2-SAT 问题是k-SAT问题在k==2时的特殊情况，因为已经证明k>=3时的k-sat问题属于npc问题。所以在这里仅研究2-SAT的特殊情况。

 
何为2-sat问题？
简单地说就是有N个集合，每个集合中有两个元素，其中一些集合中的元素存在相对关系。求出从每个集合中取出1个元素的方案。
 
先看一道例题：
2-sat的最简单情况，选出一些元素时，一些元素不可选。做这些题时，一般会考虑建图或者用并查集之类的数据结构维护。但显然复杂度是无法接受的，考虑新的算法。
 
首先，如果A1，A2，B1，B2分别为两个集合的两个元素。
且存在以下的排斥关系。
A1<->B2
B1<->A2
 
那么考虑从A1向B1连边，这条边意味着选了A1就必须选B1，因为显然选B2是不合法的。考虑相反情况。如果选了B2，就必须选A2，因为B2不可以和A1共存。 B1<->A2也是这样处理。
这时候我们就得到了一个图。把图中的一个强连通分量取出考虑，这个强连通分量里的每个元素都可以代表这一整个强连通分量，即选了这个强连通分量中的一个元素就必须选这个强连通分量里的所有元素，强连通分量里的元素部分取出构成的方案是不合法的（自己思考为什么）。同时，如果一个集合中的两个元素都位于一个强连通分量中也是不合法的。这时候各个元素中的相对关系就很显然了，采用topsort做最后的处理。
  1. //COGS 313
  2. //by Cydiater
  3. //2016.8.2
  4. #include <iostream>
  5. #include <cstdio>
  6. #include <cstring>
  7. #include <string>
  8. #include <queue>
  9. #include <map>
  10. #include <algorithm>
  11. #include <cstdlib>
  12. #include <cmath>
  13. #include <ctime>
  14. #include <iomanip>
  15. using namespace std;
  16. #define ll long long
  17. #define up(i,j,n)       for(int i=j;i<=n;i++)
  18. #define down(i,j,n)     for(int i=j;i>=n;i--)
  19. #define FILE "spo"
  20. ;
  21. const int oo=0x3f3f3f3f;
  22. inline int read(){
  23.       ,f=;
  24.       ;ch=getchar();}
  25.       +ch-';ch=getchar();}
  26.       return x*f;
  27. }
  28. ,group[MAXN],dfn[MAXN],low[MAXN],dfs_clock=,stack[MAXN],top=,group_num=,du[MAXN],opp[MAXN],LEN=,Link[MAXN],q[MAXN],head,tail,lable[MAXN];
  29. bool vis[MAXN];
  30. ],E[MAXN<<];
  31. namespace solution{
  32.       inline void insert(int x,int y){e[++len].next=LINK[x];LINK[x]=len;e[len].y=y;e[len].x=x;}
  33.       inline void Insert(int x,int y){E[++LEN].next=Link[x];Link[x]=LEN;E[LEN].y=y;E[LEN].x=x;}
  34.       void init(){
  35.             N=read();M=read();N<<=;
  36.             up(i,,M){
  37.                   ,y=read()-;
  38.                   insert(x,y^);
  39.                   insert(y,x^);
  40.             }
  41.       }
  42.       void tarjan(int node){
  43.             dfn[node]=low[node]=++dfs_clock;
  44.             stack[++top]=node;vis[node]=;
  45.             for(int i=LINK[node];i;i=e[i].next)
  46.                   if(!dfn[e[i].y]){
  47.                         tarjan(e[i].y);
  48.                         low[node]=min(low[node],low[e[i].y]);
  49.                   }
  50.                   else if(vis[e[i].y])low[node]=min(low[node],dfn[e[i].y]);
  51.             if(low[node]==dfn[node]){
  52.                   int tmp;
  53.                   group_num++;
  54.                   do{
  55.                         tmp=stack[top--];
  56.                         vis[tmp]=;
  57.                         group[tmp]=group_num;
  58.                   }while(tmp!=node);
  59.             }
  60.       }
  61.       void slove(){
  62.             memset(dfn,,sizeof(dfn));
  63.             memset(low,,sizeof(low));
  64.             memset(group,-,sizeof(group));
  65.             memset(du,,sizeof(du));
  66.             memset(lable,,sizeof(lable));
  67.             up(i,,N-)if(!dfn[i])tarjan(i);
  68.             up(i,,N-){
  69.                   ]){
  70.                         puts("NIE");
  71.                         exit();
  72.                   }
  73.                   opp[group[i]]=group[i^];
  74.                   opp[group[i^]]=group[i];
  75.             }
  76.             up(i,,len){
  77.                   int x=e[i].x,y=e[i].y;
  78.                   if(group[x]!=group[y]){
  79.                         Insert(group[y],group[x]);
  80.                         du[group[x]]++;
  81.                   }
  82.             }
  83.             head=;tail=;
  84.             up(i,,group_num))q[++tail]=i;
  85.             for(;head<=tail;head++){
  86.                   int node=q[head];
  87.                   )continue;
  88.                   lable[node]=;lable[opp[node]]=;
  89.                   for(int i=Link[node];i;i=E[i].next)
  90.                         )
  91.                               q[++tail]=E[i].y;
  92.             }
  93.       }
  94.       void output(){
  95.             up(i,,N-))printf();
  96.       }
  97. }
  98. int main(){
  99.       //freopen("input.in","r",stdin);
  100.       freopen(FILE".in","r",stdin);
  101.       freopen(FILE".out","w",stdout);
  102.       using namespace solution;
  103.       init();
  104.       slove();
  105.       output();
  106.       ;
  107. }

