2-sat(求最小字典序 hdu 1814)

2-sat:http://blog.csdn.net/swm8023/article/details/6952741,http://www.doc88.com/p-0012079707313.html

2-sat 问题一般可以简化成每对（两个）元素中必须选一个，并且每对元素间有关系，比如两对元素中x1，x2和y1，y2中必须存在x1与y1矛盾，即满足选了x1必选y2，选了y1必选x2（因为每对必须选一个）这样的关系，算法有两种，一种是暴力dfs（o（nm））可以求出最小字典序排列的可能性，一种是（o（m））可以求出任意一种可能性，以下先讲暴力dfs，主要思路为：

              1.建边，若像上面的x1和y1矛盾，则建立x1->y2，y1->x2两条边，同理建边

             2.枚举所有的点，若每对中的两个点都没染色，则先对一个点染为红色，dfs求出关系中与这个点必须同时取一种颜色的点，若存在一点已经染色但是颜色与现在要染的不同，则有错，需要还原状态来对原始点重新染另一种颜色，若每对中的点都染一种颜色，则无法实现题目要求，报有错，若最后全部满足则可能，输出染第一种颜色的所有点就是所求的选择。

具体见下题：

          题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=1814

          题意：有一个议会，这个议会需要在n个党派里每个党派选一个人来参加，每个党派有两个人,人从1---n编号，2*i-1和2*i属于一个党派中的人,同时给定一些约束条件，要求满足某些人不能再议会同时出现，要求输出最小的字典序选择

        
        输入说明：第一行输入n和m，n代表多少人，m代表有多少矛盾约束，接下来m行输入矛盾的两个人的编号。

        题解：按照上面思路，先建图，编号全部-1，方便做异或运算，然后用dfs进行染色，最后输出

       代码：(简单的vector实现)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>

using namespace std;
vector<int> edge[20000];//用于存边，代表与i相邻的所有点
bool match[20000];//记录染色，1为一种颜色，0为另一种颜色
int cnt;//堆栅，当染色出现矛盾时可以回退状态
int _stack[20000];//用于存储从原始点出发的染色顺序状态
bool dfs(int root)
{
    if(match[root^1]) return false;
    if(match[root]) return true;
    _stack[cnt++]=root;//记录染色
    match[root]=true;//染色
    for(int i=0;i<edge[root].size();i++)
    {
        if(!dfs(edge[root][i])) return false;//若后面出现矛盾，返回false
    }
    return true;
}
bool solve(int n)
{
    memset(match,false,sizeof(match));
    for(int i=0;i<2*n;i+=2)
    {
        if(!match[i] && !match[i^1]) //若全部该队中没染色时
        {
            cnt=0;
            if(!dfs(i))
            {
                for(int j=0;j<cnt;j++) match[_stack[j]]=false;
                if(!dfs(i^1)) return false;
            }
        }
    }
    return true;
}
int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        for(int i=1;i<=m;i++)//建图
        {
            int s,e;
            scanf("%d %d",&s,&e);
            s--;e--;
            edge[s].push_back(e^1);
            edge[e].push_back(s^1);
        }
        if(solve(n))//输出解决
        {
            for(int i=0;i<2*n;i+=2)
            {
                if(match[i]) printf("%d\n",i+1);
                else printf("%d\n",i+2);
            }
        }
        else  printf("NIE\n");
        for(int i=0;i<2*n;i++) edge[i].clear();
    }
    return 0;
}

利用存边

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 20010;
struct edge
{
    int to, next;
}g[N*10];
int cnt, head[N];
int n, m, tot;
int tmp[N];
bool mark[N];
void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
bool dfs(int v)
{
    if(mark[v^1]) return false;
    if(mark[v]) return true;
    tmp[tot++] = v;
    mark[v] = true;
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(! dfs(u)) return false;
    }
    return true;
}
bool solve()
{
    memset(mark, 0, sizeof mark);
    for(int i = 0; i < 2*n; i += 2)
        if(!mark[i] && !mark[i+1])
        {
            tot = 0;
            if(! dfs(i))
            {
                for(int i = 0; i < tot; i++) mark[tmp[i]] = false;
                if(! dfs(i+1)) return false;
            }
        }
    return true;
}
int main()
{
    int v, u;
    while(~ scanf("%d%d", &n, &m))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d", &v, &u);
            v--, u--;
            add_edge(v, u^1), add_edge(u, v^1);
        }
        if(solve())
        {
            for(int i = 0; i < 2*n; i += 2)
                if(mark[i]) printf("%d\n", i+1);
                else printf("%d\n", i+2);
        }
        else printf("NIE\n");
    }
    return 0;
}