【面试HOT200】回溯篇

news2024/11/18 1:25:37

系列综述：
💞目的：本系列是个人整理为了秋招面试的，整理期间苛求每个知识点，平衡理解简易度与深入程度。
🥰来源：材料主要源于【CodeTopHot300】进行的，每个知识点的修正和深入主要参考各平台大佬的文章，其中也可能含有少量的个人实验自证，所有代码均优先参考最佳性能。
🤭结语：如果有帮到你的地方，就点个赞和关注一下呗，谢谢🎈🎄🌷！！！
🌈【C++】秋招&实习面经汇总篇

文章目录

    • 基础知识
    • 回溯基础算法模板
      • 组合问题
        • 无重复元素的组合
        • 有重复元素的组合
      • 排列问题
        • 无重复元素的全排列
        • 有重复元素的全排列
    • <font face="黑体" color=purple>HOT200回溯相关题目
        • 39. 组合总和
        • 40. 组合总和 II
        • 93. 复原 IP 地址
        • 131. 分割回文串
        • 1005. K 次取反后最大化的数组和
    • 参考博客

😊点此到文末惊喜↩︎

基础知识

  1. 回溯算法 = 穷举 + 剪枝
    • 穷举：从一个选择开始，一步步尝试每一个可能的选择，如果某次选择导致问题无法解决，则回溯并选择另一种可能，直到找到一个可行的解或者穷举所有可能的解。
    • 剪枝：在搜索过程中，根据问题的限制条件，减少搜索空间，提高算法效率
  2. 作用
    • 在多个选择中搜索出满足条件的所有可能解
    • 一般地，组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。
  3. 回溯算法解决的问题一般为npc问题，难以使用常规算法进行解决
    • 组合问题：N个数里面按一定规则找出k个数的集合
      • 切割问题：一个字符串按一定规则有几种切割方式
      • 子集问题：一个N个数的集合里有多少符合条件的子集
    • 排列问题：N个数按一定规则选出M个，有几种排列方式
    • 棋盘问题：N皇后，解数独等等
  4. 所有的回溯法解决的问题都可以抽象为树形结构
    • 根节点是总数据集合，树枝节点是可选数据集合
    • 叶子节点为根节点到叶子节点的路径的选择集合
      在这里插入图片描述
// 结果集和路径集
vector<vector<type> res;
vector<type> path;
void backtracking(vecotr<type> candidates, int startIndex) {
	// 针对当前选择的合法性判断
	auto is_ok = [](const type &data)->bool{
		// type中数据项的合法性判断
	};
	// 递归出口：结点剪枝，生成慢
    if (is_ok(val)) {
        res.push_back(path);
        return;
    }
	// 延申和回撤路径时，可能涉及多个状态标记变量的改动
    for (int i = startIndex; i < candidates.size(); ++i) {
    	分叉剪枝判断（性能高）;
    	// 状态延申改动
        path.push_back(candidates[i]);// 向下延申
        backtracking(剩余可选列表); // 回溯
        // 状态回撤改动
        path.pop_back();// 回撤延申
    }
}
// 主函数
vector<vector<int>> combine(vector<type>& candidates) {
       res.clear(); // 可以不写
       path.clear();// 可以不写
       backtracking(candidates, 0);
       return result;
   }

回溯基础算法模板

模板使用的初衷：将问题的输入转换成对应模板的输入格式，然后调用模板的函数（已经背诵的）进行快速的求解

组合问题

  1. 组合问题的复杂度
    • 时间复杂度： O ( C n k × k ) O(C_n^k × k) O(Cnk​×k)，总共有 C n k C_n^k Cnk​种组合，每种组合需要 O ( k ) O(k) O(k) 的时间复杂度
    • 空间复杂度： O ( n ) O(n) O(n)，递归深度为n，所以系统栈所用空间为 O ( n ) O(n) O(n)
