网络流

「末世追忆」：”或有一次天命陨落，但层出不穷，使万物若然。”

网络

网络流是网络中的流，网络是一张有向图，表示为 ，对于每一条边 ，存在一个权值 表示容量 (capacity) ，当 ，则有 ，注意，不保证 。每一个网络有两个特殊点，一个是源点 (Source) ，一个是汇点(Sink) 。

流

一个实数函数满足 ，且有：

• 容量限制 ；
• 流守恒性 ，即从源点流出的流量等于汇点流入的流量。
• 如果考虑反向边，则有第三性质：斜对称性 。 是 的流函数， 被称为 的流量，而 称为边的剩余流量。则 为从源点出发的流量和。

最大流

可以把网络流看作水库出水，而源点则是水库，汇点就是你家。源点的“量”是无限的，中途的任何一个点不存储任意一点流量也不会产生任何一点流量，所以源点出发的所有流量必定流入汇点。而经过每一条边的最大流量，即是

最大流的算法，就是在满足流过边 的流量满足 的情况下，汇点的流量最大的问题。

残余网络

首先我们介绍一下一条边的剩余容量 （Residual Capacity），它表示的是这条边的容量与流量之差，即 。

对于流函数 ，残量网络 （Residual Network）是网络 中所有结点 和剩余容量大于 0 的边构成的子图。形式化的定义，即 。

注意，剩余容量大于 0 的边可能不在原图 中（根据容量、剩余容量的定义以及流函数的斜对称性得到）。可以理解为，残量网络中包括了那些还剩了流量空间的边构成的图，也包括虚边（即反向边）。

---

以下是二月份初学时做下的笔记。

---

我们设 为边 的实际容量。

• 饱和弧： ，流量为该边的容量
• 非饱和弧： ，实际流量小于容量
• 零流弧： ，该边未流过流量。
• 非零流弧： ，当前流量不为 。
• 残余网络：设有容量网络 及其上的网络流 ， 关于 的残留网络即为 ，其中 的顶点集 和 的顶点集 相同，即 ，对于 中任何一条弧 ，如果 ，那么在 中有一条弧 ，其容量为 ，如果 ，则在 中有一条弧 ，其容量为 。

从残留网络的定义来看，原容量网络中的每条弧在残留网络中都化为一条或者两条弧。在残留网络中，从源点到汇点的任意一条简单路径都对应一条增光路，路径上每条弧容量的最小值即为能够一次增广的最大流量。

增广路

增广路是一条从源点到汇点的路径，满足所有边的剩余容量都大于 ，则该路是网络 的一条增广路（Augmenting Path）。也可以定义为：残余网络 中，存在一条从源点到汇点的路径被称为增广路。

---

以下是二月份自学时做的笔记。

---

增广路是一条链。（链是网络中的一个顶点序列，这个序列中前后两个顶点有弧相连）链上的前向弧都是非饱和弧，链上的后向弧都是非零弧。（前向弧即输入的边，后向弧即建立的反边）链的起点是源点，终点是汇点。

增广路是一个边的集合，从 至 的一条路径。增广路的最大流量表示该路径经过的边中流量最小的边的流量，即：

一条增广路 的边集是 ，最大流量是 ，则 。

用赵悦岑巨佬的话来讲，增广路指的就是一条从源点到汇点，且经过的边最小容量不为 的路径。而我们寻找增广路之后，就会将所有经过的边的容量减去增广路的流量。但是，这种算法并不保险。所以我们对于每一条存在的 ，都建立其后向弧满足 使得我们在后续寻找增广路时可以“反悔”，使其不因之前的错误增广路而影响。

我们对于每一条边都增加一条容量为 反向边，找到增广路后经过的边流量要减去此增广路的流量，其反向边的流量还要加上此增广路的流量。所有反向边组成的图就是残留网络。

反向边

增广时需要建造反向边，这是通理，虽然我也没有想明白其正确性。总之，增广的时候，由于贪心原则，其并非全局最优解，而减去之后会导致最优解无法到达，我们要让子程序进行反悔。那么，我们每次增广的时候，就要建造一个反向边满足 ，即反向边的容量是正向边的流量。我无法解释为什么，反正它确实对了。

对于建反向边的技巧，邻接矩阵就是 。而链式前向星更常用，我们也不需要在增广时才加入反向边，我们可以预处理出反向边，而在用的时候直接将 即可。这个不必太多解释。但是，初始值需要有 Total=-1 或者 ，如果边从 开始，则会错位。

Edmonds-Karp 动能算法

圈内人称 算法。

算法只有一句话，用 找增广路，然后对其进行增广即可。

• 找：从源点开始 ，直到碰到汇点，然后进行增广（每一条路），注意流量合法。
• 增广：重走找到的增广路，然后减去这条路能够达到的最大流量，然后把答案加上最小流量即可。时间复杂度 ，不太效率。但是好想和好记。

时间复杂度 ，不太效率，但是比较好想也比较好记。

参考代码

const int MAXN=201,MAXM=5001;
const int INF=0x7f7f7f7f;
namespace EdmondsKarp
{
    int Total;
    vector<Edge>Edges;
    vector<int>G[MAXN];
    int fl[MAXN],id[MAXN];
    inline void init()
    {
        for(int i=1;i<=N;++i) G[i].clear();
        Edges.clear();
    }
    inline void addEdge(int u,int v,int c)
    {
        Edges.push_back(Edge(u,v,c,0));
        Edges.push_back(Edge(v,u,0,0));
        Total=Edges.size();
        G[u].push_back(Total-2);
        G[v].push_back(Total-1);
    }
    inline ll maxFlow(int s,int t)
    {
        ll flow=0;
        for(;;)
        {
            memset(fl,0,sizeof(fl));
            queue<int>Q;
            Q.push(s);
            fl[s]=INF;
            while(!Q.empty())
            {
                int u=Q.front();Q.pop();
                for(int i=0;i<G[u].size();++i)
                {
                    Edge& e=Edges[G[u][i]];
                    if(!fl[e.to]&&e.cap>e.flow)
                    {
                        id[e.to]=G[u][i];
                        fl[e.to]=min(fl[u],e.cap-e.flow);
                        Q.push(e.to);
                    }
                }
                if(fl[t]) break;
            }
            if(!fl[t]) break;
            for(int u=t;u!=s;u=Edges[id[u]].from)
            {
                Edges[id[u]].flow+=fl[t];
                Edges[id[u]^1].flow-=fl[t];
            }
            flow+=fl[t];
        }
        return flow;
    }
};
using namespace EdmondsKarp;
int main()
{
    // freopen("ek.in","r",stdin);
    // freopen("ek.out","w",stdout);
    read(N,M,S,T);
    EdmondsKarp::init();
    for(int i=1,u,v,c;i<=M;++i)
    {
        read(u,v,c);
        EdmondsKarp::addEdge(u,v,c);
    }
    printf("%lld",EdmondsKarp::maxFlow(S,T));
    return 0;
}

---

Dinic

在学习完 之后，我才真正开始理解 的本质。

思路同 ，但是在增广之前，使用 bfs 进行分层（将图进行分层处理，建图的常见技巧之一），源点的层数满足 ，其他点的层数取决于其与源点的距离。

分层之后，有两个优化：

同时进行多路增广，且在断层时（即找不到增广路的时候）直接中断增广，进行时间优化；增广路一定最短。我们用 dfs 来找增广路。对层数加 的点进行增广（从而确保增广路最短，原理同最短路，因为同层的点只会经过一个）。

Dinic 的优化

• 多路增广：每找到一条增广路之后，从残余流量再次增广；从而在一次 dfs 中找出多条增广路，提高算法效率。
• 当前弧优化：可以推出（或者直接背下），一条边如果已经是一条增广路的边（被增广过），那么这条边不可能被增广第二次。所以，对所有边进行标记，不必要再走已经被增广过的边。

在运用了上述两个优化之后，时间复杂度可以达到 ，在稠密图上比 EK 更胜一筹。就和 SPFA 一样，这个上界一般而言很难到达，且在二分图最大匹配问题上，Dinic 算法的复杂度能达到 ，不过不在我今天讲的范围内，所以只是提一嘴。

---

以下讲解不太明晰（个人意见），酌情观看。

• 每次多路增广： 点通过一条边，向 输出流量以后， 会尝试到达汇点（到达汇点才真正增广），然后 返回实际增广量。这时，如果 u 还有没用完的供给，就继续尝试输出到其它边。
• 但是要警惕绕远路、甚至绕回的情况，不加管制的话极易发生。怎么管？
• 源点顺着残量网络想要到达其它点，需要经过一些边对吧？按照经过的边数（即源点出发以后的距离）把图分层，即用 bfs 分层。 每次尝试给予时，只考虑给予自己下一层的点，就可以防止混乱。
• 综合上面两条。每回合也是从源点出发，先按照当前残量网络分一次层，随后多路增广，尽可能增加流量。增广过程中，会加入一些反向边，这些反向边逆着层次图，本回合并不会走。所以还需要进入下一回合。一直到 分层时搜不到汇点（即残量网络断了）为止。

首先 对网络进行分层，构成一张分层图。然后进行 寻找当前的最大流。直到 无法达到汇点，则整个算法停止。

Dinic 的当前弧优化

过程中我们会一直流直到把一条边流完再转到下一条边，如果一条边有容量但是却没有增广路，说明这条边的下一个点已经没有更多容量了，我们就可以把连接的这个点的高度标记为 ，下一次就不会再搜索到这个点了。

不过 还是很慢，甚至比 还慢，这时候我们就需要拯救 的当前弧优化。上面说到， 过程中会一直流直到把一条边流完再转到下一条边，当搜索到一条边的时候说明这条边之前的所有边都已经没有增广路了，我们就可以直接将 指向这条边，这样下一次就不会再次搜索已经没有流量的边了。

MPM

有两种实现方法，一种是基于堆的优先队列，时间复杂度 ；一种是使用 的解法，时间复杂度 。其中寻找增广路的时间用了 ，而在寻找的过程中，考虑顶点而非边的容量。

在分层网络 中引入定义点的函数 表示点 传入残量和传出残量的最小值，满足：

$$p_{in}(v)=\sum_{(u,v)\in L}(c(u,v)-f(u,v))\\ p_{out}(v)=\sum_{(v,u)\in L}(c(v,u)-f(v,u))\\ p(v)=\min(p_{in}(v),p_{out}(v)) \nonumber$$

为参考节点当且仅当 。这是 MPM 特有的定义。

对于 的其他内容，读者可以自行查阅。也没什么太大必要学（不要刀我），更重要的是 。

主要是懒得写了。

---

ISAP

与 不同的是，我们跑反图，即从 向 推进。增广的时候，选择比当前点层数少 的点来增广。每一次也不需要重跑 来重新分层，而是一边增广，一边重分层。

其实吧，（，最短增广路）就是 算法。

在结束对 点增广之后，我们遍历残量网络中 的出边，找出其层最小的出点 ，令 ，若 无出边，则有 。如果 则图不存在增广路。

ISAP 的当前弧优化 x ISAP 的 GAP 优化

当前弧优化不必多说。

记录层数为 的点的数量，并在更新层数时更新 数组，如果存在 ，则图断层，不存在增广路，将 ，终止算法。该优化称为 GAP 优化。

加上两个优化的 基本上可以吊打除了 以外的所有算法。

参考代码

int N,M,S,T;
struct Graph
{
    int next,to;
    ll val;
    Graph(int n=0,int t=0,ll v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,ll w)
{
    Edge[++Total]=Graph(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Graph(Head[v],u,0);Head[v]=Total;
}
int Dep[MAXN],Num[MAXN];
inline void Bfs()
{
    memset(Dep,-1,sizeof(Dep));
    memset(Num,0,sizeof(Num));
    Dep[T]=0;Num[0]=1;
    queue<int>Q;
    Q.push(T);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Dep[v]!=-1) continue;
            Q.push(v);
            Dep[v]=Dep[u]+1;
            ++Num[Dep[v]];
        }
    }
    return ;
}
ll MaxFlow;
ll Dfs(int u,ll inf)
{
    if(u==T)
    {
        MaxFlow+=inf;
        return inf;
    }
    ll flow=0;
    for(int e=Cur[u];e;e=Edge[e].next)
    {
        Cur[u]=e;
        int v=Edge[e].to;
        if(Edge[e].val&&Dep[v]+1==Dep[u])
        {
            ll k=Dfs(v,min(Edge[e].val,inf-flow));
            if(k)
            {
                Edge[e].val-=k;
                Edge[e^1].val+=k;
                flow+=k;
            }
            if(flow==inf) return flow;
        }
    }
    --Num[Dep[u]];
    if(Num[Dep[u]]==0) Dep[S]=N+1;
    ++Dep[u];
    ++Num[Dep[u]];
    return flow;
}
inline ll ISAP()
{
    MaxFlow=0;
    Bfs();
    while(Dep[S]<N)
    {
        memcpy(Cur,Head,sizeof(Head));
        Dfs(S,INF);
    }
    return MaxFlow;
}
int main()
{
    // freopen("isap.in","r",stdin);
    // freopen("isap.out","w",stdout);
    read(N,M,S,T);
    for(int i=1,u,v;i<=M;++i)
    {
        ll w;
        read(u,v,w);
        addEdge(u,v,w);
    }
    printf("%lld",ISAP());
    return 0;
}

---

预流推进

我们可以稍微回想一下网络流的形象化定义：

