133、给你无向 连通 图中一个节点的引用,请你返回该图的 深拷贝(克隆)。
图中的每个节点都包含它的值 val(int) 和其邻居的列表(list[Node])。
class Node {
public int val;
public List<Node> neighbors;
}测试用例格式:
简单起见,每个节点的值都和它的索引相同。例如,第一个节点值为 1(val = 1),第二个节点值为 2(val = 2),以此类推。该图在测试用例中使用邻接列表表示。
邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。
给定节点将始终是图中的第一个节点(值为 1)。你必须将 给定节点的拷贝 作为对克隆图的引用返回。
示例 1:
输入:adjList = [[2,4],[1,3],[2,4],[1,3]]
输出:[[2,4],[1,3],[2,4],[1,3]]
解释:
图中有 4 个节点。
节点 1 的值是 1,它有两个邻居:节点 2 和 4 。
节点 2 的值是 2,它有两个邻居:节点 1 和 3 。
节点 3 的值是 3,它有两个邻居:节点 2 和 4 。
节点 4 的值是 4,它有两个邻居:节点 1 和 3 。
dfs,遇到点new一下,保存val值,用dfs找neighbors。Attention:用一个unordered_map映射val和该节点指针node*,便于dfs时判断结束条件。
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> neighbors;
Node() {
val = 0;
neighbors = vector<Node*>();
}
Node(int _val) {
val = _val;
neighbors = vector<Node*>();
}
Node(int _val, vector<Node*> _neighbors) {
val = _val;
neighbors = _neighbors;
}
};
*/
class Solution {
public:
unordered_map<int, Node*> mark;
vector<Node*> dfs(Node* x, Node* old){
vector<Node*> vec;
for(auto &it:old->neighbors){ // 每一个it是一个Node*
if(mark.count(it->val)) {
vec.push_back(mark[it->val]);
continue;
}
Node* next = new Node(it->val);
mark[next->val] = next;
next->neighbors = dfs(next, it);
vec.push_back(next);
}
return vec;
}
Node* cloneGraph(Node* node) {
if(node == nullptr) return {};
Node* root = new Node(node->val);
mark[root->val] = root;
root->neighbors = dfs(root, node);
return root;
}
};
结果:
执行用时:12 ms, 在所有 C++ 提交中击败了67.81% 的用户
内存消耗:9.3 MB, 在所有 C++ 提交中击败了100.00% 的用户
拓扑排序
207、你这个学期必须选修 numCourse 门课程,记为 0 到 numCourse-1 。
在选修某些课程之前需要一些先修课程。 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示他们:[0,1]
给定课程总量以及它们的先决条件,请你判断是否可能完成所有课程的学习?
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前,你需要完成课程 0。所以这是可能的。示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前,你需要先完成课程 0;并且学习课程 0 之前,你还应先完成课程 1。这是不可能的。
队列,实现拓扑排序。
// 拓扑排序
class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& pre) {
vector<int> indegree(numCourses, 0); // 存每个点的入度,每次找入度为0的点删除。
vector<vector<int>> gra(numCourses);
queue<int> q;
for(auto &i:pre){
indegree[i[1]]++;
gra[i[0]].push_back(i[1]);
}
int cnt = 0;
while(!q.empty()) q.pop();
for(int i = 0; i < numCourses; i++) if(indegree[i] == 0) q.push(i);
while(!q.empty()){
int t = q.front();
q.pop();
cnt++;
for(auto &i:gra[t]) {
indegree[i]--; // 删除t点,并删除从t发出的边==>与之相邻点的入度减一
if(indegree[i] == 0) q.push(i);
}
}
if(cnt < numCourses) return false;
else return true;
}
};
结果:
执行用时:40 ms, 在所有 C++ 提交中击败了62.90% 的用户
内存消耗:11.9 MB, 在所有 C++ 提交中击败了100.00% 的用户
拓扑序列
210、现在你总共有 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] 。
拓扑排序,返回拓扑序列
// 拓扑排序,返回拓扑序列
class Solution {
public:
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> gra(numCourses); // 邻接链表存图
vector<int> indgree(numCourses, 0); // 存每个点的入度,每次选indgree=0的点删除
vector<int> ans; // 存拓扑序列
queue<int> q;
for(auto &i:prerequisites){ // [a,b] b-->a
indgree[i[0]]++;
gra[i[1]].push_back(i[0]);
}
while(!q.empty()) q.pop();
for(int i = 0; i < numCourses; i++) if(indgree[i] == 0) q.push(i);
int cnt = 0;
while(!q.empty()){
int t = q.front();
q.pop();
ans.push_back(t);
cnt++;
for(auto &i:gra[t]) {
indgree[i]--;
if(indgree[i] == 0) q.push(i);
}
}
if(cnt < numCourses) ans.clear();
return ans;
}
};
结果:
执行用时:28 ms, 在所有 C++ 提交中击败了98.85% 的用户
内存消耗:12.1 MB, 在所有 C++ 提交中击败了100.00% 的用户
310、对于一个具有树特征的无向图,我们可选择任何一个节点作为根。图因此可以成为树,在所有可能的树中,具有最小高度的树被称为最小高度树。给出这样的一个图,写出一个函数找到所有的最小高度树并返回他们的根节点。
格式
该图包含 n 个节点,标记为 0 到 n - 1。给定数字 n 和一个无向边 edges 列表(每一个边都是一对标签)。
你可以假设没有重复的边会出现在 edges 中。由于所有的边都是无向边, [0, 1]和 [1, 0] 是相同的,因此不会同时出现在 edges 里。
示例 1:
输入: n = 4, edges = [[1, 0], [1, 2], [1, 3]]
0
|
1
/ \
2 3输出: [1]
示例 2:
输入: n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]
0 1 2
\ | /
3
|
4
|
5输出: [3, 4]
每个节点BFS查其树高,选最小树高的节点,即为答案。但导致超时61 / 66 个通过测试用例。n=1919时,开始超时:
// 每个点BFS
const int INF = 1e9;
class Solution {
public:
vector<vector<int>> gra;
int BFS(int r, int n){
queue<int> q;
q.push(r);
vector<int> height(n, -1);
height[r] = 0;
int cnt = 1, h = 0;
while(cnt < n){
int t = q.front();
q.pop();
for(auto &i:gra[t]){
if(height[i] == -1){
q.push(i);
height[i] = height[t] + 1;
cnt++;
h = max(h, height[i]);
}
}
}
return h;
}
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
gra.resize(n);
for(auto &i:edges){ // 图初始化
gra[i[0]].push_back(i[1]);
gra[i[1]].push_back(i[0]);
}
vector<int> ans;
int minH = INF;
for(int i = 0; i < n; i++){ // 每个点BFS
int h = BFS(i, n);
if(minH > h){
minH = h;
ans.clear();
ans.push_back(i);
}else if(minH == h) ans.push_back(i);
}
return ans;
}
};
修改:
利用拓扑排序,找最内部的节点。每次删除度为1的点,存储每个点的高度h,最外层h=0,每往里走一次h+1,目标点为具有最大h的点集合。
// 找最内部的点,作为root
class Solution{
public:
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
vector<int> degree(n, 0);
vector<vector<int>> gra(n);
for(auto &i:edges){
degree[i[0]]++;
degree[i[1]]++;
gra[i[0]].push_back(i[1]);
gra[i[1]].push_back(i[0]);
}
queue<int> q;
vector<int> h(n, 0);
for(int i = 0; i < n; i++) if(degree[i] == 1) q.push(i);
while(!q.empty()){
int t = q.front();
q.pop();
for(auto &i:gra[t]){
degree[i]--;
if(degree[i] == 1) {
q.push(i);
h[i] = h[t] + 1;
}
}
}
int maxH = -1;
vector<int> ans;
for(int i = 0; i < n; i++){
if(maxH < h[i]){
maxH = h[i];
ans.clear();
ans.push_back(i);
}else if(maxH == h[i]) ans.push_back(i);
}
return ans;
}
};
结果:
执行用时:148 ms, 在所有 C++ 提交中击败了51.01% 的用户
内存消耗:23.4 MB, 在所有 C++ 提交中击败了42.86% 的用户