网络流最小割 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 + ;
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 = ; i <= n; i++)G[i].clear();
    e.clear();
}
void addedge(int u, int v, int c) {
    e.push_back(edge(u, v, c, ));
    e.push_back(edge(v, u, , ));
    m = e.size();
    G[u].push_back(m - );
    G[v].push_back(m - );
}
void BFS(int s)//预处理出level数组
//直接BFS到每个点
{
    memset(level, -, sizeof(level));
    queue<int>q;
    level[s] = ;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v = ; v < G[u].size(); v++) {
            edge& now = e[G[u][v]];
            if (now.c > now.f && level[now.v] < ) {
                level[now.v] = level[u] + ;
                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 >  && 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 > ) {
                now.f += d;//正向边流量加d
                e[G[u][v] ^ ].f -= d;
            //    printf("u=%d v=%d c=%d f=%d\n", now.u, now.v, now.c, now.f);
                //反向边减d，此处在存储边的时候两条反向边可以通过^操作直接找到
                return d;
            }
        }
    }
    return ;
}
int Maxflow(int s, int t) {
    int flow = ;
    for (;;) {
        BFS(s);
        if (level[t] < )return flow;//残余网络中到达不了t，增广路不存在
        memset(iter, , sizeof(iter));//清空当前弧数组
        int f;//记录增广路的可增加的流量
        while ((f = dfs(s, t, inf)) > ) {
            flow += f;
        }
    }
    return flow;
}
struct node
{
    int u, v, w;
    node(int u=,int v=,int w=):u(u),v(v),w(w){}
}ex[maxn];
bool vis[maxn], vit[maxn];

void dfs1(int x,int pre)
{
    vis[x] = ;
    for(int i=;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] = ;
    for(int i=;i<G[x].size();i++)
    {
        edge now = e[G[x][i]];
        edge no = e[G[x][i] ^ ];
        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 + , t = ;
        init(s);
        memset(vis, , sizeof(vis));
        memset(vit, , sizeof(vit));
        for(int i=;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 = ; i <= n; i++) addedge(s, i, inf);
        Maxflow(s, t);
        dfs1(s,-); dfs2(t,-);
        vector<int>ans; ans.clear();
        for(int i=;i<=k;i++)
        {
            if (vis[ex[i].u] && vit[ex[i].v]) ans.push_back(i);
        }
        if (ans.size() == ) printf("\n");
        else
        {
            int len = ans.size();
            for (int i = ; i < len-; i++) printf("%d ", ans[i]);
            printf("%d\n",ans[len-]);
        }
    }
    return ;
}

第二个题目，题目大意是：告诉你人与人之间的通信，

a要知道b的通信方式有两种 第一个是 a 知道b  第二个是 a 知道 c ，c 知道 b  如果一个人失联，则他的手机号码会换，而且他也不会记得任何一个人的号码

然后问你s t 要通信断开，满足这个要求，最少要使多少个人失联。

这个肯定是要拆点的，因为这个最大流表示他们联通删去的最小人数，所以要拆点，表示每一个人只有一次，如果他失联了，那么他就完全断开了。

如果不拆点，会碰到他是一个关键枢纽，经过他从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 + ;
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 = ; i <= n; i++)G[i].clear();
    e.clear();
}
void addedge(int u, int v, int c) {
    e.push_back(edge(u, v, c, ));
    e.push_back(edge(v, u, , ));
    int m = e.size();
    G[u].push_back(m - );
    G[v].push_back(m - );
}
void BFS(int s)//预处理出level数组
//直接BFS到每个点
{
    memset(level, -, sizeof(level));
    queue<int>q;
    level[s] = ;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v = ; 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] < ) {
                level[now.v] = level[u] + ;
                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 >  && 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 > ) {
                now.f += d;//正向边流量加d
                e[G[u][v] ^ ].f -= d;
            //    printf("u=%d v=%d c=%d f=%d\n", now.u, now.v, now.c, now.f);
                //反向边减d，此处在存储边的时候两条反向边可以通过^操作直接找到
                return d;
            }
        }
    }
    return ;
}
int Maxflow(int s, int t) {
    int flow = ;
    for (;;) {
        BFS(s);
        if (level[t] < )return flow;//残余网络中到达不了t，增广路不存在
        memset(iter, , sizeof(iter));//清空当前弧数组
        int f;//记录增广路的可增加的流量
        while ((f = dfs(s, t, inf)) > ) {
            flow += f;
        }
    }
    return flow;
}
int vis[][], vit[][];
int s, t, n;
void build()
{
    for(int i=;i<=n;i++)
    {
        if (i != s && i != t) addedge(i, i + n, );
        else addedge(i, i + n, inf);
        for(int j=;j<=n;j++)
        {
            if (i!=j&&vis[i][j]) addedge(i + n, j, );
        }
    }
}

int main()
{
    while(scanf("%d%d%d",&n,&s,&t)!=EOF)
    {
        init(maxn);
        for(int i=;i<=n;i++)
        {
            for(int j=;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 == ) continue;
        for (int i = ; i <= n; i++) {
            if (i == s || i == t) continue;
            init(maxn);
            for (int j = ; j <= n; j++) {
                for (int k = ; k <= n; k++) {
                    vit[j][k] = vis[j][k];
                    if (j == i || k == i) vis[j][k] = ;
                }
            }
            build();
            int an = Maxflow(s, t + n);
            if (an < ans) {
                ex.push_back(i);
                ans = an;
            }
            else {
                for (int j = ; j <= n; j++) {
                    for (int k = ; k <= n; k++) {
                        vis[j][k] = vit[j][k];
                    }
                }
            }
        }
        int len = ex.size();
        for (int i = ; i < len-; i++) printf("%d ", ex[i]);
        printf("%d\n",ex[len-]);
    }
    return ;
}