HIT_1917_Peaceful Commission(2-SAT)

Peaceful Commission

Source : POI 2001

Time limit : 10 sec

Memory limit : 32 M

The Public Peace Commission should be legislated in Parliament of The Democratic Republic of Byteland according to The Very Important Law. Unfortunately one of the obstacles is the fact that some deputies do not get on with some others.

The Commission has to fulfill the following conditions:

• Each party has exactly one representative in the Commission,
• If two deputies do not like each other, they cannot both belong to the Commission.

Each party has exactly two deputies in the Parliament. All of them are numbered from 1 to 2n. Deputies with numbers 2i-1 and 2i belong to the i-th party .

Task

Write a program, which:

• reads from the text file SPO.IN the number of parties and the pairs of deputies that are not on friendly terms,
• decides whether it is possible to establish the Commission, and if so, proposes the list of members,
• writes the result in the text file SPO.OUT.

Input

In the first line of the text file SPO.IN there are two non-negative integers n and m. They denote respectively: the number of parties, 1 <= n <= 8000, and the number of pairs of deputies, who do not like each other, 0 <= m <=2 0000. In each of the following m lines there is written one pair of integers a and b, 1 <= a < b <= 2n, separated by a single space. It means that the deputies a and b do not like each other.

There are multiple test cases. Process to end of file.

Output

The text file SPO.OUT should contain one word NIE (means NO in Polish), if the setting up of the Commission is impossible. In case when setting up of the Commission is possible the file SPO.OUT should contain n integers from the interval from 1 to 2n, written in the ascending order, indicating numbers of deputies who can form the Commission. Each of these numbers should be written in a separate line. If the Commission can be formed in various ways, your program may write any of them.

Sample Input

3 2
1 3
2 4

Sample Output

1

4

5

题意：某国有n个党派，每个党派在议会中恰有2个代表。现在要成立和平委员会 ，该会满足：每个党派在和平委员会中有且只有一个代表 如果某两个代表不和，则他们不能都属于委员会 。代表的编号从1到2n，编号为2a-1、2a的代表属于第a个党派求和平委员会是否能创立。若能，求一种构成方式。

分析：2-SAT经典问题，可留做模板。

2-SAT简介：

SAT是适定性(Satisfiability)问题的简称 。一般形式为k-适定性问题，简称 k-SAT。
当k>2时，k-SAT是NP完全的。因此一般讨论的是k=2的情况，即2-SAT问题。
2-SAT就是2判定性问题（条件只有一个，不是这个就是那个），是一种特殊的逻辑判定问题。

2-SAT，简单的说就是给出n个集合，每个集合有两个元素，已知若干个<a,b>，表示a与b矛盾(其中a与b属于不同的集合)。然后从每个集合选择一个元素，一共选n个两两不矛盾的元素。显然可能有多种选择方案，一般题中只需要求出一种即可。

2-SAT的算法流程：

1．构图   （重点+难点）
 2．求图的极大强连通子图 （模板）
 3．把每个子图收缩成单个节点，根据原图关系构造一个有向无环图 （模板）
 4．判断是否有解，无解则输出（退出） （这块常用到二分枚举答案）
 5．对新图进行拓扑排序 （模板）
 6．自底向上进行选择、删除 （模板）
 7．输出（模板）

详解请看：http://blog.csdn.net/zixiaqian/article/details/4492926

题目链接：http://acm.hit.edu.cn/hoj/problem/view?id=1917

代码清单：

#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<ctime>
#include<cctype>
#include<cstdlib>
#include<string>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;

const int maxn = (8000 + 5) * 2;
const int maxv = 20000 + 5;

int n,m,a,b;

int dfn[maxn];          //深度优先访问次序
int low[maxn];          //能追溯到的最早次序
int belong[maxn];       //点的属于哪个强连通分量
vector<int>graph[maxn]; //邻接表存图
stack<int>sta;          //存储已遍历的节点
bool InStack[maxn];     //是否在栈中
int index；             //索引号
int sccno;              //强连通分量个数

vector<int>new_graph[maxn];  //缩点后的新图
vector<int>mat[maxn];        //存每个强连通分量的包含的点
int order[maxn],k;           //存拓扑排序后的序列
bool vis[maxn];
bool color[maxn];

void init(){     //初始化
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(belong,0,sizeof(belong));
    memset(color,false,sizeof(color));
    memset(InStack,false,sizeof(InStack));
    for(int i=1;i<=2*n;i++){
        graph[i].clear();
        new_graph[i].clear();
        mat[i].clear();
    }
    while(!sta.empty()) sta.pop();
    index=0;
    sccno=0;
}

void input(){ //输入
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        graph[a].push_back(((b-1)^1)+1);   //建图
        //graph[((b-1)^1)+1].push_back(a);
        graph[b].push_back(((a-1)^1)+1);
        //graph[((a-1)^1)+1].push_back(b);
    }
}

void tarjan(int u){   //强连通分量
    dfn[u]=low[u]=++index;
    sta.push(u);
    InStack[u]=true;
    for(int i=0;i<graph[u].size();i++){
        int v=graph[u][i];
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        if(InStack[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u]==low[u]){
        sccno++;
        while(!sta.empty()){
            int j=sta.top();
            sta.pop();
            InStack[j]=false;
            belong[j]=sccno;
            if(j==u) break;
        }
    }
}

void findscc(){    //
    for(int u=1;u<=2*n;u++){
        if(!dfn[u]) tarjan(u);
    }
}

void narrow_point(){   //缩点
    for(int u=1;u<=2*n;u++){
        for(int i=0;i<graph[u].size();i++){
            int v=graph[u][i];
            if(belong[u]!=belong[v]){
                int uu=belong[u];
                int vv=belong[v];
                new_graph[uu].push_back(vv);
            }
        }
    }
}

bool exitSolution(){   //是否有解
    for(int u=1;u<=n;u++){
        if(belong[2*u-1]==belong[2*u])
            return false;
    }
    return true;
}

void dfs(int u){
    vis[u]=true;
    for(int i=0;i<new_graph[u].size();i++){
        int v=new_graph[u][i];
        if(!vis[v]) dfs(v);
    }
    order[k++]=u;
}

void topSort(){   //拓扑排序
    k=0;
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=sccno;i++){
        if(!vis[i]) dfs(i);
    }
}

void make_mat(){   //存每个强连通分量里的点
    for(int i=1;i<=2*n;i++){
        mat[belong[i]].push_back(i);
    }
}

void solve(){
    findscc();
    if(!exitSolution()){
        printf("NIE\n");
    }

    else{
        narrow_point();
        topSort();
        make_mat();
        memset(vis,false,sizeof(vis));
        for(int i=0;i<k;i++){
            if(!vis[order[i]]){
                int u=order[i];
                for(int j=0;j<mat[u].size();j++){
                    int v=((mat[u][j]-1)^1)+1;
                    vis[belong[v]]=true;
                    color[v]=true;
                }
            }
        }
        for(int i=1;i<=2*n;i++){
            if(!color[i]) printf("%d\n",i);
        }
    }
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        init();
        input();
        solve();
    }return 0;
}