《慕课网玩转算法面试》笔记及习题解答8.1~8.3

LeetCode 17. Letter Combinations of a Phone Number

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

Input:Digit string "23"
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

思路：采用回溯法，当当前是string长度等于digits长度时，则找到了一个满足条件的string

class Solution {
private:
const string record[10] = {" ","" ,"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};

void findCombinations(const string& digits, const int& index, string s, vector<string>& res){
//找到了一个满足条件的s
if( index == digits.length() ){
res.push_back(s);
return;
}
char c = digits[index];
string letters = record[c - '0'];
for(int i = 0; i < letters.length(); i++){
findCombinations( digits, index + 1, s + letters[i] , res );
}
return;
}
public:
vector<string> letterCombinations(string digits) {
vector<string> res;
if(digits =="")
return res;

findCombinations(digits, 0, "", res);
return res;
}
};

LeetCode 93

有点难，暂时不会做。。

LeetCode 131

思路：使用回溯法，对于每个能构成回文的字串放入数组，后半部分递归，递归结束后进行回溯

class Solution {
private:
bool isPalindrome(string s)
{
int i = 0, j = s.length()-1;
while(i < j){
if(s[i]!=s[j])
return false;
i++;
j--;
}
return true;
}

void findPartition(const string& s, const int& start , vector<string>& p, vector<vector<string>>& res){
if(start == s.length()){
res.push_back(p);
return;
}
for(int i = start+1; i <= s.length(); i++){
//如果s[start,i)是回文，将s[start,i)放入数组中，后半部分递归
if( isPalindrome(s.substr(start,i-start)) ){
p.push_back(s.substr(start,i-start));
findPartition(s, i, p, res);
//注意递归结束后要进行回溯操作
p.pop_back();
}
}
return;
}

public:
vector<vector<string>> partition(string s) {
vector<vector<string>> res;
if(s.empty())
return res;
vector<string> p;
findPartition(s, 0, p,res);
return res;
}
};

LeetCode 46

Given a
a43a
collection of distinct numbers, return all possible permutations.

For example,

[1,2,3]

 have the following permutations:

[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

思路：回溯法寻找，设置一个bool数组来判断是否包含，注意终止条件，递归结束后需要将bool数组修改来保证回溯

class Solution {
private:
vector<bool> isUsed;

void findPermute(const vector<int>& nums, int index, vector<int>& num, vector<vector<int>>& res)
{
//找到一个满足条件的数组的终止条件
if(num.size() == nums.size())
{
res.push_back(num);
return;
}
for(int i = 0; i< nums.size(); i++){
if(!isUsed[i]){
num.push_back(nums[i]);
isUsed[i] = true;
findPermute(nums, index+1, num, res);
//注意，递归结束时是已经找到了一个包含nums[index]的数组，要重新寻找新数组，此时要将nums[i] pop并且将isUesd[i]设置成false
num.pop_back();
isUsed[i] = false;

}
}
return;

}
public:
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> res;
if(nums.empty())
return res;
isUsed = vector<bool>(nums.size(),false);
vector<int> num;
findPermute(nums, 0, num, res);
return res;
}
};