hdu 6852Path6（最短路+最小割）

传送门

•题意

有n个城市，标号1-n

现花费最小的代价堵路

使得从1号城市到n号城市的路径边长

（注意只是变长不是最长）

堵一条路的代价是这条路的权值

•思路

在堵路以前，从1到n的最小路径当然是最短路

想要路径边长就要在最短路上动手脚

把从1到n的最短路找出来形成一个最短路图，

然后用最小的代价使得最短路图不连通

也就是求这个最短路图的最小割

那怎么建这个最短路图呢？

分别以1和n为源点跑一遍dijkstra,找出每个点到1和n的最短路

设$dis[1][i]$为1到i的最短路，$dis[n][i]$为i到n的最短路

$1->u->v->n$是$1->n$的一条最短路即$dis[1][u]+w[u->v]+dis[n][v]=dis[1][n]$

那么，u->v是1->n最短路上的一条边，加入最短路图中

（由于代码被某人嫌弃太乱，所以对dijkstra和dinic封装了一下...）

•代码

(未封装版)

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f
#define P pair<long long,int>
const int maxn=1e5+5;
int n,m;
struct Edge
{
    int v;
    ll w;
    int next;
}de[maxn],fe[maxn],e[maxn];

int head1[maxn],head2[maxn];
int cnt1,cnt2;
void add(int u,int v,ll w)
{
    de[++cnt1]={v,w,head1[u]};
    head1[u]=cnt1;

    fe[++cnt2]={u,w,head2[v]};
    head2[v]=cnt2;
}

ll dis1[maxn],disn[maxn];
bool vis1[maxn],visn[maxn];
priority_queue<P,vector<P>,greater<P> >pq;

void dijkstra()
{
    while(!pq.empty())
        pq.pop();
    for(int i=1;i<=n;i++)
        dis1[i]=INF,vis1[i]=0;
    dis1[1]=0;
    pq.push(make_pair(0,1));
    while(!pq.empty())
    {
        int u=pq.top().second;
        pq.pop();
        if(!vis1[u])
        {
            vis1[u]=1;
            for(int i=head1[u];~i;i=de[i].next)
            {
                int v=de[i].v;
                dis1[v]=min(dis1[v],dis1[u]+de[i].w);
                pq.push(make_pair(dis1[v],v));
            }
        }
    }

    while(!pq.empty())
        pq.pop();
    for(int i=1;i<=n;i++)
        disn[i]=INF,visn[i]=0;
    disn[n]=0;

    pq.push(make_pair(0,n));
    while(!pq.empty())
    {
        int u=pq.top().second;
        pq.pop();
        if(!visn[u])
        {
            visn[u]=1;
            for(int i=head2[u];~i;i=fe[i].next)
            {
                int v=fe[i].v;
                disn[v]=min(disn[v],disn[u]+fe[i].w);
                pq.push(make_pair(disn[v],v));
            }
        }
    }
}

int head[maxn],cnt;
int cur[maxn],d[maxn];
void addEdge(int u,int v,ll w)
{
    e[++cnt]={v,w,head[u]};
    head[u]=cnt;

    e[++cnt]={u,0,head[v]};
    head[v]=cnt;
}

bool bfs()
{
    queue<int> q;
    for(int i=1;i<=n;i++)
        d[i]=-1;
    d[1]=0;
    q.push(1);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];~i;i=e[i].next)
        {
            int v=e[i].v;
            if(d[v]==-1&&e[i].w>0)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[n]!=-1;
}

ll dfs(int u,ll flow)
{
    ll nowflow=0;
    if(u==n) return flow;
    for(int i=cur[u];~i;i=e[i].next)
    {
        cur[u]=i;
        int v=e[i].v;
        if(d[v]==d[u]+1&&e[i].w>0)
        {
            ll k=dfs(v,min(flow-nowflow,e[i].w));
            if(k)
            {
                nowflow+=k;
                e[i].w-=k;
                e[i^1].w+=k;
                if(nowflow==flow)
                    break;
            }
        }
    }
    if(!nowflow) d[u]=-2;
    return nowflow;
}

ll Dinic()
{
    ll ans=0;
    while(bfs())
    {
        for(int i=1;i<=n;i++)
            cur[i]=head[i];

        ans+=dfs(1,INF);
    }
    return ans;
}



void Init()
{
    mem(head1,-1);
    mem(head2,-1);
    mem(head,-1);
    cnt1=cnt2=cnt=-1;
}

