HIT 2739 - The Chinese Postman Problem - [带权有向图上的中国邮路问题][最小费用最大流]

题目链接：http://acm.hit.edu.cn/hoj/problem/view?id=2739

Time limit : 1 sec Memory limit : 64 M

A Chinese postman is assigned to a small town in China to deliver letters. In this town, each street is oriented and connects exactly two junctions. The postman's task is to start at the post office and pass each street at least once to deliver letters. At last, he must return to the post office.

Can you help him to make sure whether there exist feasible routes for him and find the minimum distance from all the feasible routes.

Input

Input contains multiple test cases. The first line is an integer T, the number of test cases. Each case begins with two integers N, M, with 2 ≤ N ≤ 100, 1 ≤ M ≤ 2000, representing the number of junctions and the number of streets respectively.

Then M lines will follow, each denoting a street. A street is represented by three integers u, v, d, with 0 ≤ u, v < N, 0 < d ≤ 1000, meaning this street whose length is d connects the junction u and v and the postman can only travel from junction u to v. Junctions are numbered from 0 to N-1. Junction 0 is always the post office. Note that there may be more than one street connecting the same pair of junctions.

Output

Output one line for each test case. If there exist feasible routes for the postman, output the minimum distance. Otherwise, output -1.

Sample Input

Sample Output

题意：

　带权有向图上的中国邮路问题：

　一名邮递员需要经过每条有向边至少一次，最后回到出发点；

　一条边多次经过权值要累加，问最小总权值是多少。（2 <= N <= 100, 1 <= M <= 2000）

构图：

　首先是比较理论的部分：

　因而有：

　　（优先判断：若原图的基图不连通，或者存在某个点的入度或出度为 0 则无解，then可以直接跳到下一个test case；）

　　统计所有点的 D[i] = outdegree[i] - indegree[i]；

　　对于 D[i] < 0 的点，加边(s, i, Di, 0)；对于 D[i] > 0 的点，加边(i, t, -Di, 0)；

　　（判断：若所有D[i]全为0，直接输出sum = Σ( all D[i][j] ) ，其中 D[i][j] 为边(i, j)的权值，then可以直接跳到下一个test case；）

　　对原图中的每条边(i, j)，在网络中加边(i, j, ∞, D[i][j])；

　　求一次最小费用最大流，费用加上原图所有边权和即为结果。

代码：

 #include<cstdio>

 #include<cstring>

 #include<vector>

 #include<queue>

 #define MAXN 105

 #define MAXM 2*(2005+2*MAXN)

 #define INF 0x3f3f3f3f

 using namespace std;

 int n,m;

 struct Edge{

     int u,v,c,f,a;

 };

 struct MCMF

 {

     int s,t,ne;

     Edge E[MAXM];

     int head[MAXN],next[MAXM];

     int vis[MAXN];

     int d[MAXN];

     int pre[MAXN];

     int aug[MAXN];

     void init()

     {

         ne=;

         memset(head,-,sizeof(head));

     }

     void addedge(int from,int to,int cap,int cost)

     {

         E[ne].u=from, E[ne].v=to, E[ne].c=cap, E[ne].f=, E[ne].a=cost;

         next[ne]=head[from]; head[from]=ne++;

         E[ne].u=to, E[ne].v=from, E[ne].c=, E[ne].f=, E[ne].a=-cost;

         next[ne]=head[to]; head[to]=ne++;

     }

     bool SPFA(int s,int t,int &flow,int &cost)

     {

         memset(d,INF,sizeof(d));

         memset(vis,,sizeof(vis));

         d[s]=, vis[s]=, pre[s]=, aug[s]=INF;

         queue<int> q;

         q.push(s);

         while(!q.empty())

         {

             int now=q.front(); q.pop();

             vis[now]=;

             for(int i=head[now];i!=-;i=next[i])

             {

                 Edge& e=E[i];

                 int nex=e.v;

                 if(e.c>e.f && d[nex]>d[now]+e.a)

                 {

                     d[nex]=d[now]+e.a;

                     pre[nex]=i;

                     aug[nex]=min(aug[now],e.c-e.f);

                     if(!vis[nex])

                     {

                         q.push(nex);

                         vis[nex]=;

                     }

                 }

             }

         }

         if(d[t]==INF) return ;

         flow+=aug[t];

         cost+=d[t]*aug[t];

         for(int i=t;i!=s;i=E[pre[i]].u)

         {

             E[pre[i]].f+=aug[t];

             E[pre[i]^].f-=aug[t];

         }

         return ;

     }

     int mincost()

     {

         int flow=,cost=,cnt=;

         while(SPFA(s,t,flow,cost));

         return cost;

     }

 }mcmf;

 int outd[MAXN],ind[MAXN],sum;

 int main()

 {

     int t;

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d%d\n",&n,&m);

         memset(outd,,sizeof(outd));

         memset(ind,,sizeof(ind));

         mcmf.s=, mcmf.t=n+; mcmf.init();

         sum=;

         for(int i=,u,v,d;i<=m;i++)

         {

             scanf("%d%d%d",&u,&v,&d);

             u++, v++, sum+=d;

             mcmf.addedge(u,v,INF,d);

             outd[u]++;

             ind[v]++;

         }

         bool hasAns=,all_d_is_zero=;

         for(int i=,d;i<=n;i++)

         {

             if(outd[i]== || ind[i]==)//显然不能有欧拉回路

             {

                 hasAns=;

                 break;

             }

             d=outd[i]-ind[i];

             if(d!=) all_d_is_zero=;

             if(d>) mcmf.addedge(i,mcmf.t,d,);

             if(d<) mcmf.addedge(mcmf.s,i,-d,);

         }

         if(!hasAns)

         {

             printf("-1\n");

             continue;

         }

         if(all_d_is_zero)

         {

             printf("%d\n",sum);

             continue;

         }

         printf("%d\n",mcmf.mincost()+sum);

     }

 }

（之前2713用STL超时，搞得这题也不敢用STL，继续数组模拟邻接表，然后最大边数MAXM没开好，RE两次、TLE一次……）