BZOJ2893:征服王(费用流)

Description

虽然春希将信息传递给了雪菜，但是雪菜却好像完全不认得春希了。心急如焚的春希打开了第二世代机能，对雪菜的脑内芯片进行了直连-hack。

进入到雪菜内部的春希发现（这什么玩意。。），雪菜的脑部结构被分成了n个块落，并且一些块落之间被有向边连接着。由于四分五裂的脑部，雪菜关于春希的记忆也完全消失，春希为了恋人，启动了inversionprocess.

在inversion process中，要想使雪菜回到正常状态，需要纳米机器人的帮助。纳米机器人可以从任意一个可以作为起点的块落出发进行修复，也可以在任意一个可以作为终点的块落结束修复（并不是到了某个终点就一定要停止）。春希希望所有的节点都能被修复(只要纳米机器人到过该点就算修复过)，这样才能让雪菜重获新生。

作为纳米机器人1号的你能帮助春希算算至少需要多少个机器人才能拯救雪菜吗？

当然，如果无论如何都无法使得春希的愿望被满足的话，请输出”no solution”（不包括引号）

Input

题目包含多组数据

第1行有一个正整数t，表示数据的组数。

第2行有两个正整数n、m，a，b，分别表示块落的数量、有向边的数量、起点的数量、终点的数量。

第3行有a个正整数，表示可以作为起点的块落。

第4行有b个正整数，表示可以作为终点的块落。

第5行至第m+4行，每行有两个正整数u、v，表示能从编号为u的块落到编号为v的块落。

之后以此类推。

Output

输出共有t行，每行输出对应数据的答案。

Sample Input

2
2 1 1 1
1
2
2 1
3 2 3 3
1 2 3
1 2 3
1 2
1 3

Sample Output

no solution
2
【数据规模和约定】
对于30%的数据，满足n <= 10, m <= 100。
对于60%的数据，满足n <= 200, m <= 5000。
对于100%的数据，满足t<=10,n <= 1000, m <= 10000。

Solution

打死白学家

首先第一感觉这个题很像最小路径覆盖……但他并不是一个$DAG$。所以我们自己动手丰衣足食把它缩成一个$DAG$。

现在变成了一个多起点多终点的最小路径覆盖问题。我们首先把一个点拆成$u$和$u'$，并且$u$连向$u'$一条流量为$1$，费用为1的边。

然后原图的边就$u'$连向$v$一条流量为$INF$，费用为$0$的边。

源点$S$向图中的起点$s$连流量为$INF$，费用为$0$的边，终点$t'$向图中的汇点$E$连流量为$INF$，费用为$0$的边。

跑一边最大费用最大流。如果费用为点数那么说明每个点都经过了，答案为增广次数。

否则无解。

Code

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#define N (10009)
using namespace std;

struct Edge{int to,next,flow,cost;}edge[N*100];
int DFN[N],Low[N],Stack[N],ID[N],Vis[N],top,dfs_num,id_num;
int T,n,m,A,B,a[N],b[N],u[N*10],v[N*10],x,INF,s,e=10000;
int dis[N],pre[N],vis[N];
int head[N],num_edge;
queue<int>q;

void Clear()
{
    memset(head,0,sizeof(head));
    memset(DFN,0,sizeof(DFN));
    memset(Low,0,sizeof(Low));
    memset(ID,0,sizeof(ID));
    memset(Vis,0,sizeof(Vis));
    num_edge=top=dfs_num=id_num=0;
}

void add(int u,int v,int l,int c)
{
    edge[++num_edge].to=v;
    edge[num_edge].next=head[u];
    edge[num_edge].flow=l;
    edge[num_edge].cost=c;
    head[u]=num_edge;
}

bool SPFA(int s,int e)
{
    memset(dis,0x7f,sizeof(dis));
    memset(pre,-1,sizeof(pre));
    dis[s]=0; q.push(s); vis[s]=1;
    while (!q.empty())
    {
        int x=q.front(); q.pop();
        for (int i=head[x]; i; i=edge[i].next)
            if (edge[i].flow && dis[x]+edge[i].cost<dis[edge[i].to])
            {
                dis[edge[i].to]=dis[x]+edge[i].cost;
                pre[edge[i].to]=i;
                if (!vis[edge[i].to])
                {
                    vis[edge[i].to]=1;
                    q.push(edge[i].to);
                }
            }
        vis[x]=0;
    }
    return dis[e]!=INF;
}

void MCMF(int s,int e)
{
    int fee=0,ans=0;
    while (SPFA(s,e))
    {
        if (dis[e]==0) break;
        else ans++;
        int d=INF;
        for (int i=e; i!=s; i=edge[((pre[i]-1)^1)+1].to)
            d=min(d,edge[pre[i]].flow);
        for (int i=e; i!=s; i=edge[((pre[i]-1)^1)+1].to)
        {
            edge[pre[i]].flow-=d;
            edge[((pre[i]-1)^1)+1].flow+=d;
        }
        fee+=d*dis[e];
    }
    if (-fee==id_num) printf("%d
",ans);
    else puts("no solution");
}

void Tarjan(int x)
{
    DFN[x]=Low[x]=++dfs_num;
    Stack[++top]=x; Vis[x]=1;
    for (int i=head[x]; i; i=edge[i].next)
        if (!DFN[edge[i].to])
        {
            Tarjan(edge[i].to);
            Low[x]=min(Low[x],Low[edge[i].to]);
        }
        else if (Vis[edge[i].to])
            Low[x]=min(Low[x],DFN[edge[i].to]);
    if (DFN[x]==Low[x])
    {
        ID[x]=++id_num; Vis[x]=0;
        while (Stack[top]!=x)
        {
            ID[Stack[top]]=id_num;
            Vis[Stack[top--]]=0;
        }
        top--;
    }
}

int main()
{
    memset(&INF,0x7f,sizeof(INF));
    scanf("%d",&T);
    while (T--)
    {
        Clear();
        scanf("%d%d%d%d",&n,&m,&A,&B);
        for (int i=1; i<=A; ++i) scanf("%d",&a[i]);
        for (int i=1; i<=B; ++i) scanf("%d",&b[i]);
        for (int i=1; i<=m; ++i) scanf("%d%d",&u[i],&v[i]), add(u[i],v[i],0,0);
        for (int i=1; i<=n; ++i) if (!DFN[i]) Tarjan(i);
        memset(head,0,sizeof(head)); num_edge=0;
        for (int i=1; i<=A; ++i)
            add(s,ID[a[i]],INF,0), add(ID[a[i]],s,0,0);
        for (int i=1; i<=B; ++i)
            add(ID[b[i]]+5000,e,INF,0), add(e,ID[b[i]]+5000,0,0);
        for (int i=1; i<=m; ++i)
            if (ID[u[i]]!=ID[v[i]])
                add(ID[u[i]]+5000,ID[v[i]],INF,0), add(ID[v[i]],ID[u[i]]+5000,0,0);
        for (int i=1; i<=id_num; ++i)
        {
            add(i,i+5000,1,-1); add(i+5000,i,0,1);
            add(i,i+5000,INF,0); add(i+5000,i,0,0);
        }
        MCMF(s,e);
    }
}