网络流小结 专题题解汇总

最新推荐文章于 2024-10-26 21:45:01 发布
最新推荐文章于 2024-10-26 21:45:01 发布
阅读量157 收藏
点赞数
分类专栏： 网络流 文章标签： 网络 bfs 网络流 acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43555854/article/details/107903540
版权
  • hdu 3572 Task Schedule 任务题
    拆点（天）
    题意：
    现在你有m个机器，n个任务，每个任务有三个属性p,s,e,表示只能在[p,e]区间内花s的时间做完这个任务，一个机器一个时间只能做一个任务，一个任务一个时间只能被一个机器做，现在问你能不能完成全部的任务。
    n,m <= 500
    1 <= p,s,e <= 500
    思路：
    设0是源点，1~500是机器，501~1000是天数，1100是汇点，假设任务i三个属性p，s，e，源点连一条容量s的边到点 i，然后点 i 分别向每个[500+p, 500+e]的顶点连容量为1的边，最后501~1000向汇点连一条容量为1的边，跑个最大流，如果最大流等于所有任务s之和就是YES，否则就是NO。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000;   //点数
const int INF = 0x3f3f3f3f;
int tc,n,m;
struct Edge{
    int from, to, cap, flow;  //如果要开ll的话，这边也要开ll
    Edge(int u, int v, int c, int f)
        : from(u), to(v), cap(c), flow(f) {}
};
struct Dicnic {
    #define Type int
    int n, m, s, t;        //节点数，边数（包括反向弧），源点编号和汇点编号
    vector<Edge> edges;    //边表。edge[e]和edge[e^1]互为反向弧
    vector<int> G[maxn];   //邻接表，G[i][j]表示节点i的第j条边在e数组中的编号
    bool vis[maxn];        //BFS使用
    Type d[maxn];           //从起点到i的距离
    int cur[maxn];         //当前弧下标
    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.emplace_back(Edge(from, to, cap, 0));
        edges.emplace_back(Edge(to, from, 0, 0));
        m = int(edges.size());
        G[from].emplace_back(m-2);
        G[to].emplace_back(m-1);
    }
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        memset(d, 0, sizeof(d));
        queue<int> q;
		while (!q.empty()) q.pop();
        q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            for (int i = 0; i < int(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];
    }
    Type DFS(int x, Type a) {
        if (x == t || a == 0) return a;
        Type flow = 0, f;
        for (int &i = cur[x]; i < int(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;
    }
    Type Maxflow(int s, int t) {
        this->s = s; this->t = t;
        Type flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
    #undef Type
}dicnic;
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    cin>>tc;
    int kase=1;
    while(tc--){
        int sum=0;
        cin>>n>>m;
        dicnic.init(1300);
        for(int i=1; i<=n; ++i){
            int p,s,e;
            cin>>p>>s>>e;
            sum+=s;
            dicnic.addEdge(0,i,s);
            for(int j=500+p; j<=500+e; ++j) dicnic.addEdge(i,j,1);
        }
        for(int i=501; i<=1000; ++i) dicnic.addEdge(i,1100,m);
        int all=dicnic.Maxflow(0,1100);
        cout<<"Case "<<kase++<<": ";
        if(all==sum) cout<<"Yes"<<'\n';
        else cout<<"No"<<'\n';
    }
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}
  • hdu 2732 Leapin’ Lizards 蜥蜴题
  • 拆点（柱子）
    题意：
    给你一张图，上面有柱子和蜥蜴，有蜥蜴的地方一定有柱子，每根柱子还有耐久度，每个蜥蜴最多能跳到离原来位置<=d距离的柱子，这个距离是x的距离差+y的距离差。
    思路：
    因为柱子有耐久度，所以可拆点连一条有容量的边来表示他的限制。
    设源点为s，入点为t。
    如果p有蜥蜴，那么s到p连一条容量1的边。
    如果p可以跳到安全地带，那么p+n*m到t连一条容量为INF的边。
    接下来就是内部柱子里面乱跳了，4个for搞一下。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;   //点数
const int INF = 0x3f3f3f3f; //ll 0x8个3fLL
int tc, n, m, d, pi[40][40], cnt[40][40];
string a[40],b[40];
struct Edge{
    int from, to, cap, flow;  //如果要开ll的话，这边也要开ll
    Edge(int u, int v, int c, int f)
        : from(u), to(v), cap(c), flow(f) {}
};
struct Dicnic {
    #define Type int
    int n, m, s, t;        //节点数，边数（包括反向弧），源点编号和汇点编号
    vector<Edge> edges;    //边表。edge[e]和edge[e^1]互为反向弧
    vector<int> G[maxn];   //邻接表，G[i][j]表示节点i的第j条边在e数组中的编号
    bool vis[maxn];        //BFS使用
    Type d[maxn];           //从起点到i的距离
    int cur[maxn];         //当前弧下标
    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.emplace_back(Edge(from, to, cap, 0));
        edges.emplace_back(Edge(to, from, 0, 0));
        m = int(edges.size());
        G[from].emplace_back(m-2);
        G[to].emplace_back(m-1);
    }
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        memset(d, 0, sizeof(d));
        queue<int> q;
		while (!q.empty()) q.pop();
        q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            for (int i = 0; i < int(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];
    }
    Type DFS(int x, Type a) {
        if (x == t || a == 0) return a;
        Type flow = 0, f;
        for (int &i = cur[x]; i < int(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;
    }
    Type Maxflow(int s, int t) {
        this->s = s; this->t = t;
        Type flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
    #undef Type
}dicnic;
int myabs(int x) {return (x<0?-x:x);}
int getdist(int x1, int y1, int x2, int y2) {
    int d1=myabs(x1-x2), d2=myabs(y1-y2);
    return (d1+d2);
}
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    int kase=1;
    cin>>tc;
    while(tc--){
        dicnic.init(950);
        cin>>n>>d;
        for(int i=0; i<n; ++i) cin>>a[i];
        for(int i=0; i<n; ++i) cin>>b[i];
        m=int(a[0].size());
        int tot=0;
        memset(cnt,0,sizeof(cnt));
        memset(pi,0,sizeof(pi));
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j){
                int num=int(a[i][j]-'0');
                pi[i][j]=num;
                if(num!=0) {
                   cnt[i][j]=++tot;
                   dicnic.addEdge(cnt[i][j], cnt[i][j]+400, num);
                }
            }
        }
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j){
                if(cnt[i][j]==0) continue;
                for(int ii=0; ii<n; ++ii){
                    for(int jj=0; jj<m; ++jj){
                        if(i==ii && j==jj) continue;
                        if(cnt[ii][jj]==0) continue;
                        if(getdist(i, j, ii, jj) <= d) {
                            dicnic.addEdge(cnt[i][j]+400, cnt[ii][jj], INF);
                        }
                    }
                }
            }
        }
        int sum=0;
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j){
                if(b[i][j]=='L') {
                    ++sum;
                    dicnic.addEdge(0, cnt[i][j], 1);
                }
            }
        }
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j){
                if(cnt[i][j]==0) continue;
                int dis;
                bool ok=false;
                dis=i;
                if(d>dis) ok=true;
                dis=j;
                if(d>dis) ok=true;
                dis=n-1-i;
                if(d>dis) ok=true;
                dis=m-1-j;
                if(d>dis) ok=true;
                if(ok) {
                    dicnic.addEdge(cnt[i][j]+400, 900, INF);
                }
            }
        }
        int res=dicnic.Maxflow(0, 900);
        if(sum-res>1) cout<<"Case #"<<kase++<<": "<<sum-res<<" lizards were left behind."<<'\n';
        else if(sum-res==1) cout<<"Case #"<<kase++<<": "<<sum-res<<" lizard was left behind."<<'\n';
        else cout<<"Case #"<<kase++<<": no lizard was left behind."<<'\n';
    }
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}
  • hdu 2883 kebab 烤肉题（和任务题类似）
    离散化
    题意：
    跟hdu 3572,也就是这个小结的第一题题意基本一样，就差了两点。
    1.允许的时间变成了[s,e)而不是[s,e]。
    2.s和e的范围变成了5000而不是500；
    思路：
    因为dicnic的上界复杂度是O(V^2*E)。你把5000个天全都拆出来肯定超时，因为只有200个时间段，所以可以离散化处理。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;   //点数
