POJ3683 Priest John's Busiest Day 【2-sat】

题目

John is the only priest in his town. September 1st is the John's busiest day in a year because there is an old legend in the town that the couple who get married on that day will be forever blessed by the God of Love. This year N couples plan to get married on the blessed day. The i-th couple plan to hold their wedding from time Si to time Ti. According to the traditions in the town, there must be a special ceremony on which the couple stand before the priest and accept blessings. The i-th couple need Di minutes to finish this ceremony. Moreover, this ceremony must be either at the beginning or the ending of the wedding (i.e. it must be either from Si to Si + Di, or from Ti - Di to Ti). Could you tell John how to arrange his schedule so that he can present at every special ceremonies of the weddings.

Note that John can not be present at two weddings simultaneously.

输入格式

The first line contains a integer N ( 1 ≤ N ≤ 1000).
The next N lines contain the Si, Ti and Di. Si and Ti are in the format of hh:mm.

输出格式

The first line of output contains "YES" or "NO" indicating whether John can be present at every special ceremony. If it is "YES", output another N lines describing the staring time and finishing time of all the ceremonies.

输入样例

2
08:00 09:00 30
08:15 09:00 20

输出样例

YES
08:00 08:30
08:40 09:00

题解

2-sat + 输出方案
对于每一个婚礼，有两个时间段可以选择，对应两个点
对于每两个婚礼，如果其中两个时间段t1和t1'相交，那么这两个时间段冲突，连边t1->t2'，t1'->t2

跑一遍tarjan缩点，若存在婚礼的两个时间段处于同一个强联通分量，则无解

否则输出方案：
QAQ蒟蒻知道有两种方法：
①拓扑排序
将缩完点后的图反向建边，按拓扑顺序访问，每访问到一个没有染色的点，就染为第一种颜色，并令其对应点【对称的那个强两桶分量缩的点】及对应点延伸出去能到达的所有点染另一种颜色【一次dfs】

②按Scc编号
很神奇的方法，所有点对中，输出Scc编号较小的那个即可。。。【比拓扑简单多了 → →】
证明【假的】：tarjan缩点时拓扑序大的先缩，则编号较小，然而我们需要选择拓扑序大的，因为拓扑大的不会推出拓扑序小的

选择一个喜欢方法就可以A了> <

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#define LL long long int
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)
#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");
using namespace std;
const int maxn = 2005,maxm = 2000005,INF = 1000000000;
inline int read(){
    int out = 0,flag = 1; char c = getchar();
    while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}
    while (c >= 48 && c <= 57) {out = (out << 3) + (out << 1) + c - '0'; c = getchar();}
    return out * flag;
}
int n,m,h[maxn],ne = 1;
struct EDGE{int to,nxt;}ed[maxm];
inline void build(int u,int v){
    ed[ne] = (EDGE){v,h[u]}; h[u] = ne++;
}
int dfn[maxn],low[maxn],Scc[maxn],scci = 0,cnt = 0,st[maxn],top = 0;
void dfs(int u){
    dfn[u] = low[u] = ++cnt;
    st[++top] = u;
    Redge(u)
        if (!dfn[to = ed[k].to])
            dfs(to),low[u] = min(low[u],low[to]);
        else if (!Scc[to]) low[u] = min(low[u],dfn[to]);
    if (dfn[u] == low[u]){
        scci++;
        do{
            Scc[st[top]] = scci;
        }while (st[top--] != u);
    }
}
int B[maxn],T[maxn],ans[maxn],inde[maxn];
void print(int x){
    printf("%02d:%02d ",x / 60,x % 60);
}
bool judge(int u,int v){
    if (T[u] <= B[v] || B[u] >= T[v]) return false;
    return true;
}
int main(){
    n = read(); int a,b,t;
    for (int i = 1; i <= n; i++){
        a = read(); b = read(); B[2 * i - 1] = a * 60 + b;
        a = read(); b = read(); T[2 * i] = a * 60 + b;
        t = read();
        T[2 * i - 1] = B[2 * i - 1] + t;
        B[2 * i] = T[2 * i] - t;
    }
    for (int i = 1; i <= n; i++)
        for (int j = i + 1; j <= n; j++){
                if (judge(2 * i,2 * j))
                    build(2 * i,2 * j - 1),build(2 * j,2 * i - 1);
                if (judge(2 * i,2 * j - 1))
                    build(2 * i,2 * j),build(2 * j - 1,2 * i - 1);
                if (judge(2 * i - 1,2 * j))
                    build(2 * i - 1,2 * j - 1),build(2 * j,2 * i);
                if (judge(2 * i - 1,2 * j - 1))
                    build(2 * i - 1,2 * j),build(2 * j - 1,2 * i);
            }
    for (int i = 1; i <= (n << 1); i++) if (!dfn[i]) dfs(i);
    bool flag = true;
    for (int i = 1; i <= n; i++) if (Scc[2 * i] == Scc[2 * i - 1]){
        flag = false; break;
    }
    if (!flag) puts("NO");
    else {
        puts("YES");
        for (int i = 1; i <= n; i++)
            if (Scc[2 * i] < Scc[2 * i - 1])
                print(B[2 * i]),print(T[2 * i]),puts("");
            else print(B[2 * i - 1]),print(T[2 * i - 1]),puts("");
    }
    return 0;
}

转载于:https://www.cnblogs.com/Mychael/p/8283819.html