POJ - 3683 Priest John's Busiest Day（2-SAT模板）

最新推荐文章于 2023-04-14 02:21:45 发布
最新推荐文章于 2023-04-14 02:21:45 发布
阅读量132 收藏
点赞数
分类专栏： =====模板===== =====图论===== 2-Sat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/birdmanqin/article/details/99111398
版权

链接：http://poj.org/problem?id=3683

题意：有n个婚礼需要主持。每个婚礼有两个时间段可以主持，求一个时间不冲突的主持n个婚礼的时间安排方案。

思路：显然是个2-SAT题，若将每个婚礼的两个时间段视为一个集合的两个元素，问题转化为从n个集合里选n个元素，并且某些元素有互斥关系。很明显的2-SAT问题。先按选谁必须选谁的方式构图，然后tarjan缩点。缩完点后，如果有集合的两个元素在同一强连通分量中，则无解。否则，有两种寻找方案的方法。第一种是将获得的缩点之间建反向边，拓扑排序的同时进行标记。即拓扑排序到u点时，如果u点没确定选不选，那就选（结论，记住即可。），并将其集合的另一个元素所在的缩点标记为不选。第二种方法，直接比较一个集合两个元素tarjan缩点的点值，谁的值更小，说明选其影响更小（这也是反向拓扑排序的原因）。

PS：改了半天（是真的半天），最后发现建原图的时候，选择的方式错了，应该按选谁必选谁的方式，我按的是不选谁必不选谁的方式。。。。。。。。。。。。。。。。。MD。。。。。。。心累。。。。。。。还是自己没理解算法。。。。。。。。。。。。。。。。。

第一种：

