POJ 3683 【2sat+求一组可行解】.cpp

题意：

　　有一个牧师要给好几对新婚夫妇准备婚礼..

　　已知每对新婚夫妇的有空的时间以及婚礼持续时间..

　　问是否可以让每对新婚夫妇都得到该牧师的祝福~

　　如果可以就输出YES以及可行解 不可以就输出NO

输入：

　　一个n 表示有n对新婚夫妇

　　接下来n行每行a b c 表示在a~b这段时间有空..以及婚礼会持续 c..

　　P.S.时间只可以选在a开始或者b结束..

　　eg：08:00 09:00 30 可以在8：00~8:30举行婚礼或者8:30~9:00举行婚礼

思路：

　　2-sat 以在前一段时间举行婚礼或者后一段时间举行婚礼为2个可选方案

　　然后每对新婚夫妇婚礼时间冲突了就给和另外一个方案连线..

　　2-sat问题连边的要求就是这两个情况一定要同时发生..

　　然后根据建的图求强连通分量以及缩点..表示是否可以同时发生并方便后面拓扑排序..

　　总方案不成立的条件是一个强连通分量里有col[ i ] == col[ i+n ]

 

　　而找可行解的方案就是：

　　根据第一次建的图建一个反图..然后求逆拓扑排序..

　　建反图的原因是保持冲突的两个事件肯定会被染成不同的颜色..

　　求逆拓扑排序的原因也是为了对图染的色不会发生冲突..

 

　　输出可行解就是遍历一次逆拓扑排序时染成的颜色..

　　输出同一组颜色的解就是其中的一组可行解..

　　

Tips：

　　※ 用双向链表..方便建反图..

　　※ 求强连通分量是把所有的点都遍历一遍..所以是2*n..

　　※ 建反图的时候是遍历所有的边..然后根据edge.from 和 edge.to 建图

　　※ 拓扑排序是对缩点后的有向无环图排序..找出一组可行解..

　　　　每次拓扑排序找到一个解的时候..就把和他冲突的另外一个解也染色了..

　　※ 连边的时候连的是必须发生的两件事..

　　※ 如果求连通分量染色的时候遇到冲突事件在一个分量中出现则不能有可行解

　　　　　否则就把缩点后冲突事件记录起来..以便拓扑排序的时候染色..

　　※ 最后记录某一个颜色的可行解..

　　　　然后遍历一遍1~n 找出该时间是否属于该可行解..属于就输出..不属于就输出对立的解..

 

总结：

　　2-sat问题是
　　①. 把有冲突的分成n组
　　②. 每组2个..然后根据冲突关系把没冲突的连边
　　③. 用tarjan染色..
　　④. 把缩点后的图建反图..
　　⑤. 根据反图拓扑排序
　　⑥. 拓扑排序过程中给其中一组解染色..同时给冲突的解染色
　　⑦. 根据第⑥.步找出可行解并输出..

 

Code：

#include <stdio.h>
#include <cstring>
#include <fstream>
#include <algorithm>
using namespace std;
#define clr(x) memset(x, 0, sizeof(x))
const int INF = 0x1f1f1f1f;
const int MAXN = 1010*2;

struct Time
{
    int st;
    int en;
    int la;
}time[MAXN];

struct Edge
{
    int from;
    int next;
    int to;
}edge[3000010], edge2[3000010];///!!!
int head[MAXN], head2[MAXN];
int tot, tot2;

void add(int s, int u)
{
    edge[tot].from = s;
    edge[tot].to = u;
    edge[tot].next = head[s];
    head[s] = tot++;
}

void add2(int s, int u)
{
    edge2[tot2].to = u;
    edge2[tot2].next = head2[s];
    head2[s] = tot2++;
}

int low[MAXN], dfn[MAXN];
int ins[MAXN], sta[MAXN], col[MAXN];
int ti, top, cnt;

void tarjan(int u)
{
    int i, j, k;
    dfn[u] = low[u] = ++ti;
    sta[++top] = u;
    ins[u] = 1;
    for(i = head[u]; i != -1; i = edge[i].next) {
        k = edge[i].to;
        if(!dfn[k]) {
            tarjan(k);
            low[u] = min(low[u], low[k]);
        } else if(ins[k])
            low[u] = min(low[u], dfn[k]);
    }
    if(dfn[u] == low[u]) {
        cnt++;
        do
        {
            k = sta[top--];
            col[k] = cnt;
            ins[k] = 0;
        }while(k != u);
    }
}