int main()
{
//    freopen("C:\Users\14685\Desktop\C++workspace\in&out\contest","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        Init();
        for(int i=1;i<=m;i++)
        {
            int u,v;
            ll w;
            scanf("%d%d%lld",&u,&v,&w);
            add(u,v,w);
        }

        dijkstra();

        for(int u=1;u<=n;u++)
        {
            for(int i=head1[u];~i;i=de[i].next)
            {
                int v=de[i].v;
                if(dis1[u]+disn[v]+de[i].w==dis1[n])
                {
//                    printf("***%d %d %d
",u,v,de[i].w);
                    addEdge(u,v,de[i].w);
                }
            }
        }

        printf("%lld
",Dinic());
    }
}

(封装版)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pli pair<ll,int>
#define INF 0x3f3f3f3f3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=1e5+5;
int n,m;
struct Edge
{
    int v;
    ll w;
    int next;
}G[maxn<<1],e[maxn<<1];
int dhead[maxn],dcnt;
void addEdge(int u,int v,ll w)
{
    G[++dcnt]={v,w,dhead[u]};
    dhead[u]=dcnt;
}

struct Dij
{
    ll dis[2][maxn];
    bool vis[maxn];
    priority_queue<pli,vector<pli>,greater<pli> > q;
    void dij(int s,int n,bool ok)
    {
        for(int i=1;i<=n;i++)
            dis[ok][i]=INF,vis[i]=0;
        dis[ok][s]=0;
        q.push({0,s});
        while(!q.empty())
        {
            int u=q.top().second;
            q.pop();
            if(vis[u])
                continue;
            vis[u]=1;
            for(int i=dhead[u];~i;i=G[i].next)
            {
                ///偶数是正向边,ok=true是正向边
                if(ok && i&1)
                    continue;
                ///奇数是反向边,ok=false是反向边
                if(!ok && !(i&1))
                    continue;

                int v=G[i].v;
                ll w=G[i].w;
                if(dis[ok][v]>dis[ok][u]+w)
                {
                    dis[ok][v]=dis[ok][u]+w;
                    if(!vis[v])
                        q.push({dis[ok][v],v});
                }
            }
        }
    }
}dij;

int head[maxn],cnt;
void add(int u,int v,ll w)
{
    e[++cnt]={v,w,head[u]};
    head[u]=cnt;
}
struct Dinic
{
    int cur[maxn],d[maxn];
    int s=1,t=n;
    bool bfs()
    {
        queue<int> q;
        for(int i=1;i<=n;i++)
            d[i]=-1;
        d[1]=0;
        q.push(1);
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            for(int i=head[u];~i;i=e[i].next)
            {
                int v=e[i].v;
                if(d[v]==-1&&e[i].w>0)
                {
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        return d[n]!=-1;
    }

    ll dfs(int u,ll flow)
    {
        ll nowflow=0;
        if(u==n) return flow;
        for(int i=cur[u];~i;i=e[i].next)
        {
            cur[u]=i;
            int v=e[i].v;
            if(d[v]==d[u]+1&&e[i].w>0)
            {
                ll k=dfs(v,min(flow-nowflow,e[i].w));
                if(k)
                {
                    nowflow+=k;
                    e[i].w-=k;
                    e[i^1].w+=k;
                    if(nowflow==flow)
                        break;
                }
            }
        }
        if(!nowflow) d[u]=-2;
        return nowflow;
    }

    ll din()
    {
        ll ans=0;
        while(bfs())
        {
            for(int i=1;i<=n;i++)
                cur[i]=head[i];

            ans+=dfs(1,INF);
        }
        return ans;
    }
}_din;

void Init()
{
    mem(dhead,-1);
    dcnt=-1;
    mem(head,-1);
    cnt=-1;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        Init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
        {
            int u,v;
            ll w;
            scanf("%d%d%lld",&u,&v,&w);
            ///跑1到其他点的最短路 加正向边
            addEdge(u,v,w);
            ///跑n到其他点的最短路 加反向边
            addEdge(v,u,w);
        }

        dij.dij(1,n,true);
        dij.dij(n,n,false);


        for(int u=1;u<=n;u++)
        {
            for(int i=dhead[u];~i;i=G[i].next)
            {
                int v=G[i].v;
                ll w=G[i].w;
                if(dij.dis[1][u]+dij.dis[0][v]+w==dij.dis[1][n])
                {
                    add(u,v,w);
                    add(v,u,0);
                }
            }
        }
        printf("%lld
",_din.din());
    }
}