代码随想录Day 52|题目：101.孤岛的面积、102.沉没孤岛、103.水流问题、104.建造最大岛屿

news2024/9/22 15:40:26

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

  • 图论part03
    • 题目一：101.孤岛的总面积
    • 解题思路
      • DFS
      • **BFS**
    • 题目二：102. 沉没孤岛
      • 解题思路
    • 题目三：103. 水流问题
      • 解题思路
      • 优化
    • 题目四：104.建造最大岛屿
      • 解题思路
      • 优化思路
    • 总结

图论part03

题目一：101.孤岛的总面积

101. 孤岛的总面积 (kamacoder.com)

解题思路

本题使用dfs，bfs，并查集都是可以的。

本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。

如图，在遍历地图周围四个边，靠地图四边的陆地，都为绿色，

img

在遇到地图周边陆地的时候，将1都变为0，此时地图为这样：

img

然后我们再去遍历这个地图，遇到有陆地的地方，去采用深搜或者广搜，边统计所有陆地。

DFS

采用深度优先搜索的代码如下：

#include <iostream>
#include <vector>
using namespace std;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向
int count; // 统计符合题目要求的陆地空格数量
void dfs(vector<vector<int>>& grid, int x, int y) {
    grid[x][y] = 0;
    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;
        // 不符合条件，不继续遍历
        if (grid[nextx][nexty] == 0) continue;

        dfs (grid, nextx, nexty);
    }
    return;
}

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];
        }
    }

    // 从左侧边，和右侧边 向中间遍历
    for (int i = 0; i < n; i++) {
        if (grid[i][0] == 1) dfs(grid, i, 0);
        if (grid[i][m - 1] == 1) dfs(grid, i, m - 1);
    }
    // 从上边和下边 向中间遍历
    for (int j = 0; j < m; j++) {
        if (grid[0][j] == 1) dfs(grid, 0, j);
        if (grid[n - 1][j] == 1) dfs(grid, n - 1, j);
    }
    count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) dfs(grid, i, j);
        }
    }
    cout << count << endl;
}

BFS

采用广度优先搜索的代码如下：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int count = 0;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(vector<vector<int>>& grid, int x, int y) {
    queue<pair<int, int>> que;
    que.push({x, y});
    grid[x][y] = 0; // 只要加入队列，立刻标记
    count++;
    while(!que.empty()) {
        pair<int ,int> cur = que.front(); que.pop();
        int curx = cur.first;
        int cury = cur.second;
        for (int i = 0; i < 4; i++) {
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1];
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了，直接跳过
            if (grid[nextx][nexty] == 1) {
                que.push({nextx, nexty});
                count++;
                grid[nextx][nexty] = 0; // 只要加入队列立刻标记
            }
        }
    }
}

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];
        }
    }
    // 从左侧边，和右侧边 向中间遍历
    for (int i = 0; i < n; i++) {
        if (grid[i][0] == 1) bfs(grid, i, 0);
        if (grid[i][m - 1] == 1) bfs(grid, i, m - 1);
    }
    // 从上边和下边 向中间遍历
    for (int j = 0; j < m; j++) {
        if (grid[0][j] == 1) bfs(grid, 0, j);
        if (grid[n - 1][j] == 1) bfs(grid, n - 1, j);
    }
    count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) bfs(grid, i, j);
        }
    }

    cout << count << endl;
}

题目二：102. 沉没孤岛

102. 沉没孤岛 (kamacoder.com)

解题思路

  1. 标记边缘陆地：从地图的边缘开始，将所有边缘的陆地（1）标记为特殊值（2）。
  2. 转换中间陆地：遍历整个地图，将未标记的陆地（1）转换为水域（0）。
  3. 恢复边缘标记：将特殊标记（2）恢复为陆地（1）。
img

整体C++代码如下，以下使用dfs实现，其实遍历方式dfs，bfs都是可以的。