#include <cstdio>
#include <queue> 
#define ll long long
using namespace std;
const int N = 2e3+10;
const int M = 5e6+10;
int n;
bool no; 
struct node { int l,r; }weds[N];
struct	Edge { int to,nxt; };
struct Two_Sat
{
	int in[N],oppo[N],head1[N],cnt1,head[N],cnt,dfn[N],id,low[N],color[N],cl,sta[N],top,book[N];; 
	//in[i]:缩点i的入度
	//oppo[i]:点i所在集合另一元素所在的缩点值
	//color[i]:点i所在缩点值 
	bool vis[N];
	struct Edge G[M],G1[M];
	inline void init()//初始化 
	{
		no=0;
		cl=cnt=cnt1=id=top=0;
		for(int i=0;i<2*n;i++)	in[i]=vis[i]=dfn[i]=0,book[i]=head[i]=head1[i]=-1;
	}
	inline void add(int u,int v)
	{
		G[cnt].to=v,G[cnt].nxt=head[u],head[u]=cnt++;
	}
	inline void add1(int u,int v)
	{
		G1[cnt1].to=v,G1[cnt1].nxt=head1[u],head1[u]=cnt1++;
	}
	inline void tarjan(int u)//tarjan强连通分量缩点 
	{
		int v;
		dfn[u]=low[u]=++id; vis[u]=1; sta[++top]=u;
		for(int i=head[u];i!=-1;i=G[i].nxt)
		{
			v=G[i].to;
			if(!dfn[v])
			{
				tarjan(v);
				low[u]=min(low[u],low[v]);
			}
			else if(vis[v])
				low[u]=min(low[u],low[v]);
		}
		if(low[u]==dfn[u])
		{
			color[u]=++cl;
			while(sta[top]!=u)
			{
				color[sta[top]]=cl; vis[sta[top--]]=0;			
			}
			vis[sta[top--]]=0;
		}
	}
	inline void Tarjan()
	{
		for(int i=0;i<2*n;i++)
			if(!dfn[i]) tarjan(i);		
	}
	inline void SetOppo()//确定每个元素的同集合元素的缩点值
	{
		for(int i=0;i<2*n;i+=2)
		{
			if(color[i]==color[i^1]) { no=1; break; }
			oppo[color[i]]=color[i^1],oppo[color[i^1]]=color[i];			
		}		
	}
	inline bool topo()//拓扑排序，同时确定确定选哪个 
	{
		int u,v;
		//先建缩点反向图 
		for(u=0;u<2*n;u++)
			for(int i=head[u];i!=-1;i=G[i].nxt)
			{
				v=G[i].to;
				if(color[v]==color[u]) continue;
				add1(color[v],color[u]),in[color[u]]++;
			}
		queue<int> q;
		for(int i=1;i<=cl;i++) if(!in[i]) q.push(i);
		while(!q.empty())
		{
			u=q.front(); q.pop();
			//没有确定选不选就一定选
			if(book[u]==-1) book[u]=1,book[oppo[u]]=0; 	
			for(int i=head1[u];i!=-1;i=G1[i].nxt)
			{
				v=G1[i].to;
				if(--in[v]==0) q.push(v);
			}
		}
		return 1;
	}
	inline void print()
	{
		for(int i=0;i<2*n;i++)
		{
			if(book[color[i]]==1)
				printf("%02d:%02d %02d:%02d\n",weds[i].l/60,weds[i].l%60,weds[i].r/60,weds[i].r%60);
		}		
	}
}two;
inline bool ok(node a,node b)
{
	if(a.r<=b.l||b.r<=a.l) return 1;
	return 0;
}
int main(void)
{
	int hl,ml,hr,mr,d;
	while(~scanf("%d",&n))
	{
		two.init();
		for(int i=0;i<2*n;i+=2)
		{
			scanf("%02d:%02d %02d:%02d %d",&hl,&ml,&hr,&mr,&d);
			weds[i].l=hl*60+ml; weds[i].r=weds[i].l+d;
			weds[i^1].r=hr*60+mr; weds[i^1].l=weds[i^1].r-d; 	
		}
		for(int i=0;i<2*n;i+=2)
			for(int j=i+2;j<2*n;j+=2)
			{
				if(!ok(weds[i],weds[j]))
					two.add(i,j^1),two.add(j,i^1);	
				if(!ok(weds[i],weds[j^1]))
					two.add(i,j),two.add(j^1,i^1);	
				if(!ok(weds[i^1],weds[j]))
					two.add(i^1,j^1),two.add(j,i);	
				if(!ok(weds[i^1],weds[j^1]))
					two.add(i^1,j),two.add(j^1,i);	
			}	
		two.Tarjan();
		two.SetOppo();
		if(no){ printf("NO\n"); continue;}  
		printf("YES\n");
		two.topo();
		two.print();
	}
	return 0;	
}

第二种：

