网络流 O - Marriage Match IV

题目链接：https://vjudge.net/contest/299467#problem/O

题目思路：网络流+最短路

这个是一个最短路+最大流，最短路容易，就是跑起点到每一个点的距离。

但是这个最大流的图难想，题解说的是，把每一个最短路的点放到网络流的图中，流量设置为1 ，然后跑一个最大流。

看了题解后，只有感觉题解特别正确，这个就是本来一个图里面有很多没有用的边，就是不能算作最短路里面的，

当我们把最短路的点放到了网络流中，然后通过跑最大流来求路径条数。

这个想清楚之后是真的好简单。

因为这个最大流这个可以不断变形，所以就有点难想啊。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <vector>
#include <string>
#include <map>
#include <iostream>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 1e5 + ;
const int INF = 0x3f3f3f3f;
struct edge
{
    int u, v, c, f;
    edge(int u, int v, int c, int f) :u(u), v(v), c(c), f(f) {}
};
vector<edge>e;
vector<int>G[maxn];
int level[maxn];//BFS分层，表示每个点的层数
int iter[maxn];//当前弧优化
void init()
{
    for (int i = ; i <= maxn; i++)G[i].clear();
    e.clear();
}
void addedge(int u, int v, int c)
{
    e.push_back(edge(u, v, c, ));
    e.push_back(edge(v, u, , ));
    int m = e.size();
    G[u].push_back(m - );
    G[v].push_back(m - );
    //printf("%d %d %d\n", u, v, c);
}
void BFS(int s)//预处理出level数组
//直接BFS到每个点
{
    memset(level, -, sizeof(level));
    queue<int>q;
    level[s] = ;
    q.push(s);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int v = ; v < G[u].size(); v++)
        {
            edge& now = e[G[u][v]];
            if (now.c > now.f && level[now.v] < )
            {
                level[now.v] = level[u] + ;
                q.push(now.v);
            }
        }
    }
}
int dfs(int u, int t, int f)//DFS寻找增广路
{
    if (u == t)return f;//已经到达源点，返回流量f
    for (int &v = iter[u]; v < G[u].size(); v++)
        //这里用iter数组表示每个点目前的弧，这是为了防止在一次寻找增广路的时候，对一些边多次遍历
        //在每次找增广路的时候，数组要清空
    {
        edge &now = e[G[u][v]];
        if (now.c - now.f >  && level[u] < level[now.v])
            //now.c - now.f > 0表示这条路还未满
            //level[u] < level[now.v]表示这条路是最短路，一定到达下一层，这就是Dinic算法的思想
        {
            int d = dfs(now.v, t, min(f, now.c - now.f));
            if (d > )
            {
                now.f += d;//正向边流量加d
                e[G[u][v] ^ ].f -= d;
                //反向边减d，此处在存储边的时候两条反向边可以通过^操作直接找到
                return d;
            }
        }
    }
    return ;
}
int Maxflow(int s, int t)
{
    int flow = ;
    for (;;)
    {
        BFS(s);
        if (level[t] < )return flow;//残余网络中到达不了t，增广路不存在
        memset(iter, , sizeof(iter));//清空当前弧数组
        int f;//记录增广路的可增加的流量
        while ((f = dfs(s, t, INF)) > )
        {
            flow += f;
        }
    }
    return flow;
}

struct node
{
    int from,to, dist;
    node(int from=,int to=,int dist=):from(from),to(to),dist(dist){}
}exa[maxn];

struct heapnode
{
    int u, d;
    heapnode(int u=,int d=):u(u),d(d){}
    bool operator<(const heapnode&a)const
    {
        return a.d < d;
    }
};

vector<node>vec[maxn];
int d[maxn], n, m;
bool vis[maxn];
void dij(int s)
{
    priority_queue<heapnode>que;
    que.push(heapnode(s, ));
    memset(vis, , sizeof(vis));
    memset(d, inf, sizeof(d));
    d[s] = ;
    while(!que.empty())
    {
        heapnode x = que.top(); que.pop();
        int u = x.u;
        if (vis[u]) continue;
        vis[u] = ;
        for(int i=;i<vec[u].size();i++)
        {
            node now = vec[u][i];
            if(d[now.to]>d[u]+now.dist)
            {
                d[now.to] = d[u] + now.dist;
                que.push(heapnode(now.to, d[now.to]));
            }
        }
    }
}

int main()
{
    int w;
    scanf("%d", &w);
    while(w--)
    {
        init();
        scanf("%d%d", &n, &m);
        for (int i = ; i <= n; i++) vec[i].clear();
        for(int i=;i<=m;i++)
        {
            int u, v, c;
            scanf("%d%d%d", &u, &v, &c);
            vec[u].push_back(node(u, v, c));
            exa[i] = node(u, v, c);
        }
        int s, t;
        scanf("%d%d", &s, &t);
        dij(s);
        for(int i=;i<=m;i++)
        {
            node now = exa[i];
            if (d[now.to] == d[now.from] + now.dist) addedge(now.from, now.to, );
        }
        int ans = Maxflow(s, t);
        printf("%d\n", ans);
    }
    return ;
}