主人~别揉了~尿了～啊哈视频,最近中文字幕mv在线资源,男女性动态激烈动全过程

源點：有n個點，有m條有向邊，有一個點很特殊，只出不進，叫做源點。
匯點：另一個點也很特殊，只進不出，叫做匯點。
容量和流量：每條有向邊上有兩個量，容量和流量，從i到j的容量通常用c[i,j]表示,流量則通常是f[i,j].

通常可以把這些邊想象成道路，流量就是這條道路的車流量，容量就是道路可承受的最大的車流量。很顯然的，流量<=容量。而對于每個不是源點和匯點的點來說，可以類比的想象成沒有存儲功能的貨物的中轉站，所有“進入”他們的流量和等于所有從他本身“
出去”的流量。

最大流：把源點比作工廠的話，問題就是求從工廠最大可以發出多少貨物，是不至于超過道路的容量限制，也就是，最大流。

網絡流基礎篇——Edmond-Karp算法

求解思路：
首先，假如所有邊上的流量都沒有超過容量(不大于容量)，那么就把這一組流量，或者說，這個流，稱為一個可行流。
一個最簡單的例子就是，零流，即所有的流量都是0的流。

(1).我們就從這個零流開始考慮，假如有這么一條路，這條路從源點開始一直一段一段的連到了
匯點，并且，這條路上的每一段都滿足流量<容量，注意，是嚴格的<,而不是<=。
(2).那么，我們一定能找到這條路上的每一段的(容量-流量)的值當中的最小值delta。我們把這條路上每一段的流量都加上這個delta，一定可以保證這個流依然是可行流，這是顯然的。
(3).這樣我們就得到了一個更大的流，他的流量是之前的流量+delta，而這條路就叫做增廣路。我們不斷地從起點開始尋找增廣路，每次都對其進行增廣，直到源點和匯點不連通，也就是找不到增廣路為止。
(4).當找不到增廣路的時候，當前的流量就是最大流，這個結論非常重要。

補充：

(1).尋找增廣路的時候我們可以簡單的從源點開始做BFS，并不斷修改這條路上的delta 量，直到找到源點或者找不到增廣路。
(2).在程序實現的時候，我們通常只是用一個c 數組來記錄容量，而不記錄流量，當流量+delta 的時候，我們可以通過容量-delta 來實現，以方便程序的實現。

相關問題：

為什么要增加反向邊？
在做增廣路時可能會阻塞后面的增廣路，
或者說，做增廣路本來是有個順序才能找完最大流的。

但我們是任意找的，為了修正，就每次將流量加在了反向弧上，讓后面的流能夠進行自我調整。

舉例：
比如說下面這個網絡流模型

2017-08-16 11-37-02.png

我們第一次找到了1-2-3-4這條增廣路，這條路上的delta值顯然是1。
于是我們修改后得到了下面這個流。（圖中的數字是容量）

2017-08-16 11-38-05.png

這時候(1,2)和(3,4)邊上的流量都等于容量了，我們再也找不到其他的增廣路了，當前的流量是1。

但是，

這個答案明顯不是最大流，因為我們可以同時走1-2-4和1-3-4，這樣可以得到流量為2的流。

那么我們剛剛的算法問題在哪里呢？

問題就在于我們沒有給程序一個“后悔”的機會，應該有一個不走(2-3-4)而改走(2-4)的機制。

那么如何解決這個問題呢？

我們利用一個叫做反向邊的概念來解決這個問題。即每條邊(i,j)都有一條反向邊(j,i)，反向邊也同樣有它的容量。
我們直接來看它是如何解決的：
在第一次找到增廣路之后，在把路上每一段的容量減少delta的同時，也把每一段上的反方向的容量增加delta。

c[x,y]-=delta;

c[y,x]+=delta;

我們來看剛才的例子，在找到1-2-3-4這條增廣路之后，把容量修改成如下：

2017.jpg

這時再找增廣路的時候，就會找到1-3-2-4這條可增廣量，即delta值為1的可增廣路。將這條路增廣之后，得到了最大流2。

2017.jpg

那么，這么做為什么會是對的呢？

