poj3683（2-SAT）

题目大概意思为有一个神父，N场婚礼，给每场婚礼的开始时间 S ，结束时间 T ，和持续时间 D ，神父可以在开始 S 到 S + D 时，或者结束 T - D 到 T 时，两选一时间段在场，神父从不同婚礼上穿梭的时间忽略不计，现在问神父是否能在所有婚礼上出现，若是可以输出所有婚礼的神父在场时间段

每次婚礼都有两种可选择，相当于布尔真假，且有一定限制条件，妥妥的2-SAT

连边只要搞清楚 2-SAT 的原理即可，我们连边（A，B），就相当于选 A 就必须选 B，因此判断假如两场婚礼 a ， b ，初始为 A ，末尾为 B ，如果 a_A 和 b_B 有交集，则相当于选了 a_A 就必须选 b_A，选 b_B 就必须选 a_B，把这个弄清楚就可以开始判断各个范围之间是否有交集，构造图

最后套个2-SAT模板即可
（基础 2-SAT 题无坑无难点）

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string.h>
using namespace std;
struct ddd
{
    int start, over, spend;
}data[1005];
vector<int> edge[2005];
vector<int> redge[2005];
vector<int> flag;
int used[10005];
int kind[10005];
int N;
void dfs(int v)
{
    used[v] = true;
    for(int i = 0; i < edge[v].size(); i++)
    {
        if(!used[edge[v][i]])
        {
            dfs(edge[v][i]);
        }
    }
    flag.push_back(v);
}
void rdfs(int v, int k)
{
    used[v] = true;
    kind[v] = k;
    for(int i = 0; i < redge[v].size(); i++)
    {
        if(!used[redge[v][i]])
        {
            rdfs(redge[v][i], k);
        }
    }
}
int main()
{
    scanf("%d", &N);
    for(int i = 0; i < N; i++)
    {
        int hour, minutes;
        scanf("%d:%d", &hour, &minutes);
        data[i].start = hour * 60 + minutes;
        scanf("%d:%d", &hour, &minutes);
        data[i].over = hour * 60 + minutes;
        scanf("%d", &data[i].spend);
    }
    for(int i = 0; i < N; i++)
    {
        for(int j = i + 1; j < N; j++)
        {
            if(min(data[i].start + data[i].spend, data[j].start + data[j].spend) > max(data[i].start, data[j].start))
            {
                edge[i].push_back(j + N);
                edge[j].push_back(i + N);
                redge[j + N].push_back(i);
                redge[i + N].push_back(j);
            }
            if(min(data[i].start + data[i].spend, data[j].over) > max(data[i].start, data[j].over - data[j].spend))
            {
                edge[i].push_back(j);
                edge[j+N].push_back(i+N);
                redge[j].push_back(i);
                redge[i+N].push_back((j+N));
            }
            if(min(data[i].over, data[j].start + data[j].spend) > max(data[i].over - data[i].spend, data[j].start))
            {
                edge[i+N].push_back(j+N);
                edge[j].push_back(i);
                redge[j+N].push_back(i+N);
                redge[i].push_back(j);
            }
            if(min(data[i].over, data[j].over) > max(data[i].over - data[i].spend, data[j].over - data[j].spend))
            {
                edge[i+N].push_back(j);
                edge[j+N].push_back(i);
                redge[j].push_back(i+N);
                redge[i].push_back(j+N);
            }
        }
    }
    memset(used, false, sizeof(used));
    for(int i = 0; i < N; i++)
    {
        if(!used[i]) dfs(i);
    }
    memset(used, false, sizeof(used));
    int num = 0;
    for(int i = flag.size() - 1; i >= 0; i--)
    {
        if(!used[flag[i]]) rdfs(flag[i], num++);
    }
    for(int i = 0; i < N; i++)
    {
        if(kind[i] == kind[i + N])
        {
            printf("NO\n");
            return 0;
        }
    }
    printf("YES\n");
    for(int i = 0; i < N; i++)
    {
        if(kind[i] > kind[i + N])
        {
            printf("%02d:%02d %02d:%02d\n", data[i].start / 60, data[i].start % 60, (data[i].start + data[i].spend) / 60, (data[i].start + data[i].spend) % 60);
        }
        else
        {
            printf("%02d:%02d %02d:%02d\n", (data[i].over - data[i].spend) / 60, (data[i].over - data[i].spend) % 60, data[i].over / 60, data[i].over % 60);
        }
    }
}