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;
}
时间: 2024-10-11 05:17:35

HIT_1917_Peaceful Commission(2-SAT)的相关文章

LA 3211 飞机调度(2—SAT)

https://vjudge.net/problem/UVALive-3211 题意: 有n架飞机需要着陆,每架飞机都可以选择“早着陆”和“晚着陆”两种方式之一,且必须选择一种,第i架飞机的早着陆时间为E,晚着陆时间为L,不得在其他时间着陆.你的任务是为这些飞机安排着陆方式,使得整个着陆计划尽量安全.换句话说,如果把所有飞机的实际着陆时间按照从早到晚的顺序排列,相邻两个着陆时间间隔的最小值. 思路: 二分查找最大值P,每次都用2—SAT判断是否可行. 1 #include<iostream>

HDU 1814 Peaceful Commission

Peaceful Commission Time Limit: 5000ms Memory Limit: 32768KB This problem will be judged on HDU. Original ID: 181464-bit integer IO format: %I64d      Java class name: Main The Public Peace Commission should be legislated in Parliament of The Democra

hdu 1814 Peaceful Commission (2-sat 输出字典序最小路径)

Peaceful Commission Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1948    Accepted Submission(s): 560 Problem Description The Public Peace Commission should be legislated in Parliament of Th

HDOJ 1814 Peaceful Commission

经典2sat裸题,dfs的2sat能够方便输出字典序最小的解... Peaceful Commission Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1578    Accepted Submission(s): 406 Problem Description The Public Peace Commission should

8.3吝啬SAT问题

吝啬SAT问题是这样的:给定一组子句(每个子句都是其中文字的析取)和整数k,求一个最多有k个变量为true的满足赋值--如果该赋值存在.证明吝啬SAT是NP-完全问题. 1.易知吝啬SAT的解可以在多项式时间内验证,因此属于NP问题. 2.如果我们把吝啬SAT问题中的k设置为输入的数目,那么SAT问题就可以规约到吝啬SAT问题,所以吝啬SAT问题是np-完全问题.

POJ 3207 Ikki&#39;s Story IV - Panda&#39;s Trick(2 - sat啊)

题目链接:http://poj.org/problem?id=3207 Description liympanda, one of Ikki's friend, likes playing games with Ikki. Today after minesweeping with Ikki and winning so many times, he is tired of such easy games and wants to play another game with Ikki. liy

多边形碰撞 -- SAT方法

检测凸多边形碰撞的一种简单的方法是SAT(Separating Axis Theorem),即分离轴定理. 原理:将多边形投影到一条向量上,看这两个多边形的投影是否重叠.如果不重叠,则认为这两个多边形是分离的,否则找下一条向量来继续投影.我们不需要比较很多条向量,因为已经在数学上证明,多边形每条边的垂直向量就是我们需要的向量. 1.AABB 让我们首先以AABB开始(AABB是一种两边分别平行于X-Y轴的矩形) 判断两个AABB是否碰撞,我们只需要投影两次,分别是投影在平行于X轴和Y轴的向量上

HIT1917Peaceful Commission(2-SAT)

Peaceful Commission   Source : POI 2001   Time limit : 10 sec   Memory limit : 32 M Submitted : 2112, Accepted : 641 The Public Peace Commission should be legislated in Parliament of The Democratic Republic of Byteland according to The Very Important

HDU 1814 Peaceful Commission(2-sat 模板题输出最小字典序解决方式)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1814 Problem Description 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 t