POJ3207

这也是一道很简单的2-SAT题目，相比网络流2-SAT的题目更好看出模型..
这个相比上一题也更加简单，仅判断是否存在方案即可。
如果两个线段是相交的，那么两个线段同时在圆内或者圆外都是相交的。
这样就得到了约束关系，套用2-SAT的模板就行了。
 
  1. //POJ 3207
  2. //by Cydiater
  3. //2016.8.2
  4. #include <iostream>
  5. #include <cstdio>
  6. #include <cstdlib>
  7. #include <cstring>
  8. #include <string>
  9. #include <algorithm>
  10. #include <queue>
  11. #include <map>
  12. #include <algorithm>
  13. #include <iomanip>
  14. #include <string>
  15. using namespace std;
  16. #define ll long long
  17. #define up(i,j,n)       for(int i=j;i<=n;i++)
  18. #define down(i,j,n)     for(int i=j;i>=n;i--)
  19. ;
  20. const int oo=0x3f3f3f3f;
  21. inline int read(){
  22.       ,f=;
  23.       ;ch=getchar();}
  24.       +ch-';ch=getchar();}
  25.       return x*f;
  26. }
  27. ,st[MAXN],nd[MAXN],dfn[MAXN],low[MAXN],stack[MAXN],dfs_clock=,top=,group[MAXN],group_num=;
  28. bool vis[MAXN];
  29. ];
  30. namespace solution{
  31.       inline void insert(int x,int y){e[++len].next=LINK[x];LINK[x]=len;e[len].y=y;e[len].x=x;}
  32.       void init(){
  33.             N=read();M=read();
  34.             up(i,,M-){
  35.                   int x=read(),y=read();
  36.                   st[i]=min(x,y);nd[i]=max(x,y);
  37.             }
  38.       }
  39.       void build(){
  40.             up(i,,M-)up(j,i+,M-){
  41.                   if((st[i]>st[j]&&st[i]<nd[j]&&nd[i]>nd[j])||(st[j]>st[i]&&st[j]<nd[i]&&nd[j]>nd[i])){
  42.                         insert(i,j+M);
  43.                         insert(j+M,i);
  44.                         insert(j,i+M);
  45.                         insert(i+M,j);
  46.                   }
  47.             }
  48.       }
  49.       void tarjan(int node){
  50.             low[node]=dfn[node]=++dfs_clock;
  51.             vis[node]=;stack[++top]=node;
  52.             for(int i=LINK[node];i;i=e[i].next)
  53.                   if(!dfn[e[i].y]){
  54.                         tarjan(e[i].y);
  55.                         low[node]=min(low[node],low[e[i].y]);
  56.                   }
  57.                   else if(vis[e[i].y]) low[node]=min(low[node],dfn[e[i].y]);
  58.             if(low[node]==dfn[node]){
  59.                   int tmp;group_num++;
  60.                   do{
  61.                         tmp=stack[top--];
  62.                         vis[tmp]=;
  63.                         group[tmp]=group_num;
  64.                   }while(tmp!=node);
  65.             }
  66.       }
  67.       bool check(){
  68.             up(i,,M);
  69.             ;
  70.       }
  71.       void slove(){
  72.             build();
  73.             memset(dfn,,sizeof(dfn));
  74.             memset(low,,sizeof(low));
  75.             memset(vis,,sizeof(vis));
  76.             up(i,,M<<)if(!dfn[i])tarjan(i);
  77.             if(check())puts("panda is telling the truth...");
  78.             else       puts("the evil panda is lying again");
  79.       }
  80. }
  81. int main(){
  82.       //freopen("input.in","r",stdin);
  83.       using namespace solution;
  84.       init();
  85.       slove();
  86.       ;
  87. }

