DAY8-力扣刷题

1.全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

通过对之前习题的了解，一看到该题就想到了用回溯法

46. 全排列 - 力扣（LeetCode）

方法一：回溯法 

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();

        List<Integer> output = new ArrayList<Integer>();
        for (int num : nums) {
            output.add(num);
        }

        int n = nums.length;
        backtrack(n, output, res, 0);
        return res;
    }

    public void backtrack(int n, List<Integer> output, List<List<Integer>> res, int first) {
        // 所有数都填完了
        if (first == n) {
            res.add(new ArrayList<Integer>(output));
        }
        for (int i = first; i < n; i++) {
            // 动态维护数组
            Collections.swap(output, first, i);
            // 继续递归填下一个数
            backtrack(n, output, res, first + 1);
            // 撤销操作
            Collections.swap(output, first, i);
        }
    }
}

2.全排列2

47. 全排列 II - 力扣（LeetCode）

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

与上一个题目主要的不同是可包含重复数字

方法一：搜索回溯 

class Solution {
    boolean[] vis;

    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        List<Integer> perm = new ArrayList<Integer>();
        vis = new boolean[nums.length];
        Arrays.sort(nums);
        backtrack(nums, ans, 0, perm);
        return ans;
    }

    public void backtrack(int[] nums, List<List<Integer>> ans, int idx, List<Integer> perm) {
        if (idx == nums.length) {
            ans.add(new ArrayList<Integer>(perm));
            return;
        }
        for (int i = 0; i < nums.length; ++i) {
            if (vis[i] || (i > 0 && nums[i] == nums[i - 1] && !vis[i - 1])) {
                continue;
            }
            perm.add(nums[i]);
            vis[i] = true;
            backtrack(nums, ans, idx + 1, perm);
            vis[i] = false;
            perm.remove(idx);
        }
    }
}

3.旋转图像

48. 旋转图像 - 力扣（LeetCode）

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

方法一：使用辅助数组

class Solution {
    public void rotate(int[][] matrix) {
        //manner1：使用辅助数组
        int n=matrix.length;
        int[][] newMatrix=new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                newMatrix[j][n-i-1]=matrix[i][j];
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                matrix[i][j]=newMatrix[i][j];
            }
        }
    }
}

 方法二：用翻转代替旋转

4.字母异位词分组

49. 字母异位词分组 - 力扣（LeetCode）

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

字母异位词判断：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

方法一：排序

由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。

Java HashMap getOrDefault() 方法

getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值

注：hashmap 是 HashMap 类的一个对象。

参数说明：

• key - 键
• defaultValue - 当指定的key并不存在映射关系中，则返回的该默认值

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String,List<String>> map=new HashMap<>();
        for(String str:strs){
            char[] array=str.toCharArray();
            Arrays.sort(array);//进行排序之后与第一个进行比较即可
            String key=new String(array);
            List<String> list=map.getOrDefault(key,new ArrayList<String>());
            list.add(str);
            map.put(key,list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

 5.pow(x,n)

 方法一：快速幂 + 递归

分治算法？？？

class Solution {
    public double myPow(double x, int n) {
        long N=n;
        return N>=0 ? quickMul(x,N) : 1.0/quickMul(x,-N);
    }
    public double quickMul(double x,long N){
        if(N==0){
            return 1.0;
        }
        double y=quickMul(x,N/2);
        return N%2 ==0 ? y*y:y*y*x;
    }
}