可以把网络流看作水库出水，而源点则是水库，汇点就是你家。源点的“量”是无限的，中途的任何一个点不存储任意一点流量也不会产生任何一点流量，所以源点出发的所有流量必定流入汇点。

那么，我们在处理网络流的时候，也可以看做不停从源点倒水，然后能流就流直到流完为止，最后看汇点有多少流量。听着就跟个大模拟一样。

这就是所谓预流推进的本质：

在求解过程中忽略流守恒性，并每次对一个节点更新消息，以求解最大流。
但是，如果真去模拟的话，你会发现最后的时间复杂度甚至没有过不了网络最大流模板题，更不要说预流推进的模板题了。这就要引出最大流的最后一个算法：

最高标号预流推进算法（）。

HLPP

其实还有一个通用的预流推进算法（称为 ），但考虑在预流推进这个东西本来就冷门，我也不想学了。

网络流，网络流，学到秃头。

引出一些定义：

流函数

同样是 函数，但是不一定保持流守恒性；在预流推进里，我们允许入流大于出流。并将超过的那部分称为 结点的超额流，记作 ，满足：

$$e(u)=\sum_{(x,u)\in E}f(x,u)-\sum_{(u,y)\in E}f(u,y) \nonumber$$

若 ，则称为 溢出，当然，溢出结点不会包括源点和汇点。

高度函数

预流推进维护每个结点的高度 ，并规定溢出的结点 如果要推送超额流，只能向满足 的 结点推送；如果 没有相邻的高度小于 的结点，就修改 的高度，称为重贴标签。

实际上，预流推进维护一个映射 ：

• ；
• 。

则 函数是残量网络 的高度函数。有性质：

设 中的高度函数为 ，则如果有 ，则 不是 的边。

预流推进只会在满足 的边执行推送。

推送(Push)

在 溢出时，且存在 满足 时执行。

将 的超额流从 推送到 去，只考虑超额流和 的最小值，无需考虑 的溢出情况。

如果 在推送完之后满流，则将 从残量网络中删除。

重贴标签(Relabel)

在 溢出时，且任意 满足 时执行。

执行时，将 更新为 即可。

初始化

初始化流函数，超额流函数和高度函数：

$$\begin{align} &\forall (u,v)\in E,f(u,v)= \begin{cases} c(u,v)&,u=s \nonumber \\ 0&,u\ne s \end{cases} \nonumber \\ &\forall u\in V,h(u)= \begin{cases} |V|&,u=s \nonumber \\ 0&,u\ne s \end{cases} \\ &\forall u\in V,e(u)=\sum_{(x,u)\in E}f(x,u)-\sum_{(u,y)\in E}f(u,y) \nonumber \end{align}$$

这样的初始化使 都可以满流，并使 抬高，满足 。

因为 ，且 满流，则 没有必要留在残量网络中；

上述操作还将 初始化为 的相反数。

HLPP 的实质

有一个不为人知，但众所皆知的网络流算法—— 算法，是唯一一个会在模板题上超时的算法。它就是推进算法，用一个队列储存待维护的点（起始为源点），然后对于每一个当前点，把它有的流量尽可能地推往与之相连的点，然后将相连的点也加入队列。

但是，如果存在两个点可以互相推送，则会死循环。这也是为什么 是一个不成功的算法。所以才会出现 ，类似于 构建一个高度函数 。

著名毒瘤科学家 和他的同事 在 年提出了最高标号预留推进算法，将 中的队列替换为优先队列，每一次都流高度最高的，可以理解为先将高处的点的水移到低处，那么给低处节点推流时可以顺便带走。后来，另外两名科学家 和 证明了 的复杂度：

。

每一次扫描整个图，只要存在结点 能够执行 push 或 relabel 操作，就执行。下图是暴力推进的示意图：颜色深度代表结点高度，绿色边代表满足 的边 。

结果：

图片来自 。

HLPP 的实现及优化

的算法过程包括：

1. 初始化（基于预流推进）；
2. 选出溢出结点中高度最高的结点 ，推送 ；
3. 如果 仍然溢出，重贴标签 ，并执行步骤 ；
4. 没有溢出，算法结束。

所涉及的三个操作上文都有讲过，读者请自行查阅。

的复杂度是较稳定的 ，卡得比较紧，且常数极大。在随机数据上甚至可能连 都跑不过，所以需要许许多多的优化。

BFS 优化

优化初始化高度，将 赋为 到 的最短距离，使 。并在使用 时检查图的连通性，排除无解的情况。

GAP 优化

如果在某一刻存在 的结点个数为 ，则对于 的结点就永远无法推送超额流到 ，只能流回 。所以直接改变高度到至少 ，以尽快推送回源点，减少重贴标签操作的复杂度。

代码实现

参考代码

const int MAXN=1e3+2e2+1,MAXM=1e5+2e4+1;
const int INF=0x3f3f3f3f;
int N,M,S,T;
struct Net
{
    int next,to,val;
    Net(int n=0,int t=0,int v=0):
        next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Net(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Net(Head[v],u,0);Head[v]=Total;
}
int Ht[MAXN+1],Ex[MAXN+1],Gap[MAXN+1];
stack<int>B[MAXN];
int Level=0;
inline int Push(int x)
{
    bool Init=x==S;
    for(int e=Head[x];e;e=Edge[e].next)
    {
        const int &v=Edge[e].to,&w=Edge[e].val;
        if(!w||(!Init)&&Ht[x]!=Ht[v]+1) continue;
        int k=Init?w:min(w,Ex[x]);
        if(v!=S&&v!=T&&!Ex[v])
            B[Ht[v]].push(v),checkMax(Level,Ht[v]);
        Ex[x]-=k,Ex[v]+=k,Edge[e].val-=k,Edge[e^1].val+=k;
        if(!Ex[x]) return 0;
    }
    return 1;
}
inline void Relabel(int x)
{
    Ht[x]=INF;
    for(int e=Head[x];e;e=Edge[e].next)
        if(Edge[e].val) checkMin(Ht[x],Ht[Edge[e].to]);
    if(++Ht[x]<N)
    {
        B[Ht[x]].push(x);
        checkMax(Level,Ht[x]);
        ++Gap[Ht[x]];
    }
}
inline bool Bfs()
{
    memset(Ht,0x3f,sizeof(Ht));
    queue<int>Q;
    Q.push(T),Ht[T]=0;
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            const int &v=Edge[e].to;
            if(Edge[e^1].val&&Ht[v]>Ht[u]+1)
                Ht[v]=Ht[u]+1,Q.push(v);
        }
    }
    return Ht[S]!=INF;
}
inline int Select()
{
    while(B[Level].empty()&&Level>=0) --Level;
    return Level==-1?0:B[Level].top();
}
inline int Hlpp()
{
    if(!Bfs()) return 0;
    memset(Gap,0,sizeof(Gap));
    for(int i=1;i<=N;++i)
        if(Ht[i]!=INF) ++Gap[Ht[i]];
    Ht[S]=N;
    Push(S);
    int u;
    while((u=Select()))
    {
        B[Level].pop();
        if(Push(u))
        {
            if(!--Gap[Ht[u]])
                for(int i=1;i<=N;++i)
                    if(i!=S&&i!=T&&Ht[i]>Ht[u]&&Ht[i]<N+1)
                        Ht[i]=N+1;
            Relabel(u);
        }
    }
    return Ex[T];
}
int main()
{
    // freopen("Hlpp.in","r",stdin);
    // freopen("Hlpp.out","w",stdout);
    read(N,M,S,T);
    for(int i=1,u,v,w;i<=M;++i)
    {
        read(u,v,w);
        addEdge(u,v,w);
    }
    printf("%d",Hlpp());
    return 0;
}

---

多源汇最大流

很简单，建立一个超级源点 链接所有的源点 ，容量为 ；建立一个超级汇点链接所有的汇点 ，容量为 。然后处理增广路（跑模板）。

可能是因为太简单了吧，我没有找到模板题，就和普通的网络最大流少了一步而已。

---

最小割

割

割是一种划分，将 划分成两个集合 满足 。且有 。

割的容量 x 最小割

对于割 有容量 表示 ，即从 到 的边的容量之和。且有 。

而最小割就是求一个集合划分使 最小。

最大流最小割定理

对于任意一个可行流 的割 ，则有：

$$f(s,t)=S\text{出边的总流量}-S\text{入边的总流量}\leq S\text{出边的总流量}=c(s,t) \nonumber$$

那么，令 是最大流，则其残余网络中不会存在 的增广路，那么 的出边是满流，入边是零流，则：

$$f(s,t)=S\text{出边的总流量}-S\text{入边的总流量}=S\text{出边的总流量}=c(s,t) \nonumber$$

而此时的 实际上是流函数 的 。

---

求割边数量

即在满足最小割的前提下，最小化割边的数量（即删除的边的数量）。首先跑最大流求出最小割，然后将没有满流的边容量改成 ，并将满流了的边的容量改为 ，重新跑一遍最小割，求出来的即是最小割边数。如果没有最小割，则直接将所有边的容量都设为 并跑最小割。

另外两种方法可以参考这一篇题解。

---

全局最小割 x Stoer-Wagner 算法

你可以把它理解为无源汇最小割，其最小割的重定义为：

去掉其中一些边能使一张网络不再连通的边集称为该网络的割。

其最小割定义为方案中边集和最小的一种方案。

使用 算法来解决这个问题。（因为无源汇，所以你暴力建源汇点跑 次即使是 也是行不通的）

时间复杂度 近似于 。

存在一个结论：

图中有任意两点 ，存在 的任意一个割 ，要么 和 连通，在同意连通块；要么 是一个 割。

算法在 年由 与 提出，是一种通过递归的方式来解决无向正权图上的全局最小割问题的算法。

流程：

1. 任意指定两点 作为源汇点并求出 ，记作 ，更新答案；
2. 合并点 ，如果 ，重复操作一；
3. 答案保证 。

合并：

删除边 ，并对于 中的 ，删除 ，并将边权 加到 中。

算法的正确性

如果 在同一连通块中，则 与 互为充分必要条件。否则，因为 连通， 连通，导致 连通，此时 ，将比 更优，反之亦然。所以 可以看做同一点。

操作一考虑了 不连通的情况，而 解决了剩下的情况。根据操作的递归性，操作执行 次后必然结束。

---

求取 S-T 最小割

如果我都写出来了，说明就不能跑最大流啊。

当前状态下的图表示为 ，构造一个集合记为 ，初始有 。

定义权值函数为 ，特殊地， 。

遍历 中的所有点，若有 ，将 中最大的节点加入 直到 。

所有点加入 的顺序必然是固定的，有 表示第 个加入 的点，有 ； 表示 被加入 后 的大小，即 被加入的顺序。

对于任意点 ，则 。

正确性证明

似乎这个算法的绝大部分代码使用的都是邻接矩阵。（至少我没有发现链式前向星和邻接表的写法）似乎可以联系 算法来理解，不过 我也没学过，所以不考虑。

写法参考 。

参考代码

const int MAXN=601;
const int INF=0x7f7f7f7f;
int Fa[MAXN],Size[MAXN],Edge[MAXN][MAXN];
int Find(int x)
{
    if(x==Fa[x]) return x;
    return Fa[x]=Find(Fa[x]);
}
int Dist[MAXN],Vis[MAXN],Bin[MAXN];
		//Bin记录该点是否被合并过
		//Vis记录本次查询中是否已经被搜到过
		//Dist记录当前最大权值（具体什么权值我也不太清楚）
int N,M;
inline int contract(int &s,int &t)
{
    memset(Dist,0,sizeof(Dist));
    memset(Vis,0,sizeof(Vis));
    int k,minCut,maxCut;
    for(int i=1;i<=N;++i)
    {
        k=maxCut=-1;
        for(int j=1;j<=N;++j)
            if(!Bin[j]&&!Vis[j]&&Dist[j]>maxCut)
            {
                k=j;
                maxCut=Dist[j];
            }
        if(k==-1) return minCut;
        s=t,t=k;
        minCut=maxCut;
        Vis[k]=1;
        for(int j=1;j<=N;++j)
            if(!Bin[j]&&!Vis[j]) Dist[j]+=Edge[k][j];
    }
    return minCut;
}
inline int Stoer_Wagner()
{
    int i,minCut,s,t,res;
    for(i=1,minCut=INF;i<N;++i)
    {
        res=contract(s,t);
        Bin[t]=1;
        if(minCut>res) minCut=res;
        if(minCut==0) return 0;
        for(int j=1;j<=N;++j)
            if(!Bin[j]) Edge[s][j]=(Edge[j][s]+=Edge[j][t]);
    }
    return minCut;
}
int main()
{
    // freopen("sto.in","r",stdin);
    // freopen("sto.out","w",stdout);
    read(N,M);
    if(M<N-1)
    {
        printf("0");
        return 0;
    }
    for(int i=1;i<=N;++i) Fa[i]=i,Size[i]=1;
    for(int i=1,u,v,w;i<=M;++i)
    {
        read(u,v,w);
        int uf=Find(u),vf=Find(v);
        if(uf!=vf)
        {
            if(Size[uf]>Size[vf]) swap(uf,vf);
            Fa[uf]=vf,Size[vf]+=Size[uf];
        }
        Edge[u][v]+=w,Edge[v][u]+=w;
    }
    int rf=Find(1);
    if(Size[rf]!=N)
    {
        printf("0");
        return 0;
    }
    printf("%d",Stoer_Wagner());
    return 0;
}

---

最大权闭合图

在一个网络（图） 中的一个子图满足该子图中的任意点的任意一条边都不会引申到该图之外的任意节点。而最大权闭合子图就是满足上述条件，点权和最大的子图。

