ISAP算法

兜率工

于 2018-07-19 10:24:18 发布

阅读量823

点赞数

分类专栏：模板图论

本文链接：https://blog.csdn.net/qq_40679299/article/details/81110756

版权

模板同时被 2 个专栏收录

119 篇文章 4 订阅

订阅专栏

图论

104 篇文章 0 订阅

订阅专栏

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define MAXN 205
#define MAXM 1000
#define INF 0x3f3f3f3f

struct Edge {
    int v,c,next;
} e[MAXM];

int eid,NV;
int p[MAXN];

void insert(int u,int v,int c){ //插入一条从u向v，容量为c的弧。
    e[eid].v=v;
    e[eid].next=p[u];
    e[eid].c=c;
    p[u]=eid++;
}
 
void addedge(int u,int v,int c){ //用insert插入网络中的弧
    insert(u,v,c);
    insert(v,u,0);                  //插入一条反方向，当前容量为0的弧
}

int d[MAXN];
int num[MAXN];

void bfs(int vt)
{
    memset(d,-1,sizeof(d));
    memset(num,0,sizeof(num));
    d[vt]=0;
    num[d[vt]]++;
    queue<int>que;
    que.push(vt);
    while(!que.empty()) {
        int u=que.front();
        que.pop();
        for(int i=p[u]; i!=-1; i=e[i].next) {
            int v=e[i].v;
            if(d[v]!=-1)continue;
            d[v]=d[u]+1;
            num[d[v]]++;
            que.push(v);

        }
    }
}

int pre[MAXN];
int cur[MAXN];

int SAP(int s,int t)
{
    bfs(t);
    memset(pre,-1,sizeof(pre));
    memcpy(cur,p,sizeof(p));
    int u=pre[s]=s,flow=0,aug=INF;
    num[0]=NV;
    while(d[s]<NV) {
        bool flag=false;
        for(int &i=cur[u]; i!=-1; i=e[i].next) {
            int v=e[i].v;
            if(e[i].c&&d[u]==d[v]+1) {
                flag=true;
                pre[v]=u;
                u=v;
                aug=min(aug,e[i].c);
                if(v==t) {
                    flow+=aug;
                    for(u=pre[v]; v!=s; v=u,u=pre[u]) {
                        e[cur[u]].c-=aug;
                        e[cur[u]^1].c+=aug;
                    }
                    aug=INF;
                }
                break;
            }
        }
        if(flag)continue;
        int minlevel=NV;
        for(int i=p[u]; i!=-1; i=e[i].next) {
            int v=e[i].v;
            if(e[i].c&&d[v]<minlevel) {
                minlevel=d[v];
                cur[u]=i;
            }
        }
        if(--num[d[u]]==0)break;
        d[u]=minlevel+1;
        num[d[u]]++;
        u=pre[u];
    }
    return flow;
}

