HDU 3416 spfa + dinic

题意：求最短路的条数。

思路：先求正反两次spfa，然后取最短路上的边加入到图中，跑一次dinic求出最大流即可。

先说取最短路上的边。

假设s是起点，t是终点，如果dis[s][i] + dis[j][t] + w[i][j] == dis[s][t] ,那么这条边(i,j)就在最短路上。将(i,j)加入图中，容量是1.

最大流问题。

从s到t一个流就代表一条最短路， 所以最大流就是其最短路的个数。

代码写的略丑。

//NetWork Flows
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 2505
#define inf 1<<28
#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define REP(i,s,t) for(int i=(s);i<=(t);++i)
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)
#define PII pair<int,int>
using namespace std;


inline void readint(int &ret)
{
    char c;
    do
    {
        c = getchar();
    }
    while(c < '0' || c > '9');
    ret = c - '0';
    while((c=getchar()) >= '0' && c <= '9')
        ret = ret * 10 + ( c - '0' );
}
struct kdq
{
    int s ,e ,l ,next ;
} ed[Max * 100] ,ed1[Max * 100] ;//正图和逆图
int head[Max] ,head1[Max] ,num ,num1 ;
void add(int s ,int e ,int l)
{
    ed[num].s = s ;
    ed[num].e = e ;
    ed[num].l = l ;
    ed[num].next = head[s] ;
    head[s] = num ++ ;
}
void add1(int s ,int e ,int l)
{
    ed1[num1].s = s ;
    ed1[num1].e = e ;
    ed1[num1].l = l ;
    ed1[num1].next = head1[s] ;
    head1[s] = num1 ++ ;
}
void init()
{
    mem(head,-1);
    mem(head1,-1);
    num = num1 = 0 ;
}
int dis1[Max] ,dis2[Max] ;
bool vis[Max] ;
int qe[Max * 100] ;
void spfa(int n,int *dis, int *hea ,kdq *ee,int s)
{
    REP(i,0,n + 1)dis[i] = inf ,vis[i] = 0 ;
    dis[s] = 0 ;
    vis[s] = 1 ;
    int h = 0 ,t = 0 ;
    qe[h ++ ] = s ;
    while( h > t )
    {
        int tt = qe[t ++ ] ;
        vis[tt] = 0 ;
        for (int i = hea[tt] ; ~i ; i = ee[i].next )
        {
            int e = ee[i].e ;
            int l = ee[i].l ;
            if(dis[e] > dis[tt] + l )
            {
                dis[e] = dis[tt] + l ;
                if(!vis[e])
                {
                    vis[e] = 1 ;
                    qe[h ++ ] = e ;
                }
            }
        }
    }
}
int S ,T ;
int deep[Max] ;
int dinic_bfs()
{
    mem(deep,-1) ;
    deep[S] = 0 ;
    int h = 0 , t = 0 ;
    qe[ h ++ ] = S ;
    while( h > t )
    {
        int tt = qe[ t ++ ] ;
        for (int i = head1[tt] ; ~i ; i = ed1[i].next )
        {
            int e = ed1[i].e ;
            int l = ed1[i].l ;
            if(deep[e] == -1 && l > 0 )
            {
                deep[e] = deep[tt] + 1 ;
                if(e == T)return 1 ;
                qe[ h ++ ] = e ;
            }
        }
    }
    return 0 ;
}

int dinic_dfs(int now ,int f)
{
    if(now == T)return f ;
    int flow = 0 ;
    for (int i = head1[now] ; ~i ; i = ed1[i].next )
    {
        int e = ed1[i].e ;
        int l = ed1[i].l ;
        if(deep[e] == deep[now] + 1 && l > 0 && (f - flow))
        {
            int mm = min(l,f - flow ) ;
            int nn = dinic_dfs(e,mm) ;
            flow += nn ;
            ed1[i].l -= nn ;
            ed1[i ^ 1].l += nn ;
        }
    }
    if(!flow)deep[now] = -2 ;
    return flow ;
}

int dinic()
{
    int flow = 0 ;
    while(dinic_bfs())
    {
        flow += dinic_dfs(S,inf) ;
    }
    return flow ;
}
int main()
{
    int t ;
    readint(t) ;
    while( t -- )
    {

        int n , m ;
        readint(n) ;
        readint(m) ;
        init() ;
        while( m -- )
        {
            int a , b , c ;
            readint(a) ;
            readint(b) ;
            readint(c) ;
            if(a == b)continue ;
            add(a,b,c) ;
            add1(b,a,c) ;
        }
        int x ,y ;
        readint(x) ;
        readint(y) ;
        spfa(n,dis1,head,ed,x) ;
        spfa(n,dis2,head1,ed1,y) ;
        if(dis1[y] >= inf)
        {
            puts("0") ;
            continue;
        }
        mem(head1,-1) ;
        num1 = 0 ;
        REP(i,1,n)
        {
            for (int j = head[i] ; ~j ; j = ed[j].next )
            {
                int e = ed[j].e ;
                int l = ed[j].l ;
                if(dis1[i] + dis2[e] + l == dis1[y])//如果该边在最短路上
                {
                    add1(i,e,1) ;
                    add1(e,i,0) ;//反向边容量为0
                }
            }
        }
        S = x, T = y ;
        printf("%d\n",dinic()) ;
    }
    return 0;
}