星际竞速 【HYSBZ - 1927】【最大流最小费用+建边思路】

BZOJ题目链接

VJ题目链接

此处打上提示：以后千万别忘了建反向的负边，WA了好多发了！！！牢记！

---

  这道题的难点就在于建边了，期间WA了好多发，一开始想的是S->i->i+N->T，其中"i -> i+N"是用来限流的。但是这样写完之后跑出来，发现永远测试样例跑出来都是201，完全就没有那些跳转的M条边。

  那么，怎么办呢？我们还是要限流，但是换一种方式，我们直到肯定有一个点得通过爆发模式来进行的（至少一个），那些可以通过爆发模式的达到的，直接连上终点，另外的边，可能可以通过其他点的边来过来，那么不妨就是去利用上这层关系，既然是可以这样子到达的，不妨还是将一个点拆成两颗，其中一个用以爆发模式得到的，另一个呢，可以通过边来得到，就是可以从其他点出发来到，不如就是这样：

S -> i ;

S -> i+N;

i+N -> T;

i -> j+N;(这里就是了，如果还能通过别的点到达，就可以这样子建边)

  这样子建边的原理在于什么？为了保证同一个点只能到达一次的同时，还可以去判断最小费用。（可以自行思考哦）

---

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 1607;
const int maxE = 3e4 + 5e3 + 7;
const int S = 0;
int N, M, head[maxN], cnt, T;
struct Eddge
{
    int nex, u, v, flow, cost;
    Eddge(int a=-1, int b=0, int c=0, int d=0, int f=0):nex(a), u(b), v(c), flow(d), cost(f) {}
}edge[maxE];
inline void addEddge(int u, int v, int flow, int cost)
{
    edge[cnt] = Eddge(head[u], u, v, flow, cost);
    head[u] = cnt++;
}
queue<int> Q;
int pre[maxN], Flow[maxN], dist[maxN];   bool inque[maxN];
bool spfa()
{
    while(!Q.empty()) Q.pop();  memset(pre, -1, sizeof(pre));   memset(Flow, 0, sizeof(Flow));  memset(dist, INF, sizeof(dist));    memset(inque, false, sizeof(inque));
    dist[S] = 0;    Flow[S] = INF;  pre[S] = 0; Q.push(S);  inque[S] = true;
    while(!Q.empty())
    {
        int u = Q.front();  Q.pop();    inque[u] = false;
        for(int i=head[u], v, cost; ~i; i=edge[i].nex)
        {
            v = edge[i].v;  cost = edge[i].cost;
            if(edge[i].flow && dist[v] > dist[u] + cost)
            {
                dist[v] = dist[u] + cost;
                pre[v] = i;
                Flow[v] = min(Flow[u], edge[i].flow);
                if(!inque[v])
                {
                    Q.push(v);
                    inque[v] = true;
                }
            }
        }
    }
    return pre[T] ^ -1;
}
int Out()
{
    int ans = 0;
    while(spfa())
    {
        int now = T, last = pre[now];
        while(now)
        {
            edge[last].flow -= Flow[T];
            edge[last^1].flow += Flow[T];
            now = edge[last].u;
            last = pre[now];
        }
        ans += Flow[T] * dist[T];
    }
    return ans;
}
inline void init()
{
    cnt = 0;    T = (N<<1) + 1;
    memset(head, -1, sizeof(head));
}
int main()
{
    scanf("%d%d", &N, &M);
    init();
    for(int i=1, power; i<=N; i++)
    {
        scanf("%d", &power);
        addEddge(S, i, 1, 0);
        addEddge(i, S, 0, 0);
        addEddge(S, i + N, 1, power);
        addEddge(i + N, S, 0, -power);
        addEddge(i + N, T, 1, 0);
        addEddge(T, i + N, 0, 0);
    }
    for(int i=1, u, v, val; i<=M; i++)
    {
        scanf("%d%d%d", &u, &v, &val);
        if(u > v) swap(u, v);
        addEddge(u, v + N, 1, val);
        addEddge(v + N, u, 0, -val);
    }
    printf("%d\n", Out());
    return 0;
}