网络流提高专题（洛谷题单）

网络流从入门到入土 #2

这份题单UVA的题目偏多。但是洛谷不知道为啥UVA交不上去。所以一般我都是去VJ上刷题。

较为简单的最大流模板题：#

The Grand Dinner#

这道题就是上一份题单里的圆桌问题。改改输出就好了。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1e6 + 10;
const int maxm = 1e5 * 2 + 10;
const ll inf = 1e18;
const int mod = 1e9 + 7;


struct Edge{
    int to;
    int next;
    ll w;
} edge[maxn*2];

int head[maxn], node_num;
int cur[maxn];//
int n, m, S, T, k;//
int dis[maxn];//Bf
int cnt = 0;//
bool vis[maxn];

inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; 
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){
            ll ans = dfs(v, min(del, edge[i].w));
            edge[i].w -= ans;
            edge[i ^ 1].w += ans;
            del -= ans;
            if(del == 0) break;
        }
    }
    return flow - del;
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

int main() {
    while (~scanf("%d %d", &m, &n))
    {
        if (!m && !n) break;
        S = 0, T = n+m+1;
        node_num = T;
        init();
        int rec_n[n+1], rec_m[m+1];
        int sum = 0;
        for (int i = 1; i <= m; ++ i) {
            scanf("%d", &rec_m[i]);
            sum += rec_m[i];
            Add_Edge(S, i, rec_m[i]);
            for (int j = 1; j <= n; ++ j)
                Add_Edge(i, j+m, 1);
        }
        for (int i = 1; i <= n; ++ i) {
            scanf("%d", &rec_n[i]);
            Add_Edge(i+m, T, rec_n[i]);
        }
        int flag = 0;
        if (Dinic() == sum) flag = 1;
        cout << flag << endl;
        if (flag) {
            vector<int> rec[m+1];
            for (int u = 1; u <= m; ++ u) {
                for (int j = head[u]; ~j; j = edge[j].next) {
                    if (edge[j].w == 0) {
                        rec[u].push_back(edge[j].to-m);
                    }
                }
            }
            for (int i = 1; i <= m; ++ i) {
                cout << rec[i][0];
                for (int j = 1; j < rec[i].size(); ++ j)
                    cout << " " << rec[i][j];
                cout << endl;
            }
        }
    }

    return 0;
}

Crimewave#

题意：给你n个点，问你是否存在n条连向矩阵外的不相交路径。

做法：将每个点拆成两个点。流量为1，能到矩阵外的点连T，开始n个点连S；跑最大流判断是否等于n即可。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1e6 + 10;
const int maxm = 1e5 * 2 + 10;
const ll inf = 1e18;
const int mod = 1e9 + 7;


struct Edge{
    int to;
    int next;
    ll w;
} edge[maxn*2];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];

inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}
int dic[4][2] = {1,0, -1,0, 0,-1, 0,1};
int main() {
    int Ti;
    scanf("%d", &Ti);
    while (Ti--)
    {
        scanf("%d %d %d", &n, &m, &k);
        S = 0, T = 2*n*m+1;
        node_num = T;
        init();
        int sum = 0;
        for (int i = 1, u, v; i <= k; ++ i) {
            scanf("%d %d", &u, &v);
            int id = (u-1)*m+v;
            Add_Edge(S, id, inf);
        }
        for (int i = 1; i <= n; ++ i) {
            for (int j = 1; j <= m; ++ j) {
                int id = (i-1)*m+j;
                Add_Edge(id, id+n*m, 1);
                for (int k = 0; k < 4; ++ k) {
                    int tx = i + dic[k][0], ty = j + dic[k][1];
                    int id1 = (tx-1)*m+ty;
                    if (tx < 1 || ty < 1 || tx > n || ty > m) {
                        Add_Edge(id+n*m, T, inf);
                        continue;
                    }
                    Add_Edge(id+n*m, id1, inf);
                }
            }
        }
        if (Dinic() == k) cout << "possible" << endl;
        else cout << "not possible" << endl;
    }

    return 0;
}

Internet Bandwidth#

题目大意：单源单汇无向网络求最大流。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1e6 + 10;
const int maxm = 1e5 * 2 + 10;
const ll inf = 1e18;
const int mod = 1e9 + 7;


struct Edge{
    int to;
    int next;
    ll w;
} edge[maxn*2];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];

inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}
int dic[4][2] = {1,0, -1,0, 0,-1, 0,1};

int main() {
    int tot = 0;
    while (~scanf("%d", &n) && n) {
        scanf("%d %d %d", &S, &T, &m);
        //S = 0, T = 2*n*m+1;
        node_num = n;
        init();
        int sum = 0;
        for (int i = 1, u, v, cap; i <= m; ++ i) {
            scanf("%d %d %d", &u, &v, &cap);
            Add_Edge(u, v, cap), Add_Edge(v, u, cap);
        }
        //cout << Dinic() << endl;
        cout << "Network " << ++tot << endl;
        cout << "The bandwidth is " << Dinic() << "." << endl << endl;
    }

    return 0;
}

Air Raid#

有向无环图（DAG）的最小路径覆盖的模板题。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1e6 + 10;
const int maxm = 1e5 * 2 + 10;
const ll inf = 1e18;
const int mod = 1e9 + 7;


struct Edge{
    int to;
    int next;
    ll w;
} edge[maxn*2];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];

inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow) {
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}
int dic[4][2] = {1,0, -1,0, 0,-1, 0,1};
/*
2
4
3
3 4
1 3
2 3
3
3
1 3
1 2
2 3
*/
int main() {
    int Ti;
    scanf("%d", &Ti);
    while (Ti--) {
        scanf("%d %d", &n, &m);
        S = 0, T = 2*n+1;
        node_num = T;
        init();
        int sum = 0;
        for (int i = 1; i <= n; ++ i) Add_Edge(S, i, 1), Add_Edge(i+n, T, 1);
        for (int i = 1, u, v; i <= m; ++ i) {
            scanf("%d %d", &u, &v);
            Add_Edge(u, v+n, 1);
        }
        cout << n - Dinic() << endl;

    }

    return 0;
}

 The K-League#

题意：网络流公平分配模型。告诉你有几支队伍，告诉你已知胜场，以及剩下需要进行的场数。问你哪些队伍可能获得胜利。

附上一个写的很好的博客：网络流和棒球赛淘汰问题 公平分配模板 足球联赛

（建模图）

AC代码：

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1000 + 10;
const int maxm = 1e6 * 2 + 10;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];
int w[maxn], d[maxn];
int a[maxn][maxn];
inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

bool canWin(int team) {
    //total代表的是team的最大胜场
    int total = w[team];
    for (int i = 0; i < n; ++ i)
        total += a[team][i];
    //如果存在其他队的胜场已经超过team的最大胜场，那么直接返回
    for (int i = 0; i < n; ++ i)
        if (w[i] > total) return 0;

    S = 0, T = n*n+n+1;
    node_num = T;
    init();
    int maxflow = 0;
    for (int u = 0; u < n; ++ u) {
        for (int v = u+1; v < n; ++ v) {
            if (a[u][v] > 0) Add_Edge(S, u*n+v+1, a[u][v]);
            maxflow += a[u][v];
            Add_Edge(u*n+v+1, n*n+u+1, inf);
            Add_Edge(u*n+v+1, n*n+v+1, inf);
        }
        if (w[u] < total) Add_Edge(n*n+u+1, T, total-w[u]);
    }
    return Dinic() == maxflow;
}
/*
3
3
2 0 1 1 0 2
0 2 2 2 0 2 2 2 0
3
4 0 2 2 0 4
0 1 1 1 0 1 1 1 0
4
0 3 3 1 1 3 3 0
0 0 0 2 0 0 1 0 0 1 0 0 2 0 0 0
*/
int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        for(int i = 0; i < n; i ++)
            scanf("%d%d", &w[i], &d[i]);
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < n; j++)
                scanf("%d", &a[i][j]);

        bool first = true;
        for(int i = 0; i < n; i++)
            if(canWin(i)) {
                if(first) first = false;
                else printf(" ");
                printf("%d", i+1);
            }
        printf("\n");
    }
    return 0;
}

Jamie's Contact Groups#

这道题就是POJ的2289之前用二分图写过了。二分+网络流check就可以了。

