算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习一（leetcode真题剖析）

在这里插入图片描述

算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习一

  • 01.全排列
  • 02.子集
  • 03.找出所有子集的异或总和再求和
  • 04.全排列 II
  • 05.电话号码的字母组合

01.全排列

题目链接：https://leetcode.cn/problems/permutations/

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示：

  • 1 <= nums.length <= 6
  • -10 <= nums[i] <= 10
  • nums 中的所有整数 互不相同

思路
这是一个典型的回溯问题，需要在每个位置上考虑所有可能情况，并确保不出现重复。通过深度优先搜索的方式，不断枚举每个数在当前位置的可能性，然后回溯到上一个状态，直到枚举完所有可能性得到正确的结果。

在这个问题中，可以通过一个递归函数 backtrack 和一个标记数组 visited 来实现全排列。递归函数的核心思想是在当前位置尝试放置每个数字，然后递归到下一层。同时，使用 visited 数组来判断某个数字是否已经在之前的位置出现过，以确保全排列的唯一性。

代码

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool cheak[7];
public:
    vector<vector<int>> permute(vector<int>& nums) {
        dfs(nums);
        return ret;
    }

    void dfs(vector<int>& nums){
        if(path.size()==nums.size()){
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();++i){
            if(!cheak[i]){
                path.push_back(nums[i]);
                cheak[i]=true;
                dfs(nums);
                path.pop_back();
                cheak[i]=false;
            }
        }
    }
};

02.子集

题目链接：https://leetcode.cn/problems/subsets/

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10
  • nums 中的所有元素 互不相同

思路

这里我们我们可以有下面两种写法，我们结合代码解释

代码一

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums, 0);
        return ret;
    }

    void dfs(vector<int>& nums, int pos) {
        ret.push_back(path);

        for (int i = pos; i < nums.size(); ++i) {
            path.push_back(nums[i]);
            dfs(nums, i + 1);
            path.pop_back();
        }
    }
};

这段代码使用深度优先搜索（DFS）的思想。主要过程如下：

  1. 在dfs函数的一开始，将当前子集 path 加入结果集 ret。
  2. 然后使用循环，从当前位置 pos 开始遍历数组 nums。
  3. 对于每个元素，将其加入当前子集 path，然后递归调用 dfs 函数，继续生成包含当前元素的子集。
  4. 递归完成后，回溯，将刚刚加入的元素从当前子集 path 移出，继续循环遍历下一个元素。

这样，通过深度优先搜索，代码逐步生成了包含不同数量元素的所有子集。

代码二

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums, 0);
        return ret;
    }

    void dfs(vector<int>& nums, int pos) {
        if (pos == nums.size()) {
            ret.push_back(path);
            return;
        }

        path.push_back(nums[pos]);
        dfs(nums, pos + 1);
        path.pop_back();

        dfs(nums, pos + 1);
    }
};

这段代码同样使用深度优先搜索的思想。主要过程如下：

  1. 在dfs函数的一开始，检查当前位置 pos 是否等于数组 nums 的大小。如果相等，表示已经处理完所有元素，将当前子集 path 加入结果集 ret，然后返回结束当前 DFS 分支。
  2. 如果当前位置 pos 不等于数组大小，将当前元素加入子集 path，然后递归调用 dfs 函数，继续生成包含当前元素的子集。
  3. 递归完成后，回溯，将刚刚加入的元素从当前子集 path 移出。
  4. 继续递归调用 dfs 函数，生成不包含当前元素的子集。

这样，同样通过深度优先搜索，代码逐步生成了包含不同数量元素的所有子集。这种实现方式在递归的不同阶段进行了两次递归调用，一次是包含当前元素的情况，一次是不包含当前元素的情况。

03.找出所有子集的异或总和再求和

题目链接：https://leetcode.cn/problems/sum-of-all-subset-xor-totals/

一个数组的 异或总和 定义为数组中所有元素按位 XOR 的结果；如果数组为 空 ，则异或总和为 0 。

  • 例如，数组 [2,5,6] 的 异或总和 为 2 XOR 5 XOR 6 = 1 。

