leetcode802找到最终的安全状态

题目描述

终端节点：出度为0的节点
安全节点：从该节点开始的所有路径都通向终端节点。
要求：
找出所有的安全节点并采用升序排序。

思路1 强连通分量

我当时刚好学了强连通分量，就直接使用了。
如果任何一个点他所在的强连通分量有多个点，或者他的子树中存在多个点的强连通分量，则他不是一个安全节点。

class Solution {
public:

stack<int> s;
vector<int> sccnum,dfn,low,isres,vis,nocir;
int dfscnt = 0,scccnt = 0;
    void tarjan(int u, vector<vector<int>>&graph)
    {
        dfn[u]= low[u] = ++dfscnt;
        s.push(u);
        vis[u] = true;
       

        for(int i = 0; i < graph[u].size(); i++)
        {
            int to = graph[u][i];
          
            
            if(!dfn[to])
            {
                tarjan(to, graph);
                low[u] = min(low[u], low[to]);
            }
            else if(!sccnum[to])
            {
                low[u] = min(low[u], dfn[to]);
                nocir[u] = 0;
            }
            nocir[u] = nocir[u]&& nocir[to];
        } 
       

        
        if(low[u] == dfn[u])
        {
            scccnt++;
            while(true)
            {
                int x = s.top();
                s.pop();
                sccnum[x] = scccnt;
                
                if(x== u)
                    break;
            }
        }
        if( nocir[u] )
        {
            isres[u] = 1;
        }

    }
    vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
        vector<int> res;
        int n = graph.size(); 
        sccnum.resize(n+1,0);
        vis.resize(n+1,0);
        dfn.resize(n+1,0);
        low.resize(n+1,0);
        isres.resize(n+1,0);
        nocir.resize(n+1,1);
        
        for(int i = 0; i <graph.size();i++)
        {
            if(!vis[i])
            {
                tarjan(i,graph);
            }
        }
        for(int i = 0;i <graph.size(); i++)
        {
            if(isres[i])
            {
                res.emplace_back(i);
            }
        }
        return res;
    }
};

回顾这个代码，感觉只要判断每个点的子树上有没有环就可以了，当然还要借助强连通分量的tarjan来分子树。

思路2 反图上的拓扑排序

性质1 ：出度为0的点为终端节点。
性质2 ：一个节点的所有出边的终点都是安全的，则他也是安全的。

拓扑排序可以将一个点的所有无环点都找到。
对于反向图，终端节点的所有无环点都是安全节点。

我们用拓扑排序将终端节点的所有无环点找到即可。

class Solution
{
	public:
	vector<int> eventualSafeNodes(vector<vector<int>>& graph)
	{
		int n = graph.size();
		vector<vector<int>> rg;
		vector<int> inDeg(n);
		for(int x = 0; x <n; x++)
		{
			for(int y:grap[x])
			{
				rg[y].push_back(x);
			}
			inDeg[x] = graph[x].size();
		}
		queue<int> q;
		for(int i = 0l; i <n; i++)
		{
			if(inDeg[i] == 0)
			{
				q.push(i);
			}
		}

		while(!q.empty())
		{
			int y = q.front();
			q.pop();
			for(int x:rg[y])
			{
				if(--inDeg[x] == 0)
				{
					q.push(x);
				}
			}
		}
		vector<int> ans;
		for(int i = 0; i <n; i++)
		{
			if(inDeg[i] == 0)
			{
				ans.push_back(i);
			}
		}
		return ans;

	}
}

注意拓扑排序不仅能够给出优先级顺序，而且能够简单的判断环。
拓扑排序得到的点都是无环点。