一般而言，这种定义都针对于有向图，如果是无向图，那么这张图唯一一个闭合图就是它本身，否则该图不连通。

那么如何求解最大权闭合图。

当然是使用网络流。（否则也不会写在这儿）

首先给出结论和做法：

1. 建立一个超级源点 和一个超级汇点 ；
2. 对于 ，链接 ；
3. 对于 ，链接 。
4. 对于 ，链接 。
5. 最大权闭合图的权值等于正权点点权和减去从 到 的最大流。

从 而出的是最大可获得权值（正权值和），向 而出的是最大损失权值（负权值和）。

尽量多从 获得的同时，避免向 丢失。

如果选定一个点进入最大权闭合图，则这个点的所有后继点都必须被选择。

否则有悖定义。

对于我们建出来的这个图，得到的最小割必定是简单割，（即划分出来的其中一个集合有且仅有源点或者汇点）否则不是该图的最小割。

那么，从 流出的流量则是得到的，流向 的则是损失的。所以 即是最大权。

所谓 ，就是 。

但如何求出 ，就是关键所在。因为对于一个点 的后继损失不会超过该点的权值。那不妨我一开始就把所有的正权点都给选了（满足从 流出的最多），让他们往后代流，大不了被负权子孙点损失完，而那些没有被损失完的，就是我们统计下来的结果。

最后得出结论： 就是从 到 的最大流（最小割）。

值得注意的一点：最大权闭合图与最小割一一对应。

令 为正点权和， 为不选的正点权和， 为选择的负点权和，则有：

是定值，所以最大权闭合子图和最小割一一对应，而最小割又与最大流一一对应。所以上文的结论也就显而易见了。

---

最大权闭合图的双倍经验。

求一个子图的边权和减去点权和。

那么，从 流出的流量则是得到的，流向 的则是损失的。所以 即是最大权。

有这句话的定义，我们可以知道建图的大概方向：

1. 对于每一条边 ，链接 ，容量为边权；
2. 对于每一个点 ，链接 ，容量为点权；
3. 对于每一条边 ，链接 ，容量都是 。

答案是 。

点数：

边数：

AC Code

const int MAXN=5e3+10;
const int MAXM=5e4+10;
const ll INF=1145141919810;
int N,M,S,T;
struct Net
{
    int next,to;ll val;
}Edge[2*MAXN+6*MAXM];
int Head[MAXN+MAXM],Cur[MAXN+MAXM],Total=1;
inline void addEdge(int u,int v,ll w)
{
    Edge[++Total]=(Net){Head[u],v,w};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0};Head[v]=Total;
}
int Fl[MAXN+MAXM];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    std::queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
ll Dfs(int x,ll inf)
{
    if(x==T) return inf;
    ll flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            ll k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline ll Dinic()
{
    ll r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
ll sum;
int main()
{
    // freopen("mincut.in","r",stdin);
    // freopen("mincut.out","w",stdout);
    read(N,M);
    S=0,T=N+M+1;
    for(int i=1;i<=N;++i)
    {
        ll w;read(w);
        addEdge(i+M,T,w);
    }
    for(int i=1,u,v;i<=M;++i)
    {
        ll w;read(u,v,w);sum+=w;
        addEdge(i,u+M,INF);
        addEdge(i,v+M,INF);
        addEdge(S,i,w);
    }
    write(sum-Dinic());
    return 0;
}

---

最大密度子图

对于一个图 ，选出其一个子边集 ，在求出一个子点集 ，即 集合中所有的边的两端点都必须在 中。对于一个子图 满足 最大，则 是 的最大密度子图。

这让人不禁想到了 规划 ，所以也就采用二分求解。但是判断函数需要联系到最小割去。

再次回忆一次 规划的思路。

令 ，则有 ，那么如果要让该式子最大，则有 ，同理就有 ，那么问题就可以转化为求出 的最大值，或者求 的最小值。

有一种方法是把求最大密度子图转化为最大权闭合图来做。但这样时间复杂度较高。

点数： ，边数 。

从最大密度子图的定义来看，它是满足了闭合图的性质的。而由边定点，对于边 ，我们可以看做有一个点 ，有边 和边 与其相连。

建图：

1. 从超级源点 到所有边点 链接一条容量为 的边；
2. 从已知点 到已知点 链接一条容量为 的边；
3. 从所有边点 到超级汇点 链接一条容量为 的边。（ 是当前二分抉择）

然后跑最小割以求最大权闭合子图，求出的最大权就是 的最大值。

性质法

已知算式 与 一一对应，且当 最大时， 正好取得最小值，我们可以从这一方面入手。

选择的点集为 的话，则点集内所有的边都被选择的情况，是对于当前点集最优的情况。

该性质显然，无需证明。

我们定义一个反点集 ，即所有没有选择的点的集合，并定义一个函数 表示 的度数。（即有多少条边以 为端点）

有：

$$g|V'|-|E'|=\sum_{v\in V'}g-\left(\frac{\sum_{v\in V'}deg[v]-C(V',\overline{V'})}{2}\right) \nonumber$$

设集合内部所有点的度数之和是 ，那么，处于集合内部的边一定被计算了 次，因为该边的两个端点均在集合内。而处于集合 与集合 之间的割边只被计算了一次，而这样的割边的数量就是该割的容量 ，因为原图的所有边的容量在流网络中都设置成了 。

变换形式，得到一个较好处理的式子：

