Day28——回溯法力扣打卡

最新推荐文章于 2024-09-14 18:52:56 发布
最新推荐文章于 2024-09-14 18:52:56 发布
阅读量518 收藏
点赞数
文章标签： leetcode java 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55687474/article/details/127526008
版权

一、93.复原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"]

示例 4：

  • 输入：s = "010010"
  • 输出：["0.10.0.10","0.100.1.0"]

示例 5：

  • 输入：s = "101023"
  • 输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

  • 0 <= s.length <= 3000
  • s 仅由数字组成

回溯三部曲： 

1、递归参数

vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {

2、递归终止条件

if (pointNum == 3) { // 逗点数量为3时，分隔结束
    // 判断第四段子字符串是否合法，如果合法就放进result中
    if (isValid(s, startIndex, s.size() - 1)) {
        result.push_back(s);
    }
    return;
}

3、单层搜索的逻辑

for (int i = startIndex; i < s.size(); i++) {
    if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
        s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
        pointNum++;
        backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
        pointNum--;                         // 回溯
        s.erase(s.begin() + i + 1);         // 回溯删掉逗点
    } else break; // 不合法，直接结束本层循环
}

判断子串是否合法：

// 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
bool isValid(const string& s, int start, int end) {
    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;
}

整体C++代码如下：

class Solution {
private:
    vector<string> result;// 记录结果
    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) { // 逗点数量为3时，分隔结束
            // 判断第四段子字符串是否合法，如果合法就放进result中
            if (isValid(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                pointNum++;
                backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
                pointNum--;                         // 回溯
                s.erase(s.begin() + i + 1);         // 回溯删掉逗点
            } else break; // 不合法，直接结束本层循环
        }
    }
    // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
    bool isValid(const string& s, int start, int end) {
        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;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;
    }
};

二、78.子集

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

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

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

以示例中nums = [1,2,3]为例把求子集抽象为树型结构，如下：

从图中红线部分，可以看出遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合。

回溯三部曲： 

1、递归函数参数

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {

2、递归终止条件

if (startIndex >= nums.size()) {
    return;
}

3、单层搜索逻辑

for (int i = startIndex; i < nums.size(); i++) {
    path.push_back(nums[i]);    // 子集收集元素
    backtracking(nums, i + 1);  // 注意从i+1开始，元素不重复取
    path.pop_back();            // 回溯
}

整体C++代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex >= nums.size()) { // 终止条件可以不加
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

三、90.子集II

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

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

示例:

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

用示例中的[1, 2, 2] 来举例，如图所示： （注意去重需要先对集合排序）

整体C++代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        result.push_back(path);
        for (int i = startIndex; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 而我们要对同一树层使用过的元素进行跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0, used);
        return result;
    }
};

 使用set去重的版本：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path);
        unordered_set<int> uset;
        for (int i = startIndex; i < nums.size(); i++) {
            if (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>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0);
        return result;
    }
};

Grace碾香入尘
关注
数据分析day01——系统认识数据分析（笔记）
10-03
看戴师兄的视频后自己做的笔记，做个记录
python日记Day18——Pandas之Excel绘图
12-22
python日记——Pandas之Excel绘图 利用pandas和pyplot进行数据可视化，绘图过程中使用到的excel文件如下：excel文件，提取码：falj 柱图的绘制 1、柱状图： import pandas as pd import matplotlib.pyplot as plt ...
蓝桥杯打卡day3——排序算法
weixin_51458838的博客
01-17 3193
冒泡排序 n = int(input("请输入数组的长度:")) a = [] for i in range(n): a.append(int(input("请输入数组元素:"))) i = 0 def bubblesort (a,n) : if (n<=1): return for i in range(n): j = 0 while (j+1<n-i): if (a[j]>a[j+1]
八股文打卡day7——计算机网络（7）
Elon15的博客
12-22 695
八股文打卡day7——计算机网络（7）
八股文打卡day14——计算机网络（14）
Elon15的博客
12-29 906
八股文打卡day14——计算机网络（14）
八股文打卡day11——计算机网络（11）
Elon15的博客
12-26 735
八股文打卡day11——计算机网络（11）
八股文打卡day5——计算机网络（5）
Elon15的博客
12-20 498
八股文打卡day5——计算机网络（5）
八股文打卡day1——计算机网络（1）
Elon15的博客
12-16 905
八股文打卡——计算机网络（1）
力扣刷题day004——最长回文子串
2301_79843391的博客
05-15 1563
给你一个字符串s，找到s中最长的 回文子串。如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。
【考研词汇训练营】Day 2 —— 词根词缀记忆法
Sky*殇的博客
07-08 1386
message 信息：发送给别人的东西 词根：mess 的释义：（其它词根 mit mis 与其释义相同） 同 send 的意义相同，发送，送 所以， mission 有使命的意思，作动词有派遣的意思 故 commission , commitment admit 有允许的意思 submit 即从下面送到上面，即有提交的意思，因为是从下至上，所以有顺从，屈服的含义......
牛客国庆集训派对Day1 —— 题解
Scar_Halo
10-01 853
Day1——自制操作系统
AnitaSun的博客
07-06 2829
虚拟机加载helloos.img 下载30天自制操作系统光盘 将"OS\projects\01_day\helloos1"文件夹复制到"OS\tolset"文件夹下 进入"OS\tolset\helloos1"文件夹，双击"!cons_nt.bat"，输入"asm"，回车; 然后输入"run"，回车; asm.bat 文件的含义 首先需要完成helloos.nas文件（汇编文件） 点击!cons_nt.bat后输入asm，就会在文件夹中看到helloos.img文件 在helloos.nas文件
大数据day11——HDFS 的 API 操作
04-20
笔记自作不易，含有博客原图。
英语六级备战打卡——day2
12-14
今日打卡： 今天一共花了两小时五十七分钟来复习英语。 1.背了《星火六级高频词》15个单词： 2.将做真题时整理出来的单词收集到生词本里，等后面都记住了就可以将它们移除了。 前天那篇阅读收进生词本的有74个，...
python日记Day10——python计算生态概览（你需要掌握的库）
01-20
python日记——python计算生态概览（你需要掌握的库） python的第三方库有十几万之多，涉及的方向之广，以下按照不同的方向介绍了一些当前的主流库。 一、从数据处理到人工智能 python库之数据分析 1、Numpy：表达N...
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 587
【代码】【JavaScript】LeetCode：707设计链表。
leetcode-617. 合并二叉树
曼巴的博客
09-11 243
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；1）如果没有root1，return root2。2）如果没有root2，return root1。null 的节点将直接作为新二叉树的节点。合并过程必须从两个树的根节点开始。3）根结点处理：两节点值加和。4）遍历两棵树的左节点。5）遍历两棵树的右节点。返回合并后的二叉树。
leetcode-647. 回文子串
曼巴的博客
09-12 411
3）遍历顺序：一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。6个回文子串: "a", "a", "a", "aa", "aa", "aaa"当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况。三个回文子串: "a", "b", "c"是字符串中的由连续字符组成的一个序列。是正着读和倒过来读一样的字符串。
408算法题leetcode--第一天
weixin_58073817的博客
09-11 408
【代码】408算法题leetcode--第一天。
软件工程基本路径测试法实验——NextDay问题
“软件工程实验四”是一个关于白盒测试的实验，主要针对NextDay问题，即给定一个日期（年，月，日），计算它的下一天。实验要求日期范围为1000年至3000年，1月至12月，1日至31日。实验内容包括使用基本路径测试法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值