#include <iostream>
#include <vector>
using namespace std;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向
void dfs(vector<vector<int>>& grid, int x, int y) {
    grid[x][y] = 2;
    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] == 0 || grid[nextx][nexty] == 2) continue;
        dfs (grid, nextx, nexty);
    }
    return;
}

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];
        }
    }

    // 步骤一：
    // 从左侧边，和右侧边 向中间遍历
    for (int i = 0; i < n; i++) {
        if (grid[i][0] == 1) dfs(grid, i, 0);
        if (grid[i][m - 1] == 1) dfs(grid, i, m - 1);
    }

    // 从上边和下边 向中间遍历
    for (int j = 0; j < m; j++) {
        if (grid[0][j] == 1) dfs(grid, 0, j);
        if (grid[n - 1][j] == 1) dfs(grid, n - 1, j);
    }
    // 步骤二、步骤三
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) grid[i][j] = 0;
            if (grid[i][j] == 2) grid[i][j] = 1;
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << grid[i][j] << " ";
        }
        cout << endl;
    }
}

题目三：103. 水流问题

103. 水流问题 (kamacoder.com)

解题思路

想象你有一块高低不平的地形，这块地形是一个由很多小格子组成的矩形，每个小格子都有一个高度值。现在下了一场雨，雨水会从高处流向低处，但是雨水只能流向四个方向：上、下、左、右，而且只能流向比它低或者一样高的地方。

现在，我们要找出那些雨水可以流到地形边缘的格子。地形的边缘分为两组：第一组是地形的左边界和上边界，第二组是右边界和下边界。

任务就是找出所有那些雨水可以流到这两组边界的格子，并输出这些格子的坐标。

（就是找出那些雨水可以流到地形边缘的格子，并告诉你这些格子在哪里。）

  1. 输入：你会得到一个矩形矩阵，矩阵的大小由两个数字 N 和 M 决定，N 表示行数，M 表示列数。矩阵中的每个数字代表一个小格子的高度。
  2. 输出：你需要找出所有那些雨水可以流到地形的左边界或上边界（第一组边界）的格子，以及所有雨水可以流到地形的右边界或下边界（第二组边界）的格子。然后，你需要输出这些格子的坐标。

一个比较直白的想法，其实就是 遍历每个点，然后看这个点 能不能同时到达第一组边界和第二组边界。

至于遍历方式，可以用dfs，也可以用bfs，以下用dfs来举例。

#include <iostream>
#include <vector>
using namespace std;
int n, m;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};

// 从 x，y 出发 把可以走的地方都标记上
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    if (visited[x][y]) return;

    visited[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 >= n || nexty < 0 || nexty >= m) continue;
        if (grid[x][y] < grid[nextx][nexty]) continue; // 高度不合适

        dfs (grid, visited, nextx, nexty);
    }
    return;
}
bool isResult(vector<vector<int>>& grid, int x, int y) {
    vector<vector<bool>> visited(n, vector<bool>(m, false));

    // 深搜，将x,y出发 能到的节点都标记上。
    dfs(grid, visited, x, y);
    bool isFirst = false;
    bool isSecond = false;

    // 以下就是判断x，y出发，是否到达第一组边界和第二组边界
    // 第一边界的上边
    for (int j = 0; j < m; j++) {
        if (visited[0][j]) {
            isFirst = true;
            break;
        }
    }
    // 第一边界的左边
    for (int i = 0; i < n; i++) {
        if (visited[i][0]) {
            isFirst = true;
            break;
        }
    }
    // 第二边界右边
    for (int j = 0; j < m; j++) {
        if (visited[n - 1][j]) {
            isSecond = true;
            break;
        }
    }
    // 第二边界下边
    for (int i = 0; i < n; i++) {
        if (visited[i][m - 1]) {
            isSecond = true;
            break;
        }
    }
    if (isFirst && isSecond) return true;
    return false;
}


int main() {
    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];
        }
    }
    // 遍历每一个点，看是否能同时到达第一组边界和第二组边界
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (isResult(grid, i, j)) {
                cout << i << " " << j << endl;
            }
        }
    }
}

直接对每个单元格进行深度优先搜索（DFS）会导致非常高的时间复杂度，尤其是在矩阵较大的情况下。这种直接的DFS方法在最坏情况下的时间复杂度是 O ( m 2 × n 2 ) O(m^2×n^2) O(m2×n2)，这对于大型矩阵来说是不可行的。

优化

那么我们可以 反过来想，从第一组边界上的节点 逆流而上，将遍历过的节点都标记上。

同样从第二组边界的边上节点 逆流而上，将遍历过的节点也标记上。

然后两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点。

从第一组边界边上节点出发，如图：

img

从第二组边界上节点出发，如图：

img

按照这样的逻辑，就可以写出如下遍历代码：（详细注释）

