目录
一，无向图
HDU 1272 小希的迷宫
力扣 1559. 二维网格图中探测环
二，有向图
力扣 207. 课程表
一，无向图
判断一个无向图是否有环，可以用并查集，在merge2个节点时，如果发现2个节点已经是同一个祖先，则表示已经形成环。
HDU 1272 小希的迷宫
Description
上次Gardon的迷宫城堡小希玩了很久（见Problem B），现在她也想设计一个迷宫让Gardon来走。但是她设计迷宫的思路不一样，首先她认为所有的通道都应该是双向连通的，就是说如果有一个通道连通了房间A和B，那么既可以通过它从房间A走到房间B，也可以通过它从房间B走到房间A，为了提高难度，小希希望任意两个房间有且仅有一条路径可以相通（除非走了回头路）。小希现在把她的设计图给你，让你帮忙判断她的设计图是否符合她的设计思路。比如下面的例子，前两个是符合条件的，但是最后一个却有两种方法从5到达8。
Input
输入包含多组数据，每组数据是一个以0 0结尾的整数对列表，表示了一条通道连接的两个房间的编号。房间的编号至少为1，且不超过100000。每两组数据之间有一个空行。
整个文件以两个-1结尾。
Output
对于输入的每一组数据，输出仅包括一行。如果该迷宫符合小希的思路，那么输出"Yes"，否则输出"No"。
Sample Input
6 8 5 3 5 2 6 4
5 6 0 0
8 1 7 3 6 2 8 9 7 5
7 4 7 8 7 6 0 0
3 8 6 8 6 4
5 3 5 6 5 2 0 0
-1 -1
Sample Output
Yes
Yes
No
代码：
#include<iostream>
#include<cstring>
using namespace std;
int fa[100001];
int num[100001];
int sum;
int find(int x) //找祖先
{
if (fa[x] == x)return x;
return fa[x] = find(fa[x]);
}
int main()
{
ios_base::sync_with_stdio(false);
int m, n,max1, max2;
while (1)
{
bool flag = true;
sum = 0, max1 = 0, max2 = 0;
while (cin >> m >> n)
{
if (m == 0 && n == 0)break;
if (m == -1 && n == -1)return 0;
if (max2 < m) max2 = m;
if (max2 < n) max2 = n;
for (int i = max1 + 1; i <= max2; i++)fa[i] = -1;
max1 = max2;
if (fa[m] >= 0 && fa[n] >= 0)
{
if (find(m) == find(n))flag = false;
else
{
num[find(n)] += num[find(m)];
fa[find(m)] = find(n);
}
}
else
{
if (fa[m] >= 0)
{
fa[n] = m;
num[find(m)]++;
}
else if (fa[n] >= 0)
{
fa[m] = n;
num[find(n)]++;
}
else
{
fa[m] = m;
fa[n] = m;
num[m] = 2;
sum++;
}
sum++;
}
}
if (flag && num[find(max2)] == sum)cout << "Yes";
else cout << "No";
cout << endl;
}
return 0;
}
力扣 1559. 二维网格图中探测环
给你一个二维字符网格数组 grid ，大小为 m x n ，你需要检查 grid 中是否存在 相同值 形成的环。
一个环是一条开始和结束于同一个格子的长度 大于等于 4 的路径。对于一个给定的格子，你可以移动到它上、下、左、右四个方向相邻的格子之一，可以移动的前提是这两个格子有 相同的值 。
同时，你也不能回到上一次移动时所在的格子。比方说，环 (1, 1) -> (1, 2) -> (1, 1) 是不合法的，因为从 (1, 2) 移动到 (1, 1) 回到了上一次移动时的格子。
如果 grid 中有相同值形成的环，请你返回 true ，否则返回 false 。
示例 1：
输入：grid = [["a","a","a","a"],["a","b","b","a"],["a","b","b","a"],["a","a","a","a"]]
输出：true
解释：如下图所示，有 2 个用不同颜色标出来的环：
示例 2：
输入：grid = [["c","c","c","a"],["c","d","c","c"],["c","c","e","c"],["f","c","c","c"]]
输出：true
解释：如下图所示，只有高亮所示的一个合法环：
示例 3：
输入：grid = [["a","b","b"],["b","z","b"],["b","b","a"]]
输出：false
提示：
m == grid.length
n == grid[i].length
1 <= m <= 500
1 <= n <= 500
grid 只包含小写英文字母。
int fa[250005];
int find(int x) //找祖先
{
if (fa[x] == x)return x;
return fa[x] = find(fa[x]);
}
void init(map<int, vector<int>>m)
{
for (auto& mi : m) {
fa[mi.first] = mi.first;
for (auto k : mi.second) {
fa[k] = k;
}
}
}
//根据无向图的邻接表判断是否有环，每条边只在一个节点的邻接表中出现
bool hasCircle(map<int, vector<int>>m)
{
init(m);
for (auto& mi : m) {
for (auto k : mi.second) {
if (find(k) == find(mi.first))return true;
fa[find(k)] = find(mi.first);
}
}
return false;
}
class Solution {
public:
int id(int x, int y)
{
return x * col + y;
}
bool containsCycle(const vector<vector<char>>& matrix) {
col = matrix[0].size();
map<int, vector<int>>m;
for (int i = 1; i < matrix.size(); i++)for (int j = 0; j < matrix[0].size(); j++)
if (matrix[i][j] == matrix[i - 1][j])m[id(i, j)].push_back(id(i - 1, j));
for (int i = 0; i < matrix.size(); i++)for (int j = 1; j < matrix[0].size(); j++)
if (matrix[i][j] == matrix[i][j - 1])m[id(i, j)].push_back(id(i, j - 1));
return hasCircle(m);
}
int col;
};
二，有向图
用DFS判断有向图是否有环。
力扣 207. 课程表
你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。
例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
示例 1：
输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
示例 2：
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。
提示：
1 <= numCourses <= 105
0 <= prerequisites.length <= 5000
prerequisites[i].length == 2
0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对 互不相同
题意：
输入点的数量n 和 由边组成的向量，描述了一个有向图，判断它有没有环。
思路：
DFS，往下遍历的时候用visitt标记，往上回溯的时候擦除标记，如果遇到已标记的说明有环。
从每个点开始遍历，都没有环的话，就没有环。
但是这样效率太低，所以我再用一个flag标记，表示曾经访问过，也就不需要作为起点开始遍历了。
代码：
class Solution {
public:
bool canFinish(vector<vector<int>>& diag, int loc) {
if (visitt[loc] == 1)return false;
if (flag[loc] == 1)return true;
visitt[loc] = 1, flag[loc] = 1;
for (int i = 0; i < diag[loc].size(); i++)
{
if (!canFinish(diag, diag[loc][i]))return false;
}
visitt[loc] = 0;
return true;
}
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<int>tmp;
vector<vector<int>>diag;
for (int i = 0; i < numCourses; i++)
{
diag.insert(diag.end(), tmp);
visitt[i] = 0, flag[i] = 0;
}
for (int i = 0; i < prerequisites.size(); i++)
{
diag[prerequisites[i][0]].push_back(prerequisites[i][1]);
}
for (int i = 0; i < numCourses; i++)
{
if (flag[i])continue;
cout << i;
if (!canFinish(diag, i))return false;
}
return true;
}
private:
map<int, int>visitt;//单次访问标记
map<int, int>flag;//所有访问标记
};
