洛谷P4382 劈配

不知道这个Zayid是谁...

题意：

有n个人，m个导师。每个导师能接纳bi个人，每个人对于这m个导师都有一个志愿档次。

优先满足靠前的人，问到最后每个人匹配的导师是他的第几志愿。

每个人又有一个限制si，问至少前进多少名才能被志愿档次不大于si的导师录取。

解：

首先发现，每个志愿档次只能填一个人的时候，可以直接贪心。否则在同一志愿档次内选择不同的导师会对后面有影响。

这时我们就可以利用网络流。

一个流量代表一个的归属，动态加边。

对于每个人枚举志愿档次，添加流向导师的边。然后看是否有流量。

如果有流量那么他就归于该志愿档次。

第二问，答案可以二分。

很简朴的想法是对于每个二分出来的值，重新建图来一遍。这样复杂度就是Tnlogn * nm，显然不行。

发现每次重新建图的时候我们进行了很多一模一样的操作。于是考虑把前k个人的网络流状态保存下来，之后直接调用。

但是太麻烦了...我们又发现一种很巧妙的方法：判断在前k个人加完之后是否可行，其实是看哪些导师还可以接纳人。于是我们从汇点出发，反向DFS，能够得到每次从哪些导师出发有增广路，就是哪些导师还能接纳。

然后二分的时候直接O(m)判定。

这样我们发现有90分，超时一个点。

回想第一问网络流的时候，如果一个志愿档次没有流量，那么这些加的边就没有用，不妨删了。

然后就A了...

#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

const int N = 210, INF = 0x3f3f3f3f;

int b[N], C, n, m, a[N][N], s[N], mat[N];
std::vector<int> topo[N][N];

namespace fl {

    struct Edge {
        int nex, v, c;
    }edge[2000010]; int top = 1;

    int d[N << 1], e[N << 1], E[N << 1], TOP;
    bool vis[N][N << 1];
    std::queue<int> Q;

    inline void add(int x, int y, int z) {
        top++;
        edge[top].v = y;
        edge[top].c = z;
        edge[top].nex = e[x];
        e[x] = top;

        top++;
        edge[top].v = x;
        edge[top].c = 0;
        edge[top].nex = e[y];
        e[y] = top;
        return;
    }

    inline bool BFS(int s, int t) {
        memset(d, 0, sizeof(d));
        d[s] = 1;
        Q.push(s);
        while(!Q.empty()) {
            int x = Q.front();
            Q.pop();
            for(int i = e[x]; i; i = edge[i].nex) {
                int y = edge[i].v;
                if(!edge[i].c || d[y]) {
                    continue;
                }
                d[y] = d[x] + 1;
                Q.push(y);
            }
        }
        return d[t];
    }

    int DFS(int x, int t, int maxF) {
        if(x == t) {
            return maxF;
        }
        int Ans = 0;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(!edge[i].c || d[x] + 1 != d[y]) {
                continue;
            }
            int temp = DFS(y, t, std::min(edge[i].c, maxF - Ans));
            if(!temp) {
                d[y] = INF;
            }
            Ans += temp;
            edge[i].c -= temp;
            edge[i ^ 1].c += temp;
            if(Ans == maxF) {
                break;
            }
        }
        return Ans;
    }

    inline int dinic(int s, int t) {
        int Ans = 0;
        while(BFS(s, t)) {
            Ans += DFS(s, t, INF);
        }
        return Ans;
    }

    void DFS(int x, int k) {
        vis[k][x] = 1;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(!edge[i ^ 1].c || vis[k][y]) {
                continue;
            }
            DFS(y, k);
        }
        return;
    }

    inline bool check(int x, int mid) {
        for(int k = 1; k <= s[x]; k++) {
            for(int jj = topo[x][k].size() - 1; jj >= 0; jj--) {
                int j = topo[x][k][jj];
                if(vis[x - mid - 1][j + n]) {
                    return 1;
                }
            }
        }
        return 0;
    }

    inline void solve() {
        memset(vis[0], -1, sizeof(vis[0]));
        int S = n + m + 1, T = n + m + 2;
        for(int i = 1; i <= m; i++) {
            add(n + i, T, b[i]);
        }
        for(int i = 1; i <= n; i++) {
            add(S, i, 1);
            mat[i] = 0;
            for(int k = 1; k <= m; k++) {
                TOP = top;
                E[i] = e[i];
                for(int jj = topo[i][k].size() - 1; jj >= 0; jj--) {
                    int j = topo[i][k][jj];
                    E[n + j] = e[n + j];
                    add(i, n + j, 1);
                }
                int temp = dinic(S, T);
                if(temp) {
                    mat[i] = k;
                    break;
                }
                else {
                    e[i] = E[i];
                    for(int jj = topo[i][k].size() - 1; jj >= 0; jj--) {
                        int j = topo[i][k][jj];
                        e[n + j] = E[n + j];
                    }
                    top = TOP;
                }
            }
            if(!mat[i]) {
                mat[i] = m + 1;
            }
            DFS(T, i);
        }
        for(int i = 1; i <= n; i++) {
            printf("%d ", mat[i]);
        }
        puts("");
        // first OVER

        for(int i = 1; i <= n; i++) {
            if(mat[i] <= s[i]) {
                printf("0 ");
                continue;
            }
            int l = 1, r = i;
            while(l < r) {
                int mid = (l + r) >> 1;
                if(check(i, mid)) {
                    r = mid;
                }
                else {
                    l = mid + 1;
                }
            }
            printf("%d ", r);
        }
        puts("");
        return;
    }

    inline void clear() {
        memset(e, 0, sizeof(e));
        top = 1;
        memset(vis, 0, sizeof(vis));
        return;
    }
}

inline void solve() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++) {
        scanf("%d", &b[i]);
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            scanf("%d", &a[i][j]);
            if(a[i][j]) {
                topo[i][a[i][j]].push_back(j);
            }
        }
    }
    for(int i = 1; i <= n; i++) {
        scanf("%d", &s[i]);
    }
    // read over

    fl::solve();
    return;
}

inline void clear() {
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            topo[i][j].clear();
        }
    }
    fl::clear();
    return;
}

int main() {

    int T;
    scanf("%d%d", &T, &C);
    while(T--) {
        solve();
        if(T) {
            clear();
        }
    }
    return 0;
}

我发现D2T1都好毒瘤...屠龙勇士也是的。