2019HDU多校一 E (最短路＋最小割)

谁能想到签到题是个最短路＋网络流？？

题目
题意：给出一个图，切掉某些边后１～ｎ的最短路变长，求割掉的最小价值

题解：
以1为起点跑一遍最短路
以n为起点再跑一遍。
将满足$dis1[v]+dis2[u]+w=minroad$的边建图跑个最小割就是答案。

#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int maxm = 2e5 + 5;
const int maxn = 1e5 + 5;
const ll inf = 1e18;
struct node
{
    int u,next,to;
    ll w;
}edge[2][maxm];
struct node2
{
    int id;
    ll dis;
    bool friend operator < (node2 a,node2 b)
    {
        return a.dis > b.dis;
    }
};
int head[2][maxn],cnt[2];
ll d[2][maxn];
void add(int u,int v,ll w,int kind)
{
    edge[kind][cnt[kind]].u = u;
    edge[kind][cnt[kind]].to = v;
    edge[kind][cnt[kind]].w = w;
    edge[kind][cnt[kind]].next = head[kind][u];
    head[kind][u] = cnt[kind]++;
}
priority_queue<node2>q;
void dij(int s,int kind)
{
    while(!q.empty())
        q.pop();
    d[kind][s] = 0;
    node2 p;
    p.id = s;
    p.dis = 0;
    q.push(p);
    while(!q.empty())
    {
        node2 temp = q.top();
        q.pop();
        int u = temp.id;
        for(int i = head[kind][u];i != -1;i = edge[kind][i].next)
        {
            int v = edge[kind][i].to;
            ll w = edge[kind][i].w;
            if(d[kind][v] > d[kind][u] + w)
            {
                d[kind][v] = d[kind][u] + w;
                node2 now;
                now.id = v;
                now.dis = d[kind][v];
                q.push(now);
            }
        }
    }
}
void init(int n)
{
    int i;
    cnt[0] = cnt[1] = 0;
    for(i = 0;i <= n;i++)
    {
        head[1][i] = head[0][i] = -1;
        d[0][i] = inf;
        d[1][i] = inf;
    }
}
//以上最短路


struct node_d
{
    int v,next;
    ll flow;
}edge_d[maxm * 2];
int dep[maxn],Q[maxn],head_d[maxn],cnt_d;
void init_d(int n)
{
    for(int i = 0;i <= n;i++)
        head_d[i] = -1;
    cnt_d = 0;

}
void add_d(int u,int v,ll w)
{
    edge_d[cnt_d].v = v;
    edge_d[cnt_d].flow = w;
    edge_d[cnt_d].next = head_d[u];
    head_d[u] = cnt_d++;
}
bool bfs(int s,int t,int n)
{
    memset(dep,-1,sizeof(dep));
    int front = 0,tail = 0,v;
    Q[tail++] = s;
    dep[s] = 0;
    while(front < tail)
    {
        int u = Q[front++];
        for(int i = head_d[u];i != -1;i = edge_d[i].next)
        {
            v = edge_d[i].v;
            if(edge_d[i].flow && dep[v] == -1)
            {
                dep[v] = dep[u] + 1;
                if(v == t)
                    return true;
                Q[tail++] = v;
            }
        }
    }
    return false;
}
ll dfs(int u,int t,ll flw,int n)
{
    if(u == t || !flw)
        return flw;
    ll temp = 0,increase;
    int v;
    for(int i = head_d[u];i != -1;i = edge_d[i].next)
    {
        v = edge_d[i].v;
        if(edge_d[i].flow && dep[u] + 1 == dep[v])
        {
            increase = dfs(v , t , min(flw - temp,edge_d[i].flow) ,n );
            edge_d[i].flow -= increase;
            edge_d[i^1].flow += increase;
            temp += increase;
            if(temp == flw)
                break;
        }
    }
    return temp;
}
ll dinic(int s,int t,int n)
{
    ll maxflow=0;
    while(bfs(s,t,n))
    {
        maxflow += dfs(s,t,inf,n);
    }
    return maxflow;
}


int main()
{
    int n,m,t;//printf("%lld\n",inf);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init(n);
        int u,v;
        ll w;
        for(int i = 1;i <= m;i++)
        {
            scanf("%d%d%lld",&u,&v,&w);
            add(u,v,w,0);
            add(v,u,w,1);
        }
        dij(1,0);
        dij(n,1);

        init_d(n);

        for(int i = 0;i < cnt[0];i++)
        {
            u = edge[0][i].u;
            v = edge[0][i].to;
            if(d[0][u] + d[1][v] + edge[0][i].w == d[0][n])
            {
                add_d(u,v,edge[0][i].w);
                add_d(v,u,0);
            }
        }

        printf("%lld\n",dinic(1,n,n));
    }
    return 0;
}