$$\text{原式}=\frac{1}{2}(\sum_{v\in V'}(2g-dep[v])+C(V',\overline{V'})) \nonumber$$

在每一次抉择时， 的值是相等的，所以影响整个式子的唯一点就是这张图的最小割。

再说说怎么建图：（讲的不是太明白）

1. 从每一个点往超级汇点 链接一条容量为 的边；
2. 从超级源点 向每一个点链接一条容量为 的边。
3. 取出原图，将所有原边的容量修改为 。

这里的 是一个常数，一个偏移量，一个满足 是正数的任意值，一般可以取到 ，即原图的边数。（ 存在的原因是容量不能为负）

我们已知，割的容量 表达式可以有三种：

其中 。

以 的一个 函数表示 之间是否连接，则有

$$C(S,T)=\sum_{v\in V'}Q+\sum_{u\in V'}(2g-deg[u]+Q)+\sum_{u\in V'}\sum_{v\in\overline{V'}}c_{(u,v)} \nonumber$$

因为有：

表示的是以 点为端点的边数；

而 表示的是点 到达集合 外部 的边数；

相减得到点 到达集合内部的边数

再次化简：

$$\begin{align} C(S,T) &=\sum_{v\in V'}Q+\sum_{u\in V'}(Q+2g-dep[u]+\sum_{v\in V'}c_{(u,v)}) \nonumber &\\ &=\sum_{v\in\overline{V'}}Q+\sum_{u\in V'}(Q+2g-\sum_{v\in V'}c_{(u,v)}) \nonumber &\\ &=\sum_{v\in V'}Q+\sum_{v\in\overline{V'}}Q+\sum_{u\in V'}2g-\sum_{u\in V'}\sum_{v\in V'}c_{(u,v)} \nonumber &\\ &=nQ+2g|V'|-2|E'| \nonumber &\end{align}$$

最后得到一个肥肠简单的式子：

$$C(S,T)=nQ+2(g|V'|-|E'|)\nonumber$$

显然地， 是针对全局的定值，而 就是整道题的答案，也就有：

$$\min\{g|V'|-|E'|\}=\frac{1}{2}\min\{C(S,T)-nQ\}\nonumber$$

总结全题：

点数： ，边数： 。时间复杂度在于 ，取决于二分的值域以及跑最小割（最大流）的算法。

后来发现，二分的值域可以取 ，不过取 也不会有太大影响。

需要注意的是：上述所有方法都是限于无权点无权边最大密度子图问题，如果有权点或者有权边则需另加讨论。

模板题指路

AC Code

const int MAXN=201,MAXM=5e3+1;
const int INF=1e9;
const double eps=1e-8;
int N,M,S,T;
struct G
{
    int next,to;
    double val;
    G(int n=0,int t=0,double v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
struct Eg
{
    int u,v;
}Edges[MAXM<<1];
int Head[MAXN],Total=1;
int Deg[MAXN],ans,Cur[MAXN];
bool St[MAXN];
inline void addEdge(int u,int v,double w1,double w2)
{
    Edge[++Total]=G(Head[u],v,w1);Head[u]=Total;
    Edge[++Total]=G(Head[v],u,w2);Head[v]=Total;
}
void build(double g)
{
    memset(Head,0,sizeof(Head));
    Total=1;
    for(int i=1;i<=M;++i) addEdge(Edges[i].u,Edges[i].v,1,1);
    for(int i=1;i<=N;++i)
    {
        addEdge(S,i,M,0);
        addEdge(i,T,M+g*2-Deg[i],0);
    }
}
int Fl[MAXN];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val>0)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
double Dfs(int x,double inf)
{
    if(x==T) return inf;
    double flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val>0)
        {
            double k=Dfs(v,min(Edge[e].val,inf-flow));
            if(k<=0) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
double Dinic(double g)
{
    build(g);
    double r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
void Search(int x)
{
    St[x]=1;
    if(x!=S) ++ans;
    for(int e=Head[x];e;e=Edge[e].next)
    {
        int v=Edge[e].to;
        if(!St[v]&&Edge[e].val>0) Search(v);
    }
}
int main()
{
    // freopen("minCut.in","r",stdin);
    // freopen("minCut.out","w",stdout);
    while((scanf("%d%d",&N,&M))!=EOF)
    {
        S=0,T=N+1;
        memset(Deg,0,sizeof(Deg));
        memset(St,0,sizeof(St));
        ans=0;
        for(int i=1,u,v;i<=M;++i)
        {
            read(u,v);
            ++Deg[u],++Deg[v];
            Edges[i]={u,v};
        }
        double l=0,r=M;
        while(r-l>eps)
        {
            double mid=(l+r)/2;
            double k=Dinic(mid);
            if(M*N-k>0) l=mid;
            else r=mid;
        }
        Dinic(l);
        Search(S);
        if(!ans) printf("1\n1\n");
        else
        {    
            printf("%d\n",ans);
            for(int i=1;i<=N;++i)
                if(St[i]) printf("%d\n",i);
        }
    }
    return 0;
}

---

最小权点覆盖集

点覆盖集 是一个集合，满足图上所有边的至少一个端点都在集合内，所有点覆盖集中，总点权值最小的集合就是最小权点覆盖集。

求解是一个 完全问题。即没有多项式时间复杂度的做法，有且仅有枚举暴力的实现。但在一个二分图里，有一种特殊的最小权点覆盖集。

最大权独立集

对于一般的最大权独立集而言，指的是：

在一个图 中选取一个点集 ，使 中任意两点不相连，其中 最大的集合称为 的最大权独立集。

---

网络最大流解决二分匹配问题

二分图匹配

另作讲解。

二分图最大匹配（匈牙利算法）

之后的二分图再另做讲解。

二分图最大匹配（网络流算法）

构造网络流模型：

1. 建立一个超级源点 与 中所有结点链接一条容量为 的边，表示一个结点只能被用 次；
2. 建立一个超级汇点 与 中所有结点链接一条容量为 的边，表示一个结点只能匹配 次。
3. 对于原图，链接 中的 与 中的 ，容量为 。

求出该图的最大流即是该二分图的最大匹配。

AC Code

const int MAXP=2001,MAXE=1e5+1;
const int INF=0x7f7f7f7f;int N,M,E,S,T;
struct G
{
    int next,to,val;
    G(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXE<<1];
int Head[MAXP],Cur[MAXP],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=G(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=G(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXP];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("Dinic.in","r",stdin);
    // freopen("Dinic.out","w",stdout);
    read(N,M,E);
    S=0,T=N+M+1;
    for(int i=1,u,v;i<=E;++i)
    {
        read(u,v);
        addEdge(u,M+v,1);
    }
    for(int i=1;i<=N;++i) addEdge(S,i,1);
    for(int i=1;i<=M;++i) addEdge(i+M,T,1);
    printf("%d",Dinic());
    return 0;
}

---

网络流解决二分匹配

以飞行员配对方案问题为例，最重要的是建出网络模型，然后照板子跑就好了。建出一个 源点和一个 汇点，然后链接 和所有外籍飞行员，链接 和所有英国飞行员，然后将所有能够匹配的外籍飞行员和英国飞行员链接，容量皆为 。最后检验一些建构出的网络的可行流和原问题的可行方案是否对应，如果是，说明建图成功，跑模板。

AC Code

const int MAXN=101;
const int INF=0x7f7f7f7f;
int N,M,S,T;
struct Graph
{
    int next,to,val;
    Graph(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXN*MAXN];
int Head[MAXN],Total=1,newTail[MAXN],Fl[MAXN];
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Graph(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Graph(Head[v],u,0);Head[v]=Total;
}
inline bool Bfs()
{
    queue<int>Q;
    memset(Fl,0,sizeof(Fl));
    Fl[S]=1;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
            if(!Fl[Edge[e].to]&&Edge[e].val)
            {
                Fl[Edge[e].to]=Fl[u]+1;
                Q.push(Edge[e].to);
            }
    }
    return Fl[T]!=0;
}
inline int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int s=0;
    for(int e=newTail[x];e;e=Edge[e].next)
    {
        newTail[x]=e;
        if(Fl[Edge[e].to]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(Edge[e].to,min(inf-s,Edge[e].val));
            if(k)
            {
                Edge[e].val-=k;
                Edge[e^1].val+=k;
                s+=k;
            }
        }
    }
    if(s<inf) Fl[x]=-1;
    return s;
}
inline void Dinic()
{
    int maxFlow=0;
    while(Bfs())
    {
        for(int i=0;i<=N+1;++i) newTail[i]=Head[i];
        maxFlow+=Dfs(S,INF);
    }
    if(maxFlow==0) printf("No Solution!");
    else
    {
        printf("%d\n",maxFlow);
        for(int i=2;i<=Total;i+=2)
        {
            if(Edge[i].to!=S&&Edge[i^1].to!=S)
                if(Edge[i].to!=T&&Edge[i^1].to!=T)
                    if(Edge[i^1].val!=0)
                        printf("%d %d\n",Edge[i^1].to,Edge[i].to);
        }
    }
}
int main()
{
    // freopen("dinic.in","r",stdin);
    // freopen("dinic.out","w",stdout);
    read(M,N);
    int u,v;
    T=N+1;
    read(u,v);
    while(u!=-1&&v!=-1)
    {
        addEdge(u,v,1);
        read(u,v);
    }
    for(int i=1;i<=M;++i) addEdge(S,i,1);
    for(int i=M+1;i<=N;++i) addEdge(i,T,1);
    Dinic();
    return 0;
}

---

最小割求解最小权点覆盖集

有性质：

在二分图中，有一个特殊的性质：当所有点权都是 时，有最大匹配数等于最小权点覆盖集；最大权独立集等于点数减去最小权点覆盖集。

在二分图中，最小权点覆盖集解决了这一类问题：

在二分图中，对于每条边，两个端点至少选一个，求所选取的点的最小权值和。

对应方法：

1. 二分图染色，使每一条边的端点颜色不同；
2. 建立超级源点 与所有颜色为 的边链接一条容量为该点权值的边；
3. 建立超级汇点 与所有颜色为 的边链接一条容量为该点权值的边。
4. 对于二分图中原有的边，改为从 到 的容量为 的边。

求取构造网络的最大流（最小割），结果则是最小点权和。 （这个结论我暂时还没有理解，但是挺好背，所以先背比较好）

---

最小割求解最大点权独立集

因为有：

最大权独立集等于所有点的总权值减去最小权点覆盖。

所以这两个问题其实是相通的，只是输出的答案略微不同罢了。

最大点权独立集模板题的双倍经验。

因为不能够选相邻的点，则我们将所有点分为两类使每一类不存在相邻。

建图：

1. 对于所有 类点，链接 ；

2. 对于所有 类点，链接 ；

3. 对于相邻的点 ，链接 。

如上述方法一致。

AC Code

const int MAXN=101,MAXP=2e4+1,MAXE=2e6+1;
const int INF=0x3f3f3f3f;
const int Dx[]={0,1,-1,0,0};
const int Dy[]={0,0,0,-1,1};int N,M,S,T;
struct G
{
    int next,to,val;
    G(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXE<<1];
int Head[MAXP],Cur[MAXP],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=G(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=G(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXP];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
bool Color[MAXN][MAXN];
int main()
{
    // freopen("netflow.in","r",stdin);
    // freopen("netflow.out","w",stdout);
    read(N,M);
    S=0,T=N*M+1;
    for(int i=1;i<=N;++i)
        for(int j=1;j<=M;++j)
        {
            if(((i&1)&&(j&1))||((!(i&1))&&(!(j&1))))
                Color[i][j]=1;
            else Color[i][j]=0;
        }
    /*for(int i=1;i<=N;++i){
        for(int j=1;j<=M;++j) cout<<Color[i][j]<<" ";
        puts("");
    }*/
    ll Cnt=0;
    for(int i=1;i<=N;++i)
        for(int j=1,x;j<=M;++j)
        {
            read(x);
            Cnt+=x;
            if(Color[i][j]) addEdge(M*(i-1)+j,T,x);
            else
            {
                addEdge(S,M*(i-1)+j,x);
                for(int k=1;k<=4;++k)
                {
                    int Nx=i+Dx[k],Ny=j+Dy[k];
                    if(Nx<1||Ny<1||Nx>N||Ny>M) continue;
                    addEdge(M*(i-1)+j,M*(Nx-1)+Ny,INF);
                }
            }
        }
    printf("%d",Cnt-Dinic());
    return 0;
}

---

上下界网络流

字面意思，对于每一条边的可行流，存在最小流 和最大流 ，该边在满足最大流的所有性质的前提下，必须满足 。这是上下界可行流。

上下界流分为有源汇和无源汇两种情况。

---

无源汇上下界可行流

我居然先理解的是有源汇。

所谓可行流，就是满足容量限制，流守恒性，斜对称性的流。而对于拥有上下界的网络，其限制严格许多。

首先，下界必须流满，所以我们可以在建边时直接将容量建为 ，但是又考虑到每条边的下界并不一定相等，所以，我们需要额外找出位置来平衡流量：

建立虚拟源点和虚拟汇点。

令虚拟源点为 ，虚拟汇点为 ，对于点 流入的流量为 ，流出的流量为 。出入的流量差记为 。则有：

1. ，多流入了流量由 补足，连边 。
2. ，流量平衡，不连边（连出来也是一条容量为 的边）。
3. ，多流出的流量流入 ，连边 。

这样其实就变成了一个常规的有源汇网络，然后跑最大流即可（毕竟最大流也是一种特殊的可行流）。如果跑得出来，那么除了 和 之外的所有点的容量应当是守恒的，则说明原图存在可行流。

模板无源汇上下界可行流

AC Code

const int MAXN=501,MAXM=2e5+1;
const int INF=0x7f7f7f7f;
int N,M,vS,vT;
struct Graph
{
    int next,to,val;
    Graph(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Lo[MAXM<<1],Total=1;
inline void addEdge(int u,int v,int lo,int up)
{
    Edge[++Total]=Graph(Head[u],v,up-lo);Lo[Total]=lo;Head[u]=Total;
    Edge[++Total]=Graph(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXN],Dif[MAXN];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[vS]=0,Cur[vS]=Head[vS];
    queue<int>Q;
    Q.push(vS);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==vT) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==vT) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(vS,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("unset-flow.in","r",stdin);
    // freopen("unset-flow.out","w",stdout);
    read(N,M);
    vS=0,vT=N+1;
    for(int i=1,u,v,lo,up;i<=M;++i)
    {
        read(u,v,lo,up);
        addEdge(u,v,lo,up);
        Dif[u]-=lo,Dif[v]+=lo;
    }
    int Tot=0;
    for(int i=1;i<=N;++i)
        if(Dif[i]>0) addEdge(vS,i,0,Dif[i]),Tot+=Dif[i];
        else if(Dif[i]<0) addEdge(i,vT,0,-Dif[i]);
    if(Dinic()!=Tot) printf("NO");
    else
    {
        puts("YES");
        for(int e=2;e<=M*2;e+=2)
            printf("%d\n",Edge[e^1].val+Lo[e]);
    }
    // for(int e=1;e<=M*2;++e) printf("%d ",Lo[e]);
    return 0;
}

---

有源汇上下界可行流

有给定的源点和汇点，求该网络的可行流。

凡事讲究一个推进，所以我们选择将有源汇的问题转化为无源汇的问题。首先，对于有源汇的问题而言，其与无源汇问题最大的不同就在于其 源点的流量与 汇点的流量一定不同。那么，我们就需要使其相同：

连接一条从 到 上界为 下界为 的边。这样就会使流量守恒定律一样满足于源汇点了。

有源汇上下界最小/最大流

最大流

首先跑出一条可行流，对于虚拟源点 到虚拟汇点 的边已经流满，但是通过定义：最大流 可行流 向上浮动的流量。所以我们要在残余网络中尽量跑满上限。

而我们需要在原图的源汇路径上重找增广路，可以得到结论是向上浮动的流量就是真实源点 到真实汇点 的最大流。

注意：跑最后一次最大流时需要把边 删掉。

模板有源汇上下界最大流

AC Code

const int MAXN=501,MAXM=2e4+1;
const int INF=0x7f7f7f7f;
int N,M,S,T,Sv,Tv;
struct Graph
{
    int next,to,val;
    Graph(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Graph(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Graph(Head[v],u,0);Head[v]=Total;
}
int A[MAXN],Fl[MAXN];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[Sv]=0,Cur[Sv]=Head[Sv];
    queue<int>Q;
    Q.push(Sv);
    while(!Q.empty())
    {
        int x=Q.front();Q.pop();
        for(int e=Head[x];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[x]+1;
                Cur[v]=Head[v];
                if(v==Tv) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==Tv) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(Sv,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("maxflow.in","r",stdin);
    // freopen("maxflow.out","w",stdout);
    read(N,M,S,T);
    Sv=0,Tv=N+1;
    for(int i=1,u,v,w,c;i<=M;++i)
    {
        read(u,v,w,c);
        addEdge(u,v,c-w);
        A[u]-=w,A[v]+=w;
    }
    int Tot=0;
    for(int i=1;i<=N;++i)
        if(A[i]>0) addEdge(Sv,i,A[i]),Tot+=A[i];
        else if(A[i]<0) addEdge(i,Tv,-A[i]);
    addEdge(T,S,INF);
    if(Dinic()<Tot) puts("please go home to sleep");
    else
    {
        int res=Edge[Total].val;
        Sv=S,Tv=T;
        Edge[Total].val=Edge[Total-1].val=0;
        printf("%d\n",res+Dinic());
    }
    return 0;
}

---

最小流

从代码的角度来讲，最小流代码与最大流代码只有 处不同。

把上下界最大流比作是“榨干”，那上下界最小流就是把残余网络“退钱”。——

所以，最后从 向 跑一遍最大流，再把第一次跑的最大流减去跑的第二次最大流就是原图的最小流了。

也要删去最后一条边！！

模板有源汇上下界最小流

AC Code

const int MAXN=1e5+1,MAXM=3e5+1;
const int INF=0x7f7f7f7f;
int N,M,S,T,vS,vT;
struct Graph
{
    int next,to,val;
    Graph(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Graph(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Graph(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXN],A[MAXN];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[vS]=0,Cur[vS]=Head[vS];
    queue<int>Q;
    Q.push(vS);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==vT) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==vT) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(vS,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("minflow.in","r",stdin);
    // freopen("minflow.out","w",stdout);
    read(N,M,S,T);
    vS=0,vT=N+1;
    for(int i=1,u,v,up,lo;i<=M;++i)
    {
        read(u,v,lo,up);
        addEdge(u,v,up-lo);
        A[u]-=lo,A[v]+=lo;
    }
    int Tot=0;
    for(int i=1;i<=N;++i)
        if(A[i]>0) addEdge(vS,i,A[i]),Tot+=A[i];
        else if(A[i]<0) addEdge(i,vT,-A[i]);
    addEdge(T,S,INF);
    if(Dinic()<Tot) printf("please go home to sleep");
    else
    {
        int res=Edge[Total].val;
        vS=T,vT=S;						//不同点1
        Edge[Total].val=Edge[Total-1].val=0;
        printf("%d",res-Dinic());		//不同点2
    }
    return 0;
}

---

费用流

最小费用最大流

不同于最大流的普通网络，对于每一条边，除了源初的 表示容量限制以外，还存在一个单位流量的费用表示 。即流过 个单位流量所花费的费用。

则有当边 流过 的流量时，就需要支付 的费用。

函数依然满足斜对称性，即有 。

在一个网络中花费最小的最大流称为最小费用最大流。一般是在最大化 的前提下最小化 。

---

SSP 算法

算法是基于贪心的算法，每次寻找单位费用最小的增广路进行增广以满足当前费用最小，直到图不存在增广路。

SSP 算法不能求解负圈，如果存在单位费用为负的圈（即负圈），则需要先使用消圈算法消除图上的负圈。

的算法时间复杂度取决于求最短路的时间复杂度和寻找增广路的时间复杂度，设网络的最大流为 ，寻找增广路的时间复杂度为 ，则上界的时间复杂度为 。而事实上，该算法是伪多项式时间的。（关于值域的多项式）

对于 的实现，只需将 寻找增广路的算法替换为使用最短路算法寻找单位费用最小的增广路即可。（ 我就不写了）

注意费用流的建边操作满足：

对于有向边 ，其中 为流量， 为费用；则其反边则为 。

参考代码

const int MAXN=5e3+1;
const int MAXM=1e5+1;
const int INF=0x3f3f3f3f;
int N,M,S,T;
struct Net
{
    int next,to,val,cost;
    Net(int n=0,int t=0,int v=0,int c=0):
        next(n),to(t),val(v),cost(c){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=Net(Head[u],v,w,c);Head[u]=Total;
    Edge[++Total]=Net(Head[v],u,0,-c);Head[v]=Total;
}
int Dist[MAXN],ret;
bool Vis[MAXN];
inline bool Spfa(int s,int t)
{
    memset(Dist,0x3f,sizeof(Dist));
    memcpy(Cur,Head,sizeof(Head));
    queue<int>Q;
    Q.push(s),Dist[s]=0,Vis[s]=1;
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Edge[e].val&&Dist[v]>Dist[u]+Edge[e].cost)
            {
                Dist[v]=Dist[u]+Edge[e].cost;
                if(!Vis[v]) Q.push(v),Vis[v]=1;
            }
        }
    }
    return Dist[t]!=INF;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    Vis[x]=1;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(!Vis[v]&&Edge[e].val&&Dist[v]==Dist[x]+Edge[e].cost)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(k)
            {
                ret+=k*Edge[e].cost;
                Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
            }
        }
    }
    Vis[x]=0;
    return flow;
}
inline int Dinic()
{
    int res=0,flow;
    while(Spfa(S,T)) while(flow=Dfs(S,INF)) res+=flow;
    return res;
}
int main()
{
    // freopen("mincost-maxflow.in","r",stdin);
    // freopen("mincost-maxflow.out","w",stdout);
    read(N,M,S,T);
    for(int i=1,u,v,w,c;i<=M;++i) 
    {
        read(u,v,w,c);
        addEdge(u,v,w,c);
    }
    int ans=Dinic();
    printf("%d %d",ans,ret);
    return 0;
}

---

Primal-Dual 原始对偶算法

这个算法似乎和 全源最短路 有些许类似。（看到这句话我还去学了一下 全源最短路算法）

因为费用流的时间复杂度受限于其求最短路的时间，而最快的算法 却无法使用（因为存在负费用），那么，我们为每一个点设置一个势能使所有的费用都变成非负值，这点类似于 算法，从而使费用流的计算可以应用 算法。

与 相似，首先跑一次最短路，求出源点到任意点的最短距离，即该点的初始势能 。然后将边 处理成 即可。

与常规的最短路问题不同的是，每次增广后图的形态会发生变化，这种情况下各点的势能需要更新。

令增广之后 到 点的最短距离为 （边权重置之后），然后将 加上 即可。这样可以使图上所有边的边权均为非负。

对于原有的边，增广之前有 ，因此 ，即用 作为新势能并不会使 的边权变为负。

对于该算法求增广路，可以用一个结构体 表示这一条增广路走到 时的起点是 ，边的编号是 ，然后就可以用一个逆推来移除增广路。

可以对比一下两种方法的时间：

算法	朴素

AC Code

const int MAXN=5e3+1;
const int MAXM=5e4+1;
const int INF=0x3f3f3f3f;
int N,M,S,T;
struct Net
{
    int next,to,val,cost;
    Net(int n=0,int t=0,int v=0,int c=0):
        next(n),to(t),val(v),cost(c){}
}Edge[MAXM<<1];
struct Que
{
    int now,d;
    Que(int n=0,int d=0):now(n),d(d){}
    bool operator<(const Que& a)const
    {
        return d>a.d;
    }
};
struct Node
{
    int v,e;
    Node(int v=0,int e=0):v(v),e(e){}
}P[MAXN];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=Net(Head[u],v,w,c);Head[u]=Total;
    Edge[++Total]=Net(Head[v],u,0,-c);Head[v]=Total;
}
int Dist[MAXN],H[MAXN],MaxF,MinC;
bool Vis[MAXN];
inline bool Dijkstra()
{
    priority_queue<Que>Q;
    memset(Dist,0x3f,sizeof(Dist));
    memset(Vis,0,sizeof(Vis));
    Dist[S]=0;Q.push(Que(S,0));
    while(!Q.empty())
    {
        int u=Q.top().now;Q.pop();
        if(Vis[u]) continue;
        Vis[u]=1;
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to,Nc=Edge[e].cost+H[u]-H[v];
            if(Edge[e].val&&Dist[v]>Dist[u]+Nc)
            {
                Dist[v]=Dist[u]+Nc;
                P[v]=Node(u,e);
                if(!Vis[v]) Q.push(Que(v,Dist[v]));
            }
        }
    }
    return Dist[T]!=INF;
}
inline void Spfa()
{
    queue<int>Q;
    memset(H,0x3f,sizeof(H));
    H[S]=0,Vis[S]=1;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Edge[e].val&&H[v]>H[u]+Edge[e].cost)
            {
                H[v]=H[u]+Edge[e].cost;
                if(!Vis[v])
                {
                    Vis[v]=1;
                    Q.push(v);
                }
            }
        }
    }
}
int main()
{
    // freopen("primal-dual.in","r",stdin);
    // freopen("primal-dual.out","w",stdout);
    read(N,M,S,T);
    for(int i=1,u,v,w,c;i<=M;++i)
    {
        read(u,v,w,c);
        addEdge(u,v,w,c);
    }
    Spfa();
    while(Dijkstra())
    {
        int MinF=INF;
        for(int i=1;i<=N;++i) H[i]+=Dist[i];
        for(int i=T;i!=S;i=P[i].v) checkMin(MinF,Edge[P[i].e].val);
        for(int i=T;i!=S;i=P[i].v)
        {
            Edge[P[i].e].val-=MinF;
            Edge[P[i].e^1].val+=MinF;
        }
        MaxF+=MinF;
        MinC+=MinF*H[T];
    }
    printf("%d %d",MaxF,MinC);
    return 0;
}

---

最大费用最大流

其实这个东西也很简单，对于原来的费用网络，我们在构造网络的时候把每一条边的费用都取为 ，然后跑一遍最小费用最大流，这个时候的费用是一个极小的负数，也就是原来费用网络中的最大费用最大流的答案的相反数，输出 即可。

有源汇上下界最小费用可行流

应该是套娃极限了。

其模型基于最小费用最大流和有源汇上下界可行流。所以将上下界网络转换为通常网络，然后套上费用流的模型即可。

先建一个有源汇上下界最大流的图，边权加上费用，然后加上所有的下界和对应费用的乘积之和，为了让有源汇上下界最大流的图中虚点间的边满流，就选用最小费用最大流，直接跑最小费用最大流即可，如果没有满流那就无解，最后答案是求出来的最小费用最大流的费用和与先前已经计算的下界和对应费用乘积之和。

摘自 博客。

对于一条边，我们需要存储 ，表示起点，终点，下界，上界和费用。

与上下界网络流一样，建立虚拟源汇点 ，然后就可以开始建图了：

1. 对于边 ，链接 ，容量为 ，费用为 ；
2. 记录 表示流量差，根据 的不同链边。通俗地讲， 表示流入下界和与流出下界和的差。
   1. 若 ，则链接 ，容量为 ，费用为 ；
   2. 若 ，则链接 ，容量为 ，费用为 。
3. 链接 ，容量为 ，费用为 。

第三步很好理解，把有源汇转化为无源汇。

然后记录答案为 ，当然，只要是最小费用最大流的算法都可以。

最后答案就是 。

即求出的费用加上原图中边下界与边费用的积。

注意：这里的流不一定是最大流。

---

80人环游世界

跑了一圈发现基本上都没几个写 的，要么是 ，要么直接暴力推流。总之，说说建图：

1. 拆点，将每个国家拆为出入两点，链接 ，容量 ，固定容量；
2. 建立虚拟结点 ，链接 ，容量为 ，并链接 ，容量为 ；
3. 链接 ，容量 。
4. 对于道路，链接 ，容量 ，费用为机票费用。

然后，这道题也可以不用上下界（其实上下界本身的解题思路就是化上下界为通常）。下面就是常规费用流 写法。

AC Code

const int MAXN=5e2+10;
const int MAXM=5e5+10;
const int INF=0x3f3f3f3f;
int N,M,S,T,Ex;
struct Net
{
    int next,to,val,cost;
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=(Net){Head[u],v,w,c};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0,-c};Head[v]=Total;
}
int Dist[MAXN],ret;
bool Vis[MAXN];
inline bool Spfa(int s,int t)
{
    memset(Dist,0x3f,sizeof(Dist));
    memset(Vis,0,sizeof(Vis));
    Dist[s]=0;
    std::queue<int>Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Dist[v]>Dist[u]+Edge[e].cost&&Edge[e].val)
            {
                Dist[v]=Dist[u]+Edge[e].cost;
                if(!Vis[v]) Vis[v]=1,Q.push(v);
            }
        }
    }
    return Dist[t]!=INF;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;Vis[x]=1;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e,v=Edge[e].to;
        if(!Vis[v]&&Dist[v]==Dist[x]+Edge[e].cost&&Edge[e].val)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(k)
            {
                Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
                ret+=k*Edge[e].cost;
            }
        }
    }
    Vis[x]=0;
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Spfa(S,T))
    {
        memcpy(Cur,Head,sizeof(Head));
        while(flow=Dfs(S,INF)) r+=flow;
    }
    return r;
}
int V[MAXN];
int main()
{
    // freopen("upper-lower-st-mincost-netflow.in","r",stdin);
    // freopen("upper-lower-st-mincost-netflow.out","w",stdout);
    read(N,M);
    S=0,T=N+N+1,Ex=T+1;
    addEdge(S,Ex,M,0);
    for(int i=1;i<=N;++i)
    {
        read(V[i]);
        addEdge(i+N,T,V[i],0);
        addEdge(Ex,i+N,INF,0);
    }
    for(int i=1;i<=N;++i)
    {
        addEdge(S,i,V[i],0);
        for(int j=i+1,v;j<=N;++j)
        {
            read(v);
            if(v==-1) continue;
            addEdge(i,j+N,INF,v);
        }
    }
    Dinic();
    write(ret);
    return 0;
}

