hdoj 4421 Bit Magic 【2-sat 经典题目】

Bit Magic

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 2499    Accepted Submission(s): 728

Problem Description

Yesterday, my teacher taught me about bit operators: and (&), or (|), xor (^). I generated a number table a[N], and wrote a program to calculate the matrix table b[N][N] using three kinds of bit operator. I thought my achievement would get teacher's attention.
The key function is the code showed below.

There is no doubt that my teacher raised lots of interests in my work and was surprised to my talented programming skills. After deeply thinking, he came up with another problem: if we have the matrix table b[N][N] at first, can you check whether corresponding number table a[N] exists?

 

Input

There are multiple test cases.
For each test case, the first line contains an integer N, indicating the size of the matrix. (1 <= N <= 500).
The next N lines, each line contains N integers, the jth integer in ith line indicating the element b[i][j] of matrix. (0 <= b[i][j] <= 2 ³¹ - 1)

 

Output

For each test case, output "YES" if corresponding number table a[N] exists; otherwise output "NO".

 

Sample Input

  
  

   
   2
0 4
4 0
3
0 1 24
1 0 86
24 86 0
  
  

 

Sample Output

  
  

   
   YES
NO
  
  

 

无语死了，一个建边的细节导致TLE6次。。。建议先做poj3678。

题意：给你B[ ][ ]数组和它的推导过程，问你能否找到一个数组A[ ]。

思路：因为b[ ][ ]数组里面的元素不会超2的31次方-1，拆分31二进制，判断每一位二进制是否有解。若31个二进制位都能找到解，那么数组A必然存在。反之，有一个二进制无解那么就不存在数组A。

建边的实现如下：希望你已经做过poj3678.

void getMap(int pos)//根据当前二进制位建图
{
    //用i表示a[i]的二进制pos位置为1 ， i + N表示该位置为0
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            if(i == j) continue;
            else if(i % 2 == 1 && j % 2 == 1)
            {
                if(B[i][j] & (1 << pos))//B[i][j]的二进制在pos 的位置是 1
                {
                    addEdge(i + N, j);//a[i]该位置为0  则a[j]该位置为1
                    addEdge(j + N, i);//a[j]该位置为0  则a[i]该位置为1
                }
                else//B[i][j]的二进制在pos 的位置是 0
                {
                    addEdge(i, i + N);//a[i] a[j]该位置必为0
                    addEdge(j, j + N);
                }
            }
            else if(i % 2 == 0 && j % 2 == 0)
            {
                if(B[i][j] & (1 << pos))//B[i][j]的二进制在pos 的位置是 1
                {
                    addEdge(i + N, i);//a[i] 必为1
                    addEdge(j + N, j);//a[j] 必为1
                }
                else//B[i][j]的二进制在pos 的位置是0
                {
                    addEdge(i, j + N);//a[i]该位置为1 则a[j]该位置为0
                    addEdge(j, i + N);//a[j]该位置为1 则a[i]该位置为0
                }
            }
            else
            {
                if(B[i][j] & (1 << pos))//B[i][j]的二进制在pos 的位置是1
                {
                    addEdge(i + N, j);//a[i]该位置为0 则a[j]该位置为1
                    addEdge(j + N, i);//a[j]该位置为0 则a[i]该位置为1
                    addEdge(i, j + N);//a[i]该位置为1 则a[j]该位置为0
                    addEdge(j, i + N);//a[j]该位置为1 则a[i]该位置为0
                }
                else//B[i][j]的二进制在pos 的位置是0
                {
                    addEdge(i, j);//a[i] a[j]该位置全为1
                    addEdge(j, i);
                    addEdge(i + N, j + N);//a[i] a[j]该位置全为0
                    addEdge(j + N, i + N);
                }
            }
        }
    }
}

AC代码：建边时一个个赋值省时间。

