回溯算法题解（难度由小到大）（力扣，洛谷）

目录

注意：

P1157 组合的输出（洛谷）https://www.luogu.com.cn/problem/P1157int result[10000] = { 0 };

216. 组合总和 IIIhttps://leetcode.cn/problems/combination-sum-iii/

17. 电话号码的字母组合https://leetcode.cn/problems/letter-combinations-of-a-phone-number/

39. 组合总和https://leetcode.cn/problems/combination-sum/

40. 组合总和 IIhttps://leetcode.cn/problems/combination-sum-ii/

131. 分割回文串https://leetcode.cn/problems/palindrome-partitioning/

93. 复原 IP 地址https://leetcode.cn/problems/restore-ip-addresses/

78. 子集https://leetcode.cn/problems/subsets/

90. 子集 IIhttps://leetcode.cn/problems/subsets-ii/

491.非递减子序列

46. 全排列https://leetcode.cn/problems/permutations/

47. 全排列 IIhttps://leetcode.cn/problems/permutations-ii/

P1219 [USACO1.5] 八皇后 Checker Challengehttps://www.luogu.com.cn/problem/P1219

51. N 皇后https://leetcode.cn/problems/n-queens/

37. 解数独https://leetcode.cn/problems/sudoku-solver/

 

✨欢迎来到脑子不好的小菜鸟的文章✨

      🎈创作不易，麻烦点点赞哦🎈

          所属专栏：刷题_脑子不好的小菜鸟的博客-CSDN博客

          我的主页：脑子不好的小菜鸟

          文章特点：关键点和步骤讲解放在

          代码相应位置

注意：

本篇由易到难，若想做难题，可移步至该文章：过去一周写过的算法题的一部分（dfs，贪心）-CSDN博客

P1157 组合的输出（洛谷）
https://www.luogu.com.cn/problem/P1157int result[10000] = { 0 };


void dfs(int n, int r, int size, int start){
    int i;
    //终止条件
    if (size == r)
    {
        for (i = 0; i < size; i++)
        {
            printf("%3d", result[i]);
        }
        printf("\n");
        return;
    }
    
    //单层递归逻辑
    for (i = start; i <= n - (r - size) + 1; i++)//剪枝
    {
        result[size] = i;
        dfs(n, r, size + 1, i + 1);
    }
}
int main(){
    int n, r;
    scanf("%d%d", &n, &r);
    dfs(n, r, 0, 1);
    return 0;
}

216. 组合总和 III
https://leetcode.cn/problems/combination-sum-iii/

