费用流建模

---

一，基础使用

• 基于$EK$ 算法的实现，把 $BFS$可行流搜索函数改写成为 $spfa$ 求解（最长）最短路扩展
• 保证最大流的前提之下求解最小（大）费用
• 0xcf 是最费用流，0x3f 是最小费用最大流
• 加边传参： （端点，端点，流量上界，费用）

void add(int a,int b,int c,int d)
{
    e[idx]=b; ne[idx]=h[a]; w[idx]=d; f[idx]=c; h[a]=idx++;
    e[idx]=a; ne[idx]=h[b]; w[idx]=-d; f[idx]= 0; h[b]=idx++;
}

bool spfa()
{
    queue<int>q;
    Mset(d,-0x3f); Mset(incf,0);
    q.push(S); st[S]=1; d[S]= 0; incf[S]=INF;
    while (q.size())
    {
        int top = q.front();
        q.pop();
        st[top]= 0;
        mrep(i,top)
        {
            int ver=e[i];
            if(f[i] && d[ver]<d[top]+w[i])
            {
                d[ver]=d[top]+w[i];
                pre[ver]=i;
                incf[ver] = min(f[i],incf[top]);
                if(!st[ver])
                {
                    q.push(ver); st[ver]=1;
                }
            }
        }
    }
    return incf[T]>0;
}

int EK()
{
    int flow = 0;
    int cans = 0;
    while (spfa())
    {
        flow += incf[T];
        cans += incf[T]*d[T];
        for(int i=T;i!=S;i=e[pre[i]^1])
        {
            int tx = pre[i];
            f[tx] -= incf[T];
            f[tx^1] += incf[T];
        }
    }
    return cans;
}

一（半），（同时）快解最大和最小费用

• 1，多退少补，退流
• 2，边权取反，大小颠倒（负数入小跟堆成为大根堆）
• 3，回归实际，费用流取相反数

int main()
{
    wri(EK()); puts("");

    for(int i=0;i<=idx;i+=2)
    {
        f[i]+=f[i^1];
        f[i^1]=0;
        w[i] = -w[i];
        w[i^1] = -w[i^1];
    }
    wri(-EK());
}

二，带权二分图匹配

三，网格图（极度稠密）建模

核心：网格编号

rep(i,1,n)
    {
        rep(j,1,n)
        {
            read(cost[i][j]);
            id[i][j]=++cnt;
        }
    }

• 约定
  1，id[i][j] * 2 作为某点的入点
  2，id[i][j] * 2 + 1 作为某点的入点
  3，点权作为出点和入点之间的费用加入，一般流量为1（视情况）

特例 1，点权不重复积累类型

• 在方格图中，如果经过了某个点，还能过再次经过，但是不能积累点权了，那需要两条边（一条可行（$c=inf$），一条限制走一次（$c=1$））

例题：

https://www.acwing.com/problem/content/384/

在一个 $N\times N$ 的矩形网格中，每个格子里都写着一个非负整数。可以从左上角到右下角安排 $K$ 条路线，每一步只能往下或往右，沿途经过的格子中的整数会被取走。
若多条路线重复经过一个格子，只取一次。求能取得的整数的和最大是多少。

int main()
{
    Mset(h,-1); idx = 0;
    add(S,id[1][1]*2,m,0);
    add(id[n][n]*2+1,T,m,0);

    rep(i,1,n)
    {
        rep(j,1,n)
        {
            add(id[i][j]*2,id[i][j]*2+1,1,cost[i][j]);
            add(id[i][j]*2,id[i][j]*2+1,INF,0);

            if(i<n) add(id[i][j]*2+1,id[i+1][j]*2,INF,0);
            if(j<n) add(id[i][j]*2+1,id[i][j+1]*2,INF,0);
        }
    }
}

特例 2，边权不重复积累

四，拆点

1，一般思想

• 出点入点，借助（容量）限制点上（最大权值或者即使在边上也能转到点上）
• 不限于两点拆法，多点拆法是存在的

2，最大权不相交路径

• 限制点权和边权：最大权完全不相交路径
• 仅限制点权：最大无相交边路径
• 仅限制边权：最大无相交公共点路径

五，上下界可行流