POJ2135_费用流

题意：

约翰的农场有N个区域，1号区域是约翰的房屋，N号是谷仓，限制有M条双向通道链接着这些区域，要求求出1到N来回行程最短且不能同时经过两次同一区域。

思路：

好像最短路可以解，但是贪心思路是错误的。可能占用了一条关键的路，但是这条路是不对的。例如测试数据的1 2 3 4就不正确。
可以假设成网络费用流，行程设置为费用，通道流量设置为1.设置超级源汇分别连接着1和N点，流量设置为2.
这样假设后就变成了，要求满足源汇走出去的流量为2的费用最小的网络流，由于通道的流量都是1，所以不会造成有的点被走两次。

题目需要注意的是，建边的时候由于是无向边，所以就有来回两个边，又由于每个边都有回退边所以就是四条边了，所以要矩阵就不能满足存边的要求，所以要用链式前向星来存边。为什么一定要四条边，一开始也是疑问，后来实际做的时候你会发现在对回退边操作的时候，如果你不建四条边那你很难存回退边到底是哪一条。用了链式前向星就只需^1奇+偶-的操作即可。具体代码见：

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
#include<queue>
#include<cmath>
#include<fstream>
using namespace std;
fstream fin("t.txt");
//streambuf *buf = cin.rdbuf(fin.rdbuf());

const int MAX = 45000;
const int INF = 99999999;
int dis[MAX];
bool vis[MAX];
int N, M;
int S, T;

struct Edge
{
    int next, to, value;
    int c;
}edge[MAX];
int head[MAX];
int k = 0;

int load[MAX];
int p[MAX];

void addedge(int u, int v, int c, int value)
{
    edge[k].to = v;
    edge[k].next = head[u];
    edge[k].c = c;
    edge[k].value = value;
    head[u] = k;
    k++;
    edge[k].to = u;
    edge[k].next = head[v];
    edge[k].c = 0;//这是回退边的
    edge[k].value = -value;
    head[v] = k;
    k++;
}

bool Spfa(int s, int e)
{
    int que[MAX];
    int qi = 0, qt = 0;
    memset(vis, false, sizeof(vis));
    for (int j = 0; j < MAX; j++)
    {
        load[j] = p[j] = -1;
    }
    for (int j = 0; j < MAX; j++)
    {
        dis[j] = INF;
    }
    que[qi++] = s;
    dis[s] = 0;
    vis[s] = true;
    while (qi != qt)
    {
        int t = que[qt++];
        vis[t] = false;
        for (int i = head[t]; i != -1; i = edge[i].next)
        {
            if (edge[i].c)
            {
                int to = edge[i].to;
                if (dis[to] - dis[t] > edge[i].value)
                {
                    dis[to] = dis[t] + edge[i].value;
                    p[to] = t;
                    load[to] = i;
                    if (!vis[to])
                    {
                        vis[to] = true;
                        que[qi++] = to;
                    }
                }
            }
        }
    }
    if (dis[e] == INF)
        return false;
    return true;
}

int MinCost_MaxFlow(int s, int e)
{
    int u, minflow;
    int max_flow = 0, min_cost = 0;
    while (Spfa(s, e))
    {
        u = e;
        minflow = INF;
        while (p[u] != -1)
        {
            minflow = min(edge[load[u]].c, minflow);
            u = p[u];
        }
        u = e;
        while (p[u] != -1)
        {
            edge[load[u]].c -= minflow;
            edge[load[u] ^ 1].c += minflow;//建四条边的原因是这里操作方便
            u = p[u];
        }
        //max_flow += minflow;
        min_cost += dis[e];
    }
    return min_cost;
}

void init()
{
    k = 0;
    for (int i = 0; i < MAX; i++)
    {
        edge[i].next = edge[i].to = edge[i].value = 0;
        head[i] = -1;
    }
    head[0] = edge[0].next = -1;
}

int main()
{

    //freopen("22.txt", "a+", stdout);
    while (cin >> N >> M)
    {
        init();
        for (int i = 0; i < M; i++)
        {
            int a, b, c;
            cin >> a >> b >> c;
            addedge(a, b, 1, c);
            addedge(b, a, 1, c);
        }
        int S = N + 1, T = N + 2;
        addedge(S, 1, 2, 0);
        addedge(N, T, 2, 0);
        cout << MinCost_MaxFlow(S, T) << endl;
    }
    return 0;
}