---

[AHOI2014/JSOI2014]支线剧情

真的诶，翻遍全网居然没有写 的？（贺都找不到地方）

然后就贺了一个 的板子然后瞎改成了 。

所谓的 算法，就是暴力推流，也就是费用流的 算法。在 上无异，但是会记录一个数组 表示是通过编号为 的边转移到的 ，并用 记录当前增广路的流量，然后用一个逆推从 计算答案。

这里给出 的函数：

参考代码

inline void Mcmf()
{
    int minCost=0;
    while(Spfa())
    {
        int x=T;
        minCost+=Dist[x]*Incf[x];
        while(x!=S)
        {
            int e=Pre[x];
            Edge[e].val-=Incf[T],Edge[e^1].val+=Incf[T];
            x=Edge[e^1].to;
        }
    }
    ret+=minCost;
}

然后就是名正言顺的 的上下界费用流写法。（甚至以 冲进了最优解）其实与上下界网络流无异，就是将 Bfs() 换成 Spfa() 即可，难点依然在建图：

1. 对于剧情 能够到达 ，链接 ，容量为 ，费用为 。
2. 因为除了 号剧情，其它所有剧情都应该能够直接结束，所以链接 ，这里的 是真实汇点，容量为 ，费用为 ；
3. 对于流量不守恒的点，根据 的正负，链接虚拟源点或者虚拟汇点，容量为 ，费用为 。
4. 链接 ，都是真实的。容量为 ，费用为 。

因为这里只是求取可行流，所以跑一遍即可。

AC Code

const int MAXN=1e3+10;
const int MAXM=1e6+10;
const int INF=0x3f3f3f3f;
int N,M,S,T,ret;
struct Net
{
    int next,to,val,cost;
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=(Net){Head[u],v,w,c};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0,-c};Head[v]=Total;
}
int Dist[MAXN],A[MAXN];
bool Vis[MAXN];
inline bool Spfa()
{
    std::queue<int>Q;
    memset(Dist,0x3f,sizeof(Dist));
    memset(Vis,0,sizeof(Vis));
    Q.push(S);
    Dist[S]=0;
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Dist[v]>Dist[u]+Edge[e].cost&&Edge[e].val)
            {
                Dist[v]=Dist[u]+Edge[e].cost;
                if(!Vis[v]) Vis[v]=1,Q.push(v);
            }
        }
    }
    return Dist[T]!=INF;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;Vis[x]=1;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(!Vis[v]&&Edge[e].val&&Dist[v]==Dist[x]+Edge[e].cost)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(k)
            {
                ret+=k*Edge[e].cost;
                Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
            }
        }
    }
    Vis[x]=0;
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Spfa())
    {
        memcpy(Cur,Head,sizeof(Head));
        while(flow=Dfs(S,INF)) r+=flow;
    }
    return r;
}
int main()
{
    // freopen("netflow.in","r",stdin);
    // freopen("netflow.out","w",stdout);
    read(N);
    int rS=1,rT=N+1,vS=N+2,vT=N+3;
    for(int i=1,k;i<=N;++i)
    {
        read(k);
        for(int j=1,u,v;j<=k;++j)
        {
            read(u,v);
            ++A[u],--A[i];
            ret+=v;addEdge(i,u,INF-1,v);
        }
    }
    for(int i=2;i<=N;++i) addEdge(i,rT,INF,0);
    for(int i=1;i<=N;++i)
    {
        if(A[i]>0) addEdge(vS,i,A[i],0);
        else if(A[i]<0) addEdge(i,vT,-A[i],0);
    }
    addEdge(rT,rS,INF,0);
    S=vS,T=vT;
    Dinic();
    write(ret);
    return 0;
}
/*
6
2 2 1 3 2
2 4 3 5 4
2 5 5 6 6
0
0
0
*/

---

网络流的实际应用（构造网络）

如果一道题能够使用网络流来做（一般指最大流和最小割），那这道题的代码非常格式化：

1. 建图，构造出原网络；
2. 增广，并计算出答案。

结束。就这么简单……么？

网络流的板子在于其第 步，正因如此，难点在于如何建图。

---

一道难题 Tree

其实可以用树型 来解，但我们今天不谈 。

我们发现，如果使叶节点和根节点分离，最小的代价就是从根节点到叶节点的路径的最小边的代价。这与一条增广路是类似的，那么，我们可以把这道题转换成另外一个模型。

对于原图的根节点，则是网络的超级汇点 ，每一个叶节点都是一个汇点 ，最后求源点到汇点的最大流。就是一个模板的多源汇最大流了，然后我们链接一个超级汇点 ，链接所有叶子汇点，求从超级源点到超级汇点的最大流。

