圆桌问题（网络24题，四）

最新推荐文章于 2022-10-23 19:39:05 发布

原创最新推荐文章于 2022-10-23 19:39:05 发布 · 1.8k 阅读

0 ·

CC 4.0 BY-SA版权

线性规划和网络流24题专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一种利用最大流算法解决圆桌问题的方法。通过构建二分图并运用最大流算法来实现人员与餐桌的有效匹配。此外，还提供了一种基于贪心策略的替代解决方案，并附带了两种不同的非递归DINIC算法实现。

圆桌问题

题目链接：Click Here~

算法分析：

二分图的多重匹配问题。想到是多重匹配可能比较简单。虽然，这题不是很难想但是建图我还是想了整整两天才想出来，想出来后还没有多大的自信就直接写先看了By_void的博客后才着手写的。一开始被输出给卡了半天，后来发现输出要求看错了，跪了T_T。一些算法分析我也讲不太清，直接引用By_void的博客原文吧。最后，如果你是在我给出的链接的博客做题的话，要注意不要多组输入！

【问题分析】

二分图多重匹配问题，可以用最大流解决。

【建模方法】

建立二分图，每个单位为X集合中的顶点，每个餐桌为Y集合中的顶点，增设附加源S和汇T。

1、从S向每个Xi顶点连接一条容量为该单位人数的有向边。 2、从每个Yi顶点向T连接一条容量为该餐桌容量的有向边。 3、X集合中每个顶点向Y集合中每个顶点连接一条容量为1的有向边。

求网络最大流，如果最大流量等于所有单位人数之和，则存在解，否则无解。对于每个单位，从X集合对应点出发的所有满流边指向的Y集合的顶点就是该单位人员的安排情况（一个可行解）。

【建模分析】

对于一个二分图，每个顶点可以有多个匹配顶点，称这类问题为二分图多重匹配问题。X，Y集合之间的边容量全部是1，保证两个点只能匹配一次（一个餐桌上只能有一个单位的一个人），源汇的连边限制了每个点匹配的个数。求出网络最大流，如果流量等于X集合所有点与S边容量之和，那么则说明X集合每个点都有完备的多重匹配。

【问题另解】

贪心，更好的方法其实是贪心。首先把所有单位和餐桌按人数从大到小排序，一种适当的贪心策略就是对于每个单位，所有人每次尽量去剩余容量较大的餐桌就坐。按照这种贪心策略，如果某时发现有人已经无法就坐，则无解。具体方法为用线段树维护餐桌的剩余容量，按人数从多到少安排每个单位的人员，每次安排就是把容量餐桌前k大的餐桌人数减1（k为该单位人数）。为保证线段树前k位时刻为前k大，要维护第k与第k+1,k+2,...人数与第k相等的位置，减少第k大时要减少尽量靠后的，这样才能保证单调。

#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 500;
const int INF = ~0u >> 1;
struct Edge{
   int from,to,cap,flow;
};
vector<Edge> edges;
vector<int> G[maxn];
int s,t,d[maxn],cur[maxn];
int a[maxn],b[maxn];
bool vst[maxn];
void Init()
{
    for(int i = 0;i < maxn;++i)
        G[i].clear();
    edges.clear();
}
void AddEdge(int from,int to,int cap)
{
    edges.push_back((Edge){from,to,cap,0});
    edges.push_back((Edge){to,from,0,0});
    int sz = edges.size();
    G[from].push_back(sz-2);
    G[to].push_back(sz-1);
}
void Build(int n,int m)
{
    s = 0,t = n+m+1;
    for(int i = 1;i <= n;++i){
        AddEdge(s,i,a[i]);
        for(int j = 1;j <= m;++j)
            AddEdge(i,j+n,1);
    }
    for(int i = 1;i <= m;++i)
        AddEdge(i+n,t,b[i]);
}
bool BFS()
{
    memset(vst,false,sizeof(vst));
    queue<int> Q;
    Q.push(s);
    d[s] = 0;
    vst[s] = true;
    while(!Q.empty()){
        int u = Q.front();Q.pop();
        for(int i = 0;i < (int)G[u].size();++i){
            Edge& e = edges[G[u][i]];
            if(!vst[e.to]&&e.cap>e.flow){
                vst[e.to] = true;
                d[e.to] = d[u] + 1;
                Q.push(e.to);
            }
        }
    }
    return vst[t];
}
int DFS(int u,int a)
{
    if(u == t||a == 0)
        return a;
    int f,flow = 0;
    for(int& i = cur[u];i < (int)G[u].size();++i){
        Edge& e = edges[G[u][i]];
        if(d[e.to]==d[u]+1&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a==0)break;
        }
    }
    return flow;
}
int Maxflow()
{
    int flow = 0;
    while(BFS()){
        memset(cur,0,sizeof(cur));
        flow += DFS(s,INF);
    }
    return flow;
}
void Print(int n,int m)
{
    for(int u = 1;u <= n;++u){
        for(int i = 0;i < (int)G[u].size();++i){
            Edge& e = edges[G[u][i]];
            if(e.flow == 1&&e.to!=t)
                printf("%d ",e.to-n);
        }
        puts("");
    }
}
int main()
{
    int n,m;
//    while(~scanf("%d%d",&n,&m))
//    {
        scanf("%d%d",&n,&m);
        Init();
        int sum = 0;
        for(int i = 1;i <= n;++i){
            scanf("%d",&a[i]);
            sum += a[i];
        }
        for(int i = 1;i <= m;++i)
            scanf("%d",&b[i]);
        Build(n,m);
        int flow = Maxflow();
        if(flow>=sum){
            puts("1");
            Print(n,m);
        }
        else
            puts("0");
//    }
    return 0;
}

