代码随想录算法训练营第五十二天 | 图论part03

最新推荐文章于 2024-08-28 23:27:41 发布
最新推荐文章于 2024-08-28 23:27:41 发布
阅读量83 收藏
点赞数
文章标签： 算法 图论 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43456971/article/details/141642882
版权

101. 孤岛的总面积

#include <vector>
#include <iostream>

using namespace std;

int dir[4][2] = {0, 1, 0, -1, -1, 0, 1, 0};
void dfs(const vector<vector<int>> &grid, 
    vector<vector<bool>> &visited, int x, int y, int& result) {
        for (int i = 0; i < 4; ++i) {
            int nextx = x + dir[i][1];
            int nexty = y + dir[i][0];
            if (nextx < 0 || nextx >= grid.size()
            || nexty < 0 || nexty >= grid[0].size())  continue;
            if (!visited[nextx][nexty] && grid[nextx][nexty] == 1) {
                visited[nextx][nexty] = true;
                result++;
                dfs(grid, visited, nextx, nexty, result);
            }
        }
}

int main() {
    int n, m, result = 0;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    
    
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    for (int j = 0; j < m; ++j) {
        if (grid[0][j] == 1 && visited[0][j] == false) {
                visited[0][j] = true;
                dfs(grid, visited, 0, j, result);
            }
        if (grid[n-1][j] == 1 && visited[n-1][j] == false) {
                visited[n-1][j] = true;
                dfs(grid, visited, n-1, j, result);
            }
    }
    
    for (int i = 0; i < n; ++i) {
        if (grid[i][0] == 1 && visited[i][0] == false) {
                visited[i][0] = true;
                dfs(grid, visited, i, 0, result);
            }
        if (grid[i][m-1] == 1 && visited[i][m-1] == false) {
                visited[i][m-1] = true;
                dfs(grid, visited, i, m-1, result);
            }
    }
    result = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (grid[i][j] == 1 && visited[i][j] == false) {
                result++;
                visited[i][j] = true;
                dfs(grid, visited, i, j, result);
            }
        }
    }
    cout << result;
}

102. 沉没孤岛

#include <vector>
#include <iostream>

using namespace std;

int dir[4][2] = {0, 1, 0, -1, -1, 0, 1, 0};
void dfs(vector<vector<int>> &grid, 
    vector<vector<bool>> &visited, int x, int y, bool transfer) {
        for (int i = 0; i < 4; ++i) {
            int nextx = x + dir[i][1];
            int nexty = y + dir[i][0];
            if (nextx < 0 || nextx >= grid.size()
            || nexty < 0 || nexty >= grid[0].size())  continue;
            if (!visited[nextx][nexty] && grid[nextx][nexty] == 1) {
                visited[nextx][nexty] = true;
                if (transfer) {
                    grid[nextx][nexty] = 0;
                }
                dfs(grid, visited, nextx, nexty, transfer);
            }
        }
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    
    
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    for (int j = 0; j < m; ++j) {
        if (grid[0][j] == 1 && visited[0][j] == false) {
                visited[0][j] = true;
                dfs(grid, visited, 0, j, false);
            }
        if (grid[n-1][j] == 1 && visited[n-1][j] == false) {
                visited[n-1][j] = true;
                dfs(grid, visited, n-1, j, false);
            }
    }
    
    for (int i = 0; i < n; ++i) {
        if (grid[i][0] == 1 && visited[i][0] == false) {
                visited[i][0] = true;
                dfs(grid, visited, i, 0, false);
            }
        if (grid[i][m-1] == 1 && visited[i][m-1] == false) {
                visited[i][m-1] = true;
                dfs(grid, visited, i, m-1, false);
            }
    }

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (grid[i][j] == 1 && visited[i][j] == false) {
                visited[i][j] = true;
                grid[i][j] = 0;
                dfs(grid, visited, i, j, true);
            }
        }
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cout << grid[i][j] << " ";
        }
        cout << endl;
    }
}

103. 水流问题

#include <iostream>
#include <vector>

using namespace std;

int dir[4][2] = {0, 1, 0, -1, -1, 0, 1, 0};


