POJ2942-Knights of the Round Table

全解题报告索引目录 -> 【北大ACM – POJ试题分类

转载请注明出处:http://exp-blog.com/2018/06/27/pid-1282/

————————————————————————-

 

大致题意:

亚瑟王要在圆桌上召开骑士会议,为了不引发骑士之间的冲突,并且能够让会议的议题有令人满意的结果,每次开会前都必须对出席会议的骑士有如下要求:

1、  相互憎恨的两个骑士不能坐在直接相邻的2个位置;

2、  出席会议的骑士数必须是奇数,这是为了让投票表决议题时都能有结果。

 

如果出现有某些骑士无法出席所有会议(例如这个骑士憎恨所有的其他骑士),则亚瑟王为了世界和平会强制把他剔除出骑士团。

       现在给定准备去开会的骑士数n,再给出m对憎恨对(表示某2个骑士之间使互相憎恨的),问亚瑟王至少要剔除多少个骑士才能顺利召开会议?

 

注意:1、所给出的憎恨关系一定是双向的,不存在单向憎恨关系。

2、由于是圆桌会议,则每个出席的骑士身边必定刚好有2个骑士。即每个骑士的座位两边都必定各有一个骑士。

3、一个骑士无法开会,就是说至少有3个骑士才可能开会。

 

解题思路:

综合性非常强的图论题,在说解题报告之前,我建议大家先对以下内容有所认识,否则本题是很难做下去的:

 

1、补图 的定义

2、双连通分量 的定义

3、二分图 的定义

4、奇圈 的定义

5、判定一个图是否为二分图的方法:交叉染色法

6、Tarjan算法

 

上述知识点用于解决本题的重要性与其编号呈正相关。

 

       最后要说一下的是,或者大家在看我这篇解题报告之前,已经看过其他解题报告,都不谋而合地给出了求割点的方法。

这里我声明一下:本题不需要求割点,我们仅仅是利用了Tarjan算法判定出现割点的过程以及条件而已,但我不建议用Tarjan算法去求无向图的割点,Tarjan算法只适用于求有向图的割点,直接套Tarjan模板用来求无向图割点会出错的。要求无向图的割点建议去看看刘汝佳的《算法艺术与信息学竞赛》,那里有详细方法。这些话与本题无关,我就不多说了。

 

==========================================================

 

为了方便大家做题,我这里大概第说一下上述的6个知识点,注意下述是我通俗的理解,不是标准定义:

1、 补图

图G的补图~G就是把图G原有的边全部删去,原本不存在的边全部连上。

 

2、双连通分量

       简单来说,无向图G如果是双连通的,那么至少要删除图G的2个结点才能使得图G不连通。换而言之,就是图G任意2个结点之间都存在两条以上的路径连接(注意:路径不是指直接相连的边),那么双连通分量就是指无向图G的子图G’是双连通了。

 

3、二分图

       二分图又叫二部图,这个百度百科有定义,了解一下二分图是什么样子的可以了,无需深入去了解。不懂得同学等到做二分图的题目时再认真学吧。

 

4、 奇圈

用一条线把奇数个点串连起来,所得到的闭合的圈就是奇圈了。其实奇圈就是有奇数个顶点的环。

 

5、交叉染色法判定二分图

       初始化所有结点为无色(颜色0)状态,用DFS遍历一个图G的同时,顺便对结点染色(只染1、2色),注意遍历过的结点还可以再遍历重新上色。让遍历到某个时候在对结点t染色时,发现边s->t的另一个结点s已染色,且s的颜色与当前正在对t染的颜色相同,那么图G必定不是二分图。

       这是因为想象一下二分图就像是河的两岸有两排结点,每染色一次则过河一次,那么相同颜色的结点必定在同一侧。一旦出现异侧有相同颜色的结点,就可以说明图G不是二分图了。

 

6、Tarjan算法

       我希望大家主要去学习一下这个算法的基本原理,尤其是DFN数组和Low数组,还有什么是深搜树,什么是树枝边,什么是后向边。