const int INF = 0x3f3f3f3f; //ll 0x8个3fLL
struct Edge{
    int from, to, cap, flow;  //如果要开ll的话，这边也要开ll
    Edge(int u, int v, int c, int f)
        : from(u), to(v), cap(c), flow(f) {}
};
struct node{
    int l,r;
    node(){}
    node(int _l, int _r):l(_l),r(_r){}
}nd[maxn];
int n,m,all[maxn],si[maxn],ni[maxn],ei[maxn],ti[maxn];
struct Dicnic {
    #define Type int
    int n, m, s, t;        //节点数，边数（包括反向弧），源点编号和汇点编号
    vector<Edge> edges;    //边表。edge[e]和edge[e^1]互为反向弧
    vector<int> G[maxn];   //邻接表，G[i][j]表示节点i的第j条边在e数组中的编号
    bool vis[maxn];        //BFS使用
    Type d[maxn];           //从起点到i的距离
    int cur[maxn];         //当前弧下标
    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.emplace_back(Edge(from, to, cap, 0));
        edges.emplace_back(Edge(to, from, 0, 0));
        m = int(edges.size());
        G[from].emplace_back(m-2);
        G[to].emplace_back(m-1);
    }
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        memset(d, 0, sizeof(d));
        queue<int> q;
		while (!q.empty()) q.pop();
        q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            for (int i = 0; i < int(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];
    }
    Type DFS(int x, Type a) {
        if (x == t || a == 0) return a;
        Type flow = 0, f;
        for (int &i = cur[x]; i < int(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;
    }
    Type Maxflow(int s, int t) {
        this->s = s; this->t = t;
        Type flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
    #undef Type
}dicnic;
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    while(cin>>n>>m){
        dicnic.init(1050);
        int tot=0, sum=0;
        for(int i=1; i<=n; ++i){
            cin>>si[i]>>ni[i]>>ei[i]>>ti[i];
            sum+=ni[i]*ti[i];
            dicnic.addEdge(0, i, ni[i]*ti[i]);
            all[++tot]=si[i]; all[++tot]=ei[i];
            nd[i]=node(si[i],ei[i]);
        }
        sort(all+1, all+1+tot);
        for(int i=1; i<=n; ++i){
            int ia=lower_bound(all+1, all+1+tot, nd[i].l)-all;
            int ib=lower_bound(all+1, all+1+tot, nd[i].r)-all;
            for(int j=ia; j<ib; ++j) dicnic.addEdge(i, 200+j, INF);
        }
        for(int i=1; i<tot; ++i){
            int num=all[i+1]-all[i];
            dicnic.addEdge(200+i, 1000, num*m);
        }
        int maxflow=dicnic.Maxflow(0, 1000);
        if(maxflow==sum) cout<<"Yes"<<'\n';
        else cout<<"No"<<'\n';
    }
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}
  • hdu 1533 回家题
    二分图最小匹配-> 二分图最大权匹配（KM+负边）或者 最小费用最大流（mcmf）
    题意：
    给你一个n*m的矩阵上面有m和H，m代表人，H代表房子，有相同数量的人和房子，现在问你让所有人都走到房子里的最小步数和是多少。
    思路：
    如果用mcmf做，设源点为s，汇点为t。
    源点向每个m连一条容量为1，代价为0的流。
    m向每个H连一条容量为1，代价为坐标绝对值差之和的流。
    每个H向t连一条容量为1，代价为0的流。
    然后跑mcmf，最小费用就是答案。
    ==============================================
    用km做就更简单了，直接m和H之间连负边，然后跑km。
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 1100;      //点数
const int INF = 0x3f3f3f3f;
int n, m, num[maxn][maxn];
char mat[maxn][maxn];
struct Edge{
    int from, to, cap, flow, cost;
    Edge(int u, int v, int c, int f, int cc)
        : from(u), to(v), cap(c), flow(f), cost(cc) {}
};
struct MCMF {
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    int inq[maxn];  //是否在队列中
    int d[maxn];    //bellmanford
    int p[maxn];    //上一条弧
    int a[maxn];    //可改进量
    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, int cost) {
        edges.emplace_back(Edge(from, to, cap, 0, cost));
        edges.emplace_back(Edge(to, from, 0, 0, -cost));
        m = int(edges.size());
        G[from].emplace_back(m - 2);
        G[to].emplace_back(m - 1);
    }
    bool spfa(int s, int t, int &flow, ll &cost) {
        for (int i = 1; i <= n; ++i) d[i] = INF;
        memset(inq, 0, sizeof(inq));
        d[s] = 0;
        inq[s] = 1;
        p[s] = 0;
        a[s] = INF;
        queue<int> q;
        q.push(s);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            inq[u] = 0;
            for (int i = 0; i < int(G[u].size()); ++i) {
                Edge &e = edges[G[u][i]];
                if (e.cap > e.flow && d[e.to] > d[u] + e.cost) {
                    d[e.to] = d[u] + e.cost;
                    p[e.to] = G[u][i];
                    a[e.to] = min(a[u], e.cap - e.flow);
                    if (!inq[e.to]) {
                        q.push(e.to);
                        inq[e.to] = 1;
                    }
                }
            }
        }
		//if (d[t] > k) return false;    //如果费用大于k就退出
		//if (d[t] >= 0) return false;   //最小费用流
        if (d[t] == INF) return false;
        flow += a[t];
        cost += (ll)d[t] * (ll)a[t];
        for (int u = t; u != s; u = edges[p[u]].from) {
            edges[p[u]].flow += a[t];
            edges[p[u] ^ 1].flow -= a[t];
        }
        return true;
    }
    int MincostMaxflow(int s, int t, ll &cost) {
        int flow = 0;
        cost = 0;
        while (spfa(s, t, flow, cost));
        return flow;
    }
}mcmf;
int myabs(int x) {return (x<0?-x:x);}
int getdist(int x1, int y1, int x2, int y2){
    int ret=myabs(x1-x2)+myabs(y1-y2);
    return ret;
}
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    while(cin>>n>>m){
        if(!n && !m) break;
        mcmf.init(1050);
        for(int i=0; i<=n; ++i) for(int j=1; j<=m; ++j) num[i][j]=0;
        for(int i=1; i<=n; ++i) for(int j=1; j<=m; ++j) cin>>mat[i][j];
        int tot=0;
        for(int i=1; i<=n; ++i) for(int j=1; j<=m; ++j) if(mat[i][j]=='m') num[i][j]=++tot;
        for(int i=1; i<=n; ++i) for(int j=1; j<=m; ++j) if(mat[i][j]=='H') num[i][j]=++tot;
        for(int i=1; i<=n; ++i) {
            for(int j=1; j<=m; ++j){
                if(mat[i][j]=='m') mcmf.addEdge(0, num[i][j], 1, 0);
                else if(mat[i][j]=='H') mcmf.addEdge(num[i][j], 1000, 1, 0);
            }
        }
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=m; ++j){
                if(mat[i][j]=='m') {
                    for(int ii=1; ii<=n; ++ii){
                        for(int jj=1; jj<=m; ++jj){
                            if(mat[ii][jj]=='H'){
                                mcmf.addEdge(num[i][j], num[ii][jj], 1, getdist(i, j, ii, jj));
                            }
                        }
                    }
                }
            }
        }
        ll cost=0;
        ll maxflow=mcmf.MincostMaxflow(0, 1000, cost);
        cout<<cost<<'\n';
    }
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}
  • hdu 1565 方格取数 方格题
    最大点权独立集 = 所有的点权 - 最小点权覆盖集（最小割）
    题意：
    现在有一个n*n的矩阵，里面每个格子都有一个非负数，现在规定取出来的数不能位置不能相邻，现在问你取出来数的值的最大和是多少。
    思路：
    最大点权独立集 = 所有的点权 - 最小点权覆盖集（最小割）
    有点抽象，先记住再说。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;   //点数