我记得，这道题目的读取方式非常地让人难受。

    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<queue>
    #include<vector>
    #include<sstream>
    using namespace std;
    const int maxn=2010;
    const int maxm=1e6+7;
    const int inf=0x3f3f3f3f;
    #define pb push_back
    struct Node
    {
        int to;
        int capa;
        int next;
    }edge[maxm];
    int n,m;
    int source,sink;
    int cnt;
    int head[maxn];
    bool vis[maxn];
    int dep[maxn];
    char name[100010];
    vector<int> vec[maxn];
    void init()
    {
        memset(head,-1,sizeof(head));
        cnt=0;
        return;
    }
    void add(int u,int v,int capa)
    {
        edge[cnt].to=v;
        edge[cnt].capa=capa;
        edge[cnt].next=head[u];
        head[u]=cnt++;
        edge[cnt].to=u;
        edge[cnt].capa=0;
        edge[cnt].next=head[v];
        head[v]=cnt++;
        return;
    }
    bool bfs()
    {
        queue<int> que;
        que.push(source);
        memset(dep,-1,sizeof(dep));
        dep[source]=0;
        while(!que.empty())
        {
            int node=que.front();
            que.pop();
            for(int i=head[node];~i;i=edge[i].next)
            {
                int v=edge[i].to;
                if(edge[i].capa>0&&dep[v]==-1)
                {
                    dep[v]=dep[node]+1;
                    if(v==sink) return true;
                    que.push(v);
                }
            }
        }
        return dep[sink]!=-1;
    }
    int dfs(int node,int minn)
    {
        if(node==sink||minn==0)
        {
            return minn;
        }
        int r=0;
        for(int i=head[node];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(dep[v]==dep[node]+1&&edge[i].capa>0)
            {
                int tmp=dfs(v,min(edge[i].capa,minn));
                if(tmp>0)
                {
                    edge[i].capa-=tmp;
                    edge[i^1].capa+=tmp;
                    r+=tmp;
                    minn-=tmp;
                    if(!minn) break;
                }
            }
        }
        if(!r) dep[node]=-1;
        return r;
    }
    int dinic()
    {
        int maxflow=0;
        while(bfs())
        {
            maxflow+=dfs(source,inf);
        }
        return maxflow;
    }
    void build(int mid)
    {
        for(int i=1;i<=n;i++)
        {
            add(source,i,1);
            int len=vec[i].size();
            for(int j=0;j<len;j++)
            {
                int x=vec[i][j];
                add(i,n+x+1,1);
            }
        }
        for(int i=1;i<=m;i++)
        {
            add(n+i,sink,mid);
        }
        return;
    }
    int main()
    {
        //freopen("in.txt","r",stdin);
        //freopen("out.txt","w",stdout);
        while(~scanf("%d%d",&n,&m))
        {
            getchar();
            if(!n&&!m) break;
            source=0;
            sink=n+m+10;
            string str;
            int num;
            for(int i=1;i<=n;i++)
            {
                vec[i].clear();
                getline(cin,str);
                stringstream stream(str);
                stream>>name;
                while(stream>>num)
                {
                    vec[i].pb(num);
                }
            }
            int left=0;
            int right=n;
            while(left<=right)
            {
                int mid=(left+right)/2;
                init();
                build(mid);
                int ans=dinic();
                if(ans==n)
                {
                    right=mid-1;
                }
                else
                {
                    left=mid+1;
                }
            }
            printf("%d\n",left);
        }
        return 0;
    }

Pool construction#

 这是一个最小割的很典型的题目。

 每个洞要么是草地，要么是洞，我们假设草地是S集合，洞是Y集合，然后洞和草之间要建栅栏，也就可以理解为，用最少的花费将S集合和Y集合分开，这就是最小割的模型了。

初始时，从s点向所有的草地点连一条边，容量为d，割这些边意味着将这个草地变成洞。把每个洞的点向t连一条边，容量为f，割这些边意味着将这个洞变成草。

相邻的两个格子之间u和v，连两条边，u到v和 v到u，容量为b。割u到v这条边意味着u是草，v是洞，在之间建围栏。割v到u的点也类似。

 题目还有一个要求，矩阵第一行/列和最后一行/列必须是草，所以，s向这些草连边容量为INF，代表这些边不能割。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>

using namespace std;
const int maxn=3000+10;
const int maxw=55;
const int maxm=30000;
const int INF=2147000000;
struct Dinic{
    int head[maxn],Next[maxm],to[maxm],cap[maxm],flow[maxm];
    int sz,n,m,s,t;
    bool vis[maxn];
    int cur[maxn],d[maxn];
    void init(int n){
        this->n=n;
        memset(head,-1,sizeof(head));
        sz=-1;
    }
    void add_edge(int a,int b,int c){
        ++sz;
        to[sz]=b;
        cap[sz]=c;flow[sz]=0;
        Next[sz]=head[a];head[a]=sz;
        ++sz;
        to[sz]=a;
        cap[sz]=c;flow[sz]=c;
        Next[sz]=head[b];head[b]=sz;
    }
    bool BFS(){
        memset(vis,0,sizeof(vis));
        queue<int>Q;
        vis[s]=1;
        d[s]=0;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            for(int i=head[u];i!=-1;i=Next[i]){
                int v=to[i];
                if(!vis[v]&&cap[i]>flow[i]){
                    vis[v]=1;
                    d[v]=d[u]+1;
                    Q.push(v);
                }
            }
        }
        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!=-1;i=Next[i]){
            int v=to[i];
            if(d[v]==d[x]+1&&(f=DFS(v,min(a,cap[i]-flow[i])))>0){
                Flow+=f;
                flow[i]+=f;
                flow[i^1]-=f;
                a-=f;
                if(a==0)break;
            }
        }
        return Flow;
    }
    int Maxflow(int s,int t){
        this->s=s,this->t=t;
        int Flow=0;
        while(BFS()){
            for(int i=0;i<=n;i++)
             cur[i]=head[i];
            Flow+=DFS(s,INF);
        }
        return Flow;
    }
}dinic;
int w,h,d,f,b,T,ans;
char G[maxw][maxw];
int main(){
    scanf("%d",&T);
    for(int t=1;t<=T;t++){
        ans=0;
        scanf("%d%d",&w,&h);
        scanf("%d%d%d",&d,&f,&b);
        for(int i=1;i<=h;i++){
            for(int j=1;j<=w;j++){
                scanf(" %c",&G[i][j]);
                if(i==1||j==1||i==h||j==w){
                    if(G[i][j]=='.'){
                        G[i][j]='#';
                        ans+=f;
                    }
                }
            }
        }
        dinic.init(w*h+2);
        for(int i=1;i<=h;i++){
            for(int j=1;j<=w;j++){
                if(i==1||j==1||i==h||j==w){
                    dinic.add_edge(0,(i-1)*w+j,INF);
                }else{
                    if(G[i][j]=='#'){
                        dinic.add_edge(0,(i-1)*w+j,d);
                    }
                    if(G[i][j]=='.'){
                        dinic.add_edge((i-1)*w+j,h*w+1,f);
                    }
                }
                if(i+1<=h){
                    dinic.add_edge((i-1)*w+j,i*w+j,b);
                    dinic.add_edge(i*w+j,(i-1)*w+j,b);
                }
                if(j+1<=w){
                    dinic.add_edge((i-1)*w+j,(i-1)*w+j+1,b);
                    dinic.add_edge((i-1)*w+j+1,(i-1)*w+j,b);
                }
            }
        }
        ans+=dinic.Maxflow(0,w*h+1);
        printf("%d\n",ans);
    }
return 0;
}

Cable TV Network#

这题正好学了一下图论中点连通度和边连通度的概念。

1.  基本概念

(1)一个具有 N 个顶点的图，在去掉任意 K-1 个顶点后 (1<=K<=N) 所得的子图仍连通，则称 G 是连通的，

而去掉 K 个顶点后的图不连通， 那么K 称作图 G 的点连通度

(2)相应地如果至少去掉 K 条边使这个图不连通，则 K 成为图的边连通度

2.  求解思路

•  对于求解边联通度的问题，为每条边赋权值为1，然后求确定一点作为源点，枚举此点外的每个点作为汇点求最大流。
• 点联通度问题可以转换到边联通度问题上来，具体转换方法如下

  • 若 G 为无向图，假设有n个点：

        (1) 原 G 图中的每个顶点 v 变成两个顶点 v' 和 v+n ，顶点 v 至 v+n 有一条弧（有向边）连接，弧容量为 1;

        (2) 原 G 图中的每条边  e ＝ uv ，连一条 u+n 到 v 的弧，再连一条 v+n 到 u 的弧，容量均为INF

        (3) A” 为源顶点， B' 为汇顶点

         注意：弧是有向边

  • 若 G 为有向图，假设有n个点：

        (1) 原 G 图中的每个顶点 v 变成两个顶点 v' 和 v+n ，顶点 v 至 v+n 有一条弧（有向边）连接，弧容量为 1;

        (2) 原 G 图中的每条弧  e ＝ uv 变成一条有向轨 u'u"v'v" ，其中轨上的弧 u"v' 的容量为 ∞;

        (3) A” 为源顶点， B' 为汇顶点