无重复元素的组合
  1. 基本概述
    • 问题：从无重复元素的集合中选出K个元素组成组合，每个元素只能被选取一次，且选出的元素之间没有顺序之分。
    • 举例：从元素集合{1，2，3}中选择2个元素的组合为{(1,2)，(1,3)，(2,3)}。
      在这里插入图片描述
  2. 代码
    • 解决的问题：给定一个线性表，求该线性表中满足条件的组合
    • 示例：求线性表中所有个数为target的结果。
    • 剪枝：列表中剩余元素(vec.size() - i) >= 所需需要的元素个数(target - path.size()) 
// 从候选集candidate中选出任意k个数组成的集合
vector<vector<int>> Backtracking(vector<int> &candidate, int k) {
	const int len = candidate.size();
    // 递归函数
    vector<int> path;			// 符合条件的路径
    vector<vector<int>> res;	// 符合条件的路径集合
    auto self = [&](auto &&self, int pos){
        // 递归出口：满足条件的路径加入结果集中
        if (path.size() == k) {
            res.push_back(path);
            return;
        }
        // i = start表示从之后剩余中选择
        for (int i = pos; i < len ; ++i) {
            if (i > len - (k-path.size())) 
                 continue;
            path.push_back(candidate[i]);	// 做出选择
           	self(self, i+1);// key: 是i+1	// 递归
            path.pop_back();				// 撤销选择
        }
    };
    self(self, 0);
    return res;
}
有重复元素的组合
  1. 基本概述
    • 问题：从有重复元素的组合中选出若干元素组成组合，每个元素只能被选取一次，且选出的元素之间没有顺序之分。
    • 举例：从集合{1, 2, 2, 3}中选择2个元素的组合为{1, 2}、{1, 3}、{2, 2}、{2, 3}。
  2. 代码
    • 解决问题：给定一个线性表，求该线性表中满足条件的组合，因为有重复元素，所以选择重复元素时只能使用一次，否则会出现集合中的重复
vector<vector<int>> Backtracking(vector<int> &candidate, int k) {
    // 排序
    sort(candidate.begin(), candidate.end());
    // 递归匿名函数
    vector<int> path;
    vector<vector<int>> res;
    auto self = [&](auto &&self, int pos){
        if (path.size() == k) {
            res.push_back(path);
            return;
        }

        for (int i = pos; i < candidate.size(); ++i) {
            // key: i > pos。第一次选取到重复的数，不会影响后面
            if (i > pos && candidate[i] == candidate[i-1])
                continue;
            path.push_back(candidate[i]);
            self(self, i+1);
            path.pop_back();
        }
    };
    // 递归调用
    self(self, 0);
    return res;
}

排列问题

  1. 组合问题的复杂度
    • 时间复杂度： O ( n × n ! ) O(n×n!) O(n×n!)，一共 n ! n! n! 种组合，每种排列构造时间需要 O ( n ) O(n) O(n) 的时间复杂度
    • 空间复杂度： O ( n ) O(n) O(n)，递归深度为n，所以系统栈所用空间为 O ( n ) O(n) O(n)
无重复元素的全排列
  1. 基本概述
    • 问题：无重复元素的排列是指在给定一组不同的元素中，按照一定的顺序排列出所有可能的组合，每个元素只出现一次。
    • 举例：从集合{1, 2, 3}，则可以产生以下6种无重复元素的排列：{1, 2, 3}、{1, 3, 2}、{2, 1, 3}、{2, 3, 1}、{3, 1, 2}、{3, 2, 1}。
      在这里插入图片描述
  2. 代码
    • 不需要使用pos，每一个i对应一位
    vector<vector<int>> permute(vector<int>& candidate) {
    const int len = candidate.size();
    vector<int> path;				// 回溯路径
    vector<vector<int>> res;		// 回溯结果集
    vector<bool> used(len, false);	// 使用标记
    auto self = [&](auto &&self){	// 回溯算法
        if (path.size() == len) {
            res.push_back(path);
            return ;
        }
        for (int i = 0; i < len; ++i) {
        	// path里已经收录的元素，直接跳过
            if (used[i] == true) continue;
            // 增加选择
            used[i] = true;
            path.push_back(candidate[i]);
            // 进行回溯
            self(self);
            // 撤回选择
            used[i] = false;
            path.pop_back();
        }
    };
    // 调用
    self(self);
    return res;
}
有重复元素的全排列

  1. 基本概述

    • 问题：无重复元素的排列是指在给定一组不同的元素中，按照一定的顺序排列出所有的不重复组合
    • 举例：从集合[1,1,2]，则可以产生无重复的全排列： [1,1,2], [1,2,1], [2,1,1]

  2. 代码

    • 产生重复解的原因：例如[1,1,2], 无法区分[1(0), 1(1), 2] 和[1(1), 1(0), 2] 这两种情况的解
      在这里插入图片描述
    vector<vector<int>> permuteUnique(vector<int>& candidate) {
    const int len = candidate.size();
    sort(candidate.begin(), candidate.end());
	// 递归
    vector<int> path;
    vector<vector<int>> res;
    vector<bool> used(len, false);  // key：注意初始化
    auto self = [&](auto &&self){
        if (path.size() == len) {
            res.emplace_back(path);
            return ;
        }
        for (int i = 0; i < len; ++i) {
            // 有效的重复元素 && 前一个元素未被使用
            // 保证相同元素同层中只有第一个被使用
            if (i > 0 && candidate[i] == candidate[i-1] && used[i-1] == false) 
                continue;
           if (used[i] == false) {
                used[i] = true;
                path.emplace_back(candidate[i]);
                self(self);
                used[i] = false;
                path.pop_back();
           }
        }
    };

    self(self);
    return res;
}