POJ 3683

这道题调了两个多小时....
要注意几点，一是标记的下放，二是邻接表存储时不要打混...邻接表的命名打混这个真心是挺难查的...
题目本身不算难，2-SAT的裸题，拆点建图即可。
还有就是如果对于当前的约束条件，只要这个约束条件是存在的，不管哪个以为着必须的边是否正确，都要连边。
同时要注意到标记的下放。dfs即可。
 
  1. //POJ 3683
  2. //by Cydiater
  3. //2016.8.2
  4. #include <iostream>
  5. #include <cstdio>
  6. #include <cstdlib>
  7. #include <queue>
  8. #include <map>
  9. #include <algorithm>
  10. #include <ctime>
  11. #include <map>
  12. #include <iomanip>
  13. #include <cstring>
  14. #include <string>
  15. using namespace std;
  16. #define ll long long
  17. #define up(i,j,n)       for(int i=j;i<=n;i++)
  18. #define down(i,j,n)     for(int i=j;i>=n;i--)
  19. ;
  20. const int oo=0x3f3f3f3f;
  21. inline int read(){
  22.       ,f=;
  23.       ;ch=getchar();}
  24.       +ch-';ch=getchar();}
  25.       return x*f;
  26. }
  27. ,dfn[MAXN],low[MAXN],dfs_clock=,stack[MAXN],top=,group[MAXN],group_num=,opp[MAXN],Link[MAXN],LEN=,du[MAXN],q[MAXN<<],head=,tail=;
  28. int lable[MAXN];
  29. bool vis[MAXN];
  30. struct edge{int x,y,next;}e[MAXN*MAXN],E[MAXN*MAXN];
  31. namespace solution{
  32.       inline bool check(int st1,int nd1,int st2,int nd2){return (nd1<=st2)||(nd2<=st1);}
  33.       inline void insert(int x,int y){e[++len].next=LINK[x];LINK[x]=len;e[len].y=y;e[len].x=x;}
  34.       inline void Insert(int x,int y){E[++LEN].next=Link[x];Link[x]=LEN;E[LEN].y=y;E[LEN].x=x;}
  35.       inline void print(int a,int b){
  36.             )printf("0%d:",a);
  37.             else     printf("%d:",a);
  38.             )printf("0%d",b);
  39.             else     printf("%d",b);
  40.             printf(" ");
  41.       }
  42.       void init(){
  43.             N=read();
  44.             up(i,,N){
  45.                   int h1,m1,t1,h2,m2,t2,d;
  46.                   scanf("%d:%d",&h1,&m1);
  47.                   t1=h1*+m1;
  48.                   scanf("%d:%d",&h2,&m2);
  49.                   t2=h2*+m2;
  50.                   st[i]=t1;nd[i]=t2;c[i]=read();
  51.             }
  52.       }
  53.       void build(){
  54.             up(i,,N)up(j,i+,N){
  55.                   if(!check(st[i],st[i]+c[i],st[j],st[j]+c[j])){
  56.                         insert(i,j+N);
  57.                         insert(j,i+N);
  58.                   }
  59.                   if(!check(st[i],st[i]+c[i],nd[j]-c[j],nd[j])){
  60.                         insert(i,j);
  61.                         insert(j+N,i+N);
  62.                   }
  63.                   if(!check(nd[i]-c[i],nd[i],st[j],st[j]+c[j])){
  64.                         insert(i+N,j+N);
  65.                         insert(j,i);
  66.                   }
  67.                   if(!check(nd[i]-c[i],nd[i],nd[j]-c[j],nd[j])){
  68.                         insert(i+N,j);
  69.                         insert(j+N,i);
  70.                   }
  71.             }
  72.       }
  73.       void tarjan(int node){
  74.             dfn[node]=low[node]=++dfs_clock;
  75.             vis[node]=;stack[++top]=node;
  76.             for(int i=LINK[node];i;i=e[i].next)
  77.                   if(!dfn[e[i].y]){
  78.                         tarjan(e[i].y);
  79.                         low[node]=min(low[node],low[e[i].y]);
  80.                   }
  81.                   else if(vis[e[i].y]) low[node]=min(low[node],dfn[e[i].y]);
  82.             if(low[node]==dfn[node]){
  83.                   int tmp;group_num++;
  84.                   do{
  85.                         tmp=stack[top--];
  86.                         vis[tmp]=;
  87.                         group[tmp]=group_num;
  88.                   }while(tmp!=node);
  89.             }
  90.       }
  91.       void re_build(){
  92.             up(i,,N){
  93.                   if(group[i]==group[i+N]){
  94.                         puts("NO");
  95.                         exit();
  96.                   }
  97.                   opp[group[i]]=group[i+N];
  98.                   opp[group[i+N]]=group[i];
  99.             }
  100.             puts("YES");
  101.             up(i,,len){
  102.                   int x=e[i].x,y=e[i].y;
  103.                   if(group[x]==group[y])continue;
  104.                   Insert(group[y],group[x]);
  105.                   du[group[x]]++;
  106.             }
  107.       }
  108.       void downit(int node){
  109.             if(lable[node])return;
  110.             lable[node]=-;
  111.             for(int i=Link[node];i;i=E[i].next)
  112.                   downit(E[i].y);
  113.       }
  114.       void top_sort(){
  115.             head=;tail=;
  116.             up(i,,group_num))q[++tail]=i;
  117.             for(;head<=tail;head++){
  118.                   int node=q[head];
  119.                   if(lable[node])continue;
  120.                   lable[node]=;downit(opp[node]);
  121.                   for(int i=Link[node];i;i=E[i].next)
  122.                         )
  123.                               q[++tail]=E[i].y;
  124.             }
  125.       }
  126.       void slove(){
  127.             memset(vis,,sizeof(vis));
  128.             memset(dfn,,sizeof(dfn));
  129.             memset(low,,sizeof(low));
  130.             memset(du,,sizeof(du));
  131.             memset(lable,,sizeof(lable));
  132.             build();
  133.             up(i,,N<<)if(!dfn[i])tarjan(i);
  134.             re_build();
  135.             top_sort();
  136.       }
  137.       void output(){
  138.             up(i,,N){
  139.                   ){print(st[i]/,st[i]%);printf(,(st[i]+c[i])%);}
  140.                   ,(nd[i]-c[i])%);printf(,nd[i]%);}
  141.                   printf("\n");
  142.             }
  143.       }
  144. }
  145. int main(){
  146.       freopen("input.in","r",stdin);
  147.       using namespace solution;
  148.       init();
  149.       slove();
  150.       output();
  151.       ;
  152. }
 题目大意是给N个点M条边，每个点可以是0或者1，每条边是一个操作，每个一边的操作对应一个值，问是否有可行的方案