事實上，當我們第二次的增廣路走3-2這條反向邊的時候，就相當于把2-3這條正向邊已經是用了的流量給“退”了回去，不走2-3這條路，而改走從2點出發的其他的路也就是2-4。

如果這里沒有2-4怎么辦？

這時假如沒有2-4這條路的話，最終這條增廣路也不會存在，因為他根本不能走到匯點
同時本來在3-4上的流量由1-3-4這條路來“接管”。而最終2-3這條路正向流量1，反向流量1，等于沒有流。

A - Drainage Ditches
一道網絡流裸題

Edmonds_Karp 算法鄰接矩陣

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN=205;
const int INF=0x3f3f3f3f;
int graph[MAXN][MAXN];
int pre[MAXN];
int vis[MAXN];
int n,m;
int BFS(int st,int ed)
{
    memset(vis,0,sizeof(vis));
    queue<int> que;
    que.push(st);
    vis[st]=1;
    int curr,flow=INF;
    pre[st]=pre[ed]=-1;
    while(!que.empty())
    {
        curr=que.front();
        que.pop();
        if(curr==ed) break;
        for(int nxt=1;nxt<=n;nxt++)
        {
            if(vis[nxt]==0&&graph[curr][nxt]!=0)
            {
                vis[nxt]=1;
                if(flow>graph[curr][nxt]) flow=graph[curr][nxt];
                pre[nxt]=curr;
                que.push(nxt);
            }
        }
    }
    if(pre[ed]==-1) return 0;
    return flow;
}
int Edmonds_Karp(int st,int ed)
{
    int stream;
    int sum=0;
    while((stream=BFS(st,ed))!=0)
    {
        int u=ed;
        while(pre[u]!=-1)
        {
            graph[pre[u]][u]-=stream;
            graph[u][pre[u]]+=stream;
            u=pre[u];
        }
        sum+=stream;
    }
    return sum;
}
int main()
{
    int a,b,flow;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(graph,0,sizeof(graph));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&flow);
            graph[a][b]+=flow;
            //注意,這里的a,b節點都是獨一無二的節點(包含分裂的節點)
            //比如原來有x個節點,通過分裂這x個節點構圖,那么n=2*x,即有2*x個不同的節點
        }
        printf("%d\n",Edmonds_Karp(1,n));
    }
}

Edmonds_Karp算法前向星

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN=1010;
const int MAXE=5010;
const int INF=0x3f3f3f3f;
int head[MAXN],cnt;
struct Node
{
    int to,next,val;
    Node(){}
    Node(int to,int next,int val):to(to),next(next),val(val){}
};
Node edge[MAXE];
void addEdge(int u,int v,int val)
{
    edge[cnt]=Node(v,head[u],val);
    head[u]=cnt++;
    edge[cnt]=Node(u,head[v],0);
    head[v]=cnt++;
}
int vis[MAXN],pre[MAXN];
int BFS(int st,int ed)
{
    memset(vis,0,sizeof(vis));
    vis[st]=1;
    queue<int> que;
    que.push(st);
    int u,v,flow=INF;
    pre[st]=pre[ed]=-1;
    while(!que.empty())
    {
        u=que.front();
        que.pop();
        if(u==ed) break;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            v=edge[i].to;
            if(vis[v]==0&&edge[i].val>0)
            {
                vis[v]=1;
                flow=min(flow,edge[i].val);
                pre[v]=i;//注意尋路方式
                que.push(v);
            }
        }
    }
    if(pre[ed]==-1) return 0;
    return flow;
}
int Edmonds_Karp(int st,int ed)
{
    int stream,flow=0;
    while((stream=BFS(st,ed))!=0)
    {   //pre通過節點存邊的坐標,通過邊的反向邊的to獲取上一個節點
        for(int i=pre[ed];i!=-1;i=pre[edge[i^1].to])
        {
            edge[i].val-=stream;
            edge[i^1].val+=stream;
        }
        flow+=stream;
    }
    return flow;
}
int main()
{
    int a,b,n,m,flow;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(head,-1,sizeof(head));
        cnt=0;
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&flow);
            addEdge(a,b,flow);
        }
        printf("%d\n",Edmonds_Karp(1,n));
    }
    return 0;
}