void dfs(const vector<vector<int>> &grid, 
    vector<vector<bool>> &isVisited,int x, int y) {
    if (isVisited[x][y]) return;
    isVisited[x][y] = true;
    for (int i = 0; i < 4; ++i) {
        int nextx = x + dir[i][0];
        int nexty = y + dir[i][1];
        if (nextx < 0 || nextx >= grid.size() || nexty < 0 
        || nexty >= grid[0].size()) continue;
        if (grid[nextx][nexty] < grid[x][y])   continue;
        dfs(grid, isVisited,nextx, nexty);
        
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    
    vector<vector<bool>> Visited1(n, vector<bool>(m, false));
    vector<vector<bool>> Visited2(n, vector<bool>(m, false));
    for (int j = 0; j < m; ++j) {
        dfs(grid, Visited1, 0, j);
        dfs(grid, Visited2, n - 1, j);
    }
    for (int i = 0; i < n; ++i) {
        dfs(grid, Visited1, i, 0);
        dfs(grid, Visited2, i, m - 1);
    }
    
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (Visited1[i][j] && Visited2[i][j])
                cout << i << " " << j << endl;
        }
    }
}

104.建造最大岛屿

#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std;

int dir[4][2] = {0, 1, 0, -1, -1, 0, 1, 0};
bool isAllGrid = true; 
void dfs(vector<vector<int>> &grid, vector<vector<bool>> &visited,
int &count, int mark, int x, int y) {
    if (visited[x][y] == true || grid[x][y] == 0) return;
    visited[x][y] = true;
    grid[x][y] = mark;
    count++;
    for (int i = 0; i < 4; ++i) {
        int nextx = x + dir[i][0];
        int nexty = y + dir[i][1];
        if (nextx < 0 || nextx >= grid.size() || nexty < 0 
        || nexty >= grid[0].size()) continue;
        
        dfs(grid, visited, count, mark, nextx, nexty);
    }
}

void firstScan(vector<vector<int>> &grid, 
unordered_map<int, int> &gridNum, vector<vector<bool>> &visited) {
    int mark = 2;
    
    for (int i = 0; i < grid.size(); ++i) {
        for (int j = 0; j < grid[0].size(); ++j) {
            if (grid[i][j] == 0) isAllGrid = false;
            if (visited[i][j] == false && grid[i][j] == 1) {
                int count = 0;
                dfs(grid, visited, count, mark, i, j);
                gridNum.emplace(mark, count);
                mark++;
            }
        }
    }
}

