【思维题】【二分图】TopCoder 12316 —— ThreeColorability

题目传送门

虽然这道题标签有个二分图,实际上只是用来判断解的.此题的精髓应该是思维的过程

首先利用样例 (题解),观察出2*2的格子中,如果有解,那么解一定为四个一样或者各两个的情况.不可能存在三个与一个的情况.也就是说,如果其中三条对角线的方向已经确定了,那么第四条的方向也是确定的.

将上述的性质转换为式子就是 $cells[x1][y1]⨂cells[x1][y2]⨂cells[x2][y1]⨂cells[x2][y2]=0$.其中cells表示当前格子的状态,0表示N,1表示Z

然后利用异或的性质可以推广到任意一个矩形上.即如果有解则图中任意一个矩形都满足这个式子.
这样就发现,在有解的条件,任意两行的状态要么是相同的,要么是相反的.

那么就下来的事情都简单了,因为上述的性质,我们可以将所有的约束条件压到一行里处理.扫描所有行的每一个位置,如果两个位置的值不一样,则连上边.反之则用并查集维护状态相同的.这样处理过后,如果最后存在解,那么这将是个二分图,所以利用二分图染色进行判定即可.

如果有解,那么可以在染色的时候利用一点贪心的性质,让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;
    }
};