标签：独立 ace algorithm sdn empty region string 增加 orange
题目：
none!
在一个有 m*n 个方格的棋盘中，每个方格中有一个正整数。现要从方格中取数，使任意 2 个数所在方格没有公共边，且取出的数的总和最大。试设计一个满足要求的取数算法。对于给定的方格棋盘，按照取数要求编程找出总和最大的数。
输入格式：
第 1 行有 2 个正整数 m 和 n，分别表示棋盘的行数和列数。接下来的 m 行，每行有 n 个正整数，表示棋盘方格中的数。
输出格式：
程序运行结束时，将取数的最大总和输出
m,n<=100
这个题目推荐博客：https://blog.csdn.net/qq_38944163/article/details/81218555
这个博客写的很好，这个题目是一个二分图的最大独立集。
这个是让我们在一个方格中选取数字，题目限制就是共享同一个边的两个数不能取，这个题目一开始很难想到用二分图的最大独立集。
那我们就跟着之前推荐的博客思路走一下，首先你要将相邻的分开，然后我们可以知道如果，我们可以找一个办法把这些数分成两个部分，
如果两个数同在一个部分则说明他们一定不相邻，不在一个部分则可能相邻。
根据这个原则，我们发现，如果两个数的奇偶性相同则一定不相邻，反之则可能相邻，就这样我们把这个方格数字提取出来分成了两个部分。
再对两个部分的数字进行处理，第一部分的数字和s相连权值为这个数值的大小，第二部分的和t相连权值为这个数值的大小，如果这两个部分的数字是相邻就连一条线，这个线的边权是inf。
权值为inf的原因是不确定第一部分和s相连的权值。
然后我们要求如果连了线，那么就不能放在一起，意思是说这个图一定最后是不连通的，这个我们就想到了割。
答案就是 ans=所有数字之和 - 割
为了ans尽量大，所以这个割应该尽量小，所以 ans=所有数字之和 - 最小割（最大流）
知道了这里，就可以跑模板了，但是呢，还是感觉会有一点不能理解。
你可以这么想，我要这个不连通，跑了一个最大流之后，有一些管道就已经满了，如果满了，这个管道满了（假设是连接s） 那么另外一个连接t的管道可能没有满
这个时候最大值只会加上这个更小一点的数，就相当于我在这两个相邻的数之间选了一个更小的数出去，这个是不是就满足我们的要求了。
这个跑最大流，就有点像短板效应了，就是就是在两块板子里面选了更短的一块加起来，这个会不会比较好理解，
这些都是最小割里面的内容了，不会的可以取看看我的另一篇博文：
这个就讲了一点点最小割的东西。
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <cstring>
#include <string>
#include <iostream>
#include <algorithm>
#define inf 0x3f3f3f3f
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 10;
struct edge
{
int u, v, c, f;
edge(int u, int v, int c, int f) :u(u), v(v), c(c), f(f) {}
};
vector<edge>e;
vector<int>G[maxn];
int level[maxn];//BFS分层，表示每个点的层数
int iter[maxn];//当前弧优化
int m;
void init(int n)
{
for (int i = 0; i <= n; i++)G[i].clear();
e.clear();
}
void add(int u, int v, int c)
{
e.push_back(edge(u, v, c, 0));
e.push_back(edge(v, u, 0, 0));
m = e.size();
G[u].push_back(m - 2);
G[v].push_back(m - 1);
}
void BFS(int s)//预处理出level数组
//直接BFS到每个点
{
memset(level, -1, sizeof(level));
queue<int>q;
level[s] = 0;
q.push(s);
while (!q.empty())
{
int u = q.front();
q.pop();
for (int v = 0; v < G[u].size(); v++)
{
edge& now = e[G[u][v]];
if (now.c > now.f && level[now.v] < 0)
{
level[now.v] = level[u] + 1;
q.push(now.v);
}
}
}
}
int dfs(int u, int t, int f)//DFS寻找增广路
{
if (u == t)return f;//已经到达源点，返回流量f
for (int &v = iter[u]; v < G[u].size(); v++)
//这里用iter数组表示每个点目前的弧，这是为了防止在一次寻找增广路的时候，对一些边多次遍历
//在每次找增广路的时候，数组要清空
{
edge &now = e[G[u][v]];
if (now.c - now.f > 0 && level[u] < level[now.v])
//now.c - now.f > 0表示这条路还未满
//level[u] < level[now.v]表示这条路是最短路，一定到达下一层，这就是Dinic算法的思想
{
int d = dfs(now.v, t, min(f, now.c - now.f));
if (d > 0)
{
now.f += d;//正向边流量加d
e[G[u][v] ^ 1].f -= d;
//反向边减d，此处在存储边的时候两条反向边可以通过^操作直接找到
return d;
}
}
}
return 0;
}
int Maxflow(int s, int t)
{
int flow = 0;
for (;;)
{
BFS(s);
if (level[t] < 0)return flow;//残余网络中到达不了t，增广路不存在
memset(iter, 0, sizeof(iter));//清空当前弧数组
int f;//记录增广路的可增加的流量
while ((f = dfs(s, t, INF)) > 0)
{
flow += f;
}
}
return flow;
}
int main()
{
int n, m, sum = 0;
cin >> n >> m;
int s = 0, t = n * m + 1;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
int x;
cin >> x;
sum += x;
int ex = (i - 1)*m + j;
if ((i+j) & 1)//这个地方要注意一下，不能用ex&1
{
add(s, ex, x);
if (j + 1 <= m) add(ex, ex + 1, inf);
if (i + 1 <= n) add(ex, i*m + j, inf);
if (j - 1 >= 1) add(ex, ex - 1, inf);
if (i - 1 >= 1) add(ex, (i - 2)*m + j, inf);
}
else add(ex, t, x);
}
}
int ans = Maxflow(s, t);
printf("%d\n", sum - ans);
return 0;
}
标签：独立 ace algorithm sdn empty region string 增加 orange
原文地址：https://www.cnblogs.com/EchoZQN/p/10805156.html
