239 滑动窗口的最大值（单调队列）、279 完全平方数、283移动零到末尾、312戳气球 （动态规划）三个乘积最大，戳中间、 338比特位计数 动态规划、位运算、347前k个高频元素

1. 239 滑动窗口的最大值 （单调队列）
2. 240 搜索二维矩阵
3. 279 完全平方数（动态规划）for(int i=1;i<=n;i++){for(int j=1;j*j<=i ;j++){
4. 283移动零到末尾 ，index：表示非0数的个数
5. 287寻找重复数 二分
6. 297二叉树的序列化和反序列化
7. 300最长上升子序列 动态规划 贪心（二分）
8. 309最佳买卖股票时期含冷冻期
9. 312戳气球 （动态规划）三个乘积最大，戳中间
10. 322零钱兑换（总和最大，不同硬币）
11. 337打家劫舍3
12. 338比特位计数 动态规划、位运算（res[i] = res[i&(i-1)]+1;）
13. 347前k个高频元素 hashmap频率、priorityQueue最小堆存k个

239 滑动窗口的最大值（单调队列）

窗口对应的数据结构为 双端队列 ，本题使用 单调队列 即可解决以上问题。遍历数组时，每轮保证单调队列 deque ：

1、deque 内 仅包含窗口内的元素 \Rightarrow⇒ 每轮窗口滑动移除了元素 nums[i−1] ，需将 dequedeque 内的对应元素一起删除。
2、dequedeque 内的元素 非严格递减 \Rightarrow⇒ 每轮窗口滑动添加了元素 nums[j+1] ，需将 dequedeque 内所有 < nums[j + 1] 的元素删除。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for(int i = 0; i < k; i++) { // 未形成窗口
            while(!deque.isEmpty() && deque.peekLast() < nums[i]) deque.removeLast();
            deque.addLast(nums[i]);
        }
        res[0] = deque.peekFirst();
        for(int i = k; i < nums.length; i++) { // 形成窗口后
            if(deque.peekFirst() == nums[i - k]) deque.removeFirst();
            while(!deque.isEmpty() && deque.peekLast() < nums[i]) deque.removeLast();
            deque.addLast(nums[i]);
            res[i - k + 1] = deque.peekFirst();
        }
        return res;
    }
}

240 搜索二维矩阵

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0) return false;
        int m = 0;
        int n = matrix[0].length - 1;
        while (m < matrix.length && n >= 0) {
            if (matrix[m][n] == target) {
                return true;
            } else if (matrix[m][n] > target) {
                n--;
            } else {
                m++;
            }
        }
        return false;
    }
}

279 完全平方数和n，个数最少 动态规划

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3
解释: 12 = 4 + 4 + 4.
示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

首先初始化长度为n+1的数组dp，每个位置都为0
如果n为0，则结果为0
对数组进行遍历，下标为i，每次都将当前数字先更新为最大的结果，即dp[i]=i，比如i=4，最坏结果为4=1+1+1+1即为4个数字
动态转移方程为：dp[i] = MIN(dp[i], dp[i - j * j] + 1)，i表示当前数字，jj表示平方数
时间复杂度：O(nsqrt(n))，sqrt为平方根

class Solution {
    public int numSquares(int n) {
        if(n==0) return 0;
        int[] dp=new int[n+1];
        for(int i=0;i<=n;i++){
            dp[i]=i;
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j*j<=i ;j++){
            //    dp[i]=i;
                dp[i]=Math.min(dp[i],dp[i-j*j]+1);
            }
        }
        return dp[n];
    }
}

283移动零到末尾

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:

必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。
思路：设置一个index，表示非0数的个数，循环遍历数组，
如果不是0，将非0值移动到第index位置,然后index + 1.
遍历结束之后，index值表示为非0的个数，再次遍历，从index位置后的位置此时都应该为0

    public void moveZeroes(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return;
        }
        int index = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                nums[index] = nums[i];
                index++;
            }
        }

        for (int i = index; i < nums.length; i++) {
            nums[i] = 0;
        }
    }

287寻找重复数

287. 寻找重复数
     给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。

示例 1:

输入: [1,3,4,2,2]
输出: 2
示例 2:

输入: [3,1,3,4,2]
输出: 3
说明：

不能更改原数组（假设数组是只读的）。
只能使用额外的 O(1) 的空间。
时间复杂度小于 O(n2) 。
数组中只有一个重复的数字，但它可能不止重复出现一次。

