力扣算法题（11）动态规划

70-Climbing Stairs (fibonacci数的矩阵计算)

//假设你正在爬楼梯，有n阶，每次可以爬1或2阶，有多少种方法可以爬到楼顶。

class solution70{int res=0;//List<String> res=new ArrayList<>();public int dfs(int res,int n,StringBuffer s) {if(n==0) {res++;return res;}//只能走一个阶梯if(true) {s.append('1');dfs(res,n-1,s);s.deleteCharAt(s.length()-1);}if(n>=2) {s.append('2');dfs(res,n-2,s);s.deleteCharAt(s.length()-1);}return res;}public int climbStairs(int n) {return dfs(res,n,new StringBuffer());}}//输入35的时候超出时间限制class solution70_2{public int climbStairs(int n) {if(n<=0) {return 0;}if(n==1) {return 1;}if(n==2) {return 2;}int first=2,second=1,cur;for(int i=3;i<=n;i++) {cur=first+second;second=first;first=cur;}return first;}}//用f(x)来表示爬到第x级台阶的方案数，考虑到最后一步可能垮了一级台阶，也可能垮了两级//f(x)=f(x-1)+f(x-2)//意味着爬到第x级台阶的方案数是爬到第x-1级台阶的方案数和爬到第x-2级台阶的方案数的和，//f(x)只和f(x-1)与f(x-2)相关，所以可以用滚动数组的思想，把空间复杂度优化成O(1)。class solution70_4{public int climbStairs(int n) {int p=0,q=0,r=1;//分别对应x-2,x-1,xfor(int i=1;i<=n;++i) {p=q;q=r;r=p+q;}return r;}}class solution70_3{public int f(int x) {if(x==0)return 0;else if(x==1)return 1;else if(x==2)return 2;else if(x==3)return 3;else return f(x-1)+f(x-2);}public int climbStairs(int n) {return f(n);}}

746-Min Cost Climbing Stairs

//使用最小花费爬楼梯，第i个阶梯对应着一个非负数的体力值cost[i]下标从0开始
//每当你爬上一个阶梯你都要花费对应体力值，一旦支付了相应的体力值，就可以选择向上爬一个阶梯或者爬两个阶梯
//找出到达楼层顶部的最低花费。开始时，可以选择从下标为0或1的元素作为初始阶梯
//从数组的第一个或第二个元素开始，加，一直到最后，隔一个加连续加都可以,输出最小值

public class solution746{int min=Integer.MAX_VALUE;//最后一节台阶可以直接跨过去public void dfs(int i,int[] cost,int sum) {if(i==cost.length-1||i==cost.length-2) {if(sum<min) {min=sum;}}dfs(i+1,cost,sum+cost[i+1]);if(i+2<cost.length) {dfs(i+2,cost,sum+cost[i+2]);}}public int minCostClimbingStairs(int[] cost) {if(cost.length==0)return 0;dfs(0,cost,cost[0]);if(cost.length>=2) {dfs(1,cost,cost[1]);}return min;}//时间复杂度太大//斐波那契数列的变种，时间复杂度O(n)，空间复杂度O(1)public int minCostClimbingStairs02(int[] cost) {int first = 0, second = 0;int cur;for (int i = 2; i <= cost.length; i++) {cur = Math.min(first + cost[i - 2], second + cost[i - 1]);first = second;second = cur;}return second;}//官方1public int minCostClimbingStairs03(int[] cost) {int n = cost.length;int[] dp = new int[n + 1];//dp数组记录了从第一个到这里最小值dp[0] = dp[1] = 0;//我在某台阶，只用考虑从头到这里最短的路线，不用在意别的，所以前面就可以只保存最小值for (int i = 2; i <= n; i++) {dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);}return dp[n];}}

1137-N-th Tribonacci Number

//第N个泰波那契数 //0,1,1,2,4 T(n+3)=T(n)+T(n+1)+T(n+2)

public class soulution1137{public int tribonacci(int n) {if(n==0)return 0;if(n==1)return 1;if(n==2)return 1;//用for循环来求第n个数的值,设置三个变量存前三个的值，res1,res2,res3int res1=0,res2=1,res3=1;int res=res1+res2+res3;for(int i=3;i<=n;i++) {res=res1+res2+res3;res1=res2;res2=res3;res3=res;}return res;}}

303-Range Sum Query - Immutable

//给定一个整数数组nums，求出数组从索引i到j范围内元素的总和，包含i，j两点。
//思路：新数组data[i]里面是从第一个数到i位置数的总和，求i到j就是data[j]-data[i]

public class solution303{class NumArray{private int[] sums;public NumArray(int[] nums) {if(nums!=null&&nums.length!=0) {sums=new int[nums.length];sums[0]=nums[0];for(int i=1;i<nums.length;i++) {sums[i]=sums[i-1]+nums[i];}}}public int sumRange(int left,int right) {if(left==0) {return sums[right];}return sums[right]-sums[left-1];}}}

// 1218-Longest Arithmetic Subsequence of Given Difference
// 53-Maximum Subarray (DP方法中状态方程与问题求解的区别)
// 121-Best Time to Buy and Sell Stock
// 122-Best Time to Buy and Sell Stock II (非DP问题)
// 123-Best Time to Buy and Sell Stock III (121题的升级)
// 309-Best Time to Buy and Sell Stock with Cooldown (123题的降级)
// 62-Unique Paths
// 63-Unique Paths II
// 980-Unique Paths III (943题类似，旅行商问题)
// 64-Minimum Path Sum
// 120-Triangle
// 174-Dungeon Game
// 931-Minimum Falling Path Sum
// 85-Maximal Rectangle (DP解法有点难，不要求掌握)
// 221-Maximal Square (85题降级)
// 304-Range Sum Query 2D - Immutable (303题的升级，221题对正方形的处理)
// 1277-Count Square Submatrices with All Ones (221题的变形)
// 198-House Robber
// 213-House Robber II
// 337-House Robber III (经典问题)
// 740-Delete and Earn (198题的变形)
// 790-Domino and Tromino Tiling
// 801-Minimum Swaps To Make Sequences Increasing
// 279-Perfect Squares
// 96-Unique Binary Search Trees
// 139-Word Break
// 140-Word Break II (139题的升级)
// 300-longest-increasing-subsequence (一种DP类型的思路)
// 673-Number of Longest Increasing Subsequence (300题的升级)
// 1048-Longest String Chain (300题的变形)
// 1105-Filling Bookcase Shelves
// 131-Palindrome Partitioning (1105题类似的DP解法，掌握回文子串判断的DP解法)
// 89-Gray Code
// 542-01 Matrix
// 241-Different Ways to Add Parentheses
// 718-Maximum Length of Repeated Subarray
// 688-Knight Probability in Chessboard (576,935等三维DP问题)
// 935-Knight Dialer
// 576-Out of Boundary Paths
// 322-Coin Change (无限制背包问题)
// 377-Combination Sum IV (39,40,216系列题目)
// 416-Partition Equal Subset Sum (0,1背包问题)
// 494-Target Sum (416题变型)
// 1049-Last Stone Weight II (494题变型)
// 1043-Partition Array for Maximum Sum
// 1220-Count Vowels Permutation
// 813-Largest Sum of Averages
// 312-Burst Balloons
// ## 字符串DP问题
// 72-Edit Distance (经典字符串DP问题)
// 10-Regular Expression Matching (正则表达式匹配问题，与72题类似)
// 44-Wildcard Matching (正则表达式匹配问题，与10题类似)
// 97-Interleaving String (与72题类似)
// 115-Distinct Subsequences
// 583-Delete Operation for Two Strings (1143题的变形)
// 1143-Longest Common Subsequence (LCS问题)
// 516-Longest Palindromic Subsequence (最长回文子序列问题)
// 1092-Shortest Common Supersequence (LCS问题变形，掌握根据dp数组还原子序列的方法)