// 哈希表处理重复解
vector<vector<int>> permuteUnique(vector<int>& candidate) {
    const int len = candidate.size();
    // 去重
    unordered_map<int, int> umap;
    for (auto &i : candidate) ++umap[i];
    // 回溯算法
    vector<vector<int> > res;
    vector<int> path;
    auto self = [&](auto &&self, int pos){
        // 递归出口
        if (pos == len) {
            res.push_back(path);
            return ;
        }
        for (auto &i : umap) {
            if (i.second == 0) continue;
            path.push_back(i.first);
            --i.second;
            self(self, pos+1);
            path.pop_back();
            ++i.second;
        }
    };
    self(self, 0);
    return res;
}

HOT200回溯相关题目

39. 组合总和
  1. 题目
    • 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回
    • candidates 中的 同一个 数字可以 无限制重复被选取
    • 输入：candidates = [2,3,5], target = 4
    • 输出：[[2,2]]
      在这里插入图片描述
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
	vector<vector<int>> res;
	vector<int> path;
	auto self =  [&](auto &&self, int pos, int sum){
	    // 结束条件
	    if (sum > target) return ;
	    if (sum == target) {
	        res.push_back(path);
	        return ;
	    }
	    // 路径回溯
	    for (int i = pos; i < candidates.size(); ++i) {
	        sum += candidates[i];
	        path.push_back(candidates[i]);
	        self(self, i, sum);	// key: 不用i+1表示可重复读取当前值
	        sum -= candidates[i];
	        path.pop_back();
	    }
	};
	self(self, 0, 0);
	return res;
}
40. 组合总和 II
  1. 题目
    • 给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
    • 输入: candidates = [2,5,2,1,2], target = 5,
    • 输出：[ [1,2,2], [5] ]
  2. 代码
    在这里插入图片描述
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
    const int len = candidates.size();
    sort(candidates.begin(), candidates.end());
    // 回溯部分
    vector<int> path;
    vector<vector<int>> res;
    vector<bool> used(len, false);
    int sum = 0;
    auto self = [&](auto &&self, int pos){
        // 结点剪枝
        if (sum == target) {
            res.emplace_back(path);
            return ;
        }

        for (int i = pos; i < len; ++i) {
            // 分叉剪枝: 性能高一些
            if (sum + candidates[i] > target) continue;
            if (i > 0 && candidates[i] == candidates[i-1] && used[i-1] == false) 
                continue;
            if (used[i] == true) continue;
            used[i] = true;
            path.emplace_back(candidates[i]);
            sum += candidates[i];
            self(self, i+1);    // i+1表示每个元素不重复使用
            sum -= candidates[i];
            path.pop_back();
            used[i] = false;
        
        }
    };
    
    self(self, 0);
    return res;
}
93. 复原 IP 地址
  1. 题目
    • 给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成
    • 输入：s = “25525511135”
    • 输出：[“255.255.11.135”,“255.255.111.35”]

