LOJ #6006. 试题库 (简单最大流+输出可行路径)

题目描述

假设一个试题库中有 $n$ 道试题。每道试题都标明了所属类别。同一道题可能有多个类别属性。现要从题库中抽取 $m$ 道题组成试卷。并要求试卷包含指定类型的试题。试设计一个满足要求的组卷算法。

输入格式

第 $1$ 行有 $2$ 个正整数 $k$ 和 $n$。$k$ 表示题库中试题类型总数，$n$ 表示题库中试题总数。第 $2$ 行有 $k$ 个正整数，第 $i$ 个正整数表示要选出的类型 $i$ 的题数。这 $k$ 个数相加就是要选出的总题数 $m$。

接下来的 $n$ 行给出了题库中每个试题的类型信息。每行的第 $1$ 个正整数 $p$ 表明该题可以属于 $p$ 类，接着的 $p$ 个数是该题所属的类型号。

输出格式

第 $i$ 行输出 i: 后接类型 $i$ 的题号。如果有多个满足要求的方案，只要输出一个方案。如果问题无解，则输出 No Solution!。

样例

样例输入

3 15
3 3 4
2 1 2
1 3
1 3
1 3
1 3
3 1 2 3
2 2 3
2 1 3
1 2
1 2
2 1 2
2 1 3
2 1 2
1 1
3 1 2 3

样例输出

1: 1 6 8
2: 7 9 10
3: 2 3 4 5

数据范围与提示

$2\le k\le 20,k\le n\le 1000$

1、从S向每个Xi连接一条容量为该类别所需数量的有向边。
2、从每个Yi向T连接一条容量为1的有向边。
3、如果一个题i属于一个类别j，连接一条从Xj到Yi容量为1的有向边。

求网络最大流，如果最大流量等于所有类别所需之和，则存在解，否则无解。对于每个类别，从X集合对应点出发的所有满流边，指向的B集合中的顶点就是该类别的所选的题（一个可行解）。

先看是否满流， 满流说明可以， 然后输出当前流是0的解就好了~

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int INF = 1e9;
const int maxn = 105;
const int maxv = 2e4;
int head[maxv], cur[maxv], d[maxv], s, t, k, sum;
int n, m;
struct node
{
    int v, w, next;
}edge[maxv+6*maxn];
void addEdge(int u, int v, int w)
{
    edge[k].v = v;
    edge[k].w = w;
    edge[k].next = head[u];
    head[u] = k++;
    edge[k].v = u;
    edge[k].w = 0;
    edge[k].next = head[v];
    head[v] = k++;

}
int bfs()
{
    memset(d, 0, sizeof(d));
    d[s] = 1;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();
        if(u == t) return 1;
        q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next)
        {
            int to = edge[i].v, w = edge[i].w;
            if(w && d[to] == 0)
            {
                d[to] = d[u] + 1;
                if(to == t) return 1;
                q.push(to);
            }
        }
    }
    return 0;
}
int dfs(int u, int maxflow)
{
    if(u == t) return maxflow;
    int ret = 0;
    for(int i = cur[u]; i != -1; i = edge[i].next)
    {
        int to = edge[i].v, w = edge[i].w;
        if(w && d[to] == d[u]+1)
        {
            int f = dfs(to, min(maxflow-ret, w));
            edge[i].w -= f;
            edge[i^1].w += f;
            ret += f;
            if(ret == maxflow) return ret;
        }
    }
    return ret;
}
int Dinic()
{
    int ans = 0;
    while(bfs() == 1)
    {
        memcpy(cur, head, sizeof(head));
        ans += dfs(s, INF);
    }
    return ans;
}
int main()
{
    while(~scanf("%d%d", &m, &n))
    {
        memset(head, -1, sizeof(head));
        k = 0; s = 0; t = n+m+1; sum = 0;
        int x, y;
//        scanf("%d", &x);
        for(int i = 1; i <= m; i++)
        {
            scanf("%d", &x);
            addEdge(s, i, x);
            sum += x;
        }
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &x);
            while(x--)
            {
                scanf("%d", &y);
                addEdge(y, i+m, 1);
            }
            addEdge(i+m, t, 1);
        }
        if(sum != Dinic())
            puts("No Solution!");
        else
        {
            for(int i = 1; i <= m; i++)
            {
                printf("%d:", i);
                for(int j = head[i]; j != -1; j = edge[j].next)  
                {
                    if(!edge[j].w && !(j&1))   //输出可行解
                        printf(" %d", edge[j].v-m);
                }
                puts("");
            }
        }
    }
    return 0;
}