2-SAT的模型通常都很好观察出来。
 
这里的建模需要注意两个点。
1.op==and而且res==1。
这时候A点必须是1，B点也必须是1，如何保证这一点？

if(op==1&&res==1){
　　insert(x,x+N);
　　insert(y,y+N);
}

2.op==XOR是不需要连边的。

 我没搞懂为什么..但是好像是最后tarjan会自动的把那个xor的情况给处理掉。
  1. //POJ 3678
  2. //by Cydiater
  3. //2016.8.3
  4. #include <iostream>
  5. #include <cstdio>
  6. #include <cstdlib>
  7. #include <cmath>
  8. #include <ctime>
  9. #include <queue>
  10. #include <map>
  11. #include <algorithm>
  12. #include <cstring>
  13. #include <string>
  14. #include <algorithm>
  15. using namespace std;
  16. #define ll long long
  17. #define up(i,j,n)       for(int i=j;i<=n;i++)
  18. #define down(i,j,n)     for(int i=j;i>=n;i--)
  19. ;
  20. const int oo=0x3f3f3f3f;
  21. inline int read(){
  22.       ,f=;
  23.       ;ch=getchar();}
  24.       +ch-';ch=getchar();}
  25.       return x*f;
  26. }
  27. ,dfn[MAXN],low[MAXN],stack[MAXN],top=,dfs_clock=,group_num=,group[MAXN];
  28. bool vis[MAXN];
  29. string s;
  30. map<string,int>m;
  31. struct edge{
  32.       int x,y,next;
  33. }e[MAXN<<];
  34. namespace solution{
  35.       inline void insert(int x,int y){e[++len].next=LINK[x];LINK[x]=len;e[len].y=y;}
  36.       void init(){
  37.             m[;m[;m[;
  38.             N=read();M=read();
  39.             up(i,,M){
  40.                   int x=read(),y=read(),res=read();cin>>s;
  41.                   int op=m[s];
  42.                   &&res==){
  43.                         insert(x,x+N);
  44.                         insert(y,y+N);
  45.                   }
  46.                   &&res==){
  47.                         insert(x+N,y);
  48.                         insert(y+N,x);
  49.                   }
  50.                   &&res==){
  51.                         insert(x,y+N);
  52.                         insert(y,x+N);
  53.                   }
  54.                   &&res==){
  55.                         insert(x+N,x);
  56.                         insert(y+N,y);
  57.                   }
  58.                   &&res==){
  59.                         insert(x,y+N);
  60.                         insert(y,x+N);
  61.                         insert(y+N,x);
  62.                         insert(x+N,y);
  63.                   }
  64.                   &&res==){
  65.                         insert(x,y);
  66.                         insert(y,x);
  67.                         insert(x+N,y+N);
  68.                         insert(y+N,x+N);
  69.                   }
  70.             }
  71.       }
  72.       void tarjan(int node){
  73.             dfn[node]=low[node]=++dfs_clock;
  74.             stack[++top]=node;vis[node]=;
  75.             for(int i=LINK[node];i;i=e[i].next)
  76.                   if(!dfn[e[i].y]){
  77.                         tarjan(e[i].y);
  78.                         low[node]=min(low[node],low[e[i].y]);
  79.                   }else if(vis[e[i].y]) low[node]=min(low[node],dfn[e[i].y]);
  80.             if(low[node]==dfn[node]){
  81.                   group_num++;
  82.                   int tmp;
  83.                   do{
  84.                         tmp=stack[top--];
  85.                         vis[tmp]=;
  86.                         group[tmp]=group_num;
  87.                   }while(tmp!=node);
  88.             }
  89.       }
  90.       bool check(){
  91.             up(i,,N-);
  92.             ;
  93.       }
  94.       void slove(){
  95.             memset(dfn,,sizeof(dfn));
  96.             memset(low,,sizeof(low));
  97.             memset(vis,,sizeof(vis));
  98.             up(i,,N<<)if(!dfn[i])tarjan(i);
  99.             if(check())puts("YES");
  100.             else       puts("NO");
  101.       }
  102. }
  103. int main(){
  104.       //freopen("input.in","r",stdin);
  105.       using namespace solution;
  106.       init();
  107.       slove();
  108.       ;
  109. }