在这里插入图片描述

vector<string> restoreIpAddresses(string s) {
  const int len = s.size();
  // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
  auto is_valid = [](const string& s, int start, int end) {
      cout << start <<' ' <<  end << endl;
       
      if (start > end) {
          return false;
      }
      if (s[start] == '0' && start != end) // 0开头的数字不合法
          return false;
      
      int num = 0;
      for (int i = start; i <= end; i++) {
          if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
              return false;
          }
          num = num * 10 + (s[i] - '0');
          if (num > 255) { // 如果大于255了不合法
              return false;
          }
      }
   return true;
};
131. 分割回文串
  1. 131. 分割回文串
    • 获取[startIndex,i]在s中的子串s.substr(startIndex, i - startIndex + 1)
    // 判断是否为回文字符串
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;
}
// 基本的回溯
vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.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); // 寻找i+1为起始位置的子串
        path.pop_back(); // 回溯过程，弹出本次已经填在的子串
    }
}


vector<vector<string>> partition(string s) {
    result.clear();
    path.clear();
    backtracking(s, 0);
    return result;
}
1005. K 次取反后最大化的数组和
  1. 1005. K 次取反后最大化的数组和
    • sort的使用：第三个参数为自定义的排序队则，在头文件#include
    • accumulate的使用：第三个参数为累加的初值，在头文件include
    static bool cmp(int a, int b) {
    return abs(a) > abs(b);// 绝对值的从大到小进行排序
}
int largestSumAfterKNegations(vector<int>& A, int K) {
	// 将容器内的元素按照绝对值从大到小进行排序
    sort(A.begin(), A.end(), cmp); 
    // 在K>0的情况下，将负值按照绝对值从大到小依次取反
    for (int i = 0; i < A.size(); i++) { 
        if (A[i] < 0 && K > 0) {
            A[i] *= -1;
            K--;
        }
    }
    // 如果K为奇数，将最小的正数取反
    if (K % 2 == 1) 
    	A[A.size() - 1] *= -1; 
   	// 求和
    return accumulate(A.begin(),A.end(),0);
    // 第三个参数为累加的初值，在头文件include<numeric>
}
少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。
不如点赞·收藏·关注一波

🚩点此跳转到首行↩︎

参考博客

  1. 「代码随想录」47. 全排列 II:【彻底理解排列中的去重问题】详解
  2. codetop

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

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

相关文章

测试相关-面试高频

测试相关-面试高频

测试面试相关 面试 测试的具体场景 功能测试 具体的测试工具Jmeter Postman selenium pytest 怎么看待测试的潜力与挑战 软件测试是正在快速发展&#xff0c;充满挑战的领域。尽管现在许多自动化测试软件的出现使得传统手工测试的方式被代替&#xff0c;但自动化测试工具的…
阅读更多...
使用idea中的Live Templates自定义自动生成Spring所需的XML配置文件格式

使用idea中的Live Templates自定义自动生成Spring所需的XML配置文件格式

文章目录 一、引言&问题描述二、解决方案 一、引言&问题描述 在使用Spring来管理对象时&#xff0c;我们需要创建Spring的配置文件applicationContext.xml&#xff0c;如下图位置&#xff1a; 在resources目录下选择new->File 或 使用idea自带模板new->XML Con…
阅读更多...
韩国DMF注册信息在线查询

韩国DMF注册信息在线查询

DMF&#xff08;Drug Master File&#xff09;是药品主文件的缩写&#xff0c;一般DMF中包含了与药品相关的化学、制造、控制、稳定性、质量控制等方面的详细信息&#xff0c;根据各国的要求所含内容各不相同。而韩国DMF一般可以简称为KDMF: Korea Drug Master File&#xff0c…
阅读更多...
＜avue-crud/＞，二级表头，children下字典项的dicUrl失效问题

＜avue-crud/＞，二级表头，children下字典项的dicUrl失效问题

