LeetCode 图

最新推荐文章于 2023-05-27 16:03:08 发布
最新推荐文章于 2023-05-27 16:03:08 发布
阅读量72 收藏
点赞数
分类专栏： 刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/almost_afei/article/details/114988246
版权

目录

207. 课程表

超时解法：

class Solution {

    bool dfs(vector<vector<int>>& graph, int i, vector<int> courses){
        for(int j = 0; j < courses.size(); j++){
            if(courses[j] == i)return false;
        }
        courses.emplace_back(i);
        for(int j = 0; j < graph.size(); j++){
            if(graph[i][j]){
                if(!dfs(graph, j, courses))return false;
            }
        }
        return true;
    }

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        if(prerequisites.size() == 0)return true;
        vector<vector<int>> graph(numCourses, vector<int>(numCourses));
        for(int i = 0; i < prerequisites.size(); i++){
            int a = prerequisites[i][0], b = prerequisites[i][1];
            graph[a][b] = 1;
        }
        
        vector<int> courses;
        for(int i = 0; i < numCourses; i++){
            if(!dfs(graph, i, courses))return false;
        }
        return true;
    }
};

优化了一下，使用 n u m C o u r c e s numCources numCources维的cources来标记当前是否遍历到，使用tranverse标记历史是否遍历到这门课，若遍历到下一次不需要再遍历。过了上次的超时用例，但是又来了新的超时用例。

class Solution {
    bool dfs(vector<vector<int>>& graph, int i, vector<int>& courses, vector<int>& traverse){
        if(courses[i] == 1)return false;
        traverse[i] = 1;
        for(int j = 0; j < graph.size(); j++){
            if(graph[i][j]){
                courses[i] = 1;
                if(traverse[i] == 1 && courses[i] == 0)continue;
                if(!dfs(graph, j, courses, traverse))return false;
                courses[i] = 0;
            }
        }
        return true;
    }

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        if(prerequisites.size() == 0)return true;
        vector<vector<int>> graph(numCourses, vector<int>(numCourses));
        for(int i = 0; i < prerequisites.size(); i++){
            int a = prerequisites[i][0], b = prerequisites[i][1];
            graph[a][b] = 1;
        }

        vector<int> traverse(numCourses);
        for(int i = 0; i < numCourses; i++){
            if(traverse[i] == 0){
                vector<int> courses(numCourses);
                if(!dfs(graph, i, courses, traverse))return false;
            }
        }
        return true;
    }
};
/*
5
[[0,2],[2,1],[3,1],[1,4],[4,1]]
*/

参考题解，只是用一个数组来标记不同状态，只需要将其置为不同的值即可，比如用1表示当前遍历过的，用2表示已经遍历成功的课。

正确解法：

class Solution {

    bool dfs(vector<vector<int>>& graph, int i, vector<int>& traverse){
        traverse[i] = 1;
        for(int j = 0; j < graph.size(); j++){
            if(graph[i][j]){
                if(traverse[j] == 1){
                    return false;
                }
                if(traverse[j] == 0){
                    if(!dfs(graph, j, traverse))return false;
                }
            }
        }
        traverse[i] = 2;
        return true;
    }

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        if(prerequisites.size() == 0)return true;
        vector<vector<int>> graph(numCourses, vector<int>(numCourses));
        for(int i = 0; i < prerequisites.size(); i++){
            int a = prerequisites[i][0], b = prerequisites[i][1];
            graph[a][b] = 1;
        }

        vector<int> traverse(numCourses);
        for(int i = 0; i < numCourses; i++){
            if(traverse[i] == 0){
                if(!dfs(graph, i, traverse))return false;
            }
        }
        return true;
    }
};

结果：
在这里插入图片描述
还是很慢，可以不使用邻接矩阵，将graph[i]向量存储课程i的先修课程序列。

310. 最小高度树

注意，树的高度是所有子树高度的最大值+1.

又是超时！
超时代码：

class Solution {
    vector<vector<int>> graph;
    int min_len = 999999;

    int getLevel(int node, int parent, int len){
        if(len > min_len)return len;
        if(graph[node].size() == 1 && graph[node][0] == parent){
            return len;
        }
        int now_len = 0;
        for(int i = 0; i < graph[node].size(); i++){
            if(graph[node][i] != parent){
                now_len = max(now_len, getLevel(graph[node][i], node, len + 1));
            }
        }
        return now_len;
    }

public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        vector<int> res;
        if(n == 1){
            res.push_back(0);
            return res;
        }

