HDU Tour

                                                                        Tour

 

题目链接：Click Here~

题目分析：

     给你N给城市M条路，要求求出一个环。且使得这个环的距离和最小，即最小花费最少。每天至少一场的比赛快受不了了T _ T。昨晚被老师叫去盘问考不考研，我说还不知道。然后，他就淡定的来一句，那你就搞到大四吧，反正ACM跟就业和项目都不冲突。当时我就惊呆了！！！！而且老师一大早就跑来说叫我们去参加广东的省赛。T_T这不是诚心让我们去受虐吗！

算法分析：

     一道挺裸的最小费用最大流问题。当然KM也是正解，话说我KM还没用过。^ _ ^看来是时候用一用了。

建模分析：

     一开始我想到了最长单调子序列的那个建模。但是最小费用问题似乎不能拆点的，可能是我处理的不好。本来是每个点只经过一次，所以要拆成(i,i+n,1,0)的但是总是不对。后来改了好久，把拆点的代码删了就对了。不知道为什么，可能是修炼的不够啊！然后就是普通的建图了。

设源点s，汇点t

1、把所有的点链接到(s,i,1,0)。

2、把所有的点链接到(i+n,t,1,0)。

3、把两点之间有连接的点(x,y+n,1,c)。

#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAXN = 400 + 5,INF = ~0U>>1;
struct Edge{
   int from,to,cap,flow,cost;
   Edge(int f,int t,int c,int _f,int _c)
       :from(f),to(t),cap(c),flow(_f),cost(_c){}
};
class MCMF{
public:
    void Init(int n);
    void AddEdge(int from,int to,int cap,int cost);
    int Mincost();
    bool BellmanFord(int& flow,int& cost);
    int Solve(int n,int m);
private:
    vector<Edge> edges;
    vector<int> G[MAXN];
    int n,s,t;
    int d[MAXN],p[MAXN],a[MAXN];
    bool inq[MAXN];
};
void MCMF::Init(int n)
{
    s = 0; t = n+n+1;
    for(int i = 0;i <= t;++i)
        G[i].clear();
    edges.clear();
}
inline void MCMF::AddEdge(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 sz = edges.size();
    G[from].push_back(sz-2);
    G[to].push_back(sz-1);
}
bool MCMF::BellmanFord(int& flow,int& cost)
{
    for(int i = 0;i <= t;++i)d[i] =INF;
    memset(inq,false,sizeof(inq));
    inq[s] = true;p[s] = 0; d[s] = 0;a[s] = INF;

    queue<int> Q;
    Q.push(s);
    while(!Q.empty()){
        int u = Q.front();
        Q.pop();
        inq[u] = false;
        for(int i = 0;i <(int)G[u].size();++i){
            Edge& e = edges[G[u][i]];
            if(e.cap > e.flow&&d[e.to] > d[u]+e.cost){
                d[e.to] = d[u]+e.cost;
                p[e.to] = G[u][i];
                a[e.to] = min(a[u],e.cap-e.flow);
                if(!inq[e.to]){inq[e.to] = true;Q.push(e.to);}
            }
        }
    }
    if(d[t]==INF)return false;
    flow += a[t];
    cost += a[t]*d[t];  
    int u = t;
    while(u!=s){
        edges[p[u]].flow += a[t];
        edges[p[u]^1].flow -= a[t];
        u = edges[p[u]].from;
    }
    return true;
}
int MCMF::Mincost()
{
    int flow = 0,cost = 0;
    while(BellmanFord(flow,cost));
    return cost;
}
int MCMF::Solve(int n,int m)
{
    Init(n);
    int x,y,c;
    for(int i = 1;i <= n;++i){
//        AddEdge(i,i+n,1,0);
        AddEdge(s,i,1,0);
        AddEdge(i+n,t,1,0);
    }
    for(int i = 0;i < m;++i){
        scanf("%d%d%d",&x,&y,&c);
        AddEdge(x,y+n,1,c);
    }
    return Mincost();
}
int main()
{
    int T,n,m;
    MCMF mcmf;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        int cost = mcmf.Solve(n,m);
        printf("%d\n",cost);
    }
    return 0;
}