Submission #201007

#	Time	Username	Problem	Language	Result	Execution time	Memory
201007		gratus907	Art Class (IOI13_artclass)	C++17	73 / 100	114 ms	4644 KiB

artclass

#include "artclass.h"
#include <bits/stdc++.h>
#define colordist(x1,y1,x2,y2) (abs(R[x1][y1]-R[x2][y2])+abs(G[x1][y1]-G[x1][y1])+abs(B[x1][y1]-B[x1][y1]))
using namespace std;
double horizontal_variation[550];
double vertical_variation[550];
double average_green;
double avg_hor[550][3], avg_ver[550][3];
const double cut = 0.05;
const int black_crit = 30;
const int bc_crit = 100;
const int white_crit = 225;
const int samecolor = 64;
int guess[5];
int choose_color()
{
    int u = (max_element(guess,guess+5)-guess);
    return u?u:2;
}
bool debug = false;


int style(int H, int W, int R[500][500], int G[500][500], int B[500][500]) 
{
    memset(guess,0,sizeof(guess));
    guess[2] = 1;
    int cellcolor[550][550];
    int color_used = 0;
    int mostly_green = 0;
    int mostly_red = 0;
    bool used_color[32][32][32];
    memset(used_color,0,sizeof(used_color));
    memset(cellcolor,-1,sizeof(cellcolor));
    for (int i = 0; i<H; i++)
    {
        for (int j = 0; j<W; j++)
        {
            int mm = max(R[i][j],max(G[i][j],B[i][j]));
            if (mm == R[i][j]) cellcolor[i][j] = 2;
            else if (mm==G[i][j]) cellcolor[i][j] =1;
            else cellcolor[i][j] = 0;
            used_color[R[i][j]/samecolor][G[i][j]/samecolor][B[i][j]/samecolor] = true;
            if (cellcolor[i][j]==1)
                mostly_green++;
            if (cellcolor[i][j]==2)
                mostly_red++;
        }
    }
    for (int i = 0; i<32; i++)
    {
        for (int j = 0; j<32; j++)
        {
            for (int k = 0; k<32; k++)
            {
                color_used += used_color[i][j][k]?1:0;
            }
        }
    }
    if (color_used<10) guess[4]++;
    int trans = 0;
    for (int i = 1; i<H; i++)
    {
        for (int j = 1; j<W; j++)
        {
            if (min(colordist(i,j,i-1,j),colordist(i,j,i,j-1))>40)
            {
                trans++;
            }
        }
    }
    memset(horizontal_variation,0,sizeof(horizontal_variation));
    memset(vertical_variation,0,sizeof(vertical_variation));
    memset(avg_hor,0,sizeof(avg_hor));
    memset(avg_ver,0,sizeof(avg_ver));
    for (int i = 0; i<H; i++)
    {
        for (int j = 0; j<W; j++)
        {
            avg_hor[i][0] += R[i][j];
            avg_hor[i][1] += G[i][j];
            avg_hor[i][2] += B[i][j];
            avg_ver[j][0] += R[i][j];
            avg_ver[j][1] += G[i][j];
            avg_ver[j][2] += B[i][j];
            if (i==H-1)
            {
                avg_ver[j][0] /= H;
                avg_ver[j][1] /= H;
                avg_ver[j][2] /= H;
            }
        }
        avg_hor[i][0] /= W;
        avg_hor[i][1] /= W;
        avg_hor[i][2] /= W;
    }
    
    int bigchange = 0;
    for (int i = 1; i<H; i++)
    {
        double u = 0;
        for (int j = 0; j<3; j++)
        {
            u = max(u, abs(avg_hor[i][j]-avg_hor[i-1][j]));
        }
        if (u > bc_crit)
            bigchange++;
    }
    for (int i = 1; i<W; i++)
    {
        double u = 0;
        for (int j = 0; j<3; j++)
        {
            u = max(u, abs(avg_ver[i][j]-avg_ver[i-1][j]));
        }
        if (u > bc_crit)
            bigchange++;
    }
    if (bigchange>2) 
        guess[1]+=5;
    int white_pixel = 0;
    for (int i = 0; i<H; i++)
    {
        for (int j = 0; j<W; j++)
        {
            if (R[i][j]>white_crit and B[i][j]>white_crit and R[i][j]>white_crit)
                white_pixel++;
        }
    }

    if (white_pixel > H*W/5)
    {
        guess[1]+=3;
    }
    double avg_hor_var = 0, avg_ver_var = 0;
    for (int i = 0; i<H; i++)
    {
        vector <double> tmpval;
        for (int j = 1; j<W; j++)
        {
            double tmp = 0;
            tmp += abs(R[i][j]-R[i][j-1]);
            tmp += abs(G[i][j]-G[i][j-1]);
            tmp += abs(B[i][j]-B[i][j-1]);
            tmpval.push_back(tmp);
        }
        sort(tmpval.begin(), tmpval.end());
        for (int j = (int)(tmpval.size()*cut); j<(int)(tmpval.size()*(1-cut)); j++)
            horizontal_variation[i] += tmpval[j];
        horizontal_variation[i] *= 1/((1-2*cut)*tmpval.size());
        avg_hor_var += pow(horizontal_variation[i],2);
    }
    for (int i = 0; i<W; i++)
    {
        vector <double> tmpval;
        for (int j = 1; j<H; j++)
        {
            double tmp = 0;
            tmp += abs(R[j][i]-R[j-1][i]);
            tmp += abs(G[j][i]-G[j-1][i]);
            tmp += abs(B[j][i]-B[j-1][i]);
            tmpval.push_back(tmp);
        }
        sort(tmpval.begin(), tmpval.end());
        for (int j = (int)(tmpval.size()*cut); j<(int)(tmpval.size()*(1-cut)); j++)
            vertical_variation[i] += tmpval[j];
        vertical_variation[i] *= 1/((1-2*cut)*tmpval.size());
        avg_ver_var += pow(vertical_variation[i],2);
    }

    if (mostly_green > H*W/5)
    {
        guess[2]++;
    }
    if (mostly_red > H*W/5)
    {
        guess[2]--;
    }
    if (trans>H*W/40) 
    {
        guess[3]++;
    }
    if (trans<H*W/1000)
    {
        guess[1]++; guess[4]++;
    }
    int tmp = 0;
    for (int i = 0; i<H; i++)
    {
        if (horizontal_variation[i]<5) 
            tmp++;
    }
    for (int i = 0; i<W; i++)
    {
        if (vertical_variation[i]<5) 
            tmp++;
    }
    guess[4]+=tmp/((H+W)/10);
    if (avg_ver_var > 500000 or avg_ver_var > 500000) 
        guess[3]++;
    if (avg_hor_var < 10000 or avg_ver_var < 10000)
        guess[4]++;

    return choose_color();

}

• Subtask 1: 73 / 100