• 枚举源点 A" ，枚举汇点B'，求 A" 到 B' 的最小最大流 F，注意源点汇点的拆点容量应该为inf（为不可割的点）

BTW， 这题网上有比较多的做法是只枚举汇点的，但是按理来说应该是源汇都要枚举。

还有些做法虽然枚举了源汇，但是确实以出点作为源点，入点作为汇点。这样是通过网络流特性来使得源汇不可割，但从理解上还是我这种建图方式较好理解。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1000 + 10;
const int maxm = 1e6 * 2 + 10;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];
int w[maxn], d[maxn];
int a[maxn][maxn];
inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}
/*
0 0
1 0
3 3 (0,1) (0,2) (1,2)
2 0
5 7 (0,1) (0,2) (1,3) (1,2) (1,4) (2,3) (3,4)
*/
int main(){
    while (~scanf("%d%d", &n, &m)){
        int u[m+1], v[m+1];
        for (int i = 0; i < m; i++)
            scanf(" (%d,%d)", &u[i], &v[i]);//, u[i]++, v[i]++;
        ll ans = inf;
        node_num = 2*n;
        for(int s=0;s<n;s++){
            for(int t=s+1;t<n;t++){
                init();
                S = s, T = t;
                for(int i=0;i<n;i++) {
                    if (i == s || i == t) Add_Edge(i,i+n,inf);
                    else Add_Edge(i,i+n,1);
                }
                for(int i=0;i<m;i++) 
                    Add_Edge(u[i]+n,v[i],inf),Add_Edge(v[i]+n,u[i],inf);
                ll temp = Dinic();
                ans = min(ans,temp);
            }
        }
        if(ans == inf){
            if(n*(n-1)/2==m) printf("%d\n",n);
            else printf("0\n");
        }
        else printf("%d\n",ans);
    }
    return 0;
}

Sabotage#

求最小割边集。其实我觉得求出残余网络中容量为0的就好了，不就是最小割么。（不知道对不对）

(UPD20.9.11)跑满流的边只是可能为最小割边，反例： 1 ----(12)------2-------(12)--------3     假设S为1，T为3。如果满流的边是最小割的话，那么就是1-2和2-3，但是答案其实是1-2或者1-3。所以下述方法才是求最小割的正解！

但是网上的做法好像都是先最大流之后dfs染色，染色中遇到容量为0的跳过。

之后判断每条边左右节点的颜色是否不同就好了。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1000 + 10;
const int maxm = 1e6 * 2 + 10;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];
inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
    memset(vis, 0, sizeof(vis));
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

void DFS(int u) {
    vis[u] = 1;//为1表示是S集的点
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] || !edge[i].w) continue;
        DFS(v);
    }
}

int main() {
    while (~scanf("%d%d",&n,&m)) {
        if (!n && !m) break;
        node_num = n;
        S = 1, T = 2;
        init();
        int x[m+1], y[m+1];
        for (int i = 1; i <= m; ++ i) {
            int u, v, w;
            scanf("%d%d%d",&u,&v,&w);
            Add_Edge(u, v, w), Add_Edge(v, u, w);
            x[i] = u, y[i] = v;
        }
        Dinic();
        DFS(S);
        for(int i = 1; i <= m; i++) {
            int u = x[i], v = y[i];
            if (vis[u] && !vis[v] || vis[v] && !vis[u])
                printf("%d %d\n", u, v);
        }
        cout << endl;
    }
    return 0;
}

Collectors Problem#

这道题我好像见过。这也算是一类题了吧（分配问题）。

题目大意：Bob有一些贴纸，他可以和别人交换，他可以把自己独有的贴纸拿出去，也可以把重复的贴纸拿出去（有时候把独有的贴纸而不是重复的贴纸拿出去能换到更多贴纸）。

              Bob的朋友也有一些贴纸，但是他们只会拿自己重复的贴纸和Bob换，而且换的是自己没有的贴纸。

              求Bob最后最多能有多少种贴纸。

解题思路：

题目意思很明确了。就算把重复的贴纸拿出去也不一定最优，贪心就不用尝试了。

全局资源调配得使用网络流模型。

建图方式：

①S点(看作是Bob)->所有物品：连一条边，cap是Bob持有贴纸数量。

②：所有朋友->所有物品：如果这个人持有的该贴纸数量>=2,连一条边,cap是贴纸数量-1。（原因是这些人只会把重复的贴纸拿出去）。

③：所有物品->所有朋友：如果这个人没有改物品，连一条边，cap=1,。(原因是这些人会接受自己没有的贴纸）

④：所有物品->T点：连一条边，cap=1，统计物品的种类。

这样建图之后，所有物品可以看作Bob的总资产，这个总资产可以流进，也可以流出，在这基础上做一次最大流，就是结果了。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1000 + 10;
const int maxm = 1e6 * 2 + 10;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int tot = 0;//边数
bool vis[maxn];
inline void init(){
    tot = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
    memset(vis, 0, sizeof(vis));
}

inline void Add_Edge(int u, int v, ll w){
    edge[tot].next = head[u];
    edge[tot].to = v;
    edge[tot].w = w;
    head[u] = tot++;

    edge[tot].next = head[v];
    edge[tot].to = u;
    edge[tot].w = 0;
    head[v] = tot++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

void DFS(int u) {
    vis[u] = 1;//为1表示是S集的点
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] || !edge[i].w) continue;
        DFS(v);
    }
}
/*
2
2 5
6 1 1 1 1 1 1
3 1 2 2
3 5
4 1 2 1 1
3 2 2 2
5 1 3 4 4 3
*/
int main() {
    int Ti; scanf("%d", &Ti);
    for (int Tii = 1; Tii <= Ti; ++ Tii) {
        scanf("%d %d", &n, &m);
        node_num = n+m+1;
        S = 0, T = n+m+1;
        init();
        int cnt[n+1][m+1] = {0};
        for (int u = 1, v; u <= n; u++) {
            int num; scanf("%d", &num);
            while (num--) {
                scanf("%d", &v);
                cnt[u][v]++;
            }
        }
        //1号是自己
        for (int i = 1; i <= m; i++)
            Add_Edge(S, i, cnt[1][i]);
        //2-n是其他人
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (!cnt[i][j]) Add_Edge(j, m+i, 1);
                else Add_Edge(m+i, j, cnt[i][j]-1);
            }
        }
        for (int i = 1; i <= m; i++)
            Add_Edge(i, T, 1);
        int ans = Dinic();
        printf("Case #%d: %d\n", Tii, ans);
    }

    return 0;
}

Matrix Decompressing#

思路：

　　这么也想不到用网络流解决，这个模型很不错。假设这个矩阵的每一行是水管，每一列是水管，每行有出水口流到每一列。

　　这样想比较好理解。然后每行的流量和每列的流量知道，就可以建图了。

　　建图过程，每行对应一个点，每列对应1个点，每行都可以流到每列，所以他们之间有边。

　　我们得假设他们是如何流向的，不如设从行流向列，那么添加源点，流向每行；添加汇点，被每列汇流。容量怎么设？我们要让每行都满流就行了，

　　那么行之和就是源点到该行的容量，同理汇点也如此。但是每行流向每列呢？注意每个格子的元素必须在1~20之间，所以把容量设为20，别让它流太多了。

　　注意到元素必须在1~20之间！！！那么这样增广路的话会出现有的完全0流怎么办？先将每个格子中的元素自减1，它的流下限总不会为负吧，计算完输出时再加回去不就行了。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1e6 + 10;
const int maxm = 1e5 * 2 + 10;
const ll inf = 1e18;
const int mod = 1e9 + 7;


struct Edge{
    int to;
    int next;
    ll w;
} edge[maxn*2];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, k;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];

inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;

}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; ~i ; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow) {
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; ~i; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

int main()
{
    //freopen("in.txt","r",stdin);
    int Ti;
    scanf("%d",&Ti);
    for (int ti = 1; ti <= Ti; ++ ti) {
        init();
        cin>>n>>m;
        S = 0, T = 1+n+m;
        node_num = T;

        int a[30]={0}, b[30]={0}, c[30]={0}, d[30]={0};
        int rec[30][30] = {0};
        for (int i=1; i<=n; i++) cin>>a[i];
        for (int i=1; i<=m; i++) cin>>b[i];
        for (int i=1; i<=n; i++) c[i] = a[i]-a[i-1]-m;
        for (int i=1; i<=m; i++) d[i] = b[i]-b[i-1]-n;

        for (int i=1; i<=n; i++)
            Add_Edge(S,i,c[i]);
        for (int i=1; i<=m; i++)
            Add_Edge(n+i,T,d[i]);
        for (int i=1; i<=n; i++)
            for (int j=1; j<=m; j++)
                Add_Edge(i,n+j,19), rec[i][j] = cnt-1;

        Dinic();
        cout << "Matrix " << ti << endl;
        for (int i = 1; i <= n; ++ i) {
            int j;
            for (j = 1; j <= m-1; ++ j) {
                cout << edge[rec[i][j]].w + 1 << " ";
            }
            cout << edge[rec[i][m]].w +1<< endl;//edge[j].w+1 << endl;
        }
        cout << endl;

    }
    return 0;
}

 Frequency Hopping#

这道题真的很好。为了做这道题我特地去重新学习了一遍网络流。

题意：问你是否在网络流中存在流量为C的流，如果不存在是否能修改一条边使得存在。

思路：存在流量为C那么只需要最大流>=C就好了，因为最大流可以不跑满。

所以possible的条件就是最大流.>= C

通过最大流最小割定理我们知道，当流量是最大流的时候，割边流量肯定跑满，所以修改容量的边肯定是割边。

所以我们枚举割边去修改

（暴力会超时。所以这里要提两点优化：

　　第一点是当跑最大流的时候一旦流量>=C那么直接跳出。

　　第二点是从跑了一遍最大流的残余网络上再跑最大流。

　　第一个点是比较好理解的就不讲了。第二点是因为Dinic算法是“阻塞流”，所以跑了一边dinic之后他会把一些道路给阻塞，就会使得增广的路减少从而达到优化时间的目的。

）

如果每一条割边都不能满足就是not possible

（最让我难受的是我的板子似乎不能满足这道题，改了一个上午还是超时。最后还是嫖了白书上的板子，以防日后会遇到相同的题目，用自己的板子写不出来。）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
 
#define maxn 110
#define maxm 22010
typedef long long ll;
#define INF 0x3f3f3f3f
#define cl(x,v); memset(x,v,sizeof(x));
 
struct Edge{
    int from,to,cap,flow;
};
 
bool cmp(const Edge& a,const Edge& b)
{
    return a.from < b.from||(a.from==b.from&&a.to<b.to);
}
 
struct Dinic{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>g[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxm];
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<=n;i++)g[i].clear();
        edges.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});
        m=edges.size();
        g[from].push_back(m-2);
        g[to].push_back(m-1);
    }
    bool BFS()
    {
        cl(vis,0);
        queue<int>q;
        q.push(s);
        d[s]=0;
        vis[s]=1;
        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;
    }
    int Maxflow(int s,int t,int need)
    {
        this->s=s;
        this->t=t;
        int flow=0;
        while(BFS())
        {
            cl(cur,0);
            flow+=DFS(s,INF);
            if(flow>need)return flow;
        }
        return flow;
    }
    vector<int> Mincut()
    {
        BFS();
        vector<int>ans;
        for(int i=0;i<edges.size();i++)
        {
            Edge& e=edges[i];
            if(vis[e.from]&&!vis[e.to]&&e.cap>0)
                ans.push_back(i);
        }
        return ans;
    }
    void Reduce()
    {
        for(int i=0;i<edges.size();i++)
            edges[i].cap-=edges[i].flow;
    }
    void ClearFlow()
    {
        for(int i=0;i<edges.size();i++)
            edges[i].flow=0;
    }
};
 
Dinic solver;
int main()
{
    int N,E,C,cas=0;
    while(scanf("%d%d%d",&N,&E,&C)!=EOF)
    {
        if(N==0)break;
        solver.init(N);
        int a,b,c;
        while(E--)
        {
            scanf("%d%d%d",&a,&b,&c);
            solver.AddEdge(a,b,c);
        }
        int flow=solver.Maxflow(1,N,INF);
        printf("Case %d: ",++cas);
        if(flow>=C)printf("possible\n");
        else
        {
            vector<int>cut=solver.Mincut();
            solver.Reduce();
            vector<Edge>ans;
            for(int i=0;i<cut.size();i++)
            {
                Edge& e=solver.edges[cut[i]];
                int temp=e.cap;
                e.cap=C;
                solver.ClearFlow();
                if(flow+solver.Maxflow(1,N,C-flow)>=C)ans.push_back(e);
                e.cap=temp;
            }
            if(ans.empty())printf("not possible\n");
            else
            {
                sort(ans.begin(),ans.end(),cmp);
                printf("possible option:(%d,%d)",ans[0].from,ans[0].to);
                for(int i=1;i<ans.size();i++)
                    printf(",(%d,%d)",ans[i].from,ans[i].to);
                printf("\n");
            }
        }
    }
    return 0;
}

 SAM I AM#

 这道题跟上面那道挺像的。这道题让我解决了上面遗留的疑惑。同时也让我对最小割理解更为深刻。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 3000 + 10;
const int maxm = 1e6 * 2 + 100;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, num;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];
inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
    memset(vis, 0, sizeof(vis));
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

void DFS(int u) {
    vis[u] = 1;//为1表示是S集的点
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] || !edge[i].w) continue;
        DFS(v);
    }
}

int main() {
    while (~scanf("%d%d%d",&n,&m,&num)) {
        if (!n && !m && !num) break;
        node_num = n+m+1;
        S = 0, T = m+n+1;
        init();
        for (int i = 1; i <= n; ++ i) Add_Edge(S, i, 1);
        for (int i = 1; i <= m; ++ i) Add_Edge(i+n, T, 1);
        for (int i = 1,u,v; i <= num; ++ i)
            scanf("%d%d",&u,&v), Add_Edge(u, v+n, 1);
        printf("%lld ", Dinic());
        DFS(S);
        for (int i = 1; i <= n; ++ i)
            if (!vis[i]) printf("r%d ", i);
        for (int i = n+1; i <= m+n; ++ i)
            if (vis[i]) printf("c%d ", i-n);
        cout << endl;
    }
    return 0;
}
/*
4 4 3
1 1
1 4
3 2

4 4 2
1 1
2 2

0 0 0
*/

Power Transmission#

这道题算是比较综合的题目吧，多源多汇+点容量限制。还行。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 3000 + 10;
const int maxm = 1e6 * 2 + 100;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, num;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];
inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
    memset(vis, 0, sizeof(vis));
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

void DFS(int u) {
    vis[u] = 1;//为1表示是S集的点
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] || !edge[i].w) continue;
        DFS(v);
    }
}

int main() {
    //freopen("out.txt","w",stdout);
    while (~scanf("%d",&n)) {
        node_num = 2*n+1;
        S = 0, T = 2*n+1;
        init();
        for (int i = 1, w; i <= n; ++ i)
            scanf("%d", &w), Add_Edge(i, i+n, w);
        scanf("%d", &m);
        for (int i = 1,u,v,w; i <= m; ++ i)
            scanf("%d%d%d",&u, &v, &w), Add_Edge(u+n, v, w);
        int ed, st; scanf("%d%d", &st, &ed);
        for (int i = 1, tt; i <= st; ++ i)
            scanf("%d", &tt), Add_Edge(S, tt, inf);
        for (int i = 1, tt; i <= ed; ++ i)
            scanf("%d", &tt), Add_Edge(tt+n, T, inf);
        printf("%lld\n", Dinic());
    }
    return 0;
}
/*
4 4 3
1 1
1 4
3 2

4 4 2
1 1
2 2

0 0 0
*/

Down Went The Titanic

多源多汇拆点。跟上一题差不多。只不过换成了矩阵的形式。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 3000 + 10;
const int maxm = 1e6 * 2 + 100;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to;
    int next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, c;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
bool vis[maxn];
char G[35][35];
inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
    memset(vis, 0, sizeof(vis));
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