        graph.resize(n);
        for(int i = 0; i < edges.size(); i++){
            graph[edges[i][0]].push_back(edges[i][1]);
            graph[edges[i][1]].push_back(edges[i][0]);
        }
        
        for(int i = 0; i < n; i++){
            int len = getLevel(i, -1, 1);
            if(len < min_len){
                min_len = len;
                res.clear();
                res.push_back(i);
            }
            else if(len == min_len)res.push_back(i);
        }
        return res;
    }
};

看了下题解，果然最优思路不是暴力来做的，再优化还是很慢。
从图的边缘开始缩小图，每次将度为1的节点删除。使用队列来做，最后的队列就是答案。

正确解法：

class Solution {

public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        vector<int> res;
        if(n == 1){
            res.push_back(0);
            return res;
        }

        vector<vector<int>> graph(n);
        vector<int> du(n);
        for(int i = 0; i < edges.size(); i++){
            graph[edges[i][0]].push_back(edges[i][1]);
            graph[edges[i][1]].push_back(edges[i][0]);
            du[edges[i][0]]++;
            du[edges[i][1]]++;
        }

        queue<int> que;
        for(int i = 0; i < n; i++){
            if(du[i] <= 1)que.push(i);
        }

        while(que.size() != n){
            int size = que.size();
            n -= size;
            while(size--){
                int q = que.front();
                que.pop();

                for(int i = 0; i < graph[q].size(); i++){
                    int j = graph[q][i];
                    du[j]--;
                    if(du[j] == 1){
                        que.push(j);
                    }
                }
            }
        }

        for(int i = 0; i < n; i++){
            res.push_back(que.front());
            que.pop();
        }
        return res;
    }
};

结果：
在这里插入图片描述

399. 除法求值

使用unordered_map来完成字符串到索引的映射，注意要使用 t r a n v e r s e tranverse tranverse来标记某节点是否被遍历过，或遍历过则说明程序跳进了循环，直接返回false。

递归解法：

class Solution {

    bool dfs(vector<vector<pair<int, double>>>& graph, int x, int goal, int parent, double& res, vector<int>& tranverse){
        if(tranverse[x] == 1)return false;
        if(x == goal){
            return true;
        }
        tranverse[x] = 1;
        for(int i = 0; i < graph[x].size(); i++){
            int nxt = graph[x][i].first;
            if(nxt == parent)continue;
            res *= graph[x][i].second;
            if(dfs(graph, nxt, goal, x, res, tranverse))return true;
            res /= graph[x][i].second;
        }
        return false;
    }
    

public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        unordered_map<string, int> m;
        vector<double> result;

        int num = 0;
        for(int i = 0; i < equations.size(); i++){
            if(m.find(equations[i][0]) == m.end()){
                m[equations[i][0]] = num++;
            }
            if(m.find(equations[i][1]) == m.end()){
                m[equations[i][1]] = num++;
            }
        }

        vector<vector<pair<int, double>>> graph(num);
        for(int i = 0; i < equations.size(); i++){
            int a = m[equations[i][0]], b = m[equations[i][1]];
            if(a == b)continue;
            graph[a].push_back(make_pair(b, values[i]));
            graph[b].push_back(make_pair(a, 1 / values[i]));
        }
        
        /*for(auto it = m.begin(); it != m.end(); it++){
            cout << it->first << " " << it->second << endl;
        }

        for(int i = 0; i < graph.size(); i++){
            cout << "----------" << i << endl;
            for(int j = 0; j < graph[i].size(); j++){
                cout << graph[i][j].first << " " << graph[i][j].second << endl;
            }
        }*/
        
        for(int i = 0; i < queries.size(); i++){
            if(m.find(queries[i][0]) == m.end() || m.find(queries[i][1]) == m.end()){
                result.push_back(-1.0);
                continue;
            }
            int a = m[queries[i][0]], b = m[queries[i][1]];
            double res = 1.0;
            // cout << "cal " << a << " " << b << endl;
            vector<int> tranverse(num);
            if(dfs(graph, a, b, -1, res, tranverse)){
                result.push_back(res);
            }
            else{
                result.push_back(-1.0);
            }
            // cout << "res " << res << endl;
        }
        return result;
    }
};

