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

news2024/11/20 23:34:37

目录

注意：

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);
    }

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

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

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

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

相关文章

YOLOv9: Learning What You Want to Learn Using Programmable Gradient Information

YOLOv9: Learning What You Want to Learn Using Programmable Gradient Information

paper: https://arxiv.org/abs/2402.13616 code YOLOv9: Learning What You Want to Learn Using Programmable Gradient Information 一、引言部分二、问题分析2.1 信息瓶颈原理2.2 可逆函数 三、本文方法3.1 可编程梯度信息 四、实验4.1消融实验部分 今天的深度学习方法关注的…
阅读更多...
ELK介绍使用

ELK介绍使用

文章目录 一、ELK介绍二、Elasticsearch1. ElasticSearch简介&#xff1a;2. Elasticsearch核心概念3. Elasticsearch安装4. Elasticsearch基本操作1. 字段类型介绍2. 索引3. 映射4. 文档 5. Elasticsearch 复杂查询 三、LogStash1. LogStash简介2. LogStash安装 四、kibana1. …
阅读更多...
hv静态资源web服务

hv静态资源web服务

在实际工作中&#xff0c;为了保证App的高可用性&#xff0c;服务端需要缓存一部分静态资源&#xff0c;通过web服务来分发资源。hv即可快速实现web服务。 hv静态资源服务。 HttpService router; router.Static("/statics", "smart-yi-ui");目录结构(sma…
阅读更多...
kafka 可视化工具

kafka 可视化工具

kafka可视化工具 随着科技发展&#xff0c;中间件也百花齐放。平时我们用的redis&#xff0c;我就会通过redisInsight-v2 来查询数据&#xff0c;mysql就会使用goland-ide插件来查询&#xff0c;都挺方便。但是kafka可视化工具就找了半天&#xff0c;最后还是觉得redpandadata…
阅读更多...
javaSE-----继承和多态

javaSE-----继承和多态

目录 一.初识继承&#xff1a; 1.1什么是继承&#xff0c;为什么需要继承&#xff1a; 1.2继承的概念与语法&#xff1a; 二.成员的访问&#xff1a; 2.1super关键字 2.2this和super的区别&#xff1a; 三.再谈初始化: 小结&#xff1a; 四.初识多态&#xff1a; 4.1多…
阅读更多...
Java Web开发---复试Tips复习

Java Web开发---复试Tips复习

***********&#xff08;自用&#xff0c;摘录自各种文章和自己总结&#xff09;********** 小知识点理解 Web Web应用开发主要是基于浏览器的应用程序开发。一个Web应用由多部分组成 java web就是用java语言开发出可在万维网上浏览的程序 Web应用程序编写完后&#xff0c;…
阅读更多...
【自然语言处理六-最重要的模型-transformer-上】

【自然语言处理六-最重要的模型-transformer-上】

自然语言处理六-最重要的模型-transformer-上 什么是transformer模型transformer 模型在自然语言处理领域的应用transformer 架构encoderinput处理部分&#xff08;词嵌入和postional encoding&#xff09;attention部分addNorm Feedforward & add && NormFeedforw…
阅读更多...
在哪里能找到抖音短视频素材？推荐热门的抖音短视频素材下载资源

在哪里能找到抖音短视频素材？推荐热门的抖音短视频素材下载资源

哎呦喂&#xff0c;小伙伴们&#xff0c;是不是在短视频的大海里划船&#xff0c;想找到那颗能让你起飞的珍珠&#xff0c;但又觉得素材难寻如针海捞针&#xff1f;别急&#xff0c;今天我就来给你们送上几个超实用的宝藏素材网站&#xff0c;让你的短视频创作不再愁素材 1&am…
阅读更多...
从零开始的LeetCode刷题日记：142.环形链表II

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

一.相关链接 视频链接&#xff1a;代码随想录&#xff1a;142.环形链表II 题目链接&#xff1a;142.环形链表II 二.心得体会 这道题是一道链表题&#xff0c;但他没有对头结点的操作&#xff0c;所以不用虚拟头结点。这道题要分两步进行&#xff0c;第一步是判断链表有没有环…
阅读更多...
如何获取国外信用卡？需要国外银行卡支付怎么解决？如何订阅国外产品？

如何获取国外信用卡？需要国外银行卡支付怎么解决？如何订阅国外产品？

当国内的用户想要使用国外的产品时&#xff0c;很多产品是需要订阅付费的。其中有些产品还没有引入国内&#xff0c;只能用国外的信用卡支付&#xff0c;对于在国内的朋友&#xff0c;如何获取一张国外的信用卡呢&#xff1f; 这里推荐一个平台&#xff1a;wildCard waildCard…
阅读更多...
基于Java的生活废品回收系统(Vue.js+SpringBoot)

