uva 3353 Optimal Bus Route Design (费用流/KM)

题目大意：

n个点，问能否找出若干个圈，使得所有的点都在某个圈上且一个点只能属于一个圈。若能，求最小花费。

法一：最佳完美匹配(KM算法)

每个点都属于一个圈，则每个点的后继唯一确定，由此拆点构图，为每个点寻找匹配的后继使得花费最小。

法二：费用流

同样根据每个点的后继唯一确定的性质来建图：

1、将每个点拆为两个点，分别编号为1~n、n+1~n+n。

2、根据输入，给每一个点i 建立有向边，容量为1，费用为d(i,j)。

3、建立源点0，到1~n每个点连一条边，容量为1，费用为0，其流量即表示该点的入度；建立汇点2n+1，n+1~n+n每个点到该点连一条边，容量为1，费用为0，其流量即表示该点的出度。

4、求一次最小费用最大流，若最大流量为n，说明每个顶点的入度=出度=1，有解，否则无解。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uI;
typedef double db;
#define inf 0x3f3f3f3f
#define maxn 205
#define maxq 1005
#define maxm 30005
struct Edge{
    int to,next,cap,cost;
}edge[maxm];

int n,m,head[maxn],cnt,Q[maxq],qhead,qtail;
int cur[maxn],f[maxn],mcmf_cost,mcmf_flow;

inline void add(int u,int v,int cap,int cost)
{
    edge[cnt].to=v;
    edge[cnt].cap=cap;
    edge[cnt].cost=cost;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].to=u;
    edge[cnt].cap=0;
    edge[cnt].cost=-cost;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

int d[maxn];
bool vis[maxn];

inline bool spfa(int s,int e)
{
    int i;
    qhead=qtail=0;
    memset(d,inf,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s]=0;
    Q[qtail++]=s;
    cur[s]=-1;
    f[s]=inf;
    vis[s]=1;
    while(qtail>qhead)
    {
        int u=Q[qhead++];
        vis[u]=0;
        for(i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>0&&d[v]>d[u]+edge[i].cost)
            {
                d[v]=d[u]+edge[i].cost;
                f[v]=min(f[u],edge[i].cap);
                cur[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    Q[qtail++]=v;
                }
            }
        }
    }
    if(d[e]==inf) return 0;
    mcmf_flow+=f[e];
    for(i=cur[e];~i;i=cur[edge[i^1].to])
    {
        edge[i].cap-=f[e];
        edge[i^1].cap+=f[e];
        mcmf_cost+=f[e]*edge[i].cost;
    }
    return 1;
}

int main()
{
    int i,j,k;
    while(~scanf("%d",&n)&&n)
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        mcmf_cost=mcmf_flow=0;
        for(i=1;i<=n;++i)
        {
           add(0,i,1,0);
           add(i+n,2*n+1,1,0);
           while(scanf("%d",&j)&&j)
           {
               scanf("%d",&k);
               add(i,j+n,1,k);
           }
        }
        while(spfa(0,2*n+1));
        printf(mcmf_flow==n?"%d\n":"N\n",mcmf_cost);
    }
    return 0;
}