试题库问题

嘟嘟嘟

做了几道网络流的题后，就感觉这道题还是挺简单的了……

这是一个二分图多重匹配问题，关键还是在建图：图的右侧是k个节点，代表每一个类型的试卷，然后都连一条容量为该类型题数通往汇点的边。图的左侧是每一个试题，因为每一个试题只能用一次，所以和源点连一条容量为1的边。然后如果试题 i 属于第 j 类试题，就在 (i, j + n)之间连一条边（j + n是为了防止编号重复，边全只要大于0就行，因为从源点出发，每一道题都限制了只能用一次）。

然后跑最大流就行了，只要判断最大流是否等于m就行。

输出方案就是对于 i : 1~k，遍历他的所有出边，如果指向 j  (1 <= j <= n)，且这条边流了-1，就说明 j 试题被选进了第 i 类试题中。为什么是流了-1呢？因为这条边是反向的，从(j, i)流了1，那么(i, j)就流了-1.

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a) memset(a, 0, sizeof(a))
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1025;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int k, n, t, sum = 0;

struct Edge
{
    int from, to, cap, flow;
};
vector<Edge> edges;
vector<int> G[maxn << 1];
void addEdge(int from, int to, int w)
{
    edges.push_back((Edge){from, to, w, 0});
    edges.push_back((Edge){to, from, 0, 0});
    int sz = edges.size();
    G[from].push_back(sz - 2);
    G[to].push_back(sz - 1);
}

int dis[maxn << 1];
bool bfs()
{
    Mem(dis); dis[0] = 1;
    queue<int> q; q.push(0);
    while(!q.empty())
    {
        int now = q.front(); q.pop();
        for(int i = 0; i < (int)G[now].size(); ++i)
        {
            Edge& e = edges[G[now][i]];
            if(!dis[e.to] && e.cap > e.flow)
            {
                dis[e.to] = dis[now] + 1;
                q.push(e.to);
            }
        }
    }
    return dis[t];
}
int cur[maxn << 1];
int dfs(int now, int res)
{
    if(now == t || res == 0) return res;
    int flow = 0, f;
    for(int& i = cur[now]; i < (int)G[now].size(); ++i)
    {
        Edge& e = edges[G[now][i]];
        if(dis[e.to] == dis[now] + 1 && (f = dfs(e.to, min(res, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edges[G[now][i] ^ 1].flow -= f;
            flow += f;
            res -= f;
            if(res == 0) break;
        }
    }
    return flow;
}

int maxflow()
{
    int flow = 0;
    while(bfs())
    {
        Mem(cur);
        flow += dfs(0, INF);
    }
    return flow;
}

int main()
{
    k = read(); n = read();
    t = k + n + 1;
    for(int i = 1; i <= k; ++i) {int x = read(); sum += x; addEdge(n + i, t, x);}
    for(int i = 1; i <= n; ++i)
    {
        int p = read();
        addEdge(0, i, 1);
        for(int j = 1; j <= p; ++j) addEdge(i, n + read(), 1);
    }
    if(maxflow() != sum) printf("No Solution!
");
    else
    {
        for(int i = 1; i <= k; ++i)
        {
            write(i); putchar(':'); space;
            for(int j = 0; j < (int)G[i + n].size(); ++j)
            {
                Edge e = edges[G[i + n][j]];
                if(e.to <= n && e.flow == -1) write(e.to), space;
            }
            enter;
        }
    }
    return 0;
}