2-SAT 挑战4.3习题

poj3678:

题目链接：

http://poj.org/problem?id=3678

题意：

给定一系列的布尔表达式，问能否找到一个解是这些都成立?

比较裸，就是对应的建立限制条件。如果i 为真，j也必须为真就建立(i,j)一条边。

要注意的就是，XOR ，比如x XOR y = 1 ， 那么 等价于x=>y’ AND x’=>y AND y=>x’ AND y’=>x

x XOR y = 0 ，等价于 x=>y AND x’=>y’ AND y=>x AND y’ =>x

x AND y = 1 等价于 x’=> x AND y’=> y

一开始写错了。。对于异或只考虑了两个限制条件，居然都过了。。。可能数据弱了。。之后的一题就被这样坑了。

然后就是比较裸的了，求scc，然后判定是否有解。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
using namespace std;
#define M 10009
vector<int> edge[M];
int DFN[M],low[M],belong[M];
bool instack[M];
stack<int> ss;
int sccnum,tot;
int n,m;
void init()
{
for(int i = 0;i <= 2*n;i++) edge[i].clear();
memset(DFN,0,sizeof(DFN));
memset(low,0,sizeof(low));
sccnum = tot = 0;
}
void add_edge(int u,int v)
{
edge[u].push_back(v);
}
void tarjan(int u)
{
instack[u] = true;
DFN[u] = low[u] = ++tot;
ss.push(u);
for(int i = 0;i < edge[u].size();i++)
{
int v = edge[u][i];
if(!DFN[v])
{
tarjan(v);
low[u] = min(low[u],low[v]);
}
else if(instack[v])
{
low[u] = min(low[u],DFN[v]);
}
}
if(DFN[u] == low[u])
{
int v;
sccnum++;
for(;;)
{
v = ss.top();
ss.pop();
instack[v] = false;
belong[v] = sccnum;
if(v == u) break;
}
}
}
void scc()
{
for(int i = 0;i < 2*n;i++)
{
if(!DFN[i]) tarjan(i);
}
}
bool solve()
{
scc();
for(int i = 0;i < n;i++)
{
if(belong[i] == belong[i+n]) return false;
}
return true;
}
int main()
{
while(scanf("%d %d",&n,&m) == 2)
{
for(int i = 0;i < m;i++)
{
int a,b,c;
char s[100];
scanf("%d %d %d %s",&a,&b,&c,s);
if(s[0] == 'A')
{
if(c == 1)
{
add_edge(a+n,a);
add_edge(b+n,b);
}
if(c == 0)
{
add_edge(a,b+n);
add_edge(b,a+n);
}
}
if(s[0] == 'O')
{
if(c == 1)
{
add_edge(a+n,b);
add_edge(b+n,a);
}
if(c == 0)
{
add_edge(a,a+n);
add_edge(b,b+n);
}
}
if(s[0] == 'X') //异或要小心
{
if(c == 1)
{
add_edge(a,b+n);
add_edge(a+n,b);
add_edge(b+n,a);
add_edge(b,a+n);
}
if(c == 0)
{
add_edge(a+n,b+n);
add_edge(a,b);
add_edge(b+n,a+n);
add_edge(b,a);
}
}
}
bool ok = solve();
if(ok) printf("YES\n");
else printf("NO\n");
}
return 0;
}

poj2723：

题目链接：http://poj.org/problem?id=2723

题意：

有n对钥匙，对于每一对钥匙来说，如果用了其中一把钥匙，那么另一把钥匙就会直接消失，这里存在一个矛盾关系。意思就是(x,y) 属于同一对钥匙，那么就有 x => y’ AND y => x’ 。

有m个门，对于每个门来说有两把钥匙可以打开这个门，那么如果想要开这个门，同时也会产生一个矛盾关系。(x,y)属于这个门对应的两把钥匙，那么如果x为假，y就要为真，如果y为假，x就要为真。 有 x’ =>y AND y’ => x。

求最多能够打开几个门。

