HDU5352 MZL's City(最小费用流)

/**
题意：一个国家有N个城市，该国家经常发生地震，地震之后可能毁坏城市，城市可能也会重建，重建之后城市不再会被毁坏，
一年之内最多重建K个城市，现在知道有M年的事件，有三种：
1. 重建与x能通过道路直接或者间接连接到的城市
2. 城市x和城市y之间连接一条道路
3. 发生地震，地震毁坏p条道路，道路连接的没有重建的城市会被毁坏
问你M年之后最多建立的多少个城市，还需要输出每个1操作在当时重建的城市数量，要求字典序最小


思路：根据题目知道每个城市重建一次就行了(也可以说是最多一次)，找出每个城市可修建的时间，又由于每年建立城市的
数量最多为K，如果只求最大数量的话就容易想到一个网络流的算法：源点和每座城市之间连边，容量为1，城市和可以修建
的年份连边，容量为1，年份和汇点连边，容量为k，这样求一遍最大流即为答案，没有要求字典序的话那么年份和汇点的边
的流量就是该年份所建造的城市的数量。但是要使1操作的字典序最小，那么就在年份和汇点的边之间加个费用，年份越大费用越
小，这样求一遍最小费用流即可。
*/

#include<bits/stdc++.h>
const int maxn = 500 + 10;
const int INF = 1e9;
using namespace std;

struct P {
    int from, to, cap, flow, cost, id;
    P() {}
    P(int f, int t, int ca, int fl, int c, int i) {
        from = f;   to = t;
        flow = fl;  cost = c;
        cap = ca; id = i;
    }
};
vector<P> edge;
vector<int> G[maxn];
int kase = 1, s, t, n, m, T, k;
int inq[maxn], d[maxn];
int p[maxn], a[maxn];
int flow, cost, vis[maxn];
vector<int> can_arrive[maxn];
set<int> to[maxn];
int ans[maxn * 2];

void add(int f, int t, int c, int co, int day) {
    edge.push_back(P(f, t, c, 0, co, day));
    edge.push_back(P(t, f, 0, 0, -co, -day));
    int sz = edge.size();
    G[f].push_back(sz - 2);
    G[t].push_back(sz - 1);
}

bool bellmanford(int s, int t, int &flow, int &cost) {
    fill(d, d + maxn, INF);
    memset(inq, 0, sizeof(inq));
    d[s] = 0; inq[s] = 1;
    p[s] = 0; a[s] = INF;
    queue<int> q; q.push(s);
    while(!q.empty()) {
        int u = q.front(); q.pop();
        inq[u] = 0;
        for(int i = 0; i < G[u].size(); i++) {
            P &e = edge[G[u][i]];
            if(e.cap <= e.flow || d[e.to] <= d[u] + e.cost) continue;
            d[e.to] = d[u] + e.cost;
            p[e.to] = G[u][i];
            a[e.to] = min(a[u], e.cap - e.flow);
            if(inq[e.to]) continue;
            q.push(e.to); inq[e.to] = 1;
        }
    }
    if(d[t] == INF) return false;
    flow += a[t]; cost += d[t] * a[t];
    for(int u = t; u != s; u = edge[p[u]].from) {
        edge[p[u]].flow += a[t];
        edge[p[u] ^ 1].flow -= a[t];
    }
    return true;
}

int mincost(int s, int t) {
    flow = 0; cost = 0;
    while(bellmanford(s, t, flow, cost));
    return flow;
}

void bfs(int day, int x) {
    memset(vis, 0, sizeof vis);
    vis[x] = 1; queue<int> que; que.push(x);
    while(!que.empty()) {
        int u = que.front(); que.pop();
        can_arrive[day - n].push_back(u);
        set<int>::iterator it = to[u].begin();
        for( ; it != to[u].end(); it++) {
            int v = *it;
            if(vis[v]) continue;
            vis[v] = 1; que.push(v);
        }
    }
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d %d", &n, &m, &k);
        edge.clear();
        for(int i = 0; i < maxn; i++) {
            to[i].clear();
            can_arrive[i].clear();
            G[i].clear();
        }
        int cnt = n + 1;
        for(int i = 1; i <= m; i++) {
            int op, x, y, p;
            scanf("%d", &op);
            if(op == 1) {
                scanf("%d", &x);
                bfs(cnt, x); cnt++;
            } else if(op == 2) {
                scanf("%d %d", &x, &y);
                to[x].insert(y);
                to[y].insert(x);
            } else {
                scanf("%d", &p);
                while(p--) {
                    scanf("%d %d", &x, &y);
                    to[x].erase(y);
                    to[y].erase(x);
                }
            }
        }
        int s = 0, t = cnt;
        for(int i = 1; i <= n; i++) add(s, i, 1, 0, -1);
        for(int i = n + 1; i < cnt; i++) {
            int id = i - n;
            for(int j = 0; j < can_arrive[id].size(); j++) {
                int x = can_arrive[id][j];
                add(x, i, 1, 700 - id, -1);
            }
            add(i, cnt, k, 700 - id, id);
        }
        int tt = mincost(s, t);
        cout << tt << endl;
        for(int i = 0; i < edge.size(); i++) {
            int from = edge[i].from;
            int to = edge[i].to;
            int id = edge[i].id;
            if(to == cnt && id > 0) ans[id] = edge[i].flow;
        }
        for(int i = 1; i < cnt - n; i++) {
            printf("%d", ans[i]);
            if(i < cnt - n - 1) printf(" ");
            else printf("\n");
        }
    }
    return 0;
}