210. 课程表 II；1162. 地图分析；380. 常数时间插入、删除和获取随机元素

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。

可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。

示例 1:

输入: 2, [[1,0]]
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

示例 2:

输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。

说明:

输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。

提示:

   这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
   通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。

   拓扑排序也可以通过 BFS 完成。

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>>GList(numCourses);//1
        vector<int>inDegree(numCourses,0);//1
        vector<int>res;
        for(auto &i:prerequisites)
            GList[i[1]].push_back(i[0]),++inDegree[i[0]];
        queue<int>q;
        for(int i=0;i<inDegree.size();++i)
            if(inDegree[i]==0)q.push(i);
        while(q.size()){
            int qs=q.size();
            while(qs--){
                auto cur=q.front();
                q.pop();
                res.push_back(cur);//2
                --numCourses;//2
                for(auto &i:GList[cur])
                    if(--inDegree[i]==0)q.push(i);//1
            }
        }
        return numCourses==0?res:vector<int>{};//2
    }
};

class Solution {//bfs 超时
    vector<vector<bool>>vis;
    vector<int>dx={1,0,-1,0};
    vector<int>dy={0,1,0,-1};
    int res;
public:
    int maxDistance(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size();        
        res=-1;
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
                if(grid[i][j]==0){
                    int tmp=helper(grid,i,j);
                    res=max(res,tmp);
                }          
        return res;
    }
    int helper(vector<vector<int>> &grid,int x,int y){
        int m=grid.size(),n=grid[0].size();
        vis.clear();//1
        vis.resize(m,vector<bool>(n,false));//
        queue<pair<int,int>>q;
        q.push(make_pair(x,y));
        int cnt=0;
        while(q.size()){
            int qs=q.size();
            ++cnt;
            while(qs--){
                auto [i,j]=q.front();
                q.pop();                
                for(int k=0;k<4;++k){
                    int ii=i+dx[k],jj=j+dy[k];
                    if(ii<0||ii==m||jj<0||jj==n||vis[ii][jj])continue;
                    vis[ii][jj]=true;
                    q.push(make_pair(ii,jj));
                    if(grid[ii][jj])return cnt;                    
                }
            }
        }
        return -1;
    }

};

设计一个支持在平均时间复杂度 O(1) 下，执行以下操作的数据结构。

   insert(val)：当元素 val 不存在时，向集合中插入该项。
   remove(val)：元素 val 存在时，从集合中移除该项。
   getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。

示例 :

// 初始化一个空的集合。
RandomizedSet randomSet = new RandomizedSet();

// 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomSet.insert(1);

// 返回 false ，表示集合中不存在 2 。
randomSet.remove(2);

// 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomSet.insert(2);

// getRandom 应随机返回 1 或 2 。
randomSet.getRandom();

// 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
randomSet.remove(1);

// 2 已在集合中，所以返回 false 。
randomSet.insert(2);

// 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
randomSet.getRandom();

class RandomizedSet {
    unordered_map<int,int>m;//1
    vector<int>v;//1
public:
    RandomizedSet() {
    }    
    bool insert(int val) {
        if(m.count(val))return false;
        v.push_back(val);
        m[val]=v.size()-1;
        return true;
    }    
    bool remove(int val) {
        if(!m.count(val))return false;
        int last=v[v.size()-1];//2
        swap(m[val],m[last]);//2
        swap(v[m[val]],v[m[last]]);//2
        m.erase(val);//2
        v.pop_back();//2    
        return true;
    }    
    int getRandom() {
        return v[rand()%v.size()];
    }
};