结果：
在这里插入图片描述

使用队列来完成非递归算法，其中使用数组 t e m p temp temp来存储中间值，初始化为-1.0。当遍历到节点i时，若 t e m p [ i ] ! = − 1.0 temp[i]!=-1.0 temp[i]!=−1.0时，则说明该节点被遍历过，因此直接跳过。

非递归解法：

class Solution {
public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        unordered_map<string, int> m;
        vector<double> result;

        int num = 0;
        for(int i = 0; i < equations.size(); i++){
            if(m.find(equations[i][0]) == m.end()){
                m[equations[i][0]] = num++;
            }
            if(m.find(equations[i][1]) == m.end()){
                m[equations[i][1]] = num++;
            }
        }

        vector<vector<pair<int, double>>> graph(num);
        for(int i = 0; i < equations.size(); i++){
            int a = m[equations[i][0]], b = m[equations[i][1]];
            if(a == b)continue;
            graph[a].push_back(make_pair(b, values[i]));
            graph[b].push_back(make_pair(a, 1 / values[i]));
        }
        
        /*for(auto it = m.begin(); it != m.end(); it++){
            cout << it->first << " " << it->second << endl;
        }

        for(int i = 0; i < graph.size(); i++){
            cout << "----------" << i << endl;
            for(int j = 0; j < graph[i].size(); j++){
                cout << graph[i][j].first << " " << graph[i][j].second << endl;
            }
        }*/
        
        for(int i = 0; i < queries.size(); i++){
            if(m.find(queries[i][0]) == m.end() || m.find(queries[i][1]) == m.end()){
                result.push_back(-1.0);
                continue;
            }
            int a = m[queries[i][0]], b = m[queries[i][1]];
            double res = 1.0;
            queue<int> que;
            que.push(a);
            vector<double> temp(num, -1.0);
            temp[a] = 1.0;  
            while(temp[b] == -1.0 && !que.empty()){
                int x = que.front();
                que.pop();
                for(int j = 0; j < graph[x].size(); j++){
                    int k = graph[x][j].first;
                    if(temp[k] == -1.0){
                        que.push(k);
                        temp[k] = temp[x] * graph[x][j].second;
                    }
                }
            }
            result.push_back(temp[b]);
        }
        return result;
    }
};

结果：
在这里插入图片描述