int secondScan(vector<vector<int>> &grid, unordered_map<int, int> &gridNum) {
    int result = 0;
    unordered_set<int> visitedGrid;
    for (int i = 0; i < grid.size(); ++i) {
        for (int j = 0; j < grid[0].size(); ++j) {
            int count = 1;
            visitedGrid.clear(); //这里没有考虑到
            if (grid[i][j] == 0) {
                for (int a = 0; a < 4; ++a) {
                    int nextx = i + dir[a][0];
                    int nexty = j + dir[a][1];
                    if (nextx < 0 || nextx >= grid.size() || nexty < 0 
                    || nexty >= grid[0].size()) continue;
                    if (visitedGrid.count(grid[nextx][nexty])) continue;
                    
                    count += gridNum[grid[nextx][nexty]];
                    visitedGrid.insert(grid[nextx][nexty]);
                }
            }
            result = max(result, count);
        }
    }
    return result;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    unordered_map<int, int> gridNum;
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    firstScan(grid, gridNum, visited);
    
    if (isAllGrid) {
        cout << n * m << endl; // 这个情况也没有考虑到
        return 0; 
    }
    cout << secondScan(grid, gridNum);
    return 0;
}
sagen aller
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录算法训练营打卡第一天
weixin_46724054的博客
03-01 1673
代码随想录算法训练营第1天 | Leetcode704 二分查找， 27 移除元素。
代码随想录算法训练营第三十四天 | LeetCode 51、37
Bingjiaokong的博客
01-30 1069
代码随想录刷题-day34
代码随想录算法训练营Day52|| 图论part03
DetouringSnail的博客
07-28 137
卡玛网101.孤岛的总面积：注意题目中孤岛的定义，孤岛必须在矩阵内部，因此必须先处理矩阵外部一圈的陆地，再把count初始化为0，再开始处理。注意，矩阵内部两块连在一起的陆地也叫做孤岛。卡玛网102.沉没孤岛：和上面一题类似，先处理矩阵边缘的陆地，把陆地特殊标记为2，之后把内陆为1的陆地全都变成0，把特殊标记的2换成1即可。卡玛网103.水流问题和卡玛网104.最大岛屿还有优化技巧需要看。补了上次岛屿最大面积的代码。图论学起来慢了好多。
代码随想录算法训练营Day62|| 图论part11
DetouringSnail的博客
08-07 125
算是一刷结束了，图论纯走马观花，晚点写个小总结吧。Floyd 算法和Astar算法。
代码随想录算法训练营Day54|| 图论part04
DetouringSnail的博客
07-30 229
算是一题简单的基础题，可以用来巩固邻接表的写法。从节点1开始，把所有能访问到的节点全都标记为true，继续深度搜索。卡玛网106岛屿的周长：这题即不需要深搜，也不需要广搜，题中给出了只有一个岛屿，从陆地的点开始朝四个方向走，遇到水了就说明有一条边，遍历所有的陆地，计算遇到水的次数即可。思路二是计算相邻岛屿的数量来计算边数。卡玛网110字符串接龙：相当于求无向图的最短路径，广搜最合适，因为广搜第一次找到路径一定最短。广搜就要利用队列，代码是能看懂的。能理解就很花时间了，先看懂逻辑和代码，关键基础部分写写吧。
代码随想录算法训练营Day59 || 图论part 09
DetouringSnail的博客
08-05 137
Bellman_ford算法精讲，卡玛网94题：变化在于权值出现了负数，用动态规划思想来维护MinDist数组。核心在于对所有边进行n-1次松弛处理，就可以得出起始点到所有节点的最短路径。dijkstra算法（堆优化版）：利用小顶堆来减少一层for循环。因为要存储边的权值，邻接表里就需要存pair了。图论章节主打一个走马观花属于是。
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法训练营第四十二天 | 01背包问题
weixin_42252688的博客
03-14 263
01背包问题
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 267
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 161
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 2549
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
深度学习（DL）算法分分类
最新发布
m0_46171719的博客
08-28 238
深度学习（DL）算法是机器学习的一个子集，专注于使用深度神经网络（DNN）来模拟人脑的学习过程，从而解决复杂的数据处理和模式识别问题。
冒泡排序算法
m0_74051652的博客
08-28 279
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
【算法】深入浅出聚类算法：原理、应用与Java实现
一个不断前行的程序者
08-26 881
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
C++ | Leetcode C++题解之第374题猜数字大小
Ddddddd_158的博客
08-26 385
C++ | Leetcode C++题解之第374题猜数字大小
代码随想录算法训练营第二十二天| 回溯算法理论基础 77. 组合 216.组合总和III 17.电话号码的字母组合
Mwicogito的博客
08-23 1659
回溯法章节开始，逐渐开始正式复习算法设计课的知识。文章图片来源：代码随想录 (https://programmercarl.com/)
【算法】动态规划
小匠码农
08-26 1320
动态规划、最长公共子序列
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，例如先看视频、了解自己所使用的编程语言、使用日志等方法来提高刷题效果和语言掌握程度。 训练营中的讨论内容非常丰富，涵盖了各种算法知识点和解题方法。例如，在第14天的训练营中，讲解了二叉树的理论基础、递归遍历、迭代遍历和统一遍历的内容。此外，在讨论中还分享了相关的博客文章和配图，帮助学员更好地理解和掌握二叉树的遍历方法。 训练营还提供了每日的讨论知识点，例如在第15天的讨论中，介绍了层序遍历的方法和使用队列来模拟一层一层遍历的效果。在第16天的讨论中，重点讨论了如何进行调试（debug）的方法，认为掌握调试技巧可以帮助学员更好地解决问题和写出正确的算法代码。 总之，代码随想录算法训练营是一个提供优质学习和讨论环境的平台，可以帮助学员系统地学习算法知识，并提供了丰富的讨论内容和刷题建议来提高算法编程能力。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [代码随想录算法训练营每日精华](https://blog.csdn.net/weixin_38556197/article/details/128462133)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值