Leetcode 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], and [3,2,1].

一. 广度优先搜索BFS

这种方法有些像广度优先搜索BFS,扩展所有可能

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        int len = nums.length;
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        ans.add(new ArrayList<Integer>());
        for(int i = 0; i < len; i++)
        {
            List<List<Integer>> new_ans = new ArrayList<List<Integer>>();
            for(int j = 0; j <= i; j++)
            {
                for(int k = 0; k < ans.size(); k++)
                {
                   List<Integer> temp = new ArrayList<Integer>(ans.get(k));
                   temp.add(j,nums[i]);
                   new_ans.add(temp);
                }
            }
            ans = new_ans;
        }
        return ans;
    }


}

 类似的做法还有手机键盘字母组合问题

 Letter Combinations of a Phone Number

https://leetcode.com/discuss/11261/my-iterative-sollution-very-simple-under-15-lines

二. 回溯backtracking 

这道题的回溯算法很典型

class Solution {
public:
    vector<vector<int> > permute(vector<int>& nums) {
        vector<vector<int> > result;
        if(nums.size() == 0)
            return result;        
        permutation(nums, 0, result);
        return result;
    }
    void permutation(vector<int>& nums, int index, vector<vector<int> >& result)
    {
        int len = nums.size();
        if(index == len)
            result.push_back(nums);
        else{
            for(int i = index; i < len; i++){
                swap(nums[i], nums[index]);
                permutation(nums, index+1, result);
                swap(nums[i], nums[index]); //palindrome
            }
        }
    }
};

 对于backtracking（or DFS)来讲，可以对比 

Palindrome Partitioning

问题

class Solution {
public:
    vector<vector<string> > partition(string s) {
        vector<vector<string> > result;
        vector<string> temp;
        dfs(s, 0, temp, result);
        return result;
    }
    void dfs(string &s, int index, vector<string> temp, vector<vector<string> > &result)
    {
        if(index == s.size())
        {
            result.push_back(temp);
            return;
        }

        for(int i = index; i < s.size(); i++)
        {
            string sub_str = s.substr(index, i - index + 1);
            if(isPalindrome(sub_str))
            {
                temp.push_back(sub_str);
                dfs(s, i+1, temp, result);
                temp.pop_back();   //back last, recover enviroment
            }
        }
    }
    bool isPalindrome (string s){
        if(s.empty())
            return false;
        int begin = 0, end = s.length() - 1;
        while(begin <= end)
        {
            if(s[begin++] != s[end--])
                return false;
        }
        return true;
    }
};