const int INF = 0x3f3f3f3f; //ll 0x8个3fLL
int n, mat[maxn][maxn], num[maxn][maxn];
struct Edge{
    int from, to, cap, flow;  //如果要开ll的话，这边也要开ll
    Edge(int u, int v, int c, int f)
        : from(u), to(v), cap(c), flow(f) {}
};
struct Dicnic {
    #define Type int
    int n, m, s, t;        //节点数，边数（包括反向弧），源点编号和汇点编号
    vector<Edge> edges;    //边表。edge[e]和edge[e^1]互为反向弧
    vector<int> G[maxn];   //邻接表，G[i][j]表示节点i的第j条边在e数组中的编号
    bool vis[maxn];        //BFS使用
    Type d[maxn];           //从起点到i的距离
    int cur[maxn];         //当前弧下标
    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.emplace_back(Edge(from, to, cap, 0));
        edges.emplace_back(Edge(to, from, 0, 0));
        m = int(edges.size());
        G[from].emplace_back(m-2);
        G[to].emplace_back(m-1);
    }
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        memset(d, 0, sizeof(d));
        queue<int> q;
		while (!q.empty()) q.pop();
        q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            for (int i = 0; i < int(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];
    }
    Type DFS(int x, Type a) {
        if (x == t || a == 0) return a;
        Type flow = 0, f;
        for (int &i = cur[x]; i < int(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;
    }
    Type Maxflow(int s, int t) {
        this->s = s; this->t = t;
        Type flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
    #undef Type
}dicnic;
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.precision(10);cout << fixed;
#ifdef LOCAL_DEFINE
    freopen("input.txt", "r", stdin);
#endif
    while(cin>>n){
        dicnic.init(600);
        int tot=0, sum=0;
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=n; ++j){
                cin>>mat[i][j];
                sum+=mat[i][j];
                num[i][j]=++tot;
            }
        }
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=n; ++j){
                if((i+j)%2==0){
                    dicnic.addEdge(0, num[i][j], mat[i][j]);
                    if(i>1) dicnic.addEdge(num[i][j], num[i-1][j], INF);
                    if(i<n) dicnic.addEdge(num[i][j], num[i+1][j], INF);
                    if(j>1) dicnic.addEdge(num[i][j], num[i][j-1], INF);
                    if(j<n) dicnic.addEdge(num[i][j], num[i][j+1], INF);
                } else{
                    dicnic.addEdge(num[i][j], 500, mat[i][j]);
                }
            }
        }
        cout<<sum-dicnic.Maxflow(0, 500)<<'\n';
    }
