假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。
思路1 记忆化搜索(自上而下) private int calcWays(int n){ if(n == 0 || n == 1) return 1; if(memo[n] == -1) memo[n] = calcWays(n - 1) + calcWays(n - 2); return memo[n]; } 思路2 DP public int climbStairs(int n) { if(n==0) return 1; if(n==1) return 1; return climbStairs(n-1)+ climbStairs(n-2); } 思路3 递归(自下而上) public int climbStairs(int n) { int[] memo = new int[n + 1]; memo[0] = 1; memo[1] = 1; for(int i = 2 ; i <= n ; i ++) memo[i] = memo[i - 1] + memo[i - 2]; return memo[n]; }给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 说明：每次只能向下或者向右移动一步。 示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。
public int minPathSum(int[][] grid) { for(int i=0;i<grid.length;i++){ for(int j=0;j<grid[0].length;j++){ if(i==0&&j==0) continue; else if(i==0 ) grid[i][j]+=grid[i][j-1];//左边是边界，只能从上面来 else if( j==0) grid[i][j]+=grid[i-1][j];//上面是边界，只能从左面来 else grid[i][j]+=Math.min(grid[i-1][j],grid[i][j-1]); } } return grid[grid.length - 1][grid[0].length - 1]; }给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。 例如，给定三角形： [ [2], [3,4], [6,5,7], [4,1,8,3] ] 自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
数学方法 public int integerBreak(int n) { int res=1; if(n<4) return n-1; while(n>4){ n-=3; res*=3; } return res*n; } //动态规划 public int integerBreak(int n) { int[] dp = new int[n + 1]; dp[1] = 1; //dp[i]表示将数字i分割后的最大乘积(至少两部分) for (int i = 2; i <= n; i++) { for (int j = 1; j < i; j++) { dp[i] = Math.max(dp[i], Math.max(j, dp[j]) * (i - j)); } } return dp[n]; } //记忆化搜索 private int[] memo; public int integerBreak(int n) { if(n < 1) throw new IllegalArgumentException("n should be greater than zero"); memo = new int[n+1]; Arrays.fill(memo, -1); return breakInteger(n); } // 将n进行分割(至少分割两部分), 可以获得的最大乘积 private int breakInteger(int n){ if(n == 1) return 1; if(memo[n] != -1) return memo[n]; int res = -1; for(int i = 1 ; i <= n - 1 ; i ++) res = max3(res, i * (n - i) , i * breakInteger(n - i)); memo[n] = res; return res; } private int max3(int a, int b, int c){ return Math.max(a, Math.max(b, c)); }给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
class Solution { public int numSquares(int n) { int[] dp = new int[n+1]; dp[0] = 0; //dp[i]:构成数i的最小的完全平方和 //dp[i] = min(dp[i-j*j] + 1 , min); dp[i] = min(dp[i-k] + 1 ) k:1~ i-k*k >=0 for(int i = 1 ; i<= n ;i++){//每个数的最小的完全平方和 int min = Integer.MAX_VALUE; for( int j = 1; i- j*j >=0 ;j++){ min = Math.min(dp[i-j*j] + 1, min); //min:这个数i中本次的min } dp[i] = min; } return dp[n]; } }你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1： 输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。 示例 2： 输入：[2,7,9,3,1] 输出：12 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。偷窃到的最高金额 = 2 + 9 + 1 = 12 。
class Solution { public int rob(int[] nums) { int n=nums.length; int dp[]=new int[n+1]; if(n==0) return 0; if(n==1) return Math.max(0,nums[0]); dp[0]=nums[0]; dp[1]=Math.max(dp[0],nums[1]); for (int i = 2; i <n ; i++) { dp[i]=Math.max(dp[i-1],nums[i]+dp[i-2]); } System.out.println(dp[n-1]); return dp[n-1]; } } //记忆化搜索 public class Solution1 { int memo[]; // memo[i] 表示考虑抢劫 nums[i...n) 所能获得的最大收益 private int[] memo; public int rob(int[] nums) { memo = new int[nums.length]; Arrays.fill(memo, -1); return tryRob(nums, 0); } // 考虑抢劫nums[index...nums.size())这个范围的所有房子 private int tryRob(int[] nums, int index){ if(index >= nums.length) return 0; if(memo[index] != -1) return memo[index]; int res = 0; for(int i = index ; i < nums.length ; i ++) res = Math.max(res, nums[i] + tryRob(nums, i + 2)); memo[index] = res; return res; } } //dp public int rob(int[] nums) { int n = nums.length; if(n == 0) return 0; // memo[i] 表示考虑抢劫 nums[i...n) 所能获得的最大收益 int[] memo = new int[nums.length]; memo[n - 1] = nums[n - 1]; for(int i = n - 2 ; i >= 0 ; i --) for (int j = i; j < n; j++) memo[i] = Math.max( memo[i], nums[j] + (j + 2 < n ? memo[j + 2] : 0)); return memo[0]; }你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1: 输入: [2,3,2] 输出: 3 解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。 示例 2: 输入: [1,2,3,1] 输出: 4 解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。 偷窃到的最高金额 = 1 + 3 = 4 。
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。示例: 输入: [1,2,3,0,2] 输出: 3 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200
示例 1: 输入: [1, 5, 11, 5] 输出: true 解释: 数组可以分割成 [1, 5, 5] 和 [11]. 示例 2: 输入: [1, 2, 3, 5] 输出: false 解释: 数组不能分割成两个元素和相等的子集.
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
示例 1: 输入: coins = [1, 2, 5], amount = 11 输出: 3 解释: 11 = 5 + 5 + 1 示例 2: 输入: coins = [2], amount = 3 输出: -1
给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。
示例:nums = [1, 2, 3] target = 4 所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1) 请注意，顺序不同的序列被视作不同的组合。 因此输出为 7。
在计算机界中，我们总是追求用有限的资源获取最大的收益。 现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。 你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于数组中的字符串的最大数量。每个 0 和 1 至多被使用一次。
示例 1: 输入: strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3 输出: 4 解释: 总共 4 个字符串可以通过 5 个 0 和 3 个 1 拼出，即 “10”,“0001”,“1”,“0” 。 示例 2: 输入: strs = [“10”, “0”, “1”], m = 1, n = 1 输出: 2 解释: 你可以拼出 “10”，但之后就没有剩余数字了。更好的选择是拼出 “0” 和 “1” 。
给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
说明： 拆分时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。 示例 1： 输入: s = “leetcode”, wordDict = [“leet”, “code”] 输出: true 解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。 示例 2： 输入: s = “applepenapple”, wordDict = [“apple”, “pen”] 输出: true 解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。 注意你可以重复使用字典中的单词。 示例 3： 输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”] 输出: false
给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。
示例： 输入：nums: [1, 1, 1, 1, 1], S: 3 输出：5 解释： -1+1+1+1+1 = 3 +1-1+1+1+1 = 3 +1+1-1+1+1 = 3 +1+1+1-1+1 = 3 +1+1+1+1-1 = 3 一共有5种方法让最终目标和为3。
给定一个无序的整数数组，找到其中最长上升子序列的长度。
示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 说明: 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n2) 。
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
示例 1: 输入: [1,7,4,9,2,5] 输出: 6 解释: 整个序列均为摆动序列。 示例 2: 输入: [1,17,5,10,13,15,10,5,16,8] 输出: 7 解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。 示例 3: 输入: [1,2,3,4,5,6,7,8,9] 输出: 2
给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。 若这两个字符串没有公共子序列，则返回 0。
