代码随想录 -- 回溯算法

news2024/12/26 22:12:16

文章目录

  • 回溯算法理论
    • 什么是回溯法
    • 回溯法的效率
    • 回溯法解决的问题
    • 理解回溯法
    • 回溯法模板
  • 组合问题I
    • 描述
    • 题解
    • 优化
  • 组合总和III
    • 描述
    • 题解
  • 电话号码的字母组合
    • 描述
    • 题解
  • 组合总和
    • 描述
    • 题解
  • 组合总和II
    • 描述
    • 题解
  • 分割回文串
    • 描述
    • 题解
  • 复原IP地址
    • 描述
    • 题解
  • 子集
    • 描述
    • 题解
  • 子集II
    • 描述
    • 题解
  • 递增子序列
    • 描述
    • 题解
  • 全排列
    • 描述
    • 题解
  • 全排列 II
    • 描述
    • 题解
  • 重新安排行程 难
    • 描述
      • 如何处理死循环？
      • 映射关系的记录
    • 题解
  • N皇后 难
    • 描述
    • 题解
  • 解数独 跳过
    • 描述
    • 题解

回溯算法理论

什么是回溯法

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。

回溯是递归的副产品，只要有递归就会有回溯。

回溯法的效率

纯暴力搜索

虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。
因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。

回溯法解决的问题

  • 组合问题：N个数里面按一定规则找出k个数的集合
  • 切割问题：一个字符串按一定规则有几种切割方式
  • 子集问题：一个N个数的集合里有多少符合条件的子集
  • 排列问题：N个数按一定规则全排列，有几种排列方式
  • 棋盘问题：N皇后，解数独等等

理解回溯法

回溯法解决的问题都可以抽象为树形结构

因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。

回溯法模板

伪代码

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

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

组合问题I

题目链接

描述

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

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

题解

class Solution {
private:
    vector<vector<int>>res;//最后的结果
    vector<int>path;//放单个组合
    
    void backtracking(int n,int k,int startIndex){
        if (path.size()==k){
            res.push_back(path);
            return;
        }
        for (int i = startIndex; i <= n; ++i) {
            path.push_back(i);
            backtracking(n,k,i+1);//使用递归代表for 一层递归一个for循环
            path.pop_back();
        }
    }
public:
    // 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合
    vector<vector<int>> combine(int n, int k) {
        backtracking(n,k,1);
        return res;
    }
};

优化

如果n=k=4 那么第一层for循环从i=2之后都毫无意义

可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

优化过程

  • 已经存入的元素的个数：path.size()
  • 还需要的元素的个数：k-path.size()
  • 表中剩余元素的个数：n-i >= 所需元素（k - path.size()）
  • 在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历
    为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。
从2开始搜索都是合理的，可以是组合[2, 3, 4]。

class Solution {
private:
    vector<vector<int>>res;//最后的结果
    vector<int>path;//放单个组合
    
    void backtracking(int n,int k,int startIndex){
        if (path.size()==k){
            res.push_back(path);
            return;
        }
        for (int i = startIndex; i <= n-(k-path.size())+1; ++i) {//优化后的for循环
            path.push_back(i);
            backtracking(n,k,i+1);//使用递归代表for 一层递归一个for循环
            path.pop_back();
        }
    }
public:
    // 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合
    vector<vector<int>> combine(int n, int k) {
        backtracking(n,k,1);
        return res;
    }
};

组合总和III

题目链接

描述

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

所有数字都是正整数。
解集不能包含重复的组合。
示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]

示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

题解

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;

    /**
     *
     * @param k 1-9之间选取的个数
     * @param n k个数的和为n
     * @param startIndex 循环开始的数
     * @param sum 目前已经和为多少
     */
    void backtracking(int k, int n, int startIndex, int sum) {
        if (sum > n)return;
        if (path.size() == k) {
            if (sum == n)res.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; ++i) {// 剪枝
            path.push_back(i);
            sum += i;
            backtracking(k, n, i + 1, sum);
            path.pop_back();
            sum -= i;
        }
    }