void DFS(int u) {
    vis[u] = 1;//为1表示是S集的点
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] || !edge[i].w) continue;
        DFS(v);
    }
}
int dic[4][2] ={0,1,0,-1,1,0,-1,0};
int main() {
    //freopen("out.txt","w",stdout);
    while (~scanf("%d%d%d",&n,&m,&c)) {
        node_num = 2*n*m+1;
        S = 0, T = 2*n*m+1;
        init();
        for (int i = 1, w; i <= n; ++ i) scanf("%s", (G[i]+1));
        for (int i = 1; i <= n; ++ i) {
            for (int j = 1; j <= m; ++ j) {
                int id = (i-1)*m+j;
                if (G[i][j] == '*') Add_Edge(S, id, 1), Add_Edge(id, id+n*m, 1);
                else if (G[i][j] == '~') continue;
                else if (G[i][j] == '.') Add_Edge(id, id+n*m, 1);
                else if (G[i][j] == '@') Add_Edge(id, id+n*m, inf);
                else if (G[i][j] == '#') Add_Edge(id+n*m, T, c), Add_Edge(id, id+n*m, inf);
                for (int k = 0; k < 4; ++ k) {
                    int tx = i+dic[k][0];
                    int ty = j+dic[k][1];
                    int id1 = (tx-1)*m+ty;
                    if (tx < 1 || tx > n || ty < 1 || ty > m || G[tx][ty] == '*' || G[tx][ty] == '~') continue;
                    Add_Edge(id+n*m, id1, inf);
                }
            }
        }

        printf("%lld\n", Dinic());
    }
    return 0;
}
/*
4 4 3
1 1
1 4
3 2

4 4 2
1 1
2 2

0 0 0
*/

Objective: Berlin

这题在洛谷上居然是黑题。也不是很难的样子。

题意：给定一些航班，每个航班有人数，和起始终止时间，每次转机要花半小时，问限制时间内最多能有多少人从起始城市到终点城市

思路：dinic最大流，将每个班机作为一个点，并且拆点成i'和i''，从i'->i''的边的限制为班机的人数，两个班机i和j如果i的终点是j的起点，且时间间隔至少为30分钟则在i''->j'建立边，最后是源点和汇点的边。

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 1e4 + 10;
const int maxm = 1e6 * 2 + 100;
const ll inf = 1e14;
const int mod = 1e9 + 7;

struct Edge{
    int to, next;
    ll w;
} edge[maxm];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, c;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
//bool vis[maxn];

inline void init(){
    cnt = 0;
    for (int i = 0; i <= node_num; ++ i) head[i] = -1;
//    memset(vis, 0, sizeof(vis));
}

inline void Add_Edge(int u, int v, ll w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1; //这里要根据你所建的点数来确定
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline ll dfs(int u, ll flow){
    if(u == T) return flow;
    ll del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            ll ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline ll Dinic() {
    ll ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

struct Plane {
    int u, v, num, stt, edt;
}P[maxn];

int main() {
    //freopen("out.txt","w",stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    while (cin >> n) {
        map<string, int> mp;
        int hash_val = 0;
        string st, ed; cin >> st >> ed;
        mp[st] = hash_val++;
        mp[ed] = hash_val++;

        int end_time; cin >> end_time;
        end_time = end_time/100*60 + end_time%100;
        cin >> m;
        S = 0, T = 2*m+1;
        node_num = 2*m+1;
        init();
        for (int i = 1; i <= m; ++ i) {
            string u, v;
            int num, edt, stt;
            cin >> u >> v >> num >> stt >> edt;
            if (!mp[u]) mp[u] = hash_val++;
            if (!mp[v]) mp[v] = hash_val++;
            stt = stt/100*60 + stt%100;
            edt = edt/100*60 + edt%100;
            P[i] = {mp[u], mp[v], num, stt, edt};
        }
        for (int i = 1; i <= m; ++ i) {
            Add_Edge(i, i+m, P[i].num);
            if (P[i].u == mp[st]) Add_Edge(S, i, inf);
            if (P[i].v == mp[ed] && P[i].edt <= end_time) Add_Edge(i+m, T, inf);
            for (int j = 1; j <= m; ++j) {
                if (i == j) continue;
                if (P[i].v == P[j].u && P[j].stt - P[i].edt >= 30)
                    Add_Edge(i+m, j, inf);
            }
        }
        printf("%lld\n", Dinic());
    }
    return 0;
}
/*
4
lisbon berlin
1500
9
lisbon london 6 1000 1100
london lisbon 6 1130 1230
lisbon paris 5 1000 1100
paris lisbon 4 1130 1230
london paris 1 1130 1300
london berlin 2 1340 1510
berlin london 2 1300 1430
paris berlin 10 1330 1500
berlin paris 9 1300 1430
*/

Hard Life#

 这道题是最大密度子图的模板题。

第一种方式

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define pii pair<long long, int>
typedef long long ll;

const int maxn = 2011;
const int maxm = 1e6 * 2 + 100;
const double inf = 1e9;
const int mod = 1e9 + 7;

struct Edge{
    int to, next;
    double w;
} edge[maxn*4];

int head[maxn], node_num;
int cur[maxn];//当前弧优化数组
int n, m, S, T, c;//点数，边数，源点，汇点
int dis[maxn];//Bfs深度
int cnt = 0;//边数
int vis[maxn];
int tx[maxn], ty[maxn];


inline void Add_Edge(int u, int v, double w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].w = w;
    head[u] = cnt++;

    edge[cnt].next = head[v];
    edge[cnt].to = u;
    edge[cnt].w = 0;
    head[v] = cnt++;
}


inline bool Bfs(){
    for(int i = 0; i <= node_num; ++i) dis[i] = -1;
    dis[S] = 0;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dis[v] == -1 && edge[i].w){//没有标记深度并且有残量
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[T] != -1;
}

inline double dfs(int u, double flow){
    if(u == T) return flow;
    double del = flow;
    for(int i = cur[u]; i != -1; i = edge[i].next){
        cur[u] = edge[i].next;//当前弧优化，下次直接从cur[u]开始增广，节省时间
        int v = edge[i].to;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0){//深度+1且残量大于0
            double ans = dfs(v, min(del, edge[i].w));//木桶原理
            edge[i].w -= ans;//正向弧减增广流量
            edge[i ^ 1].w += ans;//反向弧加增广流量
            del -= ans;//总流量减增广流量
            if(del == 0) break;//总流量为0则不继续增广
        }
    }
    return flow - del;//返回本次增广的流量
}

inline double Dinic() {
    double ans = 0;
    while(Bfs()) {
        for(int i = 0; i <= node_num; ++i) cur[i] = head[i];
        ans += dfs(S, inf);
    }
    return ans;
}

void build(double mid) {
    cnt = 0;
    memset(head, -1, sizeof(head));
    for (int i = 1; i <= m; ++ i)
        Add_Edge(n+i, tx[i], inf), Add_Edge(n+i, ty[i], inf);
    for (int i = 1; i <= m; ++ i) Add_Edge(S, n+i, 1.0);
    for (int i = 1; i <= n; ++ i) Add_Edge(i, T, mid);
}

void mark(int u) {
    vis[u] = 1;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (!edge[i].w || vis[v]) continue;
        mark(v);
    }
}

int main() {
    //freopen("out.txt","w",stdout);
    while (~scanf("%d%d", &n, &m)) {
        if (m == 0) { printf("1\n1\n"); continue;}
        for (int i = 1; i <= m; ++ i) scanf("%d%d", &tx[i], &ty[i]);
        S = 0, T = n+m+1, node_num=T;
        double L=0,R=m,M, eps=1.0/n/n;
        while (R - L > eps) {
            build(M = (L+R)/2);
            if ((double)m-Dinic() > 1e-8) L = M;
            else R = M;
        }
        //cout << L << endl;
        build(L);
        Dinic();
        memset(vis, 0, sizeof(vis));
        mark(S);
        int ans=0;
        for(int i=1;i<=n;i++) if(vis[i]) ans++;
        printf("%d\n",ans);
        for(int i=1;i<=n;i++) if(vis[i]) printf("%d\n",i);
    }
    return 0;
}
/*
5 6
1 5
5 4
4 2
2 5
1 2
3 1
*/

 附第二种方法的代码。

餐巾计划问题 #

这个写得挺好的

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;

int e_ptr = 1, S, T, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != INF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != INF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, INF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

int main() {
    int N; scanf("%d", &N);
    S = 0, T = 2*N+1;
    for(int i = 1, x; i <= N; i++) {
        scanf("%d", &x);
        AddEdge(S, i, x, 0); //每天晚上收到x条脏毛巾
        AddEdge(i+N, T, x, 0); //每天早上需要送出x条干净的毛巾
    }
    int p, m, f, s, n;
    scanf("%d%d%d%d%d", &p, &m, &f, &n, &s);
    for (int i = 1; i <= N; ++ i) {
        if (i + 1 <= N) AddEdge(i, i+1, INF, 0); //每天晚上可以把剩下的毛巾留到明天晚上
        if (i + m <= N) AddEdge(i, i+m+N, INF, f);  //把晚上的毛巾送去洗到m天后的早上
        if (i + n <= N) AddEdge(i, i+n+N, INF, s);//把晚上的毛巾送去洗到n天后的早上
        AddEdge(S, i+n, INF, p); //每天早上可以买毛巾
    }
    PrimalDual();
    printf("%lld", MinCost);
    return 0;
}