给你一个数组 nums ，请你求出 nums 中每个 子集 的 异或总和 ，计算并返回这些值相加之 和 。

**注意：**在本题中，元素 相同 的不同子集应 多次 计数。

数组 a 是数组 b 的一个 子集 的前提条件是：从 b 删除几个（也可能不删除）元素能够得到 a 。

示例 1：

输入：nums = [1,3]
输出：6
解释：[1,3] 共有 4 个子集：
- 空子集的异或总和是 0 。
- [1] 的异或总和为 1 。
- [3] 的异或总和为 3 。
- [1,3] 的异或总和为 1 XOR 3 = 2 。
0 + 1 + 3 + 2 = 6

示例 2：

输入：nums = [5,1,6]
输出：28
解释：[5,1,6] 共有 8 个子集：
- 空子集的异或总和是 0 。
- [5] 的异或总和为 5 。
- [1] 的异或总和为 1 。
- [6] 的异或总和为 6 。
- [5,1] 的异或总和为 5 XOR 1 = 4 。
- [5,6] 的异或总和为 5 XOR 6 = 3 。
- [1,6] 的异或总和为 1 XOR 6 = 7 。
- [5,1,6] 的异或总和为 5 XOR 1 XOR 6 = 2 。
0 + 5 + 1 + 6 + 4 + 3 + 7 + 2 = 28

示例 3：

输入：nums = [3,4,5,6,7,8]
输出：480
解释：每个子集的全部异或总和值之和为 480 。

提示：

  • 1 <= nums.length <= 12
  • 1 <= nums[i] <= 20

思路

这一题实际上还是和上一题类似的子集问题，只不过我们将存下的数组变为了一个值，进数组变为子集累计异或的值，出临时数组变为异或相同值，也就是删除异或过的数。

代码

