POJ 2135 Farm Tour

Farm Tour

Time Limit: 1000ms

Memory Limit: 65536KB

This problem will be judged on PKU. Original ID: 2135
64-bit integer IO format: %lld      Java class name: Main

 

When FJ's friends visit him on the farm, he likes to show them around. His farm comprises N (1 <= N <= 1000) fields numbered 1..N, the first of which contains his house and the Nth of which contains the big barn. A total M (1 <= M <= 10000) paths that connect the fields in various ways. Each path connects two different fields and has a nonzero length smaller than 35,000. 

To show off his farm in the best way, he walks a tour that starts at his house, potentially travels through some fields, and ends at the barn. Later, he returns (potentially through some fields) back to his house again. 

He wants his tour to be as short as possible, however he doesn't want to walk on any given path more than once. Calculate the shortest tour possible. FJ is sure that some tour exists for any given farm.

 

Input

* Line 1: Two space-separated integers: N and M. 

* Lines 2..M+1: Three space-separated integers that define a path: The starting field, the end field, and the path's length. 

 

Output

A single line containing the length of the shortest tour. 

 

Sample Input

4 5
1 2 1
2 3 1
3 4 1
1 3 2
2 4 2

Sample Output

6

Source

USACO 2003 February Green

 

解题：最小费用最大流。建模：求去回的最短路。每条路最多只访问一次。既然要去一次，还要回一次，不重复。路径长度刚好看作费用。每条路的容量为1。（超级源点到1的费用为0，容量为2.终点到超级汇点的费用也为0，容量为2.）为了容量设为1呢。还记得大明湖畔的增广路么？网络流的一种算法不就是寻找增广路么？可想，每次从超级源点出发，到超级汇点找到一条增广路。然后把该路上的流量减1.因为都是1，所以最小就是1.表示去的一条增广路。减了后剩余0了。就标记了此路已被访问了。保证了不走重复路。

 

然后会再次找一条增广路？再次？因为超级源点到1的流量刚才减去1还剩1啊。找到第二条增广路后。超级源点已经无法到达1了，也就是无法到达超级汇点了。

 

此时求出的费用和正式要求的最小来回费用。

 

我们把去到回的过程通过最小费用最大流的形式变成了，从超级源点到超级汇点的两条路。（边无交集，虽然超级源点到1这条边重复了，但是费用是0，跟没走一样。）

 

还要注意，此题，是无向图，故要多建边。

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <cstdlib>
#include <string>
#include <set>
#include <stack>
#define LL long long
#define pii pair<int,int>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 100100;
struct arc{
    int u,v,w,f,next;
    arc(int a = 0,int b = 0,int c = 0,int x = 0,int y = 0){
        u = a;
        v = b;
        w = c;
        f = x;
        next = y;
    }
};
arc e[maxn];
int head[1010],tot,d[1010],n,m,S,T;
int p[1010],q[maxn<<2],hd,tail;
bool in[1010];
void add(int u,int v,int w,int f){
    e[tot] = arc(u,v,w,f,head[u]);
    head[u] = tot++;
    e[tot] = arc(v,u,-w,0,head[v]);
    head[v] = tot++;
}
bool spfa(){
    for(int i = S; i <= T; i++){
        d[i] = INF;
        in[i] = false;
        p[i] = -1;
    }
    hd = tail = 0;
    in[S] = true;
    d[S] = 0;
    q[tail++] = S;
    while(hd < tail){
        int u = q[hd++];
        in[u] = false;
        for(int i = head[u]; ~i; i = e[i].next){
            if(e[i].f > 0 && d[e[i].v] > d[u]+e[i].w){
                d[e[i].v] = d[u] + e[i].w;
                p[e[i].v] = i;
                if(!in[e[i].v]){
                    in[e[i].v] = true;
                    q[tail++] = e[i].v;
                }
            }
        }
    }
    return p[T] > -1;
}
int solve(){
    int ans = 0;
    while(spfa()){
        int maxVal = INF;
        for(int i = p[T]; ~i; i = p[e[i].u])
            maxVal = min(maxVal,e[i].f);
        for(int i = p[T]; ~i; i = p[e[i].u]){
            e[i].f -= maxVal;
            e[i+1].f += maxVal;
            ans += maxVal*e[i].w;
        }
    }
    return ans;
}
int main() {
    int u,v,w;
    while(~scanf("%d %d",&n,&m)){
        S = tot = 0;
        T = n+1;
        memset(head,-1,sizeof(head));
        add(S,1,0,2);
        add(n,T,0,2);
        for(int i = 0; i < m; i++){
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,w,1);
            add(v,u,w,1);
        }
        printf("%d
",solve());
    }
    return 0;
}