#include <iostream>
#include <vector>
using namespace std;
int n, m;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    if (visited[x][y]) return;

    visited[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 >= n || nexty < 0 || nexty >= m) continue;
        if (grid[x][y] > grid[nextx][nexty]) continue; // 注意：这里是从低向高遍历

        dfs (grid, visited, nextx, nexty);
    }
    return;
}



int main() {

    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>> firstBorder(n, vector<bool>(m, false));

    // 标记从第一组边界上的节点出发，可以遍历的节点
    vector<vector<bool>> secondBorder(n, vector<bool>(m, false));

    // 从最上和最下行的节点出发，向高处遍历
    for (int i = 0; i < n; i++) {
        dfs (grid, firstBorder, i, 0); // 遍历最左列，接触第一组边界
        dfs (grid, secondBorder, i, m - 1); // 遍历最右列，接触第二组边界
    }

    // 从最左和最右列的节点出发，向高处遍历
    for (int j = 0; j < m; j++) {
        dfs (grid, firstBorder, 0, j); // 遍历最上行，接触第一组边界
        dfs (grid, secondBorder, n - 1, j); // 遍历最下行，接触第二组边界
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            // 如果这个节点，从第一组边界和第二组边界出发都遍历过，就是结果
            if (firstBorder[i][j] && secondBorder[i][j]) cout << i << " " << j << endl;;
        }
    }


}

本题整体的时间复杂度其实是： 2 ∗ n ∗ m + n ∗ m 2 * n * m + n * m 2∗n∗m+n∗m ，所以最终时间复杂度为 O( n ∗ m n * m n∗m) 。

空间复杂度为：O(n * m) 。开了几个 n * m 的数组。

题目四：104.建造最大岛屿

104. 建造最大岛屿 (kamacoder.com)

解题思路

  1. 暴力想法：尝试将地图上的每个水域（0）变成陆地（1），然后计算这种情况下的最大岛屿面积。
  2. 计算最大面积：通过深度优先搜索（DFS）或广度优先搜索（BFS）遍历地图，标记岛屿，计算面积。这一步的时间复杂度大约是 O( n 2 n^2 n2)，因为需要遍历地图上的每个单元格。
  3. 整体时间复杂度：由于地图上有 n2 个单元格，每个单元格改变状态后都需要重新计算最大岛屿面积，所以整体时间复杂度是 O( n 4 n^4 n4)。

优化思路

  1. 记录岛屿面积：首先，遍历地图一次，使用深度优先搜索（DFS）找出所有的岛屿，并记录每个岛屿的面积。这一步可以给每个岛屿一个唯一的编号，并使用一个字典（或map）来存储岛屿编号和对应的面积。

  2. 计算最大面积：然后，再次遍历地图中的水域（0），对于每个水域单元格，计算它变成陆地（1）后，与它相邻的岛屿面积总和。这样，对于每个水域单元格，你都可以得到一个“潜在的最大面积”，即如果这个水域变成陆地，与它相邻的所有岛屿合并后的总面积。

通过这两步，你可以找到将任意一个水域单元格变成陆地后，能够得到的最大岛屿面积。这种方法避免了重复计算，提高了效率。

拿如下地图的岛屿情况来举例： （1为陆地）

img

第一步，则遍历题目，并将岛屿到编号和面积上的统计，过程如图所示：

img

本过程代码如下：

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int mark) {
    if (visited[x][y] || 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, nextx, nexty, mark);
    }
}

int largestIsland(vector<vector<int>>& grid) {
    int n = grid.size(), m = grid[0].size();
    vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false)); // 标记访问过的点
    unordered_map<int ,int> gridNum;
    int mark = 2; // 记录每个岛屿的编号
    bool isAllGrid = true; // 标记是否整个地图都是陆地
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 0) isAllGrid = false;
            if (!visited[i][j] && grid[i][j] == 1) {
                count = 0;
                dfs(grid, visited, i, j, mark); // 将与其链接的陆地都标记上 true
                gridNum[mark] = count; // 记录每一个岛屿的面积
                mark++; // 记录下一个岛屿编号
            }
        }
    }
}

这个过程时间复杂度 n * n 。可能有录友想：分明是两个for循环下面套这一个dfs，时间复杂度怎么回事 n * n呢？

其实大家可以仔细看一下代码，n * n这个方格地图中，每个节点我们就遍历一次，并不会重复遍历。

第二步过程如图所示：

img

也就是遍历每一个0的方格，并统计其相邻岛屿面积，最后取一个最大值。