public:
    vector<vector<int>> combinationSum3(int k, int n) {
        path.clear();
        res.clear();
        backtracking(k, n, 1, 0);
        return res;
    }
};

电话号码的字母组合

题目链接

描述

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

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

在这里插入图片描述
输入：“23”
输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].
说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

题解

class Solution {
private:
    vector<string> res;
    string path;
    vector<string>flags={"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    void backtracking(string digits,int len,int startIndex) {
        if (path.size()==len){
            res.push_back(path);
            return;
        }
        string letter=flags[digits[startIndex]-'0'-2];
        for (int i = 0; i < letter.size(); ++i) {
            path.push_back(letter[i]);
            backtracking(digits,len,startIndex+1);
            path.pop_back();
        }
    }

public:
    vector<string> letterCombinations(string digits) {
        int len = digits.size();
        if (!len)return res;
        backtracking(digits,len,0);
        return res;
    }
};

组合总和

题目链接

描述

给定一个无重复元素的数组 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] ]

题解

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(vector<int> &canidates, int target, int nowSum, int startIndex) {
        if (nowSum > target)return;
        if (nowSum == target) {
            res.push_back(path);
            return;
        }
        int len = canidates.size();
        for (int i = startIndex; i < len; ++i) {
            path.push_back(canidates[i]);
            nowSum += canidates[i];
            backtracking(canidates, target, nowSum, i);
            path.pop_back();
            nowSum -= canidates[i];
        }
    }

public:
    vector<vector<int>> combinationSum(vector<int> &candidates, int target) {
        backtracking(candidates, target, 0, 0);
        return res;
    }
};

组合总和II

添加链接描述

描述

给定一个数组 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 {
private:
    vector<vector<int>>res;
    vector<int>path;
    void backtracking(vector<int>&candidates,int target,int nowSum,int index){
        if (nowSum>target)return;
        if (nowSum==target){
            res.push_back(path);
            return;
        }
        for (int i = index; i < candidates.size(); ++i) {
            if (i>index&&candidates[i]==candidates[i-1])continue;
            path.push_back(candidates[i]);
            nowSum+=candidates[i];
            backtracking(candidates,target,nowSum,i+1);
            path.pop_back();
            nowSum-=candidates[i];
        }

    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return res;
    }
};

分割回文串

题目链接

描述

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例: 输入: “aab” 输出: [ [“aa”,“b”], [“a”,“a”,“b”] ]

题解

class Solution {
private:
    vector<vector<string>>res;
    vector<string>path;
    bool isPalindrome(const string&s,int start,int end){
        for (int i = start,j=end; i < j; ++i,--j) {
            if (s[i]!=s[j])return false;
        }
        return true;
    }
    void backtracking(const string&s,int startIndex){
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex>=s.size()){
            res.push_back(path);
            return;
        }

        for (int i = startIndex; i < s.size(); ++i) {
            if (isPalindrome(s,startIndex,i)){
                // 获取[startIndex,i]在s中的子串
                string str=s.substr(startIndex,i-startIndex+1);
                path.push_back(str);
            }else//如果不是回文串 那么跳过
                continue;
            backtracking(s,i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return res;
    }
};

复原IP地址

题目链接

描述

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。

例如：“0.1.2.201” 和 “192.168.1.1” 是 有效的 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效的 IP 地址。

示例 1：

输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]
示例 2：

输入：s = “0000”
输出：[“0.0.0.0”]
示例 3：

输入：s = “1111”
输出：[“1.1.1.1”]

题解

class Solution {
private:
    vector<string> res;
    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string &s, int startIndex, int pointNum) {
        if (pointNum == 3) {//逗号个数为3时 分割结束
            //判断第四段字符串是否合法
            if (vaildIP(s, startIndex, s.size() - 1)) {
                res.push_back(s);
                return;
            }
        }

        for (int i = startIndex; i < s.size(); ++i) {
            if (vaildIP(s, startIndex, i)) {// 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1, '.');//在i后面插入逗号
                ++pointNum;
                backtracking(s, i + 2, pointNum);
                --pointNum;
                s.erase(s.begin() + i + 1);
            } else break;//不合法直接结束本层循环 因为如果这一段不合法那么再加一个字符也是不合法的
        }
    }

    bool vaildIP(const string &s, int start, int end) {
        if (start > end)return false;
        if (s[start] == '0' && start != end)return false;

        int num=0;
        for (int i = start; i <= end; ++i) {
            if (s[i]<'0'||s[i]>'9')return false;
            num=num*10+s[i]-'0';
            if (num>255)return false;
        }
        return true;
    }

