TopCoder[SRM587 DIV 1]:ThreeColorability(900)

Problem Statement

There is a H times W rectangle divided into unit cells. The rows of cells are numbered 0 to H-1 from top to bottom, and the columns are numbered 0 to W-1 from left to right. The corners of cells are called lattice points. By definition, there are (H+1)*(W+1) lattice points in our rectangle.

Each of the four edges of each cell is painted white. Additionally, in some cells exactly one of the two diagonals is painted white. In the remaining cells no diagonal is painted white yet. Later, you are going to paint exactly one of the diagonals white in each of these cells.

Once you are done painting the diagonals, your next goal will be to color each of the lattice points using one of three available colors: red, green, or blue. There is only one constraint: adjacent lattice points are not allowed to share the same color.

Two lattice points are called adjacent if they are connected by a white line segment. (In other words, consecutive corners of a cell are always adjacent, opposite corners of a cell are adjacent if and only if they are connected by a painted diagonal, and no other pairs of lattice points are adjacent.)

Obviously, you need to paint the missing diagonals in such a way that there will be a valid coloring of lattice points, if possible.

You are given a vector <string> cells with H elements, each consisting of W characters. If cells[i][j] is 'N', there is a diagonal line from the top left to the bottom right corner in the cell in row i, column j. If cells[i][j] is 'Z', there is a diagonal line from the top right to the bottom left corner in the cell in row i, column j. If cells[i][j] is '?', there is no diagonal yet in the cell in row i, column j.

If it is impossible to fill in the missing diagonals in such a way that there will be a valid coloring of all lattice points, return an empty vector <string>. Otherwise, return a vector <string> that represents the rectangle with all the missing diagonals filled in. I.e., the return value must be obtained from cells by replacing each '?' by either 'N' or 'Z'. The return value must represent a rectangle for which a valid coloring of its lattice points exists. If there are multiple possibilities, return the lexicographically smallest one.

Definition

Class:	ThreeColorability
Method:	lexSmallest
Parameters:	vector <string>
Returns:	vector <string>
Method signature:	vector <string> lexSmallest(vector <string> cells)
(be sure your method is public)

Limits

Time limit (s):	2.000
Memory limit (MB):	64

Notes

-

Given two different vector <string>s A and B with the same number of elements, find the smallest index i such that A[i] and B[i] differ. If A[i] < B[i] we say that A is lexicographically smaller than B and vice versa.

Constraints

-

cells will contain between 1 and 50 elements, inclusive.

-

Each element of cells will contain between 1 and 50 characters, inclusive.

-

All elements of cells will contain the same number of characters.

-

Each character of cells will be either 'N' or 'Z' or '?'.

Examples

0)

{"Z"}

Returns: {"Z" }

The given rectangle and a possible coloring is as follows.

1)

{"??", "?N"}

Returns: {"NN", "NN" }

2)

{"ZZZ", "ZNZ"}

Returns: { }

3)

{"N?N??NN","??ZN??Z","NN???Z?","ZZZ?Z??","Z???NN?","N?????N","ZZ?N?NN"}

Returns: { }

4)

{"ZZZZ","ZZZZ","ZZZZ"}

Returns: {"ZZZZ", "ZZZZ", "ZZZZ" }

题意：给定一个网格图，为每个格子安排对角线（有些格子已经安排好），使得新图可以被用三种颜色染色（被一条边相连的两个点不能染同一种颜色）。两种对角线用'Z'与'N'表示。

题解：

画图找规律，可以发现，在相邻的四个格子中（即3*3的格点），'Z'的数量为偶数。

由此可以推得，在一个合法的图中，一行格子的对角线安排如果不与相邻的行完全相同，就与相邻的行完全相反。

即不管在哪一行，第i列与第j列格子对角线安排是否相同的关系都是一样的。

即我们可以用已知的每一行内的关系，通过并查集处理出第一行各格子的关系。

然后在满足原本安排方案的情况下，求出一种字典序最小的安排方案。

代码：

 int fa[],a[][],n,m;
 int getf(int x)
 {
     if(fa[x]!=x)fa[x]=getf(fa[x]);
     return fa[x];
 }
 int hb(int xx,int yy)
 {
     int x=getf(xx),y=getf(xx+m),z=getf(yy),w=getf(yy+m);
     if((x==w)or(y==z))return ;
     fa[x]=z; fa[y]=w; return ;
 }
 int qf(int xx,int yy)
 {
     int x=getf(xx),y=getf(xx+m),z=getf(yy),w=getf(yy+m);
     if((x==z)or(y==w))return ;
     fa[x]=w; fa[y]=z; return ;
 }
 int pd(char x)
 { if(x=='N')return ; if(x=='Z')return -; return ; }
 class ThreeColorability
 {
     public:
     vector <string> lexSmallest(vector <string> cells)
     {
         //$CARETPOSITION$
         vector<string>ans;
         n=cells.size(); m=cells[].size();
         for(int i=;i<m;i++)fa[i]=i,fa[i+m]=i+m;
         for(int i=;i<n;i++)
         for(int j=;j<m-;j++)
         if(cells[i][j]!='?')
         {
             for(int k=j+;k<m;k++)
             if(cells[i][k]!='?')
             {
                 int flag;
                 if(cells[i][j]==cells[i][k])flag=hb(j,k);else flag=qf(j,k);
                 if(flag==)return ans;
             }
         }
         for(int j=;j<m;j++)
         {
             int t=pd(cells[][j]);
             if(t!=)
             {
                 int x=getf(j),y=getf(j+m);
                 for(int k=;k<m;k++)
                 {
                     if(getf(k)==x)a[][k]=t;else
                     if(getf(k)==y)a[][k]=-t;
                 }
             }
         }
         for(int j=;j<m;j++)
         if(a[][j]==)
         {
             int x=getf(j),y=getf(j+m);
             for(int k=;k<m;k++)
             {
                 if(getf(k)==x)a[][k]=;else
                 if(getf(k)==y)a[][k]=-;
             }
         }
         for(int i=;i<n;i++)
         {
             int x=;
             for(int j=;j<m;j++)if(pd(cells[i][j])!=)
             { if(pd(cells[i][j])==a[i-][j])x=;else x=-; break; }
             if(x==){ if(a[i-][]==)x=;else x=-; }
             for(int j=;j<m;j++)a[i][j]=a[i-][j]*x;
         }
         for(int i=;i<n;i++)
         {
             string s; s.clear();
             for(int j=;j<m;j++)if(a[i][j]==)s=s+'N';else s=s+'Z';
             ans.push_back(s);
         }
         return ans;
     }
 };