学习一下Tarjan算法求割点的过程(注意我上文是建议大家不要用Tarjan算法去求解割点的题,但不是让大家不要看它求割点的过程),因为这个过程是求双连通分量的关键。

       而如果想很好地了解Tarjan算法求割点的过程,还是建议先去看刘汝佳的《算法艺术与信息学竞赛》P285页,然后去做一下POJ1523(纯粹求割点的题)找点感觉。

只要弄懂了刘汝佳的方法,再看Tarjan算法就非常容易理解了。

 

给几个传送门:

有关图论的知识点的定义:http://www.byvoid.com/blog/biconnect/

我的POJ1523解题报告:http://blog.csdn.net/lyy289065406/article/details/6752662

Tarjan算法入门基础:

http://hi.baidu.com/lydrainbowcat/blog/item/42a6862489c98820c89559f3.html

Tarjan算法应用扩展:

http://hi.baidu.com/lydrainbowcat/blog/item/2194090a96bbed2db1351de8.html

 

===========================================================

 

有了上述知识支撑,可以开始解题了:

1、  利用m对憎恨对构造图G,则图G中有边相连的两个点表示这2个骑士互相憎恨。

2、  构造图G的补图~G,则图~G中有边相连的两个点表示这2个骑士可以坐在相邻位置。

3、  在图~G中,可能存在某些点的度数<=1,就是说这些骑士旁边最多只能坐另一个骑士,根据圆桌的座位要求每个骑士k的座位两边都必定各有一个骑士(k度数==2),那么我们认为这些度数<=1的点是孤立的或者是单连通的,也就是说他们不在圆桌的“环”内。

《POJ2942-Knights of the Round Table》

例如上图,我们利用图G构造补图~G后,显然骑士1的度=0,他是孤立的、不连通的;骑士5的度=1,他是单连通的;骑士{2,3,4}则构成一个双连通分量,他们正在圆桌“环”内开会。显然度数<=1的骑士1和骑士5都在环外,不满足出席会议的条件,亚瑟王为了维护世界和平自然会把这2人驱逐出骑士团。

 

4、  现在问题是,我们怎么才能知道哪些骑士在环外

我们可以把问题转化为,我们怎么才能知道哪些骑士在环内?显然在环内的所有结点都是双连通的,我们可以通过Tarjan算法求双连通分量。注意,补图~G可能有几个双连通子图,即它可能有不止一组双连通分量,而Tarjan算法是一组一组双连通分量求出来的,因此每求出一组双连通分量我们就要马上处理一组。

下面都是针对某一组双连通分量的处理。

 

5、  骑士在双连通分量内(在环内),并不能就此就说明它可以出席会议了,因为假如这个骑士所在的双连通分量,不是一个奇数顶点的环(奇圈),而是一个偶数顶点的环,那么这个双连通分量内的全部骑士都要被亚瑟王开除。

 

6、  那么怎样判断一个双连通分量是奇圈呢?

首先我们要接受两条定理,想知道证明过程的可以上网找,这里不证明:

(1)       如果一个双连通分量内的某些顶点在一个奇圈中(即双连通分量含有奇圈),那么这个双连通分量的其他顶点也在某个奇圈中;

(2)       如果一个双连通分量含有奇圈,则他必定不是一个二分图。反过来也成立,这是一个充要条件。

由于双连通分量也是一个图,那么要判断双连通分量是否为奇圈,只需判断这个双连通分量是否为一个二分图,而要判断一个图是否为二分图,就用交叉染色法!

 

7、  显然所有在奇圈中的骑士,都是允许出席会议的,而由于可能有部分骑士允许出席一个以上的会议(即他们是2个以上的奇圈的公共点),那么为了避免重复统计人数,当我们判断出哪些骑士允许出席会议时,就把他们做一个标记(相同的骑士只做一个标记)。最后当Tarjan算法结束后,我们统计一下被标记的人数有多少,再用总人数减去这部分人,剩下的就是被亚瑟王剔除的人数了。

 

==========================================================

 

