【网络流】【最小费用最大流】【建图】HDU 1853 Cyclic Tour

【题目】http://acm.hdu.edu.cn/showproblem.php?pid=1853

【大意】一堆点，一些点之间有有向边，边的长度是花费，问能否让这些点组成几个环使得花费最小？

【参考】https://blog.csdn.net/kg20006/article/details/51570201

【思路】将点*2，分左点和右点，超级源点连所有的左点，费用是0，容量是1；所有的左点按边连右点，费用是长度，容量是1；所有右点连超级汇点，费用是0，容量是1。这样只要最后汇点的流量等于点的个数，那么所有的点一定出度为1，所有的点一定入度为1，一定都在环中。

【代码】

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
const int MAXN=10000;
const int MAXM=100000;
const int INF=0x3f3f3f3f;
struct node1
{
    int to,next,cap,flow,cost;
    int x,y;
} edge[MAXM];
struct node2
{
    int x, y;
} HH[MAXN],MM[MAXN];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int n,m;
char mp[MAXN][MAXN];

void init()
{
    tol=0;
    memset(head,-1,sizeof(head));
}

//左端点，右端点，容量，花费
void addedge(int u, int v, int cap, int cost)
{

    edge[tol].to=v,edge[tol].cap=cap;
    edge[tol].cost=cost,edge[tol].flow=0;
    edge[tol].next=head[u];
    head[u]=tol++;

    edge[tol].to=u,edge[tol].cap=0;
    edge[tol].cost=-cost,edge[tol].flow=0;
    edge[tol].next=head[v];
    head[v]=tol++;
}

bool spfa(int s, int t)
{
    std::queue<int>q;
    for(int i=0; i<MAXN; i++)
    {
        dis[i]=INF;
        vis[i]=0;
        pre[i]=-1;
    }
    dis[s]=0,vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i]. to;
            if(edge[i].cap>edge[i].flow &&
                    dis[v]>dis[u]+edge[i].cost)
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
        q.pop();
        vis[u]=0;
    }
    if(pre[t]==-1)
        return 0;
    return 1;
}

//返回的是最大流， cost存的是最小费用
int minCostMaxflow(int s, int t, int &cost)
{
    int flow = 0;
    cost = 0;
    while(spfa(s,t))
    {
        int Min=INF;
        for(int i=pre[t]; i!=-1; i=pre[edge[i^1]. to])
        {
            if(Min>edge[i].cap-edge[i]. flow)
                Min=edge[i].cap-edge[i]. flow;
        }
        for(int i=pre[t]; i!=-1; i=pre[edge[i^1].to])
        {
            edge[i].flow +=Min;
            edge[i^1].flow-=Min;
            cost+=edge[i].cost*Min;
        }
        flow+=Min;
    }
    //printf("%d\n",flow);
    if(flow!=n)cost=-1;
    return flow;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        int start=0,end=2*n+1;
        for(int i=1; i<=n; i++)
            addedge(start,i,1,0);
        for(int i=n+1; i<=2*n; i++)
            addedge(i,end,1,0);
        for(int i=0; i<m; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,n+v,1,w);
        }
        int ans=0;
        minCostMaxflow(start,end,ans);
        printf("%d\n",ans);
    }
    return 0;
}