#include <cstdio>
#include <queue> 
#define ll long long
using namespace std;
const int N = 2e3+10;
const int M = 5e6+10;
int n;
bool book[N];
bool no; 
struct node { int l,r; }weds[N];
struct	Edge { int to,nxt; };
struct Two_Sat
{
	int in[N],oppo[N],head1[N],cnt1,head[N],cnt,dfn[N],id,low[N],color[N],cl,sta[N],top; 
	//in[i]:缩点i的入度
	//oppo[i]:点i所在集合另一元素所在的缩点值
	//color[i]:点i所在缩点值 
	bool vis[N];
	struct Edge G[M],G1[M];
	inline void init()//初始化 
	{
		no=0;
		cl=cnt=cnt1=id=top=0;
		for(int i=0;i<2*n;i++)	book[i]=in[i]=vis[i]=dfn[i]=0,head[i]=head1[i]=-1;
	}
	inline void add(int u,int v)//原图建边 
	{
		G[cnt].to=v,G[cnt].nxt=head[u],head[u]=cnt++;
	}
	inline void add1(int u,int v)//缩点后，反向建图 
	{
		G1[cnt1].to=v,G1[cnt1].nxt=head1[u],head1[u]=cnt1++;
	}
	inline void tarjan(int u)//tarjan强连通分量缩点 
	{
		int v;
		dfn[u]=low[u]=++id; vis[u]=1; sta[++top]=u;
		for(int i=head[u];i!=-1;i=G[i].nxt)
		{
			v=G[i].to;
			if(!dfn[v])
			{
				tarjan(v);
				low[u]=min(low[u],low[v]);
			}
			else if(vis[v])
				low[u]=min(low[u],low[v]);
		}
		if(low[u]==dfn[u])
		{
			color[u]=++cl;
			while(sta[top]!=u)
			{
				color[sta[top]]=cl; vis[sta[top--]]=0;			
			}
			vis[sta[top--]]=0;
		}
	}
	inline void Tarjan()
	{
		for(int i=0;i<2*n;i++)
			if(!dfn[i]) tarjan(i);		
	}
	inline void SetOppo()//确定每个元素的同集合元素的缩点值
	{
		for(int i=0;i<2*n;i+=2)
		{
			if(color[i]==color[i^1]) { no=1; break; }//其实这种情况不存在 
			oppo[color[i]]=color[i^1],oppo[color[i^1]]=color[i];			
		}		
	}
	inline bool topo()
	{
		int u,v;
		//建缩点反向图 
		for(u=0;u<2*n;u++)
			for(int i=head[u];i!=-1;i=G[i].nxt)
			{
				v=G[i].to;
				if(color[v]==color[u]) continue;
				add1(color[v],color[u]),in[color[u]]++;
			}
		queue<int> q;
		for(int i=1;i<=cl;i++) if(!in[i]) q.push(i);
		
		while(!q.empty())
		{
			u=q.front(); q.pop();
			//没有确定选不选就一定选 
			if(book[u]==-1) book[u]=1,book[oppo[u]]=0; 	
			for(int i=head1[u];i!=-1;i=G1[i].nxt)
			{
				v=G1[i].to;
				if(--in[v]==0) q.push(v);
			}
		}
		return 1;
	}
	inline void solve()
	{
		//根据强连通分量的缩点值，确定选谁。 
		for(int i=0;i<2*n;i+=2)
		{
			if(color[i]<color[i^1]) book[i]=1;
			else  book[i^1]=1;
		}		
	}
	inline void print()
	{
		for(int i=0;i<2*n;i++)
		{
			if(book[i])
				printf("%02d:%02d %02d:%02d\n",weds[i].l/60,weds[i].l%60,weds[i].r/60,weds[i].r%60);
		}		
	}
	
}two;
inline bool ok(node a,node b)
{
	if(a.r<=b.l||b.r<=a.l) return 1;
	return 0;
}
int main(void)
{
	int hl,ml,hr,mr,d;
	while(~scanf("%d",&n))
	{
		two.init();
		for(int i=0;i<2*n;i+=2)
		{
			scanf("%02d:%02d %02d:%02d %d",&hl,&ml,&hr,&mr,&d);
			weds[i].l=hl*60+ml; weds[i].r=weds[i].l+d;
			weds[i^1].r=hr*60+mr; weds[i^1].l=weds[i^1].r-d; 	
		}
		//建原图 
		for(int i=0;i<2*n;i+=2)
			for(int j=i+2;j<2*n;j+=2)
			{
				if(!ok(weds[i],weds[j]))
					two.add(i,j^1),two.add(j,i^1);	
				 				
				if(!ok(weds[i],weds[j^1]))
					two.add(i,j),two.add(j^1,i^1);	
				
				if(!ok(weds[i^1],weds[j]))
					two.add(i^1,j^1),two.add(j,i);	 
				if(!ok(weds[i^1],weds[j^1]))
					two.add(i^1,j),two.add(j^1,i);	 
			}
		two.Tarjan();	
		two.SetOppo();
		if(no){ printf("NO\n"); continue;}  
		printf("YES\n");
		two.solve();
		two.print();
	}
	return 0;	
}

 