Edmonds_Karp算法很難用鄰接表描述,因為通過BFS得出一個pre數組,但是pre數組給出的某個頂點u和它的前一個頂點v,理論上我們要為v --> u 這條邊減去相應的容量,u --> v這條邊要添加相應的容量,但是我們不知道這兩條邊在鄰接表的位置;解決辦法有另開一個二維數組存儲u-->v和v-->u在鄰接表的位置,這樣子還不如用鄰接矩陣劃算...
Ford_Fulkerson算法鄰接矩陣

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int INF=0x7fffffff;
const int MAXN=205;
int graph[MAXN][MAXN];
int vis[MAXN];
int n,m;
int dfs(int st,int ed,int f)
{
    vis[st]=1;
    if(st==ed) return f;
    for(int i=1;i<=n;i++)
    {
        if(graph[st][i]>0&&vis[i]==0)
        {
            int d=dfs(i,ed,min(graph[st][i],f));
            if(d>0)
            {
                graph[st][i]-=d;
                graph[i][st]+=d;
                return d;
            }
        }
    }
    return 0;
}
int Ford_Fulkerson(int st,int ed)
{
    int flow=0,curr;
    while(true)
    {
        memset(vis,0,sizeof(vis));
        curr=dfs(st,ed,INF);
        if(curr==0) return flow;
        flow+=curr;
    }
}
int main()
{
    int a,b,val;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(graph,0,sizeof(graph));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&val);
            graph[a][b]+=val;
        }
        printf("%d\n",Ford_Fulkerson(1,n));
    }
    return 0;
}

Ford_Fulkerson算法鄰接表

#include <cstdio>
#include <cstring>
#include <algorithm>
#include<vector>
using namespace std;
const int INF=0x7fffffff;
const int MAXN=205;
struct Node
{
    int to;
    int flow;
    int rev;//反向邊在數組的位置
    Node(){}
    Node(int to,int flow,int rev):to(to),flow(flow),rev(rev){}
};
vector<Node> graph[MAXN];
int vis[MAXN];
int n,m;
void addEdge(int from,int to,int val)
{
    graph[from].push_back(Node(to,val,graph[to].size()));
    graph[to].push_back(Node(from,0,graph[from].size()-1));//反向邊的流量為0
}
int dfs(int st,int ed,int f)
{
    vis[st]=1;
    if(st==ed) return f;
    for(int i=0;i<graph[st].size();i++)
    {
        Node &temp=graph[st][i];//必須用引用
        if(vis[temp.to]==0&&temp.flow>0)
        {
            int d=dfs(temp.to,ed,min(f,temp.flow));
            if(d>0)
            {
                temp.flow-=d;
                graph[temp.to][temp.rev].flow+=d;
                return d;
            }
        }
    }
    return 0;
}
int Ford_Fulkerson(int st,int ed)
{
    int flow=0,curr;
    while(true)
    {
        memset(vis,0,sizeof(vis));
        curr=dfs(st,ed,INF);
        if(curr==0) return flow;
        flow+=curr;
    }
}
int main()
{
    int a,b,val;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            graph[i].clear();
        }
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&val);
            addEdge(a,b,val);
        }
        printf("%d\n",Ford_Fulkerson(1,n));
    }
    return 0;
}

Ford_Fulkerson算法前向星