public:
    vector<string> restoreIpAddresses(string s) {
        backtracking(s, 0, 0);
        return res;
    }
};

子集

题目链接

描述

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

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

示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

题解

class Solution {
private:
    vector<vector<int>>res;
    vector<int>subSet;
    void backtracking(vector<int>&nums,int startIndex){
        res.push_back(subSet); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex>=nums.size())return;//终止条件 可以不加，因为下面的循环当startIndex==size的时候就不会进行了
        for (int i = startIndex; i < nums.size(); ++i) {
            subSet.push_back(nums[i]);
            backtracking(nums,i+1);
            subSet.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums,0);
        return res;
    }
};

子集II

题目链接

描述

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

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

示例:

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

题解

和子集I思路差不多，不过多了一个去重操作

class Solution {
private:
    vector<vector<int>>res;
    vector<int>path;

    void backtracking(vector<int>&nums,int startIndex){
        res.push_back(path);
        if (startIndex>=nums.size())return;
        for (int i = startIndex; i < nums.size(); ++i) {
            if (i>startIndex&&nums[i]==nums[i-1])continue;
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        backtracking(nums,0);
        return res;
    }
};

递增子序列

题目链接

描述

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]
说明:

给定数组的长度不会超过15。
数组中的整数范围是 [-100,100]。
给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

题解

有更好的优化 比如unordered_set换成数组 因为题目给出了数字的范围

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(vector<int> &nums, int startIndex) {
        if (path.size() >= 2) {
            res.push_back(path);
            //后面不可以加return 因为要遍历全部
        }
        unordered_set<int> uset;//uset仅负责一层 也就是一层递归调用函数
        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) {
        backtracking(nums, 0);
        return res;
    }
};

全排列

题目链接

描述

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

示例:

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

题解

排列问题：

  • 每层都是从0开始搜索而不是startIndex
  • 需要used数组记录path里都放了哪些元素了
class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(vector<int> &nums,vector<bool>&used) {
        if (path.size() == nums.size()) {
         // 此时说明找到了一组
            res.push_back(path);
            return;
        }

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

public:
    vector<vector<int>> permute(vector<int> &nums) {
        vector<bool>used(nums.size(),false);
        backtracking(nums,used);
        return res;
    }
};

全排列 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

题解

借用代码随想录网站的图：

树层上去重(used[i - 1] == false)，的树形结构如下：
在这里插入图片描述
树枝上去重（used[i - 1] == true）的树型结构如下：
在这里插入图片描述

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(vector<int> &nums, vector<bool> &used) {
        if (path.size() == nums.size()) {
            res.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]) {
                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) {
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, used);
        return res;
    }
};

重新安排行程 难

题目链接

描述

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

提示：

如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前
所有的机场都用三个大写字母表示（机场代码）。
假定所有机票至少存在一种合理的行程。
所有的机票必须都用一次 且 只能用一次。
示例 1：

