HDU 1853 Cyclic Tour（KM或费用流）

最新推荐文章于 2019-12-25 14:57:00 发布

swust_lian

最新推荐文章于 2019-12-25 14:57:00 发布

阅读量425

点赞数

分类专栏：图论文章标签： HDU 1853 KM 费用流

本文链接：https://blog.csdn.net/swust_lian/article/details/50592074

版权

图论专栏收录该内容

33 篇文章 0 订阅

订阅专栏

本文探讨了一种使用二分匹配和KM算法解决有向图中构成环路并最小化路径长度的问题。通过将每个节点拆分为两个节点来构造二分图，并利用KM算法找到最大权重匹配，从而确定最优路径。文章还讨论了处理重边和验证图是否满足要求的方法。

摘要由CSDN通过智能技术生成

题意：有n个点m条边的有向图，一个人可以从一个起点走最终回到起点，每个点只能访问一次。意思是要把这个图分成很多个环，每个点只能属于一个环，求构成这些环的最短路程，若不能满足要求的图就输出-1。

解法一：一个人要从起点出发又回到起点，并且每个点只能走一次。这不就是二分匹配问题吗？把每个点拆成两个点

i和i'。把i作为二分图左边的点，i'作为二分图右边的点。假设u到v有条边，即左边的u可以和右边的v匹配。题目又要求路程最小，并且每个点都要有匹配点，显然这是km（最大权完美匹配）。只需要把边权作为取负就ok 了。

注意：之前我一直没相通的是，怎么判断这个图是不符合要求的（即有些点不能匹配到点，不能构成环）。其实，我们可以先构造成完全图，即初始化左边每个点与右边每个点的权值为-INF。如果km跑出来后，左边的点有匹配到右边的点的值为-INF就输出-1。还需要注意的是有重边！！

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 305
#define LL long long
#define INF 1000000001
int lx[MAXN],ly[MAXN],r[MAXN];
int vis[MAXN],s[MAXN],t[MAXN];
int w[MAXN][MAXN],slack[MAXN];
int n,m;
void init()
{
    for(int i=0;i<MAXN;i++)
    {
        for(int j=0;j<MAXN;j++)
        {
            w[i][j]=-INF;//初始化匹配的边权为-INF
        }
    }
}
int match(int i)
{
    int j;
    s[i]=1;
    for(j=1;j<=n;j++)
    {
        if(lx[i]+ly[j]==w[i][j]&&!t[j])
        {
            t[j]=1;
            if(!r[j]||match(r[j]))
            {
                r[j]=i;
                return 1;
            }
        }
    }
    return 0;
}
void update()
{
    int a=INF;
    for(int i=1;i<=n;i++)
    {
        if(s[i])
        for(int j=1;j<=n;j++)
            if(!t[j])a=min(a,lx[i]+ly[j]-w[i][j]);
    }
    for(int i=1;i<=n;i++)
    {
        if(s[i])
            lx[i]-=a;
        if(t[i])
            ly[i]+=a;
    }
}
void km()
{
    int i,j;
   for(i=1;i<=n;i++)
   {
       r[i]=lx[i]=ly[i]=0;
       for(j=1;j<=n;j++)
       {
           lx[i]=max(lx[i],w[i][j]);
       }
   }
   for(i=1;i<=n;i++)
   {
       while(1)
       {
           memset(s,0,sizeof s);
           memset(t,0,sizeof t);
           if(match(i))break;
           else update();

       }
   }
}int main()
{
    int i;
    while(cin>>n>>m)
    {
        init();
        for(i=1;i<=m;i++)
        {
            int u,v,length;
            cin>>u>>v>>length;
//            w[u][v]=-length;
            w[u][v]=max(w[u][v],-length);
        }
        km();
        int f=0,ans=0;
        for(i=1;i<=n;i++)
        {
            if(w[r[i]][i]==-INF)
            {
                f=1;break;
            }
             ans+=w[r[i]][i];
        }

       if(f==1)
       {
           puts("-1");
       }
       else
        printf("%d\n",-ans);
    }
    return 0;
}

解法二：由上可知，为km。所以当然可以用费用流写了，而且代码更好写。也不需要考虑重边。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 1005
#define LL long long
#define INF 0x3f7f7f7f
const double eps = 1e-10;
struct Edge
{
    int from,to,cap,flow,cost;
    Edge(int from=0,int to=0,int cap=0,int flow=0,int cost=0)
    {
        this->from=from;
        this->to=to;
        this->cap=cap;
        this->flow=flow;
        this->cost=cost;
    }
};
vector<Edge>edges;
vector<int>g[MAXN];
bool vis[MAXN];
int dis[MAXN];
int pre[MAXN];
int a[MAXN];
int s,t;
void init()
{
    for(int i=0;i<MAXN;i++)
    {
        g[i].clear();
    }
    edges.clear();
}
void add(int from,int to,int cap,int cost)
{
    edges.push_back(Edge(from,to,cap,0,cost));
    edges.push_back(Edge(to,from,0,0,-cost));
    int m=edges.size();
    g[from].push_back(m-2);
    g[to].push_back(m-1);
}
bool spfa(int &flow,int &cost)
{
    int i;
    for(i=0;i<MAXN;i++)
        dis[i]=INF;
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(s);
    dis[s]=0;
    vis[s]=1;
    pre[s]=0;
    a[s]=INF;
   while(!q.empty())
   {
       int u=q.front();
       q.pop();
       vis[u]=0;
       int sz=g[u].size();
       for(i=0;i<sz;i++)
       {
           Edge &e=edges[g[u][i]];
           if(e.cap>e.flow&&dis[e.to]>dis[u]+e.cost)
           {
               dis[e.to]=dis[u]+e.cost;
               pre[e.to]=g[u][i];
               a[e.to]=min(a[u],e.cap-e.flow);
               if(!vis[e.to])
               {
                   vis[e.to]=1;
                   q.push(e.to);
               }
           }
       }
   }
   if(dis[t]==INF)
    return false;
   flow+=a[t];
   cost+=dis[t]*a[t];
   int v=t;
   while(v!=s)
   {
       edges[pre[v]].flow+=a[t];
       edges[pre[v]^1].flow-=a[t];
       v=edges[pre[v]].from;
   }
   return true;
}
int n,m;
int minCost()
{
    int flow=0,cost=0;
    while(spfa(flow,cost));
    if(flow==n)
    return cost;
    else return -1;
}
int maze[105][105];

int main()
{
    int i,j;
    while(cin>>n>>m)
    {
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
            maze[i][j]=INF;
        init();
        for(i=1;i<=m;i++)
        {
            int u,v,len;
            cin>>u>>v>>len;
            maze[u][v]=min(maze[u][v],len);
        }
        s=0,t=2*n+1;;
        for(i=1;i<=n;i++)
        {
            add(s,i,1,0);
            add(i+n,t,1,0);
            for(j=1;j<=n;j++)
            {
                if(maze[i][j]!=INF)
                {
                    add(i,j+n,1,maze[i][j]);
                }
            }
        }
        cout<<minCost()<<endl;
    }
    return 0;
}