#6004. 「网络流 24 题」圆桌聚餐（重点整理两种网络流输出方式）

最新推荐文章于 2021-06-03 22:58:41 发布

fighting_yifeng

最新推荐文章于 2021-06-03 22:58:41 发布

阅读量342

点赞数

CC 4.0 BY-SA版权

分类专栏：图论

本文链接：https://blog.youkuaiyun.com/fighting_yifeng/article/details/96875487

图论专栏收录该内容

11 篇文章

订阅专栏

本文探讨了圆桌问题的解决方法，通过构建图模型来寻找最优方案，并详细介绍了路径输出的具体实现。此外，还对比了路径覆盖输出的不同之处。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

P3254 圆桌问题

题意:就是让不同的单位的员工做不同的桌子，并输出方案。

建图很好想，就不多**了。

关键是路径输出：

            for(int i = 1; i <= m; i++)
            {
                int len = G[i].size(), flag = 0;
                for(int j = 0; j < len; j++)
                {
                    int y = G[i][j].to;
                    if(y != s && !G[i][j].cap)
                    {
                        if(flag) printf(" ");
                        flag = 1;
                        printf("%d", y - m);
                    }
                }
                printf("\n");
            }

还有之前遇到的路径覆盖的输出：

        for(int i = 1; i <= cur - 1; i++)
            if(!b[i]) flag = 0, print(i), printf("\n");


void print(int x)
{
    b[x] = true;
    if(flag) printf(" ");
    flag = 1;
    printf("%d", x);
    int len = G[x].size();
    for(int j = 0; j < len; j++)
        if(G[x][j].cap == 0 && G[x][j].to != 0)
        {
            print(G[x][j].to - 2000); return;
        }
}

区别在于路径覆盖时，用过的点就不能再用了，递归输出。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 51000;
const int INF = 0x3f3f3f3f;

int m, n, flag;
struct Node
{
    int to, cap, rev;
};

vector<Node> G[maxn * 50];
int level[maxn], iter[maxn], a[maxn];
bool b[maxn];

void addedge(int from, int to, int cap)
{
    G[from].push_back((Node){to, cap, G[to].size()});
    G[to].push_back((Node){from, 0, G[from].size() - 1});
}

void bfs(int s)
{
    memset(level, 0, sizeof(level));
    queue<int> que;
    level[s] = 1;
    que.push(s);
    while(!que.empty())
    {
        int v = que.front(); que.pop();
        for(int i = 0; i < G[v].size(); i++){
            Node &e = G[v][i];
            if(e.cap > 0 && level[e.to] <= 0){
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int f)
{
    if(v == t) return f;
    for(int &i = iter[v]; i < G[v].size(); i++)
    {
        Node &e = G[v][i];
        if(e.cap > 0 && level[v] < level[e.to])
        {
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t)
{
    int flow = 0;
    while(1){
        bfs(s);
        if(level[t] <= 0) return flow;
        memset(iter, 0, sizeof(iter));
        int f;
        while((f = dfs(s, t , INF)) > 0) flow += f;
    }
}

int main()
{
    scanf("%d%d", &m, &n);
    {
        int s = 0, t = m + n + 1, sum = 0;
        memset(b, 0, sizeof(b));
        for(int i = 1; i <= m; i++)
        {
            scanf("%d", &a[i]);
            sum += a[i];
            addedge(s, i, a[i]);
        }
        for(int i = 1; i <= n; i++)
        {
            int b;
            scanf("%d", &b);
            addedge(i + m, t, b);
            for(int j = 1; j <= m; j++) addedge(j, i + m, 1);
        }
        int x = max_flow(s, t);
        if(x != sum) printf("0\n");
        else
        {
            printf("1\n");
            for(int i = 1; i <= m; i++)
            {
                int len = G[i].size(), flag = 0;
                for(int j = 0; j < len; j++)
                {
                    int y = G[i][j].to;
                    if(y != s && !G[i][j].cap)
                    {
                        if(flag) printf(" ");
                        flag = 1;
                        printf("%d", y - m);
                    }
                }
                printf("\n");
            }
        }
    }
    return 0;
}