HDU 3062 Party 2-SAT

Party

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 5180    Accepted Submission(s): 1681


Problem Description

有n对夫妻被邀请参加一个聚会，因为场地的问题，每对夫妻中只有1人可以列席。在2n 个人中，某些人之间有着很大的矛盾（当然夫妻之间是没有矛盾的），有矛盾的2个人是不会同时出现在聚会上的。有没有可能会有n 个人同时列席？

 

Input

n： 表示有n对夫妻被邀请 (n<= 1000)

m： 表示有m 对矛盾关系 ( m < (n - 1) * (n -1))

在接下来的m行中，每行会有4个数字，分别是 A1,A2,C1,C2 

A1,A2分别表示是夫妻的编号 

C1,C2 表示是妻子还是丈夫 ，0表示妻子 ，1是丈夫

夫妻编号从 0 到 n -1 

 

Output

如果存在一种情况 则输出YES 

否则输出 NO 

 

Sample Input

2
1
0 1 1 1

 

Sample Output

YES

 

2-SAT算法。刚刚学。。这道题练手。。。只需要构图。然后套版就好。。。

资料：http://www.cnblogs.com/silver-bullet/archive/2013/02/18/2915097.html

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;

//HDU3062
//******************************************
//2-SAT 强连通缩点
const int MAXN = 2010;
const int MAXM = 4000010;
struct Edge
{
int to,next;
}edge[MAXM];
int head[MAXN],tot;
void init()
{
tot = 0;
memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
edge[tot].to = v; edge[tot].next = head[u]; head[u] = tot++;
}
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值1~scc
int Index,top;
int scc;
bool Instack[MAXN];
int num[MAXN];
void Tarjan(int u)
{
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for(int i = head[u];i != -1;i = edge[i].next)
{
v = edge[i].to;
if( !DFN[v] )
{
Tarjan(v);
if(Low[u] > Low[v])Low[u] = Low[v];
}
else if(Instack[v] && Low[u] > DFN[v])
Low[u] = DFN[v];
}
if(Low[u] == DFN[u])
{
scc++;
do
{
v = Stack[--top];
Instack[v] = false;
Belong[v] = scc;
num[scc]++;
}
while(v != u);
}
}

bool solvable(int n)//n是总个数,需要选择一半
{
memset(DFN,0,sizeof(DFN));
memset(Instack,false,sizeof(Instack));
memset(num,0,sizeof(num));
Index = scc = top = 0;
for(int i = 0;i < n;i++)
if(!DFN[i])
Tarjan(i);
//for(int i = 0;i < n;i += 2) printf("belong[%d] = %d\n belong[%d] = %d\n",i,Belong[i],i^1,Belong[i^1]);
for(int i = 0;i < n;i += 2)
{
if(Belong[i] == Belong[i^1])
return false;
}
return true;
}
//*************************************************

//拓扑排序求任意一组解部分
/*
queue<int>q1,q2;
vector<vector<int> > dag;//缩点后的逆向DAG图
char color[MAXN];//染色，为'R'是选择的
int indeg[MAXN];//入度
int cf[MAXN];
void solve(int n)
{
dag.assign(scc+1,vector<int>());
memset(indeg,0,sizeof(indeg));
memset(color,0,sizeof(color));
for(int u = 0;u < n;u++)
for(int i = head[u];i != -1;i = edge[i].next)
{
int v = edge[i].to;
if(Belong[u] != Belong[v])
{
dag[Belong[v]].push_back(Belong[u]);
indeg[Belong[u]]++;
}
}
for(int i = 0;i < n;i += 2)
{
cf[Belong[i]] = Belong[i^1];
cf[Belong[i^1]] = Belong[i];
}
while(!q1.empty())q1.pop();
while(!q2.empty())q2.pop();
for(int i = 1;i <= scc;i++)
if(indeg[i] == 0)
q1.push(i);
while(!q1.empty())
{
int u = q1.front();
q1.pop();
if(color[u] == 0)
{
color[u] = 'R';
color[cf[u]] = 'B';
}
int sz = dag[u].size();
for(int i = 0;i < sz;i++)
{
indeg[dag[u][i]]--;
if(indeg[dag[u][i]] == 0)
q1.push(dag[u][i]);
}
}
}
*/

int main()
{
int n,m;
int a1,a2,c1,c2;
while(~scanf("%d%d",&n,&m)){
init();
for(int i=0;i<m;i++){
scanf("%d%d%d%d",&a1,&a2,&c1,&c2);

a1*=2;
a2*=2;
if(c1==0&&c2==0) //如果两个妻子闹矛盾。那么就应该是一个a对的丈夫和b对的妻子或者是a对的妻子和b对的丈夫
{
addedge(a1,a2+1);
addedge(a2,a1+1);
}
else if(c1==0&&c2==1) //如果是a队的妻子和b对的丈夫闹矛盾，那么就因该是a对的妻子和b对的妻子或者a队的丈夫和b队的丈夫
{
addedge(a1,a2);
addedge(a2+1,a1+1);
}
else if(c1==1&&c2==0) //如果是a队的qi和b队的妻子闹矛盾，那么就应该是a对的丈夫和b队的丈夫或者a对的妻子和b队的妻子
{
addedge(a1+1,a2+1);
addedge(a2,a1);
}
else if(c1==1&&c2==1) //如果是a对丈夫和b队丈夫闹矛盾，那么就应该是a对的妻子和b对的丈夫或者a队的丈夫和b队的妻子
{
addedge(a1+1,a2);
addedge(a2+1,a1);
}

/*
addedge(2*a1+c1,((2*a2+c2)^1));
addedge(2*a2+c2,((2*a1+c1)^1));*/
}
if(solvable(n*2)){
printf("YES\n");
}
else printf("NO\n");
}
return 0;
}