代码随想录Day 25|回溯篇完结，题目：491.递增子序列、46、全排列、47.全排列Ⅱ

news2024/11/15 11:13:59

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

文章目录

  • 第七章 回溯算法part05
  • 一、题目
    • 题目一：491.递增子序列
      • 解题思路：
      • 回溯三部曲
      • 优化
    • 题目二：46.全排列
      • [46. 全排列](https://leetcode.cn/problems/permutations/)
      • 解题思路：
      • 回溯三部曲
    • 题目三：47.全排列 II
      • 解题思路
    • 拓展
    • 题目四：51. N皇后
      • 解题思路
    • 题目五：37.解数独
      • 解题思路：
      • 回溯三部曲
      • 判断棋盘是否合法
  • 总结

第七章 回溯算法part05

回溯算法的收尾

一、题目

题目一：491.递增子序列

93. 复原 IP 地址

解题思路：

这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

取子集 + 去重

本题求自增子序列，在处理自增子序列问题时，应避免对原数组进行排序，并且可以考虑使用 set 来有效地去除重复的子序列。这种方法既保持了数组的原始顺序，又能够确保结果的正确性。

使用used数组进行去重是更通用的一种方式。

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

491. 递增子序列1

回溯三部曲

本题求子序列，很明显一个元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置。

  • 递归函数参数
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex)
  • 递归终止条件

本题收集结果有所不同，题目要求递增子序列大小至少为2，所以代码如下：

if (path.size() > 1) {
    result.push_back(path);
    // 注意这里不要加return，因为要取树上的所有节点
}
  • 单层搜索的逻辑
491. 递增子序列1

在图中可以看出，同一父节点下的同层上使用过的元素就不能再使用了

那么单层搜索代码如下：

unordered_set<int> uset; // 使用set来对本层元素进行去重
for (int i = startIndex; i < nums.size(); i++) {
    if ((!path.empty() && nums[i] < path.back())
            || uset.find(nums[i]) != uset.end()) {
            continue;
    }
    uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
    path.push_back(nums[i]);
    backtracking(nums, i + 1);
    path.pop_back();
}

这也是需要注意的点，unordered_set<int> uset; 是记录本层元素是否重复使用，新的一层uset都会重新定义（清空），所以要知道uset只负责本层！

最后整体C++代码如下：

// 版本一
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
            // 注意这里不要加return，要取树上的节点
        }
        unordered_set<int> uset; // 使用set对本层元素进行去重
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || uset.find(nums[i]) != uset.end()) {
                    continue;
            }
            uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};
  • 时间复杂度: O(n * 2^n)
  • 空间复杂度: O(n）

优化

在这个特定问题中，用一个简单的数组来记录哪些元素已经被用过，比用复杂的unordered_set要来得快，因为数组访问速度快，不需要额外的哈希计算和扩容操作。

  1. 使用unordered_set的问题：在编程中，unordered_set是一个用来存放不重复元素的数据结构，它通过哈希函数来快速查找元素。但是，当你频繁地往里面添加元素时，如果元素很多，unordered_set就需要花时间来重新调整自己的内部结构，这个过程叫做“扩容”，是挺耗时间的。
  2. 数组作为哈希表的优势：题目告诉我们数值的范围是[-100, 100]，也就是说元素的取值范围很小，只有201个可能的数值（包括0）。这样，我们就可以用一个大小为201的数组来代替unordered_set。数组的每个位置对应一个数值，如果数组的某个位置已经被用过了，我们就不往那个位置再放东西，这样就避免了重复。
  3. 效率问题：使用数组来做这件事情，效率会更高。因为数组的访问速度很快，几乎是立即可以知道一个元素是否已经被使用过，不需要像unordered_set那样每次都要计算哈希值，然后再查找。
  4. 为什么不用unordered_set：虽然unordered_set在元素数量很多且分布广泛时很有用，但在这个问题中，由于元素数量有限且范围已知，使用数组作为哈希表会更简单、更快速。

完整代码:

// 版本二
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
        }
        int used[201] = {0}; // 这里使用数组来进行去重操作，题目说数值范围[-100, 100]
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || used[nums[i] + 100] == 1) {
                    continue;
            }
            used[nums[i] + 100] = 1; // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