#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=210;
const int INF=0x7fffffff;
struct Node
{
    int to;
    int next;
    int c;
};
Node Edge[MAXN*2];
int head[MAXN];
int vis[MAXN];
int cnt;
void addEdge(int u,int v,int val)
{
    Edge[cnt].to=v;
    Edge[cnt].c=val;
    Edge[cnt].next=head[u];
    head[u]=cnt++;
    Edge[cnt].to=u;//添加反向邊,流量為0
    Edge[cnt].c=0;
    Edge[cnt].next=head[v];
    head[v]=cnt++;
}
int DFS(int st,int ed,int f)
{
    vis[st]=1;
    if(st==ed) return f;
    for(int i=head[st];i!=-1;i=Edge[i].next)
    {
        if(Edge[i].c>0&&vis[Edge[i].to]==0)
        {
            int d=DFS(Edge[i].to,ed,min(Edge[i].c,f));
            if(d>0)
            {
                Edge[i].c-=d;
                Edge[i^1].c+=d;//添邊的時候反向邊正好在數組的相鄰位置,所以i^1是取反向邊
                return d;
            }
        }
    }
    return 0;
}
int Ford_Fulkerson(int st,int ed)
{
    int flow=0,d,u;
    while(true)
    {
        memset(vis,0,sizeof(vis));
        d=DFS(st,ed,INF);
        if(d==0) break;
        flow+=d;
    }
    return flow;
}
int main()
{
    int n,m,a,b,val;
    while(scanf("%d%d",&m,&n)!=EOF)
    {

        memset(head,-1,sizeof(head));
        cnt=0;
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&val);
            addEdge(a,b,val);
        }
        printf("%d\n",Ford_Fulkerson(1,n));
    }
}

Dinic算法鄰接矩陣

#include <cstdio>
#include <string.h>
#include <queue>
#include<cstring>
using namespace std;
const int INF = 0x7fffffff;
const int MAX = 205;
int c[MAX][MAX];
int step[MAX];
int n,m;
bool BFS(int st,int ed)
{
    memset(step,-1,sizeof(step));
    queue<int> que;
    step[st]=0;
    que.push(st);
    while(!que.empty())
    {
        int curr=que.front();
        que.pop();
        for(int i=1;i<=n;i++)
        {
            if(c[curr][i]>0&&(step[i]==-1))//i沒訪問過
            {
                step[i]=step[curr]+1;
                if(i==ed) return true;
                que.push(i);
            }
        }
    }
    return step[ed]!=-1;
}
int DFS(int st,int ed,int f)
{
    if(st==ed||f==0) return f;
    int flow=0,d;
    for(int i=1;i<=n;i++)
    {
        if((step[i]==step[st]+1)&&c[st][i]>0&&(d=DFS(i,ed,min(c[st][i],f))))
        {
                c[st][i]-=d;
                c[i][st]+=d;
                flow+=d;         //累加當前節點的某條路徑的合適流量
                f-=d;            //當前節點的容量減去某條路徑的合適流量
                if(f==0) break;  //如果當前節點的容量用完,說明無法再通過任何流量
        }
    }
    if(flow==0) step[st]=INF;//如果當前節點無任何流量通過,取消標記
    return flow;
}
int Dinic(int st,int ed)
{
    int flow=0;
    while(BFS(st,ed))
    {
        flow+=DFS(st,ed,INF);
    }
    return flow;
}
int main()
{
    int a,b,flow;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(c,0,sizeof(c));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&flow);
            c[a][b]+=flow;
        }
        printf("%d\n",Dinic(1,n));
    }
    return 0;
}

Dinic算法鄰接表

#include <cstdio>
#include <queue>
#include<cstring>
#include<vector>
using namespace std;
const int INF = 0x7fffffff;
const int MAX = 205;
int step[MAX];
struct Node
{
    int to;
    int flow;
    int rev;//記錄反向邊的index
    Node(){}
    Node(int to,int flow,int rev):to(to),flow(flow),rev(rev){}
};
vector<Node> graph[MAX];
int n,m;
void addEdge(int from,int to,int flow)
{
    graph[from].push_back(Node(to,flow,graph[to].size()));
    graph[to].push_back(Node(from,0,graph[from].size()-1));
}
bool BFS(int st,int ed)
{
    memset(step,-1,sizeof(step));
    queue<int> que;
    que.push(st);
    step[st]=0;
    while(!que.empty())
    {
        int curr=que.front();
        que.pop();
        for(int i=0;i<graph[curr].size();i++)
        {
            Node &temp=graph[curr][i];
            if(step[temp.to]==-1&&temp.flow>0)
            {
                step[temp.to]=step[curr]+1;
                if(temp.to==ed) return true;
                que.push(temp.to);
            }
        }
    }
    return step[ed]!=-1;
}
int DFS(int st,int ed,int f)
{
    if(st==ed||f==0) return f;
    int flow=0;
    for(int i=0;i<graph[st].size();i++)
    {
        Node &temp=graph[st][i];
        if(temp.flow>0&&step[temp.to]==step[st]+1)
        {
            int d=DFS(temp.to,ed,min(f,temp.flow));
            if(d>0)
            {
                temp.flow-=d;
                graph[temp.to][temp.rev].flow+=d;
                flow+=d;         //累加當前節點的某條路徑的合適流量
                f-=d;            //當前節點的容量減去某條路徑的合適流量
                if(f==0) break;  //如果當前節點的容量用完,說明無法再通過任何流量
            }
        }
    }
    if(flow==0) step[st]=INF;//如果當前節點無任何流量通過,取消標記
    return flow;
}
int Dinic(int st,int ed)
{
    int flow=0;
    while(BFS(st,ed))
    {
       flow+=DFS(st,ed,INF);
    }
    return flow;
}
int main()
{

    int a,b,flow;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(graph,0,sizeof(graph));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&flow);
            addEdge(a,b,flow);
        }
        printf("%d\n",Dinic(1,n));
    }
    return 0;
}

