BZOJ 1266: [AHOI2006]上学路线route Floyd_最小割

十分简单的一道题.
图这么小，跑一边 Floyd 就得到第一问最短路径的答案.
考虑第二问怎么求：
我们可以先将最短路径组成的图从原图中抽离出来，构成新图 $G$.
我们发现，只要 $G$ 的起点与终点联通，那么最短路径就仍然存在.
所以我们想用最小的代价破坏掉 $G$ 点起点与终点的连通性.
这不就是最小割的定义嘛...... 跑一边最大流即可.

Code:

#include <bits/stdc++.h>
#define setIO(s) freopen(s".in","r",stdin) 
#define maxn 200000 
#define N 502 
#define ll int
#define inf 1000000 
using namespace std; 
int n,m; 
struct Graph
{
    int u,v,dis,c; 
    Graph(int u = 0,int v = 0,int dis = 0,int c = 0) : u(u), v(v), dis(dis), c(c){} 
}G[maxn]; 
namespace Dinic{
    struct Edge
    {
        int from,to,cap; 
        Edge(int a = 0,int b = 0,int c = 0):from(a),to(b),cap(c){} 
    }; 
    vector <Edge> edges; 
    vector <int> G[N]; 
    queue <int> Q; 
    int current[N], d[N], vis[N],s,t;  
    void add(int u,int v,int c)
    {
        edges.push_back(Edge(u,v,c)); 
        edges.push_back(Edge(v,u,0)); 
        int kk = edges.size(); 
        G[u].push_back(kk - 2); 
        G[v].push_back(kk - 1); 
    }
    int BFS()
    {
        memset(vis,0,sizeof(vis)); 
        vis[s] = 1, d[s] = 0; 
        Q.push(s); 
        while(!Q.empty())
        {
            int u = Q.front(); Q.pop(); 
            for(int sz = G[u].size(),i = 0;i < sz; ++i)
            {
                Edge e = edges[G[u][i]]; 
                if(e.cap > 0 && !vis[e.to]) 
                {
                    vis[e.to] = 1, d[e.to] = d[u] + 1; 
                    Q.push(e.to); 
                }
            }
        }
        return vis[t]; 
    }
    int dfs(int x,int cur)
    {
        if(x == t) return cur; 
        int f=0,flow = 0; 
        for(int sz = G[x].size(),i = current[x];i < sz; ++i)
        {
            current[x] = i;  
            Edge e = edges[G[x][i]]; 
            if(e.cap > 0 && d[e.to] == d[x] + 1) 
            {
                f = dfs(e.to, min(cur,e.cap)); 
                cur -= f, flow += f; 
                edges[G[x][i]].cap -= f, edges[G[x][i] ^ 1].cap += f; 
            }
            if(cur == 0) break; 
        }
        return flow; 
    }
    int maxflow()
    {
        int ans = 0;
        while(BFS())
        {
            memset(current,0,sizeof(current)); 
            ans += dfs(s,inf); 
        }
        return ans; 
    }
}; 
namespace Floyd{
    ll dis[N][N];  
    void init()
    {
        for(int i = 0;i < N; ++i) 
            for(int j = 0;j < N; ++j) dis[i][j] = inf; 
        for(int i = 0;i < N; ++i) dis[i][i] = 0; 
    }
    void calc()
    {
        for(int k = 1;k <= n; ++k) 
            for(int i = 1;i <= n; ++i) 
                for(int j = 1;j <= n; ++j)  
                    dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);  
        for(int i = 1;i <= m; ++i)
        {
            Graph e = G[i]; 
            if(dis[1][e.u] + dis[e.v][n] + e.dis == dis[1][n]) Dinic :: add(e.u,e.v,e.c); 
            if(dis[1][e.v] + dis[e.u][n] + e.dis == dis[1][n]) Dinic :: add(e.v,e.u,e.c);  
        }
    }
}; 
int main()
{
    // setIO("input"); 
    Floyd :: init(); 
    scanf("%d%d",&n,&m); 
    for(int i = 1,a,b,c,d;i <= m; ++i)
    {
        scanf("%d%d%d%d",&a,&b,&c,&d); 
        Floyd :: dis[a][b] = Floyd :: dis[b][a] = c; 
        G[i] = Graph(a,b,c,d); 
    }
    Floyd :: calc();  
    printf("%d\n",Floyd :: dis[1][n]); 
    Dinic :: s = 1, Dinic :: t = n; 
    printf("%d",Dinic :: maxflow()); 
    return 0; 
}