[poj 3207] Ikki\'s Story IV - Panda\'s Trick（2-sat or 并查集）

这是A掉的第一道2-sat题目。由于题目的特殊性，可以不需要用tarjan计算强连通图，用并查集也可以轻松搞定。
题意：一个圆上依次分布着一些点，距离不重要。然后给你一些点对，要你将这两个点连线，问存不存在一种方案，使得在所有线段都不交叉的情况下，能连完所有线段。显然线段不是在圆内连线就是在圆外连线。
样例数据如下：

4 2
0 1
3 2

4个点两条线，满足条件的方案有好2种，如下图，所以输出"panda is telling the truth..."

 
每个点有两种状态，内连或外连，所以只要建图以后判断同一个点是否既必须内连又必须外连即可。

 

容易看出两条线段何时一定会交叉。

 

 假设第一条线段是a-b，那么内部相交就是c-d以这样的形式在两边，也就是说c-d必须在圆外相连。
所以冲突的条件就是

bool conflict(int a, int b, int c, int d)
{
	if(c < a && d > a && d < b)  // c<a与d>a好写，千万不要遗漏d<b的条件
		return true;
	if(c > a && c < b && d > b)
		return true;
	return false;
}

找到冲突边以后建图，我用的是邻接表，要注意点对是2i，2i+1，2j，2j+1。

struct point
{
	vector<int> v;
}pt[maxn*2];


for(int i = 0; i < n - 1; i++)
{ 
	for(int j = i+1; j < n; j++)
	{
		if(conflict(tt[i].s, tt[i].t, tt[j].s, tt[j].t))
		{
			pt[i*2].v.push_back(j*2+1);
			pt[j*2+1].v.push_back(i*2);
			pt[i*2+1].v.push_back(j*2);
			pt[j*2].v.push_back(i*2+1);
		}
	}
}

建图并tarjan以后，只要判断同一个点是否又得内连又得外连(无解)即可。

for(int i = 0; i < n; i++)
{
	if(belong[i*2] == belong[i*2+1])
	{
		flag = 1;
		break;
	}
}

完整代码如下：

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

#define maxn 1010
int n, m;

struct point
{
	vector<int> v;
}pt[maxn*2];

struct node
{
	int s;
	int t;
}tt[maxn];

int index, stacktop, cnt;
int dfn[maxn*2], low[maxn*2];
int instack[maxn*2], stap[maxn*2];
int belong[maxn*2];

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

bool conflict(int a, int b, int c, int d)
{
	if(c < a && d > a && d < b)
		return true;
	if(c > a && c < b && d > b)
		return true;
	return false;
}

void Clear()
{
	index = stacktop = cnt = 0;
	memset(dfn, 0, sizeof(dfn));
	memset(low, 0, sizeof(low));
	memset(instack, false, sizeof(instack));
	memset(belong, 0, sizeof(belong));
}

void tarjan(int u)
{
	dfn[u] = low[u] = ++index;
	instack[u] = true;
	stap[++stacktop] = u;
	for(int i = 0; i < pt[u].v.size(); i++)
	{
		if(!dfn[i])
		{
			tarjan(i);
			low[u] = min(low[u], low[i]);
		}
		else if(instack[i])
		{
			low[u] = min(low[u], dfn[i]);
		}
	}
	if(low[u] == dfn[u])
	{
		cnt++;
		int v;
		do
		{
			v = stap[stacktop--];
			instack[v] = false;
			belong[v] = cnt;
		}while(v != u);
	}
}

int main()
{
	while(~scanf("%d%d", &n, &m))
	{
		for(int i = 0; i < m; i++)
		{
			scanf("%d%d", &tt[i].s, &tt[i].t);
		}
		
		for(int i = 0; i < n - 1; i++)
		{
			for(int j = i+1; j < n; j++)
			{
				if(conflict(tt[i].s, tt[i].t, tt[j].s, tt[j].t))
				{
					pt[i*2].v.push_back(j*2+1);
					pt[j*2+1].v.push_back(i*2);
					pt[i*2+1].v.push_back(j*2);
					pt[j*2].v.push_back(i*2+1);
				}
			}
		}
		
		Clear();
		
		for(int i = 0; i < 2*n; i++)
		{
			if(!dfn[i])
				tarjan(i); 
		}
		int flag = 0;
		for(int i = 0; i < n; i++)
		{
			if(belong[i*2] == belong[i*2+1])
			{
				flag = 1;
				break;
			}
		}
		if(flag)
			printf("the evil panda is lying again\n");
		else
			printf("panda is telling the truth...\n");
	}
	return 0;
}

另外由于这道题比较特别，矛盾边为i j和i' j'

 其实就相当于无向图，这样的话图都不用建了，直接合并i与j'、i'与j到同一集合中。最后判断i和i'是否在同一集合中(无解)即可。

#include<iostream>
using namespace std;

struct node
{
	int s;
	int t;
}line[600];

int father[2010];

bool judge(int a, int b, int c, int d)
{
	if(c < b && c > a && d > b)
		return true;
	if(c < a && d > a && d < b)
		return true;
	return false;
}

int find(int x)
{
	if(x == father[x])
		return x;
	return father[x] = find(father[x]);
}

int main()
{
	int n, m;
	int x, y;
	while(~scanf("%d%d", &n, &m))
	{
		for(int i = 0; i < m; i++)
		{
			scanf("%d%d", &line[i].s, &line[i].t);
		}
		for(int i = 0; i < n; i++)
			father[i] = i;
		for(int i = 0; i < m-1; i++)
		{
			for(int j = i+1; j < m; j++)
			{
				if(judge(line[i].s, line[i].t, line[j].s, line[j].t))
				{
					x = find(2*i);
					y = find(2*j+1);
					father[x] = y;
					
					x = find(2*i+1);
					y = find(2*j);
					father[x] = y;
				}
			}
		}
		int flag = 0;
		for(int i = 0; i < m; i++)
		{
			if(find(2*i) == find(2*i+1))
			{
				flag = 1;
				break;
			}
		}
		if(flag)
			printf("the evil panda is lying again\n");
		else
			printf("panda is telling the truth...\n");
	}
	return 0;
}