目录 1.提出问题&#xff1a; 1.1 代码&#xff1a; 1.2 效果图&#xff1a;会发现处在children下的dicUrl失效了 2. 解决思路 3. 解决代码&#xff08;你要的都在这&#xff0c;看这里&#xff09; 1.提出问题&#xff1a; 在使用<avue-crud/>组件实现二级表头时&…
阅读更多...
漏洞复现--安恒明御安全网关 aaa_local_web_preview 任意文件上传

漏洞复现--安恒明御安全网关 aaa_local_web_preview 任意文件上传

免责声明&#xff1a; 文章中涉及的漏洞均已修复&#xff0c;敏感信息均已做打码处理&#xff0c;文章仅做经验分享用途&#xff0c;切勿当真&#xff0c;未授权的攻击属于非法行为&#xff01;文章中敏感信息均已做多层打马处理。传播、利用本文章所提供的信息而造成的任何直…
阅读更多...
OSG编程指南＜十四＞：OSG纹理渲染之普通纹理、多重纹理、Mipmap多级渐远纹理及TextureRectangle矩阵纹理

OSG编程指南＜十四＞：OSG纹理渲染之普通纹理、多重纹理、Mipmap多级渐远纹理及TextureRectangle矩阵纹理

1、纹理映射介绍 物体的外观不仅包括形状&#xff0c;不同物体表面有着不同的颜色和图案。一个简单而有效地实现这种特性的方法就是使用纹理映射。在三维图形中&#xff0c;纹理映射&#xff08;Texture Mapping&#xff09;的方法运用广泛&#xff0c;使用该技术可以大大提高物…
阅读更多...
BatchOutput PDF for Mac(PDF 批量处理软件)

BatchOutput PDF for Mac(PDF 批量处理软件)

BatchOutput PDF是一款适用于 Mac 的 PDF 批量处理软件。它可以帮助用户将多个 PDF 文件进行异步处理&#xff0c;提高工作效率。 BatchOutput PDF 可以自动化执行许多任务&#xff0c;包括 PDF 文件的打印、转换、分割、压缩、加密、重命名等&#xff0c;而且它还可以将自定义…
阅读更多...
公有云频繁宕机引发思考：超越灾难，跨云容灾的未来

公有云频繁宕机引发思考：超越灾难，跨云容灾的未来

近期&#xff0c;阿里云全球服务器和可用区的故障事件导致所有依赖其服务的应用在三个小时内无法使用&#xff0c;这一事件凸显了单一云服务依赖的风险。成千上万的企业和服务瞬间陷入混乱&#xff0c;这不仅仅是技术故障的问题&#xff0c;而是关乎信任、安全和业务连续性的危…
阅读更多...
【蓝桥杯选拔赛真题49】python英文转换 青少年组蓝桥杯python 选拔赛STEMA比赛真题解析

【蓝桥杯选拔赛真题49】python英文转换 青少年组蓝桥杯python 选拔赛STEMA比赛真题解析

目录 python英文转换 一、题目要求 1、编程实现 2、输入输出 二、算法分析
阅读更多...
私家车位共享APP-计算机毕业设计源码24384

私家车位共享APP-计算机毕业设计源码24384

目 录 摘要 1 绪论 1.1 课题的研究背景 1.2研究内容与研究目标 1.3ssm框架 1.4论文结构与章节安排 2 2 私家车位共享APP系统分析 2.1 可行性分析 2.2 系统流程分析 2.2.1 数据增加流程 2.2.2 数据修改流程 2.2.3数据删除流程 2.3 系统功能分析 2.3.1功能性分析 2…
阅读更多...
使用Java将properties转为yaml，保证顺序、实测无BUG版本

使用Java将properties转为yaml，保证顺序、实测无BUG版本

使用Java将properties转为yaml 一 前言1.1 顺序错乱的原因1.2 遗漏子节点的原因 二、优化措施三、源码 一 前言 浏览了一圈网上的版本&#xff0c;大多存在以下问题&#xff1a; 转换后顺序错乱遗漏子节点 基于此进行了优化&#xff0c;如果只是想直接转换&#xff0c;可直接…
阅读更多...
golang—kafka架构原理快速入门以及自测环境搭建（docker单节点部署）

golang—kafka架构原理快速入门以及自测环境搭建（docker单节点部署）

