网络流+二分图总结

一. Dinic跑最大流
1.模板(上限V^2*E)
//先init将放边的数组清空,再将[a, b]的g边清空,加边的时候正向边为0, 反向边为1;
//MAXN为顶点个数,每个边的flow为此边跑了多少流.正向边为正数,而反向边为负数,但只看差值即可.
//复杂度V^2E;
const int MAXN = 5000 + 10;
const int INF = 1000000000;

struct Edge
{
int from, to, cap, flow;
};

struct Dinic
{
int s, t;
vector edges; // 边数的两倍
vector G[MAXN]; // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
bool vis[MAXN]; // BFS使用
int d[MAXN]; // 从起点到i的距离
int cur[MAXN]; // 当前弧指针

void init()
{
    edges.clear();
}

void clearNodes(int a, int b)
{
    for(int i = a; i <= b; i++) G[i].clear();
}

void AddEdge(int from, int to, int cap)
{
    edges.push_back((Edge)
    {
        from, to, cap, 0
    });
    edges.push_back((Edge)
    {
        to, from, 0, 0
    });
    int m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

bool BFS()
{
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    vis[s] = 1;
    d[s] = 0;
    while(!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        for(int i = 0; i < G[x].size(); i++)
        {
            Edge& e = edges[G[x][i]];
            if(!vis[e.to] && e.cap > e.flow)
            {
                vis[e.to] = 1;
                d[e.to] = d[x] + 1;
                Q.push(e.to);
            }
        }
    }
    return vis[t];
}

int DFS(int x, int a)
{
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i < G[x].size(); i++)
    {
        Edge& e = edges[G[x][i]];
        if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0)
        {
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}

// 求s-t最大流。如果最大流超过limit，则只找一个流量为limit的流
int Maxflow(int s, int t, int limit)
{
    this->s = s;
    this->t = t;
    int flow = 0;
    while(BFS())
    {
        memset(cur, 0, sizeof(cur));
        flow += DFS(s, limit - flow);
        if(flow == limit) break; // 达到流量限制，直接退出
    }
    return flow;
}

};

Dinic g;
2.最小割=最大流. 然后最小割:最大权闭合图, 以及:对于有些顶点不能共存,比如矩阵上二分染色,相邻的不能共处,加一些不能存在的边跑最大独立集以及带权最大独立集.
3. 对于无向图可以构造两条边,dinic不担心本身有环.
4. 如果点有最大流限制,拆点加限制.并且定义好出入.如果点有最小流限制e,最大限制c,把点u拆成ua(负责接收 入) ub(负责放出 出). 在原本的s和t的基础上再搞S和T,然后,S连ub,流e, ua连T,流e. 超级S和T接收总流量就行.(因为有新的附加,在S-s,t-T跑之前,先跑一遍S和T,看有没有达到e和,防止附加值下限不对).
5. 增加流和推流,增加流找到相应的增加就行.但是推流:u->v,如果cap>flow,那么直接cap–,如果cap==flow,那么从v遍历到t,找flow>0的路,退一个流.从s找到u,一样.然后最大流–;其实也可以不用退:如果u->v找到一个增广路,就不用退,跑一个1流就行.
6. 对时间的拆点和二分思路:图中有很多个门,每个门一秒只能出去一个人.然后问图中的人均出去的最短时间.到门的分配问题,涉及到最短时间.二分枚举最短时间,然后判定.一个门一秒只能流一个人,门的t拆点.

1. 最大权闭合图.可能需要自己先构造虚拟点,比如太空做实验的题目.正值的点放在s连,并且求一个sum,负值的点放在t,改为正值加边.然后中间有关系的不能断的搞INF.跑一遍最大流.
2. 最小割可以用来求将图割成两块的边权.随便搞一个点最为s,枚举另一个点,求一下割.所有的最小值就是最小值.但是这样复杂度太高.可以用Stoer-Wagner算法.
3. 最大稠密子图.在一个无向图中,找出一部分图:使得边的个数/点的个数 最大. 首先变成分数规划,g = max(e/v). 然后h(g) = max(e – gv), 是一个单调减.且答案是让h(g)=0,的g. 因此二分枚举g,然后搞出max(e-gv), 转化一下:ans = -min(g – (dv/2 – C(v,v’))). 然后ans = -min(g-dv/2 + C(v,v’)), 括号内的构图: S连每个点权值为U（很大的数，这里为它的度）；相连的点关系不变，权值为1；每个点连T，权值为U+2*g-dv. 然后ans = U*n – dinic;比如下面的代码:

include