说到这里,本题就已经解出来了,所有知识点都被联系起来了。老实说做完这题还很有成就感的O(∩_∩)O哈!

 

几点小建议:

1、  为方便输入,图G用邻接矩阵存储,但为了后期处理数据方便,补图~G则最好改用邻接链表,图G唯一的作用就只有生成补图~G而已。

2、  给结点和边都独立开辟一个存储结构。结点是为了链表处理,边是为了Tarjan求双连通分量时的压栈。

3、  在弄清楚知识点之前不要盲目做这题,最好先找相关知识点的简单一点的题目做一下练笔。我在Disscuss上发现有同学做这题用了4个月,而我算上做练笔题的时间,前后只用了2天。

 

 

//Memory  Time
//632K	 2469MS  

#include<iostream>
#include<stack>
using namespace std;

/*结点存储结构*/
class Node
{
public:
	int id;
	class Node* next;
	Node():id(0),next(0){}
};

/*边存储结构*/
class Edge
{
public:
	Edge(int x=0,int y=0):s(x),t(y){}	//初始化
	Edge(const Edge& c):s(c.s),t(c.t){}	//复制
	
	int u(void) const{return s;}
	int v(void) const{return t;}

protected:
	int s,t;	//边s->t
};

bool operator==(Edge a,Edge b)	//协助函数:==运算符重载
{
	return a.u()==b.u() && a.v()==b.v();
}

/*********************************************************/
class solve
{
public:
	solve(int n=0,int m=0):N(n),M(m)
	{
		Initial();
		Input();
		Struct_G();

		for(int i=1;i<=N;i++)	//图G的补图可能不连通
			if(!DFN[i])
				Tarjan(i,-1);

		/*统计留席的骑士数*/
		int NotFireNum=0;
		for(int j=1;j<=N;j++)
			if(NotFire[j])
				NotFireNum++;
		printf("%d\n",N-NotFireNum); //总数减去留席骑士数,就是被剔除的骑士数
	}
	~solve()
	{
		for(int i=1;i<=N;i++)
			delete[] G[i];

		delete[] Dcc;
		delete[] DFN;
		delete[] Low;
		delete[] NotFire;
		delete[] flag;
		delete[] color;

		EmptyList();

		while(!stack_Edge.empty())
			stack_Edge.pop();
	}

	int min(int a,int b) const{return a<b?a:b;}

	void Initial(void);				//申请存储空间并初始化
	void Input(void);				//输入图G
	void Struct_G(void);			//构造图G的补图
	void Tarjan(int s,int father);	//Tarjan算法。s:当前搜索位置, father:s的父亲结点
	bool IsBinary(int s,int col);	//交叉染色判断s所在的双连通分量是否为二分图(s为搜索起点)

	void DelLink(Node* p);			//删除以结点p为表头的整条链
	void EmptyList(void);			//清空邻接链表

protected:

	int N;					//the number of Kinghts
	int M;					//the pairs of hate
	bool** G;				//邻接矩阵 记录图G
	Node** LinkHead;		//图G的补图的邻接链表表头

	int TimeStamp;			//(外部)时间戳
	int* DFN;				//DFN[u]: 结点u的搜索次序(时间戳)
	int* Low;				//Low[u]: 结点u或u的子树能够追溯到的最早的栈中结点的次序号

	stack<Edge>stack_Edge;	//边栈
	int* Dcc;				//存储点的双连通分量
	bool* flag;				//标记处于同一个双联通分量的所有顶点
	int dNum;				//双连通分量的顶点个数
	int* color;				//记录结点所染的颜色
	bool* NotFire;			//标记留席的骑士(即没有被剔除的骑士)
};

