Hdu4421 Bit Magic 【2-SAT、位运算】

Bit Magic

题意

一个二维数组 $b$ 按照上述方式形成，现在给定结果数组 $b$，问是否存在一种原始一维数组 $a$，可以按照上述规则形成结果数组 $b$？

思路

位运算是在二进制上计算的，二进制每一位不是 $0$ 就是 $1$，我们不妨按位考虑，如果所有位都没有冲突，那么就存在可行解

那么对于当前位 $p$，我们按照上述规则：

• 如果 $i,j$ 都是奇数，如果 $b[i][j{]}_p$ 是 $1$，那么 $a[i{]}_p$ 和 $a[j{]}_p$ 至少有一个为 $1$；如果 $b[i][j{]}_p$ 是 $0$，那么 $a[i{]}_p$ 和 $a[j{]}_p$ 都是 $0$

其他情况也是类似讨论，注意跳过 $i=j$ 的情况

// Problem: Bit Magic
// Contest: HDOJ
// URL: https://acm.hdu.edu.cn/showproblem.php?pid=4421
// Memory Limit: 32 MB
// Time Limit: 4000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
#define fore(i,l,r)	for(int i=(int)(l);i<(int)(r);++i)
#define fi first
#define se second
#define endl '\n' 
#define ull unsigned long long

const int INF=0x3f3f3f3f;
const long long INFLL=0x3f3f3f3f3f3f3f3fLL;

typedef long long ll;

struct TwoSat {
    int n; //属性数量
    std::vector<std::vector<int>> e;
    std::vector<bool> ans;
    TwoSat(int n) : n(n), e(2 * n), ans(n) {} //下标从0开始
 
    /* 建边表示 u为f 且 v为g */
    void addedge(int u, bool f, int v, bool g) { //原变量和反变量相邻放
        e[2 * u + !f].push_back(2 * v + g); //反变量在偶数位置，原变量在奇数位置
        e[2 * v + !g].push_back(2 * u + f);
    }
    
    void adde(int u, int f, int v, int g){
    	e[2 * u + f].push_back(2 * v + g);
    }
 
    bool satisfiable() {
        std::vector<int> id(2 * n, -1), dfn(2 * n, -1), low(2 * n, -1);
        std::vector<int> stk;
        int now = 0, cnt = 0;
        std::function<void(int)> tarjan = [&](int u) {
            stk.push_back(u);
            dfn[u] = low[u] = now++;
            for (auto v : e[u]) {
                if (dfn[v] == -1) {
                    tarjan(v);
                    low[u] = std::min(low[u], low[v]);
                } else if (id[v] == -1) {
                    low[u] = std::min(low[u], dfn[v]);
                }
            }
            if (dfn[u] == low[u]) {
                int v;
                do {
                    v = stk.back();
                    stk.pop_back();
                    id[v] = cnt;
                } while (v != u);
                ++cnt;
            }
        };
        for (int i = 0; i < 2 * n; ++i) if (dfn[i] == -1) tarjan(i);
        for (int i = 0; i < n; ++i) {
            if (id[2 * i] == id[2 * i + 1]) return false;
            ans[i] = id[2 * i] > id[2 * i + 1]; //取依赖性更高的那个
        }
        return true;
    }
 
    std::vector<bool> get_ans() { return ans; }
};

bool solve(int n, std::vector<std::vector<int>>& b){
	fore(k, 0, 31){
		TwoSat ts(n);
		fore(i, 0, n)
			fore(j, 0, n){
				if(i == j)	continue;
				int bit = b[i][j] >> k & 1;
				if((i & 1) && (j & 1)){
					if(!bit){
						ts.adde(i, 1, i, 0);
						ts.adde(j, 1, j, 0);
						ts.adde(i, 0, j, 0);
						ts.adde(j, 0, i, 0);
					}
					else{
						ts.addedge(i, 1, j, 1);
					}
				}
				else if(!(i & 1) && !(j & 1)){
					if(!bit){
						ts.addedge(i, 0, j, 0);
					}
					else{
						ts.adde(i, 0, i, 1);
						ts.adde(j, 0, j, 1);
						ts.adde(i, 1, j, 1);
						ts.adde(j, 1, i, 1);
					}
				}
				else{
					if(!bit){
						ts.addedge(i, 0, j, 1);
						ts.addedge(i, 1, j, 0);
					}
					else{
						ts.addedge(i, 1, j, 1);
						ts.addedge(i, 0, j, 0);
					}
				}
			}
		if(!ts.satisfiable())	return false;
	}
	
	return true;
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n;
    while(std::cin >> n){
    	std::vector<std::vector<int>> b(n, std::vector<int>(n));
    	fore(i, 0, n)
    		fore(j, 0, n)
    			std::cin >> b[i][j];
    	std::cout << (solve(n, b) ? "YES" : "NO") << endl;
    }
	return 0; 
}