基于Java的生活废品回收系统(Vue.js+SpringBoot)

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、研究内容三、界面展示3.1 登录注册3.2 资源类型&资源品类模块3.3 回收机构模块3.4 资源求购/出售/交易单模块3.5 客服咨询模块 四、免责说明 一、摘要 1.1 项目介绍 生活废品回收系统是可持续发展的解决方案&#xff0c;旨在鼓…
阅读更多...
安泰ATA-4014高压功率放大器的特点有哪些呢

安泰ATA-4014高压功率放大器的特点有哪些呢

高压功率放大器是一种用于放大高压和高功率信号的电子设备&#xff0c;具有特殊的性能和特点。下面安泰电子将详细介绍高压功率放大器的特点和应用。 高压功率放大器具有较高的输出电压和功率能力。相比于普通的放大器&#xff0c;高压功率放大器可以提供更高的输出电压和功率&…
阅读更多...
Day16：信息打点-语言框架开发组件FastJsonShiroLog4jSpringBoot等

Day16：信息打点-语言框架开发组件FastJsonShiroLog4jSpringBoot等

目录 前置知识 指纹识别-本地工具-GotoScan&#xff08;CMSEEK&#xff09; Python-开发框架-Django&Flask PHP-开发框架-ThinkPHP&Laravel&Yii Java-框架组件-Fastjson&Shiro&Solr&Spring 思维导图 章节知识点 Web&#xff1a;语言/CMS/中间件/…
阅读更多...
Decontam去污染：一个尝试

Decontam去污染：一个尝试

为了程序运行的便利性&#xff0c;不想将Decontam放到windows的Rstudio里面运行&#xff0c;需要直接在Ubuntu中运行&#xff0c;并且为了在Decontam时进行其他操作&#xff0c;使用python去运行R 首先你需要有一个conda环境&#xff0c;安装了R&#xff0c;Decontam&#xff0…
阅读更多...
迅速上手：CentOS 系统下 SSH 服务配置指南

迅速上手：CentOS 系统下 SSH 服务配置指南

前言 掌握 SSH 服务&#xff0c;就像拥有了一把解锁网络世界的钥匙。本文深入浅出地介绍了如何使用 SSH&#xff08;Secure Shell&#xff09;服务&#xff0c;从连接远程服务器到安全文件传输&#xff0c;让你轻松驾驭远程管理与数据传输&#xff0c;提高工作效率&#xff0c…
阅读更多...
安全防御-第七次

安全防御-第七次

在FW5和FW6之间建立一条IPSEC通道保证10.0.2.0/24网段可以正常访问到192.168.1.0/24 NAT&#xff1a; 安全策略&#xff1a; NAT: 安全策略&#xff1a; 修改服务器映射&#xff1a; 配置IPSEC&#xff1a;
阅读更多...
常州大学-吴颖：参加数维杯竞赛后，我成功拿到梦寐以求的奖项

常州大学-吴颖：参加数维杯竞赛后，我成功拿到梦寐以求的奖项

转眼间&#xff0c;数维杯数模竞赛已经进行到了第八年&#xff0c;这八年中&#xff0c;成千上万的数模人乘着属于自己的船成功抵达梦想的彼岸&#xff0c;每一场比赛都留下了他们努力的痕迹&#xff0c;更成为每次想起都觉得极为宝贵的经历。 当然&#xff0c;每个人的参赛经…
阅读更多...
SpringCloud之Nacos入门与实战系列

SpringCloud之Nacos入门与实战系列

目录 一、Nacos介绍 1.1、配置中心和注册中心的概念 1.2 Nacos 优点 二、Nacos的使用 2.1 以单机模式启动Nacos 2.2 Nacos部署方式介绍 2.3 配置数据源 2.4 开启控制台权限登录 三、配置中心的使用 3.1 创建配置信息 3.2 SpringBoot使用配置中心 四、注册中心的使用 4…
阅读更多...
如何在云服务器上面安装宝塔

如何在云服务器上面安装宝塔

一、宝塔面板 1.进入宝塔面板免费注册账号 2.找到安装宝 复制centos安装脚本 二、云服务器上安装宝塔 1.输入centos安装脚本 等待安装 出现这个表示安装成功 外网面板地址: https://云服务器内网IP:30230/d3032ee5内网面板地址: https://本地IP:30230/d3032ee5username: p27…
阅读更多...
每日学习总结20240308

每日学习总结20240308

每日总结 20240305 常用控件 QPushButton&#xff08;按钮&#xff09;&#xff1a;用于触发操作或响应用户点击事件。QLabel&#xff08;标签&#xff09;&#xff1a;用于显示文本或图像。QLineEdit&#xff08;行编辑器&#xff09;&#xff1a;单行文本输入框&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023