void solve::Initial(void)
{
	/*申请图G的存储空间并初始化*/

	G=new bool*[N+1];
	for(int i=1;i<=N;i++)
	{
		G[i]=new bool[N+1];
		memset(G[i],false,sizeof(bool)*(N+1));
		G[i][i]=true;
	}

	/*申请图G的补图~G的存储空间并初始化*/

	LinkHead=new Node*[N+1];
	for(int j=0;j<=N;j++)
		LinkHead[j]=0;

	/*申请执行Tarjan算法所需的存储空间并初始化*/

	TimeStamp=0;
	DFN=new int[N+1];
	Low=new int[N+1];
	memset(DFN,0,sizeof(int)*(N+1));
	memset(Low,0,sizeof(int)*(N+1));

	/*申请用于判定二分图所需的存储空间并初始化*/

	Dcc=new int[2*N+1];		//由于是按边压栈,则同一个点可能最多2次入栈
	flag=new bool[N+1];
	color=new int[N+1];
	NotFire=new bool[N+1];
	memset(NotFire,false,sizeof(bool)*(N+1));

	return;
}

void solve::Input(void)
{
	int x,y;		//temporary
	for(int j=1;j<=M;j++)
	{
		scanf("%d %d",&x,&y);
		G[x][y]=G[y][x]=true;
	}
	return;
}

void solve::Struct_G(void)
{
	for(int i=1;i<=N;i++)
	{
		LinkHead[i]=new Node;
		for(int j=1;j<=N;j++)
		{
			if(!G[i][j])
			{
				Node* tmp=LinkHead[i]->next;
				LinkHead[i]->next=new Node;
				LinkHead[i]->next->id=j;
				LinkHead[i]->next->next=tmp;
			}
		}
	}
	return;
}

void solve::Tarjan(int s,int father)
{
	DFN[s]=Low[s]=++TimeStamp;
	for(Node* p=LinkHead[s]->next;p;p=p->next)
	{
		int t=p->id;
		if(t!=father && DFN[t]<DFN[s])
		{
			if(!DFN[t])	//s->t为树枝边
			{
				Edge tagE(s,t);
				stack_Edge.push(tagE);	//树枝边压栈

				Tarjan(t,s);
				Low[s]=min(Low[s],Low[t]);

				if(DFN[s]<=Low[t])		//此时s为割点
				{
					/*寻找双连通分量,找到一组则马上处理一组*/
					dNum=0;
					memset(flag,false,sizeof(bool)*(N+1));
					memset(color,0,sizeof(int)*(N+1));
					for(Edge e=stack_Edge.top();;e=stack_Edge.top())
					{
						stack_Edge.pop();
						Dcc[dNum++]=e.u();
						Dcc[dNum++]=e.v();
						flag[e.u()]=true;		//标记处于同一个双连通分量的所有点
						flag[e.v()]=true;
						
						if(e==tagE || stack_Edge.empty())
							break;
					}
					if(!IsBinary(Dcc[0],1))		//当前的双连通分量不是二分图,则说明双连通分量内有奇圈
					{
						for(int i=0;i<dNum;i++)	//奇圈内的所有骑士均留席
							NotFire[Dcc[i]]=true;
					}
				}
				
			}
			else		//s->t为后向边
			{
				Low[s]=min(Low[s],DFN[t]);
			}
		}
	}
	return;
}

bool solve::IsBinary(int s,int col)
{
	color[s]=col;	//对s染色
	for(Node* p=LinkHead[s]->next;p;p=p->next)
	{
		int t=p->id;
		if(flag[t])			//检查t是否与s在同一个双连通分量
		{
			if(color[t]==0)	//t未染色
			{
				return IsBinary(t,3-col);	//3-col,目的是轮番用“1、2”交替染色
			}
			else			//t已染色
			{
				if(color[s]==color[t])		//若同一条边的两个端点同色
					return false;			//说明双连通分量不是二分图
			}								//即双连通分量内有奇圈
		}
	}
	return true;
}

void solve::DelLink(Node* p)
{
	if(p->next)
		DelLink(p->next);
	delete p;
	return;
}

void solve::EmptyList(void)
{
	for(int i=1;i<=N;i++)
		if(LinkHead[i])
			DelLink(LinkHead[i]);
	return;
}

int main(void)
{
	int n,m;
	while(scanf("%d %d",&n,&m) && (n+m))
		solve poj2942(n,m);

	return 0;
}

 

 

 

 

 

 

 

 

点赞