方格取数加强版 #

这道题太裸了。唯一需要注意的点就是需要连一条用作经过的边。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;

int e_ptr = 1, S, T, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != INF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != INF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, INF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}
int g[55][55];
int dic[2][2] = {1,0,0,1};
int main() {
    int n, k; scanf("%d%d", &n, &k);
    S = 0, T = 2*n*n+1;
    for(int i = 1; i <= n; i++)
        for (int j = 1; j <= n; ++ j)
            scanf("%d", &g[i][j]);
    AddEdge(S, 1, k, 0), AddEdge(n*n*2, T, k, 0);
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            int id = (i-1)*n+j;
            AddEdge(id, id+n*n, 1, -g[i][j]), AddEdge(id, id+n*n, INF, 0);
            for (int k = 0; k < 2; ++ k) {
                int tx = i+dic[k][0], ty = j+dic[k][1];
                if (tx > n || ty > n) continue;
                int _id = (tx-1)*n+ty;
                AddEdge(id+n*n, _id, INF, 0);
            }
        }
    }
    PrimalDual();
    printf("%lld", -MinCost);
    return 0;
}

[SCOI2007]修车 #

这道题的建图十分的难想。大家都知道要拆点，但是怎么拆就是个问题。这个算是涨个知识，知道建图还能这么建。

 

之后只需要车向时间段连固定代价即可。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;

int e_ptr = 1, S, T, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != INF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != INF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, INF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}
int cost[65][10];
int main() {
    int n, m; scanf("%d%d", &m, &n); //n车，m人
    S = 0, T = m*n+n+1;
    for (int i = 1; i <= m; ++ i)
        for (int j = 1; j <= n; ++ j)
            AddEdge((i-1)*n+j+n, T, 1, 0);
    for (int i = 1; i <= n; ++ i) { //最外层是车
        AddEdge(S, i, 1, 0);
        for (int j = 1; j <= m; ++ j) { //这一层是人
            int temp; scanf("%d", &temp);
            for (int k = 1; k <= n; ++ k) //这一层是枚举时间段
                AddEdge(i, n+(j-1)*n+k, 1, k*temp);
        }
    }
    PrimalDual();
    printf("%.2f\n", 1.0*MinCost/n);
    return 0;
}

[NOI2012]美食节 #

修车的加强版。区别就是每款车都有个数了，所以时间段建点会很多，会导致爆时间。

具体的优化就是需要根据每次哪个人倒数第几次修车被跑满了，就动态加入新的时间段。

附上嫖自洛谷的代码。

#include <iostream>
#include <iomanip>
#include <cstring>
#include <map>
#include <queue>
#define inf 2147483646
#define N 10000
using namespace std;

struct ed{
    int u,w,next,f;
}e[1000000];
int g[1000][2000],a[2000];
int n,m,st=1,ans,cost,sm,fir[30000],c[30000],d[30000];
int vis[30000],sp[30000];
queue<int> q; bool v[30000]; 
map<int,int> ha;

void add(int x,int y,int w,int f)
{
    e[++st].u=y; e[st].next=fir[x]; e[fir[x]=st].w=w; e[st].f=f;
    e[++st].u=x; e[st].next=fir[y]; e[fir[y]=st].w=0; e[st].f=-f;
}

bool spfa()
{
    for (int i=0;i<=N;i++) d[i]=inf/2,c[i]=fir[i],v[i]=0;
    q.push(0); v[0]=1; d[0]=0;
    while (!q.empty())
    {
        int k=q.front(); q.pop();  v[k]=0;
        for (int i=fir[k];i;i=e[i].next){
            int u=e[i].u,w=e[i].f;
            if (d[u]>d[k]+w&&e[i].w){
                d[u]=d[k]+w; if (!v[u]) v[u]=1,q.push(u);
            }
        }
    } 
    return (d[N]<inf/2);
}

int dfs(int p,int now)
{
    if (p==N){v[N]=1; return now;}
    int mw=0;  v[p]=1;
    for (int i=fir[p];i;i=e[i].next)
    {
        int u=e[i].u,w=e[i].f; 
        if (d[u]==d[p]+w&&e[i].w&&(!v[u]||u==N))
        if (mw=dfs(u,min(e[i].w,now)))
        {
            e[i].w-=mw; e[i^1].w+=mw; 
            cost+=mw*w; return mw;
        }
    }
}

void dinic()
{
    while (spfa()) {
         ans+=dfs(0,inf);
         for (int i=fir[N];i;i=e[i].next){
             int u=e[i].u,w=e[i].w;
             if (w&&!vis[u]) {
                 vis[u]=1; int co=ha[u]; sp[co]++;
                 add(++sm,N,1,0); ha[sm]=co;
                 for (int i=1;i<=n;i++) add(i,sm,1,sp[co]*g[i][co]);
             }
         }
    }
}

int main()
{
    cin>>n>>m; int sum=0;
    for (int i=1;i<=n;i++) cin>>a[i],sum+=a[i];
    for (int i=1;i<=n;i++) 
    for (int j=1;j<=m;j++) cin>>g[i][j];
    
    for (int i=1;i<=n;i++) add(0,i,a[i],0);
    sm=n;
    //for (int k=1;k<=n;k++) 时间K(总数不为n了） 
    for (int j=1;j<=m;j++) {//厨师j 
        add(++sm,N,1,0); ha[sm]=j; sp[j]=1;
        for (int i=1;i<=n;i++) add(i,sm,1,g[i][j]); //菜i 
    }
    dinic();
    cout<<cost<<endl; 
}

[SDOI2009]晨跑 #

路线不会相交，所以每个点只能走一遍。直接拆点，出点和入点连费用为0容量为1的边。

对于每条有向边，起点出点连终点入点，容量为1，费用为输入费用。

关于代码中S = 1+n(1号点的出点），T = n(n号点的入点)，是因为S和T是可以重复经过的。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m;
int e_ptr = 1, S, T, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

int main() {
    scanf("%d%d", &n, &m);
    S = n+1, T = n;
    for (int i = 1; i <= n; ++ i)
        AddEdge(i, i+n, 1, 0);
    for(int i=1; i<=m; i++) {
        int u, v, cost;
        scanf("%d%d%d", &u, &v, &cost);
        AddEdge(u+n, v, 1, cost);
    }
    PrimalDual();
    printf("%lld %lld", MaxFlow, MinCost);
    return 0;
}

[SDOI2010]星际竞速

第一道最小路径覆盖的费用流的题目。

再费用流中，最小路径覆盖就不能像在最大流中一样了。

但是背后的思想都是一样的。

在最大流中的最小路径覆盖的方法是：先将n个点拆点为i和i′。然后由源点向所有的i点连一条容量为1的边，再由所有的i'点向汇点连一条容量为1的边，对于每条边u−>v，由u向v'连一条容量为1的边，跑一遍最大流后，n减去最大流就是最小路径覆盖。

为什么可以这样做呢？可以发现，上面其实是一个二分图，最大流实际上就是最大匹配数。在这里可以发现，匹配中每连一条边，路径的数量就减1

所以路径数 = n - 最大流

 算是给自己长个见识把。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;

int e_ptr = 1, S, T, n, m, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

int main() {
    int u, v, cap, cost;
    scanf("%d%d", &n, &m);
    S = 0, T = n+n+1;
    for (int i = 1; i <= n; i ++) {
        int temp; scanf("%d", &temp);
        AddEdge(S, i+n, 1, temp);
        AddEdge(S, i, 1, 0);
        AddEdge(i+n, T, 1, 0);
    }

    for (int i = 1, u, v, c; i <= m; i ++) {
        scanf("%d%d%d", &u, &v, &c);
        if (u > v) swap(u, v);
        AddEdge(u, v+n, 1, c);
    }

    PrimalDual();
    printf("%lld\n", MinCost);
    return 0;
}

[HAOI2010]订货 #

比较裸。但是我最近拆点做多了，啥都拆点。不过这道题倒是不用。直接连就好了

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m;
int e_ptr = 1, S, T, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

int main() {
    int store;
    scanf("%d%d%d", &n, &m, &store);
    S = 0, T = 2*n+1;
    for (int i = 1; i <= n; ++ i) {
        int temp; scanf("%d", &temp);
        AddEdge(i, T, temp, 0);
//        AddEdge(i, i+n, store, 0);
        if (i < n) AddEdge(i, i+1, store, m);
    }
    for (int i = 1; i <= n; ++ i) {
        int temp; scanf("%d", &temp);
        AddEdge(S, i, LLINF, temp);
    }
    PrimalDual();
    printf("%lld\n", MinCost);
    return 0;
}

[ZJOI2010]网络扩容 #

这道题我以为会是像上面那道UVA上的网络扩容一样的，之后就在求最小割，之后枚举边，之后扩容跑MFMC。

但是其实这道题可以很简单就可以，原边的费用都是0，之后跑一次最大流。

清除原来的图，之后在建一次图，在原图基础上再加一条容量无限费用为wi的。同时新开一个T = n+1，n连向T容量原先的最大流+k费用为0.

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000+10, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, k;
int e_ptr = 1, S, T, head[MAXN]; Edge E[(MAXM)<<1];
ll dist[MAXN], MaxFlow, MinCost, delta;
int inq[MAXN], done[MAXN], vis[MAXN];
int color[MAXN];
void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}
struct record {
    int u, v;
    ll w, c;
}rec[MAXN];
int main() {
    scanf("%d%d%d", &n, &m, &k);
    S = 1, T = n;
    for (int i = 1,u,v,c; i <= m; ++ i) {
        scanf("%d%d%d%d", &rec[i].u, &rec[i].v, &rec[i].c, &rec[i].w);
        AddEdge(rec[i].u, rec[i].v, rec[i].c, 0);
    }
    PrimalDual();
    printf("%lld ", MaxFlow);
    T = n+1; memset(head, 0, sizeof(head)), e_ptr = 1;
    AddEdge(n, T, MaxFlow+k, 0);
    for (int i = 1,u,v,c; i <= m; ++ i) {
        AddEdge(rec[i].u, rec[i].v, rec[i].c, 0);
        AddEdge(rec[i].u, rec[i].v, LLINF, rec[i].w);
    }
    ll rec_MinCost = MinCost;
    PrimalDual();
    printf("%lld\n", MinCost);
    return 0;
}

 P2770 航空路线问题 #