最后一道2-SAT题目！
首先一些hate和friend的约束条件建图，然后根据二分出来的最长距离，对于i,j之间所有可能的路径:
i-S1-j
i-S2-j
i-S1-S2-j
i-S2-S1-j
如果存在大于lim的，也加入到约束条件中，判一下就行了。
 
  1. //POJ 2749
  2. //by Cydiater
  3. //2016.8.8
  4. #include <iostream>
  5. #include <cstdio>
  6. #include <cstring>
  7. #include <string>
  8. #include <algorithm>
  9. #include <queue>
  10. #include <map>
  11. #include <iomanip>
  12. #include <ctime>
  13. #include <cmath>
  14. #include <cstdlib>
  15. using namespace std;
  16. #define ll long long
  17. #define up(i,j,n)       for(int i=j;i<=n;i++)
  18. #define down(i,j,n)     for(int i=j;i>=n;i--)
  19. typedef pair<int,int> pii;
  20. ;
  21. const int oo=0x3f3f3f3f;
  22. inline int read(){
  23.       ,f=;
  24.       ;ch=getchar();}
  25.       +ch-';ch=getchar();}
  26.       return x*f;
  27. }
  28. pii S1,S2,node[MAXN],hate[MAXN],fri[MAXN];
  29. int N,A,B,leftt,rightt,mid,LINK[MAXN],len,dfn[MAXN],low[MAXN],stack[MAXN],top,dfs_clock,group[MAXN],group_num;
  30. bool vis[MAXN];
  31. ];
  32. namespace solution{
  33.       inline int dist(pii a,pii b){return abs(a.first-b.first)+abs(a.second-b.second);}
  34.       inline void insert(int x,int y){e[++len].next=LINK[x];LINK[x]=len;e[len].y=y;e[len].x=x;}
  35.       void init(){
  36.             N=read();A=read();B=read();
  37.             int x=read(),y=read();
  38.             S1=make_pair(x,y);
  39.             x=read();y=read();
  40.             S2=make_pair(x,y);
  41.             up(i,,N){
  42.                   int x=read(),y=read();
  43.                   node[i]=make_pair(x,y);
  44.             }
  45.             up(i,,A){
  46.                   int x=read(),y=read();
  47.                   hate[i]=make_pair(x,y);
  48.             }
  49.             up(i,,B){
  50.                   int x=read(),y=read();
  51.                   fri[i]=make_pair(x,y);
  52.             }
  53.       }
  54.       void tarjan(int node){
  55.             stack[++top]=node;vis[node]=;
  56.             low[node]=dfn[node]=++dfs_clock;
  57.             for(int i=LINK[node];i;i=e[i].next)
  58.                   if(!dfn[e[i].y]){
  59.                         tarjan(e[i].y);
  60.                         low[node]=min(low[node],low[e[i].y]);
  61.                   }else if(vis[e[i].y])   low[node]=min(low[node],dfn[e[i].y]);
  62.             if(dfn[node]==low[node]){
  63.                   group_num++;int tmp;
  64.                   do{
  65.                         tmp=stack[top--];
  66.                         vis[tmp]=;
  67.                         group[tmp]=group_num;
  68.                   }while(tmp!=node);
  69.             }
  70.       }
  71.       bool check(int lim){
  72.             len=;top=;dfs_clock=;group_num=;
  73.             memset(LINK,,sizeof(LINK));
  74.             memset(dfn,,sizeof(dfn));
  75.             memset(low,,sizeof(low));
  76.             memset(vis,,sizeof(vis));
  77.             up(i,,A){
  78.                   int x=hate[i].first,y=hate[i].second;
  79.                   insert(x,y+N);
  80.                   insert(y,x+N);
  81.                   insert(x+N,y);
  82.                   insert(y+N,x);
  83.             }
  84.             up(i,,B){
  85.                   int x=fri[i].first,y=fri[i].second;
  86.                   insert(x,y);
  87.                   insert(y,x);
  88.                   insert(x+N,y+N);
  89.                   insert(y+N,x+N);
  90.             }
  91.             up(i,,N)up(j,i+,N){
  92.                   if(dist(node[i],S1)+dist(S1,node[j])>lim){
  93.                         insert(i,j+N);
  94.                         insert(j,i+N);
  95.                   }
  96.                   if(dist(node[i],S2)+dist(S2,node[j])>lim){
  97.                         insert(i+N,j);
  98.                         insert(j+N,i);
  99.                   }
  100.                   if(dist(node[i],S1)+dist(S1,S2)+dist(S2,node[j])>lim){
  101.                         insert(i,j);
  102.                         insert(j+N,i+N);
  103.                   }
  104.                   if(dist(node[i],S2)+dist(S1,S2)+dist(S1,node[j])>lim){
  105.                         insert(i+N,j+N);
  106.                         insert(j,i);
  107.                   }
  108.             }
  109.             up(i,,N<<)if(!dfn[i])tarjan(i);
  110.             up(i,,N);
  111.             ;
  112.       }
  113.       void slove(){
  114.             leftt=;rightt=;
  115.             <rightt){
  116.                   mid=(leftt+rightt)>>;
  117.                   if(check(mid))    rightt=mid;
  118.                   else              leftt=mid;
  119.             }
  120.             if((!check(leftt))&&(!check(rightt)))puts("-1");
  121.             else if(check(leftt))  printf("%d\n",leftt);
  122.             else              printf("%d\n",rightt);
  123.       }
  124. }
  125. int main(){
  126.       //freopen("input.in","r",stdin);
  127.       using namespace solution;
  128.       init();
  129.       slove();
  130.       ;
  131. }

