洛谷3381，最小費用最大流模板題

輸入格式：

第一行包含四個正整數N、M、S、T，分別表示點的個數、有向邊的個數、源點序號、匯點序號。

接下來M行每行包含四個正整數ui、vi、wi、fi，表示第i條有向邊從ui出發，到達vi，邊權為wi（即該邊最大流量為wi），單位流量的費用為fi。

輸出格式：

一行，包含兩個整數，依次為最大流量和在最大流量情況下的最小費用。

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9;
const int maxn=5005;
const int maxm=50005;
int n,m,s,t;   //點的個數，邊的個數，源點，匯點
int num=-1,tot,sum; //tot是最大流  sum是在最大流條件下的最小費用
int dis[maxn],b[maxn],xb[maxn],flow[maxn],fa[maxn];
int head[maxm];
struct Edge
{
    int from,to,dis,nxt,w;
}edge[maxm*2];//要建立反向邊，所以這裡要*2

void add_edge(int from,int to,int w,int dis)
{
    edge[++num].nxt=head[from];
    edge[num].from=from;
    edge[num].to=to;
    edge[num].w=w;
    edge[num].dis=dis;
    head[from]=num;
}


/*void add(int from,int to,int w,int dis)
{
    add_edge(from,to,w,dis);
    add_edge(to,from,0,-dis);
}*/


bool spfa()
{
    for(int i=0;i<=maxn;i++) //初始化1-n的dis陣列
        dis[i]=inf;
    memset(b,0,sizeof(b));
    queue<int>que;
    while(!que.empty()) que.pop();
    memset(fa,-1,sizeof(fa));
    b[s]=1;
    dis[s]=0;
    fa[s]=0;
    flow[s]=inf;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        b[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(edge[i].w>0&&dis[v]>dis[u]+edge[i].dis)
            {
                dis[v]=dis[u]+edge[i].dis;
                fa[v]=u;
                xb[v]=i;
                flow[v]=min(flow[u],edge[i].w);
                if(!b[v])
                {
                   b[v]=1;
                   que.push(v);
                }
            }
        }
    }
    return dis[t]<inf;
}

void max_flow()
{
   while(spfa())
   {
       int k=t;
       while(k!=s)
       {
           edge[xb[k]].w-=flow[t];
           edge[xb[k]^1].w+=flow[t];
           k=fa[k];
       }
       tot+=flow[t];
       sum+=flow[t]*dis[t];
   }
}

int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d %d %d %d",&n,&m,&s,&t);
    for(int i=1;i<=m;i++)
    {
        int a,b,c,d;
        scanf("%d %d %d %d",&a,&b,&c,&d);//有向邊起點，終點，邊的流量，單位流量的費用
        add(a,b,c,d);
    }
    max_flow();
    cout<<tot<<" "<<sum<<endl; //tot是最大流，sum是在最大流條件下的最小費用*/
}
 

例：

CCPC-Wannafly Summer Camp #1——A——Birthday（最小費用最大流）

題意：把n個蛋糕放到m個區域裡，每個蛋糕都有兩種區域可以放，總花費為所有區域蛋糕數量的平方和，要求花費盡量小。

解法：想到把每個區域都拆成n個點，如果某一蛋糕可以放到一個區域裡，就把蛋糕和這對應的點都連邊，流量為1，連第i個點的代價是f(i)-f(i-1),f(x)=x*x。然後建立超級源點和超級匯點，源點與所有蛋糕連邊且流量為1，費用為0，匯點與所有區域連邊且流量為1，費用為0。跑一遍最小費用最大流，最後得出的費用即是ans。

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9;
const int maxn=5005;
const int maxm=50005;
int s,t;   //點的個數，邊的個數，源點，匯點
int num=-1,tot,sum; //tot是最大流  sum是在最大流條件下的最小費用
int dis[maxn],b[maxn],xb[maxn],flow[maxn],fa[maxn];
int head[maxm];
struct Edge
{
    int from,to,dis,nxt,w;
}edge[maxm*2];//要建立反向邊，所以這裡要*2

void add_edge(int from,int to,int w,int dis)
{
    edge[++num].nxt=head[from];
    edge[num].from=from;
    edge[num].to=to;
    edge[num].w=w;
    edge[num].dis=dis;
    head[from]=num;
}


/*void add(int from,int to,int w,int dis)
{
    add_edge(from,to,w,dis);
    add_edge(to,from,0,-dis);
}*/


