圆桌问题

题目描述
假设有来自m 个不同单位的代表参加一次国际会议。每个单位的代表数分别为ri (i =1,2,……,m)。

会议餐厅共有n 张餐桌，每张餐桌可容纳ci (i =1,2,……,n)个代表就餐。

为了使代表们充分交流，希望从同一个单位来的代表不在同一个餐桌就餐。试设计一个算法，给出满足要求的代表就餐方案。

对于给定的代表数和餐桌数以及餐桌容量，编程计算满足要求的代表就餐方案。

输入格式
第1 行有2 个正整数m 和n，m 表示单位数，n 表示餐桌数，1<=m<=150, 1<=n<=270。

第2 行有m 个正整数，分别表示每个单位的代表数。

第3 行有n 个正整数，分别表示每个餐桌的容量。

输出格式
如果问题有解，第1 行输出1，否则输出0。接下来的m 行给出每个单位代表的就餐桌号。如果有多个满足要求的方案，只要输出1 个方案。

用贪心A了一发，还兴高采烈地以为只有自己会在刷网络流时，去搞贪心

正准备去写一篇博客，然后我去翻了翻题解，诶……

根据：代表人数多的要占更多桌子数，将桌子数从小到大，代表数从大到小，一一对应

贪心

#include<bits/stdc++.h>
#define re return
#define inc(i,l,r) for(int i=l;i<=r;++i)

using namespace std;

template<typename T>inline void rd(T&x)
{
    char c;bool f=0;
    while((c=getchar())<'0'||c>'9')if(c=='-')f=1;
    x=c^48;
    while((c=getchar())>='0'&&c<='9')x=x*10+(c^48);
    if(f)x=-x;
} 

priority_queue<int,vector<int>,greater<int> >G[300];

int n,m;
struct node 
{
    int val,id;
    bool operator<(node a)const
    {
        re val>a.val;
    }
}Re[200],tab[300];


inline bool cmp(node a,node b)
{
    re a.val<b.val;
} 
int main()
{
    rd(n),rd(m);
    inc(i,1,n)
    {
        rd(Re[i].val);
        Re[i].id=i;
    }
    
    inc(i,1,m)
    {
        rd(tab[i].val);
        tab[i].id=i;
    }
    
    sort(Re+1,Re+n+1);
    sort(tab+1,tab+m+1,cmp);
    
    inc(i,1,m)
    {
        int v=tab[i].id;
        for(int j=1;j<=tab[i].val;++j)
        if(!Re[j].val)break;
        else 
        {
            --Re[j].val;
            G[Re[j].id].push(v);
        }
        sort(Re+1,Re+n+1); 
    }
    
    
    if(Re[1].val)
        printf("0");
    else
    {
        printf("1\n");
        inc(i,1,n)
        {
            while(!G[i].empty())
            {
                printf("%d ",G[i].top());
                G[i].pop();
            }
            printf("\n");
        }
    }

    re 0;
} 

 

最大流最小割

将源点与代表团连接，流量为代表团人数；

将桌子与汇点，流量为桌子树

将代表团与桌子相连，流量为1，同一个单位来的代表不在同一个餐桌就餐

#include<bits/stdc++.h>
#define re return
#define inc(i,l,r) for(int i=l;i<=r;++i)

using namespace std;

template<typename T>inline void rd(T&x)
{
    char c;bool f=0;
    while((c=getchar())<'0'||c>'9')if(c=='-')f=1;
    x=c^48;
    while((c=getchar())>='0'&&c<='9')x=x*10+(c^48);
    if(f)x=-x;
} 

const int maxn=600,inf=2147483647;
int n,m,k=1,s,t,hd[maxn],cur[maxn];
int deep[maxn];

struct node{
    int to,nt,flow;
}e[100005];

inline void add(int x,int y,int flow)
{
    e[++k].to=y;e[k].nt=hd[x];hd[x]=k;e[k].flow=flow;
    e[++k].to=x;e[k].nt=hd[y];hd[y]=k;e[k].flow=0;
}

inline bool bfs()
{
    inc(i,1,t)deep[i]=0;
    deep[s]=1;
    queue<int>q;
    q.push(s);
    
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=hd[x];i;i=e[i].nt)
        {
            int v=e[i].to;
            if(deep[v]==0&&e[i].flow)
            {
                deep[v]=deep[x]+1;
                if(v==t)re 1;
                q.push(v);
            }
        }
    }
    re 0;
}


inline int dfs(int x,int flow)
{
    if(x==t)re flow;
    int delta=flow;
    for(int i=hd[x];i;i=e[i].nt)
    {
        int v=e[i].to;
        if(deep[v]==deep[x]+1&&e[i].flow)
        {
            int d=dfs(v,min(delta,e[i].flow));
            e[i].flow-=d;
            e[i^1].flow+=d;
            delta-=d;
            if(!delta)re flow; 
            
        }
    }
    re flow-delta;
}

int main()
{
    rd(n),rd(m);
    int x;
    s=n+m+1;t=s+1;
    int sum=0;
    inc(i,1,n)
    {
        rd(x);
        add(s,i,x);
        sum+=x;
    }
    inc(i,1,m)
    {
        rd(x);
        add(i+n,t,x);
    }
    
    inc(i,1,n)
    inc(j,1,m)
        add(i,j+n,1);
    
    int ans=0;
    while(bfs())
    {
        inc(i,1,t)
        cur[i]=hd[i];
        ans+=dfs(s,inf);
    }

    if(ans==sum)
    {
        printf("1\n");
        inc(i,1,n)
        {
            for(int j=hd[i]-(m-1)*2;j<=hd[i];j+=2)
            if(!e[j].flow)
            printf("%d ",e[j].to-n);
            printf("\n");
        }
    }
    else printf("0");
    re 0;
}