阿财继续努力

文章目录1. 题目2. 思路(1) 单调栈3. 代码1. 题目2. 思路(1) 单调栈left[i]表示下标i左边第一个高度小于i的下标，right[i]表示下标i右边第一个高度小于i的下标。利用单调栈高度小于当前下标的下标，则栈顶元素为左边或右边第一个小于当前下标的下标。3. 代码import java.util.Deque;import java.util.LinkedList;public class Test { public static void main(S

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划left[i]表示i左边的最大值，right[i]表示i右边的最大值，取两者的较小值减去height[i]即为在i处能够接到的水量。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int trap(int[] height) {

文章目录1. 题目2. 思路(1) 单调栈3. 代码1. 题目2. 思路(1) 单调栈由于数组是循环的，可以假设将数组复制一份连在原数组后面，这样只需要遍历一遍即可。3. 代码import java.util.Deque;import java.util.LinkedList;public class Test { public static void main(String[] args) { }}class Solution { public int

文章目录1. 题目2. 思路(1) 单调栈3. 代码1. 题目2. 思路(1) 单调栈从后往前遍历nums2，利用单调栈存储比当前元素大的元素，利用哈希表存储当前元素右边的下一个更大元素。3. 代码import java.util.Deque;import java.util.HashMap;import java.util.LinkedList;import java.util.Map;public class Test { public static void mai

文章目录1. 题目2. 思路(1) 单调栈3. 代码1. 题目2. 思路(1) 单调栈从后往前遍历数组，若栈顶温度不大于当天温度，则弹出栈顶元素，直到当天温度是单调栈中的最低温度。此时，栈顶元素即为最近的高于当天温度的下标，计算两个下标之间的距离，并将当天下标入栈。3. 代码import java.util.Deque;import java.util.LinkedList;public class Test { public static void main(String

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示字符串s的下标为[i,j]的最长回文子序列的长度。若chars[i]==chars[j]，则dp[i][j]=dp[i+1][j-1]+2；否则，dp[i][j]取dp[i][j-1]和dp[i+1][j]中较大值。3. 代码public class Test { public static void main(String[] args) { }}clas

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示字符串s的下标为[i,j]的子串是否是回文子串。当chars[i]==chars[j]且下标为[i+1,j-1]的子串是回文子串时，可判定下标为[i,j]的子串也是回文子串，即dp[i][j]=true。3. 代码public class Test { public static void main(String[] args) { }}class Solu

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划题目中给出的三种操作可以简化为以下三种操作：向字符串word1插入一个字符；向字符串word2插入一个字符；修改字符串word1的一个字符。dp[i][j]表示使字符串word1的前i个字符和字符串word2的前j个字符相等的最少操作次数。对于前两个操作，状态转移方程为dp[i][j]=dp[i-1][j]+1和dp[i][j]=dp[i][j-1]+1。对于第三个操作，若两个字符相等，则

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示word1的前i个字符与word2的前j个字符的最长公共子串的长度，dp数组的长度设置为n1+1与n2+1可以自动处理空串的情况。n1-dp[n1][n2]即为word1需要删除的字符个数，n2-dp[n1][n2]即为word2需要删除的字符个数。3. 代码public class Test { public static void main(String[] args

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示s从下标i到末尾的子字符串中t从下标j到末尾的子字符串出现的个数。从后往前转移状态，初始化时，令dp[i][n]=1，即均包含1个空字符串。若两个字符相等，则累加dp[i+1][j+1]，否则，只等于s中前一个字符的dp[i+1][j]。3. 代码public class Test { public static void main(String[] args) {

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示字符串t的下标i之后字母j第一次出现的位置。初始化时，令dp[t.length()][i]均为t.length()，然后从后往前进行状态转移。首先将当前下标之后所有字母第一次出现的位置都更新为后一个下标的结果，即dp[i][j]=dp[i+1][j]，然后更新当前下标上的字母第一次出现的位置为当前下标，即dp[i][c2[i]-‘a’]=i。最后从头开始确定s中每一个字母在t中出现

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示以下标为i的元素结尾的子数组的最大和，维护一个全局变量找出最大的dp[i]。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int maxSubArray(int[] nums) { int n = nums

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示nums1的前i个元素和nums2的前j个元素的最大连线数。初始化dp[i][0]和dp[0][i]时，若某个元素和另一个数组的第一个元素相等，则从该元素开始后面的dp均为1。若nums1[i]=nums2[j]，则dp[i][j]=dp[i-1][j-1]+1；否则，dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])。3. 代码public c

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示text1的前i个字符与text2的前j个字符的最长公共子序列的长度。初始化时，若text1的某一个字符与text2的第一个字符相等，则dp[j][0]-dp[m-1][j]均为1，dp[0][j]-dp[0][n-1]同理。遍历字符串时，若两个字符串的某两个字符相等，则dp[i][j]=dp[i-1][j-1]+1;否则，dp[i][j]取dp[i-1][j]和dp[i][j-1]

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][j]表示nums1的前i个元素和nums2的前j个元素中最长的公共子数组的长度。若nums1[i]==nums2[j]，则dp[i][j]=dp[i-1][j-1]+1，同时更新全局最长的公共子数组的长度。3. 代码public class Test { public static void main(String[] args) { }}class Solutio

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示以下标i结尾的最长连续递增子序列的长度，若nums[i]>nums[i-1]，则dp[i]在前一个的基础上加1，同时更新全局最大长度；否则，dp[i]置为1。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int fi

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示前i个元素的最长递增子序列的长度，计算dp[i]时，由于dp[0]~dp[i-1]已经得到，因此，比较每个元素的值，若nums[i]>nums[j]，则更新dp[i]，最终使其取最大值即可。3. 代码public class Test { public static void main(String[] args) { }}class Solution {

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划只需在计算dp[i][1]时，考虑前一天持有股票而这一天卖出的情况下，减去手续费即可。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int maxProfit(int[] prices, int fee) { int n

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][0]表示第i天持有股票时的最高利润，dp[i][1]表示第i天不持有股票时的最高利润。第i天持有股票的状态要么是由第i-1天持有股票的状态转移而来，要么是由第i-2天不持有股票的状态加上这一天买入股票转移而来。第i天不持有股票的状态要么是由第i-1天不持有股票的状态转移而来，要么是由第i-1天持有股票的状态加上这一天卖出股票转移而来。3. 代码public class Test {

文章目录1. 题目2. 思路(1) 动态规划(2) 动态规划优化3. 代码1. 题目2. 思路(1) 动态规划为每一天定义2k个状态，第0、2、……个状态表示完成第1、2、……次股票买入的最高利润，第1、3、……个状态表示完成第1、2、……次股票卖出的最高利润。第i天的第j个状态由第i-1天转化而来，若计算奇数状态，即卖出股票的最高利润，则要么是第i天不进行任何操作，要么是第i天卖出了股票；若计算偶数状态，即买入股票的最高利润，则要么是第i天不进行任何操作，要么是第i天买入了股票。最终的最高

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][0]表示第i天完成第一次股票买入的最高利润，dp[i][1]表示第i天完成第一次股票卖出的最高利润，dp[i][2]表示第i天完成第二次股票买入的最高利润，dp[i][3]表示第i天完成第二次股票卖出的最高利润。计算dp[i][0]时，可取前一天完成第一次股票买入的最高利润和这一天完成第一次股票买入的最高利润的较大值。计算dp[i][1]时，可取前一天完成第一次股票卖出的最高利润和这一天完

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i][0]表示第i天不持有股票所能得到的最大利润，dp[i][1]表示第i天持有股票所能得到的最大利润，显然，最终的最大利润为dp[n-1][0]。第i天不持有股票的状态要么来自前一天也不持有股票，要么来自前一天持有股票而今天给卖了；第i天持有股票的状态要么来自前一天也持有股票，要么来自前一天不持有股票但是今天买入了。3. 代码public class Test { public s

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划遍历数组，维护当前下标之前的子数组的最小值，若当前元素大于之前的最小值，则更新最大利润；否则，更新最小值。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int maxProfit(int[] prices) { int

文章目录1. 题目2. 思路(1) 递归+动态规划3. 代码1. 题目2. 思路(1) 递归+动态规划为二叉树中的每个结点定义一个状态数组status，status[0]表示盗取该结点的以该结点为根的最高金额，status[1]表示不盗取该结点的以该结点为根的最高金额。利用递归深度优先搜索每个结点，获取每个子结点的状态数组status。对于根结点，status[0]等于该结点的值加上左右子结点的status[1]的值，status[1]等于左右子结点的最高金额之和。3. 代码publ

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划由于第一家和最后一家只能选择一家偷，另一家必然不能偷，因此，可以直接删除第一家或者最后一家，这样就断开了环，分别进行动态规划，取两次中的金额较大的一个即可。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int rob(int[] num

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示打劫前i个房屋获得的最高金额。对于第i个房屋，有两种选择，若实施打劫，则获得的金额为dp[i-2]+nums[i]；若不实施打劫，则获得的金额为dp[i-1]。因此，dp[i]取两者较大的一个即可。3. 代码public class Test { public static void main(String[] args) { }}class Solution {

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示字符串s的前i个字符的子串是否能被字典中的字符串拼接而成。以s="applepenapple"为例，当i=8时，即到达字符n时，发现字典中有以n结尾的pen，将pen的n与s中的n对齐后，若s.substring(5,8)与pen相等，且dp[5]=true，则可判定dp[8]=true。3. 代码import java.util.ArrayList;import java.util

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示和为i的完全平方数的最少数量，则可以枚举[1,根号i]的所有数字，对于数字j来说，dp[i]=dp[i-j*j]+1。对于每一个数字i，都要遍历其所有的[1,根号i]，保证dp[i]是最少数量的。3. 代码public class Test { public static void main(String[] args) { }}class Solution {

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划dp[i]表示凑成金额i所需的最小硬币个数，初始化时，dp[i]=Max，dp[0]=0。注意！容量在外，重量在内。3. 代码import java.util.Arrays;public class Test { public static void main(String[] args) { }}class Solution { public int coinC

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划动态规划数组dp[i]表示爬到第i个台阶的方案数，累加最后一步的所有方案数即可。注意！转化为完全背包问题即为容量在外，物品在内。3. 代码public class Test { public static void main(String[] args) { }}class Solution { public int climbStairs(int n) {

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划动态规划数组dp[i]表示总和为i的组合的个数，初始化时，dp[0]=1。对于总和为i-num的每一种排列，在最后添加num后即可得到总和为i的排列，因此，dp[i]等于所有dp[i-num]之和。3. 代码public class Test { public static void main(String[] args) { }}class Solution { p

文章目录1. 题目2. 思路(1) 动态规划(2) 动态规划优化3. 代码1. 题目2. 思路(1) 动态规划首先确定动态规划数组dp的含义，dp[i][j]表示前i个硬币能够凑出金额j的组合数。由于每个硬币的个数不限，因此，每个硬币凑出金额j时要转移k个状态，且k满足k*coin<=j。(2) 动态规划优化一维动态规划数组dp[i]表示凑出金额j的组合数。对于面额为coin的硬币，当coin≤i≤amount时，如果存在一种硬币组合的金额之和等于i−coin，则在该硬币组合

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划定义三维动态规划数组dp，dp[i][j][k]表示在前i个字符串中，最多有j个0、k个1的情况下，所能包含的最大字符串数量。初始化时，dp[0][j][k]=0。若不选第i个字符串，则dp[i][j][k]=dp[i-1][j][k]；若选第i个字符串，则dp[i][j][k]=dp[i-1][j-zero][k-one]+1。3. 代码public class Test { publi

文章目录1. 题目2. 思路(1) 动态规划(2) 动态规划优化3. 代码1. 题目2. 思路(1) 动态规划这道题可以转化为0/1背包问题，由于总和sum和目标和target已经确定，因此，要求的即是从数组中挑出和为(sum-target)/2的方案数。首先确定动态规划数组的含义，dp[i][j]表示从下标为[0,i)的元素中挑出和为j的方案数，初始化时令dp[0][0]=1即可。若nums[i-1]>j，则必然不取nums[i-1]，因此，dp[i][j]=dp[i-1][j]；否

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划将所有石头分成两堆，一堆的重量为target，则另一堆的重量为sum-target，要使最后一块石头的重量最小，就要使两堆石头的重量尽可能地接近，即target尽可能地趋近于sum/2。因此，该问题可以转化为如何挑出重量尽可能接近sum/2的石头子集。动态规划数组dp[j]表示容量为j的背包所能装的最大重量，对于每一块石头来说，均有两种状态，要么装，要么不装。对于石头i，若不装进容量为j的背包，则该

文章目录1. 题目2. 思路(1) 动态规划(2) 动态规划优化3. 代码1. 题目2. 思路(1) 动态规划这是经典的0/1背包问题，可以将问题转化为能否从数组中挑出一些元素使其和正好等于所有元素和的一半。若元素个数小于2，则返回false；若所有元素和为奇数，则返回false；若最大元素大于所有元素和的一半，则其他元素和必然小于所有元素和的一半，返回false。动态规划数组dp[i][j]表示从前i个元素中是否能挑出和正好等于j的子集，对于第i个元素，有两种状态，要么不取，要么取。若不

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划设i个结点构成的二叉搜索树的个数为f(i)，则以1为根结点时，其左右子树的结点数分别为0和i-1；以2为根结点时，其左右子树的结点数分别为1和i-2；以j+1为根结点时，其左右子树的结点数分别为j和i-j-1。因此，转移方程为f(i)=f(0)*f(i-1)+f(1)*f(i-2)+…+f(i-1)*f(0)。注意！由于是左右子树的二叉搜索树个数相乘，因此，初始化时f(0)=1。3. 代码publ

文章目录1. 题目2. 思路(1) 数学法(2) 动态规划3. 代码1. 题目2. 思路(1) 数学法根据数学规律，将整数尽量拆分成3时的乘积最大，拆分的结果有三种：余数为1：将最后一个3与1合并成4，然后连乘。余数为2：正常连乘；余数为0：正常连乘。(2) 动态规划对于整数i，可以拆分成j和i-j，其局部最大乘积=max(j*(i-j),j*dp[i-j])，因此，从1遍历到i-1，即可得到整数i的全局最大乘积dp[i]。3. 代码public class Test

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划若网格[i,j]处有障碍，则到达网格[i,j]的路径数为0，否则，到达网格[i,j]的路径数为f(i,j)=f(i-1,j)+f(i,j-1)。初始化时，对于最左边和最上面的网格，若到达前一个网格的路径数为0，则之后网格的路径数均为0。3. 代码public class Test { public static void main(String[] args) { }}cl

文章目录1. 题目2. 思路(1) 动态规划3. 代码1. 题目2. 思路(1) 动态规划对于方格[i,j]来说，要么从上面的方格[i-1,j]到达它，要么从左边的方格[i,j-1]到达它，因此，到达方格[i,j]的路径数为f(i,j)=f(i-1,j)+f(i,j-1)。初始化时，由于最左边和最上面的方格只有一条路径可到达，因此全部设置为1即可。3. 代码public class Test { public static void main(String[] args) {