但是，这道题的边是双向边，在开始的时候我们并不知道谁是起点谁是终点，所以我们跑一遍 处理出叶节点并连边，并将双向边处理成单向边。

AC Code

const int MAXN=2e5+1;
const int MAXM=5e5+1;
const int INF=0x7f7f7f7f;
template<class T>
inline void read(T &x)
{
    x=0;
    char ch=gh(),t=0;
    while(ch<'0'||ch>'9') t|=ch=='-',ch=gh();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+(ch^48),ch=gh();
    if(t) x=-x;
}
template<class T,class ...T1>
inline void read(T &x,T1 &...x1)
{
    read(x),read(x1...);
}
template<class T>
inline bool checkMax(T &x,T &y)
{
    return x<y?x=y,1:0;
}
template<class T>
inline bool checkMin(T &x,T &y)
{
    return x>y?x=y,1:0;
}
int N,S,T;
struct Net
{
    int next,to,val;
    Net(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Net(Head[u],v,w);Head[u]=Total;
}
int Fl[MAXN];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
void dpTree(int x,int last)
{
    bool flag=0;
    for(int e=Head[x],v;e;e=Edge[e].next)
    {
        if((v=Edge[e].to)==last) continue;
        dpTree(v,x);
        flag=1;
        Edge[e^1].val=0;	//处理双向边
    }
    if(!flag)		//链接超级汇点
    {
        addEdge(x,T,INF);
        addEdge(T,x,0);
    }
    return ;
}
int main()
{
    // freopen("mxaflow.in","r",stdin);
    // freopen("maxflow.out","w",stdout);
    read(N,S);
    T=N+1;
    for(int i=2,u,v,w;i<=N;++i)
    {
        read(u,v,w);
        addEdge(u,v,w);
        addEdge(v,u,w);
    }
    dpTree(S,-1);
    printf("%d",Dinic());
    return 0;
}
/*
4 1
1 2 1 
1 3 1
1 4 1
*/    

---

蜥蜴

将平面二维图建立成网络。可以发现，能够流入的网络应该是 的，而能够流出的流量就是该点的高度（权值）。这里会用到一种叫拆点的技巧——顾名思义，将原来的 结点拆成 和 两个结点， 用来链接原来指向 的边， 用来链接原来从 出发的边。而链接 和 以保证经过 之后只能有 只蜥蜴。

建图：

1. 对于 的结点，链接 ；
2. 对于 ，链接 ；
3. 对于 ，即存在蜥蜴，链接 ；
4. 对于 ，即达到边界，链接 。

为什么所有容量都可以设成 ？因为能够通过 点的流，必然会经过 的边，则其最多的流量必然会是 ，而避免胡乱赋值导致容量变小，不如全部赋为 。

AC Code

const int MAXR=21;
const int MAXP=1e3+1;
const int MAXE=2e4+1;
const int INF=0x7f7f7f7f;
template<class T>
inline void read(T &x)
{
    x=0;
    char ch=gh(),t=0;
    while(ch<'0'||ch>'9') t|=ch=='-',ch=gh();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+(ch^48),ch=gh();
    if(t) x=-x;
}
template<class T,class ...T1>
inline void read(T &x,T1 &...x1)
{
    read(x),read(x1...);
}
template<class T>
inline bool checkMax(T &x,T &y)
{
    return x<y?x=y,1:0;
}
template<class T>
inline bool checkMin(T &x,T &y)
{
    return x>y?x=y,1:0;
}
int R,C,D,Dth,S,T,Tot;
struct G
{
    int next,to,val;
    G(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXE<<1];
int Head[MAXP],Cur[MAXP],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=G(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=G(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXP];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
char opt[MAXR];
inline int Dist(int x1,int y1,int x2,int y2)
{
    return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
}
inline int In(int i,int j)
{
    return C*(i-1)+j;
}
inline int Out(int i,int j)
{
    return C*(i-1)+j+R*C;
}
int main()
{
    // freopen("maxflow.in","r",stdin);
    // freopen("maxflow.out","w",stdout);
    read(R,C,D);
    Dth=D*D;
    S=0,T=2*R*C+1;
    for(int i=1;i<=R;++i)
    {
        scanf("%s",opt+1);
        for(int j=1;j<=C;++j)
            if(opt[j]!='0') addEdge(In(i,j),Out(i,j),opt[j]-'0');
    }
    for(int i=1;i<=R;++i)
    {
        scanf("%s",opt+1);
        for(int j=1;j<=C;++j)
            if(opt[j]=='L') addEdge(S,In(i,j),1),++Tot;
    }
    for(int i=1;i<=R;++i)
        for(int j=1;j<=C;++j)
            if(i-D<1||j-D<1||i+D>R||j+D>C) addEdge(Out(i,j),T,INF);
    for(int i=1;i<=R;++i)
        for(int j=1;j<=C;++j)
            for(int k=1;k<=R;++k)
                for(int l=1;l<=C;++l)
                    if(Dist(i,j,k,l)<=Dth)
                        addEdge(Out(i,j),In(k,l),INF);
    printf("%d",Tot-Dinic());
    return 0;
}
/*
5 8 2
00000000
02000000
00321100
02000000
00000000
........
........
..LLLL..
........
........
*/

---

假期的宿舍

有点像二分图匹配，所以考虑最大流。

把学生看作是结点 ，床看作是结点 ，建图：

1. 如果该学生留校（包括看望的学生），链接 与该学生；
2. 如果该学生有床，链接该学生的床和 。
3. 链接每一位本校学生和自己的床。
4. 如果 和 认识，链接学生 的人和学生 的床。
5. 容量都是 。

跑一遍 就好了。

AC Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<ctime>
#include<iomanip>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#define gh() getchar()
#define re register
typedef long long ll;
using namespace std;
const int MAXP=1e3+1;
const int MAXE=2e4+1;
const int INF=0x3f3f3f3f;
template<class T>
inline void read(T &x)
{
    x=0;
    char ch=gh(),t=0;
    while(ch<'0'||ch>'9') t|=ch=='-',ch=gh();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+(ch^48),ch=gh();
    if(t) x=-x;
}
template<class T,class ...T1>
inline void read(T &x,T1 &...x1)
{
    read(x),read(x1...);
}
template<class T>
inline bool checkMax(T &x,T &y)
{
    return x<y?x=y,1:0;
}
template<class T>
inline bool checkMin(T &x,T &y)
{
    return x>y?x=y,1:0;
}
int N,M,S,T;
struct Net
{
    int next,to,val;
    Net(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXE<<1];
int Head[MAXP],Cur[MAXP],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Net(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Net(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXP];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
int Test,Cnt;
bool In[MAXP];
inline void Solve()
{
    memset(In,0,sizeof(In));Cnt=0;
    memset(Head,0,sizeof(Head));Total=1;
    read(N);
    S=0,T=N+N+1;
    for(int i=1;i<=N;++i)
    {
        read(In[i]);
        if(In[i]) addEdge(i+N,T,1);
    }
    for(int i=1,x;i<=N;++i)
    {
        read(x);
        if((!x&&In[i])||(!In[i])) addEdge(S,i,1),++Cnt;
    }
    for(int i=1;i<=N;++i)
    {
        if(In[i]) addEdge(i,i+N,1);
        for(int j=1,x;j<=N;++j)
        {
            read(x);
            if(x) addEdge(i,j+N,1);
        }
    }
    if(Dinic()>=Cnt) printf("^_^\n");
    else printf("T_T\n");
}
int main()
{
    // freopen("maxflow.in","r",stdin);
    // freopen("maxflow.out","w",stdout);
    read(Test);
    while(Test--) Solve();
    return 0;
}
/*
1
3
1 1 0
0 1 0
0 1 1
1 0 0
1 0 0
*/

---

网络流 24 题

这玩意儿洛谷上有题单， 题都可以找得到。

---

餐巾计划问题

---

家园 / 星际转移问题

考虑到所有参数都极其的小，所以这题肯定没有想象的那么简单。

首先往网络流那个方面想，把人数当作流量是显然的，主要在于这个网络的构建应该从何开始。

考虑将地球作为源点，月球作为汇点。但事实上，地球和月球本身也是一个中转站，可能会经过而成为下一个太空船的接船口，所以我们不能让流量在此流失。所以考虑新建源汇点，直接连向地球与月球，流量为 。

这道题有一个判无解，这个简单，只要有任意两支（或者一支）太空船经过了地球和月球，那必有解，考虑用 维护。

如果判定了无解的话，我们可以考虑枚举时间来依次建点（最大数不超过 意味着我们可以跑很多很多次 ），在每一秒跑一次新结点的最大流，加到答案里，然后建出这一刻时间到下一刻时间的转移，依次类推，必定可以完成。

原题解

时间戳网络流。

首先，对于无解的情况，可以有两种判断方式，一种是使用并查集维护地球与月球之间是否连通，一种是跑一个周期（指此刻的状态与起始状态一致），然后是否有流动。

刚开始时，想到了跑一个周期，这样的话，一共需要建立 个结点，虽然有 ，但是最阴间的情况下，空间复杂度是 ，直接 。

所以考虑另一种方式——时间戳在线网络流，我们枚举一个时间 ，并在线维护哪些结点可以从 流向 ，又有哪些结点可以从源点流出，又可以流向汇点。

刚开始明明想到的是费用流，结果发现跑的还是最大流，费用是通过枚举得到的。

然后考虑如何递推在线构建网络。

对于每一个独立的飞船，可以连接一条容量为 ，即飞船容量的边 ，其中的 是路线， 是路线长度。

对于飞船与飞船之间，不靠飞船，靠太空站连接，容量为 。

然后特判一下源汇点，每向前推进一个单位的时间后跑一次 ，因为数据极小（甚至支持状态压缩），所以随便搞搞都不会 。

AC Code

// ----- Eternally question-----
// Problem: P2754 [CTSC1999]家园 / 星际转移问题
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2754
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Written by: Eternity
// Time: 2022-11-18 18:28:19
// ----- Endless solution-------

#include<bits/stdc++.h>
#define re register
typedef long long ll;
template<class T>
inline void read(T &x)
{
	x=0;
	char ch=getchar(),t=0;
	while(ch<'0'||ch>'9') t|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
	if(t) x=-x;
}
template<class T,class ...T1>
inline void read(T &x,T1 &...x1){ read(x),read(x1...); }
template<class T>
inline void write(T x)
{
	if(x<0) putchar('-'),x=-x;
	if(x>9) write(x/10);
	putchar(x%10+'0');
}
template<>
inline void write(bool x){ std::cout<<x; }
template<>
inline void write(char c){ putchar(c); }
template<>
inline void write(char *s){ while(*s!='\0') putchar(*s++); }
template<>
inline void write(const char *s){ while(*s!='\0') putchar(*s++); }
template<class T,class ...T1>
inline void write(T x,T1 ...x1){ write(x),write(x1...); }
template<class T>
inline bool checkMax(T &x,T y){ return x<y?x=y,1:0; }
template<class T>
inline bool checkMin(T &x,T y){ return x>y?x=y,1:0; }
const int MAXN=1e3+10,MAXV=1e4+10,MAXE=1e6+10;
const int INF=0x3f3f3f3f;
int N,M,K,S,T;
struct Net
{
    int next,to,val;
}Edge[MAXE<<1];
int Head[MAXV],Cur[MAXV],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=(Net){Head[u],v,w};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0};Head[v]=Total;
}
int Fl[MAXV];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    std::queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1,Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
struct Dsu
{
	int Rt[MAXN];
	inline void init(int n){ for(int i=1;i<=n;++i) Rt[i]=i; }
	int getRt(int x){ return Rt[x]==x?x:Rt[x]=getRt(Rt[x]); }
	inline void merge(int u,int v)
	{
		int p=getRt(u),q=getRt(v);
		if(p==q) return ;
		Rt[p]=q;
	}
	inline bool connect(int x,int y){ return (getRt(x)==getRt(y)); }
}Dsu;
int Num[MAXN],Cnt[MAXN];
std::vector<int>Path[MAXN];
int main()
{
    // freopen(".in","r",stdin);
    // freopen(".out","w",stdout);
	read(N,M,K);
	Dsu.init(N+3);
	S=0,T=MAXN-1;
	for(int i=1;i<=M;++i)
	{
		read(Num[i],Cnt[i]);
		for(int j=1,x;j<=Cnt[i];++j)
		{
			read(x);
			if(!x) x=N+1;
			else if(x==-1) x=N+2;
			Path[i].push_back(x);
			if(j>1) Dsu.merge(Path[i][j-2],Path[i][j-1]);
		}
	}
	if(!Dsu.connect(N+1,N+2)) return putchar('0'),0;
	int r=0;
	for(int ans=1;;++ans)
	{
		addEdge(S,ans*(N+1),INF);
		for(int i=1;i<=M;++i)
		{
			int x=(ans-1)%Cnt[i],y=ans%Cnt[i];
			if(Path[i][x]==N+2) x=T;
			else x=(ans-1)*(N+1)+Path[i][x];
			if(Path[i][y]==N+2) y=T;
			else y=ans*(N+1)+Path[i][y];
			addEdge(x,y,Num[i]);
		}
		r+=Dinic();
		if(r>=K) return write(ans),0;
		for(int i=1;i<=N+1;++i) addEdge((ans-1)*(N+1)+i,ans*(N+1)+i,INF);
	}
	return 0;
}
/*

*/

---

飞行员配对方案问题

二分图最大匹配的板子题，因为要输出方案，考虑用网络流解决。

输出方案的话，就直接判断当前边的反边是否存在流量即可。

AC Code

int N,M,S,T;
struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};
namespace EdmondsKarp
{
    int Total;
    vector<Edge>Edges;
    vector<int>G[MAXN];
    int fl[MAXN],id[MAXN];
    inline void init()
    {
        for(int i=1;i<=N;++i) G[i].clear();
        Edges.clear();
    }
    inline void addEdge(int u,int v,int c)
    {
        Edges.push_back(Edge(u,v,c,0));
        Edges.push_back(Edge(v,u,0,0));
        Total=Edges.size();
        G[u].push_back(Total-2);
        G[v].push_back(Total-1);
    }
    inline ll maxFlow(int s,int t)
    {
        ll flow=0;
        for(;;)
        {
            memset(fl,0,sizeof(fl));
            queue<int>Q;
            Q.push(s);
            fl[s]=INF;
            while(!Q.empty())
            {
                int u=Q.front();Q.pop();
                for(int i=0;i<G[u].size();++i)
                {
                    Edge& e=Edges[G[u][i]];
                    if(!fl[e.to]&&e.cap>e.flow)
                    {
                        id[e.to]=G[u][i];
                        fl[e.to]=min(fl[u],e.cap-e.flow);
                        Q.push(e.to);
                    }
                }
                if(fl[t]) break;
            }
            if(!fl[t]) break;
            for(int u=t;u!=s;u=Edges[id[u]].from)
            {
                Edges[id[u]].flow+=fl[t];
                Edges[id[u]^1].flow-=fl[t];
            }
            flow+=fl[t];
        }
        return flow;
    }
};
using namespace EdmondsKarp;
int main()
{
    // freopen("ek.in","r",stdin);
    // freopen("ek.out","w",stdout);
    read(M,N);
    S=0,T=N+1;
    EdmondsKarp::init();
    int u,v;
    read(u,v);
    while(u!=-1&&v!=-1)
    {
        EdmondsKarp::addEdge(u,v,1);
        read(u,v);
    }
    for(int i=1;i<=M;++i) EdmondsKarp::addEdge(S,i,1);
    for(int i=M+1;i<=N;++i) EdmondsKarp::addEdge(i,T,1);
    printf("%lld\n",EdmondsKarp::maxFlow(S,T));
    for(int i=0;i<Total;i+=2)
        if(Edges[i].to!=S&&Edges[i].from!=S)
            if(Edges[i].to!=T&&Edges[i].from!=T)
                if(Edges[i].flow!=0)
                    printf("%d %d\n",Edges[i].from,Edges[i].to);
    return 0;
}
/*
5 10
1 7
1 8
2 6
2 9
2 10
3 7
3 8
4 7
4 8
5 10
-1 -1
*/

---

软件补丁问题

---

太空飞行计划问题

最大流？最小割？反正就按着模板打即可，一边是代价一边是利益，那就是个最小割模型。然后除了这道题因为是 Windows 环境数据外，有一个特别的输入方式，以及特判 Fl[] 函数输出方案之外，没什么特别的了。

AC Code

int N,M,S,T;
struct Net
{
    int next,to,val;
}Edge[MAXM<<2];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=(Net){Head[u],v,w};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0};Head[v]=Total;
}
int Fl[MAXN],SumW;
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    std::queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1,Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("netflow.in","r",stdin);
    // freopen("netflow.out","w",stdout);
    read(N,M);
    S=0,T=N+M+1;
    for(int i=1,W;i<=N;++i)
    {
        read(W);addEdge(S,i,W);SumW+=W;
        char tools[10000];
        memset(tools,0,sizeof tools);
        std::cin.getline(tools,10000);
        int ulen=0,tool;
        while(sscanf(tools+ulen,"%d",&tool)==1)//之前已经用scanf读完了赞助商同意支付该实验的费用
        {//tool是该实验所需仪器的其中一个      
            //这一行，你可以将读进来的编号进行储存、处理，如连边。
            addEdge(i,tool+N,INF);
            if(tool==0) 
                ulen++;
            else
            {
                while(tool)
                {
                    tool/=10;
                    ulen++;
                }
            }
            ulen++;
        }
    }
    for(int i=1,W;i<=M;++i)
    {
        read(W);addEdge(i+N,T,W);
    }
    int ans=SumW-Dinic();
    for(int e=1;e<=N;++e)
        if(Fl[e]!=-1) write(e),putchar(' ');
    puts("");
    for(int e=N+1;e<=N+M;++e)
        if(Fl[e]!=-1) write(e-N),putchar(' ');
    puts("");
    write(ans);
    return 0;
}
/*
2 3
10 1 2
25 2 3
5 6 7
*/