这就是一个最大化最小值的问题，因为题目中有说如果要打开第i个门，那么第i-1个门必须已经被打开。所以开门的顺序就有了。二分答案，对于当前的尝试能开 k 个门 进行判定，也就是加入前k个门的限定条件。如果可以打开，就提升下限。接着做。。

悲剧的是，二分写错了。。 找了半天。。在m为1的时候答案直接错了。。

我的二分写法要把上限设置成m+1，不能写成m。。（好像以前错过这个，太蠢了）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
using namespace std;
#define M 3000
int DFN[M*4],low[M*4],belong[M*4];
bool instack[M*4];
int key1[M],key2[M],door1[M],door2[M];
vector<int> edge[M*4];
stack<int> ss;
int n,m;
int tot,sccnum;
void init()
{
memset(DFN,0,sizeof(DFN));
for(int i = 0;i < 4*n;i++) edge[i].clear();
memset(instack,false,sizeof(instack));
memset(belong,0,sizeof(belong));
while(!ss.empty()) ss.pop();
tot = sccnum = 0;
}
void add_edge(int u,int v)
{
edge[u].push_back(v);
//edge[v].push_back(u);
}
void tarjan(int u)
{
instack[u] = true;
DFN[u] = low[u] = ++tot;
ss.push(u);
for(int i = 0;i < edge[u].size();i++)
{
int v = edge[u][i];
if(!DFN[v])
{
tarjan(v);
low[u] = min(low[u],low[v]);
}
else if(instack[v])
{
low[u] = min(low[u],DFN[v]);
}
}
if(DFN[u] == low[u])
{
int v;
sccnum++;
for(;;)
{
v = ss.top();
ss.pop();
instack[v] = false;
belong[v] = sccnum;
if(v == u) break;
}
}
}
void scc()
{
for(int i = 0;i < 4*n;i++)
{
if(!DFN[i]) tarjan(i);
}
}
bool solve(int mid)
{
init();
for(int i = 0;i < n;i++)
{
add_edge(key1[i],key2[i]+2*n);
add_edge(key2[i],key1[i]+2*n);
}
for(int i = 0;i < mid;i++)
{
add_edge(door1[i]+2*n,door2[i]);
add_edge(door2[i]+2*n,door1[i]);
}
scc();
for(int i = 0;i < 2*n;i++)
{
if(belong[i] == belong[i+2*n])
return false;
}
return true;
}
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",&key1[i],&key2[i]);
for(int i = 0;i < m;i++)
scanf("%d %d",&door1[i],&door2[i]);
int l = 0,r = m+1; // 要写成 m+1 不然 写成m的话m = 1 时会直接退出。。
int ans = 0;
while(l < r - 1)
{
int mid = (l+r)/2;
if(solve(mid)) l = mid;
else r = mid;
}
printf("%d\n",l);
}
return 0;
}

poj2749:

题意：

要使得每个牛棚都能相互到达，建立了s1和s2两个中转站，每个牛棚都跟其中的一个中转站建立联系。但是牛棚之间还有一定的限制条件，比如有hate关系，如果a，b有hate关系，那么a、b不能和同一个中转站建立联系。还有friend关系，如果a，b是friend，那么a、b一定要在一个中转站中。

要是任意两个牛棚之间距离的最大值尽可能的小。

也是一个二分的做法

思路

那么定义布尔变量xi，如果xi 为真表示i这个牛棚与s1建立联系，为假就是与s2建立联系。

然后就可以利用之前的hate和friend关系进行建图。但是只靠这些限制条件还是不够的。

二分这个最大距离，对于任意两个点，判断所有连接方法，也就是四种情况，如果这种方法连接超过了最大了，那么就不能这样连接。增加限定条件，比如i 连 s1, j连 s2，这两个之间的距离超过了maxlen，那么就意味着如果i连s1，那么j 不能连s2， j连s2，i就不能连s1。 xi => xj AND xj’ => xi’。

