目录
讀題
93.复原IP地址
自己看到题目的第一想法
- startIndex 是切割點
- startIndex, i 之間是切割點
- path大小為一 path[0] 可以是0,path大小大於1 path[0] ≠ 0
- ip 長度 需介於 0~255之間
- 建立函數判斷子字符串是否合法
- 最多切割四次
看完代码随想录之后的想法
看完之後,腦袋對於這道題目的想法清晰很多,自己的做法比較偏向是加一個path,而卡哥則是在原字串上進行操作,但兩種方法都實現出來了,一開始主要錯誤點在終止條件的錯誤設置,判斷Valid IP 的函數處理錯誤,以及回溯操作的錯誤,這幾個錯誤點導致我的程式無法正常值行,但整體的想法是有,但實際執行上在思考上自己有很多部分需要去釐清。
78.子集
自己看到题目的第一想法
在組合以及分割的時候都是有符合某個條件才收集結果,但在這一題當中可以想像就是每個節點收集結果,並且這個是一個集合,彼此不能相互干擾,需要使用startIndex 來進行控制
90.子集II
自己看到题目的第一想法
這題的第一個想法是其實就是跟組合總和II 一樣,需要進行去重,如果用卡哥的做法used 或者是跳過重複元素都可以蠻清楚的去解決這個問題
93.复原IP地址 - 實作
思路
錯誤思路
- 建立一個results 以及 path 儲存結果
- 回溯函數
- 傳入值 s, startIndex
- 終止條件
- startIndex大於s.size
- 如果startIndex大於s.size 代表已經找到一組切割方案,因為startIndex可以想像成切割線,如果切割線大於等於s的大小,代表已經沒有要切割的部分了
- 並且因為在單遞迴都有判斷是否為有效IP,所以如果到達終止條件的path裡的子字串都是有效IP
- 單遞迴
- i = startIndex; i < s.size() + 3 ; i++ 每個子字符串最多三個數
- 獲取startIndex 到 i 之間的區間→ 代表著s中的子串
- 判斷startIndex 到 i之間是否為有效IP
- 如果是,則將這個子串存入path
- 不是則跳過這次迴圈
- 判斷有效IP函數
- path大小為一 path[0] 可以是0,path大小大於1 path[0] ≠ 0
- ip 長度 需介於 0~255之間
- 主函式
- 傳入s以及0
- return results.
錯誤點:
- 終止條件設置錯誤,導致遞迴並未在深度為四的時候停止,而是繼續執行,新增pointSum來記錄目前的深度(已分割幾次),並對最後的字串進行判斷與處理
- for迴圈的終止條件設錯,有可能會讓startIndex超出i的範圍
- 回溯操作錯誤,導致path字串沒有正常回溯,改為紀錄原本的size,對path字串進行回溯操作
- 判斷Valid IP 函數中
- 未Filter s.size > 3 && < 1 的狀況
- 計算數值的部分,邊界條件設錯,應該是i ≥ 0 而不是 i > 0 這樣會少計算一次,導致錯誤結果
正確思路
- 建立一個results 以及 path 儲存結果
- 回溯函數
- 傳入值 s, startIndex, pointSum
- 終止條件
- pointSum == 3
- 如果pointSum == 3代表已經切割到第三次,代表已經沒有要切割的部分了
- 判斷最後的子字串是否Valid,如果有效則將結果放入results當中
- 單遞迴
- i = startIndex; i < s.size() ; i++
- 獲取startIndex 到 i 之間的區間→ 代表著s中的子串
- 紀錄目前的path大小 → 供字串回溯操作使用
- 判斷startIndex 到 i之間是否為有效IP
- 如果是,則將這個子串存入path,並加入’.’
- 不是則跳過這次迴圈
- 遞迴操作 backtracking(s, i + 1, pointSum + 1)
- 回溯操作 path.resize(oldSize)
- 判斷有效IP函數
- path大小為一 path[0] 可以是0,path大小大於1 path[0] ≠ 0
- path長度需介於 1 ~ 3 之
- ip 數值 需介於 0~255之間
- 主函式
- 傳入s, 0, 0
- return results.
不使用path的思路
- 建立一個results 儲存結果
- 回溯函數
- 傳入值 s, startIndex, pointSum
- 終止條件
- pointSum == 3
- 如果pointSum == 3代表已經切割到第三次,代表已經沒有要切割的部分了
- 判斷最後的子字串是否Valid,如果有效則將結果放入results當中
- 單遞迴
- i = startIndex; i < s.size() ; i++
- 判斷startIndex 到 i之間是否為有效IP
- 如果是
- 在切割點加入一個逗號
- 遞迴操作
- 回溯刪除逗號
- 不是則結束本層循環,因為假設當前的切割是 01.0.0.01 就算第一個切割點在往後仍然都不是合法的IP 數值。 → 剪枝操作
- 如果是
- 遞迴操作 backtracking(s, i + 1, pointSum + 1)
- 回溯操作 path.resize(oldSize)
- 判斷有效IP函數
- path大小為一 path[0] 可以是0,path大小大於1 path[0] ≠ 0
- path長度需介於 1 ~ 3 之
- ip 數值 需介於 0~255之間
- 非數字字符不合法
- 主函式
- 傳入s, 0, 0
- return results.
Code
錯誤思路
class Solution {
public:
vector<string> results;
string path;
void backtracking(const string& s, int startIndex) {
if(startIndex >= s.size()) {
results.push_back(path);
return;
}
for(int i = startIndex; i < startIndex + 3; i++) {
string str = s.substr(startIndex, i - startIndex + 1);
if(isValidIP(str)) {
path += str;
path += '.';
} else {
continue;
}
backtracking(s, i + 1);
path.pop_back();
}
}
bool isValidIP(const string& s) {
int count = 1;
int sum = 0;
if(s.size() != 1 && (s[0] - '0') == 0) return false;
for (int i = s.size() - 1; i > 0; i--) {
sum += (s[i] - '0') * count;
count *= 10;
}
if(sum > 255 || sum < 0) return false;
return true;
}
vector<string> restoreIpAddresses(string s) {
backtracking(s, 0);
return results;
}
};
正確思路
class Solution {
public:
vector<string> results;
string path;
void backtracking(const string& s, int startIndex, int pointSum) {
if(pointSum == 3) {
string str = s.substr(startIndex, s.size());
if(isValidIP(str)) {
results.push_back(path + str);
}
return;
}
for(int i = startIndex; i < s.size(); i++) {
string str = s.substr(startIndex, i - startIndex + 1);
int oldSize = path.size();
if(isValidIP(str)) {
path += str;
path += '.';
} else {
continue;
}
backtracking(s, i + 1, pointSum + 1);
path.resize(oldSize);
}
}
bool isValidIP(const string& s) {
int count = 1;
int sum = 0;
if(s.size() != 1 && (s[0] - '0') == 0 ) return false;
if(s.size() > 3 || s.size() < 1) return false;
for (int i = s.size() - 1; i >= 0; i--) {
sum += (s[i] - '0') * count;
count *= 10;
}
for (int i = 0; i < s.size(); i++) {
sum = (s[i] - '0') + sum * 10;
}
if(sum > 255) return false;
return true;
}
vector<string> restoreIpAddresses(string s) {
backtracking(s, 0, 0);
return results;
}
};
不使用path的思路(代碼來源 代碼隨想錄)
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的后面插入一个逗点
backtracking(s, i + 2, pointNum + 1); // 插入逗点之后下一个子串的起始位置为i+2
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.子集 - 實作
思路
- 建立一個path 以及 results 收集結果
- 回溯函數 需傳入 nums 以及 startIndex
- 終止條件 if startIndex >= nums.size()
- 單遞迴
- I = startIndex I < nums.size() I ++
- path.push_back(nums[i])
- results.push_back(path)
- backtracking (nums, i + 1)
- path.pop_back()
- return
Code
class Solution {
public:
vector<vector<int>> results;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
if(startIndex >= nums.size()) return;
for(int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
results.push_back(path);
backtracking(nums, i + 1);
path.pop_back();
}
return;
}
vector<vector<int>> subsets(vector<int>& nums) {
results.push_back(path);
backtracking(nums, 0);
return results;
}
};
90.子集II - 實作
思路
Used 錯誤思路
- 建立一個path, results 數組儲存結果
- 回溯函數
- 傳入值 nums, startIndex, used
- 終止條件
- if startIndex ≥ nums.size()
- 單遞迴
- I = startIndex i < nums.size I ++
- if( i > 0 && nums[i] == nums[i-1] && used[i - 1] == false)
- continue;
- else
- path.push_back(nums[i])
- results.push_back(path)
- used[i] == true
- backtracking(nums, i + 1, used)
- used[i] == false
- path.pop_back()
- return
- 主函式
- created used
- backtracking
- Return results
錯誤點: 忘記排序
Used 正確思路
- 建立一個path, results 數組儲存結果
- 回溯函數
- 傳入值 nums, startIndex, used
- 終止條件
- if startIndex ≥ nums.size()
- 單遞迴
- I = startIndex i < nums.size I ++
- if( i > 0 && nums[i] == nums[i-1] && used[i - 1] == false)
- continue;
- else
- path.push_back(nums[i])
- results.push_back(path)
- used[i] == true
- backtracking(nums, i + 1, used)
- used[i] == false
- path.pop_back()
- return
- 主函式
- created used
- sort nums;
- backtracking
- Return results
使用i 跳過相同元素 思路
- 建立一個path, results 數組儲存結果
- 回溯函數
- 傳入值 nums, startIndex, used
- 終止條件
- if startIndex ≥ nums.size()
- 單遞迴
- I = startIndex i < nums.size I ++
- path.push_back(nums[i])
- results.push_back(path)
- backtracking(nums, i + 1, used)
- path.pop_back()
- while ( i + 1 < nums.size() && nums[i] == nums[i+1] ) i ++
- return
- 主函式
- sort nums;
- backtracking
- Return results
Code
Used 錯誤思路
class Solution {
public:
vector<vector<int>> results;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
if(startIndex >= nums.size()) return;
for(int i = startIndex; i < nums.size(); i++) {
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
else {
path.push_back(nums[i]);
results.push_back(path);
}
used[i] = true;
backtracking(nums, i + 1, used);
used[i] = false;
path.pop_back();
}
return;
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
vector<bool> used(nums.size(), false);
results.push_back(path);
backtracking(nums, 0, used);
return results;
}
};
Used 正確思路
class Solution {
public:
vector<vector<int>> results;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
if(startIndex >= nums.size()) return;
for(int i = startIndex; i < nums.size(); i++) {
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
else {
path.push_back(nums[i]);
results.push_back(path);
}
used[i] = true;
backtracking(nums, i + 1, used);
used[i] = false;
path.pop_back();
}
return;
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
vector<bool> used(nums.size(), false);
sort(nums.begin(), nums.end());
results.push_back(path);
backtracking(nums, 0, used);
return results;
}
};
使用i 跳過相同元素 思路
class Solution {
public:
vector<vector<int>> results;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
if(startIndex >= nums.size()) return;
for(int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
results.push_back(path);
backtracking(nums, i + 1);
path.pop_back();
while(i + 1 < nums.size() && nums[i] == nums[i + 1]) i++;
}
return;
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(), nums.end());
results.push_back(path);
backtracking(nums, 0);
return results;
}
};
總結
自己实现过程中遇到哪些困难
今天主要遇到的問題仍然是切割,在處理IP 的過程中,實作上沒有考慮清楚條件,導致各種問題產生。
但後續也通過代碼隨想錄的文字版以及卡哥的講解,慢慢釐清自己的錯誤點,並加已修正後就將問題解決了。
今日收获,记录一下自己的学习时长
今天大概學了2.5 hr , IP 大概佔了2hr ,另外兩題很直覺地寫出來了,但這兩個小時也讓我對切割的問題有比較深的理解,也有將我的錯誤點給列點出來,將問題點加以修正後,程式就沒有問題了
相關資料
93.复原IP地址
题目链接/文章讲解:https://programmercarl.com/0093.复原IP地址.html
视频讲解:回溯算法如何分割字符串并判断是合法IP?| LeetCode:93.复原IP地址_哔哩哔哩_bilibili
78.子集
题目链接/文章讲解:https://programmercarl.com/0078.子集.html
视频讲解:回溯算法解决子集问题,树上节点都是目标集和! | LeetCode:78.子集_哔哩哔哩_bilibili