2-SAT 问题的更多相关文章

  1. 多边形碰撞 -- SAT方法

    检测凸多边形碰撞的一种简单的方法是SAT(Separating Axis Theorem),即分离轴定理. 原理:将多边形投影到一条向量上,看这两个多边形的投影是否重叠.如果不重叠,则认为这两个多边形 ...

  2. POJ 3678 Katu Puzzle（2 - SAT） - from lanshui_Yang

    Description Katu Puzzle is presented as a directed graph G(V, E) with each edge e(a, b) labeled by a ...

  3. Map Labeler POJ - 2296（2 - sat 具体关系建边）

    题意: 给出n个点  让求这n个点所能建成的正方形的最大边长,要求不覆盖,且这n个点在正方形上或下边的中点位置 解析: 当然是二分,但建图就有点还行..比较难想..行吧...我太垃圾... 2 - s ...

  4. 学习笔记（two sat）

    关于two sat算法 两篇很好的论文由对称性解2-SAT问题(伍昱), 赵爽 2-sat解法浅析(pdf). 一些题目的题解 poj 3207 poj 3678 poj 3683 poj 3648 ...

  5. LA 3211 飞机调度（2—SAT）

    https://vjudge.net/problem/UVALive-3211 题意: 有n架飞机需要着陆,每架飞机都可以选择“早着陆”和“晚着陆”两种方式之一,且必须选择一种,第i架飞机的早着陆时间 ...

  6. HIT 1917 2—SAT

    题目大意:一国有n个党派,每个党派在议会中都有2个代表, 现要组建和平委员会,要从每个党派在议会的代表中选出1人,一共n人组成和平委员会. 已知有一些代表之间存在仇恨,也就是说他们不能同时被选为和平委 ...

  7. 2 - sat 模板（自用）

    2-sat一个变量两种状态符合条件的状态建边找强连通,两两成立1 - n 为第一状态(n + 1) - (n + n) 为第二状态 例题模板 链接一  POJ 3207 Ikki's Story IV ...

  8. SAT考试里最难的数学题？ · 三只猫的温暖

    问题 今天无意中在Quora上看到有人贴出来一道号称是SAT里最难的一道数学题,一下子勾起了我的兴趣.于是拿起笔来写写画画,花了差不多十五分钟搞定.觉得有点意思,决定把解题过程记下来.原帖的图太小,我 ...

  9. 世界碰撞算法原理和总结（sat gjk）

    序言 此文出于作者的想法,从各处文章和论文中,总结和设计项目中碰撞结构处理方法.如有其它见解,可以跟作者商讨.(杨子剑,zijian_yang@yeah.net). 在一个世界中,有多个物体,物体可以 ...

  10. hdu 4115 (2—SAT)

    题意:两个人石头剪刀布,一个人的出法已确定,另一个人的出法有一定约束,某两次要相同或者不同,问你第二个人能否全部都不失败. 思路:根据Bob出的情况,我们可以确定每次Alice有两种方案. R与P,S ...