_almost__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode-editor
05-09
《leetcode-editor：提升编程技能的高效工具》 在编程领域，LeetCode 是一个广受欢迎的在线平台，它提供了丰富的算法题目，帮助开发者提升编程技能、准备面试，甚至纯粹享受解决问题的乐趣。而“leetcode-editor”...
leetcode png
06-24
leetcode png
LeetCode总结 -- 图篇
热门推荐
Code Ganker
09-18 2万+
图的算法跟树一样是准备面试中必不可少的一块，不过图的方法很容易概括，面试中考核的无非就是两种搜索算法：深度优先搜索和广度优先搜索。LeetCode中关于图的问题有以下几个：Clone GraphWord LadderWord Ladder IILongest Consecutive SequenceWord SearchSurrounded Regions先来看看最基础的Clone Graph，很
leetcode_图
powerful_ren的博客
05-09 199
文章目录785. 判断二分图207. 课程表 785. 判断二分图 给定一个无向图graph，当这个图为二分图时返回true。 如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。 graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length...
LeetCode | 图
qq_40933711的博客
06-24 288
LeetCode图类题目合集
LeetCode常见题型——图
贫道绝缘子的博客
08-22 470
图是树的升级版。图通常分为有向（directed）或无向（undirected），有循环（cyclic）或无循环（acyclic），所有节点相连（connected）或不相连（disconnected）。
LeetCode 克隆图
hestyle的博客
02-22 590
克隆一张无向图，图中的每个节点包含一个 label （标签）和一个 neighbors （邻接点）列表 。 OJ的无向图序列化： 节点被唯一标记。 我们用 # 作为每个节点的分隔符，用 , 作为节点标签和邻接点的分隔符。 例如，序列化无向图 {0,1,2#1,2#2,2}。 该图总共有三个节点, 被两个分隔符 # 分为三部分。 第一个节点的标签为 0，存在从节点 0 到节点 1 和节点 2 的...
LeetCode刷题笔记
05-29
LeetCode全栈攻略：高效刷题笔记分享 从零开始到技术大牛的必经之路，提升算法能力与编程技巧。 内容概要： 欢迎来到这个全面解析LeetCode刷题心得的世界！这里汇集了我数月来的点滴努力和收获，旨在帮助你在...
LeetCode刷题手册
01-16
数据结构： 对常见数据结构（数组、链表、树、图等）进行深入解释，以及如何在算法问题中使用它们。 刷题策略： 提供刷题的有效策略，包括按主题刷题、按难度刷题、每日刷题计划等。 实战经验： 分享刷题的实战...
leetcode题目精选
03-15
leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode...
一文通数据结构与算法之——图+常见题型与解题策略+Leetcode经典题
尚墨1111的博客
10-03 705
文章目录数据结构——图1 基本概念1.1 图的存储方式1.2 有向加权图1.3 实现1.4 图的遍历1.4.1 深度优先遍历图 BFS1.4.2 广度优先遍历图 BFS1.5 拓扑排序1.5.1 判断有向图是否存在环1.5.2 输出拓扑顺序：深度遍历法1.5.3 拓扑排序：广度优先遍历法2 真题2.1 路径问题（动态规划）2.1.1 **[64. 最小路径和](https://leetcode-cn.com/problems/minimum-path-sum/)**2.2.2 **[62. 不同路径]
LeetcCode之图
qq_41174940的博客
02-10 325
1、什么是图： 图就是一堆顶点和边对象而已，可以用邻接表和邻接矩阵表示。 2、注意事项： 在 稀疏图的情况下，每一个顶点都只会和少数几个顶点相连，这种情况下相邻列表是最佳选择。如果这个图比较密集，每一个顶点都和大多数其他顶点相连，那么相邻矩阵更合适。 3、核心算法 搜索——终止——回溯——搜索——直到找到解/遍历全部节点。 （一）DFS 举例一（leetcode200) 给定一个由 ‘1’（陆地）...
LeetCode【图】专题
qq_36183146的博客
05-27 94
关于图的基本概念，简单的过一遍吧 图的分类（简单图：没有自环和复边）：有向图，无向图 图的常用的存储结构：邻接矩阵，邻接表 图的性质：度，出度，入度 图的遍历方式：深度优先遍历，广度优先遍历 图的应用：最短路径，拓扑排序等 1.关于图的邻接矩阵的性质 图的邻接矩阵A相乘，比如 B = A^n 第 i 行第 j 列的值表示节点 i 到节点 j 的长度为 n 路径共有 B[i][j] 条。 如：LCP...
Leetcode中图的遍历
hello_qingwen的专栏
05-19 1291
Leetcode中有两道题涉及到图的遍历，
Leetcode图专题
三笔竹林的博客
09-22 1778
要明白的基础知识 node1=UndirectedGraphNode(1) node2=UndirectedGraphNode(2) nodeMap={} nodeMap[node1]=&quot;hello&quot; nodeMap[node2]=&quot;world&quot; #这样是合法的，打印nodeMap看看 nodeMap Out[8]: {&amp;lt;__main__.UndirectedGraphNode at 0x...
leetcode-图总结
许诗宇的博客
11-21 1226
leetcode-200-岛屿的个数 (number of islands)-java 方法1：深度优先遍历 设置hasGone二维数组，使用深度优先遍历，将周围是1的都遍历到，并且设置hasGone为true。 从主方法开始，遍历过几次，就有几个岛屿（因为遍历第一个岛屿，会将岛屿所有连接的地方都设为true，那些地方不会再从主方法遍历） 也可以把访问过的改为‘0’，继续遍历。 方法2：...
分包合同计量单.docx
最新发布
07-13
分包合同计量单.docx
树莓派简介PPT课件.ppt
07-13
树莓派简介PPT课件.ppt
项目债务盘点明细表.docx
07-13
项目债务盘点明细表.docx
5LeetCode专题解答.docx
08-04
"LeetCode专题解答，包括对BFS（广度优先搜索）的应用解析，特别是针对图的BFS，并提供了解决具体问题‘As Far From Land As Possible’的算法思路和代码实现。" 在LeetCode中，BFS是一种常用且重要的算法，常用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值