Leetcode刷题笔记之 回溯

最新推荐文章于 2021-09-15 11:38:32 发布
最新推荐文章于 2021-09-15 11:38:32 发布
阅读量135 收藏
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43540151/article/details/119190013
版权
本文深入探讨了计算机科学中的几种经典组合问题，包括无重复元素的子集、有重复元素的子集、组合、组合总和以及全排列等。通过递归和回溯法详细阐述了解决这些问题的算法实现，并提供了示例代码，帮助读者理解如何生成所有可能的解集。同时，还介绍了电话号码字母组合和单词缩写的生成方法，展示了如何在字符串处理中应用这些算法。
摘要由CSDN通过智能技术生成
78. 子集

难度中等1058

给你一个整数数组 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 {
public:
    vector<vector<int>> res;
    vector<int> Nums;
    vector<vector<int>> subsets(vector<int>& nums) {
        Nums = nums;
        vector<int> temp;
        subsets_help(0,temp);
        return res;
    }
    void subsets_help(int j, vector<int> temp){      
        res.push_back(temp);
        for(int i = j; i<Nums.size(); i++){
            temp.push_back(Nums[i]);
            subsets_help(i+1,temp);
            temp.pop_back();
        }       
    }
};
90. 子集 II

难度中等415

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

**说明：**解集不能包含重复的子集。

示例:

输入: [1,2,2]
输出:
[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

class Solution {
public:
    vector<vector<int>> res;
    vector<int> Nums;
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        Nums = nums;
        vector<int> temp;
        subsetsWithDup_helper(0, temp);
        return res;
    }
    void subsetsWithDup_helper(int j, vector<int> temp){
        res.push_back(temp);
        for(int i = j;i<Nums.size();i++){
            if(i>j && Nums[i]== Nums[i-1]) continue;//这轮的点和上一轮的点重复没关系，但是新加入的点不能和这轮重复
            temp.push_back(Nums[i]);
            subsetsWithDup_helper(i+1,temp);
            temp.pop_back();
        }
    }
};
77. 组合

难度中等525

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

示例:

输入: n = 4, k = 2
输出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

class Solution {
public:
    int N;
    int K;
    vector<vector<int>> res;
    vector<vector<int>> combine(int n, int k) {
        N = n; K = k;
        vector<int> temp;
        combine_helper(1,temp);
        return res;
    }
    void combine_helper(int j, vector<int> temp){
        if(temp.size()==K) {
            res.push_back(temp);
            return;
        }
        for(int i=j;i<=N-(K-temp.size())+1;i++){//优化剪枝，删去无数可选的情况
            temp.push_back(i);
            combine_helper(i+1,temp);
            temp.pop_back();
        }
    }
};
39. 组合总和

难度中等1220

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

  • 所有数字（包括 target）都是正整数。
  • 解集不能包含重复的组合。

示例 1：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
  [7],
  [2,2,3]
]

示例 2：

输入：candidates = [2,3,5], target = 8,
所求解集为：
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

提示：

  • 1 <= candidates.length <= 30
  • 1 <= candidates[i] <= 200
  • candidate 中的每个元素都是独一无二的。
  • 1 <= target <= 500
class Solution {
public:
    vector<vector<int>> res;
    vector<int> Can;
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int> temp;
        sort(candidates.begin(),candidates.end());
        Can = candidates;
        combinationSum_helper(target, 0,temp);
        return res;
    }
    void combinationSum_helper(int target,int start,vector<int> temp){
        if(target==0){
            res.push_back(temp);
            return;
        }
        if(target<0)return;
        for(int i= start;i< Can.size();i++ ){
            temp.push_back(Can[i]);
            combinationSum_helper(target-Can[i],i,temp);
            temp.pop_back();
        }
    }
};
40. 组合总和 II

难度中等528

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

  • 所有数字（包括目标数）都是正整数。
  • 解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
  [1,2,2],
  [5]
]

class Solution {
public:
    vector<vector<int>> res;
    vector<int> Candidates;

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        Candidates = candidates;
        vector<int> temp;
        combinationSum2_helper(target,0,temp);
        return res;
    }
    void combinationSum2_helper(int target,int start, vector<int> temp){
        if(target==0){
            res.push_back(temp);
            return;
        }
        if(target <0 )return;

        for(int i=start;i<Candidates.size();i++){
            if(i>start && Candidates[i]==Candidates[i-1])continue;
            if(target<Candidates[i]) return; //剪枝！
            temp.push_back(Candidates[i]);
            combinationSum2_helper(target-Candidates[i],i+1,temp);
            temp.pop_back();
        }
    }
};
46. 全排列

