BZOJ 1927: [Sdoi2010]星际竞速费用流

1927: [Sdoi2010]星际竞速

Time Limit: 1 Sec

Memory Limit: 256 MB

题目连接

http://www.lydsy.com/JudgeOnline/problem.php?id=1927

Description

10 年一度的银河系赛车大赛又要开始了。作为全银河最盛大的活动之一，夺得这个项目的冠军无疑是很多人的梦想，来自杰森座 α星的悠悠也是其中之一。赛车大赛的赛场由 N 颗行星和M条双向星际航路构成，其中每颗行星都有一个不同的引力值。大赛要求车手们从一颗与这 N 颗行星之间没有任何航路的天体出发，访问这 N 颗行星每颗恰好一次，首先完成这一目标的人获得胜利。由于赛制非常开放，很多人驾驶着千奇百怪的自制赛车来参赛。这次悠悠驾驶的赛车名为超能电驴，这是一部凝聚了全银河最尖端科技结晶的梦幻赛车。作为最高科技的产物，超能电驴有两种移动模式：高速航行模式和能力爆发模式。在高速航行模式下，超能电驴会展开反物质引擎，以数倍于光速的速度沿星际航路高速航行。在能力爆发模式下，超能电驴脱离时空的束缚，使用超能力进行空间跳跃——在经过一段时间的定位之后，它能瞬间移动到任意一个行星。天不遂人愿，在比赛的前一天，超能电驴在一场离子风暴中不幸受损，机能出现了一些障碍：在使用高速航行模式的时候，只能由每个星球飞往引力比它大的星球，否则赛车就会发生爆炸。尽管心爱的赛车出了问题，但是悠悠仍然坚信自己可以取得胜利。他找到了全银河最聪明的贤者——你，请你为他安排一条比赛的方案，使得他能够用最少的时间完成比赛。

Input

第一行是两个正整数 N, M。第二行 N 个数 A1~AN，其中Ai表示使用能力爆发模式到达行星 i 所需的定位时间。接下来 M行，每行 3个正整数ui, vi, wi，表示在编号为 ui和vi的行星之间存在一条需要航行wi时间的星际航路。输入数据已经按引力值排序，也就是编号小的行星引力值一定小，且不会有两颗行星引力值相同。

Output

仅包含一个正整数，表示完成比赛所需的最少时间。

Sample Input

3 3
1 100 100
2 1 10
1 3 1
2 3 1

Sample Output

HINT

说明：先使用能力爆发模式到行星 1，花费时间 1。
然后切换到高速航行模式，航行到行星 2，花费时间10。
之后继续航行到行星 3完成比赛，花费时间 1。
虽然看起来从行星 1到行星3再到行星 2更优，但我们却不能那样做，因为
那会导致超能电驴爆炸。

对于 30%的数据 N≤20，M≤50；
对于 70%的数据 N≤200，M≤4000；
对于100%的数据N≤800， M≤15000。输入数据中的任何数都不会超过106
。
输入数据保证任意两颗行星之间至多存在一条航道，且不会存在某颗行星到
自己的航道。

题意

题解：

比较裸的费用流啦，注意拆点

S-v-v'-t

一开始跳跃的，就直接从S - V'就好了，费用为跳跃时间，建边的，就让编号小的v指向编号大的v',cap为1 cost为这条路的长度就行了

然后跑一发费用流

代码：

//qscqesze

#include <cstdio>

#include <cmath>

#include <cstring>

#include <ctime>

#include <iostream>

#include <algorithm>

#include <set>

#include <bitset>

#include <vector>

#include <sstream>

#include <queue>

#include <typeinfo>

#include <fstream>

#include <map>

#include <stack>

typedef long long ll;

using namespace std;

//freopen("D.in","r",stdin);

//freopen("D.out","w",stdout);

#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)

#define maxn 200500

#define mod 1001

#define eps 1e-9

#define pi 3.1415926

int Num;

//const int inf=0x7fffffff;

const ll inf=;

inline ll read()

{

    ll x=,f=;char ch=getchar();

    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}

    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}

    return x*f;

}

//*************************************************************************************

const int MAXN = ;

const int MAXM = ;

const int INF = 0x3f3f3f3f;

struct Edge

{

    int to, next, cap, flow, cost;

    int x, y;

} edge[MAXM],HH[MAXN],MM[MAXN];

int head[MAXN],tol;

int pre[MAXN],dis[MAXN];

bool vis[MAXN];

int N, M;

char map[MAXN][MAXN];

void init()

{

    N = MAXN;

    tol = ;

    memset(head, -, sizeof(head));

}

void addedge(int u, int v, int cap, int cost)//左端点，右端点，容量，花费

{

    edge[tol]. to = v;

    edge[tol]. cap = cap;

    edge[tol]. cost = cost;

    edge[tol]. flow = ;

    edge[tol]. next = head[u];

    head[u] = tol++;

    edge[tol]. to = u;

    edge[tol]. cap = ;

    edge[tol]. cost = -cost;

    edge[tol]. flow = ;

    edge[tol]. next = head[v];

    head[v] = tol++;

}

bool spfa(int s, int t)

{

    queue<int>q;

    for(int i = ; i < N; i++)

    {

        dis[i] = INF;

        vis[i] = false;

        pre[i] = -;

    }

    dis[s] = ;

    vis[s] = true;

    q.push(s);

    while(!q.empty())

    {

        int u = q.front();

        q.pop();

        vis[u] = false;

        for(int i = head[u]; i != -; i = edge[i]. next)

        {

            int v = edge[i]. to;

            if(edge[i]. cap > edge[i]. flow &&

                    dis[v] > dis[u] + edge[i]. cost )

            {

                dis[v] = dis[u] + edge[i]. cost;

                pre[v] = i;

                if(!vis[v])

                {

                    vis[v] = true;

                    q.push(v);

                }

            }

        }

    }

    if(pre[t] == -) return false;

    else return true;

}

//返回的是最大流， cost存的是最小费用

int minCostMaxflow(int s, int t, int &cost)

{

    int flow = ;

    cost = ;

    while(spfa(s,t))

    {

        int Min = INF;

        for(int i = pre[t]; i != -; i = pre[edge[i^]. to])

        {

            if(Min > edge[i]. cap - edge[i]. flow)

                Min = edge[i]. cap - edge[i]. flow;

        }

        for(int i = pre[t]; i != -; i = pre[edge[i^]. to])

        {

            edge[i]. flow += Min;

            edge[i^]. flow -= Min;

            cost += edge[i]. cost * Min;

        }

        flow += Min;

    }

    return flow;

}int main()

{

    init();//注意

    int beg = ;//超级起点

    int end = ;//超级汇点

    int n=read(),m=read();

    for(int i=;i<=n;i++)

    {

        int x=read();

        addedge(beg,i,,);

        addedge(beg,n+i,,x);

        addedge(n+i,end,,);

    }

    for(int i=;i<=m;i++)

    {

        int x=read(),y=read(),z=read();

        if(x>y)swap(x,y);

        addedge(x,n+y,,z);

    }

    int ans = ;

    minCostMaxflow(beg,end,ans);

    printf("%d\n",ans);

}