C++算法题 - 图

200. 岛屿数量

LeetCode_link


给你一个由 '1'(陆地)和 '0'(水)组成的的二维网格,请你计算网格中岛屿的数量。

岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外,你可以假设该网格的四条边均被水包围。

示例 1
输入:grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出:1

示例 2
输入:grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出:3

提示:
m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 '0''1'


思路:把图当作一个4叉树,然后出界条件的判断类似于二叉树中的if(root == nullptr) return;一样的判断,并且要注意不要重复访问,要将访问过的位置做标记

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size(), m = grid[0].size();
        int count = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == '1'){
                    count++;
                    paint(grid, i, j);
                }
            }
        }
        return count;
    }
    void paint(vector<vector<char>>& grid, int i, int j){
        int n = grid.size(), m = grid[0].size();
        if(i<0 || i>=n || j<0 || j>=m) return;
        if(grid[i][j] != '1')   return;
        grid[i][j] = '2';
        int a[4] = {1, 0, -1, 0};
        int b[4] = {0, 1, 0, -1};
        for(int k = 0; k < 4; k++){
            paint(grid, i+a[k], j+b[k]);
        }
    }
};

130. 被围绕的区域

LeetCode_link


给你一个 m x n 的矩阵 board ,由若干字符 'X''O' ,找到所有被 'X' 围绕的区域,并将这些区域里所有的 'O''X' 填充。

示例 1
在这里插入图片描述
输入:board = [[“X”,“X”,“X”,“X”],[“X”,“O”,“O”,“X”],[“X”,“X”,“O”,“X”],[“X”,“O”,“X”,“X”]]
输出:[[“X”,“X”,“X”,“X”],[“X”,“X”,“X”,“X”],[“X”,“X”,“X”,“X”],[“X”,“O”,“X”,“X”]]
解释:被围绕的区间不会存在于边界上,换句话说,任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上,或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻,则称它们是“相连”的。

示例 2
输入:board = [[“X”]]
输出:[[“X”]]

提示
m == board.length
n == board[i].length
1 <= m, n <= 200
board[i][j]'X''O'


思路:分别把与边界相连的“根”和不与边界相连的“根”保存下来,之后再根据“根”进行染色

注意:
bool re = found(board, i+1, j) && found(board, i-1, j) && found(board, i, j+1) && found(board, i, j-1);

bool down = found(board, i+1, j);
bool up = found(board, i-1, j);
bool right = found(board, i, j+1);
bool left = found(board, i, j-1);
bool re = down && up && right && left;
是不一样的,如果是* && * && * && *的情况,如果第一个表达式的值是false,则后面的表达式都不会执行,因此,如果我们希望后面的函数依旧执行来进行染色,则不能合并成一个语句书写。

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        int n = board.size(), m = board[0].size();
        stack<pair<int, int>> p;
        stack<pair<int, int>> nop;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m ;j++){
                if(board[i][j] == 'O'){
                    if(found(board, i, j)){
                        p.push({i, j});
                    }else{
                        nop.push({i ,j});
                    }
                }
            }
        }
        while(!p.empty()){
            auto site = p.top();
            paint(board, site.first, site.second, 'X');
            p.pop();
        }
        while(!nop.empty()){
            auto site = nop.top();
            paint(board, site.first, site.second, 'O');
            nop.pop();
        }
    }
    bool found(vector<vector<char>>& board, int i, int j){
        if(i<0 || i>=board.size() || j<0 || j>=board[0].size()) return false;
        if(board[i][j] != 'O')  return true;
        board[i][j] = 'A';
        bool down = found(board, i+1, j);
        bool up = found(board, i-1, j);
        bool right = found(board, i, j+1);
        bool left = found(board, i, j-1);
        return down && up && right && left;
    }
    void paint(vector<vector<char>>& board, int i, int j, char c){
        if(i<0 || i>=board.size() || j<0 || j>=board[0].size()) return;
        if(board[i][j] != 'A')  return;
        board[i][j] = c;
        paint(board, i+1, j, c);
        paint(board, i-1, j, c);
        paint(board, i, j+1, c);
        paint(board, i, j-1, c);
    }
};

思路:先把边界的点作为“根”寻找一遍,标记上’A’。之后遍历全部,如果被标记为’A’的就是与边界相连的,如果不是’A’而是’O’的,则是不与边界相连的,直接置为’X’即可。

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        int n = board.size(), m = board[0].size();
        for(int i = 0; i < n; i++){
            found(board, i, 0);
            found(board, i, m-1);
        }
        for(int i = 0; i < m; i++){
            found(board, 0, i);
            found(board, n-1, i);
        }
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(board[i][j] == 'A'){
                    board[i][j] = 'O';
                }else if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
            }
        }
    }
    void found(vector<vector<char>>& board, int i, int j){
        if(i<0 || i>=board.size() || j<0 || j>=board[0].size()) return;
        if(board[i][j] != 'O')  return;
        board[i][j] = 'A';
        found(board, i+1, j);
        found(board, i-1, j);
        found(board, i, j+1);
        found(board, i, j-1);
    }
};

