leetcode刷题 557~

题目557

反转字符串中的单词III

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

思路实现

class Solution {
    public String reverseWords(String s) {
        String[] buff = s.split(" ");
        StringBuffer result = new StringBuffer();
        for(String string: buff){
            String reverse = new StringBuffer(string).reverse().toString();
            result.append(reverse+" ");
        }
        return result.toString().substring(0, s.length());
    }
}

题目558

四叉树交集

二进制矩阵中的所有元素不是 0 就是 1 。

给你两个四叉树，quadTree1 和 quadTree2。其中 quadTree1 表示一个 n * n 二进制矩阵，而 quadTree2 表示另一个 n * n 二进制矩阵。

请你返回一个表示 n * n 二进制矩阵的四叉树，它是 quadTree1 和 quadTree2 所表示的两个二进制矩阵进行 按位逻辑或运算 的结果。

注意，当 isLeaf 为 False 时，你可以把 True 或者 False 赋值给节点，两种值都会被判题机制 接受 。

四叉树数据结构中，每个内部节点只有四个子节点。此外，每个节点都有两个属性：

val：储存叶子结点所代表的区域的值。1 对应 True，0 对应 False；
isLeaf: 当这个节点是一个叶子结点时为 True，如果它有 4 个子节点则为 False 。

思路

递归

实现

class Solution {
    public Node intersect(Node quadTree1, Node quadTree2) {
        if(quadTree1.isLeaf){
            if(quadTree1.val == true){
                return quadTree1;
            }
            else{
                return quadTree2;
            }
        }else if(quadTree2.isLeaf){
            if(quadTree2.val == true){
                return quadTree2;
            }else{
                return quadTree1;
            }
        }
        Node topLeft = intersect(quadTree1.topLeft, quadTree2.topLeft);
        Node topRight = intersect(quadTree1.topRight, quadTree2.topRight);
        Node bottomLeft = intersect(quadTree1.bottomLeft, quadTree2.bottomLeft);
        Node bottomRight = intersect(quadTree1.bottomRight, quadTree2.bottomRight);
        if(topLeft.isLeaf && topRight.isLeaf && bottomLeft.isLeaf && bottomRight.isLeaf &&topLeft.val && topRight.val && bottomLeft.val && bottomRight.val){
            return new Node(true, true, null, null, null, null);
        }
        return new Node(false, false,topLeft, topRight, bottomLeft, bottomRight);
    }
}

题目559

N叉树的最大深度

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

思路实现

class Solution {
    private int maxLevel = 0;
    public int maxDepth(Node root) {
        if(root == null){
            return maxLevel;
        }
        dfs(root, 0);
        return maxLevel;
    }

    private void dfs(Node node, int level){
        int curLevel = level +1;
        if(node.children.isEmpty()){
            maxLevel = Math.max(maxLevel, curLevel);
        }else{
            for(Node next: node.children){
                dfs(next, curLevel);
            }
        }
    }
}

题目560

和为k的子数组

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。

思路

前缀树：

维护一个表，这个表的key是从0到index的和，value是key出现的次数。

实现

class Solution {
    public int subarraySum(int[] nums, int k) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int sum = 0;
        int res = 0;
        map.put(0,1);
        for (int index = 0; index < nums.length; index++ ){
            sum += nums[index];
            int temp = sum - k;
            if(map.containsKey(temp)){
                res += map.get(temp);
            }
            map.put(sum, map.getOrDefault(sum, 0)+1);
        }
        return res;
    }
}

题目561

数组拆分I

给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

返回该 最大总和 。

思路

排序

实现

class Solution {
    public int arrayPairSum(int[] nums) {
        Arrays.sort(nums);
        int res=0;
        for(int index=0; index < nums.length; index+=2){
            res += nums[index];
        }
        return res;
    }
}

题目563

二叉树的坡度

给定一个二叉树，计算 整个树 的坡度 。

