題目傳送門

雖然這道題標籤有個二分圖,實際上只是用來判斷解的.此題的精髓應該是思維的過程

首先利用樣例 (題解),觀察出2*2的格子中,如果有解,那麼解一定為四個一樣或者各兩個的情況.不可能存在三個與一個的情況.也就是說,如果其中三條對角線的方向已經確定了,那麼第四條的方向也是確定的.

將上述的性質轉換為式子就是 $cells[x1][y1] \bigotimes cells[x1][y2] \bigotimes cells[x2][y1] \bigotimes cells[x2][y2]=0$

然後利用異或的性質可以推廣到任意一個矩形上.即如果有解則圖中任意一個矩形都滿足這個式子.
這樣就發現,在有解的條件,任意兩行的狀態要麼是相同的,要麼是相反的.

那麼就下來的事情都簡單了,因為上述的性質,我們可以將所有的約束條件壓到一行裡處理.掃描所有行的每一個位置,如果兩個位置的值不一樣,則連上邊.反之則用並查集維護狀態相同的.這樣處理過後,如果最後存在解,那麼這將是個二分圖,所以利用二分圖染色進行判定即可.

如果有解,那麼可以在染色的時候利用一點貪心的性質,讓0的狀態儘可能在前面.染色完畢後就得到了第一行的狀態.之後行的狀態可以利用當前行和第一行的關係,貪心地推出解.因為已經判斷出了此時是有解的,所以這樣做一定是可以找到解得.

(code by lwc)

#include <bits/stdc++.h>
using namespace std;

class ThreeColorability
{
    static const int MAXN = 50 + 5;

    class
    {
        int fa[ThreeColorability::MAXN];
    public:
        void initialize()
        {
            iota(fa, fa + ThreeColorability::MAXN, 0);
        }

        int
 
 find(int x)
        {
            if (fa[x] == x)
                return x;
            return fa[x] = find(fa[x]);
        }

        void merge(int x, int y)
        {
//			cerr << "Merge " << x << " " << y << endl ;
            fa[find(x)] = find(y);
        }

    } disjointSet;

    struct edge;
    typedef struct edge * pEdge;
    struct edge
    {
        int to;
        pEdge nxt;
    } E[MAXN * MAXN * 4];

    int eCnt;
    int N, M;
    int vis[MAXN];
    int a[MAXN][MAXN];

    bool adjMat[MAXN][MAXN];
    pEdge head[MAXN];

    void addEdge(int u, int v)
    {
//		cerr << "Edge added :" << u << " " << v << endl ;
        pEdge p;
        p = &E[eCnt++];
        p->nxt = head[u], head[u] = p;
        p->to = v;

        p = &E[eCnt++];
        p->nxt = head[v], head[v] = p;
        p->to = u;
    }

    bool isBipartite = true;
    void DFS(int x, int col)
    {
        if (vis[x] >= 0)
        {
//			cerr << "Revisited " << x << " " << col << " " << vis[x] << endl ;
            if (vis[x] != col)
                isBipartite = false;
            return;
        }
        vis[x] = col;

        for (pEdge p = head[x]; p; p = p->nxt)
            DFS(p->to, col ^ 1);
    }

public:

    ThreeColorability()
    {
        eCnt = 0;
        N = 0, M = 0;
        memset(vis, 0xFF, sizeof vis);
        memset(head, 0x00, sizeof head);
        memset(adjMat, 0x00, sizeof adjMat);
        disjointSet.initialize();
    }

    vector<string> lexSmallest(vector<string> cells)
    {
        vector<string> answer = cells;
        N = cells.size(), M = cells[0].length();

        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++)
                switch (cells[i][j])
                {
                case '?':
                    a[i][j] = -1;
                    break;
                case 'N':
                    a[i][j] = 0;
                    break;
                default:
                    a[i][j] = 1;
                }

        for (int i = 1; i < N; i++)
            for (int j = 0; j < M; j++)
                for (int k = j + 1; k < M; k++)
                    if ((~a[i][j]) && (~a[i][k]))
                    {
                        if (a[i][j] ^ a[i][k])
                            adjMat[j][k] = adjMat[k][j] = 1;
                        else
                            disjointSet.merge(j, k);
                    }

        for (int i = 0; i < M; i++)
            for (int j = i + 1; j < M; j++)
                if (adjMat[i][j])
                    addEdge(disjointSet.find(i), disjointSet.find(j));

        for (int i = 0; i < M; i++)
            if (~a[0][i])
                DFS(disjointSet.find(i), a[0][i]);
        for (int i = 0; i < M; i++)
            if (vis[disjointSet.find(i)] < 0)
                DFS(disjointSet.find(i), 0);

        if (!isBipartite)
            return vector<string>
                   { };

        for (int i = 0; i < M; i++)
            a[0][i] = vis[disjointSet.find(i)];
        for (int i = 1; i < N; i++)
        {
            bool vist[2] =
            { 0 };
            for (int j = 0; j < M; j++)
                if (~a[i][j])
                    vist[a[i][j] ^ a[0][j]] = 1;
            if (!vist[0] && !vist[1])
                vist[a[0][0]] = 1;

            if(vist[0])
                for(int j = 0; j < M; j++)
                    a[i][j] = a[0][j];
            else
                for(int j = 0; j < M; j++)
                    a[i][j] = a[0][j] ^ 1;
        }

        for(int i = 0; i < N; i++)
            for(int j = 0; j < M; j++)
                answer[i][j] = (a[i][j] ? 'Z' : 'N');

        return answer;
    }
};