#ifdef LOCAL_DEFINE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}
whoammiiiiii
关注
专栏目录
网络流24题 选做 题意+题解
Never give in.
03-02 291
Preface 最近做题感觉自己的网络流姿势不是很够，决定去做一做传说中的网络流24题，就有了这一篇Blog 这些题LibreOJ上不少都有，直接搜网络流24题即可 1.[loj#6000] 搭配飞行员 一架飞机需要正副驾驶员恰好各一位，有一些正驾驶员和一些副驾驶员，他们之间有些能在一起合作。问最多能同时出发多少飞机。 直接二分图最大匹配，没什么好说的。 2.[loj#6001] 太空飞行计划 有...
网络流最大流（FF、Dinic）详解
weixin_43945141的博客
11-23 3254
网络流基础概念 考虑这幅图，你可以看成从村庄s到村庄t有很多条物流道路，每个点都是个中转结点，每条路的权值即该条路最多能运送的货物 介绍一些基本概念： 网络：一个入度为0的点s，一个出度为0的点t，每条边有自己权值的有向图 容量：当前边上的权值，比如SA的容量即为3 源点：入度为0的点，通常s来表示 汇点：出度为0的点，通常t来表示 流：一个合法解称作一个流，也就是一条可以从源点到汇点的一条合法路径。 流量：每条边各自运送的包裹数称作其流量，最终收集的总数为整个流的流量。边上的流量：f（SA）=2，代表今
最大流
weixin_34023982的博客
12-10 76
Dinic： int tot; int front[N],to[M<<1],nxt[M<<1],val[M<<1]; int src,decc; int cur[N],lev[N]; queue<int>q; void read(int &x) { x=0; char c=getchar();...
poj1273（最大网络流问题模版）
Keep_Trying_Go的博客
03-07 222
方法一： #include <iostream> #include<algorithm> #include<cstring> #include<cstdio> #include<cmath> using namespace std; const int maxn=1e4+1,maxm=2e5+1; int n,m,s,t,tot=1,head[maxn],vis[maxn]; struct edge{ int to,next,w; }e[m
51nod贪心专题题解（补充）
晚安(￣o￣) . z Z
11-21 167
1091 线段的重叠（贪心） 1099 任务执行顺序（贪心，思维） 1117 聪明的木匠（优先队列，贪心） 1125 交换机器的最小代价（贪心，环） 1133 不重叠的线段（贪心） 1163 最高的奖励（贪心，优先队列） 1191 消灭兔子（贪心，优先队列） 1212 无向图最小生成树(prim) 1255 字典序最小的子序列（贪心） 1257 背包问题 V3(贪心，二分，分数规划) 1279 扔...
[kuangbin带你飞]专题十八 后缀数组 题解汇总
勇敢前进的ACMer
03-10 398
      我是一个ACM弱校的ACMer，发现ACM队的同学没几个对字符串处理这块比较熟悉。。所以clone了 kuangbin的后缀数组专题进行了为期一星期的专题训练。从寒假开始就把自己大部分AC的题目和题解上传到了GitHub上，所以这段时间写博客写的少了很多。 其实无论是写博客还是放到GitHub上，学会总结思路和表达清晰题意都是非常重要的。      拉了kuangbin好多的专题进行训...
KMP总结归纳 题型汇总(kuangbin带你飞专题16)
vaeloverforever的博客
08-27 715
前序：花了好几天才把带你飞系列的KMP专题(地址：https://vjudge.net/contest/246969#overview搞定，刷了很多题，发现KMP可以用来解决这几类问题： ①单个字符串匹配问题（s1在s2中匹配）：这个用strstr(const char* big, const char* small)函数也可以，这个函数返回small在big函数中首次出现的地址，没有出现就返回...
算法面试题《精选题目+题解分类汇总》
clonechen
03-24 2737
从去年年底开始想准备找实习，于是就开始懒散的复习。 大二学过数据结构，对基本的算法理论和数据结构有过了解，但是感觉又基本都交还给老师了 于是开始零散的复习，在leetcode上按照通过率由高到低开始刷，发现自己连通过率最高的几个题都吃力，几乎每个题都要去看题解然后慢慢消化 刷了十多个题就放弃了，这种盲目的玩法真的太伤自信心 于是就去看书，先复习下基础，当然就盲目看书还是没学到什么东西 之后又买了慕...
【笔试题汇总】华为春招笔试题题解 2024-3-20
fans2306的博客
04-26 3206
这里是paoxiaomo，一个现役ACMer，之后将会持续更新算法笔记系列以及笔试题题解系列本文章面向想打ICPC/蓝桥杯/天梯赛等程序设计竞赛，以及各个大厂笔试的选手有什么想看的算法专题可以私信博主（本文题面由收集）
leetcode题库-LeetCode-Topic:LeetCode专题刷题模板分类Java版讲解
06-29
计划把LeetCode分专题总结，每个文件夹对应一个专题 一个专题里内容有两部分： \*\*模板.md: 包含相应专题的知识点，以及我融合网上讲解和我自己的总结得到的模板，以及文件夹下的题目的简要思路 \*\*习题.md：相应...
自动驾驶算法/规划决策控制算法面经汇总、学习路线、面经心得
热门推荐
qq_41667348的博客
02-16 1万+
自动驾驶规划决策算法学习路线，求职建议
[kuangbin带你飞]专题十六 KMP & 扩展KMP & Manacher
qq_45810570的博客
07-15 324
可算在学校大佬的带领下 正经学了点算法了 人的专注力不行啊我 挂个题目链接 24道题搞定了21，看其他的完成率，估计不行了 当然还是有些看了题解的。 写这个主要是为了总结一下板子，和思路吧，以后好直接抄，嘿嘿 KMP模板 next数组 next_[0] = -1; int i = 0， j = -1; while (i < e) {//e字符串c1长度 if (j == -1 || c1[i] == c1[j]) { i++; j++; next_[i] = j
网络编程（Day34）
weixin_65095004的博客
10-24 1028
子网网段的个数 = 2^(子网掩码中1的个数)子网网段下的主机个数 = 2^(子网掩码中0的个数)今天的学习内容主要涉及计算机网络的基础知识和发展历程，包含网络发展阶段、TCP/IP协议的概念和分层模型、字节序的转换及相关函数、IP地址的分类与转换方法，以及端口号的概念和使用方法。通过这些内容，能够全面了解计算机网络的基本架构、数据传输的原理，以及网络通信中的关键技术。
java核心技术点都有哪些
最新发布
weixin_57763462的博客
10-26 311
ORM框架则像是图书馆的图书管理员，它帮你把书籍的标题（数据库表名）、作者（字段名）等信息转换成你更容易理解的形式（对象），让你能够更方便地借阅和归还书籍（操作数据库）。try块就像是正常行驶的路段，catch块则是遇到问题时（如爆胎、抛锚）的应对措施，finally块则是无论是否遇到问题都要执行的收尾工作（如锁车、关灯）。同步和锁就像是服务员之间的协作机制，确保他们不会同时去服务同一个顾客（避免数据竞争），而并发集合则像是餐厅的菜单，它支持多个服务员同时查看和更新（线程安全）。
内网穿透问题
weixin_62528784的博客
10-24 756
内网穿透，frp的原理需要深入理解
【网络原理】——HTTP协议、fiddler抓包
阿华的博客
10-23 1285
HTTP超文本传输，HTML，fiddler抓包，URL，urlencode,HTTP首行方法，GET方法，POST方法
交换机访问控制列表（ACL）和防火墙有什么区别？
Welcome To OpenClouds World !!!
10-25 176
ACL主要用于限制特定类型的流量通过设备，例如限制从特定网络或主机访问网络资源。防火墙可以实现更加复杂的安全策略，例如检测和阻止恶意软件、入侵检测和预防等。而ACL则只能限制特定类型的流量，无法检测和防止更复杂的网络威胁。防火墙通常是一种独立的安全设备，用于保护整个网络。器和交换机等网络设备上，用于限制网络流量的进出。防火墙具有更强的安全性，可以防止更多的。
华为Eth-Trunk级联堆叠接入IPTV网络部署案例
专研计算机网络，数据通信，网络安全，系统集成
10-23 788
随着IPTV业务的迅速发展，IPTV平台承载的用户也越来越多，用户对IPTV直播业务的可靠性要求越来越高。IPTV作为视频类业务，最终用户对业务体验的连续性要求极高，需要保障日常维护中的用户业务体验连续，在重大事件保障、重大版本升级保障中保证业务的延续性。如图1所示是某个地区广电基本组网图。为了保证广电直播流的质量，广电组播源服务器发送的直播流需要先转发到MRF转码服务器进行转码，然后由转码服务器再转发给接收者。转码服务器通过Eth-Trunk级联堆叠的方式接入IPTV组网，提高网络可靠性。
网络安全（黑客技术）2024年三个月自学手册
2401_85026116的博客
10-23 1633
网络安全可以基于攻击和防御视角来分类，我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。走安全行业的工程方向的，技术上面其实有很大的重叠性，抛开甲乙方、岗位名称、岗位职责等因素来看，作为学技术的，也根据以往我们给学员推荐就业和入职情况来看，只要好好掌握以下几种技术（网络协议与安全设备、Linux操作系统、Web服务部署/开发、主流渗透测试/安全工具、一门及以上的编程语言）中的2到3个，都可以较好的胜任工作需求。
网络流模型经典题解集合
"这篇文档是关于网络流问题的题解集合，涵盖了多个经典的网络流模型在实际问题中的应用。文档中列举了多个编程竞赛题目，包括最大流、最小割、有上下界的网络流以及最小费用流等不同类型的网络流问题，并提供了对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值