poj3683 2-SAT 求解

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

 

题目大意：在一个结婚高潮的时段，很多人想结婚，但是只有一个神父可以主持婚礼，给出每组婚礼的两个开始时间a，b和婚礼的持续时间d，问能否主持所有的婚礼，若能，则输出每个婚礼占用的时间段，不能就输出NO

 

考查点：2-SAT判定加求解

 

思路：因为每个婚礼只有两个开始时间a或b，由于只有两种状态，所以可以看作是x和非x，然后利用n方的时间判断两个婚礼的开始时间之间是否有冲突，若有，非（I and j） = 1

然后化为析取式建立边。

建完边以后，就可以求强连通分图。判断是否有冲突，如有，输出NO。若无，则进行求解。

求解是先缩图，然后反向建边。拓扑排序后，从拓扑序中第一个缩点开始，遇到没有染过色的，染成红色，然后把这个缩点内的所有点的非所在的缩点染成蓝色。然后再找下一个没有被染过色的缩点，然后往复执行前面的过程。知道所有点都被染了色

 

提交情况  Accepted   1次

 

经验：如何思考一个问题是不是2-SAT问题。每个状态有两种可能（看作是1，0），状态之间又有一些约束条件。

 

收获：拥有了2-SAT问题求解的模板

 

AC code：

#include <stdio.h>

#include <string.h>

 

#define MAXN 3000

#define MAXE MAXN * MAXN

struct NODE{

    int st, to;

    int next;

};

NODE edges[MAXE], minedges[MAXE], incde[MAXE];

int head[MAXN], minhead[MAXN], minmap[MAXN];

int ad, edge2, edge1, top, times, mintotal;

int time[MAXN][2], d[MAXN], start[MAXN], strack[MAXN], In_strack[MAXN], vis[MAXN], dfn[MAXN], low[MAXN];

int ru[MAXN], belong[MAXN], colour[MAXN], tp[MAXN];

 

void In_edges(int x, int y){

    edges[ad].st = x;

    edges[ad].to = y;

    edges[ad].next = head[x];

    head[x] = ad ++;

}

 

void Built_Map(int n){

    ad = 0;

    memset(head, -1, sizeof(head));

    for(int i = 0; i < n; i ++)

        for(int j = i + 1; j < n; j ++){

            if((time[i][0] <= time[j][0] && time[i][0] + d[i] > time[j][0]) || (time[j][0] <= time[i][0] && time[j][0] + d[j] > time[i][0])){

                In_edges(i * 2, j * 2 + 1);

                In_edges(j * 2, i * 2 + 1);

            }

            if((time[i][0] <= time[j][1] && time[i][0] + d[i] > time[j][1]) || (time[j][1] <= time[i][0] && time[j][1] + d[j] > time[i][0])){

                In_edges(i * 2, j * 2);

                In_edges(j * 2 + 1, i * 2 + 1);

            }

            if((time[i][1] <= time[j][0] && time[i][1] + d[i] > time[j][0]) || (time[j][0] <= time[i][1] && time[j][0] + d[j] > time[i][1])){

                In_edges(i * 2 + 1, j * 2 + 1);

                In_edges(j * 2, i * 2);

            }

            if((time[i][1] <= time[j][1] && time[i][1] + d[i] > time[j][1]) || (time[j][1] <= time[i][1] && time[j][1] + d[j] > time[i][1])){

                In_edges(i * 2 + 1, j * 2);

                In_edges(j * 2 + 1, i * 2);

            }

        }

    edge1 = ad;

}

 

void dfs(int u){

    int p;

    low[u] = dfn[u] = times ++;

    vis[u] = 1;

    In_strack[u] = 1;

    strack[ ++ top] = u;

    for(p = head[u]; ~p; p = edges[p].next)

        if(!vis[edges[p].to]){

            dfs(edges[p].to);

            low[u] = low[u] < low[edges[p].to] ? low[u] : low[edges[p].to];

        }

        else

            if(In_strack[edges[p].to])

                low[u] = low[u] < low[edges[p].to] ? low[u] : low[edges[p].to];

    if(low[u] == dfn[u]){

        incde[ad].to = u; incde[ad].st = mintotal;

        incde[ad].next = minhead[mintotal]; minhead[mintotal] = ad ++;

        In_strack[u] = 0;

        belong[u] = mintotal;

        while((p = strack[top--]) != u){

            incde[ad].to = p; incde[ad].st = mintotal;

            incde[ad].next = minhead[mintotal]; minhead[mintotal] = ad ++;;

            In_strack[p] = 0;

            belong[p] = mintotal;

        }

        mintotal ++;

    }

}

 

void Tarjan(int n){

    int i;

    times = ad = 0, top = -1, mintotal = 0;

    memset(vis, 0, sizeof(vis));

    memset(minhead, -1, sizeof(minhead));

    dfn[0] = 0;

    for(i = 0; i < n * 2; i ++)

        if(!vis[i]) dfs(i);

}

 

void built_min_map(int ed){

    memset(minmap, -1, sizeof(minmap));

    memset(ru, 0, sizeof(ru));

    edge2 = 0;

    for(int i = 0; i < ed; i ++)

        if(belong[edges[i].st] != belong[edges[i].to]){

            minedges[edge2].to = belong[edges[i].st];

            minedges[edge2].next = minmap[belong[edges[i].to]];

            minmap[belong[edges[i].to]] = edge2 ++;

            ru[belong[edges[i].st]] ++;

        }

}

 

void tuopu(int mintotal){

    int i,j, count = 0;

    top = -1;

    for(i = 0; i < mintotal; i ++ )

        if(!ru[i])

            strack[++top] = i, tp[count ++] = i;

    while(top >= 0){

        j = strack[top--];

        for(i = minmap[j]; ~i; i = minedges[i].next){

            ru[minedges[i].to] --;

            if(ru[minedges[i].to] == 0){

                strack[++top] = minedges[i].to;

                tp[count++] = minedges[i].to;

            }

        }

    }

}

 

int Getans(int n){

    int i, p;

    for(i = 0; i < n; i ++)

        if(low[i * 2] == low[i * 2 + 1]) return 0;

    built_min_map(edge1);

    tuopu(mintotal);

    memset(colour, -1, sizeof(colour));

    for(i = 0; i < mintotal; i ++)

        if(colour[i] == -1){

            colour[i] = 1;

            for(p = minhead[i]; ~p; p = incde[p].next)

                colour[belong[incde[p].to ^ 1]] = 0;

        }

    for(i = 0; i < n; i ++)

        if(colour[belong[i * 2]])

            start[i] = time[i][0];

        else

            start[i] = time[i][1];

}

 

int main(){

    int n, i, x, y, z, w;

    while(~scanf("%d", &n)){

        for(i = 0; i < n; i ++){

            scanf("%d:%d %d:%d %d", &x, &y, &z, &w, &d[i]);

            time[i][0] = x * 60 + y;

            time[i][1] = z * 60 + w - d[i];

        }

        Built_Map(n);

        Tarjan(n);

        if(Getans(n)){

            printf("YES\n");

            for(i = 0; i < n; i ++)

                printf("%.2d:%.2d %.2d:%.2d\n", start[i] / 60, start[i] % 60, (start[i] + d[i]) / 60, (start[i] + d[i]) % 60);

        }

        else printf("NO\n");

    }

    return 0;

}