Qingo呀
关注
专栏目录
POJ - 3683 Priest John's Busiest Day(2-SAT+路径打印)
Falcon的博客
12-26 259
题目链接：点击查看 题目大意：现在有n对新人要结婚，每一场婚礼都要请牧师主持一个特殊的仪式，这个仪式必须在婚礼的前d分钟或者最后d分钟进行，现在问能否有一种安排，能让牧师参加到每一场婚礼去主持仪式，输出方案 题目分析：也是一个2-SAT模板题，只是路径打印有点不好理解，我们可以将两个赋值拆成前d分钟主持仪式和后d分钟主持仪式，这样每个点都有两种赋值情况了，并且我们可以预先储存n场婚礼的时间，随...
POJ-3683（2-SAT）
还有多远
11-18 428
题目：http://poj.org/problem?id=3683 第三道2-SAT，普通的
poj 3683【2-SAT】
leolin_的专栏
08-11 935
题意是说，一个牧师要帮人举办婚礼庆典，给出每对新人的可用时间段s，e和举办庆典时长len，这个庆典只能在时间段前或时间段后举行并且这些时间段不能有冲突，问牧师能否为他们举办庆典，能就输出具体时间段。 解法：2-SAT i表示甲婚礼前段，^i表示甲婚礼后段 j表示乙婚
poj 3683 2-SAT 拓扑排序输出
AChunter的专栏
05-07 1726
【题意】 有n个婚礼，每个婚礼有起始时间si，结束时间ti，还有一个主持时间ti，ti必须安排在婚礼的开始或者结束，主持由祭祀来做，但是只有一个祭祀，所以各个婚礼的主持时间不能重复，问你有没有可能正常的安排主持时间，不能输出no，能的话要输出具体的答案：即每个婚礼的主持时间段是什么样的。 【题解】 2-SAT判定问题，建图很简单，此略。 重点讲一下输出方案。 我们可以把处在同一个强连
POJ_3683
smsmn的专栏
10-31 768
<br />http://poj.org/problem?id=3683<br />/*题目描述：有n个婚礼，每个婚礼有起始时间si，结束时间ti，还有一个主持时间ti，ti必须安排在婚礼的开始 或者结束，主持由祭祀来做，但是只有一个祭祀，所以各个婚礼的主持时间不能重复， 问你有没有可能正常的安排主持时间，不能输出no，能的话要输出具体的答案： 即每个婚礼的主持时间段是什么样的。*/ /* 对于题意：主持时间要么在开始的时刻，要么在结束的时刻，而且各个婚礼之间有限制，因此用2-sat 建图：对于
【算法练习】POJ - 3683 Priest John's Busiest Day （2-SAT）
Pengwill's Blog
08-25 183
题意 有一个小镇上只有一个牧师。这个小镇上有一个传说，在九月一日结婚的人会受到爱神的保佑，但是要牧师举办一个仪式。这个仪式要么在婚礼刚刚开始的时候举行，要么举行完婚礼正好结束。 现在已知有n场婚礼，告诉你每一场的开始和结束时间，以及举行仪式所需要的时间。问牧师能否参加所有的婚礼，如果能则输出一种方案。 题解 2-SAT + 路径输出 首先建图不难，判断两个时间段是否相交。 然后按照...
poj-1009.rar_poj
09-23
【标题】"POJ-1009"是北大在线编程竞赛平台上的一个题目，它涉及到计算机科学中的算法和编程技巧。POJ（Problem Set of Peking University）是中国北京大学主办的一个在线编程竞赛平台，旨在提高学生的算法设计和...
poj-1028-Web-Navigation.zip_poj
09-21
【标题】"poj-1028-Web-Navigation.zip_poj" 指向的是一个编程竞赛问题，POJ（Programming Online Judge）平台上的第1028题，名为“Web Navigation”。该问题通常涉及到算法设计和实现，可能是为了考察参赛者的编程...
POJ-2151.rar_poj
09-21
【标题】"POJ-2151.rar_poj"是一个与编程竞赛相关的压缩文件，主要涉及的问题是“检查问题的难度”，并且是为动态规划的实战练习而设计的。这个题目来自于著名的在线编程竞赛平台POJ（Programming Online Judge）。 ...
POJ-1170.rar_poj
09-22
标题中的“POJ-1170.rar_poj”指的是编程竞赛网站POJ（Programming Online Judge）上的一个问题，编号为1170。POJ是一个在线的编程练习平台，主要面向学习和提升算法与编程技能的用户。这个问题的解决方案可能包含在...
POJ - 1700 Crossing River
最新发布
程序员阿甘的博客
04-14 2271
渡过问题，贪心算法，动态规划
2-SAT——5.0（poj3683 Priest John's Busiest Day）
laoda扯一扯
08-08 2756
poj3683 Priest John's Busiest Day 题意：一个小镇里面只有一个牧师，现在有些新人要结婚，需要牧师分别去主持一个仪式，给出每对新人婚礼的开始时间 s 和结束时间 t ，还有他们俩的这个仪式需要的时间（每对新人需要的时间长短可能不同） d ，牧师可以
【POJ3683】Priest John's Busiest Day
小蒟蒻yyb的博客
07-01 2233
POJ 3683 题目John is the only priest in his town. September 1st is the John’s busiest day in a year because there is an old legend in the town that the couple who get married on that day will be forever blessed b
map的排序
birdmanqin的博客
03-08 4972
1.按key值排序 (第一个值，即&lt;key,value&gt;中的key值) 为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。在我们插入&lt;key, value&gt;键值对时，就会按照key的大小顺序进行存储，其中key的类型必须能够进行 &lt; 运算，且唯一，默认排序是按照从小到大便于记忆，可以联想到需要支持小于运算。 map的模板定义如下 template &lt;...
C++快读、快写模板
birdmanqin的博客
07-23 3019
inline int Read() { int res=0,ch,flag=0; if((ch=getchar())=='-') flag=1; else if(ch>='0'&&ch<='9') res=ch-'0'; while((ch=getchar())>='0'&&amp...
一般图最大匹配（带花树算法）（学习+模板）
birdmanqin的博客
08-30 2645
参考博客： https://blog.csdn.net/xuezhongfenfei/article/details/10148445 https://www.cnblogs.com/zhoushuyu/p/8717234.html https://www.cnblogs.com/owenyu/p/6858508.html 经典例题： https://www.cnblogs.com/BA...
图论-连通图学习总结
birdmanqin的博客
08-18 1462
一、有向图 有向图的问题就是直接Tarjan求强连通分量，然后搞就行。 二、无向图 1、割点和桥 无向图的割点和桥的求法和有向图的差不多，唯一多的限制就是不能从该点往他的父亲走，当然可能会有重边。但有统一的解决方法，那就是标记走过的边，既然是无向图，那么加边的时候肯定加两条边（这俩边的编号关系就是相互^1），那么就走一条边时，把另一条边标记即可。 if(g[i].u...
欧拉回路/路径学习（求欧拉回路/路径模板）
birdmanqin的博客
09-14 763
参考博客： https://www.cnblogs.com/LMCC1108/p/11306297.html 本校潘武灵/杰巨 https://blog.csdn.net/PacosonSWJTU/article/details/50007847 求回路/路径详解 欧拉回路 如果图G中的一个路径包括每个边恰好一次，则该路径称为欧拉路径(Euler path)。 如果一个回路...
莫队算法（普通莫队、带修莫队、树上莫队、不删除莫队）学习笔记【理解+套路/核心代码+例题及题解】
birdmanqin的博客
11-29 751
一、理解 我的理解就是巧妙的暴力，利用双指针以及分块思想，巧妙的移动双指针，时间复杂度可以达到O(NlogN)。 这里强推博客：写的又好又全。链接 二、套路 1、普通莫队 int l=1,r=0; for(int i=1;i<=m;i++){ int ql=q[i].l,qr=q[i].r; while(l<ql) del(l++); while(l>ql) add(--l); while(r<qr) add(++r); while(r>qr) de
2-SAT问题解析与应用
类似的应用还包括在POJ3905PerfectElection、POJ3683PriestJohn'sBusiestDay、POJ3648Wedding等编程竞赛题目中，这些题目通常要求在满足特定条件的情况下，找出一组可行的解决方案，而2-SAT模型提供了一种有效的方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值