hdu 3416 Marriage Match IV 【 最短路 最大流 】

求边不可重复的最短路条数

先从起点到终点用一次dijkstra,再从终点到起点用一次dijkstra,来判断一条边是否在最短路上

如果在，就将这条边的两个端点连起来，容量为1

再跑一下dinic(),最大流就是不可重复的最短路条数

还是想不到怎么建图啊------

每次做网络流的题目---

诶---该怎么建图啊---

想了一会儿----啊--不会啊---

搜一下题解吧---

啊，原来这样连边啊---

啊，原来需要---floyd / 并查集 /dijkstra /------

啊---快，粘一粘模板---

恩--试着跑一发---

诶--怎么不对---

原来数组开小了，，终点没有改过来--

好，厚着脸皮交一发---

哇----居然过了-------------------------------------------------

可是还是不会写网络流

唉--不说了---滚了---

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <iostream>
#include <algorithm>
#define MP(a,b) make_pair(a,b)
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
const int INF = (1 << 30) - 1;
const int maxn = 100055;

int path;
int first1[maxn],nxt1[10 * maxn],ecnt1;
int first2[maxn],nxt2[10 *maxn],ecnt2;
int first[maxn],nxt[10*maxn],ecnt;
int dis1[maxn],dis2[maxn];
int st,ed,lev[maxn],now[maxn];
int n,m;

int vis[20*maxn];

struct edge{
    int v,u,cost;
    int c;
    int next;
    friend bool operator < (edge a,edge b){
        return a.cost > b.cost;
    }
};

edge e1[5*maxn],e2[5*maxn],e[5*maxn];

void init(){
    ecnt1 = ecnt2 = ecnt = 0;
    memset(first1,-1,sizeof(first1));
    memset(first2,-1,sizeof(first2));
    memset(first,-1,sizeof(first));
}

void Add_edge1(int u,int v,int c){
    nxt1[++ecnt1] = first1[u];
    e1[ecnt1].u = u;
    e1[ecnt1].v = v;
    e1[ecnt1].cost = c;
    first1[u] = ecnt1;
}

void Add_edge2(int u,int v,int c){
    nxt2[++ecnt2] = first2[u];
    e2[ecnt2].v = v;
    e2[ecnt2].cost = c;
    first2[u] = ecnt2;
}

void Add_edge(int u,int v,int c){
    e[ecnt].next = first[u];
    e[ecnt].v = v;
    e[ecnt].u = u;
    e[ecnt].c = c;
    first[u] = ecnt++;
}

struct cmp{
    bool operator ()(pii a,pii b){
        return a.first > b.first;
    }
};

void Dijstra1(int s){
    priority_queue<pii,vector<pii >,cmp> PQ;
    dis1[s] = 0;
    PQ.push(MP(dis1[s],s));
    int cnt = 0;
    while(!PQ.empty()){
        pii x = PQ.top(); PQ.pop();
        if(dis1[x.second] < x.first) continue; 
        for(int i = first1[x.second]; i != -1; i = nxt1[i]){
            int v = e1[i].v;
            if(dis1[v] > dis1[x.second] + e1[i].cost){
                dis1[v] = dis1[x.second] + e1[i].cost;
                PQ.push(MP(dis1[v],v));
            }
        }
    }
}

void Dijstra2(int s){
    priority_queue<pii,vector<pii >,cmp> PQ;
    dis2[s] = 0;
    PQ.push(MP(dis2[s],s));
    int cnt = 0;
    while(!PQ.empty()){
        pii x = PQ.top(); PQ.pop();
        if(dis2[x.second] < x.first) continue; 
        for(int i = first2[x.second]; i != -1; i = nxt2[i]){
            int v = e2[i].v;
            if(dis2[v] > dis2[x.second] + e2[i].cost){
                dis2[v] = dis2[x.second] + e2[i].cost;
                PQ.push(MP(dis2[v],v));
            }
        }
    }
}

bool bfs(){
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(st);
    memset(lev,-1,sizeof(lev));
    lev[st] = 0;
    while(!q.empty()){
        int x = q.front();q.pop();
        for(int i = first[x];~i;i = e[i].next){
            int v = e[i].v;
            if(lev[v] < 0 && e[i].c > 0){
                lev[v] = lev[x] + 1;
                q.push(v);
            }
        }
    }
    return lev[ed] != -1;
}

int dfs(int p,int minf){
    if(p == ed || minf == 0) return minf;
    for(int &i = now[p];~i;i = e[i].next){
        int v = e[i].v;
        if(lev[v] == lev[p] + 1 && e[i].c > 0){
            int d = dfs(v,min(e[i].c,minf));
            if(d > 0){
                e[i].c -= d;
                e[i^1].c += d;
                return d;
            }
        }
    }
    return 0;
}

int dinic(){
    int max_flow = 0,p1;
    while(bfs()){
        memcpy(now,first,sizeof(first));
        while((p1 = dfs(st,INF)) > 0)
        max_flow += p1;
    }
    return max_flow;
}



int main(){
    int a,b,c;
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d %d",&n,&m);
        init();
        for(int i = 1; i <= m; ++i){
            scanf("%d%d%d",&a,&b,&c);
            Add_edge1(a,b,c);
            Add_edge2(b,a,c);
        }
        scanf("%d %d",&st,&ed);
        
        for(int i = 1;i <= n;i++) dis1[i] = dis2[i] = INF;
        
        Dijstra1(st);
        Dijstra2(ed);
        path = dis1[ed];
        
     //   for(int i = 1;i <= n;i++)
      //  printf("dis1[%d] = %d  dis2[%d] = %d
",i,dis1[i],i,dis2[i]);
        
        for(int u = 1;u <= n;u++){
            for(int i = first1[u];~i;i = nxt1[i]){
                int v = e1[i].v;
                if(dis1[u] + dis2[v] +e1[i].cost == path){
                //    printf("u = %d  v = %d
",u,v);
                    Add_edge(u,v,1);
                    Add_edge(v,u,0);
                }
            }
        }
        printf("%d
",dinic()); 
    }
    return 0;
}