其他分享
首页 > 其他分享> > 网络流最小割 H - Internship I - Friendship

网络流最小割 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