NWERC 2012 A - Admiral【最小费用最大流】

题意：

有n个岛屿 起点1 终点 n

现在两个人同时从起点出发向终点前进

两个人的路径不能有交集（一个人走过的路另一个人不能再走了）

问两个人的最小总花费

分析：

刚开始的的时候以为是最短路和次短路的和就行了   （太天真了）

快要结束的时候突然间发现这不就是传说中的最小费用最大流问题吗

可惜时间不够

思路是这样的：因为两个人来走，所以输入和输出的流量为1 费用为0

而连接的两点流量为1花费为权值

建图即可

结束之后敲完了代码，测试数据通过

不过没有地方提交

在程的帮助下重启pc^2完成了提交，

可是

结果却是wrong

很苦恼啊

于是各种修改啊

还是wrong

最后在网上搜了一下题解

我终于知道wrong的地方了

就跟牛选食物跟饮料那个题一样的 ，如果一头牛同时喜欢两种食物和两种饮料的话，结果就是不对的

这个题类似

修改方法便是拆点

代码如下：

  1 //已ac

  2 #include <iostream>

  3 #include <cstdio>

  4 #include <cstring>

  5 #include <vector>

  6 #include <queue>

  7 using namespace std;

  8

  9 const int maxn = 10005;

 10 const int INF = 1000000000;

 11

 12 struct Edge {

 13     int from, to, cap, flow, cost;//起点 终点 容量 花费

 14 };

 15

 16 struct MCMF

 17 {

 18     int n, m, s, t;

 19     vector<Edge> edges;

 20     vector<int> G[maxn];

 21

 22     int inq[maxn];

 23     int d[maxn];

 24     int p[maxn];

 25     int a[maxn];

 26

 27     void init(int n) {//初始化的是所有的点数

 28         this -> n = n;

 29         for(int i = 0; i < n; i++) G[i].clear();

 30         edges.clear();

 31     }

 32

 33     void AddEdge(int from, int to, int cap, int cost) {

 34         edges.push_back((Edge) { from, to, cap, 0, cost } );

 35         edges.push_back((Edge) { to, from, 0, 0, -cost } );

 36         m = edges.size();

 37         G[from].push_back(m - 2);

 38         G[to].push_back(m - 1);

 39     }

 40

 41     bool BellmanFord(int s, int t, int &flow, int &cost) {

 42         for(int i = 0; i < n; i++) d[i] = INF;

 43         memset(inq, 0, sizeof(inq) );

 44         d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;

 45         queue<int> Q;

 46         Q.push(s);

 47         while(!Q.empty()) {

 48             int u = Q.front(); Q.pop();

 49             inq[u] = 0;

 50             for(int i = 0; i < G[u].size(); i++) {

 51                 Edge &e = edges[G[u][i]];

 52                 if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {

 53                     d[e.to] = d[u] + e.cost;

 54                     p[e.to] = G[u][i];

 55                     a[e.to] = min(a[u], e.cap - e.flow);

 56                     if(!inq[e.to]) { Q.push(e.to); inq[e.to] = 1; }

 57                 }

 58             }

 59         }

 60

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

 62         flow += a[t];

 63         cost += d[t] * a[t];

 64         int u = t;

 65         while(u != s) {

 66             edges[p[u]].flow += a[t];

 67             edges[p[u] ^ 1].flow -= a[t];

 68             u = edges[p[u]].from;

 69         }

 70         return true;

 71     }

 72

 73     int MinCost(int s, int t) {//起点和终点

 74       //  this -> s = s; this -> t = t;

 75         int flow = 0, cost = 0;

 76         while(BellmanFord(s, t, flow, cost)){};

 77         return cost;

 78     }

 79 };

 80

 81 MCMF g;

 82

 83 int main() {

 84     int n, m;

 85     int a, b, c;

 86     freopen("a.txt","r",stdin);

 87     while(EOF != scanf("%d %d",&n, &m)) {

 88         g.init(n * 2 + 1);

 89         g.AddEdge(1, 1 + n, 2, 0);

 90         g.AddEdge(n, n + n, 2, 0);

 91         for(int i = 2; i <= n - 1; i++) {

 92             g.AddEdge(i, i + n, 1, 0);

 93         }

 94         for(int i = 0; i < m; i ++) {

 95             scanf("%d %d %d",&a, &b, &c);

 96             g.AddEdge(a + n, b, 1, c);

 97         }

 98         printf("%d\n",g.MinCost(1, n + n));

 99     }

100     return 0;

101 }