Codeforces Round #731 (Div. 3) G

G - How Many Paths?

本题的题面意思大概是：
如果一个点不可以从1开始到达那么输出0
如果一个点可以从1到达且路径有且仅有一条输出1
如果可以从1到达且有多条路径则输出2
如果有无数条路径到达则输出-1

本题需要注意的是存在自环

大概思路肯定是优先找-1，因为-1其实很好找，就是找环，找环（强连通块）的方法
有几种：拓扑排序，tarjan，拓扑排序应该也是可以做的吧，我看很多人都是用
tarjan做的。找到环中的这些点后，由这些点扩张出来的点一定也是-1。然后就可
以开始找1，2了，从1开始dfs,找完后，我们还要继续找，因为以2开始的点，之后
的所有不是-1的点都可以变成2.

#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
#define ll long long int
#define ms(a, b) memset(a, b, sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define endl "\n"
#define bug cout << "----acac----" << endl;
#define IOS ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
using namespace std;
const int maxn = 4e5 + 10;
const int maxm = 2e4 + 50;
const double eps = 1e-8;
const ll inf = 0x3f3f3f3f;
const ll lnf = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1);
const ll mod = 1e9 + 7;
int n, m;
vector<int> ve[maxn];
int low[maxn], dfn[maxn], ans[maxn], in[maxn];
int vis[maxn];
stack<int> st;
int cnt;

void init()
{
    while(!st.empty())
        st.pop();
    cnt = 0;
    for (int i = 1; i <= n;i++)
    {
        low[i] = dfn[i] = ans[i] = in[i] = vis[i] = 0;
        ve[i].clear();
    }
}

void tarjan(int u) {

	low[u] = dfn[u] = ++ cnt;
	st.push(u);
	in[u] = 1;
	int sz = ve[u].size();
	for(int i = 0; i < sz; i ++) {
		int v = ve[u][i];
		if(v == u)  ans[u] = -1;
		if(!dfn[v]) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		} else if(in[v]) {
			low[u] = min(low[u], dfn[v]);
		}
	}
	if(dfn[u] == low[u]) {
		if(st.top() == u) {
			in[st.top()] = 0; 
			st.pop();
		} else {
			int v;
			do {
				v = st.top();
				st.pop();
				ans[v] = -1; 
				in[v] = 0; 
			} while(u != v);
		}
	}
}

void solve(int child,int fa)
{
    if(fa==-1)
    {
        ans[child] = -1;
    }
    if(ans[child]==-1)
    {
        return;
    }
    ans[child] = min(ans[child] + fa, 2);
}
void dfs(int x)
{
    if(vis[x])
        return;
    vis[x] = 1;
    for (auto u:ve[x])
    {
        solve(u, ans[x]);
        dfs(u);
    }
}

void dfs2(int x)
{
    for (auto u:ve[x])
    {
        if(ans[u]==1)
        {
            ans[u] = 2;
            dfs2(u);
        }
    }
}
int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        cin >> n >> m;
        init();
        for (int i = 1; i <= m;i++)
        {
            int u, v;
            cin >> u >> v;
            ve[u].push_back(v);
        }
        tarjan(1);
        solve(1, 1);
        for (int i = 1; i <= n;i++)
        {
            if(ans[i] == -1)
            {
                dfs(i);
            }
        }
        dfs(1);
        for (int i = 1; i <= n;i++)
        {
            if (ans[i] == 2)
            {
                dfs2(i);
            }
        }
        for (int i = 1; i <= n;i++)
            cout << ans[i] << " ";
        cout << endl;
    }
    return 0;
}