随机推荐

  1. Android手机截屏

    刚开始打算做一个简单的截屏程序时,以为很轻松就能搞定. 在Activity上放一个按钮,点击完成截屏操作,并将数据以图片形式保存在手机中. 动手之前,自然是看书和网上各种查资料.结果发现了解的知识越多 ...

  2. GBPR: Group Preference Based Bayesian Personalized Ranking for One-Class Collaborative Filtering-IJACA 2013_20160421

    1.Information publication:IJACA 2013 2.What 基于BPR模型的改进:改变BPR模型中,a,用户对商品喜好偏序对之间相互独立;b,用户之间相互独立的假设 原因: ...

  3. BroadcastReceiver之(手动代码注册广播)屏幕锁屏、解锁监听、开机自启

    对于解锁和锁屏这种用的比较频繁action,谷歌做了限制,必须手动用代码注册 直接上代码:这是注册广播(手动代码注册广播接收者) public class MainActivity extends A ...

  4. android 按钮点击效果实现

    在其他人的博客里看到其实实现按钮点击效果的方法有很多,这里提到的只是其中一个办法 图片素材(我自己用截图截的,可以自己搞) 放到mipmap目录下(studio是在这个目录下 , eclipse 直接 ...

  5. 使用jsp/servlet简单实现文件上传与下载

    使用JSP/Servlet简单实现文件上传与下载    通过学习黑马jsp教学视频,我学会了使用jsp与servlet简单地实现web的文件的上传与下载,首先感谢黑马.好了,下面来简单了解如何通过使用 ...

  6. 安卓activity生命周期

    相信不少朋友也已经看过这个流程图了,也基本了解了Activity生命周期的几个过程,我们就来说一说这几个过程. 1.启动Activity:系统会先调用onCreate方法,然后调用onStart方法, ...

  7. mysql之路【第三篇】

    1,查看表的结构 desc   表名; 查看表的详细结构 show   create  table; show   create  table   \G;   (加上G格式化输出), 2,修改表 2. ...

  8. java.net.URLConnectioin的http(get,post)请求(原生)

    使用Java发送这两种请求的代码大同小异,只是一些参数设置的不同.步骤如下: 通过统一资源定位器(java.net.URL)获取连接器(java.net.URLConnection) 设置请求的参数 ...

  9. 如何更新firefox中的flash

    要了解当前安装的版本是否为最新版本,请访问 插件检查页面http://www.mozilla.com/plugincheck/  ,如果该页面告诉你 Flash 插件需要更新,请手动安装最新版本. 使 ...

  10. EF异常：“System.InvalidOperationException”类型的未经处理的异常在 mscorlib.dll 中发生

     实体框架System.Data.Entity.SqlServer提供者类型”. SqlProviderServices EntityFramework. 的在应用程序配置文件注册状态"置疑 ...