在给出一个非递归版的DINIC的写法（非原创）:

/*
 * Problem: 线性规划与网络流24题 #5 圆桌问题
 * Author: Guo Jiabao
 * Time: 2009.6.27 12:59
 * State: Solved
 * Memo: 网络最大流 二分图多重匹配
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=150+270+3,MAXM=150*270*2+MAXN*2,INF=~0U>>1;
struct edge
{
	edge *next,*op;
	int t,c;
}*V[MAXN],*P[MAXN],ES[MAXM],*Stae[MAXN];
int N,M,S,T,EC,Ans,Maxflow,Total;
int Lv[MAXN],Stap[MAXN];
inline void addedge(int a,int b,int c)
{
	ES[++EC].next = V[a]; V[a]=ES+EC; V[a]->t=b; V[a]->c=c;
	ES[++EC].next = V[b]; V[b]=ES+EC; V[b]->t=a; V[b]->c=0;
	V[a]->op = V[b]; V[b]->op = V[a];
}
void init()
{
	int i,j,c;
	scanf("%d%d",&M,&N);
	S=0; T=N+M+1;
	for (i=1;i<=M;i++)
	{
		scanf("%d",&c);
		Total += c;
		addedge(S,i,c);
	}
	for (i=1;i<=N;i++)
	{
		scanf("%d",&c);
		addedge(i+M,T,c);
	}
	for (i=1;i<=M;i++)
		for (j=N;j>=1;j--)
			addedge(i,j+M,1);
}
bool Dinic_Label()
{
	int head,tail,i,j;
	Stap[head=tail=0]=S;
	memset(Lv,-1,sizeof(Lv));
	Lv[S]=0;
	while (head<=tail)
	{
		i=Stap[head++];
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (e->c && Lv[j]==-1)
			{
				Lv[j] = Lv[i]+1;
				if (j==T)
					return true;
				Stap[++tail] = j;
			}
		}
	}
	return false;
}
void Dinic_Augment()
{
	int i,j,delta,Stop;
	for (i=S;i<=T;i++)
		P[i] = V[i];
	Stap[Stop=1]=S;
	while (Stop)
	{
		i=Stap[Stop];
		if (i!=T)
		{
			for (;P[i];P[i]=P[i]->next)
				if (P[i]->c && Lv[i] + 1 == Lv[j=P[i]->t])
					break;
			if (P[i])
			{
				Stap[++Stop] = j;
				Stae[Stop] = P[i];
			}
			else
				Stop--,Lv[i]=-1;
		}
		else
		{
			delta = INF;
			for (i=Stop;i>=2;i--)
				if (Stae[i]->c < delta)
					delta = Stae[i]->c;
			Maxflow += delta;
			for (i=Stop;i>=2;i--)
			{
				Stae[i]->c -= delta;
				Stae[i]->op->c += delta;
				if (Stae[i]->c==0)
					Stop = i-1;
			}
		}
	}
}
void Dinic()
{
	while (Dinic_Label())
		Dinic_Augment();
}
void print()
{
	if (Total == Maxflow)
	{
		printf("1\n");
		for (int i=1;i<=M;i++)
		{
			for (edge *e=V[i];e;e=e->next)
				if (e->c == 0 && e->t !=S)
					printf("%d ",e->t-M);
			putchar('\n');
		}
	}
	else
		printf("0\n");
}
int main()
{
	init();
	Dinic();
	print();
	return 0;
}