solution 二分查找

class Solution {
    public int findDuplicate(int[] nums) {
        int n=nums.length;
        if(nums==null || n==0 ) return 0;
        int left=1,right=n;
        while(left<right){
            int mid = left+((right-left)>>1);
            int count=0;
            for(int num:nums){
                if(num<=mid){
                    count++;
                }
            }
            if(count>mid){
                right=mid;
            }
            else{
                left=mid+1;
            }
        }
        return left;
    }
}

297二叉树的序列化和反序列化

public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        if(root == null) return null;
        helperSer(sb,root);
        return sb.toString();
    }
    public String helperSer(StringBuilder sb , TreeNode root){
        if(root == null){
            sb.append("#,");
            return sb.toString();
        }
        sb.append(root.val+",");
        helperSer(sb,root.left);
        helperSer(sb,root.right);
        return sb.toString();
    }
    int index = 0;   //计数变量
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String str) {
        if(str == null || str == "") return null;
        String[] strr = str.split(",");
        return helperDe(strr);
    }
    public TreeNode helperDe(String[] strr){
        String cur = strr[index++];
        if(cur.equals("#")) return null;
        TreeNode node = new TreeNode(Integer.parseInt(cur));
        node.left = helperDe(strr);
        node.right = helperDe(strr);
        return node;
    }
}

300最长上升子序列 动态规划、贪心（二分）

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?
数列未必一直递增
所以所有数字都得扫描

代码如下：

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length==0) return 0;
        int[] dp=new int[nums.length];//第0个长度为1 
        Arrays.fill(dp,1);// 最小长度就是自身1
        // 第i个元素的最大子序列长度为dp[i]
        for(int i=1;i<nums.length;i++){
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]){
                    dp[i]=Math.max(dp[i], dp[j]+1);
                }
            }
        }
        int res=1;
        for(int i=0;i<nums.length;i++){// 再遍历一遍
            res=Math.max(res,dp[i]);
        }
        return res;
    }
}

复杂度

时：O(N^2)

O（nlogn）？可以吗

可以贪心算法

public class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = nums.length;
        // 特判
        if (len <= 1) {
            return len;
        }
        // tail 数组的定义：长度为 i + 1 的上升子序列的末尾最小是几
        int[] tail = new int[len];
        // 遍历第 1 个数，直接放在有序数组 tail 的开头
        tail[0] = nums[0];
        // end 表示有序数组 tail 的最后一个已经赋值元素的索引

        int end = 0;
        for (int i = 1; i < len; i++) {
            // 【逻辑 1】比 tail 数组实际有效的末尾的那个元素还大
            if (nums[i] > tail[end]) {
                // 直接添加在那个元素的后面，所以 end 先加 1
                end++;
                tail[end] = nums[i];
            } else {
                // 使用二分查找法，在有序数组 tail 中
                // 找到第 1 个大于等于 nums[i] 的元素，尝试让那个元素更小
                int left = 0;
                int right = end;
                while (left < right) {
                    // 选左中位数不是偶然，而是有原因的，原因请见 LeetCode 第 35 题题解
                    // int mid = left + (right - left) / 2;
                    int mid = left + ((right - left) >>> 1);
                    if (tail[mid] < nums[i]) {
                        // 中位数肯定不是要找的数，把它写在分支的前面
                        left = mid + 1;
                    } else {
                        right = mid;
                    }
                }
                // 走到这里是因为 【逻辑 1】 的反面，因此一定能找到第 1 个大于等于 nums[i] 的元素
                // 因此，无需再单独判断
                tail[left] = nums[i];
            }
            // 调试方法
            // printArray(nums[i], tail);
        }
        // 此时 end 是有序数组 tail 最后一个元素的索引
        // 题目要求返回的是长度，因此 +1 后返回
        end++;
        return end;
    }
}

