Path(最短路+最小割)

题目链接：Path

题意：给你一个有向图，然后删除一条边的代价是这条边的边权，问你最小付出多少代价，使得点1到n的最短路变长（或者不存在通路）。

思路：

1. 题目意思也就是说要删除一些边使得原本图中的最短路不存在
2. 那么我们可以先找出图中所有的最短路，然后用这些最短路建几个新图
3. 然后对这个新图求最小割，也就是最大流，因为最小割就是最少割掉多少流量，使得源点与汇点不连通

怎么构建新图呢，我们可以先对原图跑一边最短路求出最短路的距离，然后遍历所有边，如果这条边满足dis[v] == dis[u]+w那么这条边就需要放到我们后来的新图中去

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;

typedef long long ll;

const int N = 100010;

struct node
{
    int to;
    ll w;
    int next;
} edge1[N], edge2[2*N];

int n;
int head1[N], tot1;
int head2[N], tot2;
ll dis[N];
bool vis[N];
int level[N];

void add1(int u, int v, ll w)
{
    edge1[tot1].to = v;
    edge1[tot1].w = w;
    edge1[tot1].next = head1[u];
    head1[u] = tot1++;
}

void add2(int u, int v, ll w)
{
    edge2[tot2].to = v;
    edge2[tot2].w = w;
    edge2[tot2].next = head2[u];
    head2[u] = tot2++;
}

bool operator < (const node &a, const node &b)
{
    return a.w > b.w;
}

void dj(node st)
{
    memset(dis, inf, sizeof(dis));
    memset(vis, false, sizeof(vis));
    priority_queue<node> q;
    dis[st.to] = 0;
    q.push(st);
    while(!q.empty())
    {
        node fir = q.top();
        int u = fir.to;
        q.pop();
        if(vis[u]) continue;
        vis[u] = true;
        for(int i = head1[u]; i != -1; i = edge1[i].next)
        {
            int v = edge1[i].to;
            ll w = edge1[i].w;
            if(!vis[v] && dis[v] > dis[u]+w)
            {
                dis[v] = dis[u]+w;
                node nex;
                nex.to = v;
                nex.w = dis[v];
                q.push(nex);
            }
        }
    }
}

void init()
{
    memset(head1, -1, sizeof(head1));
    memset(head2, -1, sizeof(head2));
    tot1 = tot2 = 0;
}

void get_map()
{
    for(int i = 0; i < n; i++)
    {
        int u = i;
        for(int j = head1[i]; j != -1; j = edge1[j].next)
        {
            int v = edge1[j].to;
            ll w = edge1[j].w;
            if(dis[u]+w == dis[v])
            {
                add2(u, v, w);
                add2(v, u, 0);
            }
        }
    }
}

bool bfs(int s, int d)
{
    memset(level, -1, sizeof(level));
    level[s] = 0;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();
        if(u == d) return true;
        q.pop();
        for(int i = head2[u]; i != -1; i = edge2[i].next)
        {
            int v = edge2[i].to;
            ll w = edge2[i].w;
            if(level[v] == -1 && w)
            {
                level[v] = level[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}

ll dfs(int u, int d, ll f)
{
    if(u == d) return f;
    ll t = 0;
    ll tmp;
    for(int i = head2[u]; i != -1; i = edge2[i].next)
    {
        int v = edge2[i].to;
        ll w = edge2[i].w;
        if(w && level[v] == level[u]+1 && (tmp = dfs(v, d, min(f, w))))
        {
            edge2[i].w -= tmp;
            edge2[i^1].w += tmp;
            t += tmp;
            f -= tmp;
            if(!f) break;
        }
    }
    if(t) return t;
    level[u] = -1;
    return 0;
}

ll dinic(int s, int d)
{
    ll ans = 0;
    while(bfs(s, d))
    {
        ll tmp = dfs(s, d, inf);
        if(!tmp) break;
        ans += tmp;
    }
    return ans;
}

int main()
{
    int t, m, u, v;
    ll w;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d %d",&n,&m);
        while(m--)
        {
            scanf("%d %d %lld",&u,&v,&w);
            add1(u, v, w);
        }
        node tmp;
        tmp.to = 1;
        tmp.w = 1;
        dj(tmp);
        get_map();
        ll ans = dinic(1, n);
        cout << ans << endl;
    }
    return 0;
}