kafka Apache Kafka 是一个分布式的流处理平台。它具有以下特点&#xff1a; 支持消息的发布和订阅&#xff0c;类似于 RabbtMQ、ActiveMQ 等消息队列支持数据实时处理能保证消息的可靠性投递支持消息的持久化存储&#xff0c;并通过多副本分布式的存储方案来保证消息的容错高…
阅读更多...
【代码】考虑区域多能源系统集群协同优化的联合需求侧响应模型（完美复现）

【代码】考虑区域多能源系统集群协同优化的联合需求侧响应模型（完美复现）

程序名称&#xff1a;考虑区域多能源系统集群协同优化的联合需求侧响应模型 实现平台&#xff1a;matlab-yalmip-cplex/gurobi 代码简介&#xff1a;风电、光伏发电等波动电源接入比例不断提高&#xff0c;使得区域多能源系统中能量转化和协调能力减弱。基于此&#xff0c;该…
阅读更多...
orvibo旗下的VS30ZW网关分析之一

orvibo旗下的VS30ZW网关分析之一

概述 从官网的APP支持的智能中枢来看，一共就两种大类： MixPad系列和网关系列 排除MixPad带屏网关外，剩余的设备如下图： 目前在市场上这四种网关已经下市，官方已经宣布停产。所以市场上流通的也几乎绝迹。 从闲鱼市场上可以淘到几个，拿来分析一下，这里我手头有如下的两…
阅读更多...
简单字符串处理

简单字符串处理

答案&#xff1a; #include <stdio.h> #include <string.h> #define MAX 51 //该定义宏为字符串最大长度 int main() {char arr[MAX] { 0 }; gets(arr); //读取存给arrint len 0, i 0, num 0;len strlen(arr); //len代表字符串长度for (i 0; i &l…
阅读更多...
【实战教程】PHP如何轻松对接阿里云直播？

【实战教程】PHP如何轻松对接阿里云直播？

1. 配置阿里云直播的推流地址和播放地址 使用阿里云直播功能前&#xff0c;首先需要在阿里云控制台中创建直播应用&#xff0c;然后获取推流地址和播放地址。 推流地址一般格式为&#xff1a; rtmp://{Domain}/{AppName}/{StreamName}?auth_key{AuthKey}-{Timestamp}-{Rand…
阅读更多...
Docker安装Elasticsearch以及ik分词器

Docker安装Elasticsearch以及ik分词器

Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎&#xff0c;能够解决不断涌现出的各种用例。作为 Elastic Stack 的核心&#xff0c;Elasticsearch 会集中存储您的数据&#xff0c;让您飞快完成搜索&#xff0c;微调相关性&#xff0c;进行强大的分析&#xff…
阅读更多...
微服务中配置Nacos热更新

微服务中配置Nacos热更新

启动Nacos startup.cmd -m standalone 在IDE中启动服务 打开nacos管理后台并选择配置列表 创建配置(这里以日期格式为例) 因为这里配置的是userservice的服务,所以在userservice服务的pom文件中引入依赖 配置一个bootstrap.yml文件 注意这里bootstrap文件中配置过的内容,在app…
阅读更多...
一起学docker系列之十五深入了解 Docker Network：构建容器间通信的桥梁

一起学docker系列之十五深入了解 Docker Network：构建容器间通信的桥梁

目录 1 前言2 什么是 Docker Network3 Docker Network 的不同模式3.1 桥接模式&#xff08;Bridge&#xff09;3.2 Host 模式3.3 无网络模式&#xff08;None&#xff09;3.4 容器模式&#xff08;Container&#xff09; 4 Docker Network 命令及用法4.1 docker network ls4.2 …
阅读更多...
Web安全漏洞分析-XSS（中）

Web安全漏洞分析-XSS（中）

随着互联网的迅猛发展&#xff0c;Web应用的普及程度也愈发广泛。然而&#xff0c;随之而来的是各种安全威胁的不断涌现&#xff0c;其中最为常见而危险的之一就是跨站脚本攻击&#xff08;Cross-Site Scripting&#xff0c;简称XSS&#xff09;。XSS攻击一直以来都是Web安全领…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023