class Solution {
    int sum=0,path=0;
public:
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        return sum;
    }

    void dfs(vector<int>& nums,int pos){
        sum+=path;

        for(int i=pos;i<nums.size();++i){
            path^=nums[i];
            dfs(nums,i+1);
            path^=nums[i];
        }
    }
};
  1. int sum = 0, path = 0;: 这两个类成员变量用于追踪异或和的总和 (sum) 和当前正在生成的子集异或和 (path)。
  2. int subsetXORSum(vector<int>& nums): 这是主函数，用于调用 DFS 函数，并返回最终的异或和结果。
  3. void dfs(vector<int>& nums, int pos): 这是深度优先搜索（DFS）函数，用于递归生成所有子集的异或和。
    • sum += path;: 在每一层递归中，将当前子集的异或和加到总和中。
    • for(int i = pos; i < nums.size(); ++i) {: 循环从当前位置 pos 开始遍历数组 nums。
    • path ^= nums[i];: 将当前元素 nums[i] 异或到当前子集异或和中。
    • dfs(nums, i + 1);: 递归调用 DFS 函数，以 i + 1 为新的起点，生成包含当前元素的子集异或和。
    • path ^= nums[i];: 回溯，将刚刚异或的元素从当前子集异或和中移出，继续循环遍历下一个元素。
  4. 最终，sum 存储了所有子集的异或和总和，该值作为结果返回。

04.全排列 II

题目链接：https://leetcode.cn/problems/permutations-ii/

定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

思路

这里要考虑全排列，在同一节点的所有组合中，相同的元素只能选择一次，所以这里我们要有一个标记元素是否使用的数组，在后面的主逻辑递归中，有两种写法，第一种是只关心“不合法”分支，第二种是只关心“合法”分支。

代码一

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool cheak[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos){
        if(pos==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();++i){
            if(cheak[i]||(i!=0&&nums[i]==nums[i-1]&&cheak[i-1]==false))
                continue;
            path.push_back(nums[i]);
            cheak[i]=true;
            dfs(nums,pos+1);
            path.pop_back();
            cheak[i]=false;
        }
    }
};

  1. vector<vector<int>> ret;: 用于存储所有的全排列结果。

  2. vector<int> path;: 用于存储当前正在生成的排列。

  3. bool cheak[9];: 一个布尔数组，用于标记在当前生成排列的过程中哪些元素已经被选择。

  4. vector<vector<int>> permuteUnique(vector<int>& nums): 主函数，用于调用 DFS 函数，并返回最终的全排列结果。

  5. sort(nums.begin(), nums.end());: 在开始生成排列之前，先将输入数组排序，以便处理重复元素。

  6. void dfs(vector<int>& nums, int pos): 深度优先搜索函数，递归生成全排列。

    • if(pos == nums.size()): 如果当前位置 pos 等于数组的大小，表示已经处理完所有元素，将当前排列加入结果集。
      • ret.push_back(path);: 将当前排列加入结果集。
      • return;: 返回结束当前 DFS 分支。
    • for(int i = 0; i < nums.size(); ++i): 遍历数组中的每个元素。
      • if(cheak[i] || (i != 0 && nums[i] == nums[i-1] && cheak[i-1] == false)): 如果当前元素已经被选择（cheak[i] 为 true）或者当前元素与前一个元素相同，且前一个元素未被选择，则跳过当前循环。这是为了处理重复元素的情况，确保不会生成重复的排列。
        • continue;: 跳过当前循环，进入下一个循环。
      • path.push_back(nums[i]);: 将当前元素加入排列。
      • cheak[i] = true;: 将当前元素标记为已选择。
      • dfs(nums, pos + 1);: 递归调用 DFS 函数，继续生成下一个元素的排列。
      • path.pop_back();: 回溯，将刚刚加入的元素移出排列。
      • cheak[i] = false;: 回溯，将刚刚标记为已选择的元素重新标记为未选择。

    代码二

    class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool cheak[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos){
        if(pos==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();++i){
            if(!cheak[i]&&(i==0||nums[i]!=nums[i-1]||cheak[i-1]==true))
            {
                path.push_back(nums[i]);
                cheak[i]=true;
                dfs(nums,pos+1);
                path.pop_back();
                cheak[i]=false;
            }
        }
    }
};
    1. vector<vector<int>> ret;: 用于存储所有的全排列结果。
    2. vector<int> path;: 用于存储当前正在生成的排列。
    3. bool cheak[9];: 一个布尔数组，用于标记在当前生成排列的过程中哪些元素已经被选择。
    4. vector<vector<int>> permuteUnique(vector<int>& nums): 主函数，用于调用 DFS 函数，并返回最终的全排列结果。
    5. sort(nums.begin(), nums.end());: 在开始生成排列之前，先将输入数组排序，以便处理重复元素。
    6. void dfs(vector<int>& nums, int pos): 深度优先搜索函数，递归生成全排列。
      • if(pos == nums.size()): 如果当前位置 pos 等于数组的大小，表示已经处理完所有元素，将当前排列加入结果集。
        • ret.push_back(path);: 将当前排列加入结果集。
        • return;: 返回结束当前 DFS 分支。
      • for(int i = 0; i < nums.size(); ++i): 遍历数组中的每个元素。
        • if(!cheak[i] && (i == 0 || nums[i] != nums[i-1] || cheak[i-1] == true)): 如果当前元素未被选择且（是第一个元素或者与前一个元素不相同或者前一个元素已被选择），则进入循环。
          • path.push_back(nums[i]);: 将当前元素加入排列。
          • cheak[i] = true;: 将当前元素标记为已选择。
          • dfs(nums, pos + 1);: 递归调用 DFS 函数，继续生成下一个元素的排列。
          • path.pop_back();: 回溯，将刚刚加入的元素移出排列。
          • cheak[i] = false;: 回溯，将刚刚标记为已选择的元素重新标记为未选择。

05.电话号码的字母组合

题目链接：https://leetcode.cn/problems/letter-combinations-of-a-phone-number/

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。

思路

这里比前面的排列组合更为简单，只不过在这里我们需要额外创建一个哈希结构来建立数字和字母的映射关系。