bool spfa()
{
    for(int i=0;i<=maxn;i++) //初始化1-n的dis陣列
        dis[i]=inf;
    memset(b,0,sizeof(b));
    queue<int>que;
    while(!que.empty()) que.pop();
    memset(fa,-1,sizeof(fa));
    b[s]=1;
    dis[s]=0;
    fa[s]=0;
    flow[s]=inf;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        b[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(edge[i].w>0&&dis[v]>dis[u]+edge[i].dis)
            {
                dis[v]=dis[u]+edge[i].dis;
                fa[v]=u;
                xb[v]=i;
                flow[v]=min(flow[u],edge[i].w);
                if(!b[v])
                {
                   b[v]=1;
                   que.push(v);
                }
            }
        }
    }
    return dis[t]<inf;
}

void max_flow()
{
   while(spfa())
   {
       int k=t;
       while(k!=s)
       {
           edge[xb[k]].w-=flow[t];
           edge[xb[k]^1].w+=flow[t];
           k=fa[k];
       }
       tot+=flow[t];
       sum+=flow[t]*dis[t];
   }
}

int main()
{
    memset(head,-1,sizeof(head));
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int a,b;
        cin>>a>>b;
        for(int j=1;j<=n;j++)
        {
            add_edge(i,n+(j-1)*m+a,1,2*j-1);
            add_edge(n+(j-1)*m+a,i,0,1-2*j);
            add_edge(i,n+(j-1)*m+b,1,2*j-1);
            add_edge(n+(j-1)*m+b,i,0,1-2*j);
        }
    }
    for(int i=1;i<=n;i++)
    {
        add_edge(0,i,1,0);
        add_edge(i,0,0,0);
    }
    for(int i=n+1;i<=n+n*m;i++)
    {
        add_edge(i,n+n*m+1,1,0);
        add_edge(n+n*m+1,i,0,0);
    }
    s=0;
    t=n+n*m+1;
    max_flow();
    cout<<sum<<endl;
}
 

洛谷3376 最大流模板題

輸入格式：

第一行包含四個正整數N、M、S、T，分別表示點的個數、有向邊的個數、源點序號、匯點序號。

接下來M行每行包含三個正整數ui、vi、wi，表示第i條有向邊從ui出發，到達vi，邊權為wi（即該邊最大流量為wi）

輸出格式：

一行，包含一個正整數，即為該網路的最大流。

EK演算法目前在演算法競賽中幾乎廢棄，這裡我們使用弧優化的dinic演算法已經非常快了，雖然最大流的最快演算法可能還是IASP，但是一般不會出現只能IASP過而卡dinic的演算法的。

#include<bits/stdc++.h>
using namespace std;
const int maxn=10005;
const int maxm=100005;
const int inf=1e9;
int cnt=-1,n,m,s,t;  //點和邊的個數，起點和終點的編號
int head[maxn],dep[maxn],cur[maxn];
struct Edge
{
    int next=-1;
    int to,w;
} edge[2*maxm]; //next初始值是-1,有反向邊所以開了2倍陣列
void add_edge(int u,int v,int w)
{
    edge[++cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].w=w;
    head[u]=cnt;
}
bool bfs()
{
    queue<int>que;
    while(!que.empty()) que.pop();
    memset(dep,0,sizeof(dep));
    dep[s]=1;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].to;
            if((dep[v]==0)&&edge[i].w>0)
            {
                dep[v]=dep[u]+1;
                que.push(v);
            }
        }
    }
    if(dep[t]>0)
        return 1;
    return 0;
}
int dfs(int u,int flow)
{
    if(u==t) return flow;
    for(int &i=cur[u]; i!=-1; i=edge[i].next)
    {
        int v=edge[i].to;
        if ((dep[v]==dep[u]+1)&&(edge[i].w!=0))
        {
            int d=dfs(v,min(flow,edge[i].w));
            if (d>0)
            {
                edge[i].w-=d;
                edge[i^1].w+=d;
                return d;
            }
        }
    }
    return 0;
}
int Dinic()
{
    int ans=0;
    while (bfs())
    {
        for (int i=1; i<=n; i++) 
            cur[i]=head[i];
        while (int d=dfs(s,inf))
        {
            ans+=d;
        }
    }
    return ans;
}
int main()
{
    memset(head,-1,sizeof(head));
    cin>>n>>m>>s>>t; //輸入資訊可能會隨題目改變而不一樣，請注意隨機應變
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add_edge(a,b,c);
        add_edge(b,a,0);//反向邊流量是0，切不可記作-c。
    }
    cout<<Dinic()<<endl;
    return 0;
}