【最大流/费用流】BZOJ1834-[ZJOI2010]network 网络扩容

【题目大意】

给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况下，1到N的最大流； 2、 将1到N的最大流增加K所需的最小扩容费用。

【思路】

问题用Dinic搞一搞。问题二可以看出是费用流。

(1)残余网络中边还有一些容量，而如果利用这些容量，是不需要花费新的费用的。则将这些边的费用设置为0。

(2)对于原有的边，添加一条起点、终点相同的点，容量设置为INF，费用设置为一开始输入的扩容费用。再添加一个超级源点，和1之间添加一条边，容量为K，费用为0。

所谓的费用流，就是将EK中每一次搜索改为关于单位费用的SPFA即可，其余板块类似。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue> 
using namespace std;
const int MAXN=1000+50;
const int MAXM=5000+50;
const int INF=0x7fffffff;
int n,m,k;//点数边数和需要扩充的容量 
struct node
{
    int to,cap,pos,w;
};
vector<node> E[MAXN];
int vis[MAXN];
int dis[MAXN];
int U[MAXM],V[MAXM],C[MAXM],W[MAXM];
int pre[MAXN],preedge[MAXN];//记录每次SPFA中每一个节点的前驱,以及当前节点在前驱的vector中是第几条边 

void addedge(int u,int v,int c,int w)
{
    E[u].push_back((node){v,c,E[v].size(),w});
    E[v].push_back((node){u,0,E[u].size()-1,-w});/*失误把这里敲成了E[u]，看了好久才看出来T T*/ 
}

void init()
{
    scanf("%d%d%d",&n,&m,&k);
    for (int i=0;i<m;i++)
    {
        scanf("%d%d%d%d",&U[i],&V[i],&C[i],&W[i]);
        addedge(U[i],V[i],C[i],0);
    }
}

int bfs()
{
    queue<int> que;
    memset(dis,-1,sizeof(dis));
    dis[1]=0;
    que.push(1);
    while (!que.empty())
    {
        int head=que.front();que.pop();
        for (int i=0;i<E[head].size();i++)
        {
            node tmp=E[head][i];
            if (dis[tmp.to]==-1 && tmp.cap>0)
            {
                dis[tmp.to]=dis[head]+1;
                que.push(tmp.to);
            }
        } 
    }
    if (dis[n]==-1) return 0;
        else return 1;
}

int dfs(int s,int e,int f)
{
    vis[s]=1;
    if (s==e) return f;
    for (int i=0;i<E[s].size();i++)
    {
        node& tmp=E[s][i];
        if (!vis[tmp.to] && tmp.cap>0 && dis[tmp.to]==dis[s]+1)
        {
            int delta=dfs(tmp.to,e,min(f,tmp.cap));
            if (delta>0)
            {
                tmp.cap-=delta;
                E[tmp.to][tmp.pos].cap+=delta;
                return delta;
            }
        }
    }
    return 0;
}

void dinic()
{
    int flow=0;
    while (bfs())
    {
        memset(vis,0,sizeof(vis));
        int f=dfs(1,n,INF);
        if (f==0) break;
            else flow+=f;
    }
    cout<<flow<<' '; 
}

void rebuild()
{
    for (int i=0;i<m;i++) addedge(U[i],V[i],INF,W[i]);
    addedge(0,1,k,0);
}

int spfa(int u,int v)
{
    memset(vis,0,sizeof(vis));
    for (int i=0;i<=n;i++) dis[i]=INF;
    memset(pre,-1,sizeof(pre));
    queue<int> que;
    dis[0]=0;
    vis[0]=1;
    que.push(0);
    while (!que.empty())
    {
        int head=que.front();
        que.pop();
        vis[head]=0;
        for (int i=0;i<E[head].size();i++)
        {
            node& tmp=E[head][i];
            if (tmp.cap>0 && dis[tmp.to]>dis[head]+tmp.w)
            {
                dis[tmp.to]=dis[head]+tmp.w;
                pre[tmp.to]=head;
                preedge[tmp.to]=i;
                if (!vis[tmp.to])
                {
                    vis[tmp.to]=1;
                    que.push(tmp.to);
                }
            }
        }
    }
    if (dis[n]==INF) return 0;
    else return 1;
}

void mcf()
{
    int ans=0;
    while (spfa(1,n))
    {
        int flow=INF;
        for (int i=n;pre[i]!=-1;i=pre[i])
            flow=min(flow,E[pre[i]][preedge[i]].cap);
        for (int i=n;pre[i]!=-1;i=pre[i])
        {
            node& tmp=E[pre[i]][preedge[i]];
            tmp.cap-=flow;
            E[tmp.to][tmp.pos].cap+=flow;
            ans+=flow*tmp.w;
        }
    }
    cout<<ans<<endl; 
}

int main()
{
    init();
    dinic();
    rebuild(); 
    mcf();
    return 0;
}