LeetCode典型題——遞歸與回溯

遞歸和回溯

{查找全部解。。。}

class Solution {
public:
	vector<string> letterCombinations(string digits) {
        
        vector<string> ret;        
        
		if(digits.length() == 0)
            return ret;
        
        help(digits, 0, "", ret);
            
        return ret;
	}

	void help(string digits, int index, string str, vector<string> &v)
    {
        if(index == digits.length())
        {
            v.push_back(str);
            return ;
        }
        
        char ch = digits[index];
        string s = letterMap[ch-'0'];
        for(int i=0; i<s.length(); i++)
        {
            help(digits, index+1, str+s[i], v);
        }
        
        
    }

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

全排列

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        
        if(nums.size() == 0)
            return ret;
        
        visited = vector<bool>(nums.size(), false);
        vector<int> v;
        help(nums, v);
        
        return ret;
        
    }
    
private:
    vector<vector<int>> ret;
    vector<bool> visited;
    
    void help(const vector<int>& nums, vector<int> v)
    {
        if(v.size() == nums.size())
        {
            ret.push_back(v);
            return ;
        }
        
        for(int i=0; i<nums.size(); i++)
        {
            if(!visited[i])
            {
                v.push_back(nums[i]);
                visited[i] = true;
                help(nums, v);
                visited[i] = false;
                v.pop_back();
            }
        }
    }
};

class Solution {

private:
    vector<vector<int>> res;
    vector<bool> visited;

public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {

        if(nums.size() == 0)
            return res;

        visited = vector<bool>(nums.size(), false);
        sort(nums.begin(), nums.end());
        vector<int> p;

        help(nums, p);

        return res;
    }

private:
    void help(const vector<int>& nums, vector<int> &p){

        if(p.size() == nums.size()){
            res.push_back(p);
            return;
        }

        for(int i = 0 ; i < nums.size() ; i ++)
            if(!visited[i]){
                if(i > 0 && nums[i] == nums[i-1] && !visited[i-1])             //對於重複的元素，只對第一個未被使用的進行遞歸
                    continue;
                p.push_back(nums[i]);
                visited[i] = true;

                help(nums, p);

                p.pop_back();
                visited[i] = false;
            }

    }
};

二維平面

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        
        m = board.size();
        n = board[0].size();
       
        
        visited = vector<vector<bool>>(m, vector<bool>(n, false));
        
        for(int i=0; i<m; i++)
            for(int j=0; j<n; j++)
                if(help(board, word, i, j, 0))
                    return true;
        
        return false;
        
    }
    
private:
    bool help(const vector<vector<char>> &board, const string &word, int x, int y, int index)
    {
         if( index == word.size() - 1 )
            return board[x][y] == word[index];
        
        if(board[x][y] != word[index])
            return false;
        
        //四個方向
        for(int i=0; i<4; i++)
        {
            visited[x][y] = true;
            
            int new_x = x + direction[i][0];
            int new_y = y + direction[i][1];
            
            if(new_x >= 0 && new_x < m && new_y >= 0 && new_y < n && !visited[new_x][new_y])    //位置合法 && 沒有訪問過
                if( help(board, word, new_x, new_y, index+1) )
                    return true;
            
            visited[x][y] = false;
        }
        
        return false;
    }
    
    int direction[4][2] = { {-1,0}, {0,1}, {1,0}, {0,-1} };
    
    vector<vector<bool>> visited;
                   
    int m;
    int n;
};

N皇后

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        
        vector<vector<string>> ret;
        
        col = vector<bool>(n, false);
        dia1 = vector<bool>(2*n-1, false);
        dia2 = vector<bool>(2*n-1, false);
        
        vector<int> v;
        help(n, 0, v, ret);
        
        return ret;
    }
    
private:
    
    vector<bool> col;
    vector<bool> dia1;
    vector<bool> dia2;
    
    //第 index 行， 每行皇后放置的列保存在 vector<int> &v
    void help(int n, int index, vector<int> &v, vector<vector<string>> &res)
    {
        if(n == index)
        {
            res.push_back(generate(n, v));
            return ;    
        }
        
        //i列
        for(int i=0; i<n; i++)
        {
            if(!col[i] && !dia1[index+i] && !dia2[index-i+n-1])
            {
                v.push_back(i);
                col[i] = true;
                dia1[index+i] = true;
                dia2[index-i+n-1] = true;
                
                help(n, index+1, v, res);
                
                col[i] = false;
                dia1[index+i] = false;
                dia2[index-i+n-1] = false;
                v.pop_back();
            }
        }
    }
    
    vector<string> generate(int n, vector<int> &v)
    {
        vector<string> board(n, string(n, '.'));
        
        for(int i=0; i<n; i++)
            board[i][v[i]] = 'Q';
        
        return board;
    }
};