【BZOJ-2893】征服王 最大费用最大流（带下界最小流）

2893: 征服王

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit:
156  Solved: 48
[Submit][Status][Discuss]

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。

HINT

Source

Solution

一眼网络流，起点终点有限制的最小路径覆盖

一般的最小路径覆盖问题，是用二分图的方法去解

而这里，应该考虑另一种做法

对于有向图，先Tarjan缩点，重建图，然后求带下届的最小流即可

但是这里用的最大费用最大流，同时需要缩点，建图：

对于Tarjan后缩成的点，每个点拆成两个点，入点向出点连两条边，容量inf，费用0；容量1，费用1

原图中的点，缩成的点相连，容量inf，费用1

S到起始点缩成的点连容量inf，费用0

T到终止点缩成的点连容量inf，费用0

然后跑最大费用最大流，因为最大费用最大流每次增广的费用是严格从大到小的，所以增广次数既为答案

Code

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
int read()
{
    int x=,f=; char ch=getchar();
    while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}
    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}
    return x*f;
}
#define maxm 100100
#define maxn 2010
int n,m,A,B,t,ans,cost;
struct Edgenode{int to,next,cap,cost,from;}edge[maxm];
int head[maxn],cnt;
inline void add(int u,int v,int w,int c)
{
    cnt++; edge[cnt].next=head[u]; head[u]=cnt;
    edge[cnt].from=u; edge[cnt].to=v; edge[cnt].cap=w; edge[cnt].cost=c;
}
inline void insert(int u,int v,int w,int c)
{add(u,v,w,c); add(v,u,,-c);}
struct Roadnode{int to,next;}road[maxm];
int last[maxn],cnr;
inline void Add(int u,int v)
{
    cnr++; road[cnr].next=last[u]; last[u]=cnr; road[cnr].to=v;
}
#define inf 0x7fffffff
int S,T; int dis[maxn]; queue<int>q; bool mark[maxn];
inline bool spfa()
{ 

    memset(mark,,sizeof(mark));
    for (int i=; i<=S; i++) dis[i]=-;
    q.push(T); mark[T]=; dis[T]=;
    while (!q.empty())
        {
            int now=q.front(); q.pop();
            for (int i=head[now]; i; i=edge[i].next)
                if (edge[i^].cap && dis[edge[i].to]<dis[now]+edge[i^].cost)
                    {
                        dis[edge[i].to]=dis[now]+edge[i^].cost;
                        if (!mark[edge[i].to])
                            mark[edge[i].to]=,q.push(edge[i].to);
                    }
            mark[now]=;
          //  printf("%d %d %d\nhahahaha",now,he,ta);
        }
    return dis[S]!=-;
}
inline int dfs(int loc,int low)
{
    mark[loc]=;
    if (loc==T) return low;
    int w,used=;
    for (int i=head[loc]; i; i=edge[i].next)
        if (edge[i].cap && dis[edge[i].to]==dis[loc]-edge[i].cost && !mark[edge[i].to])
            {
                w=dfs(edge[i].to,min(low-used,edge[i].cap));
                edge[i].cap-=w; edge[i^].cap+=w; used+=w;
                cost+=w*edge[i].cost; if (used==low) return low;
            }
    return used;
}
inline void zkw()
{
    while (spfa())
        {
            int pre=cost;
            mark[T]=;
            while (mark[T])
                {memset(mark,,sizeof(mark)); dfs(S,inf);}
            insert(S,,,);
            if (pre==cost) break; else ans++;
        }
//    printf("%d %d %d\n",cnt,cost,ans);
}
int stack[maxn],top,dfn[maxn],low[maxn],tot,qcnt,belong[maxn]; bool visit[maxn];
void Tarjan(int x)
{
    dfn[x]=low[x]=++tot;
    visit[x]=; stack[++top]=x;
    for (int i=last[x]; i; i=road[i].next)
        {
            if (!dfn[road[i].to])
                {
                    Tarjan(road[i].to);
                    if (low[road[i].to]<low[x]) low[x]=low[road[i].to];
                }
            else
                if(visit[road[i].to] && dfn[road[i].to]<low[x])
                    low[x]=dfn[road[i].to];
        }
    if (dfn[x]==low[x])
        {
            int uu=;qcnt++;
            while (x!=uu)
                uu=stack[top--],visit[uu]=,belong[uu]=qcnt;
        }
}
inline void init()
{
    memset(dfn,,sizeof(dfn));
    memset(head,,sizeof(head));
    memset(last,,sizeof(last));
    cnt=; cnr=top=tot=qcnt=cost=ans=;
}
int cans[maxn],cant[maxn];
inline void rebuild()
{
    T=*qcnt+;S=T+;
    for (int i=; i<=A; i++) insert(,belong[cans[i]],inf,);
    for (int i=; i<=B; i++) insert(belong[cant[i]]+qcnt,T,inf,);
    for (int u=; u<=n; u++)
        for (int i=last[u]; i; i=road[i].next)
            if (belong[u]!=belong[road[i].to])
                insert(belong[u]+qcnt,belong[road[i].to],inf,);
    for (int i=; i<=qcnt; i++) insert(i,i+qcnt,,),insert(i,i+qcnt,inf,);
    insert(S,,,);
}
int main()
{
//    freopen("sail.in","r",stdin);
//    freopen("sail.out","w",stdout);
    t=read();
    while (t--)
        {
            init();
            n=read(),m=read(),A=read(),B=read();
            for (int i=; i<=A; i++) cans[i]=read();
            for (int i=; i<=B; i++) cant[i]=read();
            for (int u,v,i=; i<=m; i++) u=read(),v=read(),Add(u,v);
            for (int i=; i<=n; i++) if (!dfn[i]) Tarjan(i);
            rebuild();
            zkw();
            if (cost!=qcnt) puts("no solution");
                else printf("%d\n",ans);
        }
    return ;
}

这题自己默默T成狗，改了好久