Leeli9316的博客

①确定状态： maxP[i]表示以nums[i]结尾的最大子数组乘积; minP[i]表示以nums[i]结尾的最小子数组乘积;②转移方程： maxP[i] = Math.max(nums[i], Math.max(maxP[i - 1] * nums[i], minP[i - 1] * nums[i])); minP[i] = Math.min(nums[i], Math.min(minP[i - 1] * nums[i], maxP[i - 1]

方法：动态规划①确定状态：dp[i][j]表示以(i,j)为右下角的正方形最大边长；②转移方程： ③初始条件和边界情况：i = 0，j = 0；④计算顺序：因为dp[i][j]由dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1] 推出，所以从小到大遍历。......

①确定状态：dp[i][j]表示以(i,j)为右下角的正方形最大边长；②转移方程： ③初始条件和边界情况：i = 0，j = 0；④计算顺序：因为dp[i][j]由dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1] 推出，所以从小到大遍历。证明过程：1277. 统计全为 1 的正方形子矩阵的官方题解...

①确定状态：dp[i][j]表示到grid[i][j]路径上的最小数字总和；②转移方程：dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];③初始条件和边界情况：dp[0][0] = grid[0][0]；④计算顺序：因为dp[i][j] 由dp[i - 1][j]和dp[i][j - 1]推出，所以从小到大遍历。...

①确定状态：dp[i] 表示凑成总金额 i 所需的最少硬币个数；②转移方程：dp[i] = Math.min(dp[i], dp[i - coin] + 1); ③初始条件和边界情况：dp[i] = 0；④计算顺序：因为dp[i] 由 dp[i - coin] 推出，所以从小到大遍历。...

