hrbust 1716 双狙人【费用流Min_Cost_Max_flow】

双狙人

Time Limit: 1000 MS Memory Limit: 32768 K   Total Submit: 27(13 users) Total Accepted: 15(12 users) Rating:  Special Judge: No

Description

Alice和Bob收到上头密令，需要深入丛林执行一项暗杀任务...... 两人来到茂盛的丛林前，发现很多暗哨，他们需要尽快的摸过一些暗哨，到达目标点执行暗杀，并且返回他们开始的地方。 他们经过这些暗哨时，都需要把暗哨里的人杀掉(杀掉暗哨的时间不算)，所以当他们完成任务返回时，不能经过之前经过的暗哨，防止被围堵。 现在求他们完成这项任务所需要的最少时间。

Input

有多组测试数据，对于每组测试数据： 第一行为n和m，表示有n个点，编号1到n，其中1为起始点，n为他们的目标点，2至n-1为暗哨; m表示有m条可以走的路径。 接下来为m行，每行包含三个整数a b c，表示他们从暗哨a摸到暗哨b的时间为c，注意路径是双向的，并且没有重复路径。 2<=n<=200, 1 <= m <= n*n/2, 1 <= c <= 100

Output

对于每组测试数据，输出一行。 如果能完成任务，输出所花最少时间，如果不能完成任务则输出"Mission Failed!"，输出不包含引号。

Sample Input

5 8 1 5 50 1 3 3 3 5 10 4 5 4 2 3 5 3 4 8 1 2 10 2 4 50 5 7 1 3 3 3 5 10 4 5 4 2 3 5 3 4 8 1 2 10 2 4 50 5 6 1 3 3 3 5 10 4 5 4 2 3 5 3 4 8 1 2 10

Sample Output

63 77 Mission Failed!

思路：

1、首先，求一个来回最短路，而且对应一个点不能重复走 ，其实我们可以理解为：求两遍从起点到终点的最短路并使得其中两次最短路求的时候没有重复的点出现即可。

2、那么这个时候我们在对点的限制加一个容量，那么就能解决一个点不能重复走两次的问题，而流量问题是建立在边之上的，并不是点，那么我们将一个点一分为二.设定一条有向边，然后设定其流量为1，表示这条边只能走一次，那么就相当于这个点只能走一次了。

3、大概思路构建完毕，剩下的就是去实现建图了：

①建立源点S，连入1号节点，其流设定为2，花费为0，表示跑两次最短路。

②建立汇点T,N号节点连入汇点T，其流设定为2，花费为0，表示跑两次最短路。

③每个点一分为二.两点之间建立一条有向边，其流设定为1，花费为0，表示这个点只能走一次。

④然后将输入进来的边建立双向边即可。

4、跑一遍连续增广路算法。如果求出的最大流==2，那么表示任务能够成功，输出最小花费，否则输出任务失败。

Ac代码：

#include<stdio.h>
#include<queue>
#include<string.h>
using namespace std;
#define INF 0x3f3f3f3f
struct node
{
    int from;
    int to;
    int w;
    int f;
    int next;
    int num;
}e[15151515];
int out[151515];
int head[151515];
int pre[151515];
int path[151515];
int dis[151515];
int vis[151515];
int n,m,ss,tt,cont;
void add(int from,int to,int w,int f)
{
    e[cont].from=from;
    e[cont].to=to;
    e[cont].f=f;
    e[cont].w=w;
    e[cont].num=cont;
    e[cont].next=head[from];
    head[from]=cont++;
}
int SPFA()
{
    queue<int >s;
    s.push(ss);
    memset(pre,-1,sizeof(pre));
    memset(path,-1,sizeof(path));
    for(int i=1;i<=tt;i++)dis[i]=0x3f3f3f3f;
    dis[ss]=0;
    memset(vis,0,sizeof(vis));
    vis[ss]=1;
    while(!s.empty())
    {
        int u=s.front();
        s.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].to;
            int w=e[i].w;
            int f=e[i].f;
            if(f&&dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                pre[v]=u;
                path[v]=e[i].num;
                if(vis[v]==0)
                {
                    s.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    if(dis[tt]!=0x3f3f3f3f)return 1;
    else return 0;
}
void Min_costflow()
{
    int ans=0;
    int maxflow=0;
    while(SPFA()==1)
    {
        int minn=0x3f3f3f3f;
        for(int i=tt;i!=ss;i=pre[i])
        {
            minn=min(minn,e[path[i]].f);
        }
        maxflow+=minn;
        ans+=dis[tt]*minn;
        for(int i=tt;i!=ss;i=pre[i])
        {
            e[path[i]].f-=minn;
            e[path[i]^1].f+=minn;
        }
    }
    if(maxflow==2)
    printf("%d\n",ans);
    else printf("Mission Failed!\n");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        ss=n*2+1;
        tt=ss+1;
        cont=0;
        memset(head,-1,sizeof(head));
        for(int i=0;i<m;i++)
        {
            int x,y,w;
            scanf("%d%d%d",&x,&y,&w);
            add(x+n,y,w,INF);
            add(y,x+n,-w,0);
            add(y+n,x,w,INF);
            add(x,y+n,-w,0);
        }
        add(ss,1,0,2);
        add(1,ss,0,0);
        add(n*2,tt,0,2);
        add(tt,n*2,0,0);
        for(int i=1;i<=n;i++)
        {
            if(i==1||i==n)
            {
                add(i,i+n,0,2);
                add(i+n,i,0,0);
                continue;
            }
            add(i,i+n,0,1);
            add(i+n,i,0,0);
        }
        Min_costflow();
    }
}