代码

class Solution {
    string hash[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs","tuv", "wxyz"};
    string path;
    vector<string> ret;
public:
    vector<string> letterCombinations(string digits) {
        if(!digits.size()) return ret;
        dfs(digits,0);
        return ret;
    }

    void dfs(string& digits,int pos){
        if(pos==digits.size()){
            ret.push_back(path);
            return;
        }

        for(auto ch:hash[digits[pos]-'0']){
            path+=ch;
            dfs(digits,pos+1);
            path.pop_back();
        }
    }
};
  1. string hash[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs","tuv", "wxyz"};: 数字与对应的字母组合的映射关系，hash[2] 对应 “abc”，hash[3] 对应 “def”，以此类推。
  2. string path;: 用于存储当前正在生成的字母组合。
  3. vector<string> ret;: 用于存储所有的字母组合结果。
  4. vector<string> letterCombinations(string digits): 主函数，用于调用 DFS 函数，并返回最终的字母组合结果。
  5. if(!digits.size()) return ret;: 如果输入的数字序列为空，则直接返回空的结果集。
  6. void dfs(string& digits, int pos): 深度优先搜索函数，递归生成数字序列对应的所有字母组合。
    • if(pos == digits.size()): 如果当前位置 pos 等于数字序列的大小，表示已经处理完所有数字，将当前字母组合加入结果集。
      • ret.push_back(path);: 将当前字母组合加入结果集。
      • return;: 返回结束当前 DFS 分支。
    • for(auto ch : hash[digits[pos] - '0']): 遍历当前数字对应的所有字母。
      • path += ch;: 将当前字母加入字母组合。
      • dfs(digits, pos + 1);: 递归调用 DFS 函数，继续生成下一个数字对应的字母组合。
        )`: 主函数，用于调用 DFS 函数，并返回最终的字母组合结果。
  7. if(!digits.size()) return ret;: 如果输入的数字序列为空，则直接返回空的结果集。
  8. void dfs(string& digits, int pos): 深度优先搜索函数，递归生成数字序列对应的所有字母组合。
    • if(pos == digits.size()): 如果当前位置 pos 等于数字序列的大小，表示已经处理完所有数字，将当前字母组合加入结果集。
      • ret.push_back(path);: 将当前字母组合加入结果集。
      • return;: 返回结束当前 DFS 分支。
    • for(auto ch : hash[digits[pos] - '0']): 遍历当前数字对应的所有字母。
      • path += ch;: 将当前字母加入字母组合。
      • dfs(digits, pos + 1);: 递归调用 DFS 函数，继续生成下一个数字对应的字母组合。
      • path.pop_back();: 回溯，将刚刚加入的字母移出字母组合。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

BioTech - 大型蛋白质复合物的组装流程 (CombFold)

BioTech - 大型蛋白质复合物的组装流程 (CombFold)

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/136187314 CombFold是用于预测大型蛋白质复合物结构的组合和分层组装算法&#xff0c;利用AlphaFold2预测的亚基之间的成对相互作用。CombFold的组…
阅读更多...
C++学习：总结

C++学习：总结

#include <bits/stdc.h> using namespace std; int main() {int n;cin >> n;int a[n];for(int i0 ; i < n ;i ){cin >> a[i];}sort(a,a n);for(int i 0;i< n;i){cout << a[i] << " ";}cout << endl;// 请在此输入您的代…
阅读更多...
IDEA查询对应功能的快捷键

IDEA查询对应功能的快捷键

首先要知道快捷键的key叫什么&#xff0c;然后通过key来找到对应的快捷键 比如下面这个查找删除导入未使用的类 跳转 或者安装对应插件
阅读更多...
【sgCreateTableData】自定义小工具：敏捷开发→自动化生成表格数据数组[基于el-table]

【sgCreateTableData】自定义小工具：敏捷开发→自动化生成表格数据数组[基于el-table]

源码 <template><!-- 前往https://blog.csdn.net/qq_37860634/article/details/136141769 查看使用说明 --><div :class"$options.name"><div class"sg-head">表格数据生成工具</div><div class"sg-container&quo…
阅读更多...
设计模式----工厂模式

设计模式----工厂模式

工厂模式 工厂模式即建立创建对象的工厂&#xff0c;实现创建者和调用者分离。 简单工厂模式&#xff1a;该模式对对象创建管理方式最为简单&#xff0c;因为他简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象。 工厂方法模式&am…
阅读更多...
pip镜像源：清华镜像、阿里云镜像、豆瓣镜像与如何修改默认镜像源

pip镜像源：清华镜像、阿里云镜像、豆瓣镜像与如何修改默认镜像源

pip镜像源&#xff1a;清华镜像、阿里云镜像、豆瓣镜像与如何修改默认镜像源 &#x1f308; 个人主页&#xff1a;高斯小哥 &#x1f525; 高质量专栏&#xff1a;【Matplotlib之旅&#xff1a;零基础精通数据可视化】 &#x1f3c6;&#x1f3c6;关注博主&#xff0c;随时获取…
阅读更多...
MyBatis关联查询和部分主配置文件映射文件

MyBatis关联查询和部分主配置文件映射文件

一、主配置文件 注意必须按规定的结构来配置 设置&#xff08;settings&#xff09; 这是 MyBatis 中极为重要的调整设置&#xff0c;它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。 看mybatis <settings><setting name"useGe…
阅读更多...
善于利用GPT确实可以解决许多难题

善于利用GPT确实可以解决许多难题

当我设计一个导出Word文档的功能时&#xff0c;我面临了一个挑战。在技术选型时&#xff0c;我选择了poi-tl这个模板引擎&#xff0c;因为在网上看到了很多关于它的推荐。poi-tl可以根据模板快速导出Word文档。虽然之前没有做过类似的功能&#xff0c;而且项目中也没有用过&…
阅读更多...
超声波清洗机大测评！希亦、洁盟、德国ODI、苏泊尔哪款性价比高?

超声波清洗机大测评！希亦、洁盟、德国ODI、苏泊尔哪款性价比高?

眼镜逐渐已经成为现在大部分都离不开的一个视线辅助&#xff0c;但是很多朋友对于眼镜的清洗从开始佩戴眼镜时&#xff0c;就没有重视起来。其实清洗眼镜的方法有很多种&#xff0c;手动清洗跟超声波清洗机&#xff0c;后者的清洗相对来说会更加方便快捷一点&#xff0c;且清洗…
阅读更多...
啄木鸟家庭维修｜空调滤网多久清洗一次？

啄木鸟家庭维修｜空调滤网多久清洗一次？

啄木鸟家庭维修范师傅解答 1、家用空调,如果不是在油烟较多或风沙较大的地区,是空调使用三百小时后就清洗一次过滤网。如果是处于油烟大或风沙大的地区,空调使用一百小时后就要清洗一次过滤网。 2、清洗空调滤网的时候先将空调的前盖打开,然后抠住面板的两边,用力拉开就可以看…
阅读更多...
【算法 - 动态规划】最长公共子序列问题

【算法 - 动态规划】最长公共子序列问题

在上两篇文章中&#xff0c;我们将 暴力递归 逐步修改成为 动态规划 &#xff0c;并介绍了有严格 dp表依赖 和无表依赖结构的解题方法。其中&#xff0c;前篇文章中的纸牌博弈问题属于 [L , R]上范围尝试模型。该模型给定一个范围&#xff0c;在该范围上进行尝试&#xff0c;套…
阅读更多...
word文件中的图片压缩怎么操作？这几招教你轻松压缩

word文件中的图片压缩怎么操作？这几招教你轻松压缩

word文件中的图片压缩怎么操作&#xff1f;在日常办公中&#xff0c;我们经常需要在Word文档中插入图片来丰富内容。但有时候&#xff0c;插入的图片过大&#xff0c;不仅会增加文档的打开速度&#xff0c;还可能影响打印效果。那么&#xff0c;如何在保持图片质量的同时&#…
阅读更多...
Android 面试问题 2024 版（其一）

Android 面试问题 2024 版（其一）

Android 面试问题 2024 版&#xff08;其一&#xff09; 一、Java 和 Kotlin二、安卓组件三、用户界面 (UI) 开发四、安卓应用架构五、网络和数据持久性 一、Java 和 Kotlin Java 中的抽象类和接口有什么区别&#xff1f; 答&#xff1a;抽象类是不能实例化的类&#xff0c;它…
阅读更多...
番茄工作法规则

番茄工作法规则

番茄工作法规则: 一个番茄钟共30分钟&#xff0c;包括25分钟的工作时间和5分钟的休息时间。每完成四个番茄钟&#xff0c;就进行一次较长时间的休息&#xff0c;大约15-30分钟。一个番茄钟是不可分割的&#xff0c;一旦开启就必须坚持到底&#xff0c;如果打断&#xff0c;就视…
阅读更多...
万界星空科技MES系统，实现数字化智能工厂

万界星空科技MES系统，实现数字化智能工厂

万界星空科技帮助制造型企业解决生产过程中遇到的生产过程不透明&#xff0c;防错成本高&#xff0c;追溯困难&#xff0c;品质不可控&#xff0c;人工效率低下&#xff0c;库存积压&#xff0c;交期延误等问题&#xff0c;从而达到“降本增效”的目标。打通各个信息孤岛&#…
阅读更多...
英伟达推出ConsiStory免训练文生图模型；Sora物理悖谬的几何解释；Groq推出全球最快大模型

英伟达推出ConsiStory免训练文生图模型；Sora物理悖谬的几何解释；Groq推出全球最快大模型

&#x1f989; AI新闻 &#x1f680; 英伟达推出ConsiStory免训练文生图模型 摘要&#xff1a;ConsiStory是一种免训练的一致性连贯文生成图模型&#xff0c;由英伟达和特拉维夫大学的研究人员开发。它解决了文生成图模型在生成内容一致性方面的两个主要问题。首先&#xff0…
阅读更多...
顺序表漫谈

顺序表漫谈

目录 ​编辑 1.线性表 2.顺序表 2.1概念及结构 2.2接口实现 1.顺序表的动态存储 2.顺序表初始化 3.顺序表销毁 4.顺序表增容 5.顺序表头插 6.顺序表尾插 7.顺序表头删 8.顺序表尾删 9.顺序表打印 10.顺序表在任意下标位置插入数据 11.顺序表删除任意下标位置的值…
阅读更多...
VIO第2讲：IMU标定实验

VIO第2讲：IMU标定实验

VIO第2讲&#xff1a;IMU标定实验 文章目录 VIO第2讲&#xff1a;IMU标定实验5 IMU标定实验5.1 仿真数据产生5.1.1 c代码分析5.1.2 生成ros包数据 5.2 Allan方差实验&#xff08;港科大imu_utils&#xff09;5.2.1 安装5.2.2 运行 5.3 Allan方差实验&#xff08;matlab代码kali…
阅读更多...
深度学习基础——GAN生成对抗网络

深度学习基础——GAN生成对抗网络

生成对抗网络(GAN)的简介 生成对抗网络GAN(Generative adversarial networks)是Goodfellow等在2014年提出的一种生成式模型。GAN在结构上受博弈论中的二元零和博弈(即二元的利益之和为零&#xff0c;一方的所得正是另一方的所失)的启发&#xff0c;系统由一个生成器和一个判别器…
阅读更多...
pc微信逆向最新3.9.8.25版本

pc微信逆向最新3.9.8.25版本

朋友让我开发一个关于微信的计数、统计、自动回复功能的机器人&#xff0c;主要是用在win10上面。 先看看结果&#xff01; 之前写过手机端的逆向&#xff0c;PC端逆向很长时间没写了&#xff0c;所以就在网上找了找。基本都是基于3.6&#xff0c;3.7&#xff0c;3.8版本的&a…
阅读更多...
最新文章

Copyright @ 2022~2023