int main()
{
    int u,v,w,m,n,s,t;
    while(cin>>m>>n){
    	s=1,t=n,NV=n,eid=0;
	    memset(p,-1,sizeof(p));
	    while(m--){
	    	scanf("%d%d%d",&u,&v,&w);
        	addedge(u,v,w);
		}
		printf("%d\n",SAP(s,t));
	}
    return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define MAXN 205
#define MAXM 1000
#define INF 0x3f3f3f3f

struct Edge {
    int v,c,next;
} e[MAXM];

int eid,NV;
int p[MAXN];

void insert(int u,int v,int c){ //插入一条从u向v，容量为c的弧。
    e[eid].v=v;
    e[eid].next=p[u];
    e[eid].c=c;
    p[u]=eid++;
}

void addedge(int u,int v,int c){ //用insert插入网络中的弧
    insert(u,v,c);
    insert(v,u,0);                  //插入一条反方向，当前容量为0的弧
}

int gap[MAXN];
int dis[MAXN];
int cur[MAXN];
int pre[MAXN];
int rec[MAXN];
int S,T;                             //S是源点，T是汇点。

void BFS()
{
    int i;
    for(i = 0; i <= T; i++) dis[i] = INF;
    queue<int> q;
    q.push(T);
    dis[T] = 0;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        gap[dis[u]]++;
        for(i = p[u]; i != -1; i = e[i].next)
        {
            int v = e[i].v;
            if(dis[v] == INF && e[i^1].c)
            {
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
}


int SAP()
{
    int i;
    int u = pre[S] = S, Maxflow = 0, flow = INF;

    for(i = 0; i <= T; i++)//这里 T 为最大顶点编号
    {
        gap[i] = 0;
        cur[i] = p[i];
    }
    BFS();
    while(dis[S] <= T)
    {
        if(u == T)
        {
            Maxflow += flow;
            for(; u != S; u = pre[u])
            {
                e[rec[u]].c -= flow;
                e[rec[u]^1].c += flow;
            }
            flow = INF;
        }

        for(i = cur[u]; i != -1; i = e[i].next)
        {
            int v = e[i].v;
            if(e[i].c && dis[u] == dis[v] + 1)
            {
                flow = min(flow, e[i].c);
                pre[v] = u;
                rec[v] = i;
                cur[u] = i;//当前弧优化
                u = v;
                break;
            }
        }
        if(i == -1)
        {
            int mindis = T + 1;//T是顶点数
            if((--gap[dis[u]]) == 0) break;//间隙优化
            for(i = cur[u] = p[u]; i != -1; i = e[i].next)
            {
                if(e[i].c && mindis > dis[e[i].v])
                {
                    mindis = dis[e[i].v];
                }
            }
            gap[dis[u] = mindis+1]++;
            u = pre[u];
        }
    }
    return Maxflow;
}

int main()
{
    int u,v,w,m,n;
    while(cin>>m>>n){
    	S=1,T=n,NV=n,eid=0;
	    memset(p,-1,sizeof(p));
	    while(m--){
	    	scanf("%d%d%d",&u,&v,&w);
        	addedge(u,v,w);
		}
		printf("%d\n",SAP());
	}
    return 0;
}


using namespace std;
 
#define N 1000
#define INF 100000000
struct Edge
{
    int from,to,cap,flow;
};
 
struct ISAP
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[N];
    bool vis[N];
    int d[N],cur[N];
    int p[N],num[N];//比Dinic算法多了这两个数组，p数组标记父亲结点，num数组标记距离d[i]存在几个
    void addedge(int from,int to,int cap)
    {
        edges.push_back((Edge){from,to,cap,0});
        edges.push_back((Edge){to,from,0,0});
        int m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
 
    int Augumemt()
    {
        int x=t,a=INF;
        while(x!=s)//找最小的残量值
        {
            Edge&e=edges[p[x]];
            a=min(a,e.cap-e.flow);
            x=edges[p[x]].from;
        }
        x=t;
        while(x!=s)//增广
        {
            edges[p[x]].flow+=a;
            edges[p[x]^1].flow-=a;
            x=edges[p[x]].from;
        }
        return a;
    }
    void bfs()//逆向进行bfs
    {
        memset(vis,0,sizeof(vis));
        queue<int>q;
        q.push(t);
        d[t]=0;
        vis[t]=1;
        while(!q.empty())
        {
            int x=q.front();q.pop();
            int len=G[x].size();
            for(int i=0;i<len;i++)
            {
                Edge&e=edges[G[x][i]];
                if(!vis[e.from]&&e.cap>e.flow)
                {
                    vis[e.from]=1;
                    d[e.from]=d[x]+1;
                    q.push(e.from);
                }
            }
        }
    }
 
    int Maxflow(int s,int t)//根据情况前进或者后退，走到汇点时增广
    {
        this->s=s;
        this->t=t;
        int flow=0;
        bfs();
        memset(num,0,sizeof(num));
        for(int i=0;i<n;i++)
            num[d[i]]++;
        int x=s;
        memset(cur,0,sizeof(cur));
        while(d[s]<n)
        {
            if(x==t)//走到了汇点，进行增广
            {
                flow+=Augumemt();
                x=s;//增广后回到源点
            }
            int ok=0;
            for(int i=cur[x];i<G[x].size();i++)
            {
                Edge&e=edges[G[x][i]];
                if(e.cap>e.flow&&d[x]==d[e.to]+1)
                {
                    ok=1;
                    p[e.to]=G[x][i];//记录来的时候走的边，即父边
                    cur[x]=i;
                    x=e.to;//前进
                    break;
                }
            }
            if(!ok)//走不动了，撤退
            {
                int m=n-1;//如果没有弧，那么m+1就是n，即d[i]=n
                for(int i=0;i<G[x].size();i++)
                {
                    Edge&e=edges[G[x][i]];
                    if(e.cap>e.flow)
                        m=min(m,d[e.to]);
                }
                if(--num[d[x]]==0)break;//如果走不动了，且这个距离值原来只有一个，那么s-t不连通，这就是所谓的“gap优化”
                num[d[x]=m+1]++;
                cur[x]=0;
                if(x!=s)
                    x=edges[p[x]].from;//退一步，沿着父边返回
            }
        }
        return flow;
    }
};
int main()
{
//    freopen("t.txt","r",stdin);
    ISAP sap;
    while(cin>>sap.n>>sap.m)
    {
        for(int i=0;i<sap.m;i++)
        {
            int from,to,cap;
            cin>>from>>to>>cap;
            sap.addedge(from,to,cap);
        }
        cin>>sap.s>>sap.t;
        cout<<sap.Maxflow(sap.s,sap.t)<<endl;
    }
    return 0;
}