网络流最小割 H - Internship I - Friendship
作者：互联网
我觉得这两个最小割都还比较难。
第一个题目大意是给你一个网络，这个网络是由城市和中转站组成，终点是0，给你每一条边的流量，
问，从城市到终点最大流流完之后，是否可以增加一条路上的一条边的容量，使得最大流增加。
这个其实很好想到的就是枚举每一个条边，如果这条边增加容量之后可以使得最大流增加，那么就是符合要求的。
但是这个复杂度太高了。
然后看了题解就发现 如果 s~u v~t s可以到u，并且v可以到达t，如果增加(u,v) 容量，最大流是不是增大了。
根据这个想法可以写。
怎么去找这个(u,v)的边呢，就是从s往下搜索，搜正向边，如果这个没有流满，就标记一下。
再从t进行递归，搜逆向边，如果这个边的正向边没有流满，就标记一下。
然后再从第一条边开始查找，如果有一条边的左右都被不同的标记标记了，那么就是一条关键割。
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#define inf 0x3f3f3f3f
#define inf64 0x3f3f3f3f3f3f3f3f
using namespace std;
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 n, m, k;
void init(int n) {
for (int i = 0; i <= n; i++)G[i].clear();
e.clear();
}
void addedge(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;
// printf("u=%d v=%d c=%d f=%d\n", now.u, now.v, now.c, now.f);
//反向边减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;
}
struct node
{
int u, v, w;
node(int u=0,int v=0,int w=0):u(u),v(v),w(w){}
}ex[maxn];
bool vis[maxn], vit[maxn];
void dfs1(int x,int pre)
{
vis[x] = 1;
for(int i=0;i<G[x].size();i++)
{
edge now = e[G[x][i]];
if (now.v == pre) continue;
if (vis[now.v]) continue;
if (now.c <= now.f) continue;
dfs1(now.v,x);
}
}
void dfs2(int x,int pre)
{
vit[x] = 1;
for(int i=0;i<G[x].size();i++)
{
edge now = e[G[x][i]];
edge no = e[G[x][i] ^ 1];
if (now.v == pre) continue;
if (vit[now.v]) continue;
if (no.c <= no.f) continue;
dfs2(now.v, x);
}
}
int main()
{
while(scanf("%d%d%d",&n,&m,&k)!=EOF&&(n+m+k))
{
int N = n + m;
int s = N + 1, t = 0;
init(s);
memset(vis, 0, sizeof(vis));
memset(vit, 0, sizeof(vit));
for(int i=1;i<=k;i++)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w);
ex[i] = node(u, v, w);
}
for (int i = 1; i <= n; i++) addedge(s, i, inf);
Maxflow(s, t);
dfs1(s,-1); dfs2(t,-1);
vector<int>ans; ans.clear();
for(int i=1;i<=k;i++)
{
if (vis[ex[i].u] && vit[ex[i].v]) ans.push_back(i);
}
if (ans.size() == 0) printf("\n");
else
{
int len = ans.size();
for (int i = 0; i < len-1; i++) printf("%d ", ans[i]);
printf("%d\n",ans[len-1]);
}
}
return 0;
}
View Code
第二个题目，题目大意是：告诉你人与人之间的通信，
a要知道b的通信方式有两种 第一个是 a 知道b 第二个是 a 知道 c ，c 知道 b 如果一个人失联，则他的手机号码会换，而且他也不会记得任何一个人的号码
然后问你s t 要通信断开，满足这个要求，最少要使多少个人失联。
这个要拆点，其实我有点不太明白为什么要拆点。
拆完点之后就是就是去枚举每一个点断开之后的最大流，如果减小了，如果这个点就是满足要求的点，
题目要求按照字典序输出。
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#define inf 0x3f3f3f3f
#define inf64 0x3f3f3f3f3f3f3f3f
using namespace std;
const int maxn = 1e3 + 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];//当前弧优化
void init(int n) {
for (int i = 0; i <= n; i++)G[i].clear();
e.clear();
}
void addedge(int u, int v, int c) {
e.push_back(edge(u, v, c, 0));
e.push_back(edge(v, u, 0, 0));
int 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]];
//printf("u=%d v=%d c=%d f=%d\n", now.u, now.v, now.c, now.f);
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;
// printf("u=%d v=%d c=%d f=%d\n", now.u, now.v, now.c, now.f);
//反向边减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 vis[220][220], vit[220][220];
int s, t, n;
void build()
{
for(int i=1;i<=n;i++)
{
if (i != s && i != t) addedge(i, i + n, 1);
else addedge(i, i + n, inf);
for(int j=1;j<=n;j++)
{
if (i!=j&&vis[i][j]) addedge(i + n, j, 1);
}
}
}
int main()
{
while(scanf("%d%d%d",&n,&s,&t)!=EOF)
{
init(maxn);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
scanf("%d", &vis[i][j]);
vit[i][j] = vis[i][j];
}
}
if (vis[s][t]) {
printf("NO ANSWER!\n");
continue;
}
build();
vector<int>ex; ex.clear();
int ans = Maxflow(s, t + n);
printf("%d\n", ans);
if (ans == 0) continue;
for (int i = 1; i <= n; i++) {
if (i == s || i == t) continue;
init(maxn);
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
vit[j][k] = vis[j][k];
if (j == i || k == i) vis[j][k] = 0;
}
}
build();
int an = Maxflow(s, t + n);
if (an < ans) {
ex.push_back(i);
ans = an;
}
else {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
vis[j][k] = vit[j][k];
}
}
}
}
int len = ex.size();
for (int i = 0; i < len-1; i++) printf("%d ", ex[i]);
printf("%d\n",ex[len-1]);
}
return 0;
}
View Code
标签：include,return,level,Internship,最小,int,maxn,now,Friendship 来源： https://www.cnblogs.com/EchoZQN/p/11234374.html