SGU242 最大流容量限制为2

最新推荐文章于 2022-11-23 09:09:31 发布

原创最新推荐文章于 2022-11-23 09:09:31 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#ACM #SGU #最大流

ACM 同时被 3 个专栏收录

121 篇文章

订阅专栏

最大流

9 篇文章

订阅专栏

SGU

3 篇文章

订阅专栏

此博客讨论了如何设计一种方案，使得N名学生访问M所学校，确保每所学校至少有2名学生访问，允许学生在家休息。通过构建源点、目标点和中间节点的网络模型，使用增广路径算法实现方案生成。

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

题目意思就是 N 个学生到M 个学校，每个学生有想去的学校，要求M个学校必须都被访问，并且访问人数 >= 2，但是学生可以在家里休息不去学校，要求输出一种方案

建源 S，到N 个学生，每个点流量是1， N个学生到每个学校，流量是1，每个公司到点T，流量是2.

最后只要判断是否满流就可以了。

输出方案时，通过残留网络判断

//tpl  
//ipqhjjybj_tpl.h  
//header.h  
#include <cstdio>  
#include <cstdlib>  
#include <map>  
#include <set>  
#include <algorithm>  
#include <cstring>  
#include <iostream>  
#include <vector>  
#include <string>  
#include <queue>  
#include <sstream>  
#include <math.h>  
  
#define mp(x,y) make_pair(x,y)  
#define pii pair<int,int>  
#define pLL pair<long long ,long long>  
#define pb(x) push_back(x)  
#define rep(i,j,k) for(int i = j; i < k;i++)  
  
#define MAX(x,a)  x=((x)<(a))?(a):(x);  
#define MIN(x,a)  x=((x)>(a))?(a):(x);  
  
using namespace std;  
  
const int N = 500;  
int n,m,tot;  
int s,t;  
int sum;  
struct node{  
    int u,v,w,next;  
    node(){}  
    node(int _u,int _v,int _w,int _next){  
        u=_u,v=_v,w=_w,next=_next;  
    }  
}edge[N*N];  
int head[N],cur[N],dis[N];  
int pre[N],gap[N],aug[N];  
const int oo=0x3f3f3f;  
void addEdge(int u,int v,int w){  
    edge[tot]=node(u,v,w,head[u]);  
    head[u]=tot++;  
    edge[tot]=node(v,u,0,head[v]);  
    head[v]=tot++;  
}  
  
int SAP(int s,int e,int n){  
    int max_flow=0,v,u=s;  
    int id,mindis;  
    aug[s]=oo;  
    pre[s]=-1;  
    memset(dis,0,sizeof(dis));  
    memset(gap,0,sizeof(gap));  
    gap[0]=n;  
  
    for(int i=0;i <= n;i++)  
        cur[i]=head[i];  
  
    while(dis[s]<n){  
        if(u==e){  
            max_flow += aug[e];  
            for(v=pre[e]; v!=-1; v=pre[v]){  
                int ed=cur[v];  
                edge[ed].w -= aug[e];  
                edge[ed^1].w += aug[e];  
                aug[v]-=aug[e];  
                if(edge[ed].w==0) u=v;  
            }  
        }  
        bool flag=false;  
        for(id=cur[u]; id!=-1;id=edge[id].next){  
            v=edge[id].v;  
            if(edge[id].w > 0 && dis[u]==dis[v]+1){  
                flag=true;  
                pre[v]=u;  
                cur[u]=id;  
                aug[v]=min(aug[u],edge[id].w);  
                u=v;  
                break;  
            }  
        }  
        if(flag==false){  
            if(--gap[dis[u]] == 0) break;   
            int mindis=n;  
            for(id=head[u]; id!=-1; id=edge[id].next){  
                v=edge[id].v;  
                if(edge[id].w>0 && dis[v] < mindis){  
                    mindis = dis[v];  
                    cur[u]=id;  
                }  
            }  
            dis[u] = mindis + 1;  
            gap[dis[u]]++;  
            if(u!=s)u=pre[u];  
        }  
    }  
    return max_flow;  
}  
  
vector<int> fa[444];
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		memset(head,-1,sizeof(head));
		tot = sum = s = 0 , t = n+m+1;
		
		int max_flow = m*2;
		rep(i,1,n+1){
			int x;scanf("%d",&x);
			while(x--){
				int kk; scanf("%d",&kk);
				addEdge(i,n+kk,1);
			}
		}
		int fx = tot;
		rep(i,1,n+1) addEdge(s,i,1);
		rep(i,1,m+1) addEdge(n+i,t,2);
		rep(i,0,m+1) fa[i].clear();
		int z = SAP(s,t,t+1) ;
		// printf("z=%d\n",z);
		if(z == max_flow){
			puts("YES");
			for(int i = 1;i < fx;i+=2){
				if(edge[i].w > 0){
					// printf("u=%d v=%d\n",edge[i].u,edge[i].v);
					fa[edge[i].u-n].pb(edge[i].v);
				}
			}
			rep(i,1,m+1){
				printf("2 %d %d\n",fa[i][0],fa[i][1]);
			}
		}else puts("NO");
	}
	return 0;
}