输入：[[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
输出：[“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]
示例 2：

输入：[[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”]。但是它自然排序更大更靠后。

本题中存在的几个难点

如何处理死循环？

在这里插入图片描述
出发机场和到达机场也会重复的，如果在解题的过程中没有对集合元素处理好，就会死循环

映射关系的记录

题目要求：如果有多个路径，字母序靠前排在前面

一个机场映射多个机场，多个机场之间要按照字母序排序

可以使用unordered_map<string,map<string,int>> targets ，也就是对应

map/set 自动排序（按照数字、字母序，从小到大排序）

unordered_map<出发机场，map<到达机场，航班次数>>

在遍历 unordered_map<出发机场, map<到达机场, 航班次数>> targets的过程中，可以使用"航班次数"这个字段的数字做相应的增减，来标记到达机场是否使用过了

如果“航班次数”大于零，说明目的地还可以飞，如果“航班次数”等于零说明目的地不能飞了，而不用对集合做删除元素或者增加元素的操作。

题解

class Solution {
private:
    unordered_map<string, map<string, int>> targets;
    vector<string> result;

    // 对于本题目而言 我们不需要遍历跟到节点的所有可能，只需要找到一个行程，就是在树形结构中唯一的一条通向叶子节点的路线
    // 所以需要返回值
    bool backtracking(vector<vector<string>> &tickets, int ticketNum) {
        if (ticketNum + 1 == result.size())return true;
        for (pair<const string, int> &target: targets[result[result.size() - 1]]) {
            if (target.second) {
                result.push_back(target.first);
                target.second--;
                if (backtracking(tickets, ticketNum))return true;
                target.second++;
                result.pop_back();
            }
        }
        return false;
    }

public:
    vector<string> findItinerary(vector<vector<string>> &tickets) {
        for (const vector<string> &ticket: tickets)
            targets[ticket[0]][ticket[1]]++;

        result.push_back("JFK");
        backtracking(tickets, tickets.size());
        return result;
    }
};

N皇后 难

题目链接

描述

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

不能同行
不能同列
不能同斜线

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
在这里插入图片描述

题解

class Solution {
private:
    vector<vector<string>>res;
    bool isValid(int row,int col,int n,vector<string>&path){
        //检查列
        for(int i = 0; i < row; ++i)
            if(path[i][col]=='Q')return false;
        /* 检查行是多余的，
            因为在单层搜索的过程中，每一层递归，只会选for循环（也就是同一行）里的一个元素，所以不用去重了。
        for(int i = 0;i < col;++i)
            if(path[row][i]=='Q')return false;   
        */
       //45度
       for(int i = col-1,j=row-1;i >= 0&&j>=0;--i,--j){
            if(path[j][i]=='Q')return false;
       }

       //135度
       for(int i = row-1,j=col+1;i>=0&&j<n ;--i,++j){
            if(path[i][j]=='Q')return false;
       }
       return true;

    }
    void backtracking(int n,int start,vector<string>&path){
        if(start==n){
            res.push_back(path);
            return;
        }

        for(int i = 0 ;i < n ;++i){
            if(isValid(start,i,n,path)){
                path[start][i]='Q';
                backtracking(n,start+1,path);
                path[start][i]='.';
            }
        }
    }
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<string>path(n,string(n,'.'));
        backtracking(n,0,path);
        return res;
    }
};

解数独 跳过

题目链接

描述

编写一个程序，通过填充空格来解决数独问题。

一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。
在这里插入图片描述

在这里插入图片描述
提示：

给定的数独序列只包含数字 1-9 和字符 ‘.’ 。
你可以假设给定的数独只有唯一解。
给定数独永远是 9x9 形式的。

题解

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

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

相关文章

【JAVA】JAVA方法的学习和创造

【JAVA】JAVA方法的学习和创造

&#x1f308;个人主页: Aileen_0v0 &#x1f525;热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法|MySQL| ​&#x1f4ab;个人格言:“没有罗马,那就自己创造罗马~” 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不…
阅读更多...
考研C语言复习进阶（2）

考研C语言复习进阶（2）

目录 1. 字符指针 2. 指针数组 3. 数组指针 3.1 数组指针的定义 3.2 &数组名VS数组名 4. 函数指针 5. 函数指针数组 6. 指向函数指针数组的指针 7. 回调函数 8.三步辗转法 9. 指针和数组笔试题解析 10. 指针笔试题 指针的主题&#xff0c;我们在初级阶段的《指…
阅读更多...
Parade Series - Web Streamer Low Latency

Parade Series - Web Streamer Low Latency

Parade Series - FFMPEG (Stable X64) 延时测试秒表计时器 ini/config.ini [system] homeserver storestore\nvr.db versionV20240312001 verbosefalse [monitor] listrtsp00,rtsp01,rtsp02 timeout30000 [rtsp00] typelocal deviceSurface Camera Front schemartsp ip127…
阅读更多...
mac启动skywalking报错

mac启动skywalking报错

这个命令显示已经成功 但是日志报错了以上内容。 然后去修改。vim .bash_profile 查看全局变量&#xff0c;这个jdk却是有2个。所以这个问题没解决。
阅读更多...
豆瓣电影信息爬取与可视化分析

豆瓣电影信息爬取与可视化分析

目录 一、项目背景 二、代码 三、总结 一、项目背景 &#xff08;1&#xff09;利用requests库采集豆瓣网分类排行榜 (“https://movie.douban.com/chart”)中各分类类别前100部电影的相关信息并存储为csv文件。 &#xff08;2&#xff09;利用获取的13个分类类别共1300部电…
阅读更多...
C#，人工智能，机器学习，聚类算法，训练数据集生成算法、软件与源代码

C#，人工智能，机器学习，聚类算法，训练数据集生成算法、软件与源代码

摘要：本文简述了人工智能的重要分支——机器学习的核心算法之一——聚类算法，并用C#实现了一套完全交互式的、可由用户自由发挥的，适用于聚类算法的训练数据集生成软件——Clustering。用户使用鼠标左键（拖动）即可生成任意形状，任意维度，任意簇数及各种数据范围的训练数…
阅读更多...
第十六个实验：FOR循环生成随机数

第十六个实验：FOR循环生成随机数

实验内容&#xff1a; 用For循环生成10个1-2之间的随机数 然后打印出来 实验步骤; 视频&#xff1a; 教学视频
阅读更多...
外卖点餐系统 |基于springboot框架+ Mysql+Java+JSP技术+Tomcat的外卖点餐系统 设计与实现(可运行源码+设计文档)

外卖点餐系统 |基于springboot框架+ Mysql+Java+JSP技术+Tomcat的外卖点餐系统 设计与实现(可运行源码+设计文档)

推荐阅读100套最新项目 最新ssmjava项目文档视频演示可运行源码分享 最新jspjava项目文档视频演示可运行源码分享 最新Spring Boot项目文档视频演示可运行源码分享 目录 前台功能效果图 骑手功能模块 商家功能模块 管理员功能登录前台功能效果图 用户功能模块 系统功能设…
阅读更多...
Dynamo PythonScript 代码速查手册By九哥

Dynamo PythonScript 代码速查手册By九哥

你好&#xff0c;这里是 BIM 的乐趣&#xff0c;我是九哥 今天给大家带来的是我的知识工程的第二套知识库&#xff0c;这套知识库不是教程&#xff0c;是一套完整的笔记&#xff0c;里面包含了大量的 Python 代码。 当然这里也没有实现太多的具体逻辑&#xff0c;单纯的是通过 …
阅读更多...
可视化软件：第一原理计算/VASP + 结构预测/USPEX

可视化软件：第一原理计算/VASP + 结构预测/USPEX

分享一篇 VASPUSPEX 的可视化软件。 感谢论文的原作者&#xff01; 主要内容 “流行的第一原理仿真代码 Vienna Ab initio Simulation Package (VASP) 和晶体结构预测 (CSP) 包、Universal Structure Predictor: Evolutionary Xtallography (USPEX) 已集成到 GDIS 可视化软件…
阅读更多...
项目分享--NO.1

项目分享--NO.1

搭建高可用的web集群.部署网站 包含数据库,ceph/nfs,haproxy,keepalived,ansible部署 1,配置ansible管理环境 创建工作目录,编写ansible配置文件,和主机清单文件,yum配置文件 将yum文件到控制机上,然后用模块上传到被管理机器上 #vim 01-upload-repo.yml --- - name: confi…
阅读更多...
【开源鸿蒙】为QEMU RISC-V虚拟平台构建OpenHarmony轻量系统

【开源鸿蒙】为QEMU RISC-V虚拟平台构建OpenHarmony轻量系统

文章目录 一、背景介绍二、准备OpenHarmony源代码三、准备hb命令3.1 安装hb命令3.2 检查hb命令 四、编译RISC-V架构的OpenHarmony轻量系统4.1 设置hb构建目标4.2 启动hb构建过程 五、问题解决5.1 hb set 报错问题解决 六、参考链接 开源鸿蒙坚果派&#xff0c;学习鸿蒙一起来&a…
阅读更多...
达梦如何备份以及导入

达梦如何备份以及导入

启动达梦服务 右键选择管理服务器 点击系统管理&#xff0c;点击配置&#xff0c;点击转换 归档配置点击归档 创建文件夹&#xff0c;选择文件夹目录点击确定 命令方式 逻辑备份与还原 逻辑导出(dexp)和逻辑导入(dimp)支持如下四种级别操作&#xff1a; 数据库级(FULL)&#…
阅读更多...
【SpringBoot】请求与响应参数 IoC与DI 总结

【SpringBoot】请求与响应参数 IoC与DI 总结

文章目录 ① —— 请求 ——一、简单参数 RequestParam1.1 参数与形参 命名相同1.2 参数与形参 命名不同 二、实体参数2.1 简单实体对象2.2 复杂实体对象 三、数组集合参数3.1 数组3.2 集合 RequestParam 四、日期参数 DateTimeFormat五、JSON参数 RequestBody六、路径参数 Pat…
阅读更多...
Vmware虚拟机使用过程中断电后无法重启处理

Vmware虚拟机使用过程中断电后无法重启处理

背景 今天在用新装的虚拟机进行测试的过程中&#xff0c;忽然笔记本关机了&#xff08;没插电源线&#xff09;&#xff0c;重启电脑后发现虚拟机提示“正在使用中“&#xff0c;具体如下所示&#xff1a; 解决 在相关虚拟机文件夹内查找以 .lck 结尾的文件&#xff0c;名称一…
阅读更多...
如何优化使用Nginx

如何优化使用Nginx

文章目录 &#x1f50a;博主介绍&#x1f964;本文内容数据压缩负载均衡安装OpenResty或ngx_http_lua_module配置Nginx以启用Lua编写Lua脚本配置upstream块以使用Lua变量测试配置 合并请求1. 确保SSI模块已启用2. 配置Nginx以使用SSI3. 使用SSI指令4. 重新加载或重启Nginx 集成…
阅读更多...
【Maven入门篇】(2)IDEA集成Maven环境的具体操作

【Maven入门篇】(2)IDEA集成Maven环境的具体操作

&#x1f38a;专栏【Maven入门篇】 &#x1f354;喜欢的诗句&#xff1a;更喜岷山千里雪 三军过后尽开颜。 &#x1f386;音乐分享【The truth that you leave】 &#x1f970;欢迎并且感谢大家指出我的问题 文章目录 &#x1f354;配置Maven环境⭐方法一&#xff08;当前工程&…
阅读更多...
选频网络与串联谐振回路

选频网络与串联谐振回路

选频网络概述 在高频电子线路中&#xff0c;常以选频网络作为负载。选频网络能选出我们需要的频率分量和滤除不需要的频率分量。 选频网络分类&#xff1a; 1、振荡回路&#xff08;由L、C组成&#xff0c;也称谐振回路&#xff09;&#xff1a;包括单振荡回路、耦合振荡回路…
阅读更多...
Java项目：58 ssm012医院住院管理系统+vue

Java项目：58 ssm012医院住院管理系统+vue

作者主页&#xff1a;源码空间codegym 简介&#xff1a;Java领域优质创作者、Java项目、学习资料、技术互助 文中获取源码 项目介绍 管理员&#xff1b;首页、个人中心、医护人员管理、科室管理、病人管理、病房管理、病人信息管理、病历管理、医嘱管理、手术安排管理、药品信…
阅读更多...
【linux】搜索所有目录和子目录下的包含.git的文件并删除

【linux】搜索所有目录和子目录下的包含.git的文件并删除

一、linux命令搜索所有目录和子目录下的包含.git的文件 在Linux系统中&#xff0c;要搜索所有目录和子目录下的包含.git的文件&#xff0c;可以使用find命令。find命令允许指定路径、表达式和操作来查找文件。 以下是使用find命令搜索包含.git的文件的方法&#xff1a; 1. 基…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023