这道题的DFS遍历非常值得学习，因为必然是从 i + n 到 j 。

所以我们进入的点必然是 i + n 点， 出去的点必然是 j ，所以我们就直接跳到 j +n 就代表经过 j 点。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;

int e_ptr = 1, S, T, n, m, head[MAXN+10]; Edge E[(MAXM+10)<<1];
ll dist[MAXN+10], MaxFlow, MinCost, delta;
int inq[MAXN+10], done[MAXN+10], vis[MAXN+10];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

map<string, int> name;
map<int, string> num;
int color[MAXN];

void DFS1(int u) {
    color[u]=1;
    cout << num[u-n] << endl;
    for(int i=head[u];i;i=E[i].next)
        if(E[i].v<=n&&E[i].cap > 0 && E[i].cap == E[i].flow) {
            DFS1(E[i].v+n);
            break;
        }
}
void DFS2(int u) {
    for(int i=head[u];i;i=E[i].next)
        if(E[i].v<=n&&!color[E[i].v+n]&& E[i].cap == E[i].flow)
        DFS2(E[i].v+n);
    cout<<num[u-n]<<endl;
}

int main() {
    cin >> n >> m;
    S = 1, T = n+n;
    int flag = 0;
    AddEdge(S, 1+n, 2, -1), AddEdge(n, T, 2, -1);
    for (int i = 1; i <= n; ++ i) {
        string city; cin >> city;
        name[city] = i, num[i] = city;
        if (i == 1 || i == n) continue;
        AddEdge(name[city], name[city]+n, 1, -1);
    }
    for (int i = 1; i <= m; ++ i) {
        string u, v; cin >> u >> v;
        if (name[u] > name[v]) swap(u, v);
        AddEdge(name[u]+n, name[v], 1, 0);
        if (name[u] == 1 && name[v] == n) flag = 1;
    }
    PrimalDual();
    if (MaxFlow != 2 && !flag) printf("No Solution!\n");
    else if (MaxFlow == 1 && flag) {
        cout << 2 << endl;
        cout << num[1] << endl << num[n] << endl << num[1] << endl;
    }
    else {
        cout << -MinCost-2 << endl;
        DFS1(n+1), DFS2(1+n);
    }


    return 0;
}

 P3159 [CQOI2012]交换棋子

这道题主要需要注意的是这里是交换而不是移动，所以这里拆点方式就会很特别。

 

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000+10, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, k;
int e_ptr = 1, S, T, head[MAXN]; Edge E[(MAXM)<<1];
ll dist[MAXN], MaxFlow, MinCost, delta;
int inq[MAXN], done[MAXN], vis[MAXN];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}
char st[25][25];
char ed[25][25];
char times[25][25];
int dic[8][2] = {1,0, 0,1, -1,0, 0,-1, 1,1, 1,-1, -1,1, -1,-1};
int main() {
    cin >> n >> m;
    S = 0, T = n*m*3+1;
    int cnt1 = 0, cnt2 = 0;
    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= m; ++ j)
            cin >> st[i][j], cnt1 += st[i][j]-'0';
    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= m; ++ j)
            cin >> ed[i][j], cnt2 += ed[i][j]-'0';
    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= m; ++ j)
            cin >> times[i][j];
    // 不加就是pre , + n*m就是mid,  + 2*n*m就是aft
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j) {
            int id = (i-1)*m+j;
            int limit = times[i][j]-'0';
            if (st[i][j] == '1') AddEdge(S, id+n*m, 1, 0);
            if (ed[i][j] == '1') AddEdge(id+n*m, T, 1, 0);
            if (st[i][j] == '0' && ed[i][j] == '1')
                AddEdge(id, id+n*m, (limit+1)/2, 0), AddEdge(id+n*m, id+2*n*m, limit/2, 0);
            else if (st[i][j] == '1' && ed[i][j] == '0')
                AddEdge(id, id+n*m, limit/2, 0), AddEdge(id+n*m, id+2*n*m, (limit+1)/2, 0);
            else
                AddEdge(id, id+n*m, limit/2, 0), AddEdge(id+n*m, id+2*n*m, limit/2, 0);
            for (int k = 0; k < 8; ++ k) {
                int tx = i+dic[k][0], ty = j+dic[k][1];
                if (tx < 1 || ty < 1 || tx > n || ty > m) continue;
                int id1 = (tx-1)*m + ty;
                AddEdge(id+2*n*m, id1, LLINF, 1);
            }
        }
    }
    PrimalDual();
    if (cnt1 != cnt2 || MaxFlow != cnt1) cout << -1 << endl;
    else cout << MinCost << endl;
    return 0;
}

P3356 火星探险问题 #

主要就是路径输出，看来我已经掌握了路径输出的要点了。

这道题因为没有用最大费用导致debug了好久。好累。

今天把讨厌的人删了，还是挺舒服的。

建图不是很难，我都想到了

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000+10, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, k;
int e_ptr = 1, S, T, head[MAXN]; Edge E[(MAXM)<<1];
ll dist[MAXN], MaxFlow, MinCost, delta;
int inq[MAXN], done[MAXN], vis[MAXN];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}
int g[36][36];
int dic[2][2] = {1,0, 0,1};

void FindPath(int tms, int u) {
    for (int i = head[u]; i; i = E[i].next) {
        int v = E[i].v;
        if (v == u-n*m) continue;
        if (v == T || v == S) continue;
        if (!E[i].flow) continue;
        E[i].flow--;
        int pos = (v == u-n*m+1);
        cout << tms << " " << pos << endl;
        FindPath(tms, v+n*m);
        break;
    }
}

int main() {
    int num; scanf("%d", &num);
    scanf("%d%d", &m, &n);
    S = 0, T = n*m*2+1;
    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= m; ++ j)
            scanf("%d", &g[i][j]);
    AddEdge(S, 1, num, 0), AddEdge(n*m*2, T, LLINF, 0);
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j) {
            int id = (i-1)*m+j;
            AddEdge(id, id+n*m, LLINF, 0);
            if (g[i][j] == 1) continue ;
            if (g[i][j] == 2) AddEdge(id, id+n*m, 1, -1);
            for (int k = 0; k < 2; ++ k) {
                int tx = i+dic[k][0], ty = j+dic[k][1];
                int _id = (tx-1)*m+ty;
                if (ty > m || tx > n || g[tx][ty] == 1) continue;
                AddEdge(id+n*m, _id, LLINF, 0);
            }
        }
    }
    PrimalDual();
    for (int i = 1; i <= MaxFlow; ++ i)
        FindPath(i, 1+n*m);
    return 0;
}

P3440 [POI2006]SZK-Schools #

看数据范围就知道很暴力。直接将200范围全部拆点，暴力连就好了。跑出来最大流不为n就输出NIE。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000+10, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, k;
int e_ptr = 1, S, T, head[MAXN]; Edge E[(MAXM)<<1];
ll dist[MAXN], MaxFlow, MinCost, delta;
int inq[MAXN], done[MAXN], vis[MAXN];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

