【Leetcode刷题】【50/17/77/90】求x的n次方,电话号码的字母组合，组合

50求x的n次方

题目描述

思路

分治法：
1.写出递归终止条件
2.当前层的处理
3.下探到下一层，
4.合并，

class Solution {
    public double myPow(double x, int n) {
        
         long N=n;
        if(N<0){//n小于0则变换变为正数
            x=1/x;
            N=-N;
        }
        return pow(x,N);
    }
    public double pow(double x, long n){
        if(n==0){
            return 1.0;//n为0返回1
        }
        double half=pow(x,n/2);//回溯法可以将它看成是两部分，比如求2的10次方，可以求2的5次方，再合并
        return n%2==1?half*half*x:half*half;//合并时如果n为奇数，则最后还要乘上一个x,偶数就两个子部分相乘
    }
}

17电话号码的字母组合

题目描述

思路

1.先用一个hashmap存储数字对应的字母，方便查找；
2.回溯：
定义个函数，参数包含输出的字符串子集，输入的字符串，层数，结果集，map;
回溯终止条件，i与输入字符串长度相等,添加子集到结果集，并返回上一层
处理当前层，从输入字符串的数字通过hashmap查找转换成字符串，
并遍历字符串每一个字符，回溯到下一层，进行组合。

class Solution {
    public List<String> letterCombinations(String digits) {
        if(digits==null||digits.length()==0){//输入字符串为空，返回空的数组链表
            return new ArrayList();
        }
        Map<Character,String> map=new HashMap<Character,String>();
        map.put('2',"abc");
        map.put('3',"def");
        map.put('4',"ghi");
        map.put('5',"jkl");
        map.put('6',"mno");
        map.put('7',"pqrs");
        map.put('8',"tuv");
        map.put('9',"wxyz");
        List<String> list=new LinkedList<String>();
        search("",digits,0,list,map);
        return list;
    }
    public void search(String s,String digits,int i,List<String> res,Map<Character,String> map){

        //递归终止条件
        if(i==digits.length()){
            res.add(s);//加入结果集
            return;//返回上一层
        }
        String letter=map.get(digits.charAt(i));//如将数字2转换成“abc”
        for(int j=0;j<letter.length();j++){//取转换好的字符串每一个字母
            search(s+letter.charAt(j),digits,i+1,res,map);//去到下一层，递归组合
        }
    }
}

77组合

题目描述

组合问题：
与上述的电话号码问题相似，也是套用回溯的模板；关键是要用个start排除已经选择过的数字。
推荐：组合

result = []
 backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

class Solution {
    List<List<Integer>> list =new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
          LinkedList<Integer> track=new LinkedList<>();
          if(k<=0||n<=0){
              return list;
          }
          backtrack(n,k,1,track);
          return list;
    }
    public void backtrack(int n,int k,int start,LinkedList<Integer> track){
        if(track.size()==k){
            list.add(new LinkedList(track));
            return;//返回上一层
        }
        for(int i=start;i<=n;i++){
           
            track.add(i);
            backtrack(n,k,i+1,track);//下探到下一层，进行组合
            track.removeLast();
        }
    }
}

78子集I

class Solution {


    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backtrack(0, nums, res, new ArrayList<Integer>());
        return res;

    }

    private void backtrack(int i, int[] nums, List<List<Integer>> res, ArrayList<Integer> tmp) {
        res.add(new ArrayList<>(tmp));
        for (int j = i; j < nums.length; j++) {
            tmp.add(nums[j]);
            backtrack(j + 1, nums, res, tmp);
            tmp.remove(tmp.size() - 1);
        }
    }
}


法二：
import java.util.Collections;

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
        backtracks(nums, 0, new LinkedList<>(), result);
        return result;
    }

    //递归遍历数组，每到一个元素就有两种情况：1.选该元素 2.不选该元素
    public void backtracks(int[] nums, int current, LinkedList<Integer> track, List<List<Integer>> result) {
        //已经遍历完所有元素
        if (current == nums.length) {
            result.add(new LinkedList<>(track));
            return;
        }

        //不选当前元素
        backtracks(nums, current + 1, track, result);
        //选当前元素
        track.add(nums[current]);
        backtracks(nums, current + 1, track, result);
        //撤销选取当前元素（回溯）
        track.removeLast();
    }
}

90子集II

重复元素的解决方式就是，在选择某一位元素时，已经选过的就跳过。要能达到这个要求，需要使得数组有序，这样在选择某个元素i的时候与前面一个元素比较，相等nums[i] == nums[i - 1]则说明已经在上一次循环中选择过了，所以跳过。当然如果i == start，这是第一个数，不需要跳过

class Solution {
    List<List<Integer>> res=new ArrayList();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        //先排序
        Arrays.sort(nums);
        backtrack(nums,0,new ArrayList<Integer>());
        return res;
    }

    private void backtrack(int[] nums,int start,List<Integer> temp){

        //求子集，几个都行，别重复就可以
        res.add(new ArrayList(temp));

        for(int i=start;i<nums.length;i++){
            //排序了，跳过重复的
            if(i>start && nums[i]==nums[i-1]){
                continue;
            }
            temp.add(nums[i]);//选择
            backtrack(nums,i+1,temp);//下探到下一层
            temp.remove(temp.size()-1);//撤销选择
        }
    }

    

}