难度中等1219

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

class Solution {
public:
    vector<vector<int>> res;
    vector<int> Nums;
    vector<vector<int>> permute(vector<int>& nums) {
        Nums = nums;
        vector<int> temp;
        vector<bool> used(nums.size(),false);
        permute_helper(0,temp,used);
        return res;
    }
    void permute_helper(int start,vector<int> temp,vector<bool> used){
        if(temp.size()== Nums.size()){
            res.push_back(temp);
            return;
        }
        for(int i = 0;i<Nums.size();i++){
            if(used[i]==true) continue;
            temp.push_back(Nums[i]);
            used[i]=true;
            permute_helper(i+1,temp,used);
            temp.pop_back();
            used[i] = false;
        }
    }
};
47. 全排列 II

难度中等632

给定一个可包含重复数字的序列 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 {
public:
    vector<int> Nums;
    vector<vector<int>> res;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        Nums = nums;
        vector<int> temp;
        vector<bool> used(nums.size(),false);
        permuteUnique_helper(temp,used);
        return res;
    }

    void permuteUnique_helper(vector<int> temp,vector<bool> used){
        if(temp.size()== Nums.size()){
            res.push_back(temp);
            return;
        }
        for(int i=0;i<Nums.size();i++){
            if(used[i])continue;
            if( i>0 && Nums[i] == Nums[i-1] && used[i-1]) continue;
            temp.push_back(Nums[i]);
            used[i] = true;
            permuteUnique_helper(temp,used);
            temp.pop_back();
            used[i] = false;
        }
    }
};
17. 电话号码的字母组合

难度中等1190

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dKBBBlkf-1627477236813)(回溯.assets/17_telephone_keypad.png)]

