Bzoj3258 秘密任务

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 140  Solved: 59

Description

Alice听说在一片神奇的大陆MagicLand，有一个古老的传说…… 
 很久很久以前，那个时候 MagicStates共和国刚刚成立。 反对新政府的势力虽已被镇压，但仍然在暗地活动。这一次，情报局得到了一个令人震惊的消息，被软禁在首都府邸中的Frank ——著名的反对派领袖，秘密逃出首都，去往反对派的大本营。根据相关的情报，Frank计划通过城市之间 发达的高速公路，经过最短的路程抵达目的地。不妨将 MagicStates共和国简化为由N个城市,M条高速公路构成的连通的无向图，首都为城市1，反对派的大本营为城市N。 
每条高速公路连接两个不同的城市，且路程是已知的。而Frank选择了一条从城市1到城市N的最短路径作为他的逃跑路线。为了阻止Frank，共和国总统决定在某些城市的高速公路的出入口设立检查 点，在Frank经过检查点时将他逮捕。 
举例来说，如果有一条高速公路连接城市u和城市v，在这条公路的城市u或城市v的出入口设立检查点，那么Frank经过高速公路时就会被发现。特别的是，由于城市N实际上处在反对派的控制下，所以不能在城市N设立检查点。

然而在任何城市设立检查点都需要一定的费用。更具体的，若在城市 u设立k个检查点，就要花费 Au乘以k的代价，其中Au是城市u的相关参数。值得注意的是，这个代价与这k个检查点具体设在哪些公路的出入口无关,于是，总统责令情报局拟定一个方案，花费最小的代价使得无论Frank选择哪条最短路线，都会在（除城市N以外）某个城市的高速公路出入口被发现。读到这里，Alice很想知道阻止Frank所需要花费的最小代价，并且她还希 望知道最优方案是否是唯一的。只好再请你帮助她了。 
注意，我们称两个方案不同当且仅当存在某城市k，两种方案中在城市 k的检查点的设置（而不仅是数目）是不同的。 
注意，输入文件包含多组测试数据。

Input

第一行包含一个正整数T，表示有T组测试数据。接下来依次是T组测试数据。 
 每组测试数据的第一行包含两个整数 N、M。 
第二行包含N - 1个正整数，依次表示A1，A2， …，An-1。
接下来M行，每行三个整数Ui,Vi,Ci,表示一条连接城市Ui和城市Vi的路程等于Ci的高速公路

Output

输出T行，依次表示每组测试数据的答案。若最优方案唯一则输出 ”Yes” 和
最小代价，否则输出”No”和最小代价。字符串和整数之间请用一个空格隔开。

Sample Input

3
3 3
2 4
1 3 23
3 2 12
2 1 11
4 4
3 2 2
1 2 1
2 3 1
3 4 1
4 1 1
3 4
3 2
1 2 1
2 3 2
2 3 19
3 1 4

图论 网络流 最小割唯一性判定

找出最短路，建立流量网络，跑最大流，在残量网络上跑tarjan。

遍历每条割边，如果一条割边的两端点不在同一个强连通分量内且不是由S所在强连通分量指向T所在强连通分量，那么说明有多解。