309最佳买卖股票时期含冷冻期

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:
输入: [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

class Solution {
    public int maxProfit(int[] prices) {
        // 参考309 团灭股票方法
        // dp[i][0]=Math.max(dp[i-1][0], dp[i-1][1]+prices[i]);
        // dp[i][1]=Math.max(dp[i-1][1], dp[i-2][0]-prices[i]);
        int n=prices.length;
        int dp_i_0=0, dp_i_1=Integer.MIN_VALUE;
        int dp_pre_0=0;
        for(int i=0;i<n;i++){
            int tmp=dp_i_0;// 保存昨天的
            dp_i_0=Math.max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=Math.max(dp_i_1, dp_pre_0-prices[i]);
            dp_pre_0=tmp;// 保存的就是前天的了
        }
        return dp_i_0;
    }
}

312戳气球

有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。
现在要求你戳破所有的气球。如果你戳破气球 i ，就可以获得 nums[left] * nums[i] * nums[right] 个硬币。 这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。

求所能获得硬币的最大数量。

说明:
你可以假设 nums[-1] = nums[n] = 1，但注意它们不是真实存在的所以并不能被戳破。
0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
示例:
输入: [3,1,5,8]
输出: 167
解释: nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 315 + 358 + 138 + 181 = 167

solution动态规划
以两个数作为左右端点，找出最优解中它们中间那个戳破的气球，中间这个气球把整个队列分为了2部分，要想让中间这个气球和2个端点靠在一起，就需要先把分开的2部分的气球戳破。 dp[i][j]表示i~j最大值，i，j不戳破。 比如k气球在i,j之间时(i,k,j)被戳破，那么要先戳破i,k、k,j之间的气球，所以

dp[i][j]=dp[i][k]+dp[k][j]+nums[i]*nums[k]*nums[j]

class Solution {
    public int maxCoins(int[] nums) {
        // 在首尾分别插入一个权重为1的气球，是运算更简便
        int n = nums.length;
        int[]arr = new int[n+2];
        arr[0]=arr[n+1]=1;
        for (int i = 1; i <=n ; i++) {
            arr[i] = nums[i-1];
        }

        // dp[i][j]表示戳破i~j之间的气球获得的最大值
        // 已经初始化了dp[0][0]=dp[n+1][n+1]=0
        int [][]dp = new int[n+2][n+2];
        // 倒序迭代
        // 起点
        for (int l = n-1; l>=0 ; l--) {
            // 终点
            for (int r = l+2; r<=n+1 ; r++) {
                // 遍历得到该区间的最大值
                for (int k = l+1; k <=r-1 ; k++) {
                    dp[l][r] = Math.max(dp[l][r],dp[l][k]+dp[k][r]+arr[l]*arr[k]*arr[r]);
                }
            }
        }
        return dp[0][n+1];
    }
}

322零钱兑换 不同面额总数n 最少硬币

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3
解释: 11 = 5 + 5 + 1
示例 2:

输入: coins = [2], amount = 3
输出: -1

class Solution {
    public int coinChange(int[] coins, int amount) {
        if(coins.length==0) return 0;
        if(amount<0) return -1;
        int[] dp =new int[amount+1];//因为最多只能为amount 都是一元
        Arrays.fill(dp, amount+1);
        dp[0]=0;
        for(int i=0;i<=amount;i++){
            for(int j=0;j<coins.length;j++){
                if(amount<coins[j]) continue;
                if(i-coins[j]<0) continue;
                dp[i]=Math.min(dp[i], dp[i-coins[j]]+1);
                
            }
        }
        return dp[amount]==amount+1? -1:dp[amount];
    }
}

337打家劫舍3

lee337

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
示例 1:
输入: [3,2,3,null,3,null,1]

 3
/ \

2 3
\ \
3 1

输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:
输入: [3,4,5,1,3,null,1]
3
/
4 5
/ \ \
1 3 1
输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

思路 递归 首先要看清题 其实就是二叉树结构 不能相邻节点 就是父节点选中 不能有子节点，可以选孙子节点

在解法1和解法2中 我们使用爷爷-两个孩子-4个孙子来说明问题
首先来定义这个问题的状态
爷爷节点获取到最大的偷取的钱数呢

首先要明确相邻的节点不能偷，也就是爷爷选择偷，儿子就不能偷了，但是孙子可以偷
二叉树只有左右两个孩子，一个爷爷最多2个儿子,4个孙子
根据以上条件，我们可以得出单个节点的钱该怎么算
4个孙子偷的钱 + 爷爷的钱 VS 两个儿子偷的钱 哪个组合钱多，就当做当前节点能偷的最大钱数。这就是动态规划里面的最优子结构

由于是二叉树，这里可以选择计算所有子节点
4个孙子投的钱加上爷爷的钱如下
int method1 = root.val + rob(root.left.left) + rob(root.left.right) + rob(root.right.left) + rob(root.right.right)
两个儿子偷的钱如下
int method2 = rob(root.left) + rob(root.right);
挑选一个钱数多的方案则
int result = Math.max(method1, method2);

public int rob(TreeNode root) {
    if (root == null) return 0;

    int money = root.val;
    if (root.left != null) {
        money += (rob(root.left.left) + rob(root.left.right));
    }

    if (root.right != null) {
        money += (rob(root.right.left) + rob(root.right.right));
    }

    return Math.max(money, rob(root.left) + rob(root.right));
}

这样效率低，想到memo[ ] 存储

我们这一步针对重复子问题进行优化，我们在做斐波那契数列时，使用的优化方案是记忆化,但是之前的问题都是使用数组解决的，把每次计算的结果都存起来，下次如果再来计算，就从缓存中取，不再计算了，这样就保证每个数字只计算一次。
由于二叉树不适合拿数组当缓存，我们这次使用哈希表来存储结果，TreeNode当做key，能偷的钱当做value

修改一下上面的代码可得：

class Solution {
    HashMap<TreeNode, Integer> map = new HashMap<>();
    public int rob(TreeNode root) {
        if(root==null) return 0;
  //       map.put(root,0);
        if(map.containsKey(root)) return map.get(root);
        
        int money=root.val;
       
        if(root.left!=null){
            money+=(rob(root.left.left)+rob(root.left.right));

        }
        if(root.right!=null){
            money+=(rob(root.right.left)+rob(root.right.right));
        }
        
        int res= Math.max(money, rob(root.left)+rob(root.right));
        map.put(root,res);
        return res;
    }
}

一般人想不到的终极解法3

上面两种解法用到了孙子节点，计算爷爷节点能偷的钱还要同时去计算孙子节点投的钱，虽然有了记忆化，但是还是有性能损耗。

我们换一种办法来定义此问题
每个节点可选择偷或者不偷两种状态，根据题目意思，相连节点不能一起偷

当前节点选择偷时，那么两个孩子节点就不能选择偷了
当前节点选择不偷时，两个孩子节点只需要拿最多的钱出来就行(两个孩子节点偷不偷没关系)
我们使用一个大小为2的数组来表示 int[] res = new int[2] 0代表不偷，1代表偷
任何一个节点能偷到的最大钱的状态可以定义为

当前节点选择不偷: 当前节点能偷到的最大钱数 = 左孩子能偷到的钱 + 右孩子能偷到的钱
当前节点选择偷: 当前节点能偷到的最大钱数 = 左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数
表示为公式如下

root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) + Math.max(rob(root.right)[0], rob(root.right)[1])
root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;