这个过程的时间复杂度也为 n * n。

所以整个解法的时间复杂度，为 n * n + n * n 也就是 n 2 n^2 n2。

当然这里还有一个优化的点，就是 可以不用 visited数组，因为有mark来标记，所以遍历过的grid[i][j]是不等于1的。

代码如下：

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(vector<vector<int>>& grid, int x, int y, int mark) {
    if (grid[x][y] != 1 || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水
    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 >= n || nexty < 0 || nexty >= m) continue;  // 越界了，直接跳过
        dfs(grid, nextx, nexty, mark);
    }
}

int main() {
    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;
    int mark = 2; // 记录每个岛屿的编号
    bool isAllGrid = true; // 标记是否整个地图都是陆地
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 0) isAllGrid = false;
            if (grid[i][j] == 1) {
                count = 0;
                dfs(grid, i, j, mark); // 将与其链接的陆地都标记上 true
                gridNum[mark] = count; // 记录每一个岛屿的面积
                mark++; // 记录下一个岛屿编号
            }
        }
    }

不过为了让各个变量各司其事，代码清晰一些，完整代码还是使用visited数组来标记。

最后，整体代码如下：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <unordered_map>
using namespace std;
int n, m;
int count;

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int mark) {
    if (visited[x][y] || 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 >= n || nexty < 0 || nexty >= m) continue;  // 越界了，直接跳过
        dfs(grid, visited, nextx, nexty, mark);
    }
}

int main() {
    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)); // 标记访问过的点
    unordered_map<int ,int> gridNum;
    int mark = 2; // 记录每个岛屿的编号
    bool isAllGrid = true; // 标记是否整个地图都是陆地
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 0) isAllGrid = false;
            if (!visited[i][j] && grid[i][j] == 1) {
                count = 0;
                dfs(grid, visited, i, j, mark); // 将与其链接的陆地都标记上 true
                gridNum[mark] = count; // 记录每一个岛屿的面积
                mark++; // 记录下一个岛屿编号
            }
        }
    }
    if (isAllGrid) {
        cout << n * m << endl; // 如果都是陆地，返回全面积
        return 0; // 结束程序
    }

    // 以下逻辑是根据添加陆地的位置，计算周边岛屿面积之和
    int result = 0; // 记录最后结果
    unordered_set<int> visitedGrid; // 标记访问过的岛屿
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            count = 1; // 记录连接之后的岛屿数量
            visitedGrid.clear(); // 每次使用时，清空
            if (grid[i][j] == 0) {
                for (int k = 0; k < 4; k++) {
                    int neari = i + dir[k][1]; // 计算相邻坐标
                    int nearj = j + dir[k][0];
                    if (neari < 0 || neari >= n || nearj < 0 || nearj >= m) continue;
                    if (visitedGrid.count(grid[neari][nearj])) continue; // 添加过的岛屿不要重复添加
                    // 把相邻四面的岛屿数量加起来
                    count += gridNum[grid[neari][nearj]];
                    visitedGrid.insert(grid[neari][nearj]); // 标记该岛屿已经添加过
                }
            }
            result = max(result, count);
        }
    }
    cout << result << endl;

}

总结

坚持！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2155382.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Windows11+Microsoft MPI v10.1.3 安装配置记录

Windows11+Microsoft MPI v10.1.3 安装配置记录

WindowsMicrosoft MPI v10.1.3 安装配置记录 MS-MPI 安装VS中进行配置属性管理器-添加新项目属性表VC目录-包含目录链接器-常规-附加库目录链接器-输入-附加依赖项 测试 某个项目需要MPI支持&#xff0c;在此记录MS MPI的安装配置过程。 MS-MPI 安装 在微软官网下载 两个都下…
阅读更多...
去中心化的力量：探索Web3的分布式网络

去中心化的力量：探索Web3的分布式网络

Web3作为一种新兴的网络架构&#xff0c;代表了对互联网发展的一种探索。与传统的中心化互联网模式相比&#xff0c;Web3致力于通过去中心化的方式构建更加开放和透明的数字世界。本文将探讨Web3的核心理念、技术实现及其潜在应用。 一、去中心化的核心理念 Web3的去中心化理…
阅读更多...
深度学习02-pytorch-06-张量的形状操作

深度学习02-pytorch-06-张量的形状操作