Dinic算法前向星

#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN=1010;
const int INF=0x7fffffff;
struct Node
{
    int to;
    int next;
    int c;
};
Node Edge[MAXN*2];//因為要建立反向邊,所以邊的數目要為兩倍
int head[MAXN];
int step[MAXN];
int cnt;
void addEdge(int u,int v,int val)
{
    Edge[cnt].to=v;
    Edge[cnt].next=head[u];
    Edge[cnt].c=val;
    head[u]=cnt++;
    Edge[cnt].to=u;
    Edge[cnt].c=0;
    Edge[cnt].next=head[v];
    head[v]=cnt++;
}
bool BFS(int st,int ed)
{
    queue<int> que;
    que.push(st);
    memset(step,-1,sizeof(step));
    step[st]=0;
    int u,i;
    while(!que.empty())
    {
        u=que.front();
        que.pop();
        for(i=head[u];i!=-1;i=Edge[i].next)
        {
            if(step[Edge[i].to]==-1&&Edge[i].c>0)
            {
                step[Edge[i].to]=step[u]+1;
                que.push(Edge[i].to);
                if(Edge[i].to==ed) return true;
            }
        }
    }
    return step[ed]!=-1;
}
int DFS(int st,int ed,int flow)
{
    if(st==ed||!flow) return flow;
    int curr=0;
    for(int i=head[st];i!=-1;i=Edge[i].next)
    {
        if(step[st]+1==step[Edge[i].to]&&Edge[i].c>0)
        {
            int d=DFS(Edge[i].to,ed,min(Edge[i].c,flow));
            if(d>0)
            {
                Edge[i].c-=d;
                Edge[i^1].c+=d;//添反向邊的時候是相鄰的,i^1取相鄰數;
                curr+=d;       //累加當前節點的某條路徑的合適流量
                flow-=d;       //當前節點的容量減去某條路徑的合適流量
                if(flow==0) break;//如果當前節點的容量用完,說明無法再通過任何流量
            }
        }
    }
    if(curr==0) step[st]=INF;//如果當前節點無任何流量通過,取消標記
    return curr;
}
int Dinic(int st,int ed)
{
    int flow=0;
    while(BFS(st,ed))
    {
       flow+=DFS(st,ed,INF);
    }
    return flow;
}
int main()
{
    int n,m,a,b,val;
    while(scanf("%d%d",&m,&n)!=EOF)
    {

        memset(head,-1,sizeof(head));
        cnt=0;
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&val);
            addEdge(a,b,val);
        }
        printf("%d\n",Dinic(1,n));
    }
}

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

網絡流入門

網絡流入門

但是，

那么我們剛剛的算法問題在哪里呢？

那么如何解決這個問題呢？

那么，這么做為什么會是對的呢？

如果這里沒有2-4怎么辦？

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

網絡流入門

但是，

那么我們剛剛的算法問題在哪里呢？

那么如何解決這個問題呢 ？

那么，這么做為什么會是對的呢？

如果這里沒有2-4怎么辦？

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

那么如何解決這個問題呢？