之前的错误，没有想到对于任意两个点都要再次加入限定条件，只考虑了之前关系的联系，并且只想到了如果这个点到s1的距离超过maxlen，那么就一定要连s2。然而这个条件太弱了，还有要根据当前的maxlen，来限定任意两个点之间的连接方式。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
using namespace std;
#define M 100009
int DFN[M],low[M],belong[M],dis1[M],dis2[M];
int dx[M],dy[M],which[M];
bool instack[M];
vector<int> edge[M];
vector<pair<int,int> > hate,frd;
stack<int> ss;
int N,A,B;
int dis_s1_s2;
int sx1,sy1,sx2,sy2;
int tot,sccnum;
void init()
{
memset(DFN,0,sizeof(DFN));
memset(instack,false,sizeof(instack));
for(int i = 1;i <= 2*N;i++) edge[i].clear();
tot = sccnum = 0;
}
void add_edge(int u,int v)
{
edge[u].push_back(v);
}
void tarjan(int u)
{
instack[u] = true;
DFN[u] = low[u] = ++tot;
ss.push(u);
for(int i = 0;i < edge[u].size();i++)
{
int v = edge[u][i];
if(!DFN[v])
{
tarjan(v);
low[u] = min(low[u],low[v]);
}
else if(instack[v])
{
low[u] = min(low[u],DFN[v]);
}
}
if(DFN[u] == low[u])
{
int v;
sccnum++;
for(;;)
{
v = ss.top();
ss.pop();
instack[v] = false;
belong[v] = sccnum;
if(v == u) break;
}
}
}
void scc()
{
for(int i = 1;i <= 2*N;i++)
{
if(!DFN[i]) tarjan(i);
}
}
bool solve(int mid)
{
init();
for(int i = 0;i < hate.size();i++)
add_edge(hate[i].first,hate[i].second);
for(int i = 0;i < frd.size();i++)
add_edge(frd[i].first,frd[i].second);
for(int i = 1;i <= N;i++)
{
for(int j = 1;j < i;j++)
{
if(dis1[i] + dis1[j] > mid)
{
add_edge(i,j+N);
add_edge(j,i+N);
}
if(dis1[i] + dis2[j] + dis_s1_s2 > mid)
{
add_edge(i,j);
add_edge(j+N,i+N);
}
if(dis2[i] + dis1[j] + dis_s1_s2 > mid)
{
add_edge(i+N,j+N);
add_edge(j,i);
}
if(dis2[i] + dis2[j] > mid)
{
add_edge(i+N,j);
add_edge(j+N,i);
}
}
}
scc();
for(int i = 1;i <= N;i++)
{
if(belong[i] == belong[i+N]) return false;
}
return true;
}
int main()
{
while(scanf("%d %d %d",&N,&A,&B) == 3)
{
scanf("%d %d %d %d",&sx1,&sy1,&sx2,&sy2);
dis_s1_s2 = abs(sx1-sx2) + abs(sy1-sy2);
for(int i = 1;i <= N;i++)
{
scanf("%d %d",&dx[i],&dy[i]);
dis1[i] = abs(dx[i]-sx1) + abs(dy[i]-sy1);
dis2[i] = abs(dx[i]-sx2) + abs(dy[i]-sy2);
}
for(int i = 0;i < A;i++)
{
int a,b;
scanf("%d %d",&a,&b);
hate.push_back(make_pair(a,b+N));
hate.push_back(make_pair(a+N,b));
hate.push_back(make_pair(b+N,a));
hate.push_back(make_pair(b,a+N));
}
for(int i = 0;i < B;i++)
{
int a,b;
scanf("%d %d",&a,&b);
frd.push_back(make_pair(a,b));
frd.push_back(make_pair(a+N,b+N));
frd.push_back(make_pair(b,a));
frd.push_back(make_pair(b+N,a+N));
}
int l = 0, r = 1000000000;
int ans = -1;
while(l < r - 1)
{
int mid = (l+r)/2;
if(solve(mid))
{
r = mid;
ans = r;
}
else l = mid;
}
printf("%d\n",ans);
}
return 0;
}