数组，set，map都可以做哈希表，而且数组干的活，map和set都能干，但如果数值范围小的话能用数组尽量用数组。

题目二：46.全排列

46. 全排列

解题思路：

抽象成树形结构如下：

全排列

回溯三部曲

  • 确定递归函数参数

首先排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方。

可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。

但排列问题需要一个used数组，标记已经选择的元素，如图橘黄色部分所示:

全排列 
vector<vector<int>> result;
vector<int> path;
void backtracking (vector<int>& nums, vector<bool>& used)
  • 确定终止条件

当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

// 此时说明找到了一组
if (path.size() == nums.size()) {
    result.push_back(path);
    return;
}
  • 单层搜索过程

used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。

代码如下：

for (int i = 0; i < nums.size(); i++) {
    if (used[i] == true) continue; // path里已经收录的元素，直接跳过
    used[i] = true;
    path.push_back(nums[i]);
    backtracking(nums, used);
    path.pop_back();
    used[i] = false;
}

回溯算法的模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

回溯三部曲分析完了，整体C++代码如下：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking (vector<int>& nums, vector<bool>& used) {
        // 此时说明找到了一组
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue; // path里已经收录的元素，直接跳过
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};
  • 时间复杂度: O(n!)
  • 空间复杂度: O(n)

小结：

排列问题的不同：

  • 每层都是从0开始搜索而不是startIndex
  • 需要used数组记录path里都放了哪些元素了

题目三：47.全排列 II

47. 全排列 II

解题思路

强调的是去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

以示例中的 [1,1,2]为例 （为了方便举例，已经排序）抽象为一棵树，去重过程如图：

47.全排列II1

图中我们对同一树层，前一位（也就是nums[i-1]）如果使用过，那么就进行去重。

一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

完整的代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking (vector<int>& nums, vector<bool>& used) {
        // 此时说明找到了一组
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 排序
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

// 时间复杂度: 最差情况所有元素都是唯一的。复杂度和全排列1都是 O(n! * n) 对于 n 个元素一共有 n! 中排列方案。而对于每一个答案，我们需要 O(n) 去复制最终放到 result 数组
// 空间复杂度: O(n) 回溯树的深度取决于我们有多少个元素
  • 时间复杂度: O(n! * n)
  • 空间复杂度: O(n)

拓展

去重最为关键的代码为：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
    continue;
}

如果改成 used[i - 1] == true， 也是正确的!，去重代码如下：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) {
    continue;
}

这是为什么呢，如果要对树层中前一位去重，就用used[i - 1] == false，如果要对树枝前一位去重用used[i - 1] == true。

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！

题目四：51. N皇后

51. N 皇后

解题思路

都知道n皇后问题是回溯算法解决的经典问题，但是用回溯解决多了组合、切割、子集、排列问题之后，遇到这种二维矩阵还会有点不知所措。

首先来看一下皇后们的约束条件：

  1. 不能同行
  2. 不能同列
  3. 不能同斜线

确定完约束条件，来看看究竟要怎么去搜索皇后们的位置，其实搜索皇后的位置，可以抽象为一棵树。

51.N皇后

从图中，可以看出，二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。

那么我们用皇后们的约束条件，来回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

  • 验证棋盘是否合法
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}

完整的C++回溯代码：

class Solution {
private:
vector<vector<string>> result;
// n 为输入的棋盘大小
// row 是当前递归到棋盘的第几行了
void backtracking(int n, int row, vector<string>& chessboard) {
    if (row == n) {
        result.push_back(chessboard);
        return;
    }
    for (int col = 0; col < n; col++) {
        if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
            chessboard[row][col] = 'Q'; // 放置皇后
            backtracking(n, row + 1, chessboard);
            chessboard[row][col] = '.'; // 回溯，撤销皇后
        }
    }
}
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};
  • 时间复杂度: O(n!)
  • 空间复杂度: O(n)

