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

最新推荐文章于 2020-01-09 17:13:19 发布

weixin_30788619

最新推荐文章于 2020-01-09 17:13:19 发布

阅读量78

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Mychael/p/8283819.html

本文介绍了一个关于2-SAT问题的应用实例——如何合理安排神父参与镇上多场婚礼的时间表，确保每场婚礼都有特殊仪式。通过构建图模型，使用Tarjan算法寻找强连通分量来判断是否可以完成所有婚礼的特殊仪式，并提供了两种输出解决方案的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

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