Poj--3683（2-SAT，拓扑排序，输出解）

2014-10-21 15:12:37

思路：自己断断续续搞了差不多两个小时吧，把这题A掉，2-sat也学的差不多了。

　　做法就是把每个婚礼看成连个点，i 和 i' 分别表示牧师在婚礼开始时祝福、在婚礼结束时祝福。于是我们就能获得每个婚礼的两个祝福时间段。两层循环扫一遍每两个婚礼，判断他们两个时间段是否重合，如果重合，则建“必须”边。（如：A和B’时间段有重合部分（即A在婚礼开始祝福和B在婚礼结束祝福的两个时间段有重合），那么建边：A->B,B'->A'），由于每个婚礼自己会和自己重合，所以要判断一下。

/*************************************************************************
    > File Name: 3683.cpp
    > Author: Nature
    > Mail: 564374850@qq.com 
    > Created Time: Mon 20 Oct 2014 09:57:49 PM CST
************************************************************************/

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define lp (p << 1)
#define rp (p << 1|1)
#define getmid(l,r) (l + (r - l) / 2)
#define MP(a,b) make_pair(a,b)
typedef long long ll;
const int INF = 1 << 30;
const int maxn = 2010;

int N;
int first[maxn],next[maxn * maxn],ver[maxn * maxn],ecnt;
int f1[maxn],n1[maxn * maxn],v1[maxn * maxn],e1;
int low[maxn],dfn[maxn],sc[maxn],asc[maxn],scnt,tot;
int din[maxn],col[maxn];
stack<int> S;
queue<int> Q;

struct time{
    int s,t;
    int sh,sm,th,tm;
    int sd,td;
}t[maxn];

void Add_edge(int u,int v){
    next[++ecnt] = first[u];
    ver[ecnt] = v;
    first[u] = ecnt;
}

void Build_graph(){
    for(int i = 0; i < N; ++i){
        for(int j = 0; j < N; ++j){
            if(i == j) continue;
            if(min(t[i].sd,t[j].sd) - max(t[i].s,t[j].s) > 0){
                Add_edge(i * 2,j * 2 + 1);
                Add_edge(j * 2,i * 2 + 1);
            }
            if(min(t[i].t,t[j].t) - max(t[i].td,t[j].td) > 0){
                Add_edge(i * 2 + 1,j * 2);
                Add_edge(j * 2 + 1,i * 2);
            }
            if(min(t[i].sd,t[j].t) - max(t[i].s,t[j].td) > 0){
                Add_edge(i * 2,j * 2);
                Add_edge(j * 2 + 1,i * 2 + 1);
            }
            if(min(t[i].t,t[j].sd) - max(t[i].td,t[j].s) > 0){
                Add_edge(i * 2 + 1,j * 2 + 1);
                Add_edge(j * 2,i * 2);
            }
        }
    }
}

void Dfs(int p){
    dfn[p] = low[p] = ++tot;
    S.push(p);
    for(int i = first[p]; i != -1; i = next[i]){
        int v = ver[i];
        if(!dfn[v]){
            Dfs(v);
            low[p] = min(low[p],low[v]);
        }
        else if(!sc[v]){
            low[p] = min(low[p],dfn[v]);
        }
    }
    if(low[p] == dfn[p]){
        ++scnt;
        while(1){
            int x = S.top();
            S.pop();
            sc[x] = scnt;
            if(x == p) break;
        }
    }
}

void Tarjan(){
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(sc,0,sizeof(sc));
    memset(asc,0,sizeof(asc));
    scnt = tot = 0;
    while(!S.empty()) S.pop();
    for(int i = 0; i < 2 * N; ++i)
        if(!dfn[i]) Dfs(i);
}

void Add_edge1(int u,int v){
    n1[++e1] = f1[u];
    v1[e1] = v;
    f1[u] = e1;
}

void Build_dag(){
    for(int i = 0; i < 2 * N; ++i){
        for(int j = f1[i]; j != -1; j = next[j]){
            int v = ver[j];
            if(sc[i] != sc[v]){
                Add_edge1(sc[v],sc[i]);
                din[sc[i]]++;
            }
        }
    }
}

void Toposort(){
    while(!Q.empty()) Q.pop();
    for(int i = 1; i <= scnt; ++i)
        if(din[i] == 0) Q.push(i);
    while(!Q.empty()){
        int x = Q.front();
        Q.pop();
        if(!col[x]){
            col[x] = 1;
            col[asc[x]] = 2;
        }
        for(int i = f1[x]; i != -1; i = n1[i]){
            int v = v1[i];
            din[v]--;
            if(din[v] == 0) Q.push(v);
        }
    }
}        

void Init(){
    memset(first,-1,sizeof(first));
    memset(f1,-1,sizeof(f1));
    memset(din,0,sizeof(din));
    memset(col,0,sizeof(col));
    ecnt = 0;
    e1 = 0;
}

int main(){
    int d;
    Init();
    scanf("%d",&N);
    for(int i = 0; i < N; ++i){
        scanf("%d:%d %d:%d %d",&t[i].sh,&t[i].sm,&t[i].th,&t[i].tm,&d);
        t[i].s = t[i].sh * 60 + t[i].sm;
        t[i].t = t[i].th * 60 + t[i].tm;
        t[i].sd = t[i].s + d;
        t[i].td = t[i].t - d;
    }
    Build_graph();
    Tarjan();
    Build_dag();
    int flag = 1;
    for(int i = 0; i < 2 * N; i += 2){
        if(sc[i] == sc[i + 1]){
            flag = 0;
            break;
        }
        asc[sc[i]] = sc[i + 1];
        asc[sc[i + 1]] = sc[i];
    }
    if(flag){
        printf("YES\n");
        Toposort();
        int f;
        for(int i = 0; i < 2 * N; i += 2){
            if(col[sc[i]] == 1){
                printf("%02d:%02d %02d:%02d\n",t[i/2].sh,t[i/2].sm,t[i/2].sd/60,t[i/2].sd%60);
            }
            else{
                printf("%02d:%02d %02d:%02d\n",t[i/2].td/60,t[i/2].td%60,t[i/2].th,t[i/2].tm);
            }
        }
    }
    else printf("NO\n");
    return 0;
}