class Solution {
public:
    vector<vector<int>>result;
    vector<int>path;
    void backtracking(int k, int n, int sum, int start)
    {
        if (sum > n || start > n)    return;
        if (sum == n && path.size() == k)
        {
            result.push_back(path);
            return;
        }

        int i;
        for (i = start; i <= 9; i++)//可优化(剪枝)
        {
            path.push_back(i);
            if (sum + i <= n)   backtracking(k, n, sum + i, i + 1);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum3(int k, int n) 
    {
        backtracking(k, n, 0, 1);
        return result;
    }
};

17. 电话号码的字母组合
https://leetcode.cn/problems/letter-combinations-of-a-phone-number/



//注意是组合，不是排列
//需要先将各个按键代表的字符串记录---->枚举常量

//该题注意：
//1.C++中的类似C语言中枚举的定义方式
//2.对枚举的常量的调用
class Solution {
public:
    const string/**/ lettermap[10]/**/ =/**/ {
        "",
        "",//这两行不能省，否则按0，1这两种情况解决不了
        "abc" ,
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz",/**/
    };
    vector<string>result;
    string path;
    void backtracking(string digits, int index)
    {
        if (path.size() == digits.size())/**/
        {
            result.push_back(path);
            return;
        }

        int digit = digits[index] - '0';
        int i;
        for (i = 0; i < lettermap[digit].size(); i++)
        {
            path.push_back(lettermap[digit][i]);
            backtracking(digits, index + 1);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) 
    {
        if (digits.size() == 0) return result;
        backtracking(digits, 0);
        return result;
    }
};

39. 组合总和
https://leetcode.cn/problems/combination-sum/



//与之前的组合问题不同的是：这需要在每一个节点判断结果，而不是叶子节点

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>& candidates, int target, int sum, int start)
    {
        if (sum > target)   return;
        if (sum == target)
        {
            result.push_back(path);
            return;
        }
        
        int i;
        for (i = start; i < candidates.size(); i++)
        {
            path.push_back(candidates[i]);
            if (sum + candidates[i] <= target)  backtracking(candidates, target, sum + candidates[i], i/*注意是i，不是i + 1*/);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) 
    {
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

40. 组合总和 II
https://leetcode.cn/problems/combination-sum-ii/


//map是find键，而不是值
//unordered_map<vector<int>, int>map;要自己构造哈希函数

/*！！！该题重点：不能有重复的集合----->树层去重，树枝去重
树层去重目的：不出现相同的组合（用used数组）
树枝去重目的：一个数不被用两次（用start控制起始下标）
！！！！*/

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>& candidates, int target, int sum, int start, vector<bool>& used)
    {
        if (sum == target)
        {
            result.push_back(path);
            return;
        }
        
        int i;
        for (i = start; i < candidates.size(); i++)
        {
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false/***不是true,若为true,说明是同一树枝，而不是树层***/)
                continue;

            path.push_back(candidates[i]);
            used[i] = true;
            if (sum + candidates[i] <= target)  backtracking(candidates, target, sum + candidates[i], i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) 
    {
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

131. 分割回文串
https://leetcode.cn/problems/palindrome-partitioning/


//重点：分割字符串
//注意strsub（分割字符串）的使用：strsub(string s, 起始坐标，分割的字母个数);

class Solution {
public:
    vector<vector<string>>result;
    vector<string>str;
    bool ishuiwen(string& s, int start, int end)
    {
        int i = start, j = end;
        while (i < j)
        {
            if (s[i] != s[j])
                return false;
            
            i++;
            j--;
        }
        return true;
    }
    void backtracking(string& s, int start)
    {
        if (start >= s.size())
        {
            result.push_back(str);
            return;
        }

        int i;
        for (i = start; i < s.size(); i++)
        {
            if (ishuiwen(s, start, i))
            {
                string temp = s.substr(start, i - start + 1);
                str.push_back(temp);
                backtracking(s, i + 1);
                str.pop_back();
            }
            else
                continue;
        }
    }
    vector<vector<string>> partition(string s) 
    {
        if (s.size() == 0)  return result;
        backtracking(s, 0);
        return result;
    }
};

93. 复原 IP 地址
https://leetcode.cn/problems/restore-ip-addresses/



//该题不要path,直接在s里加'.'
//注意insert和erase的使用

class Solution {
public:
    vector<string>result;
    bool islegal(string& s, int start, int end)
    {
        if (s[start] == '0' && end - start != 0)
            return false;
        int sum = 0;
        int i;
        for (i = start; i <= end; i++)
        {
            if (s[i] < '0' && s[i] > '9')
                return false;
            
            sum = sum * 10 + (s[i] - '0');
            if (sum > 255)/******要放在for循环里面*****/
                return false;
        }
        return true;
    }
    void backtracking(string& s, int num, int start)
    {
        if (num == 3)
        {
            if (islegal(s, start, s.size() - 1))
            {
                result.push_back(s);
            }
            return;
        }

        int i;
        for (i = start; i < s.size(); i++)
        {
            if (islegal(s, start, i) && i + 1 != s.size()/*******/)
            {
                s.insert(s.begin() + i + 1, '.');
                // string temp = s.substr(start, i - start + 1);
                // path.push_back(temp);
                // path.push_back('.');
                backtracking(s, num + 1, i + 1 + 1/*注意不是i + 1*/);
                // path.pop_back();
                s.erase(s.begin() + i + 1);
            }
            else
                break;/******/
        }
    }
    vector<string> restoreIpAddresses(string s) 
    {
        if (s.size() < 4 || s.size() > 12)
            return result;
        
        backtracking(s, 0, 0);
        return result;
    }
};

78. 子集
https://leetcode.cn/problems/subsets/



class Solution {
public:
    vector<vector<int>>result;
    vector<int>path;
    void backtracking(vector<int>& nums, int start)
    {
        result.push_back(path);

        int i;
        for (i = start; i < nums.size(); i++)
        {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) 
    {
        backtracking(nums, 0);
        return result;
    }
};

90. 子集 II
https://leetcode.cn/problems/subsets-ii/



//注意点：解集 不能 包含重复的子集------>涉及树层的去重问题

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>& nums, vector<int>& used, int start)
    {
        result.push_back(path);
        
        int i;
        for (i = start; i < nums.size(); i++)
        {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)/*树层去重的关键*/
                continue;
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, used, i + 1);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) 
    {
        sort(nums.begin(), nums.end());/*树层去重的关键！！！！！！！！！！！*/
        vector<int>used(nums.size(), false);
        backtracking(nums, used, 0);
        return result;
    }
};

491.非递减子序列

注意：
放入答案时要注意其大小和path中最后一个元素的大小，注意是path的最后一个，而不是数组的前一个
https://leetcode.cn/problems/non-decreasing-subsequences/



//注意unordered_set的使用，与map不同，加入是insert,查找不可用下标
//注意查看vector的最后一个元素不可用下标，而是vector.back()


class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>& nums/*, vector<int>& used*/, int start)
    {
        if (path.size() >= 2)
            result.push_back(path);

        unordered_set<int>uset;/**!!!!!!!!!!!!!!!!!!*/
        
        int i;
        for (i = start; i < nums.size(); i++)
        {
            /*注意使用path.back()时要检查path是否为空*/
            if (!path.empty() && nums[i] < path.back())
                continue;

            /*[10,1,1,1,1,1]过不了，因为这题没有排序，而是按照之前的顺序，因此比较nums[i]和nums[i-1]没用*/
            // if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)/*树层去重的关键*/
            //     continue;

            if (uset.find(nums[i]) != uset.end())/*树层去重的关键*/
                continue;
                
            path.push_back(nums[i]);
            uset.insert(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
            // uset[nums[i]] = 0;(不用,因为退出该层就重新创建了)
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) 
    {
        // vector<int>used(nums.size(), false);
        // backtracking(nums, used, 0);

        backtracking(nums, 0);
        return result;
    }
};

46. 全排列
https://leetcode.cn/problems/permutations/



class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>& nums, vector<int>& used)
    {
        if (path.size() == nums.size())
        {
            result.push_back(path);
            return;
        }

        int i;
        for (i = 0; i < nums.size(); i++)
        {
            if (used[i] == 1)
                continue;
            path.push_back(nums[i]);
            used[i] = 1;
            backtracking(nums, used);
            path.pop_back();
            used[i] = 0;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) 
    {
        if (nums.size() == 0)
            return result;
        vector<int> used(nums.size(), 0);/*一定要初始化*/
        backtracking(nums, used);
        return result;
    }
};

47. 全排列 II
https://leetcode.cn/problems/permutations-ii/



//又涉及树层去重

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>& nums, vector<int>& used)
    {
        if (path.size() == nums.size())
        {
            result.push_back(path);
            return;
        }

        int i;
        for (i = 0; i < nums.size(); i++)
        {
            if (i > 0 && nums[i] == nums[i-1] && used[i - 1] == 0)
                continue;

            if (used[i] == 1)/*不能少*/
                continue;

            path.push_back(nums[i]);
            used[i] = 1;
            backtracking(nums, used);
            path.pop_back();
            used[i] = 0;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) 
    {
        if (nums.size() == 0)
            return result;
        
        sort(nums.begin(),nums.end());
        vector<int> used(nums.size(), 0);/*一定要初始化*/
        backtracking(nums, used);
        return result;
    }
};

P1219 [USACO1.5] 八皇后 Checker Challenge
https://www.luogu.com.cn/problem/P1219



int count = 0, ans[50] = { 0 }, lie[50] = { 0 }, dui[50] = { 0 }, fandui[17] = { 0 };
void dfs(int n, int row)
{
	int i;
	if (row == n + 1)/*注意是n + 1啊*/
	{
		count++;
		if (count <= 3)
		{
			for (i = 0; i < n; i++)
				printf("%d ", ans[i]);
			printf("\n");
		}
		return;
	}

	for (i = 1; i <= n; i++)//列
	{
		if (lie[i] == 1 || dui[i + row] == 1 || fandui[i - row + n] == 1)
			continue;

		lie[i] = 1;
		dui[i + row] = 1;
		fandui[i - row + n] = 1;

		ans[row - 1] = i;
		dfs(n, row + 1);

		lie[i] = 0;
		dui[i + row] = 0;
		fandui[i - row + n] = 0;
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	dfs(n, 1);
	printf("%d\n", count);
	return 0;
}

51. N 皇后
https://leetcode.cn/problems/n-queens/



//注意主对角线和副对角线的行列之间的关系

/*
<0,0>  <0,1>  <0,2>
 
<1,0>  <1,1>  <1,2>
 
<2,0>  <2,1>  <2,2>
*/

//主对角线：y - x相等------>注意可能是负数：至少要加上n - 1---->可能和主对角线的标记重复----->都加上n - 1
//副      ：y + x相等

class Solution {
public:
    vector<vector<string>> res;
    bool isValid(int row, int col, int n, std::vector<std::string> path)
    {
        int i, j;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (j == col && path[i][j] == 'Q')
                    return false;
                
                if ((i + j == row + col && path[i][j] == 'Q') || (-i + j == -row + col && path[i][j] == 'Q'))
                    return false;
            }
        }
        return true;
    }
    void backtracking(int n, int size, std::vector<std::string> path)
    {
        if (size == n)
        {
            res.push_back(path);
            return;
        }

        int i, j;
        for (j = 0; j < n; j++)
        {
            if (isValid(size, j, n,path))
            {
                path[size][j] = 'Q';
                backtracking(n, size + 1,path);
                path[size][j] = '.';
            }
        }
        
    }
    vector<vector<string>> solveNQueens(int n) 
    {
        //表示的是：path是一个装满string的容器，容器被初始化为有n个元素，每个元素是string，string被初始化为长度为n的.
        //：：是一个作用域解析运算符，用于指定一个名称在哪个命名空间或类中定义的
        //std ---->using namespace std;//用了叫做std的命名空间
        std::vector<std::string> path(n, std::string(n, '.'));/*先全部初始化为'.'*/
        backtracking(n, 0, path);
        return res;
    }
};

