关于全排列组合问题

1、给定一个数字字符串，返回数字可能表示的所有可能的字母组合。数字与字母的对应关系和手机按键对应。

解题思路：

• 建立数字到字符的映射字典
• 将输入的数字字符串转换为对应字符串列表
• 用枚举回溯法求解
  代码实现：

    class Solution {
    public:
        vector<string> letterCombinations(string digits) {
             vector<string> result(1,"");
            map<int,string> numToStr={{2,"abc"},{3,"def"},{4,"ghi"},{5,"jkl"},{6,"mno"},{7,"pqrs"},{8,"tuv"},{9,"wxyz"}};
            for(int i=0;i<digits.size();i++){
                vector<string> tmp;
                for(int j=0;j<result.size();j++){
                    int num=digits[i]-'0';
                    for(int k=0;k<numToStr[num].size();k++)
                    {
                        tmp.push_back(result[j]+numToStr[num][k]);
                    }
                }
                result=tmp;
            }
            return result;
        }
    };

2、给定两个整数n和k，返回1 … n中k个数的所有可能组合。

例如 n = 4 且 k = 2，返回的解为：[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4]]
解题思路：采用递归回溯的方法，以上面这个例子为例：

• 先将1放入组合：[1] 那么剩下的数只能在2, 3, 4中选择，因为k = 2，所以，我们只需要在2, 3, 4中选择一个就行，也就是[1, 2], [1, 3], [1, 4]；
• 将2放入组合：[2]，因为1已经处理过，所以在3, 4中选择一个：[2, 3], [2, 4]

• 将3放入组合：[3]，因为1, 2已经处理过，所以只能选择4：[3, 4]
  代码实现：

  class Solution {
      public:
          vector<vector<int> > combine(int n, int k) {
             vector<vector<int>> res;
              if(n<=0||n<k||k<=0)
                  return res;
              vector<int> path;
              findNum(res,path,n,k,1);
              return res;
          }
  
           void findNum(vector<vector<int>>& result,vector<int>& path,int n,int k,int start){
              if(path.size()==k){
                  result.push_back(path);
               //   path.clear();
              }
              for(int i=start;i<=n;i++){
                  path.push_back(i);
                  findNum(result,path,n,k,i+1);
                  path.pop_back();
              }
           }
      };
  

3、Given a string containing only digits, restore it by returning all possible valid IP address combinations.

样例：
Given”25525511135”,
return[“255.255.11.135”, “255.255.111.35”]. (Order does not matter)
解题思路：
IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。
因此，需要判断一个数字字符串是否符合IP地址中的一组IP字段（即两个点分割的数字），符合的情况分为如下几种：（这里的IP字段指的是0~255）

• 任意单个数字（0也是符合的）；
• 两个数字，则高位不为0；

• 三个数字，则最高位为1或者2，且小于等于255，即最高位为1 或者 最高位为2且第二位小于5 或者 最高位为2且第二位等于5且最低位小于等于5。
  代码实现：

  class Solution {
  public:
      vector<string> restoreIpAddresses(string s) {
          vector<string> res;
          if(s.length()<=0)
              return res;
          for(int i = 1; i < 4 && i < s.size(); ++ i)
               for(int j = i + 1; j < i + 4 && j < s.size(); ++ j)
                   for(int k = j + 1; k < j + 4 && k < s.size(); ++ k)
                   {
                       string s1 = s.substr(0, i), s2 = s.substr(i, j - i),
                              s3 = s.substr(j, k - j), s4 = s.substr(k, s.size() - k);
                       if(isIP(s1) && isIP(s2) && isIP(s3) && isIP(s4))
                           res.push_back(s1 + "." + s2 + "." + s3 + "." + s4);
                   }
           return res;
      }
  
      bool isIP(string s)
       {
          if(s.size() == 1 || (s.size() == 2 && s[0] != '0') || (s.size() == 3 &&
              (s[0] == '1' v|| s[0] == '2' && (s[1] < '5' || s[1] == '5' && s[2] <= '5'))))
               return true;
          return false;
       }
  };
  

4、给定可能包含重复的数字的集合，返回所有可能的唯一排列

解题思路：
用swap进行交换，确保已经遍历的点在前面，未遍历的点在后面。这个方法在没有duplicate的情况下，比如上一题，完全没有问题。但是对于有重复的点， 首先要用sort排序，不然的话还是会遍历到重复的点的。每次寻找下一个点的时候还要用sort排一次序，因为每次经过排序之后，用两个swap已经无法还原了，一定要再次排序。
代码实现：

    class Solution {
public:
    vector<vector<int>>res;
    vector<vector<int> > permuteUnique(vector<int> &num) {
         res.clear();
        vector<int> temp;

        dfs(num,temp,0);
        return res;
    }
    void dfs(vector<int>& nums,vector<int> temp, int begin)
    {
        if(begin >= nums.size())
        {
            res.push_back(temp);
            return;
        }
        sort(nums.begin() + begin,nums.end());
        for(int i = begin; i < nums.size(); i++)
        {
            temp.push_back(nums[i]);
            swap(nums[i], nums[begin]);
            dfs(nums,temp,begin + 1);
            temp.pop_back();
            //swap(nums[i], nums[begin]);
            sort(nums.begin() + begin,nums.end());
            while(i + 1 < nums.size() && nums[i + 1] == nums[i])
                i++;
        }
    }
};

5、输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba

中心思想：列出第一位所有可能情况，然后后面的位递归排列

class Solution {
public:
    vector<string> Permutation(string str) {
        vector<string> res;//用来存放结果
        int len=str.size();
        if(len==0)//判断是否为空
            return res;
        Per(res,str,0);//递归遍历并排列
        sort(str.begin(),str.end());
        return res;
    }

    void Per(vector<string>& resualt,string str,int index)
    {
        int size=str.size();
        if(index==size-1)//递归结束条件：第一位和最后一位全部交换完成
        {
            resualt.push_back(str);
            return;
        }
        for(int i=index;i<size;i++)
        {//如果第一位和非第一位重复了，就不用交换
            if(i!=index&&str[i]==str[index])
                continue;
            swap(str[index],str[i]);//进行交换
            Per(resualt,str,index+1);//递归，第一位固定了，将除了第一位，后面的字符串全排序。
        }
    }
};