<span style="color:#330033;background-color: rgb(255, 255, 255);">最近做了一些2-sat的题,作为模板性很强的题,网上对于原理讲的都比较详细,这里就不再重复,图论题主要是建图,对于2-sat模型则是要找出两两只能选择其中一个的元素,分别记为a和!a,然后对于这些元素连选A必须选B的边,连A到B,就可以套模板求解了。</span>
<span style="color:#330033;background-color: rgb(255, 255, 255);">题目链接:http://poj.org/problem?id=3678</span>
<span style="color:#330033;background-color: rgb(255, 255, 255);">说明:裸的2-sat,考察的就是对于每一个逻辑条件怎么加边。</span>
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int scc,top,index;
void init()
{
scc=top=index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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 solve(int n)
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
int n,m,a,b,c;
char s[10];
scanf("%d%d",&n,&m);
init();
for(int i=1;i<=m;i++)
{
scanf("%d%d%d%s",&a,&b,&c,s);
if(s[0]=='A')
{
if(c==1)
{
addedge(a,b);
addedge(b,a);
addedge(a+n,a); //±ØÐëÑ¡a
addedge(b+n,b);
}
else
{
addedge(a,b+n);
addedge(b,a+n);
}
}
if(s[0]=='O')
{
if(c==1)
{
addedge(a+n,b);
addedge(b+n,a);
}
else
{
addedge(a+n,b+n);
addedge(b+n,a+n);
addedge(a,a+n);
addedge(b,b+n);
}
}
if(s[0]=='X')
{
if(c==1)
{
addedge(a,b+n);
addedge(b,a+n);
addedge(a+n,b);
addedge(b+n,a);
}
else
{
addedge(a,b);
addedge(b,a);
addedge(a+n,b+n);
addedge(b+n,a+n);
}
}
}
if(solve(n))
printf("YES\n");
else
printf("NO\n");
return 0;
}
poj3905 Perfect Election
链接:http://poj.org/problem?id=3905
说明:意思是每个人的两个要求至少满足一个,那么如果这个条件没满足另一个必须满足,建图解即可。
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int scc,top,index;
void init()
{
scc=top=index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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 solve(int n)
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
int n,m,a,b,k,j;
while(scanf("%d%d",&n,&m)==2)
{
init();
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a,&b);
if(a>0&&b>0)
{
a--,b--;
addedge(a+n,b);
addedge(b+n,a);
}
else if(a>0)
{
b=-b;
a--,b--;
addedge(a+n,b+n);
addedge(b,a);
}
else if(b>0)
{
a=-a;
a--,b--;
addedge(b+n,a+n);
addedge(a,b);
}
else
{
a=-a,b=-b;
a--,b--;
addedge(a,b+n);
addedge(b,a+n);
}
}
if(solve(n))
printf("1\n");
else
printf("0\n");
}
return 0;
}
poj3683
链接:http://poj.org/problem?id=3683
说明:神父只能参加一个主持仪式,然后枚举各个的时间关系连边建图,这个题要求输出一种方案,用的是赵爽论文的那种做法比较麻烦,代码略长。
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm],edge1[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int indeg[maxn];//rudu
int col[maxn]; //ranse
int cf[maxn];
int scc,top,index,tot1;
int s[maxn],t[maxn],d[maxn];
void init()
{
scc=top=index=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++;
}
void addedge1(int u,int v)
{
edge1[tot1].to=v;
edge1[tot1].next=head[u];
head[u]=tot1++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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);
}
}
void solve(int n)
{
int flag=0;
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
{
flag=1;
break;
}
cf[belong[i]]=belong[i+n];
cf[belong[i+n]]=belong[i];
}
if(flag==1)
{
printf("NO\n");
return;
}
printf("YES\n");
memset(head,-1,sizeof(head));
memset(indeg,0,sizeof(indeg));
tot1=0;
for(int i=0;i<2*n;i++)
{
for(int j=head[i];j!=-1;j=edge[i].next)
{
int v=edge[i].to;
if(belong[i]!=belong[v])
{
addedge1(belong[v],belong[i]);
indeg[belong[i]]++;
}
}
}
queue <int>q;
memset(col,0,sizeof(col));
for(int i=1;i<=scc;i++)
if(indeg[i]==0)
q.push(i);
while(!q.empty())
{
int cur=q.front();
q.pop();
if(col[cur]==0)
{
col[cur]=1;
col[cf[cur]]=-1;
}
for(int i=head[cur];i!=-1;i=edge1[i].next)
{
int u=edge[i].to;
if(--indeg[u]==0)
q.push(u);
}
}
for(int i=0;i<n;i++)
{
if(col[belong[i]]==1)
{
printf("%02d:%02d %02d:%02d\n",s[i]/60,s[i]%60,(s[i]+d[i])/60,(s[i]+d[i])%60);
}
else
{
printf("%02d:%02d %02d:%02d\n",(t[i]-d[i])/60,(t[i]-d[i])%60,(t[i])/60,(t[i])%60);
}
}
}
void buildmap(int n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<i;j++)
{
if(min(s[i]+d[i],s[j]+d[j])>max(s[i],s[j]))
{
addedge(i,j+n);
addedge(j,i+n);
}
if(min(s[i]+d[i],t[j])>max(s[i],t[j]-d[j]))
{
addedge(i,j);
addedge(j+n,i+n);
}
if(min(t[i],s[j]+d[j])>max(t[i]-d[i],s[j]))
{
addedge(i+n,j+n);
addedge(j,i);
}
if(min(t[i],t[j])>max(t[i]-d[i],t[j]-d[j]))
{
addedge(i+n,j);
addedge(j+n,i);
}
}
}
}
int main()
{
int n,x,y,u,v;
init();
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d:%d%d:%d%d",&x,&y,&u,&v,&d[i]);
s[i]=x*60+y;
t[i]=u*60+v;
}
buildmap(n);
solve(n);
return 0;
}
poj3207
说明:比较有意思的一道题,给圆上的点连线,那么两个点之间的线两种可能圆内或圆外,然后可以根据几何关系枚举判断每对线是否矛盾即可,可以参考下这篇博客http://blog.csdn.net/l04205613/article/details/6668318
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[maxn],b[maxn];
int scc,top,index;
void init()
{
scc=top=index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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 solve(int n)
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
init();
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
{
scanf("%d%d",&a[i],&b[i]);
}
for(int i=0;i<m;i++)
{
for(int j=i+1;j<m;j++)
{
if((a[j]>a[i]&&a[j]<b[i]&&b[j]>b[i])||(a[i]>a[j]&&b[j]>a[i]&&b[i]>b[j]))
{
addedge(i,j+m);
addedge(j,i+m);
addedge(i+m,j);
addedge(j+m,i);
}
}
}
if(solve(m))
{
printf("panda is telling the truth...\n");
}
else
{
printf("the evil panda is lying again\n");
}
return 0;
}
poj2749
说明: N 个牛栏,现在通过一条通道(s1,s2)把他们连起来,他们之间有一些约束关系,一些牛栏不能连在同一个点,一些牛栏必须连在同一个点,现在问有没有可能把他们都连好,而且满足所有的约束关系,如果可以,输出两个牛栏之间距离最大值的最小情况。每个牛栏只能连s1或者s2,求最小化最大值,明显的二分答案,然后对于每一个mid,如果两个牛连某两个栏设为sx,sy距离大于mid,则连sx到!sy,sy到!sx。
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int x[maxn],y[maxn];
int a[maxn],b[maxn];
int ax[maxn],ay[maxn];
int bx[maxn],by[maxn];
int x1,y1,x2,y2,d;
int n,A,B;
int scc,top,index;
void init()
{
scc=top=index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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);
}
}
void build(int mid)
{
init();
for(int i=0;i<A;i++)
{
addedge(ax[i],ay[i]+n);
addedge(ay[i],ax[i]+n);
addedge(ax[i]+n,ay[i]);
addedge(ay[i]+n,ax[i]);
}
for(int i=0;i<B;i++)
{
addedge(bx[i],by[i]);
addedge(by[i],bx[i]);
addedge(bx[i]+n,by[i]+n);
addedge(by[i]+n,bx[i]+n);
}
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(a[i]+a[j]>mid)
{
addedge(i,j+n);
addedge(j,i+n);
}
if(b[i]+b[j]>mid)
{
addedge(i+n,j);
addedge(j+n,i);
}
if(a[i]+b[j]+d>mid)
{
addedge(i,j);
addedge(j+n,i+n);
}
if(b[i]+a[j]+d>mid)
{
addedge(i+n,j+n);
addedge(j,i);
}
}
}
}
bool solve(int mid)
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
build(mid);
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
scanf("%d%d%d",&n,&A,&B);
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
for(int i=0;i<n;i++)
{
scanf("%d%d",&x[i],&y[i]);
a[i]=abs(x[i]-x1)+abs(y[i]-y1);
b[i]=abs(x[i]-x2)+abs(y[i]-y2);
}
d=abs(x1-x2)+abs(y1-y2);
for(int i=0;i<A;i++)
{
scanf("%d%d",&ax[i],&ay[i]);
ax[i]--,ay[i]--;
}
for(int i=0;i<B;i++)
{
scanf("%d%d",&bx[i],&by[i]);
bx[i]--,by[i]--;
}
int l=1,r=8000000,ans=-1;
while(l<=r)
{
int mid=(l+r)>>1;
if(solve(mid))
{
ans=mid;
r=mid-1;
}
else
l=mid+1;
}
printf("%d\n",ans);
return 0;
}
poj2296
说明:每个点只能在正方形的下边或上边,同样的二分答案,关于覆盖的判断比较麻烦点,具体见代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
struct point{
int x,y;
}a[1005];
int scc,top,index,n;
void init()
{
scc=top=index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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);
}
}
void build(int mid)
{
init();
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(abs(a[i].x-a[j].x)>=mid)
continue;
if(a[i].y==a[j].y)
{
addedge(i,j+n);
addedge(j,i+n);
addedge(i+n,j);
addedge(j+n,i);
}
else if(abs(a[i].y-a[j].y)<mid)
{
if(a[i].y>a[j].y)
{
addedge(i+n,i);
addedge(j,j+n);
}
else
{
addedge(i,i+n);
addedge(j+n,j);
}
}
else if(abs(a[i].y-a[j].y)<2*mid)
{
if(a[i].y>a[j].y)
{
addedge(i+n,j+n);
addedge(j,i);
}
else
{
addedge(j+n,i+n);
addedge(i,j);
}
}
}
}
}
bool solve()
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d%d",&a[i].x,&a[i].y);
}
int l=1,r=20000,ans=0;
while(l<=r)
{
int mid=(l+r)>>1;
build(mid);
if(solve())
{
ans=mid;
l=mid+1;
}
else
r=mid-1;
}
printf("%d\n",ans);
}
return 0;
}
poj2723
说明:每组钥匙只能选一个,比较裸,,然后二分开门的数,每个门至少应该有一把钥匙,orz当年楼教曾经打过的比赛
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <math.h>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=4000005;
const int maxn=4505;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[maxn],b[maxn];
int x[maxn],y[maxn];
int scc,top,Index,n,m;
void init()
{
scc=top=Index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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 solve()
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
for(int i=0;i<4*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<2*n;i++)
{
if(belong[i]==belong[i+2*n])
return false;
}
return true;
}
void build(int mid)
{
init();
for(int i=0;i<n;i++)
{
addedge(x[i],y[i]+2*n);
addedge(y[i],x[i]+2*n);
}
for(int i=0;i<mid;i++)
{
addedge(a[i]+2*n,b[i]);
addedge(b[i]+2*n,a[i]);
}
}
int main()
{
while(scanf("%d%d",&n,&m)==2)
{
if(n==0&&m==0)
break;
for(int i=0;i<n;i++)
{
scanf("%d%d",&x[i],&y[i]);
}
for(int i=0;i<m;i++)
scanf("%d%d",&a[i],&b[i]);
int l=0,r=m,ans=0;
while(l<=r)
{
int mid=(l+r)>>1;
build(mid);
if(solve())
{
l=mid+1;
ans=mid;
}
else
{
r=mid-1;
}
}
printf("%d\n",ans);
}
return 0;
}
zoj3656
说明:和poj第一道差不多,不同的是对于二进制每一位的数都判断下,最多31次2-sat
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int b[maxn][maxn];
int scc,top,Index,n;
void init()
{
scc=top=Index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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);
}
}
void build()
{
init();
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(i&1 && j&1)
{
if(b[i][j]&1)
{
addedge(i+n,j);
addedge(j+n,i);
}
else
{
addedge(i,i+n);
addedge(j,j+n);
addedge(i+n,j+n);
addedge(j+n,i+n);
}
}
else if(!(i&1) && !(j&1))
{
if(b[i][j]&1)
{
addedge(i,j);
addedge(j,i);
addedge(i+n,j);
addedge(j+n,i);
}
else
{
addedge(i,j+n);
addedge(j,i+n);
}
}
else
{
if(b[i][j]&1)
{
addedge(i,j+n);
addedge(j,i+n);
addedge(i+n,j);
addedge(j+n,i);
}
else
{
addedge(i,j);
addedge(j,i);
addedge(i+n,j+n);
addedge(j+n,i+n);
}
}
b[i][j]>>=1;
}
}
}
bool check()
{
for(int i=0;i<n;i++)
{
for(int j=i;j<n;j++)
{
if(i==j)
{
if(b[i][i]!=0)
return true;
continue;
}
if(b[i][j]!=b[j][i])
return true;
}
}
return false;
}
bool solve()
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
while(scanf("%d",&n)==1)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
scanf("%d",&b[i][j]);
}
}
if(check())
{
printf("NO\n");
continue;
}
int flag=1;
for(int bit=0;bit<31;bit++)
{
build();
if(!solve())
{
flag=0;
break;
}
}
if(flag)
{
printf("YES\n");
}
else
printf("NO\n");
}
return 0;
}
zoj3422
说明:这个题挺有意思,x数组的值只能是0或者1,对于每个特定的第i项x[i]只能是一个值,然后二分dep的值,根据每组c[dep]的值建图。
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[10005],b[10005],c[10005];
int scc,top,Index,n,m;
void init()
{
scc=top=Index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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);
}
}
void build(int mid)
{
init();
for(int i=0;i<mid;i++)
{
if(c[i]==0)
{
addedge(a[i],b[i]+n);
addedge(b[i],a[i]+n);
}
else if(c[i]==1)
{
addedge(a[i],b[i]);
addedge(a[i]+n,b[i]+n);
addedge(b[i],a[i]);
addedge(b[i]+n,a[i]+n);
}
else
{
addedge(a[i]+n,b[i]);
addedge(b[i]+n,a[i]);
}
}
}
bool solve()
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
}
int l=0,r=m,ans=0;
while(l<=r)
{
int mid=(l+r)>>1;
build(mid);
if(solve())
{
ans=mid;
l=mid+1;
}
else
r=mid-1;
}
printf("%d\n",ans);
}
return 0;
}
hdu4115
说明:也是很有意思的题,剪刀石头布,由于这个人不能输,那么他肯定只能出和另一个人一样或者取胜,这就是2-sat的两种选择,然后要求的条件连边建图即可。
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=12005;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[maxn],b[maxn];
int scc,top,Index,n,m;
void init()
{
scc=top=Index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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 solve()
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
int main()
{
int t,cnt=0;
scanf("%d",&t);
while(t--)
{
init();
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
{
int x;
scanf("%d",&x);
b[i]=x;
if(x==1) a[i]=2;
else if(x==2) a[i]=3;
else a[i]=1;
}
for(int i=0;i<m;i++)
{
int u,v,c;
scanf("%d%d%d",&u,&v,&c);
u--,v--;
if(c==1) //not same
{
if(a[u]==a[v])
{
addedge(u,v+n);
addedge(v,u+n);
addedge(u+n,v);
addedge(v+n,u);
}
if(a[u]==b[v])
{
addedge(u,v);
addedge(v+n,u+n);
}
if(b[u]==a[v])
{
addedge(u+n,v+n);
addedge(v,u);
}
}
else
{
if(a[u]!=a[v])
{
addedge(u,v+n);
addedge(v,u+n);
addedge(u+n,v);
addedge(v+n,u);
}
if(a[u]!=b[v])
{
addedge(u,v);
addedge(v+n,u+n);
}
if(b[u]!=a[v])
{
addedge(u+n,v+n);
addedge(v,u);
}
}
}
printf("Case #%d: ",++cnt);
if(solve())
printf("yes\n");
else
printf("no\n");
}
return 0;
}
zoj3717
说明:比较明显的2-sat,二分mid,根据mid连边判断
代码:
/**
* @author neko01
*/
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <math.h>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=505;
struct Edge{
int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int scc,top,Index,n,m;
struct point{
double x,y,z;
}a[maxn];
double dis[maxn][maxn];
void init()
{
scc=top=Index=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++;
}
void tarjan(int u)
{
int v;
dfn[u]=low[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);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
{
low[u]=min(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 solve()
{
memset(dfn,0,sizeof(dfn));
memset(instack,false,sizeof(instack));
memset(num,0,sizeof(num));
memset(belong,0,sizeof(belong));
for(int i=0;i<2*n;i++)
{
if(!dfn[i])
tarjan(i);
}
for(int i=0;i<n;i++)
{
if(belong[i]==belong[i+n])
return false;
}
return true;
}
void build(double mid)
{
init();
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(dis[i][j]<mid)
{
addedge(i,j+n);
addedge(j,i+n);
}
if(dis[i+n][j]<mid)
{
addedge(i+n,j+n);
addedge(j,i);
}
if(dis[i][j+n]<mid)
{
addedge(i,j);
addedge(j+n,i+n);
}
if(dis[i+n][j+n]<mid)
{
addedge(i+n,j);
addedge(j+n,i);
}
}
}
}
int main()
{
while(scanf("%d",&n)==1)
{
for(int i=0;i<n;i++)
{
scanf("%lf%lf%lf",&a[i].x,&a[i].y,&a[i].z);
scanf("%lf%lf%lf",&a[i+n].x,&a[i+n].y,&a[i+n].z);
}
memset(dis,0,sizeof(dis));
double l=0,r=0,ans=0;
for(int i=0;i<2*n;i++)
{
for(int j=i+1;j<2*n;j++)
{
dis[i][j]=dis[j][i]=sqrt((a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y)+(a[i].z-a[j].z)*(a[i].z-a[j].z));
r=max(dis[i][j],r);
}
}
while(l+eqs<r)
{
double mid=(l+r)/2;
build(mid);
if(solve())
{
ans=mid;
l=mid;
}
else
r=mid;
}
ans/=2;
printf("%.3lf\n",ans-0.0005);
}
return 0;
}
通过这几道题,不难发现,解决2-sat问题的关键主要是找到那些两两只能选一个的元素,然后建图的时候牢牢记住根据矛盾关系选xxxx就必须选oooo,而且2-sat一般有不少二分答案判断是否可行的题,值得注意。