在 PyTorch 中&#xff0c;张量的形状操作是非常重要的&#xff0c;可以让你灵活地调整和处理张量的维度和数据结构。以下是一些常用的张量形状函数及其用法&#xff0c;带有详细解释和举例说明&#xff1a; 1. reshape() 功能: 改变张量的形状&#xff0c;但不改变数据的顺序…
阅读更多...
Stable Diffusion 使用详解（12）--- 设计师风格变换

Stable Diffusion 使用详解（12）--- 设计师风格变换

目录 背景 seg模型&#xff08;语义分割&#xff09; 描述 原理 实战-装修风格变换 现代风格 欧式风格转换 提示词及相关参数设置 模型选择 seg cn 加持 效果 还能做点啥 问题 解决方法 出图效果 二次优化调整 二次出图效果 地中海风格转换 参数修改 效果 …
阅读更多...
软硬件项目运维方案（Doc原件完整版套用）

软硬件项目运维方案（Doc原件完整版套用）

1 系统的服务内容 1.1 服务目标 1.2 信息资产统计服务 1.3 网络、安全系统运维服务 1.4 主机、存储系统运维服务 1.5 数据库系统运维服务 1.6 中间件运维服务 2 运维服务流程 3 服务管理制度规范 3.1 服务时间 3.2 行为规范 3.3 现场服务支持规范 3.4 问题记录规范…
阅读更多...
C++容器list底层迭代器的实现逻辑~list相关函数模拟实现

C++容器list底层迭代器的实现逻辑~list相关函数模拟实现

目录 1.两个基本的结构体搭建 2.实现push_back函数 3.关于list现状的分析&#xff08;对于我们如何实现这个迭代器很重要&#xff09; 3.1和string,vector的比较 3.2对于list的分析 3.3总结 4.迭代器类的封装 5.list容器里面其他函数的实现 6.个人总结 7.代码附录 1.两…
阅读更多...
【C++ Primer Plus习题】17.1

【C++ Primer Plus习题】17.1

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: #include <iostream> using namespace std;int main() {char …
阅读更多...
移动登录页：让用户开启一段美好的旅程吧。

移动登录页：让用户开启一段美好的旅程吧。

Hi,大家好&#xff0c;我是大千UI工场&#xff0c;移动登录页千千万&#xff0c;这里最好看&#xff0c;本期分享一批移动端的登录页面&#xff0c;供大家欣赏。 本次分享的是毛玻璃/3D风格的登录页。
阅读更多...
【Unity设计模式】Unity MVC/MVP架构介绍，及MVC/MVP框架的简单应用

【Unity设计模式】Unity MVC/MVP架构介绍，及MVC/MVP框架的简单应用

文章目录 什么是MVC&#xff1f;MVC眼花缭乱设计图MVP和MVC最经典的MVC的业务流程Unity MVC 框架示例1. 创建项目结构2. 实现模型3. 实现视图4. 实现控制器5. 使用示例 总结参考完结 什么是MVC&#xff1f; MVC自1982年被设计出来&#xff0c;至今都有着很大比重的使用率&…
阅读更多...
前端项目代码开发规范及工具配置

前端项目代码开发规范及工具配置

在项目开发中&#xff0c;良好的代码编写规范是项目组成的重要元素。本文将详细介绍在项目开发中如何集成相应的代码规范插件及使用方法。 项目规范及工具 集成 EditorConfig集成 Prettier1. 安装 Prettier2. 创建 Prettier 配置文件3. 配置 .prettierrc4. 使用 Prettier 集成 …
阅读更多...
python--基础语法（2）

python--基础语法（2）

1.顺序语句 默认情况下&#xff0c;Python的代码执行顺序是按照从上到下的顺序&#xff0c;依次执行的。 2.条件语句 条件语句能够表达“如果 ...否则 ...”这样的语义这构成了计算机中基础的逻辑判定条件语&#xff0c; 也叫做 分支语句。表示了接下来的逻辑可能有几种走向…
阅读更多...
HOSTS文件劫持--导致笔记本网络卡顿

HOSTS文件劫持--导致笔记本网络卡顿

写在前面&#xff1a; 因为笔记本网速卡顿&#xff0c;去维修店维修网卡&#xff0c;网卡咱们测试都没有问题&#xff0c;一直吐槽售后服务一般。自己也装过几次系统了 点击任务栏中的搜索图标&#xff0c;输入"cmd"&#xff0c;点击"命令提示符"选择&qu…
阅读更多...
笔记整理—内核！启动！—linux应用编程、网络编程部分（2）linux的文件管理策略

