hdu 5889 Barricade

最新推荐文章于 2019-12-09 02:16:17 发布

风所在的街道

最新推荐文章于 2019-12-09 02:16:17 发布

阅读量338

点赞数

本文链接：https://blog.csdn.net/qq_30927651/article/details/52621822

版权

本文探讨了如何在网络流算法中仅沿着最短路径进行流量分配的问题，并提供了两种实现方式：一种使用Edmonds-Karp算法，另一种使用Dinic算法。通过预处理最短路径并限制搜索范围，确保了流量仅在这些关键路径上传输。

摘要由CSDN通过智能技术生成

大意：1为源点，n为汇点，在图的最短路上，跑网络流

题是很水，可是在跑完最短路上，怎么处理最短路的边使得等会跑网络流的时候只在最短路的边上跑，我试了好几种方法都感觉不太好处理

最后突然恍然大悟，跑完最短路后，，直接从汇点往源点跑网络流也是一样的效果啊

最近才刚学网络流，都敲了一遍

第一种是用EK做的，，，

第二种是用Dinic做的

听说此题会卡isap，，以后试试。。

#include<iostream>//EK得做法
#include<cstdio>
#include<math.h>
#include<algorithm>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<string.h>
#include<cstring>
#include<vector>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
#define FIN freopen("input.txt","r",stdin)
#define mem(x,y) memset(x,y,sizeof(x))
typedef unsigned long long ULL;
typedef long long LL;
#define MX 1111
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef pair<pair<int,int>,int> PIII;
typedef pair<int,int> PII;
int n,m,head[MX],rear;
int vis[MX],path[MX],d[MX];
int arr[MX];
struct Edge {
    int from,to,flow,nxt;
} edge[22222];
void edge_init() {
    rear=0;
    mem(head,-1);
}
void edge_add(int a,int b,int c) {
    edge[rear].from=a;
    edge[rear].to=b;
    edge[rear].flow=c;
    edge[rear].nxt=head[a];
    head[a]=rear++;
}
void bfs(int s) {
    mem(vis,0);
    queue<int> my;
    arr[s] = 0;
    my.push(s);
    vis[s]=1;
    while(!my.empty()) {
        int u = my.front();
        my.pop();
        for(int i = head[u]; ~i; i = edge[i].nxt) {
            int v = edge[i].to;
            if(vis[v]) continue;
            vis[v]=1;
            arr[v] = arr[u] + 1;
            my.push(v);
        }
    }
}
int EK(int s,int t) {
    int ans=0;
    while(1) {
        mem(vis,0);
        d[s]=INF;
        queue<int> my;
        my.push(s);
        vis[s]=1;
        int flag=0;
        while(!my.empty()) {
            int u=my.front();
            my.pop();
            if(u==t) {
                flag=1;
                break;
            }
            for(int i=head[u]; ~i; i=edge[i].nxt) {
                int v=edge[i].to;
                if(!edge[i].flow||vis[v]||arr[u]!=arr[v]+1) continue;
                path[v]=i;
                d[v]=min(edge[i].flow,d[u]);
                my.push(v);
                vis[v]=1;
            }
        }
        if(flag) {
            ans+=d[t];
            for(int i=t; i!=s; i=edge[path[i]].from) {
                edge[path[i]].flow-=d[t];
                edge[path[i]^1].flow+=d[t];
            }
        } else break;
    }
    return ans;
}
int main() {
    int _;
    scanf("%d",&_);
    while(_--) {
        scanf("%d%d",&n,&m);
        edge_init();
        for(int i=1; i<=m; i++) {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            edge_add(a,b,c);
            edge_add(b,a,c);
        }
        bfs(1);
        printf("%d\n",EK(n,1));
    }
    return 0;
}

</pre><pre>

#include<cstdio>//Dinic得做法
#include<math.h>
#include<algorithm>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<string.h>
#include<cstring>
#include<vector>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
#define FIN freopen("input.txt","r",stdin)
#define mem(x,y) memset(x,y,sizeof(x))
typedef unsigned long long ULL;
typedef long long LL;
#define MX 1111
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef pair<pair<int,int>,int> PIII;
typedef pair<int,int> PII;
int n,m,head[MX],rear;
int vis[MX],cur[MX],d[MX];
int arr[MX];
struct Edge
{
    int to,flow,nxt;
} edge[22222];
void edge_init()
{
    rear=0;
    mem(head,-1);
}
void edge_add(int a,int b,int c)
{
    edge[rear].to=b;
    edge[rear].flow=c;
    edge[rear].nxt=head[a];
    head[a]=rear++;
}
void bfs(int s)
{
    mem(vis,0);
    queue<int> my;
    arr[s] = 0;
    my.push(s);
    vis[s]=1;
    while(!my.empty())
    {
        int u = my.front();
        my.pop();
        for(int i = head[u]; ~i; i = edge[i].nxt)
        {
            int v = edge[i].to;
            if(vis[v]) continue;
            vis[v]=1;
            arr[v] = arr[u] + 1;
            my.push(v);
        }
    }
}
bool BFS(int s,int t)
{
    mem(vis,0);
    queue<int> my;
    my.push(s);
    vis[s]=1;
    d[s]=0;
    d[t]=-1;
    while(!my.empty())
    {
        int u=my.front();
        my.pop();
        for(int i=head[u]; ~i; i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(arr[u]!=arr[v]+1||vis[v]||!edge[i].flow) continue;
            d[v]=d[u]+1;
            vis[v]=1;
            my.push(v);
        }
    }
    return d[t]!=-1;
}
int DFS(int x,int t,int a)
{
    if(x==t||a==0) return a;
    int flow=0,f;
    for(int &i=cur[x]; ~i; i=edge[i].nxt)
    {
        int v=edge[i].to;
        if(d[v]==d[x]+1&&arr[x]==arr[v]+1&&(f=DFS(v,t,min(a,edge[i].flow)))>0)
        {
            edge[i].flow-=f;
            edge[i^1].flow+=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}
int Dinic(int s,int t)
{
    int flow=0;
    while(BFS(s,t))
    {
        memcpy(cur,head,sizeof(head));
        flow+=DFS(s,t,INF);
    }
    return flow;
}
int main()
{
    FIN;
    int _;
    scanf("%d",&_);
    while(_--)
    {
        scanf("%d%d",&n,&m);
        edge_init();
        for(int i=1; i<=m; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            edge_add(a,b,c);
            edge_add(b,a,c);
        }
        bfs(1);
        printf("%d\n",Dinic(n,1));
    }
    return 0;
}