[HDOJ6165] FFF at Valentine（强联通分量，缩点，拓扑排序）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6165

题意：问一个有向图中是否有任意两点可以到达。

读错题就彻底输了，读成判断是否有任意条路，使得经过所有点并且每条边最多走一次。

强联通缩点，然后维护拓扑序，假如拓扑序中有两个以上点入度为0，那么这几个点之间就不能互相到达了。

#include <bits/stdc++.h>
using namespace std;

namespace fastIO {
    #define BUF_SIZE 20
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if (p1 == pend) {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if (pend == p1) {
                IOerror = 1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }
    inline void read(int &x) {
        char ch;
        while (blank(ch = nc()));
        if (IOerror)
            return;
        for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
    }
    #undef BUF_SIZE
};

const int maxn = 1010;
const int maxm = 6060;
typedef struct Edge {
    int u, v, next;
    Edge() { next = -1; }
}Edge;
int n, m, cnt;
int head[maxn], ecnt;
Edge edge[maxm];
int bcnt, dindex;
int dfn[maxn], low[maxn];
int stk[maxn], top;
int belong[maxn];
int in[maxn];
bool instk[maxn];
bool vis[maxn];
int f[maxn][maxn];

void init() {
    memset(edge, 0, sizeof(edge));
    memset(head, -1, sizeof(head));
    memset(instk, 0, sizeof(instk));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(belong, 0, sizeof(belong));
    memset(in, 0, sizeof(in));
    ecnt = top = bcnt = dindex = 0;
}

void adde(int uu, int vv) {
    edge[ecnt].u = uu;
    edge[ecnt].v = vv;
    edge[ecnt].next = head[uu];
    head[uu] = ecnt++;
}

void tarjan(int u) {
    int v = u;
    dfn[u] = low[u] = ++dindex;
    stk[++top] = u;
    instk[u] = 1;
    for(int i = head[u]; ~i; i=edge[i].next) {
        v = edge[i].v;
        if(!dfn[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(instk[v]) low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u]) {
        bcnt++;
        do {
            v = stk[top--];
            instk[v] = 0;
            belong[v] = bcnt;
        } while(v != u);
    }
}

queue<int> q;

int check() {
    while(!q.empty()) {
        int u = q.front(); q.pop();
        int tot = 0;
        for(int v = 1; v <= bcnt; v++) {
            if(!f[u][v]) continue;
            in[v]--;
            if(!in[v]) {
                tot++;
                q.push(v);
            }
        }
        if(tot >= 2) return puts("Light my fire!");
    }
    return puts("I love you my love and our love save us!");
}

signed main() {
    // freopen("in", "r", stdin);
    using namespace fastIO;
    int T, u, v;
    read(T);
    while(T--) {
        read(n); read(m);
        init();
        memset(f, 0, sizeof(f));
        for(int i = 0; i < m; i++) {
            read(u); read(v);
            adde(u, v);
        }
        for(int i = 1; i <= n; i++) {
            if(!dfn[i]) tarjan(i);
        }
        for(int i = 0; i < ecnt; i++) {
            u = belong[edge[i].u], v = belong[edge[i].v];
            if(u == v) continue;
            if(f[u][v]) continue;
            f[u][v] = 1; in[v]++;
        }
        while(!q.empty()) q.pop();
        int cnt = 0;
        for(int i = 1; i <= bcnt; i++) {
            if(in[i] == 0) {
                q.push(i);
                cnt++;
            }
        }
        (cnt == 1) ? check() : puts("Light my fire!");
    }
    return 0;
}