Optimal Marks SPOJ - OPTM(最小割)

传送门

论文《最小割模型在信息学竞赛中的应用》原题

二进制不同位上互不影响，那么就按位跑网络流

每一位上，确定的点值为1的与S连一条容量为INF的有向边。为0的与T连一条容量为INF的有向边。

其他的按给定的无向图建边，容量为1。

统计答案是从源点能到达的点(流量未达到容量)即为该位上为1的点。

需要跑多少遍根据所有权值的最高位来确定。直接跑30次TLE了。

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

inline int read() {
    int x = , f = ; char ch = getchar();
    while (ch < '' || ch > '') { if (ch == '-') f = -; ch = getchar(); }
    while (ch >= '' && ch <= '') { x = x *  + ch - ; ch = getchar(); }
    return x * f;
}

const int INF = 0x3f3f3f3f;
const int N = 2e5 + ;
struct Edge { int v, next, f; } edge[N];
struct IN { int u, v; } in[N];
int head[N], cnt, level[N], iter[N], n, m;
int a[N], res[N];
bool vis[N];
vector<int> appear;

inline void add(int u, int v, int f) {
    edge[cnt].v = v; edge[cnt].f = f; edge[cnt].next = head[u]; head[u] = cnt++;
}

bool bfs(int s, int t) {
    for (int i = ; i <= t; i++) level[i] = -, iter[i] = head[i];
    queue<int> que;
    que.push(s);
    level[s] = ;
    while (!que.empty()) {
        int u = que.front(); que.pop();
        for (int i = head[u]; ~i; i = edge[i].next) {
            int v = edge[i].v, f = edge[i].f;
            if (level[v] <  && f) {
                que.push(v);
                level[v] = level[u] + ;
            }
        }
    }
    return level[t] != -;
}

int dfs(int u, int t, int f) {
    if (u == t || !f) return f;
    int flow = ;
    for (int i = iter[u]; ~i; i = edge[i].next) {
        iter[u] = i;
        int v = edge[i].v;
        if (level[v] == level[u] +  && edge[i].f) {
            int w = dfs(v, t, min(f, edge[i].f));
            if (!w) continue;
            flow += w; f -= w;
            edge[i].f -= w; edge[i^].f += w;
            if (f <= ) break;
        }
    }
    return flow;
}

int dinic(int s, int t) {
    int ans = ;
    while (bfs(s, t)) ans += dfs(s, t, INF);
    return ans;
}

void get_ans(int u, int bit) {
    vis[u] = ;
    res[u] +=  << bit;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].v;
        if (!vis[v] && edge[i].f) {
            get_ans(v, bit);
        }
    }
}

void solve(int bit, int s, int t) {
    for (int i = ; i <= t; i++) head[i] = -, vis[i] = false;
    cnt = ;
    for (int i = , sz = appear.size(); i < sz; i++) {
        int x = appear[i];
        if (( << bit) & a[x]) {
            add(s, x, INF);
            add(x, s, );
        } else {
            add(x, t, INF);
            add(t, x, );
        }
    }
    for (int i = ; i <= m; i++) { add(in[i].u, in[i].v, ); add(in[i].v, in[i].u, ); }
    dinic(s, t);
    get_ans(s, bit);
}

inline void init() {
    for (int i = ; i <= n; i++) {
        res[i] = a[i] = ;
    }
    appear.clear();
}

int main() {
    int T = read();
    while (T--) {
        n = read(), m = read();
        init();
        int s = , t = n + ;
        int mak = ;
        for (int i = ; i <= m; i++) {
            in[i].u = read(), in[i].v = read();
        }
        int k = read();
        while (k--) {
            int u = read();
            a[u] = read();
            appear.emplace_back(u);
        }
        for (int i = , sz = appear.size(); i < sz; i++) {
            int u = appear[i];
            int temp = a[u];
            int bit = ;
            while (temp) {
                bit++;
                temp >>= ;
            }
            mak = max(bit, mak);
        }
        for (int i = ; i <= mak; i++) {
            solve(i, s, t);
        }
        for (int i = ; i <= n; i++) printf("%d\n", res[i]);
    }
}