一个树的 节点的坡度 定义即为，该节点左子树的节点之和和右子树节点之和的 差的绝对值 。如果没有左子树的话，左子树的节点之和为 0 ；没有右子树的话也是一样。空结点的坡度是 0 。

整个树 的坡度就是其所有节点的坡度之和。

思路实现

class Solution {
    private int res = 0;
    public int findTilt(TreeNode root) {
        int num = dfs(root);
        return res;
    }

    private int dfs(TreeNode node){
        if(node == null){
            return 0;
        }
        int left = dfs(node.left);
        int right = dfs(node.right);
        res += Math.abs(left-right);
        return node.val+left+right;
    }
}

题目565

数组嵌套

索引从0开始长度为N的数组A，包含0到N - 1的所有整数。找到最大的集合S并返回其大小，其中 S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }且遵守以下的规则。

假设选择索引为i的元素A[i]为S的第一个元素，S的下一个元素应该是A[A[i]]，之后是A[A[A[i]]]... 以此类推，不断添加直到S出现重复的元素。

思路

深度优先遍历

实现

class Solution {
    private int[] nums;
    boolean[] visited;
    public int arrayNesting(int[] nums) {
        this.nums = nums;
        visited = new boolean[nums.length];
        int res = 0;
        for(int i=0; i<nums.length; i++){
            if(!visited[i]){
                res = Math.max(dfs(i), res);
            }
        }
        return res;
    }

    public int dfs(int begin){
        visited[begin] = true;
        int nextIndex = nums[begin];
        int num =0;
        if(!visited[nextIndex]){
            num = dfs(nextIndex);
        }
        return 1+num;
    }
}

题目566

重塑矩阵

在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。

给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。

如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

思路实现

class Solution {
    public int[][] matrixReshape(int[][] nums, int r, int c) {
        int m = nums.length;
        int n = nums[0].length;
        int count = m*n;
        if(r*c != count){
            return nums;
        }
        int[][] res = new int[r][c];
        for(int i=0; i<count; i++){
            res[i/c][i%c] = nums[i/n][i%n];
        }
        return res;
    }
}

题目567

字符串的排列

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。

换句话说，第一个字符串的排列之一是第二个字符串的子串。

示例1:

输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba").

思路

用字典和滑动窗口

实现

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        if(s1.length() > s2.length()){
            return false;
        }
        char[] chars1 = s1.toCharArray();
        char[] chars2 = s2.toCharArray();
        int windows = s1.length();
        int[] s1map = new int[26];
        int[] s2map = new int[26];
        for (int i = 0; i < windows; i++) {
            s1map[chars1[i] - 'a']++;
            s2map[chars2[i] - 'a']++;
        }
        int res = 0;
        for(int i=0; i<26; i++){
            if(s1map[i] == s2map[i]){
                res += 1 ;
            }
        }
        for(int i = windows ; i < s2.length(); i++){
            if(res==26){
                return true;
            }
            int r = chars2[i] - 'a', l = chars2[i-windows]-'a';
            s2map[r] += 1;
            if (s2map[r] == s1map[r])
                res += 1;
            else if(s2map[r] == s1map[r]+1)
                res -= 1;
            s2map[l] -= 1;
            if (s2map[l] == s1map[l])
                res += 1;
            else if(s2map[l] == s1map[l]-1)
                res -= 1;
        }
        return res == 26;
    }
}

题目572

另一个树的子树

给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。

思路

深度优先遍历

准备答案还使用了KMP和哈希表

实现

class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        if(s == null){
            return false;
        }
        return equals(s, t)||isSubtree(s.left, t) || isSubtree(s.right, t);
    }

    private boolean equals(TreeNode s, TreeNode t){
        if(s == null && t == null){
            return true;
        }
        if(s != null && t != null && s.val == t.val){
            return equals(s.left, t.left) && equals(s.right, t.right);
        }
        return false;
    }

}

题目575

分糖果

给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

思路实现

