HDU 5076 Memory

Memory

Time Limit: 4000ms

Memory Limit: 262144KB

This problem will be judged on HDU. Original ID: 5076
64-bit integer IO format: %I64d      Java class name: Main

Special Judge

 

Little Bob’s computer has 2n bytes of memory. For convenience, n-bit integers 0 to 2n - 1 are used to index these bytes.



Now he wants to assign a value to each byte of the memory. In this problem, a byte is composed of m bits. Therefore he can only assign 0 to 2^m - 1 (inclusive) to a single byte.

Bob has some preferences on which value to be assigned to each byte. For the byte indexed by i, if it is assigned with value j (0 ≤ j < 2^m), the preference score for it is w_i,j.

In addition, each byte has a threshold value. For two different bytes indexed by a and b, if the following two conditions are satisfied, there will be an additional score (u_a xor u_b):

1.a and b only have one bit of difference in their binary forms;

2.The assigned value of byte a is not less than its threshold value, or the assigned value of byte b is not less than its threshold value.

The total score of an assignment solution is the sum of the preference scores of all bytes plus the sum of all additional scores.

Bob wants to find an assignment solution with the maximum total score. If there are multiple solutions, you can output any of them.

 

Input

The first line contains an integer T (T ≤ 3), denoting the number of the test cases.

For each test case, the first line contains two integers, n and m(1 ≤ n, m ≤ 8), as mentioned above. The second line contains 2ⁿ integers, and the i-th integer is the threshold value for byte i. The threshold values are between 0 and 2^m - 1, inclusively. The third line contains 2ⁿ integers, and the i-th integer is u_i(0 ≤ u_i < 1024). The next 2ⁿ lines give all preference scores. Each line contains 2^m integers, and the j-th integer of the i-th line is w_i,j (-1024 ≤ w_i,j < 1024).

 

Output

For each test case, output one line consisting of 2n integers between 0 and 2m - 1, and the i-th integer is the value assigned to byte i in the assignment solution with the maximum total score.

 

Sample Input

1
3 2
0 1 1 3 3 0 3 3
4 8 8 7 0 9 2 9
-9 -8 3 2
-9 -6 4 1
-6 -8 -5 3
3 -1 -4 -1
-6 -5 1 10
-10 7 3 -10
-3 -10 -4 -5 
-2 -1 -9 1

Sample Output

2 2 3 0 3 1 0 3

Source

2014 Asia AnShan Regional Contest

 

解题：网络流

1. 对于每个位置拆成两个点，左边源右边汇。
2. 如果这个位置的index有奇数个1，左边连小于的w，右边连大于等于的w。
3. 如果这个位置的index有偶数个1，左边连大于等于的w，右边连小于的w。
4. 每个位置左边往右边连一条inf的弧，代表这两个点不能都不割。
5. 对于每组a,b，从奇数的小于连向偶数的小于，ua xor ub。
6. 为了避免负流量可以把所有w加一个1024，不影响最后结果。
7. 总之建出来是个二分图。
8. 最后建完就可以发现其实可以不用拆点，但拆了还是更好理解一些。

最后所有的收益加起来减掉最小割就是最大收益。

据说上面是昂神分析的

#include <bits/stdc++.h>
using namespace std;
const int INF = ~0U>>2;
const int maxn = 1024;
struct arc {
    int to,flow,next;
    arc(int x = 0,int y = 0,int z = -1) {
        to = x;
        flow = y;
        next = z;
    }
} e[maxn*maxn];
int head[maxn],d[maxn],cur[maxn],tot,S,T;
void add(int u,int v,int flow) {
    e[tot] = arc(v,flow,head[u]);
    head[u] = tot++;
    e[tot] = arc(u,0,head[v]);
    head[v] = tot++;
}
bool bfs() {
    queue<int>q;
    memset(d,-1,sizeof d);
    d[S] = 1;
    q.push(S);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = e[i].next) {
            if(e[i].flow && d[e[i].to] == -1) {
                d[e[i].to] = d[u] + 1;
                q.push(e[i].to);
            }
        }
    }
    return d[T] > -1;
}
int dfs(int u,int low) {
    if(u == T) return low;
    int a,tmp = 0;
    for(int &i = cur[u]; ~i; i = e[i].next) {
        if(e[i].flow &&d[e[i].to] == d[u]+1&&(a=dfs(e[i].to,min(low,e[i].flow)))) {
            e[i].flow -= a;
            e[i^1].flow += a;
            low -= a;
            tmp += a;
            if(!low) break;
        }
    }
    if(!tmp) d[u] = -1;
    return tmp;
}
int dinic(int ret = 0) {
    while(bfs()) {
        memcpy(cur,head,sizeof cur);
        ret += dfs(S,INF);
    }
    return ret;
}
int U[maxn],Th[maxn],B[maxn],L[maxn],ans[maxn],Bid[maxn],Lid[maxn];
int main() {
    int kase,n,m;
    scanf("%d",&kase);
    while(kase--) {
        scanf("%d%d",&n,&m);
        n = (1<<n);
        m = (1<<m);
        for(int i = tot = 0; i < n; ++i)
            scanf("%d",Th + i);
        for(int i = 0; i < n; ++i)
            scanf("%d",U + i);
        for(int i = 0; i < n; ++i) {
            B[i] = L[i] = -1;
            for(int j = 0,w; j < m; ++j) {
                scanf("%d",&w);
                w += 1024;
                if(j >= Th[i] && B[i] < w) {
                    B[i] = w;
                    Bid[i] = j;
                } else if(L[i] < w) {
                    L[i] = w;
                    Lid[i] = j;
                }
            }
        }
        S = n<<1;
        T = S + 1;
        memset(head,-1,sizeof head);
        for(int i = 0; i < n; ++i) {
            int k = __builtin_popcount(i);
            add(i,i + n,INF);
            if(k&1) {
                add(S,i,L[i]);
                add(i + n,T,B[i]);
            } else {
                add(S,i,B[i]);
                add(i + n,T,L[i]);
            }
            for(int j = i + 1; j < n; ++j) {
                if(__builtin_popcount(i^j) == 1) {
                    if(k&1) add(i,j + n,U[i]^U[j]);
                    else add(j,i + n,U[i]^U[j]);
                }
            }
        }
        dinic();
        for(int i = 0; i < n; ++i) {
            if(i) putchar(' ');
            if(__builtin_popcount(i)&1)
                printf("%d",(~d[i])?Lid[i]:Bid[i]);
            else printf("%d",(~d[i])?Bid[i]:Lid[i]);
        }
        putchar('
');
    }
    return 0;
}