#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#define MAXN 1000+10
#define MAXM 1000000+100
#define INF 100000000
using namespace std;
struct Edge
{
    int from, to, next;
};
Edge edge[MAXM];
int head[MAXN], edgenum;
int low[MAXN], dfn[MAXN];
int dfs_clock;
int sccno[MAXN], scc_cnt;
stack<int> S;
bool Instack[MAXN];
int B[MAXN][MAXN];
bool flag;
int N;//N*N矩阵
void input()
{
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++)
            scanf("%d", &B[i][j]);
}
void init()
{
    edgenum = 0;
    memset(head, -1, sizeof(head));
}
void addEdge(int u, int v)//一个个赋值省时间
{
    edge[edgenum].from = u;
    edge[edgenum].to = v;
    edge[edgenum].next = head[u];
    head[u] = edgenum++;
}
void getMap(int pos)//根据当前二进制位建图
{
    //用i表示a[i]的二进制pos位置为1 ， i + N表示该位置为0
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            if(i == j) continue;
            else if(i % 2 == 1 && j % 2 == 1)
            {
                if(B[i][j] & (1 << pos))//B[i][j]的二进制在pos 的位置是 1
                {
                    addEdge(i + N, j);//a[i]该位置为0  则a[j]该位置为1
                    addEdge(j + N, i);//a[j]该位置为0  则a[i]该位置为1
                }
                else//B[i][j]的二进制在pos 的位置是 0
                {
                    addEdge(i, i + N);//a[i] a[j]该位置必为0
                    addEdge(j, j + N);
                }
            }
            else if(i % 2 == 0 && j % 2 == 0)
            {
                if(B[i][j] & (1 << pos))//B[i][j]的二进制在pos 的位置是 1
                {
                    addEdge(i + N, i);//a[i] 必为1
                    addEdge(j + N, j);//a[j] 必为1
                }
                else//B[i][j]的二进制在pos 的位置是0
                {
                    addEdge(i, j + N);//a[i]该位置为1 则a[j]该位置为0
                    addEdge(j, i + N);//a[j]该位置为1 则a[i]该位置为0
                }
            }
            else
            {
                if(B[i][j] & (1 << pos))//B[i][j]的二进制在pos 的位置是1
                {
                    addEdge(i + N, j);//a[i]该位置为0 则a[j]该位置为1
                    addEdge(j + N, i);//a[j]该位置为0 则a[i]该位置为1
                    addEdge(i, j + N);//a[i]该位置为1 则a[j]该位置为0
                    addEdge(j, i + N);//a[j]该位置为1 则a[i]该位置为0
                }
                else//B[i][j]的二进制在pos 的位置是0
                {
                    addEdge(i, j);//a[i] a[j]该位置全为1
                    addEdge(j, i);
                    addEdge(i + N, j + N);//a[i] a[j]该位置全为0
                    addEdge(j + N, i + N);
                }
            }
        }
    }
}
void tarjan(int u, int fa)
{
    int v;
    low[u] = dfn[u] = ++dfs_clock;
    S.push(u);
    Instack[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if(!dfn[v])
        {
            tarjan(v, u);
            low[u] = min(low[u], low[v]);
        }
        else if(Instack[v])
            low[u] = min(low[u], dfn[v]);
    }
    if(low[u] == dfn[u])
    {
        scc_cnt++;
        for(;;)
        {
            v = S.top(); S.pop();
            Instack[v] = false;
            sccno[v] = scc_cnt;
            if(v == u) break;
        }
    }
}
void find_cut(int l, int r)
{
    memset(low, 0, sizeof(low));
    memset(dfn, 0, sizeof(dfn));
    memset(sccno, 0, sizeof(sccno));
    memset(Instack, false, sizeof(Instack));
    dfs_clock = scc_cnt = 0;
    for(int i = l; i <= r; i++)
        if(!dfn[i]) tarjan(i, -1);
}
bool judge()
{
    for(int i = 0; i < N; i++)
    {
        if(sccno[i] == sccno[i + N])
            return false;
    }
    return true;
}
void solve()
{
    for(int i = 0; i < 31; i++)//不会超过30个二进制位
    {
        init();
        getMap(i);
        find_cut(0, 2*N-1);
        if(!judge())//如果有一个二进制位无解 就一定无解
        {
            printf("NO\n");
            return ;
        }
    }
    printf("YES\n");
}
int main()
{
    while(scanf("%d", &N) != EOF)
    {
        input();
        solve();
    }
    return 0;
}