class Solution {
    public int distributeCandies(int[] candyType) {
        HashSet < Integer > set = new HashSet < > ();
        for (int candy: candyType) {
            set.add(candy);
        }
        return Math.min(set.size(), candyType.length / 2);
    }
}

题目576

出界的路径数

给定一个 m × n 的网格和一个球。球的起始坐标为 (i,j) ，你可以将球移到相邻的单元格内，或者往上、下、左、右四个方向上移动使球穿过网格边界。但是，你最多可以移动 N 次。找出可以将球移出边界的路径数量。答案可能非常大，返回 结果 mod 10**9 + 7 的值。

思路

1.深度优先遍历，但是会超时

2.动态规划

dp[i][j][k]:表示从(i,j)出发第k步出界的路径总数，等价于从外界出发第k步走到(i,j)的路径总数

状态转移方程

dp[i][j][k] = dp[i-1][j][k-1]+dp[i+1][j][k-1] + dp[i][j-1][k-1]+dp[i][j+1][k-1]

结果
Sum=∑dp[i][j][k]

实现

1.
class Solution {
    private int m;
    private int n;
    int[][] move = new int[][]{{-1,0},{1,0},{0,-1},{0,1}};
    public int findPaths(int m, int n, int N, int i, int j) {
        this.m = m;
        this.n = n;
        int res = dfs(i,j,N);
        return res;
    }

    public int dfs(int i, int j ,int round){
        int res = 0;
        if (i < 0 || i == m || j < 0 || j ==n ){
            return 1;
        }
        if (round > 0){
            for(int in=0; in<4; in++){
                int x = i + move[in][0];
                int y = j + move[in][1];
                res += dfs(x,y, round-1) % (10**9+7);
            }
        }
        return res;
    }
}
2.class Solution {
    private int m;
    private int n;
    int[][] move = new int[][]{{-1,0},{1,0},{0,-1},{0,1}};
    public int findPaths(int m, int n, int N, int x, int y) {
       long[][][] dp = new long [m+2][n+2][N+1];
       int mod = 1000000007;
       for(int i =0 ; i < m+2; i++){
           dp[i][0][0] = 1;
           dp[i][n+1][0] = 1;
        }
       for(int j=0; j < n+2; j++){
           dp[0][j][0] = 1;
           dp[m+1][j][0] = 1;
        }
        for(int k = 1; k<=N; k++){
            for(int i = 1; i < m+1; i++){
                for(int j=1; j< n+1; j++){
                    dp[i][j][k] = (dp[i-1][j][k-1]+dp[i+1][j][k-1]+dp[i][j-1][k-1]+dp[i][j+1][k-1])%(mod);
                }
            }
        }
        long res =0;
        for(int k=0; k<=N; k++){
            res = (res + dp[x+1][y+1][k]) % mod;
        }
        return (int)res;
    }
}

题目581

最短无序连续子数组

给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

你找到的子数组应是最短的，请输出它的长度。

示例 1:

输入: [2, 6, 4, 8, 10, 9, 15]
输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。

思路

从左到右循环，记录最大值为 max，若 nums[i] < max, 则表明位置 i 需要调整, 循环结束，记录需要调整的最大位置 i 为 high;

同理，从右到左循环，记录最小值为 min, 若 nums[i] > min, 则表明位置 i 需要调整，循环结束，记录需要调整的最小位置 i 为 low.

实现

class Solution {
    public int findUnsortedSubarray(int[] nums) {
        int max = nums[0];
        int high = 0;
        for(int i = 0; i < nums.length; i ++){
            if(nums[i] < max){
                high = i;
            }
            else{
                max = nums[i];
            }
        }
        int min = nums[nums.length-1];
        int low = nums.length -1;
        for(int i = nums.length-1; i>=0; i--){
            if(nums[i] > min){
                low = i;
            }
            else{
                min = nums[i];
            }
        }
        return (low - high +1) == nums.length ? 0 : high - low +1;

    }
}