笔记整理—内核！启动！—linux应用编程、网络编程部分（2）linux的文件管理策略

关于硬盘中的静态文件与inode&#xff1a;例如文件存储在扇区中&#xff0c;一个文件占用10个字节&#xff0c;一个扇区为512字节&#xff0c;这样的情况下一个扇区就只放了一个实际为10字节的文件&#xff0c;余下的502字节不可存放其他文件&#xff0c;因为扇区已经是可以访问…
阅读更多...
C++入门(07)标准输入输出_cin

C++入门(07)标准输入输出_cin

文章目录 4.cin4.1 基本功能4.2 常见数据类型的输入4.3 cin多项输入中的分隔符如果需要将空格作为输入的一部分读入 4.4 使用 cin 一次读取多个整数方法一方法二 接上一篇 cout C入门(07)标准输入输出_cout、缓冲、\n endl 4.cin 4.1 基本功能 C 标准输入 cin 是一个控制台输…
阅读更多...
LLMs之MemLong：《MemLong: Memory-Augmented Retrieval for Long Text Modeling》翻译与解读

LLMs之MemLong：《MemLong: Memory-Augmented Retrieval for Long Text Modeling》翻译与解读

LLMs之MemLong&#xff1a;《MemLong: Memory-Augmented Retrieval for Long Text Modeling》翻译与解读 导读&#xff1a;MemLong 是一种新颖高效的解决 LLM 长文本处理难题的方法&#xff0c;它通过外部检索器获取历史信息&#xff0c;并将其与模型的内部检索过程相结合&…
阅读更多...
IPsec-VPN中文解释

IPsec-VPN中文解释

网络括谱图 IPSec-VPN 配置思路 1 配置IP地址 FWA:IP地址的配置 [FW1000-A]interface GigabitEthernet 1/0/0 [FW1000-A-GigabitEthernet1/0/0]ip address 10.1.1.1 24 //配置IP地址 [FW1000-A]interface GigabitEthernet 1/0/2 [FW1000-A-GigabitEthernet1/0/2]ip a…
阅读更多...
C#测试调用PdfiumViewer浏览PDF文件的基本用法

C#测试调用PdfiumViewer浏览PDF文件的基本用法

印章管理项目后续准备实现打开浏览PDF文件并进行盖章的功能&#xff0c;需要在Winform中使用控件在线浏览PDF文件&#xff0c;在网上找了几个开源的PDF浏览控件进行测试&#xff0c;以便应用于印章管理项目。本文测试调用PdfiumViewer模块打开及浏览PDF文件。   PdfiumViewer…
阅读更多...
VisionPro - 基础 - 模板匹配技术和在VP中的使用 - PMAlign - PatMax（4）- 控制模板的匹配

VisionPro - 基础 - 模板匹配技术和在VP中的使用 - PMAlign - PatMax（4）- 控制模板的匹配

前言&#xff1a; 针对PatMax 的高级应用和原理&#xff0c;在这一节继续进行说明&#xff1a;这一节主要考虑的是PatMax模板匹配的原理&#xff1a;如何控制模板的匹配。 本节先介绍了几个模板匹配的衡量标准&#xff0c;比如模板匹配分数&#xff0c;和模板的几种模板匹配的…
阅读更多...
JAVA并发编程系列之Semaphore信号量剖析

JAVA并发编程系列之Semaphore信号量剖析

腾讯T2面试&#xff0c;现场限时3分钟限最多20行代码&#xff0c;模拟地铁口安检进站。其中安检入口10个&#xff0c;当前排队人数是100个&#xff0c;每个人安检进站耗时5秒。开始吧! 候选人&#xff0c;心中万马奔腾&#xff01;&#xff01;&#xff01;吐了一口82年老血&am…
阅读更多...
re题(37)BUUCTF-[GWCTF 2019]xxor

re题(37)BUUCTF-[GWCTF 2019]xxor

BUUCTF在线评测 (buuoj.cn) 用ida打开文件&#xff0c;ctrle定位main函数 也可以用shiftF12查找字符串&#xff0c;找与我们解题有关的字符串 通过字符串定位到引用字符串的函数 进入main entry 但还不是我们要分析的代码 进入__libc_start_main中的main参数&#xff0c;是我们…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023