示例 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 {
public:
    vector<string> letter={"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    string Digits;
    vector<string> res;

    vector<string> letterCombinations(string digits) {
        Digits = digits;
        string temp;
        if(digits.empty()) return res;
        letterCombinations_helper(0,temp);
        return res;
    }

    void letterCombinations_helper(int start, string temp){
        if(temp.size()==Digits.size()){
            res.push_back(temp);
            return;
        }
        for(int i = 0;i<letter[Digits[start]-'2'].size();i++){
            temp.push_back(letter[Digits[start]-'2'][i]);
            letterCombinations_helper(start+1,temp);
            temp.pop_back();
        }
    }
};
320. 列举单词的全部缩写

难度中等52

请你写出一个能够举单词全部缩写的函数。

**注意：**输出的顺序并不重要。

示例：

输入: "word"
输出:
["word", "1ord", "w1rd", "wo1d", "wor1", "2rd", "w2d", "wo2", "1o1d", "1or1", "w1r1", "1o2", "2r1", "3d", "w3", "4"]

class Solution {
public:
    vector<string>res;
    string Word;
    vector<string> generateAbbreviations(string word) {
        Word = word;
        string temp;
        generateAbbreviations_helper(0,0,temp);
        return res;
    }

    void generateAbbreviations_helper(int start, int num, string temp){
        if(start == Word.size()){
            if(num==0) res.push_back(temp);
            else{
                temp+=to_string(num);
                res.push_back(temp);
            }
            return;
        }

        //start字母被缩写
        generateAbbreviations_helper(start+1,num+1,temp);

        //start不被缩写
        int currentLength = temp.size();
        if(num!=0)temp+=to_string(num);
        temp.push_back(Word[start]);
        generateAbbreviations_helper(start+1,0,temp);
        temp.resize(currentLength);
    }
};
254. 因子的组合

难度中等71

整数可以被看作是其因子的乘积。

例如：

8 = 2 x 2 x 2;
  = 2 x 4.

请实现一个函数，该函数接收一个整数 n 并返回该整数所有的因子组合。

注意：

  1. 你可以假定 n 为永远为正数。
  2. 因子必须大于 1 并且小于 n。

示例 1：

输入: 1
输出: []

示例 2：

输入: 37
输出: []

示例 3：

输入: 12
输出:
[
  [2, 6],
  [2, 2, 3],
  [3, 4]
]

示例 4:

输入: 32
输出:
[
  [2, 16],
  [2, 2, 8],
  [2, 2, 2, 4],
  [2, 2, 2, 2, 2],
  [2, 4, 4],
  [4, 8]
]

class Solution {
public:

    vector<vector<int>> res;
    vector<vector<int>> getFactors(int n) {
        vector<int> temp;
        getFactors_helper(n,2,temp);       
        return res;
    }

    void getFactors_helper(int target,int start,vector<int> temp){

        if(target==1){
            if(temp.size()>1)res.push_back(temp);
        }
        for(int i=start;i*i<=target;i++){
            if(target%i!=0 ) continue;
            //这轮加入
            temp.push_back(i);
            temp.push_back(target/i);
            res.push_back(temp);
            //继续分解
            temp.pop_back();
            getFactors_helper(target/i,i,temp);
            temp.pop_back();
        }
    }
};
剑指 Offer 38. 字符串的排列

难度中等243

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

示例:

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

1.生成法（没有剪枝，使用set在输出时去重）

class Solution {
public:
    unordered_set<string> res;
    int strSize;
    string S;
    vector<string> permutation(string s) {
        string temp;
        strSize = s.size();
        S = s;
        vector<bool> used(strSize,false);
        permutation_help(used,temp,s.size());
        vector<string> vecRes;
        for(auto i:res){
            vecRes.push_back(i);
        }
        return vecRes;
    }

    void permutation_help(vector<bool>used, string temp,int remain){
        if(remain==0)
        res.emplace(temp);

        for(int i=0;i<strSize;i++){
            if(used[i])continue;
            used[i] = true;
            temp += S[i];
            permutation_help(used, temp,remain-1);
            temp.pop_back();
            used[i] = false;
        }
    }
};

2.交换法（有剪枝）

class Solution {
public:
    vector<string> permutation(string s) {
        dfs(s, 0);
        return res;
    }
private:
    vector<string> res;
    void dfs(string s, int x) {
        if(x == s.size() - 1) {
            res.push_back(s);                       // 添加排列方案
            return;
        }
        set<int> st;
        for(int i = x; i < s.size(); i++) {
            if(st.find(s[i]) != st.end()) continue; // 重复，因此剪枝
            st.insert(s[i]);
            swap(s[i], s[x]);                       // 交换，将 s[i] 固定在第 x 位
            dfs(s, x + 1);                          // 开启固定第 x + 1 位字符
            swap(s[i], s[x]);                       // 恢复交换
        }
    }
};

法（有剪枝）

class Solution {
public:
    vector<string> permutation(string s) {
        dfs(s, 0);
        return res;
    }
private:
    vector<string> res;
    void dfs(string s, int x) {
        if(x == s.size() - 1) {
            res.push_back(s);                       // 添加排列方案
            return;
        }
        set<int> st;
        for(int i = x; i < s.size(); i++) {
            if(st.find(s[i]) != st.end()) continue; // 重复，因此剪枝
            st.insert(s[i]);
            swap(s[i], s[x]);                       // 交换，将 s[i] 固定在第 x 位
            dfs(s, x + 1);                          // 开启固定第 x + 1 位字符
            swap(s[i], s[x]);                       // 恢复交换
        }
    }
};
喝可乐的阿晨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串的排列
皮卡qiu~的博客
10-04 883
一、需求 输入一个字符串，打印该字符串中字符的所有排列； 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。 示例: 输入：s = "abc" 输出：["abc","acb","bac","bca","cab","cba"] 二、回溯法 2.1 思路分析 排列方案数量：对于一个长度为n的字符串(假设字符互不重复)，其排列共有 n! 种； 排列方案的生成方法：根据字符串排列的特点，考虑深度优先搜索所有排列方案。即通过字符交换，先固定第1位字符(n种情况)、再固定第2位字符(n-1种情.
回溯--组合，排列
qq_48094059的博客
08-14 360
回溯
LeetCode 搜索回溯专题
karry_zzj的博客
09-15 313
子集组合问题 78. 子集 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 示例 1： 输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 示例 2： 输入：nums = [0] 输出：[[],[0]] class Solution { public: vector<int> sub = {};
剑指offer——数学类问题集合（Leetcode）
超喜欢榴莲呀的博客
06-12 763
面试题10- I. 斐波那契数列 题目 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。 输入：n = 5 输出：5 法一：直接按照递推式写即可。
LeetCode刷题笔记（七）--- DFS
weixin_45216055的博客
07-27 161
文章内容为LeetCode刷题笔记，如发现错误请多多指教 22、字符串的排列问题：全排列问题，DFS 输入一个字符串，打印出该字符串中字符的所有排列。 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。 全排列问题可以看做如下多叉树形态： 很明显，如果我们想要得到合适的排列，我们要用到深度优先遍历，该问题可以把目标串分成两个部分，第一部分呢是哪个字符作为开头，第二部分就是该字符做开头的子部分，所以让所有的字符做一遍开头，再求解子问题就可以了。 class Solution { public:
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
谷歌高畅Leetcode刷题笔记.pdf
08-04
因此，本书的编写是建立在作者的刷题经验和项目实践基础之上的。 书籍内容被组织成算法和数据结构两个部分，并进一步细分为十五个章节，每一章节针对特定的算法和数据结构进行深入讲解，包括贪心算法、双指针、二分...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
谷歌和阿里大佬的Leetcode刷题笔记.zip
08-10
《谷歌和阿里大佬Leetcode刷题笔记》是一个珍贵的学习资源，专为提升算法能力和准备面试设计。LeetCode是一个在线平台，提供了大量的编程题目，旨在帮助程序员提升算法技能，特别是对于那些希望进入顶级科技公司如...
Leetcode 面试题38. 字符串的排列【回溯算法，解释非常清晰】
MD
04-17 329
文章目录问题描述解题报告实现代码参考资料 问题描述 输入一个字符串，打印出该字符串中字符的所有排列。 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。 【字符串中可能存在重复字符】 解题报告 典型的回溯算法题。 使用 index 来表示枚举到哪一位上了，使用 target 来表示目前形成的字符串，使用数组 vis[] 来表示某个字符是否被使用，用 ans 表示最终的答案。 枚举每个位置能...
LeetCode 254. 因子的组合（回溯）*
Michael是个半路程序员
07-07 1743
文章目录1. 题目2. 解题 1. 题目 整数可以被看作是其因子的乘积。 例如： 8 = 2 x 2 x 2; = 2 x 4. 请实现一个函数，该函数接收一个整数 n 并返回该整数所有的因子组合。 注意： 你可以假定 n 为永远为正数。 因子必须大于 1 并且小于 n。 示例 1： 输入: 1 输出: [] 示例 2： 输入: 37 输出: [] 示例 3： 输入: 12 输出: [ [2, 6], [2, 2, 3], [3, 4] ] 示例 4: 输入: 32 输出: [
254 因子的组合
weixin_44171872的博客
09-15 336
题目描述： 整数可以被看作是其因子的乘积。 例如： 8 = 2 x 2 x 2; = 2 x 4. 请实现一个函数，该函数接收一个整数 n 并返回该整数所有的因子组合。 注意： 你可以假定 n 为永远为正数。 因子必须大于 1 并且小于 n。 示例 1： 输入: 1 输出: [] 示例 2： 输入: 37 输出: [] 示例 3： 输入: 12 输出: [ [2, 6], [2, 2, 3], [3, 4] ] 示例 4: 输入: 32 输出: [ [2, 16], [2, 2, 8], [2, 2, 2,
Leetcode 254.因子的组合
Bing's Blog
10-06 1243
Time: 20191005 Type: Medium 题目描述 整数可以被看作是其因子的乘积。 例如： 8 = 2 x 2 x 2; = 2 x 4. 请实现一个函数，该函数接收一个整数n并返回该整数所有的因子组合。 注意： 你可以假定n为永远为正数。因子必须大于 1 并且小于 n。 示例 1： 输入: 1 输出: [] 示例 2： 示例2： 输入: 37 输出: [] 示例 3： 输...
LeetCode 254. Factor Combinations
qq_31361913的博客
08-03 95
step 1: 先按照从大到小的顺序找出所有的因数 step 2: 递归地解决问题（类似于99 cents） 需要注意的是在尝试完本层所有的branch以后退回上一层之前需要状态重置即删除之前加入path的数。 class Solution { public List<List<Integer>> getFactors(int n) { List<List<Integer>> res = new ArrayList<>
LeetCode-Python-254. 因子的组合
Keep Coding
05-27 1456
整数可以被看作是其因子的乘积。 例如： 8 = 2 x 2 x 2; = 2 x 4. 请实现一个函数，该函数接收一个整数n并返回该整数所有的因子组合。 注意： 你可以假定n为永远为正数。 因子必须大于 1 并且小于n。 示例 1： 输入: 1 输出: [] 示例 2： 输入: 37 输出: [] 示例 3： 输入: 12 输出: [ [2, 6]...
（全新整理）上市公司数字经济与实体经济融合发展程度测算数据（2008-2022年）
09-06
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/141966339 2、代码特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理
目标检测相关，yolo系列.zip
09-06
1 目标检测的定义 目标检测（Object Detection）的任务是找出图像中所有感兴趣的目标（物体），确定它们的类别和位置，是计算机视觉领域的核心问题之一。由于各类物体有不同的外观、形状和姿态，加上成像时光照、遮挡等因素的干扰，目标检测一直是计算机视觉领域最具有挑战性的问题。 目标检测任务可分为两个关键的子任务，目标定位和目标分类。首先检测图像中目标的位置（目标定位），然后给出每个目标的具体类别（目标分类）。输出结果是一个边界框（称为Bounding-box，一般形式为(x1,y1,x2,y2)，表示框的左上角坐标和右下角坐标），一个置信度分数（Confidence Score），表示边界框中是否包含检测对象的概率和各个类别的概率（首先得到类别概率，经过Softmax可得到类别标签）。 1.1 Two stage方法 目前主流的基于深度学习的目标检测算法主要分为两类：Two stage和One stage。Two stage方法将目标检测过程分为两个阶段。第一个阶段是 Region Proposal 生成阶段，主要用于生成潜在的目标候选框（Bounding-box proposals）。这个阶段通常使用卷积神经网络（CNN）从输入图像中提取特征，然后通过一些技巧（如选择性搜索）来生成候选框。第二个阶段是分类和位置精修阶段，将第一个阶段生成的候选框输入到另一个 CNN 中进行分类，并根据分类结果对候选框的位置进行微调。Two stage 方法的优点是准确度较高，缺点是速度相对较慢。 常见Tow stage目标检测算法有：R-CNN系列、SPPNet等。 1.2 One stage方法 One stage方法直接利用模型提取特征值，并利用这些特征值进行目标的分类和定位，不需要生成Region Proposal。这种方法的优点是速度快，因为省略了Region Proposal生成的过程。One stage方法的缺点是准确度相对较低，因为它没有对潜在的目标进行预先筛选。 常见的One stage目标检测算法有：YOLO系列、SSD系列和RetinaNet等。 2 常见名词解释 2.1 NMS(Non-Maximum Suppression) 目标检测模型一般会给出目标的多个预测边界框，对成百上千的预测边界框都进行调整肯定是不可行的,需要对这些结果先进行一个大体的挑选。NMS称为非极大值抑制，作用是从众多预测边界框中挑选出最具代表性的结果，这样可以加快算法效率，其主要流程如下： 设定一个置信度分数阈值，将置信度分数小于阈值的直接过滤掉 将剩下框的置信度分数从大到小排序，选中值最大的框 遍历其余的框，如果和当前框的重叠面积(IOU)大于设定的阈值（一般为0.7），就将框删除（超过设定阈值，认为两个框的里面的物体属于同一个类别） 从未处理的框中继续选一个置信度分数最大的，重复上述过程，直至所有框处理完毕 2.2 IoU(Intersection over Union) 定义了两个边界框的重叠度，当预测边界框和真实边界框差异很小时，或重叠度很大时，表示模型产生的预测边界框很准确。边界框A、B的IOU计算公式为: 2.3 mAP(mean Average Precision) mAP即均值平均精度，是评估目标检测模型效果的最重要指标，这个值介于0到1之间，且越大越好。mAP是AP(Average Precision)的平均值，那么首先需要了解AP的概念。想要了解AP的概念，还要首先了解目标检测中Precision和Recall的概念。 首先我们设置置信度阈值（Confidence Threshold）和IoU阈值（一般设置为0.5，也会衡量0.75以及0.9的mAP值）： 当一个预测边界框被认为是True Positive（TP）时，需要同时满足下面三个条件： Confidence Score > Confidence Threshold 预测类别匹配真实值(Ground truth)的类别 预测边界框的IoU大于设定的IoU阈值 不满足条件2或条件3，则认为是False Positive（FP）。当对应同一个真值有多个预测结果时，只有最高置信度分数的预测结果被认为是True Positive，其余被认为是False Positive。 Precision和Recall的概念如下图所示： Precision表示TP与预测边界框数量的比值 Recall表示TP与真实边界框数量的比值 改变不同的置信度阈值，可以获得多组Precision和Recall，Recall放X轴，Precision放Y轴，可以画出一个Precision-Recall曲线，简称P-R
8051Proteus仿真c源码用数组的指针控制P0口8位LED流水点亮
最新发布
09-06
8051Proteus仿真c源码用数组的指针控制P0 口8 位LED流水点亮提取方式是百度网盘分享地址
Java版LeetCode刷题笔记：51-100题解析
“LeetCode 刷题笔记 with Java 51-100（暗黑版）.pdf 是一本关于使用Java解决LeetCode算法题目的详细笔记，由沉默王二创作。该笔记涵盖51至100号题目，包含题解预览链接、LeetCode官方题目链接以及GitHub项目地址。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值