方法：动态规划①确定状态：dp[i][j]表示字符串s的下标范围[i, j]内的最长回文子序列长度；②转移方程：if(s.charAt(i)==s.charAt(j)){//长度为1或2的子序列if(j-i<2){dp[i][j]=j-i+1;//长度大于2的子序列...

方法一：暴力求解class Solution { public String longestPalindrome(String s) { int n = s.length(); String ans = ""; int maxLen = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j <= n; j++) { ..

方法一：暴力求解(O(n^3))class Solution { public int countSubstrings(String s) { int n = s.length(); int ans = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j <= n; j++) { if (satisfy(s.subst..

方法：动态规划①确定状态：dp[i][j]表示长度[0, i - 1]的字符串text1与长度[0, j - 1]的字符串text2的最长公共子序列；②转移方程：dp[i][j]=dp[i−1][j−1]+1, 当 text1[i - 1] == text2[j - 1];dp[i][j]=Math.max(dp[i−1][j],dp[i][j−1]), 当 text1[i - 1] != text2[j - 1];③初始条件和边界情况：dp[i...

方法一：暴力求解 (写不出来)class Solution { public int findLength(int[] nums1, int[] nums2) { int n1 = nums1.length, n2 = nums2.length; if (n1 < n2) return findLength(nums2, nums1); int ans = 0; for (int i = 0; i < n1; i+..

方法一：枚举class Solution { public int findLengthOfLCIS(int[] nums) { int n = nums.length; int ans = 0; for (int i = 0; i < n; i++) { int pre = nums[i]; int count = 1; for (int j = i + 1; j..

方法：动态规划①确定状态：dp[i] 为i之前包括i的以nums[i]结尾最长递增子序列长度；②转移方程：位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值，所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1)，注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是要取dp[j] + 1的最大值；③初始条件和边界情况：dp[0] = 1，每一个i，对应的dp[i]（即最长上升...

方法：动态规划class Solution { public int rob(int[] nums) { int n = nums.length; if (n == 1) { return nums[0]; } else if (n == 2) { return Math.max(nums[0], nums[1]); } return Math.max(ro...

方法：动态规划①确定状态：dp[i] 为偷窃第 i +1个房屋的最高金额；②转移方程：dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i])；③初始条件和边界情况：dp[0]=nums[0];dp[1]=Math.max(nums[0],nums[1]);④计算顺序：因为 dp[i] 由 dp[i-1] 和 dp[i-2]推出，所以从前往后遍历--一维数组class Solution { public int rob(...

方法：动态规划(转化为01背包)--三维数组class Solution { public int findMaxForm(String[] strs, int m, int n) { int length = strs.length; int[][][] dp = new int[length + 1][m + 1][n + 1]; for (int i = 1; i <= length; i++) { ...

方法一：深度优先搜索class Solution { int ans = 0; public int findTargetSumWays(int[] nums, int target) { dfs(nums, target, 0, 0); return ans; } public void dfs(int[] nums, int target, int i, int sum){ //数组遍历结束 if(..

方法：动态规划(转化为01背包)--二维数组class Solution { public int lastStoneWeightII(int[] stones) { //转化为01背包问题：尽量让石头分成重量相同的两堆，粉碎之后重量最小 int sum = 0; for (int stone : stones) { sum += stone; } int n = stones.l...

方法：动态规划class Solution { public boolean canPartition(int[] nums) { int n = nums.length; if (n < 2) { return false; } int sum = 0, maxNum = 0; for (int num : nums) { sum += num; ...

方法：动态规划①确定状态：dp[i] 为从 1 到 n 互不相同的二叉搜索树总数；②转移方程：dp[i]+=dp[j-1]*dp[i-j];③初始条件和边界情况：dp[0] = 1；④计算顺序：因为 dp[i] 是依靠 dp[i - j]的状态，先有 dp[i - j] 再有 dp[i]，所以从前往后遍历。class Solution { public int numTrees(int n) { int[] dp = new int[n + ...

方法：动态规划①确定状态：dp[i] 为拆分数字 i, 可以得到的最大乘积；②转移方程：dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));;③初始条件和边界情况：dp[2] = 1；④计算顺序：因为 dp[i] 是依靠 dp[i - j]的状态，先有 dp[i - j] 再有 dp[i]，所以从前往后遍历。class Solution { public int integerBreak(int n) ..

方法：动态规划①确定状态：dp[i][j] 为到达第 i +1 行 j+1 列网格的所有路径；②转移方程：dp[i][j] = dp[i - 1][j] + dp[i][j - 1];③初始条件和边界情况：obstacleGrid[i][j]== 0时，dp[i][j] = 1；④计算顺序：因为 dp[i][j] 由 dp[i - 1][j] 和 dp[i][j - 1]推出，所以根据向下或向右按顺序遍历。class Solution { public int uniqu...

方法：动态规划①确定状态：dp[i][j] 为到达第 i +1 行 j+1 列网格的所有路径；②转移方程：dp[i][j] = dp[i - 1][j] + dp[i][j - 1];③初始条件和边界情况：dp[0][1] = 1;dp[1][0] = 1;④计算顺序：因为 dp[i][j] 由 dp[i - 1][j] 和 dp[i][j - 1]推出，所以根据向下或向右按顺序遍历。class Solution { public int uniquePaths(int m..

方法：动态规划①确定状态：dp[i] 为到达第 i 个台阶的最低花费②转移方程：dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i]③初始条件和边界情况：dp[0] = cost[0]; dp[1] = cost[1];④计算顺序：因为 dp[i] 由 dp[i-1] 和 dp[i-2]推出，所以从前往后遍历class Solution { public int minCostClimbingStairs(int[] cost) ..

方法：动态规划class Solution { public int climbStairs(int n) { //第 n 个台阶只能从第 n - 2 或第 n - 1 个台阶爬上来， //到第 n - 2个台阶的走法 ＋ 到第 n - 1 个台阶的走法 = 到第 n 个台阶的走法 if (n <= 2) return n; //确定状态 int[] dp = new int[n + 1]; ..

方法一：递归class Solution { public int fib(int n) { if (n <= 1) return n; return fib(n - 1) + fib(n - 2); }}方法二：动态规划class Solution { public int fib(int n) { if (n <= 1) return n; int[] dp = n..