---

试题库问题

配对即可，输出方案依然按反边流量判定。

AC Code

int N,K,S,T,M;
struct Net
{
    int next,to,val;
    Net(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Net(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Net(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXN],Ans[MAXK][MAXN],Cnt[MAXN];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("maxflow.in","r",stdin);
    // freopen("maxflow.out","w",stdout);
    read(K,N);
    S=0,T=N+K+1;
    for(int i=1,ksum;i<=K;++i)
    {
        read(ksum);
        addEdge(S,i,ksum);
        M+=ksum;
    }
    for(int i=1,kopt,ver;i<=N;++i)
    {
        read(kopt);
        for(int j=1;j<=kopt;++j)
        {
            read(ver);
            addEdge(ver,i+K,1);
        }
        addEdge(i+K,T,1);
    }
    if(Dinic()<M) printf("No Solution!");
    else
    {
        for(int i=2;i<=Total;i+=2)
        {
            int from=Edge[i^1].to,to=Edge[i].to;
            if(1<=from&&from<=K)
                if(K+1<=to<=N+K)
                    if(Edge[i^1].val)
                        Ans[from][++Cnt[from]]=to-K;
        }
        for(int i=1;i<=K;++i)
        {
            sort(Ans[i]+1,Ans[i]+1+Cnt[i]);
            printf("%d: ",i);
            for(int j=1;j<=Cnt[i];++j) printf("%d ",Ans[i][j]);
            puts("");
        }
    }
    return 0;
}
/*
3 15
3 3 4
2 1 2
1 3
1 3
1 3
1 3
3 1 2 3
2 2 3
2 1 3
1 2
1 2
2 1 2
2 1 3
2 1 2
1 1
3 1 2 3
*/

---

最小路径覆盖问题

---

魔术球问题

---

最长不下降子序列问题

---

航空路线问题

是一个双调巡游问题，有比较巧妙的 的 做法。

考虑网络流怎么做，发现我们需要找到两条不相交的从 到 的最长路。考虑一个比较经典的拆点，把点 记作 ，连边 流量为 表示只能经过一次，费用也为 表示对答案进行一次贡献。注意当 的时候流量为 。

对于连边，将原来的边 变成 ，流量为 ，无费用。

考虑这样的连边方式，每一条边只能被走一次，但起点和终点只有 的流量，所以最后的最大费用就是经过的最多结点。

对于输出方案，考虑一个比较经典的倒叙走无流量边即可。

AC Code

// ----- Eternally question-----
// Problem: P2770 航空路线问题
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2770
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Written by: Eternity
// Time: 2023-09-18 19:47:04
// ----- Endless solution-------

#include<bits/stdc++.h>
#define re register
typedef long long ll;
template<class T>
inline void read(T &x)
{
	x=0;
	char ch=getchar(),t=0;
	while(ch<'0'||ch>'9') t|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
	if(t) x=-x;
}
template<class T,class ...T1>
inline void read(T &x,T1 &...x1){ read(x),read(x1...); }
template<class T>
inline void write(T x)
{
	if(x<0) putchar('-'),x=-x;
	if(x>9) write(x/10);
	putchar(x%10+'0');
}
template<>
inline void write(bool x){ putchar(x?'1':'0'); }
template<>
inline void write(char c){ putchar(c); }
template<>
inline void write(char *s){ while(*s!='\0') putchar(*s++); }
template<>
inline void write(const char *s){ while(*s!='\0') putchar(*s++); }
template<>
inline void write(std::string s)
{
	int cur=0;
	while(s[cur]!='\0') putchar(s[cur++]);
}
template<class T,class ...T1>
inline void write(T x,T1 ...x1){ write(x),write(x1...); }
template<class T>
inline bool checkMax(T &x,T y){ return x<y?x=y,1:0; }
template<class T>
inline bool checkMin(T &x,T y){ return x>y?x=y,1:0; }
const int MAXN=1e2+10,MAXM=1e4+10,MAXV=2e2+10,MAXE=1e5+10;
const int Inf=0x3f3f3f3f;
std::unordered_map<std::string,int>Hash;
int N,M,S,T;
struct Net
{ int next,to,val,cost; }Edge[MAXE<<1];
int Head[MAXV],Cur[MAXV],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
	Edge[++Total]=(Net){Head[u],v,w,c};Head[u]=Total;
	Edge[++Total]=(Net){Head[v],u,0,-c};Head[v]=Total;
}
int Dist[MAXV],ret;
bool Vis[MAXV];
inline bool Spfa()
{
	std::queue<int>Q;
	std::memset(Dist,0x3f,sizeof(Dist));
	std::memset(Vis,0,sizeof(Vis));
	std::memcpy(Cur,Head,sizeof(Head));
	Q.push(S),Dist[S]=0;
	while(!Q.empty())
	{
		int u=Q.front();Q.pop();
		Vis[u]=0;
		for(int e=Head[u],v;e;e=Edge[e].next)
		{
			v=Edge[e].to;
			if(Edge[e].val&&checkMin(Dist[v],Dist[u]+Edge[e].cost))
				if(!Vis[v]) Q.push(v),Vis[v]=1;
		}
	}
	return Dist[T]!=Inf;
}
int Dfs(int x,int inf)
{
	if(x==T) return inf;
	Vis[x]=1;
	int flow=0;
	for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
	{
		Cur[x]=e,v=Edge[e].to;
		if(Edge[e].val&&!Vis[v]&&Dist[v]==Dist[x]+Edge[e].cost)
		{
			int k=Dfs(v,std::min(Edge[e].val,inf-flow));
			if(k) 
			{
				ret+=Edge[e].cost*k;
				Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
			}
		}
	}
	Vis[x]=0;
	return flow;
}
inline int SSP()
{
	int r=0,flow;
	while(Spfa()) while(flow=Dfs(S,Inf)) r+=flow;
	return r;
}
std::string Str[MAXN],tmp;
bool direct;
void dfsFir(int x)
{
	std::cout<<Str[x]<<std::endl;Vis[x]=1;
	for(int e=Head[x],v;e;e=Edge[e].next)
	{
		v=Edge[e].to;
		if(v>N&&v<T&&Edge[e].val==0){ dfsFir(v-N);break; }
	}
}
void dfsSec(int x)
{
	Vis[x]=1;
	for(int e=Head[x],v;e;e=Edge[e].next)
	{
		v=Edge[e].to;
		if(v>N&&v<T&&Edge[e].val==0&&!Vis[v-N]) dfsSec(v-N);
	}
	std::cout<<Str[x]<<std::endl;
}
int main()
{
	// freopen(".in","r",stdin);
	// freopen(".out","w",stdout);
	read(N,M);S=0,T=N+N+1;
	for(int i=1;i<=N;++i)
	{
		std::cin>>Str[i];
		Hash[Str[i]]=i;
	}
	for(int i=2;i<=N-1;++i) addEdge(i+N,i,1,-1);
	addEdge(1+N,1,2,-1),addEdge(N+N,N,2,-1);
	addEdge(S,1+N,Inf,0),addEdge(N,T,Inf,0);
	for(int i=1;i<=M;++i)
	{
		std::cin>>tmp;int u=Hash[tmp];
		std::cin>>tmp;int v=Hash[tmp];
		// write(u,' ',v,'\n');
		if(u>v) std::swap(u,v);
		if(u==1&&v==N) direct=1;
		addEdge(u,v+N,1,0);
	}
	// int flow=0;
	int flow=SSP();
	if(flow==2) write(-(ret+2),'\n');
	else if(flow==1&&direct)
	{
		puts("2");
		write(Str[1],'\n',Str[N],'\n',Str[1],'\n');
		return 0;
	}
	else return puts("No Solution!"),0;
	std::memset(Vis,0,sizeof(Vis));
	dfsFir(1),dfsSec(1);
	return 0;
}
/*

*/

---

方格取数问题

最大权独立集，看前面的讲解。

AC Code

int N,M,S,T;
struct G
{
    int next,to,val;
    G(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXE<<1];
int Head[MAXP],Cur[MAXP],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=G(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=G(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXP];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
bool Color[MAXN][MAXN];
int main()
{
    // freopen("netflow.in","r",stdin);
    // freopen("netflow.out","w",stdout);
    read(N,M);
    S=0,T=N*M+1;
    for(int i=1;i<=N;++i)
        for(int j=1;j<=M;++j)
        {
            if(((i&1)&&(j&1))||((!(i&1))&&(!(j&1))))
                Color[i][j]=1;
            else Color[i][j]=0;
        }
    /*for(int i=1;i<=N;++i){
        for(int j=1;j<=M;++j) cout<<Color[i][j]<<" ";
        puts("");
    }*/
    ll Cnt=0;
    for(int i=1;i<=N;++i)
        for(int j=1,x;j<=M;++j)
        {
            read(x);
            Cnt+=x;
            if(Color[i][j]) addEdge(M*(i-1)+j,T,x);
            else
            {
                addEdge(S,M*(i-1)+j,x);
                for(int k=1;k<=4;++k)
                {
                    int Nx=i+Dx[k],Ny=j+Dy[k];
                    if(Nx<1||Ny<1||Nx>N||Ny>M) continue;
                    addEdge(M*(i-1)+j,M*(Nx-1)+Ny,INF);
                }
            }
        }
    printf("%d",Cnt-Dinic());
    return 0;
}
/*
3 3
1 2 3
3 2 3
2 3 1 
*/

---

机器人路径规划问题

---

圆桌问题

比较经典的网络流模型，一面连单位，一面连桌子，以人为流量。源点到桌子的容量为桌子容量，代表到汇点的容量为代表人数，之间每个桌子连每个代表容量为 ，就难在输出方案。

AC Code

int N,M,S,T;
struct Graph
{
    int next,to,val;
    Graph(int n=0,int t=0,int v=0):next(n),to(t),val(v){}
}Edge[MAXM<<1];
int Head[MAXN],NewT[MAXN],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=Graph(Head[u],v,w);Head[u]=Total;
    Edge[++Total]=Graph(Head[v],u,0);Head[v]=Total;
}
int Fl[MAXN],Tot;
inline bool Bfs()
{
    queue<int>Q;
    memset(Fl,-1,sizeof(Fl));
    Q.push(S);
    NewT[S]=Head[S],Fl[S]=0;
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1;
                NewT[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int u,int inf)
{
    if(u==T) return inf;
    int flow=0;
    for(int e=NewT[u];e&&flow<inf;e=Edge[e].next)
    {
        NewT[u]=e;
        int v=Edge[e].to;
        if(Fl[v]==Fl[u]+1&&Edge[e].val)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k;
            flow+=k;
        }
    }
    return flow; 
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("netflow.in","r",stdin);
    // freopen("netflow.out","w",stdout);
    read(M,N);
    S=0,T=N+M+1;
    for(int i=1,c;i<=M;++i)
    {
        read(c);
        addEdge(S,i,c);
        Tot+=c;
    }
    for(int i=1,c;i<=N;++i)
    {
        read(c);
        addEdge(i+M,T,c);
    }
    for(int i=1;i<=M;++i)
        for(int j=1;j<=N;++j)
            addEdge(i,M+j,1);
    if(Dinic()!=Tot) puts("0");
    else
    {
        puts("1");
        for(int i=1;i<=M;++i)
        {
            for(int j=Head[i];j;j=Edge[j].next)
                if(Edge[j].to>M&&Edge[j].to<=N+M)
                    if(!Edge[j].val) printf("%d ",Edge[j].to-M);
            puts("");
        }
    }
    return 0;
}
/*
4 5
4 5 3 5
3 5 2 6 4
*/

---

骑士共存问题

不能共存，那就是最小割，最多共存数，那就是最大流。

AC Code

const int MAXN=2e2+10,MAXM=2e4+10,MAXV=4e4+10,MAXE=1e6+10;
const int dx[]={0,1,2,2,1,-1,-2,-2,-1};
const int dy[]={0,2,1,-1,-2,2,1,-1,-2};
const int INF=0x3f3f3f3f;
int N,K,S,T;
struct Net
{
    int next,to,val;
}Edge[MAXE<<1];
int Head[MAXV],Cur[MAXV],Total=1;
inline void addEdge(int u,int v,int w)
{
    Edge[++Total]=(Net){Head[u],v,w};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0};Head[v]=Total;
}
int Fl[MAXV];
inline bool Bfs()
{
    memset(Fl,-1,sizeof(Fl));
    Fl[S]=0,Cur[S]=Head[S];
    std::queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Fl[v]==-1&&Edge[e].val)
            {
                Fl[v]=Fl[u]+1,Cur[v]=Head[v];
                if(v==T) return 1;
                Q.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(Fl[v]==Fl[x]+1&&Edge[e].val)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(!k) Fl[v]=-1;
            Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
        }
    }
    return flow;
}
inline int Dinic()
{
    int r=0,flow;
    while(Bfs()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
inline int getId(int x,int y)
{
    return N*(x-1)+y;
}
bool Forbid[MAXN][MAXN];
int main()
{
    // freopen(".in","r",stdin);
    // freopen(".out","w",stdout);
    read(N,K);
    S=0,T=N*N+1;
    for(int i=1,x,y;i<=K;++i)
    {
        read(x,y);Forbid[x][y]=1;
    }
    for(int i=1;i<=N;++i)
        for(int j=1;j<=N;++j)
        {
            if(Forbid[i][j]) continue;
            if((i-j+N)&1) addEdge(S,getId(i,j),1);
            else
            {
                addEdge(getId(i,j),T,1);
                continue;
            }
            for(int k=1;k<=8;++k)
            {
                int nx=i+dx[k],ny=j+dy[k];
                if(nx<1||nx>N||ny<1||ny>N||Forbid[nx][ny]) continue;
                addEdge(getId(i,j),getId(nx,ny),INF);
            }
        }
    write(N*N-Dinic()-K);
    return 0;
}
/*
3 2
1 1
3 3
*/

---

火星探险问题

---

最长 k 可重线段集问题

---

最长 k 可重区间集问题

---

汽车加油行驶问题

这道题可以用分层图最短路做。显然是贺的

但等用网络流做了之后再写。

---

孤岛营救问题

---

深海机器人问题

---

数字梯形问题

---

分配问题

能够同时做最大和最小限制就只有费用流了。

AC Code

int N,S,T;
struct Net
{
    int next,to,val,cost;
}Edge[MAXN<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=(Net){Head[u],v,w,c};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0,-c};Head[v]=Total;
}
int Dist[MAXN],ret;
bool Vis[MAXN];
inline bool Spfa()
{
    memset(Vis,0,sizeof(Vis));
    memset(Dist,0x3f,sizeof(Dist));
    memcpy(Cur,Head,sizeof(Head));
    Dist[S]=0,Vis[S]=1;
    std::queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Dist[v]>Dist[u]+Edge[e].cost&&Edge[e].val)
            {
                Dist[v]=Dist[u]+Edge[e].cost;
                if(!Vis[v]) Vis[v]=1,Q.push(v);
            }
        }
    }
    return Dist[T]!=INF;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    Vis[x]=1;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(!Vis[v]&&Dist[v]==Dist[x]+Edge[e].cost&&Edge[e].val)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow));
            if(k)
            {
                ret+=k*Edge[e].cost;
                Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
            }
        }
    }
    Vis[x]=0;
    return flow;
}
inline int Dinic_SSP()
{
    int r=0,flow;
    while(Spfa()) while(flow=Dfs(S,INF)) r+=flow;
    return r;
}
int main()
{
    // freopen("maxflow-mincost.in","r",stdin);
    // freopen("maxflow-mincost.out","w",stdout);
    read(N);
    for(re int i=1;i<=N;++i)
        for(int j=1,x;j<=N;++j)
        {
            read(x);
            addEdge(i,j+N,1,x);
            addEdge(i+N+N+N,j+N+N+N+N,1,-x);
        }
    S=0,T=N+N+1;
    for(int i=1;i<=N;++i) addEdge(S,i,1,0),addEdge(i+N,T,1,0);
    Dinic_SSP();
    write(ret),puts("");
    S=N+N+N,T=N+N+N+N+N+1;ret=0;
    for(int i=1;i<=N;++i) addEdge(S,i+N+N+N,1,0),addEdge(i+N+N+N+N,T,1,0);
    Dinic_SSP();
    write(-ret);
    return 0;
}
/*
5
2 2 2 1 2
2 3 1 2 4
2 0 1 1 1
2 3 4 3 3
3 2 1 2 1
*/

