LeetCode 397. 整数替换 / 594. 最长和谐子序列 / 559. N 叉树的最大深度

Posted 2021-12-18 Zephyr丶J

397. 整数替换

2021.11.19 每日一题

题目描述

给定一个正整数 n ，你可以做如下操作：

如果 n 是偶数，则用 n / 2替换 n 。
如果 n 是奇数，则可以用 n + 1或n - 1替换 n 。

n 变为 1 所需的最小替换次数是多少？

示例 1：

输入：n = 8
输出：3
解释：8 -> 4 -> 2 -> 1

示例 2：

输入：n = 7
输出：4
解释：7 -> 8 -> 4 -> 2 -> 1
或 7 -> 6 -> 3 -> 2 -> 1

示例 3：

输入：n = 4
输出：2

提示：

1 <= n <= 2^31 - 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/integer-replacement
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

看到以后第一反应想变成2的n次方，然后写了个记忆化搜索

class Solution 
    int min = Integer.MAX_VALUE;
    Map<Long, Integer> memo = new HashMap<>();
    public int integerReplacement(int n) 
        //最快的肯定是2的几次方
        //偶数只能除以
        //算了，先写个递归看看吧
        int min = backtracking(n);
        return min;
    

    public int backtracking(long n)
        if(n == 1)
            return 0;
        
        if(memo.containsKey(n))
            return memo.get(n);
        if(n % 2 == 0)
            int t = backtracking(n / 2);
            memo.put(n, t + 1);
        else
            int t1 = backtracking(n + 1);
            int t2 = backtracking(n - 1);
            memo.put(n, Math.min(t1, t2) + 1);
        
        return memo.get(n);
    

还有一个位运算的做法，也就是贪心，其实就是除4的那种思想，拿三叶姐的那种想法来看，如果末尾有两个以上连续的1，那么如果减1的话，除以2，还是奇数，还要再减1或者加1；而如果加1，那么就可以做很多次除法；而如果末尾只有一个连续的1，那么减1肯定要比加1操作少
3是特殊情况

class Solution 
    public int integerReplacement(int _n) 
        long n = _n;
        int ans = 0;
        while (n != 1) 
            if (n % 2 == 0) 
                n >>= 1;
             else 
                if (n != 3 && ((n >> 1) & 1) == 1) n++;
                else n--;
            
            ans++;
        
        return ans;
    

594. 最长和谐子序列

2021.11.20 每日一题

题目描述

和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。

现在，给你一个整数数组 nums ，请你在所有可能的子序列中找到最长的和谐子序列的长度。

数组的子序列是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。

示例 1：

输入：nums = [1,3,2,2,5,2,3,7]
输出：5
解释：最长的和谐子序列是 [3,2,2,2,3]

示例 2：

输入：nums = [1,2,3,4]
输出：2

示例 3：

输入：nums = [1,1,1,1]
输出：0

提示：

1 <= nums.length <= 2 * 10^4
-10^9 <= nums[i] <= 10^9

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-harmonious-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

子序列的简单题
想了一下，统计每个数字的出现次数，然后遍历所有数字，如果有和它相邻的数字，就说明可以组成这样的和谐子序列，然后统计最大的长度就可以了，但是这样击败的不多
或者先排序吧，排序时间复杂度按理说应该比这样高

class Solution 
    public int findLHS(int[] nums) 
        int n = nums.length;
        Map<Integer, Integer> count = new HashMap<>();
        for(int i = 0; i < n; i++)
            count.put(nums[i], count.getOrDefault(nums[i], 0) + 1);
        
        int max = 0;
        for(int key : count.keySet())
            int c1 = count.get(key);
            int c2 = count.getOrDefault(key + 1, 0);
            if(c2 != 0)
                max = Math.max(max, c1 + c2);
        
        return max;
    

排序击败百分百了，但是写的不优雅，有点丑陋，官解还是很简洁的

class Solution 
    public int findLHS(int[] nums) 
        int n = nums.length;
        Arrays.sort(nums);
        int num = nums[0];
        int pre = 0;
        int mid = 0;
        int max = 0;
        for(int i = 1; i < n; i++)
            if(nums[i] == num)
                continue;
            else if(nums[i] != num)
                if(nums[mid] - nums[pre] == 1)
                    max = Math.max(i - pre, max);
                
                pre = mid;
                mid = i;
                num = nums[i];
            
        
        if(mid != n && nums[mid] - nums[pre] == 1)
            max = Math.max(n - pre, max);
        
        return max;
    

559. N 叉树的最大深度

2021.11.21 每日一题

题目描述

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

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

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：3

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

提示：

树的深度不会超过 1000 。
树的节点数目位于 [0, 10^4] 之间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-depth-of-n-ary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

bfs

class Solution 
    public int maxDepth(Node root) 
        //看到第一眼反应就是层序遍历
        //想想怎么搞null
        int deep = 0;
        if(root == null)
            return 0;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty())
            int size = queue.size();
            deep++;
            while(size-- > 0)
                Node node = queue.poll();
                List<Node> list = node.children;
                for(Node n : list)
                    queue.add(n);
                
            
        
        return deep;
    

dfs

class Solution 
    public int maxDepth(Node root) 
        //看到第一眼反应就是层序遍历
        if(root == null)
            return 0;
        List<Node> list = root.children;
        int deep = 0;
        for(Node n : list)
            deep = Math.max(deep, maxDepth(n));
        
        return deep + 1;