struct Node {

} sch[205];

int main() {
    int n; scanf("%d", &n);
    S = 0, T = 200+n+1;
    for (int i = 1; i <= n; ++ i) {
        int mi, ai, bi, ki;
        scanf("%d %d %d %d", &mi, &ai, &bi, &ki);
        for (int j = ai; j <= bi; ++ j)
            AddEdge(i, n+j, 1, ki*abs(j-mi));
        AddEdge(S, i, 1, 0);
    }
    for (int i = 1; i <= 200; ++ i) AddEdge(n+i, T, 1, 0);
    PrimalDual();
    if (MaxFlow != n) cout << "NIE" << endl;
    else cout << MinCost << endl;
    return 0;
}

P3705 [SDOI2017]新生舞会 #

 我的原始对偶板子好像不是很适合求这种分数规划费用流的题目，这算是给个板子吧。思想是不难的。

#include<bits/stdc++.h>
using namespace std;
int read() {
    char cc = getchar(); int cn = 0, flus = 1;
    while(cc < '0' || cc > '9') {  if( cc == '-' ) flus = -flus;  cc = getchar();  }
    while(cc >= '0' && cc <= '9')  cn = cn * 10 + cc - '0', cc = getchar();
    return cn * flus;
}
const int M = 2e5 + 5 ; 
const int N = 200 + 5 ; 
#define inf 123456789
#define eps 1e-8
#define rep( i, s, t ) for( register int i = s; i <= t; ++ i )
#define Next( i, x ) for( register int i = head[x]; i; i = e[i].next )
struct E {
    int to, next, w;
    double f ; 
} e[M * 2]; 
int head[N * 2], cur[N * 2], cnt, n, mark[N * 2], vis[N * 2], s, t ;
double dis[N * 2], Ans, a[N][N], b[N][N] ;
void add( int x, int y, int z, double f ) {
    e[++ cnt] = (E){ y, head[x], z, f }, head[x] = cnt ; 
    e[++ cnt] = (E){ x, head[y], 0, -f }, head[y] = cnt ; 
} 
queue< int > q; 
bool spfa() {
    rep( i, s, t ) dis[i] = - inf ; 
    memset( vis, 0, sizeof(vis) ) ;
    q.push(s) ; dis[s] = 0 ;
    while( !q.empty() ) {
        int u = q.front() ; q.pop() ; vis[u] = 0;
        Next( i, u ) {
            int v = e[i].to ; 
            if( dis[v] < dis[u] + e[i].f && e[i].w ) {
                dis[v] = dis[u] + e[i].f;
                if( !vis[v] ) q.push(v), vis[v] = 1; 
            }    
        }
    }
    return dis[t] != -inf ;
}
int dfs( int x, int dist ) {
    mark[x] = 1 ; 
    if( x == t ) return dist ; 
    int flow = 0 ; 
    for( register int &i = cur[x]; i; i = e[i].next ) {
        int v = e[i].to ; 
        if( !mark[v] && dis[v] == dis[x] + e[i].f && e[i].w ) {
            int di = dfs( v, min( dist, e[i].w ) ) ; 
            if( di > 0 ) {
                e[i].w -= di, e[i ^ 1].w += di;
                flow += di, dist -= di ; 
                Ans += di * e[i].f ; 
                if( dist == 0 ) return flow ; 
            }
        }
    }
    return flow ;
}
void zkwflow() {
    Ans = 0;
    while(spfa()) {
        memcpy( cur, head, sizeof(head) ) ;
        mark[t] = 1 ; 
        while( mark[t] ) {
            memset( mark, 0, sizeof(mark) ) ;
            dfs( s, inf ) ;
        }
    }
} 
bool check( double x ) {
    s = 0, t = 2 * n + 1 ; cnt = 1;
    memset( head, 0, sizeof(head) );
    rep( i, 1, n ) add( s, i, 1, 0 ), add( i + n, t, 1, 0 ) ;
    rep( i, 1, n ) rep( j, 1, n ) add( i, j + n, 1, a[i][j] - x * b[i][j] );
    zkwflow() ;
    return Ans >= 0 ;
}
void solve() {
    double l = 0, r = 10000 + 5, mid, ans = 0 ;
    while( r - l > eps ) {
        mid = ( l + r ) / 2.0 ; 
        if( check(mid) ) ans = mid, l = mid + eps ; 
        else r = mid - eps ;
    }
    printf("%.6lf\n", ans ) ;
}
signed main()
{
    n = read() ; 
    rep( i, 1, n ) rep( j, 1, n ) a[i][j] = read() ; 
    rep( i, 1, n ) rep( j, 1, n ) b[i][j] = read() ; 
    solve() ; 
    return 0;
}

[TJOI2013]循环格

这道题主要是要发现出点和入点的关系，之后需要注意的点就是，这个方向是可以出图的，就是不用判边界，而是要取模。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

struct Edge {
    int u, v;
    ll flow, cap, cost;
    int next;
};

const int MAXN = 5000+10, MAXM = 50000;
const ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, k;
int e_ptr = 1, S, T, head[MAXN]; Edge E[(MAXM)<<1];
ll dist[MAXN], MaxFlow, MinCost, delta;
int inq[MAXN], done[MAXN], vis[MAXN];

void AddEdge(int u, int v, ll cap, ll cost) {
    E[++e_ptr] = (Edge) { u, v, 0, cap, cost, head[u] }; head[u] = e_ptr;
    E[++e_ptr] = (Edge) { v, u, 0,  0, -cost, head[v] }; head[v] = e_ptr;
}

void Reduce() {
    for(int i = 2; i <= e_ptr; i++)
        E[i].cost += dist[E[i].v] - dist[E[i].u];
    delta += dist[S];
}

bool BellmanFord() {
    queue<int> Q;
    memset(dist, 0x3f, sizeof(dist));
    dist[T] = 0; Q.push(T); inq[T] = true;
    while(!Q.empty()) {
        int u = Q.front(); Q.pop(); inq[u] = false;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                if(!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return dist[S] != LLINF;
}

bool Dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    dist[T] = 0; pq.push({dist[T], T});
    while(!pq.empty()) {
        int u = pq.top().second; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int j=head[u]; j; j=E[j].next) {
            int v = E[j].v; ll f = E[j^1].flow, c = E[j^1].cap, len = E[j^1].cost;
            if(f < c && dist[v] > dist[u] + len) {
                dist[v] = dist[u] + len;
                pq.push({dist[v],v});
            }
        }
    }
    return dist[S] != LLINF;
}

ll DFS(int u, ll flow) {
    if(u == T || flow == 0) return flow;
    vis[u] = true; // differ from dinic
    ll res = flow;
    for(int j=head[u]; j; j=E[j].next) {
        int v = E[j].v; ll f = E[j].flow, c = E[j].cap, len = E[j].cost;
        if(!vis[v] && f < c && len == 0) { // not `dist[v] == dist[u]` ! they do not equal !
            ll tmp = DFS(v, min(res, c-f)); // len = 0 <=> on the shortest path
            E[j].flow += tmp;
            E[j^1].flow -= tmp;
            res -= tmp;
        }
    }
    return flow - res;
}

void Augment() {
    ll CurFlow = 0;
    while(memset(vis, 0, sizeof(vis)),
        (CurFlow = DFS(S, LLINF))) {
        MaxFlow += CurFlow;
        MinCost += CurFlow * delta;
    }
}

void PrimalDual() {
    if(!BellmanFord()) return;
    Reduce(); Augment();
    while(Dijkstra()) {
        Reduce(); Augment();
    }
}

map<char, int> DicHash;
int g[20][20];
int dic[4][2] = {-1,0, 1,0, 0,-1, 0,1};

int main() {
    DicHash['U'] = 0, DicHash['D'] = 1;
    DicHash['L'] = 2, DicHash['R'] = 3;
    cin >> n >> m;
    S = 0, T = n*m*2+1;
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j) {
            char ch; cin >> ch, g[i][j] = DicHash[ch];
            int id = (i-1)*m+j;
            AddEdge(S, id, 1, 0), AddEdge(id+n*m, T, 1, 0);
            for (int k = 0; k < 4; ++ k) {
                int tx = (i+dic[k][0]+n-1)%n+1, ty = (dic[k][1]+j+m-1)%m+1;
                int _id = (tx-1)*m+ty;
                AddEdge(id, _id+n*m, 1, g[i][j] != k);
            }
        }
    }
    PrimalDual();
    cout << MinCost << endl;
    return 0;
}