---

运输问题

和分配问题可以相当是双倍经验了。

AC Code

const int MAXN=10001;
const int MAXM=20001;
const int INF=0x3f3f3f3f;
const int Q=5000;
int N,M,S,T,S_b,T_b;
struct Net
{
    int next,to,val,cost;
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=(Net){Head[u],v,w,c};Head[u]=Total;
    Edge[++Total]=(Net){Head[v],u,0,-c};Head[v]=Total;
}
int Dist[MAXN],ret;
bool Vis[MAXN];
inline bool Spfa(int s,int t)
{
    memset(Dist,0x3f,sizeof(Dist));
    memset(Vis,0,sizeof(Vis));
    memcpy(Cur,Head,sizeof(Head));
    Dist[s]=0,Vis[s]=1;
    std::queue<int>Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u],v;e;e=Edge[e].next)
        {
            v=Edge[e].to;
            if(Dist[v]>Dist[u]+Edge[e].cost&&Edge[e].val)
            {
                Dist[v]=Dist[u]+Edge[e].cost;
                if(!Vis[v]) Vis[v]=1,Q.push(v);
            }
        }
    }
    return Dist[t]!=INF;
}
int Dfs(int x,int inf,int t)
{
    if(x==t) return inf;
    Vis[x]=1;
    int flow=0;
    for(int e=Cur[x],v;e&&flow<inf;e=Edge[e].next)
    {
        v=Edge[e].to,Cur[x]=e;
        if(!Vis[v]&&Dist[v]==Dist[x]+Edge[e].cost&&Edge[e].val)
        {
            int k=Dfs(v,std::min(Edge[e].val,inf-flow),t);
            if(k)
            {
                ret+=k*Edge[e].cost;
                Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
            }
        }
    }
    Vis[x]=0;
    return flow;
}
inline int SSP(int s,int t)
{
    int r=0,flow;
    while(Spfa(s,t)) while(flow=Dfs(s,INF,t)) r+=flow;
    return r;
}
int main()
{
    // freopen("mcmf.in","r",stdin);
    // freopen("mcmf.out","w",stdout);
    read(N,M);
    S=0,T=N+M+1;
    S_b=Q,T_b=N+M+Q+1;
    for(int i=1,x;i<=N;++i) read(x),addEdge(S,i,x,0),addEdge(S_b,i+Q,x,0);
    for(int i=1,x;i<=M;++i) read(x),addEdge(i+N,T,x,0),addEdge(i+N+Q,T_b,x,0);
    for(int i=1;i<=N;++i)
        for(int j=1,x;j<=M;++j)
        {
            read(x);addEdge(i,j+N,INF,x);addEdge(i+Q,j+N+Q,INF,-x);
        }
    SSP(S,T);
    write(ret),puts("");
    ret=0;
    SSP(S_b,T_b);
    write(-ret);
    return 0;
}
/*
2 3
220 280
170 120 210
77 39 105
150 186 122
*/

---

负载平衡问题

一眼贪心题，放弃，用费用流做是一个道理，虽然码量稍长但思路简单。

AC Code

int N,M,S,T;
struct Net
{
    int next,to,val,cost;
    Net(int n=0,int t=0,int v=0,int c=0):
        next(n),to(t),val(v),cost(c){}
}Edge[MAXM<<1];
int Head[MAXN],Cur[MAXN],Total=1;
inline void addEdge(int u,int v,int w,int c)
{
    Edge[++Total]=Net(Head[u],v,w,c);Head[u]=Total;
    Edge[++Total]=Net(Head[v],u,0,-c);Head[v]=Total;
}
int Dist[MAXN],ret;
bool Vis[MAXN];
inline bool Spfa(int s,int t)
{
    memset(Dist,0x3f,sizeof(Dist));
    memcpy(Cur,Head,sizeof(Head));
    queue<int>Q;
    Q.push(s),Dist[s]=0,Vis[s]=1;
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        Vis[u]=0;
        for(int e=Head[u];e;e=Edge[e].next)
        {
            int v=Edge[e].to;
            if(Edge[e].val&&Dist[v]>Dist[u]+Edge[e].cost)
            {
                Dist[v]=Dist[u]+Edge[e].cost;
                if(!Vis[v]) Q.push(v),Vis[v]=1;
            }
        }
    }
    return Dist[t]!=INF;
}
int Dfs(int x,int inf)
{
    if(x==T) return inf;
    Vis[x]=1;
    int flow=0;
    for(int e=Cur[x];e&&flow<inf;e=Edge[e].next)
    {
        Cur[x]=e;
        int v=Edge[e].to;
        if(!Vis[v]&&Edge[e].val&&Dist[v]==Dist[x]+Edge[e].cost)
        {
            int k=Dfs(v,min(Edge[e].val,inf-flow));
            if(k)
            {
                ret+=k*Edge[e].cost;
                Edge[e].val-=k,Edge[e^1].val+=k,flow+=k;
            }
        }
    }
    Vis[x]=0;
    return flow;
}
inline int Dinic()
{
    int res=0,flow;
    while(Spfa(S,T)) while(flow=Dfs(S,INF)) res+=flow;
    return res;
}
int Val[MAXN],SumV;
int main()
{
    // freopen("mincost-maxflow.in","r",stdin);
    // freopen("mincost-maxflow.out","w",stdout);
    read(N);
    S=0,T=N+N+1;
    for(int i=1;i<=N;++i) read(Val[i]),SumV+=Val[i];
    SumV/=N;
    for(int i=1;i<=N;++i) Val[i]-=SumV;
    for(int i=1;i<=N;++i)
    {
        if(Val[i]>0) addEdge(S,i,Val[i],0);
        else if(Val[i]<0) addEdge(i,T,-Val[i],0);
    }
    for(int i=1;i<=N;++i)
    {
        if(i!=1) addEdge(i,i-1,INF,1);
        if(i!=N) addEdge(i,i+1,INF,1);
    }
    addEdge(1,N,INF,1),addEdge(N,1,INF,1);
    int ans=Dinic();
    printf("%d",ret);
    return 0;
}
/*
5
17 9 14 16 4
*/

---