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"].求数字代表的键盘字母组合。回溯思想，每次加入一个字母后进入下一层遍历，回溯时去掉该字母。
class Solution {
public:
void myFunc(string digits,string temp,vector<string> &result,map<char,string>letter){
int cur=temp.size();
if(cur==digits.size()){
result.push_back(temp);
}
else{
for(int i=0;i<letter[digits[cur]].size();i++){
temp=temp+letter[digits[cur]][i];
myFunc(digits,temp,result,letter);
temp.pop_back();
}
}
}
vector<string> letterCombinations(string digits) {
vector<string> result;
string temp="";
if(digits.size()<1){
return result;
}
map<char,string> letter;
letter['2']="abc";
letter['3']="def";
letter['4']="ghi";
letter['5']="jkl";
letter['6']="mno";
letter['7']="pqrs";
letter['8']="tuv";
letter['9']="wxyz";
myFunc(digits,temp,result,letter);
return result;
}
};22. Generate Parentheses
Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
For example, given n = 3, a solution set is:
[ "((()))", "(()())", "(())()", "()(())", "()()()" ]生成合法括号对。优先加入左括号，当左括号加完且左括号数大于右括号数时，加入右括号，否则回溯到上一层。
class Solution {
public:
void search(int left,int right,string result,vector<string> &v){
if(!left&&!right){
v.push_back(result);
return;
}
if(left>0) search(left-1,right,result+"(",v);
if(left<right) search(left,right-1,result+")",v);
}
vector<string> generateParenthesis(int n) {
vector<string> v;
search(n,n,"",v);
return v;
}
};
37. Sudoku Solver
Write a program to solve a Sudoku puzzle by filling the empty cells.
Empty cells are indicated by the character '.'.
You may assume that there will be only one unique solution.
A sudoku puzzle...
...and its solution numbers marked in red.
求数独的解。需要两个子函数，isSudoku用来判断数独是否合法，思路与36题相同。searchSudoku通过回溯，求数独的合法解。当board中当前元素为'.'时，依次尝试填入0~9到当前位置：当每行、每列、每个九宫格都未填入该数字时，则把该数字填入，再搜索board中下一个位置的元素。当下一个位置搜索失败，即下一个位置0~9均无法填入时，则回溯到上一层，将当前board中元素重新赋为'.'，并继续尝试填入其他数字。直到board中元素遍历完时结束，此时board中填入数独的解。
class Solution {
public:
bool row[9][9];
bool col[9][9];
bool area[9][9];
bool isSudoku(vector<vector<char>>& board){
memset(row, false, sizeof(row));
memset(col, false, sizeof(col));
memset(area, false, sizeof(area));
for(int r=0;r<board.size();r++){
for(int c=0;c<board[r].size();c++){
if(!isdigit(board[r][c])) continue;
int num=board[r][c]-'0'-1;
int a=(r/3)*3+c/3;
if(row[r][num]==true || col[c][num]==true || area[a][num]==true){
return false;
}
row[r][num]=col[c][num]=area[a][num]=true;
}
}
return true;
}
bool searchSudoku(vector<vector<char>>& board,int r,int c){
if(r>=9){
return true;
}
if(c>=9){
return searchSudoku(board,r+1,0);
}
if(board[r][c]=='.'){
for(int i=0;i<9;i++){
int a=(r/3)*3+c/3;
if(row[r][i]==true || col[c][i]==true || area[a][i]==true){
continue;
}
board[r][c]=i+'1';
row[r][i]=col[c][i]=area[a][i]=true;
if(searchSudoku(board,r,c+1)==true){
return true;
}
board[r][c]='.';
row[r][i]=col[c][i]=area[a][i]=false;
}
return false;
}else{
return searchSudoku(board,r,c+1);
}
}
void solveSudoku(vector<vector<char>>& board) {
if(!isSudoku(board)){
return;
}
searchSudoku(board,0,0);
}
};
39. Combination Sum
Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
The same repeated number may be chosen from C unlimited number of times.
Note:
- All numbers (including target) will be positive integers.
- The solution set must not contain duplicate combinations.
For example, given candidate set [2, 3, 6, 7] and target 7,
A solution set is:
[ [7], [2, 2, 3] ]在集合中寻找和为目标值的子集，集合中数字可重复使用。先对原始集合排序，然后从小到达依次向空集中填入集合中的数字，解集中数字之和大于target时则回溯到上一层，每次遍历完集合中所有元素时，判断sum是否等于target：sum等于target时，把当前解集加入res中。最终返回res。
class Solution {
public:
void find(vector<int>& candidates,int index,int target,int sum,vector<vector<int>>& res,vector<int>& cur){
if(sum>target){
return;
}
if(index>=candidates.size()){
if(sum==target){
res.push_back(cur);
}
return;
}
if((index==0) || (candidates[index-1]!=candidates[index])){
cur.push_back(candidates[index]);
find(candidates,index,target,sum+candidates[index],res,cur);
cur.pop_back();
}
find(candidates,index+1,target,sum,res,cur);
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
sort(candidates.begin(),candidates.end());
vector<vector<int>> res;
vector<int> cur;
find(candidates,0,target,0,res,cur);
return res;
}
};40. Combination Sum II
Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in Cwhere the candidate numbers sums to T.
Each number in C may only be used once in the combination.
Note:
- All numbers (including target) will be positive integers.
- The solution set must not contain duplicate combinations.
For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
A solution set is:
[ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ]与上一题基本相同，唯一区别是集合内数字不可以重复使用。同样使用回溯的思想，先对集合中数字排序，然后从小到大依次往空集中填入数字，当sum等于target时，判断一下res中是否含有相同解，如果没有则把当前解集加入res中。
class Solution {
public:
void finds(vector<int>& candidates,int index,int target,int sum,vector<vector<int>>& res,vector<int> cur){
if(sum>target){
return;
}
if(sum==target){
if(find(res.begin( ), res.end( ),cur)==res.end()){
res.push_back(cur);
}
return;
}
for(int i=index;i<candidates.size();i++){
cur.push_back(candidates[i]);
finds(candidates,i+1,target,sum+candidates[i],res,cur);
cur.pop_back();
}
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
sort(candidates.begin(),candidates.end());
vector<vector<int>> res;
vector<int> cur;
finds(candidates,0,target,0,res,cur);
return res;
}
};44. Wildcard Matching
Implement wildcard pattern matching with support for '?' and '*'.
'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).
The matching should cover the entire input string (not partial).
The function prototype should be:
bool isMatch(const char *s, const char *p)
Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "*") → true
isMatch("aa", "a*") → true
isMatch("ab", "?*") → true
isMatch("aab", "c*a*b") → false
字符串匹配，？可以匹配单个字符，*可以匹配任意个字符。回溯思想，从s和p开头开始匹配：p为*时p++；p不为*时，如果p为？或者当前p和s匹配，那么p++，s++；如果p不是*或？，当前p与s也不匹配，那么把p退回到上一个p=*的位置，s退回到上一个p=*时s的位置，s++，即回溯到上一个p为*的位置，让*多匹配一个s中的字符，再向后匹配。
class Solution {
public:
bool isMatch(string s, string p) {
int n=s.size(),m=p.size();
int last_s=-1,last_p=-1;
int now_s=0,now_p=0;
while(now_s!=n){
if(p[now_p]=='*'){
now_p++;
if(now_p==m) return true;
last_s=now_s;
last_p=now_p; //record the previous '*' in p
}else if(p[now_p]=='?' || s[now_s]==p[now_p]){
now_s++;now_p++;
}else if(last_s !=-1){
now_p=last_p; //return to the previous '*'
now_s=++last_s;
}else{
return false;
}
}
while(p[now_p]=='*') now_p++;
return now_p==m;
}
};46. Permutations
Given a 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] ]不相同数字的全排列。经典回溯问题，每次交换两个数字的位置即可。
class Solution {
public:
void permuteRecursive(vector<int>& nums,int index,vector<vector<int>>& result){
if(index>=nums.size()){
result.push_back(nums);
return;
}
for(int i=index;i<nums.size();i++){
swap(nums[index],nums[i]);
permuteRecursive(nums,index+1,result);
swap(nums[index],nums[i]);
}
}
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> result;
permuteRecursive(nums,0,result);
return result;
}
};47. Permutations II
Given a collection of numbers that might contain duplicates, return all possible unique permutations.
For example,
[1,1,2] have the following unique permutations:
[ [1,1,2], [1,2,1], [2,1,1] ]包含重复数字的全排列，先对数字排序，避免出现重复解。
class Solution {
public:
void permuteRecursive(vector<int> nums,int index,vector<vector<int>>& result){
if(index==nums.size()-1){
result.push_back(nums);
return;
}
for(int i=index;i<nums.size();i++){
if(i!=index && nums[i]==nums[index]) continue;
swap(nums[index],nums[i]);
permuteRecursive(nums,index+1,result);
}
}
vector<vector<int>> permuteUnique(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(),nums.end());
permuteRecursive(nums,0,result);
return result;
}
};51. N-Queens
The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.
Given an integer n, return all distinct solutions to the n-queens puzzle.
Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.
For example,
There exist two distinct solutions to the 4-queens puzzle:
[ [".Q..", // Solution 1 "...Q", "Q...", "..Q."], ["..Q.", // Solution 2 "Q...", "...Q", ".Q.."] ]经典的n皇后问题，即在n*n棋盘上放置n个皇后，要求每行每列及对角线上只有一个皇后。递归的思路，每次填入某一行的皇后，之后填入的皇后与之前的不能冲突，若存在冲突则尝试改行下一个位置；若改行所有位置均冲突则回溯到上一行，将上一行皇后的位置也继续向后尝试。空间优化：可以只使用一维数组记录列的坐标，因为遍历过程中行数依次增加，不会产生冲突。另外需要一个isValid函数判断是否存在列冲突或对角线冲突。
class Solution {
public:
bool isValid(int attemptedColumn, int currentRow, vector<int> &solution) {
for(int i=0; i<currentRow; i++) {
if (attemptedColumn == solution[i] ||
abs(attemptedColumn - solution[i]) == abs(currentRow - i)) {
return false;
}
}
return true;
}
void solveNQueensRecursive(int n, int currentRow, vector<int>& solution, vector< vector<string> >& result) {
if (currentRow == n){
vector<string> s;
for (int row = 0; row < n; row++) {
string sRow;
for (int col = 0; col < n; col++) {
sRow = sRow + (solution[row] == col ? "Q" :"." );
}
s.push_back(sRow);
}
result.push_back(s);
return;
}
for (int col = 0; col < n; col++) {
if (isValid(col, currentRow, solution) ) {
solution[currentRow] = col;
solveNQueensRecursive(n, currentRow+1, solution, result);
}
}
}
vector< vector<string> > solveNQueens(int n) {
vector< vector<string> > result;
vector<int> solution(n);
solveNQueensRecursive(n, 0, solution, result);
return result;
}
};52. N-Queens II
Follow up for N-Queens problem.
Now, instead outputting board configurations, return the total number of distinct solutions.
class Solution {
public:
bool isValid(int attemptedColumn,int currentRow,vector<int>& solution){
for(int i=0;i<currentRow;i++){
if(attemptedColumn==solution[i] ||
abs(attemptedColumn-solution[i])==abs(currentRow-i)){
return false;
}
}
return true;
}
void solveNQueensRecursive(int n,int currentRow,vector<int>& solution,int& result){
for(int i=0;i<n;i++){
if(isValid(i,currentRow,solution)){
if(currentRow+1==n){
result++;
continue;
}
solution[currentRow]=i;
solveNQueensRecursive(n,currentRow+1,solution,result);
}
}
}
int totalNQueens(int n) {
int result=0;
vector<int> solution(n);
solveNQueensRecursive(n,0,solution,result);
return result;
}
};
426
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
