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*];
 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*],v[N*],x,INF,s,e=;
 int dis[N],pre[N],vis[N];
 int head[N],num_edge;
 queue<int>q;

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

 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,-,sizeof(pre));
     dis[s]=; q.push(s); vis[s]=;
     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]=;
                     q.push(edge[i].to);
                 }
             }
         vis[x]=;
     }
     return dis[e]!=INF;
 }

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

 void Tarjan(int x)
 {
     DFN[x]=Low[x]=++dfs_num;
     Stack[++top]=x; Vis[x]=;
     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]=;
         while (Stack[top]!=x)
         {
             ID[Stack[top]]=id_num;
             Vis[Stack[top--]]=;
         }
         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=; i<=A; ++i) scanf("%d",&a[i]);
         for (int i=; i<=B; ++i) scanf("%d",&b[i]);
         for (int i=; i<=m; ++i) scanf("%d%d",&u[i],&v[i]), add(u[i],v[i],,);
         for (int i=; i<=n; ++i) if (!DFN[i]) Tarjan(i);
         memset(head,,sizeof(head)); num_edge=;
         for (int i=; i<=A; ++i)
             add(s,ID[a[i]],INF,), add(ID[a[i]],s,,);
         for (int i=; i<=B; ++i)
             add(ID[b[i]]+,e,INF,), add(e,ID[b[i]]+,,);
         for (int i=; i<=m; ++i)
             if (ID[u[i]]!=ID[v[i]])
                 add(ID[u[i]]+,ID[v[i]],INF,), add(ID[v[i]],ID[u[i]]+,,);
         for (int i=; i<=id_num; ++i)
         {
             add(i,i+,,-); add(i+,i,,);
             add(i,i+,INF,); add(i+,i,,);
         }
         MCMF(s,e);
     }
 }