坑点：如果一条割边的两端点的代价相等，也算有多解。

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
#define LL long long
using namespace std;
const LL INF=0x3f3f3f3f3f3f3f;
const int mxn=300100;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,S,T;
struct edge{
    int u,v,nxt;
    LL f;
}e[mxn<<2],eg[mxn<<2];
int hd[mxn],hd2[mxn],mct1=0,mct=1;
void add(int u,int v,LL d){
    eg[++mct1].nxt=hd2[u];
    eg[mct1].u=u;eg[mct1].v=v;
    eg[mct1].f=d;
    hd2[u]=mct1;
    return;
}
void add_edge(int u,int v,LL w){
    e[++mct].nxt=hd[u];e[mct].u=u;e[mct].v=v;e[mct].f=w;hd[u]=mct;return;
}
void insert(int u,int v,LL w){
    add_edge(u,v,w);
    add_edge(v,u,0);
}
int d[mxn];
bool BFS(){
    memset(d,0,sizeof d);
    queue<int>q;
    q.push(S);d[S]=1;
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=hd[u];i;i=e[i].nxt){
            int v=e[i].v;
            if(!e[i].f || d[v])continue;
            d[v]=d[u]+1;
            q.push(v);
        }
    }
    return d[T];
}
LL DFS(int u,LL lim){
    if(u==T)return lim;
    LL f=0,tmp;
    for(int i=hd[u];i;i=e[i].nxt){
        int v=e[i].v;
        if(d[v]==d[u]+1 && e[i].f && (tmp=DFS(e[i].v,min(lim,e[i].f)))){
            e[i].f-=tmp;
            e[i^1].f+=tmp;
            f+=tmp;
            lim-=tmp;
            if(!lim)return f;
        }
    }
    d[u]=0;
    return f;
}
LL Dinic(){
    LL res=0;
    while(BFS())res+=DFS(S,INF);
    return res;
}
//
int dfn[mxn],low[mxn],dtime=0;
int belong[mxn],scc=0;
int st[mxn],top=0;
bool inst[mxn];
void tarjan(int u){
    dfn[u]=low[u]=++dtime;
    st[++top]=u;
    inst[u]=1;
    for(int i=hd[u];i;i=e[i].nxt){
        int v=e[i].v;if(!e[i].f)continue;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(inst[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u]){
        int v=0;
        ++scc;
        do{
            v=st[top--];
            inst[v]=0;
            belong[v]=scc;
        }while(u!=v);
    }
    return;
}
//
LL dis[4050];//,dis2[405];
struct dist{
    int v;
    LL dis;
    bool operator < (dist b)const{return dis>b.dis;}
};
priority_queue<dist>q;
void Dij(int s){
//    printf("in
");
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;
    q.push((dist){s,0});
    while(!q.empty()){
        dist tmp=q.top();q.pop();
        if(tmp.dis>dis[tmp.v]){continue;}
        int u=tmp.v;
        for(int i=hd2[u],v;i;i=eg[i].nxt){
            v=eg[i].v;
            if(dis[v]>dis[u]+eg[i].f){
                dis[v]=dis[u]+eg[i].f;
                q.push((dist){v,dis[v]});
            }
        }
    }
    return;
}
int cnt=0;
LL au[mxn];
LL ans;
void Build(){
    Dij(1);
    for(int i=1;i<=mct1;i++){
        if(dis[eg[i].u]+eg[i].f==dis[eg[i].v]){
            cnt++;
            insert(eg[i].u,eg[i].v,min(au[eg[i].u],au[eg[i].v]));
        }
    }
    S=1;T=n;
    ans=Dinic();
    return;
}
void solve(){
    int i,j;
    for(i=1;i<=n;i++)
        if(!dfn[i])tarjan(i);
    bool flag=1;
    for(i=2;i<=mct;i+=2){
        if(e[i].f==0){
            int u=e[i].u,v=e[i].v;
            if(belong[u]==belong[v])continue;
//            printf("u:%d v:%d bu:%d bv:%d
",u,v,belong[u],belong[v]);
            if( (belong[u]!=belong[S] || belong[v]!=belong[T]) 
                && (belong[u]!=belong[T] || belong[v]!=belong[S])){
                flag=0;break;
            }
            if(au[u]==au[v]){
                flag=0;break;
            }
        }
    }
    if(flag)printf("Yes ");
    else printf("No ");
    printf("%lld
",ans);
    return;
}
//
//
void init(){
    memset(hd,0,sizeof hd);
    memset(hd2,0,sizeof hd2);
    memset(dfn,0,sizeof dfn);
    memset(low,0,sizeof low);
    mct1=0;mct=1;
    cnt=0;scc=0;dtime=0;
    //
    return;
}
int main(){
    freopen("in.txt","r",stdin);
    int i,j;
    int T=read();
    while(T--){
        init();
        n=read();m=read();
        for(i=1;i<n;i++)au[i]=read();
        au[n]=INF;
        int u,v,w;
        for(i=1;i<=m;i++){
            u=read();v=read();w=read();
//            printf("%d to %d :%d
",u , v, w );
            add(u,v,w);
            add(v,u,w);
        }
        Build();
        solve();
    }
    return 0;
}