37. 解数独
https://leetcode.cn/problems/sudoku-solver/


class Solution {
public:
    bool isValid(vector<vector<char>>& board, int row, int col, char ch)
    {
        int i, j;
        for (i = 0; i < board.size(); i++)
        {
            for (j = 0; j < board[0].size(); j++)
            {
                if (i == row && board[i][j] == ch)
                    return false;
                
                if (j == col && board[i][j] == ch)
                    return false;

            }
        }
        
        int startx = row / 3 * 3;
        int starty = col / 3 * 3;
        for (i = startx; i < startx + 3; i++)
        {
            for (j = starty; j < starty + 3; j++)
            {
                if (board[i][j] >= '1' && board[i][j] <= '9' && board[i][j] == ch)
                    return false;
            }
        }
        return true;
    }
    //该题没有终止条件也没事，因为两层循环进行完了就会结束
    bool backtracking(vector<vector<char>>& board)
    {
        int i, j;
        for (i = 0; i < board.size(); i++)
        {
            for (j = 0; j < board[0].size(); j++)
            {
                if (board[i][j] <= '9' && board[i][j] >= '1')
                    continue;
                
                for (char ch = '1'; ch <= '9'; ch++)
                {
                    if (isValid(board, i, j, ch))
                    {
                        board[i][j] = ch;
                        if(backtracking(board))/*只要一种结果---->找到就立马返回---->递归函数要有返回值*/
                            return true;
                        board[i][j] = '.';
                    }
                }
                return false;//9个数都试完了，都没找到
            }
        }
        return true;
    }
    void solveSudoku(vector<vector<char>>& board) 
    {
        backtracking(board);
    }

看完了记得关注我哦：脑子不好的小菜鸟

以后共同进步，该账号会发布项目，算法，知识点等内容

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

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

相关文章

文献学习-13-机器人顶刊IJRR近期国人新作(2024.3)

文献学习-13-机器人顶刊IJRR近期国人新作(2024.3)

一、IJRR简介 The International Journal of Robotics Research&#xff08;IJRR&#xff09;是机器人领域的高水平学术期刊&#xff0c;专注于发布关于机器人技术和相关领域的最新研究成果。IJRR创刊于1982年&#xff0c;是该领域的第一本学术刊物&#xff0c;2022-2023最新影…
阅读更多...
qnx启动中控屏黑屏

qnx启动中控屏黑屏

bmetrics_service boot metrics service, 用于记录统计启动性能信息,读取/dev/bmetrics可以获取到这些信息 # use memorydump memorydump Sets the debug cookies, copies MMU info into reset_info asinfo, sets the secure monitor(TZ) dump buffer, starts tracelogger Usa…
阅读更多...
消息队列-Kafka-消费方如何分区与分区重平衡

消息队列-Kafka-消费方如何分区与分区重平衡

消费分区 资料来源于网络 消费者订阅的入口&#xff1a;KafkaConsumer#subscribe 消费者消费的入口&#xff1a;KafkaConsumer#poll 处理流程&#xff1a; 对元数据重平衡处理&#xff1a;KafkaConsumer#updateAssignmentMetadataIfNeeded 协调器的拉取处理&#xff1a;onsum…
阅读更多...
Fiddler抓包丨最常用功能实战演练

Fiddler抓包丨最常用功能实战演练

Fiddler中常用的功能如下&#xff1a; 停止抓包清空会话窗内容过滤请求解码设置断点 一. 停止抓包 二. 清空会话窗 方法一&#xff0c;工具栏工具&#xff1a; 方法二&#xff0c;命令行形式&#xff1a; 当然&#xff0c;命令行工具也还支持其他命令的输入&#xff0c;这里不…
阅读更多...
【C++】设计模式：建造者、原型、单例

【C++】设计模式：建造者、原型、单例

&#x1f60f;★,:.☆(&#xffe3;▽&#xffe3;)/$:.★ &#x1f60f; 这篇文章主要介绍设计模式&#xff1a;建造者、原型、单例。 学其所用&#xff0c;用其所学。——梁启超 欢迎来到我的博客&#xff0c;一起学习&#xff0c;共同进步。 喜欢的朋友可以关注一下&#xf…
阅读更多...
接口自动化测试用例的编写方法

接口自动化测试用例的编写方法

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 关注公众号【互联网杂货铺】&#xff0c;回复 1 &#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 phpunit 接口自动化测试系列 Post接口自动化测试用例 Post方式…
阅读更多...
Java使用spire.doc操作word文档(合并、插入文字图片和表格、替换书签)

Java使用spire.doc操作word文档(合并、插入文字图片和表格、替换书签)

一、引入依赖 <dependency><groupId>e-iceblue</groupId><artifactId>spire.office</artifactId><version>7.5.4</version> </dependency> 二、word操作 1、合并word文档 import com.spire.doc.Document; import com.spir…
阅读更多...
java多线程实现同步的方式介绍

java多线程实现同步的方式介绍

在 Java 多线程编程中&#xff0c;同步是确保多个线程在访问共享资源时的正确性和一致性的重要机制。Java 提供了多种方式来实现线程同步&#xff0c;每种方式都有其特点和适用场景。以下是一些常见的同步方式及其特点和应用场景&#xff0c;以及简单的例子来说明它们的用法。 …
阅读更多...
从零开始的LeetCode刷题日记：142.环形链表II

从零开始的LeetCode刷题日记：142.环形链表II

一.相关链接 视频链接&#xff1a;代码随想录&#xff1a;142.环形链表II 题目链接&#xff1a;142.环形链表II 二.心得体会 这道题是一道链表题&#xff0c;但他没有对头结点的操作&#xff0c;所以不用虚拟头结点。这道题要分两步进行&#xff0c;第一步是判断链表有没有环…
阅读更多...
win11修改主机mac地址

win11修改主机mac地址

很多时候&#xff0c;为了限制恶意的蹭流浪&#xff0c;除了分配固定的ip地址外&#xff0c;还限制mac地址。只有mac与ip一致&#xff0c;才能上网冲浪 网络适配器中修改 搜索“控制面板”打开 控制面板 > 网络和Internet > 网络和共享中心 >查看网络状态和任务>…
阅读更多...
Redis什么这么快和Redis单线程模型和多线程

Redis什么这么快和Redis单线程模型和多线程

概述 1、完全基于内存&#xff0c;绝大部分请求是纯粹的内存操作&#xff0c;非常快速。数据存在内存中&#xff0c;类似于HashMap&#xff0c;HashMap的优势就是查找和操作的时间复杂度都是O(1)&#xff1b; 2、数据结构简单&#xff0c;对数据操作也简单&#xff0c;Redis中…
阅读更多...
测试常用的Linux命令

测试常用的Linux命令

前言 直接操作硬件 将把操作硬件的代码封装成系统调用&#xff0c;供程序员使用 虚拟机软件 可以模拟的具有完整硬件系统的功能 可以在虚拟机上安装不同的操作系统 Linux内核只有一个&#xff0c;发行版有很多种 内核来运行程序和管理像磁盘和打印机等硬件设备的核心程序 终端…
阅读更多...
AD20中关于“Net(s) Not Found in Differential Pair”的解决方法

AD20中关于“Net(s) Not Found in Differential Pair”的解决方法

问题描述&#xff1a; Net(s) Not Found in Differential Pair&#xff1a;在差分对中找不到网络 我们需要在原理图设计中需要添加差分对&#xff0c;已经遵循了_N _P 结尾&#xff0c;也添加了差分对标识符&#xff0c;但是转换到PCB时显示差分对报错 解决方法&#xf…
阅读更多...
GSA、GSEA、ssGSEA、GSVA用到的统计学知识点

GSA、GSEA、ssGSEA、GSVA用到的统计学知识点

文章目录 概率密度函数&#xff08;probability density function&#xff0c;PDF&#xff09;分布函数&#xff08;Cumulative Distribution Function&#xff0c;CDF&#xff09;核密度估计&#xff08;KDE&#xff09;经验累计分布函数&#xff08;Empirical Cumulative Dis…
阅读更多...
VUE_nuxt启动只能通过localhost访问，ip访问不到:问题解决

VUE_nuxt启动只能通过localhost访问，ip访问不到:问题解决

修改项目根目录下的 package.json "config": {"nuxt": {"host": "0.0.0.0","port": "3000"} } 这样项目启动后就可以通过ip进行访问了
阅读更多...
目标检测论文模型笔记——YOLO系列

目标检测论文模型笔记——YOLO系列

1. YOLOv1的核心思想&#xff1a; YOLOv1&#xff1a;使用整张图作为输入&#xff0c;直接在输出层回归bounding box和类别&#xff1b;&#xff08;one-stage&#xff09;Faster RCNN&#xff1a;使用用整张图作为输入&#xff0c;但整体采用了RCNN&#xff1a; proposalclas…
阅读更多...
Facebook的社交未来：元宇宙时代的数字共融

Facebook的社交未来：元宇宙时代的数字共融

引言&#xff1a; 随着科技的不断进步和社会的快速发展&#xff0c;人们对于社交网络的需求和期待也在不断演变。在这个数字化时代&#xff0c;元宇宙的概念逐渐引发了人们对社交体验的重新思考。作为全球最大的社交网络之一&#xff0c;Facebook正在积极探索元宇宙时代的社交…
阅读更多...
低空经济20人｜卓翼智能任雪峰：以技术驱动市场，引领无人机细分领域创新

低空经济20人｜卓翼智能任雪峰：以技术驱动市场，引领无人机细分领域创新

作为国内系留无人机领域的领头羊企业&#xff0c;卓翼智能致力于提供智能无人系统解决方案。本期“低空经济20人”请到卓翼智能CEO任雪峰分享他对系留无人机研发应用的经验以及未来无人机行业生态发展的观点。 如今&#xff0c;无人机的应用场景逐渐广泛&#xff0c;在社会发展…
阅读更多...
go go.mod file not found in current directory or any parent directory

go go.mod file not found in current directory or any parent directory

场景&#xff1a; 安装好 liteide 之后创建了第一个 “hello world” 的golang 项目&#xff0c;却报了如下错误。 原因分析&#xff1a; go 的环境配置问题。与 golang 的包管理有关。 解决方案&#xff1a; 如果你是 Windows 系统&#xff0c;快捷键 “WinR”&#xff0c…
阅读更多...
Baumer工业相机堡盟工业相机如何通过NEOAPI SDK实现双快门采集两张曝光时间非常短的图像（C#）

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK实现双快门采集两张曝光时间非常短的图像（C#）

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK实现双快门采集两张曝光时间非常短的图像&#xff08;C#&#xff09; Baumer工业相机Baumer工业相机定序器功能的技术背景Baumer工业相机通过NEOAPI SDK使用定序器功能预期的相机动作技术限制定序器的工作原理 Baumer工业相机通过…
阅读更多...
最新文章

Copyright @ 2022~2023