棋盘的宽度就是for循环的长度，递归的深度就是棋盘的高度，这样就可以套进回溯法的模板里了。

题目五：37.解数独

37. 解数独

解题思路：

棋盘搜索问题可以使用回溯法暴力搜索，只不过这次我们要做的是二维递归。

怎么做二维递归呢？

树形结构太大了，抽取一部分，如图所示：

37.解数独

回溯三部曲

  • 递归函数以及参数

递归函数的返回值需要是bool类型，为什么呢？

因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。

bool backtracking(vector<vector<char>>& board)
  • 递归终止条件

本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。

不用终止条件会不会死循环？

递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！

  • 递归单层搜索逻辑

在树形图中可以看出我们需要的是一个二维的递归 （一行一列）

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

代码如下：（详细看注释）

bool backtracking(vector<vector<char>>& board) {
    for (int i = 0; i < board.size(); i++) {        // 遍历行
        for (int j = 0; j < board[0].size(); j++) { // 遍历列
            if (board[i][j] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) {
                    board[i][j] = k;                // 放置k
                    if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                    board[i][j] = '.';              // 回溯，撤销k
                }
            }
            return false;                           // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}

注意这里return false的地方，这里放return false 是有讲究的。

因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！

那么会直接返回， 这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！

判断棋盘是否合法

判断棋盘是否合法有如下三个维度：

  • 同行是否重复
  • 同列是否重复
  • 9宫格里是否重复
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
    for (int i = 0; i < 9; i++) { // 判断行里是否重复
        if (board[row][i] == val) {
            return false;
        }
    }
    for (int j = 0; j < 9; j++) { // 判断列里是否重复
        if (board[j][col] == val) {
            return false;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}

最后的完整代码；

class Solution {
private:
bool backtracking(vector<vector<char>>& board) {
    for (int i = 0; i < board.size(); i++) {        // 遍历行
        for (int j = 0; j < board[0].size(); j++) { // 遍历列
            if (board[i][j] == '.') {
                for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                    if (isValid(i, j, k, board)) {
                        board[i][j] = k;                // 放置k
                        if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                        board[i][j] = '.';              // 回溯，撤销k
                    }
                }
                return false;  // 9个数都试完了，都不行，那么就返回false
            }
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
    for (int i = 0; i < 9; i++) { // 判断行里是否重复
        if (board[row][i] == val) {
            return false;
        }
    }
    for (int j = 0; j < 9; j++) { // 判断列里是否重复
        if (board[j][col] == val) {
            return false;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

总结

  • 使用unordered_set,作为去重的逻辑。只限于自增子序列，不能手动排序。
  • 全排列无startIndex的使用，顺序是必要的。
  • 使用used数组，在排列问题上，树层和树枝去重都可以。

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

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

相关文章

日撸Java三百行（day34：图的深度优先遍历）

日撸Java三百行（day34：图的深度优先遍历）

目录 一、深度优先搜索 二、图的深度优先遍历 三、代码实现 总结 一、深度优先搜索 深度优先搜索&#xff08;Depth First Search&#xff1a;DFS&#xff09;是一种用于遍历树或图的算法&#xff0c;具体来说就是从起始节点开始&#xff0c;沿某一分支路径不断深入&#…
阅读更多...
Linux内核定时器、阻塞_非阻塞IO

Linux内核定时器、阻塞_非阻塞IO

一.内核时间管理 Linux 内核中有大量的函数需要时间管理,比如周期性的调度程序、延时程序、对于我们驱动编写者来说最常用的定时器。硬件定时器提供时钟源,时钟源的频率可以设置, 设置好以后就周期性的产生定时中断,系统使用定时中断来计时。中断周期性产生的频率就是系统频率…
阅读更多...
吴恩达谈AI未来：Agentic Workflow、推理成本下降与开源的优势

吴恩达谈AI未来：Agentic Workflow、推理成本下降与开源的优势

近年来&#xff0c;人工智能&#xff08;AI&#xff09;领域的发展势如破竹&#xff0c;然而随着技术的普及&#xff0c;市场也开始出现对AI泡沫的质疑声。2024年8月&#xff0c;AI领域的权威专家吴恩达&#xff08;Andrew Ng&#xff09;在与ARK Invest的对谈中&#xff0c;分…
阅读更多...
利用Matlab求解高阶微分方程（ode45）

利用Matlab求解高阶微分方程（ode45）

1、高阶微分方程的基本概念 二阶以及二阶以上的微分方程称之为高阶微分方程&#xff0c;一般来说&#xff0c;微分方程的阶数越高&#xff0c;求解的难度也就越大。求高阶方程的一个常用方法就是降低阶数。对二阶方程 &#xff0c;如果能用变量代换把它化成一阶方程&#xff0c…
阅读更多...
【Tesla FSD V12的前世今生】从模块化设计到端到端自动驾驶技术的跃迁

【Tesla FSD V12的前世今生】从模块化设计到端到端自动驾驶技术的跃迁

自动驾驶技术的发展一直是全球汽车行业的焦点&#xff0c;Tesla的Full-Self Driving&#xff08;FSD&#xff09;系统凭借其持续的技术革新和强大的数据支持&#xff0c;在这个领域独占鳌头。本文将深入介绍Tesla FSD V12的演进历史&#xff0c;从自动驾驶的基础概念入手&#…
阅读更多...
【XML详解】

【XML详解】

XML基本概念 XML&#xff08;全称EXtensible Markup Language&#xff0c;可扩展标记语言&#xff09;&#xff1a;是一种用于存储和传输数据的标记语言&#xff0c;通过标签&#xff08;tags&#xff09;来定义数据的结构和含义。数据格式&#xff1a;XML本质上是一种数据的格…
阅读更多...
【异常错误】pycharm可以在terminal中运行，但是无法在run中运行（没有输出错误就停止了）

【异常错误】pycharm可以在terminal中运行，但是无法在run中运行（没有输出错误就停止了）

问题&#xff1a; pycharm的命令可以在terminal中运行&#xff0c;但是复制到无法在run中运行&#xff08;没有输出错误就停止了&#xff09; run中运行后什么错误提示都没有 搞不懂为什么 解决&#xff1a; 降低run中batch-size的大小&#xff0c;即可以运行 我并没有观察到…
阅读更多...
视频在线去水印解析相册怎么弄,轻松掌握五大技巧

视频在线去水印解析相册怎么弄,轻松掌握五大技巧

在当前短视频流行的时代&#xff0c;我们常常需要下载一些短视频来进行剪辑或分享&#xff0c;但视频中的水印却成了一个不小的烦恼。为了帮助大家解决这个问题&#xff0c;本文将介绍五款高效的短视频去水印免费软件&#xff0c;让你轻松告别水印烦恼。 工具一&#xff1a;奈…
阅读更多...
在VB.net中，LINQ有什么方法与属性

在VB.net中，LINQ有什么方法与属性

标题 在VB.net中&#xff0c;LINQ有什么方法与属性 正文 在VB.NET中使用LINQ&#xff08;Language Integrated Query&#xff09;&#xff0c;你可以利用一系列的方法和属性来查询和操作内存中的集合&#xff08;如数组、列表等&#xff09;以及数据库等数据源。LINQ提供了丰富…
阅读更多...
Python相关系数导图

Python相关系数导图

&#x1f3af;要点 量化变量和特征关联绘图对比皮尔逊相关系数、斯皮尔曼氏秩和肯德尔秩汽车性价比相关性矩阵热图大流行病与资产波动城镇化模型预测交通量宝可梦类别特征非线性依赖性捕捉向量加权皮尔逊相关系数量化图像相似性 Python皮尔逊-斯皮尔曼-肯德尔 皮尔逊相关系…
阅读更多...
QcomboBox 组件

QcomboBox 组件

在记事本项目中&#xff0c;有一个问题&#xff0c;字体的编码格式是写死的。我们要建一个 组件提供这样的功能&#xff1a;通过点击&#xff0c;获得 不同的格式编码 定义它的槽 首先 把ui里面的comboBox组件与槽关联起来 connect(ui->comboBox,SIGNAL(currentIndexChange…
阅读更多...
cesium加载矢量切片数据（mvt）全网方案总结

cesium加载矢量切片数据（mvt）全网方案总结

引言：Cesium是一款开源的3D地球可视化引擎，支持全球范围的数据展示，包括高分辨率地形、卫星图像和建筑模型等，允许用户创建交互式的3D地图，并提供了一系列的工具和API来处理地理空间数据。 Cesium支持加载多数据源的栅格切片数据，例如ArcGIS、BingMaps、WMTS、WMS等等。栅…
阅读更多...
Qt 线程与窗体之间的传值

Qt 线程与窗体之间的传值

QThread 和窗口之间的通信通常通过信号和槽机制来实现 也可以直接通过调用线程中的值 效果图(Dialog To hello; TextLabel To hello) 在主窗口类中创建线程实例&#xff0c;并连接线程发出的信号到主窗口的槽函数。 .h #ifndef TESTAPP_H #define TESTAPP_H#include <QD…
阅读更多...
Threejs学习-Stats 性能监控器、抗锯齿

Threejs学习-Stats 性能监控器、抗锯齿

stats性能监控器 import Stats from three/addons/libs/stats.module.js //引入包//添加性能监视器&#xff0c;查看帧率 const stats new Stats(); document.body.appendChild(stats.domElement); // //渲染 function animate() {requestAnimationFrame(animate);stats.upda…
阅读更多...
GraphRAG论文解读

GraphRAG论文解读

欢迎一起讨论 论文地址综述介绍部分核心翻译翻译解释重要的信息元素和实体的关系&#xff08;包含和被包含&#xff0c;而非相等&#xff09;Graph Index&#xff08;图索引&#xff09;Community Detection&#xff08;社区检测&#xff09;Query-Focused Summarization&#…
阅读更多...
Qt+FFmpeg开发视频播放器笔记(二)：界面UI搭建

Qt+FFmpeg开发视频播放器笔记(二)：界面UI搭建

效果图 主要使用无边框窗体搭建,实现窗体的拖动和缩放&#xff0c;播放列表、文件打开等。 主要代码 manwindow设计类 #ifndef MAINWINDOW_H #define MAINWINDOW_H#include <QMainWindow> #include <QMutex> #include "framelesshelper.h"QT_BEGIN_NA…
阅读更多...
力扣最热一百题——6.三数之和

力扣最热一百题——6.三数之和

目录 题目链接&#xff1a;15. 三数之和 - 力扣&#xff08;LeetCode&#xff09; 题目描述 示例 提示 解法一&#xff1a;双指针 代码分析 总结 没啥多说的&#xff0c;就是最近CS根本上不了分谢谢。 题目链接&#xff1a;15. 三数之和 - 力扣&#xff08;LeetCode&…
阅读更多...
NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis 精读

NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis 精读

1 传统视图合成和NeRF&#xff08;Neural Radiance Fields&#xff09; 1.1 联系 传统视图合成和NeRF的共同目标都是从已有的视角图像中生成新的视角图像。两者都利用已有的多视角图像数据来预测或合成从未见过的视角。 1.2 区别 1.2.1 几何表示方式 传统视图合成&#xff…
阅读更多...
frameworks 之InputReader

frameworks 之InputReader

frameworks 之InputReader InputManagerService 初始化InputManagerService 启动InputReader 事件的读取设备节点注册和监听设备输入事件的读取 InputReader 事件的处理设备的添加和删除处理触摸事件的处理数据的加工和分发 android 输入事件 主要分 2个流程 事件读取 和 事件…
阅读更多...
先进提示词工程

先进提示词工程

大型语言模型 (LLM) 的普及彻底改变了我们人类解决问题的方式。在过去&#xff0c;用计算机解决任何任务&#xff08;例如&#xff0c;重新格式化文档或对句子进行分类&#xff09;都需要创建一个程序&#xff08;即根据某种编程语言精确编写的一组命令&#xff09;。使用 LLM&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023