133. 克隆图

LeetCode_link


给你无向 连通 图中一个节点的引用,请你返回该图的 深拷贝(克隆)。

图中的每个节点都包含它的值 valint) 和其邻居的列表(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 。

示例 2
在这里插入图片描述
输入:adjList = [[]]
输出:[[]]
解释:输入包含一个空列表。该图仅仅只有一个值为 1 的节点,它没有任何邻居。

示例 3
输入:adjList = []
输出:[]
解释:这个图是空的,它不含任何节点。

提示
这张图中的节点数在 [0, 100] 之间。
1 <= Node.val <= 100
每个节点值 Node.val 都是唯一的,
图中没有重复的边,也没有自环。
图是连通图,你可以从给定节点访问到所有节点。


思路:hash中存储已经创建的新节点,并且可以用作判断是不是创建过,防止绕圈。用队列进行广度搜索。

/*
// 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 {
private:
    unordered_map<int, Node*> hash;
public:
    Node* cloneGraph(Node* node) {
        if(node == NULL)    return NULL;
        queue<Node*> q;
        Node* root = new Node(node->val);
        hash[node->val] = root;
        q.push(node);
        while(!q.empty()){
            Node* temp = q.front();
            Node* now_new = hash[temp->val];
            for(auto nei : temp->neighbors){
                if(hash.find(nei->val) == hash.end()){
                    q.push(nei);
                    Node* n = new Node(nei->val);
                    hash[nei->val] = n;
                }
                now_new->neighbors.push_back(hash[nei->val]);
            }
            q.pop();
        }
        return hash[node->val];
    }
};

399. 除法求值

LeetCode_link


给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件,其中 equations[i] = [Ai, Bi]values[i] 共同表示等式 Ai / Bi = values[i] 。每个 AiBi 是一个表示单个变量的字符串。

另有一些以数组 queries 表示的问题,其中 queries[j] = [Cj, Dj] 表示第 j 个问题,请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。

返回 所有问题的答案 。如果存在某个无法确定的答案,则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串,也需要用 -1.0 替代这个答案。

注意:输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况,且不存在任何矛盾的结果。

注意:未在等式列表中出现的变量是未定义的,因此无法确定它们的答案。

示例 1
输入:equations = [[“a”,“b”],[“b”,“c”]], values = [2.0,3.0], queries = [[“a”,“c”],[“b”,“a”],[“a”,“e”],[“a”,“a”],[“x”,“x”]]
输出:[6.00000,0.50000,-1.00000,1.00000,-1.00000]
解释:
条件:a / b = 2.0, b / c = 3.0
问题:a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
结果:[6.0, 0.5, -1.0, 1.0, -1.0 ]
注意:x 是未定义的 => -1.0

示例 2
输入:equations = [[“a”,“b”],[“b”,“c”],[“bc”,“cd”]], values = [1.5,2.5,5.0], queries = [[“a”,“c”],[“c”,“b”],[“bc”,“cd”],[“cd”,“bc”]]
输出:[3.75000,0.40000,5.00000,0.20000]

示例 3
输入:equations = [[“a”,“b”]], values = [0.5], queries = [[“a”,“b”],[“b”,“a”],[“a”,“c”],[“x”,“y”]]
输出:[0.50000,2.00000,-1.00000,-1.00000]

提示
1 <= equations.length <= 20
equations[i].length == 2
1 <= Ai.length, Bi.length <= 5
values.length == equations.length
0.0 < values[i] <= 20.0
1 <= queries.length <= 20
queries[i].length == 2
1 <= Cj.length, Dj.length <= 5
Ai, Bi, Cj, Dj 由小写英文字母与数字组成


思路:先建图,有向图。之后深度搜索,以问题中的第一个串为根,找问题中的第二个串。
在这里插入图片描述

class Solution {
    struct Node{
        string s;
        vector<Node*> neiborhoods;
        vector<double> value;
        Node(string _s): s(_s),  neiborhoods(vector<Node*>()), value(vector<double>()) {}
    };
    unordered_map<string, Node*> hash;//用于建图时,为了不重复建节点
    unordered_set<string> flag;//用于找答案时,为了不兜圈子
public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        //建图
        int n = equations.size(), m = equations[0].size();
        for(int i = 0; i < n; i++){
            if(hash.find(equations[i][0]) == hash.end()){
                Node* node = new Node(equations[i][0]);
                hash[equations[i][0]] = node;
            }
            if(hash.find(equations[i][1]) == hash.end()){
                Node* node = new Node(equations[i][1]);
                hash[equations[i][1]] = node;
            }
            //有向图,相反方向互为导数
            Node* left = hash[equations[i][0]];
            Node* right = hash[equations[i][1]];
            left->neiborhoods.push_back(right);
            left->value.push_back(values[i]);
            right->neiborhoods.push_back(left);
            right->value.push_back(1/values[i]);

        }
        //找答案
        vector<double> rec = {};
        for(int i = 0; i < queries.size(); i++){
            flag.clear();
            if(hash.find(queries[i][0]) == hash.end() || hash.find(queries[i][1]) == hash.end()){  
                rec.push_back(-1);
            }else{
                rec.push_back(find_road(queries[i][0], queries[i][1]));
            }
        }
        return rec;
    }
    double find_road(string a, string b){
        if(a == b)  return 1;
        flag.insert(a);
        int n = hash[a]->neiborhoods.size();
        for(int i = 0; i < n; i++){
            string neibor = hash[a]->neiborhoods[i]->s;
            if(flag.find(neibor) == flag.end()){
                double temp = find_road(hash[a]->neiborhoods[i]->s, b);
                if(temp > 0){
                    return temp * hash[a]->value[i];
                }
            }
        }
        return -1;
    }
};

207. 课程表

LeetCode_link


你这个学期必须选修 numCourses 门课程,记为 0numCourses - 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 <= 2000
0 <= prerequisites.length <= 5000
prerequisites[i].length == 2
0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对 互不相同


思路:拓扑问题,需要记录入度信息。用列表存放入度为0的点,用于“学习”课程,可以直接学习,不需要前序课程了。需要统计每门课的后续节点。

class Solution {
    unordered_map<int, vector<int>> hash;
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        if(prerequisites.size() == 0)  return true;       
        queue<int> q;
        vector<int> indegrees(numCourses, 0);
        for(int i = 0; i < prerequisites.size(); i++){
            int first = prerequisites[i][0];
            int second = prerequisites[i][1];
            if(hash.find(second) == hash.end()){
                hash[second] = {first};
            }else{
                hash[second].push_back(first);
            }
            indegrees[first] ++;
        }
        for(int i = 0; i < numCourses; i++){
            if(indegrees[i] == 0){
                q.push(i);
            }
        }
        int now_node;
        while(!q.empty() && numCourses > 0){
            now_node = q.front();
            q.pop();
            numCourses--;
            if(hash.find(now_node) == hash.end())   continue;
            int next = hash[now_node].size();
            for(int i = 0; i < next; i++){
                indegrees[hash[now_node][i]]--;
                if(indegrees[hash[now_node][i]] == 0){
                    q.push(hash[now_node][i]);
                }
            }
        }
        if(numCourses > 0){
            return false;
        }
        return true;
    }
};

210. 课程表 II

LeetCode_link


现在你总共有 numCourses 门课需要选,记为 0numCourses - 1。给你一个数组 prerequisites ,其中 prerequisites[i] = [ai, bi] ,表示在选修课程 ai必须 先选修 bi

  • 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示:[0,1]

返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序,你只要返回 任意一种 就可以了。如果不可能完成所有课程,返回 一个空数组

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

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

示例 3
输入:numCourses = 1, prerequisites = []
输出:[0]

提示
1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= ai, bi < numCourses
ai != bi
所有[ai, bi] 互不相同


思路:与上一题相似

class Solution {
    unordered_map<int, vector<int>> hash;
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        queue<int> q;
        vector<int> rec;
        vector<int> indegrees(numCourses, 0);
        for(int i = 0; i < prerequisites.size(); i++){
            if(hash.find(prerequisites[i][1]) == hash.end()){
                hash[prerequisites[i][1]] = {prerequisites[i][0]};
            }else{
                hash[prerequisites[i][1]].push_back(prerequisites[i][0]);
            }
            indegrees[prerequisites[i][0]] ++;
        }
        for(int i = 0; i < numCourses; i++){
            if(indegrees[i] == 0){
                q.push(i);
            }
        }
        int now_course;
        while(!q.empty() && numCourses > 0){
            now_course = q.front();
            rec.push_back(now_course);
            numCourses --;
            q.pop();
            if(hash.find(now_course) == hash.end()) continue;
            for(int i = 0; i < hash[now_course].size(); i++){
                indegrees[hash[now_course][i]]--;
                if(indegrees[hash[now_course][i]] == 0){
                    q.push(hash[now_course][i]);
                }
            }
        }
        if(numCourses > 0)  return {};
        return rec;
    }
};
  • 22
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

x_fengmo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值