COCI2009 着色

Description

　　Alice是一个奇怪的画家。她想对一副有N×N个像素点组成的画进行着色，N是2的幂（1，2，4，8，16等等）。每个像素点可以着成黑色或白色。
　　Alice着色方案不是唯一的，她采用以下不确定的规则：
　　•如果画作只有一个像素点，那可以直接着白色或黑色；
　　•否则，把画平均分成四块，然后进行以下操作：
　　(1) 选择一块全部着白色；
　　(2) 选择一块全部着黑色；
　　(3) 把剩下的两块当作是独立的画作并采用同样的方法进行着色。
　　对于每一幅画作，Alice心目中已经有一个蓝图，接下来请你帮她采用上述方法着色，要求选择跟心目中的蓝图差异最小的着色方案，当然要遵循上述的着色规则，两幅图的差异是指对应位置颜色不相同的像素点的个数。

Input

　　输入第一行包含整数N(1<=N<=512)，表示画作的尺寸为N×N，N保证是2的幂。
　　接下来N行每行包含N个0或1，描述Alice心目中的蓝图，0表示白色，1表示黑色。

Output

　　第一行输出最小的差异是多少。
　　

Sample Input

输入1：

4
0001
0001
0011
1110

输入2：

4
1111
1111
1111
1111

输入3：

8
01010001
10100011
01010111
10101111
01010111
10100011
01010001
10100000

Sample Output

输出1：

1

输出2：

6

输出3：

16

Hint

　　50%的数据N<=8

50%：

状态压缩搜索，即把n=4的情况记忆下来。大概可以通过n<=16。

100%：

动态规划。

设f[i][j][k]表示以第i行，第j列这个点作为正方形的左上角，边长是 2k 的最小差异。

很明显我们把它分成四个部分，枚举两个部分是全部染成1，0，剩下两个转移就行了。

如果不满意空间可以把k这一维滚动。

时间复杂度：O( (24)n2logn )

Code:

#include
#define fo(i,x,y) for(int i=x;i<=y;i++)
#define maxlongint 2147483647
using namespace std;

int mi,n,x5,y5,x6,y6,x1,y1,x2,y2,x3,y3,x4,y4,s1,s2,ab,p[3],a[513][513],f[513][513][10],s[513][513],a2[10],m[4][2]={{0,0},{0,1},{1,0},{1,1}};
char c;

int min(int x,int y){
    return xx:y;
}

int main(){
    freopen("b4.in","r",stdin);
    a2[0]=1;
    fo(i,1,9)
        a2[i]=a2[i-1]*2;
    scanf("%d\n",&n);
    fo(i,1,n){
        fo(j,1,n){
            scanf("%c",&c);
            a[i][j]=c-'0';
            s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];
        }
        scanf("\n");
    }
    fo(i,0,9)
        if(a2[i]==n)
            mi=i;
    fo(k,1,mi){
        fo(i,1,n-a2[k]+1){
            fo(j,1,n-a2[k]+1){
                f[i][j][k]=maxlongint;
                fo(k1,0,2){
                    x1=i+m[k1][0]*a2[k-1]-1;
                    y1=j+m[k1][1]*a2[k-1]-1;
                    x3=x1+a2[k-1];
                    y3=y1+a2[k-1];
                    fo(k2,k1+1,3){
                        x2=i+m[k2][0]*a2[k-1]-1;
                        y2=j+m[k2][1]*a2[k-1]-1;
                        x4=x2+a2[k-1];
                        y4=y2+a2[k-1];
                        s1=s[x1][y1]-s[x1][y3]-s[x3][y1]+s[x3][y3];
                        s2=s[x2][y2]-s[x2][y4]-s[x4][y2]+s[x4][y4];
                        ab=min(a2[k-1]*a2[k-1]-s1+s2,s1+a2[k-1]*a2[k-1]-s2);
                        p[0]=0;
                        fo(k3,0,3)
                            if(k3!=k1&&k3!=k2)
                                p[++p[0]]=k3;
                        x5=i+m[p[1]][0]*a2[k-1]; y5=j+m[p[1]][1]*a2[k-1];
                        x6=i+m[p[2]][0]*a2[k-1]; y6=j+m[p[2]][1]*a2[k-1];
                        if(f[x5][y5][k-1]+f[x6][y6][k-1]+ab1]+f[x6][y6][k-1]+ab;
                    }
                }
            }
        }
    }
    printf("%d",f[1][1][mi]);
}