代码如下：

public int rob(TreeNode root) {
    int[] result = robInternal(root);
    return Math.max(result[0], result[1]);
}

public int[] robInternal(TreeNode root) {
    if (root == null) return new int[2];
    int[] result = new int[2];

    int[] left = robInternal(root.left);
    int[] right = robInternal(root.right);

    result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
    result[1] = left[0] + right[0] + root.val;
    return result;
}

338比特位计数

给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。

示例 1:

输入: 2
输出: [0,1,1]
示例 2:

输入: 5
输出: [0,1,1,2,1,2]
进阶:

给出时间复杂度为O(n*sizeof(integer))的解答非常容易。但你可以在线性时间O(n)内用一趟扫描做到吗？
要求算法的空间复杂度为O(n)。

class Solution {
    public int[] countBits(int n) {
        if(n==0) return new int[]{0};
       
        int[] res = new int[n+1];
        for(int i=1;i<=n;i++){
            res[i] = res[i&(i-1)]+1;
        }
        return res;
    }
}

347前k个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。
solution1 hashmap记录频率，优先队列最小堆存

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
         //先统计每个数字出现的次数，这个貌似不可避免，时间复杂度为O(n)
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
        }

        //然后应该可以使用优先队列了，
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return map.get(o1)-map.get(o2);
            }
        });
        for(int key:map.keySet()){
            if(pq.size()<k){
                pq.add(key);
                continue;
            }

            int small = pq.peek();
            if(map.get(small)<map.get(key)){
                pq.poll();
                pq.add(key);
            }
        }
        int[] res =new int[pq.size()];
        for(int i=0; i<res.length;i++){
            res[i] = pq.poll();
        }
        return res;
    }
}

时：nlogk