int n;
void solve_ta()
{
    int i, j, k;
    ti = cnt = top = 0;
    clr(dfn);
    for(i = 1; i <= 2*n; ++i)
    if(!dfn[i])
        tarjan(i);
}

int ind[MAXN], res[MAXN];
int q[MAXN];

void make_G()
{
    int i, j, k;
    tot2 = 0;
    memset(head2, 0xff, sizeof(head2));
    clr(ind);
    for(i = 0; i < tot; ++i) {///!!!!
        if(col[edge[i].from] != col[edge[i].to]) {
            add2(col[edge[i].to], col[edge[i].from]);
            ind[col[edge[i].from]]++;
        }
    }
}

int ccol[MAXN];
int ans[MAXN], ct[MAXN];
void toposort()
{
    int front = 0, rear = 0;
    int i, k;
    make_G();
    top = 0;
    clr(ccol);
    for(i = 1; i <= cnt; i++)///!!
        if(ind[i] == 0)
            q[rear++] = i;
    while(front < rear) {
        int x = q[front++];
        if(ccol[x] == 0) {
            ccol[x] = 1;
            ccol[ct[x]] = -1;
        }
        for(i = head2[x]; i != -1;i = edge2[i].next) {
            k = edge2[i].to;
            ind[k]--;
            if(ind[k] == 0) {
                q[rear++] = k;
            }
        }
    }
}

int main()
{
    int i, j, k;
    int sh, sm, eh, em, d;///!!!
    bool flag;
   // freopen("e:\\acm\\mess\\stdin-stdout\\in.txt", "r", stdin);
    while(scanf("%d", &n) != EOF)
    {
        tot = 0;
        memset(head, 0xff, sizeof(head));
        flag = false;

        for(i = 1; i <= n; ++i) {
            scanf("%d:%d %d:%d %d", &sh, &sm, &eh, &em, &d);
            time[i].st = sh*60+sm;
            time[i].en = eh*60+em;
            time[i].la = d;
        }

        for(i = 1; i <= n; ++i)
        for(j = 1; j <= n; ++j)
            if(i != j) {
                /*
                if((time[i].st+time[i].la < time[j].st) || (time[i].st > time[j].st + time[j].la))
                    add(i, j);
                if((time[i].en-time[i].la > time[j].st+time[j].la) || (time[i].en < time[j].st))
                    add(i+n, j);
                if((time[i].st+time[i].la < time[j].en-time[j].la) || (time[i].st > time[j].en))
                    add(i, j+n);
                if((time[i].en-time[i].la > time[j].en) || (time[i].en < time[j].en-time[j].la))
                    add(i+n, j+n);
                */

                if(time[i].st < time[j].st+time[j].la && time[j].st < time[i].st+time[i].la )
                    add(i, j+n);
                if(time[i].st < time[j].en && time[j].en-time[j].la < time[i].st+time[i].la)
                    add(i, j);
                if(time[i].en-time[i].la< time[j].st+time[j].la && time[j].st<time[i].en)
                    add(i+n, j+n);
                if(time[i].en - time[i].la < time[j].en && time[j].en-time[j].la < time[i].en)
                    add(i+n, j);
            }

        solve_ta();
        for(i = 1; i <= n; ++i) {
            if(col[i] == col[i+n]) {
                flag = true;
                break;
            }
            ct[col[i]] = col[i+n];
            ct[col[i+n]] = col[i];
        }


        if(flag) puts("NO");
        else {
            toposort();
            clr(ans);

            for(i = 1; i <= 2*n; ++i)
                if(ccol[col[i]] == 1)
                    ans[i] = 1;
            puts("YES");
            for(i = 1; i <= n; ++i) {
                if(ans[i]) printf("%02d:%02d %02d:%02d\n", time[i].st/60, time[i].st%60, (time[i].st+time[i].la)/60, (time[i].st+time[i].la)%60);
                else printf("%02d:%02d %02d:%02d\n", (time[i].en-time[i].la)/60, (time[i].en-time[i].la)%60, time[i].en/60, time[i].en%60);
            }
        }

    }
    return 0;
}

 

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