Leeli9316的博客

①确定状态：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 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..

方法：动态规划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 maxProfit(int[] prices, int fee) { int profit = 0; //buy表示在最大化收益的前提下，拥有一支股票的最低买入价格 int buy = prices[0] + fee; for (int i = 1; i < prices.length; i++) { //如果当前的股票价格加...

方法：贪心class Solution { public List<Integer> partitionLabels(String s) { //记录每个字母出现的最后位置 int[] lastPos = new int[26]; for (int i = 0; i < s.length(); i++) { lastPos[s.charAt(i) - 'a'] = i; } ..

方法：贪心class Solution { public int[][] merge(int[][] intervals) { //按区间左端点升序排列，如(1, 4)和(2, 3) Arrays.sort(intervals, new Comparator<int[]>() { public int compare(int[] interval1, int[] interval2) { ...

方法：贪心class Solution { public int eraseOverlapIntervals(int[][] intervals) { //按右端点升序排列 Arrays.sort(intervals, (o1, o2) -> o1[1] - o2[1]); int ans = 0; int pos = intervals[0][1]; for (int i = 1; i < int..

方法：贪心class Solution { public int findMinArrowShots(int[][] points) { //对[[-2147483646,-2147483645],[2147483646,2147483647]]来说 //用Arrays.sort(points, (o1, o2) -> o1[1] - o2[1]);进行排序，相减会溢出 //应该按以下写法对Xend升序排列 Array...

思路：按身高降序排列(若h相同，按k升序排列)如果按照排完序后的顺序，依次将每个人放入队列中，那么当放入第 i 个人时：可以发现，后面的人既然不会对第 i个人造成影响，那么可以采用「插空」的方法，依次给每一个人在当前的队列中选择一个插入的位置。也就是说，当放入第 i个人时，只需要将其插入队列中，使得前面恰好有 k个人即可。class Solution { public int[][] reconstructQueue(int[][] people) { ...

方法：贪心class Solution { public int monotoneIncreasingDigits(int n) { if (n < 10) return n; char[] number = String.valueOf(n).toCharArray(); //记录赋值9开始的位置 int start = number.length; for (int i = number.le..

方法：计数class Solution { public boolean lemonadeChange(int[] bills) { int[] counter = new int[21]; for (int bill : bills) { counter[bill]++; if (bill == 10) { if (counter[5] < 1) return fals...

方法：贪心class Solution { public int candy(int[] ratings) { int n = ratings.length; int[] candies = new int[n]; Arrays.fill(candies, 1); //从前往后遍历，若当前评分大于前一个评分，多分发一个糖果 for (int i = 1; i < n; i++) { ...

方法一：暴力求解(超时)class Solution { public int canCompleteCircuit(int[] gas, int[] cost) { int n = gas.length; for (int i = 0; i < n; i++) { //剩余油量 int remainder = gas[i] - cost[i]; //下一个起始位置 ..

方法一：优先队列(小顶堆)class Solution { public int largestSumAfterKNegations(int[] nums, int k) { PriorityQueue<Integer> pq = new PriorityQueue<>(); for (int num : nums) { pq.offer(num); } for (int i =..

方法：贪心class Solution { //贪心思路：局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一 // 整体最优：一步尽可能多走，从而达到最小步数 public int jump(int[] nums) { int n = nums.length; if (n <= 1) return 0; int ans = 0; //当前的最远距离 int c...

方法：贪心class Solution { public boolean canJump(int[] nums) { int n = nums.length; if (n <= 1) return true; //前n-1个元素能到达的最远距离 int maxDistance = 0; for (int i = 0; i <= maxDistance; i++) { //..

方法一：贪心class Solution { public int maxProfit(int[] prices) { int ans = 0; for (int i = 1; i < prices.length; i++) { if (prices[i] > prices[i - 1]) { ans += prices[i] - prices[i - 1]; }..

方法：贪心思路——维护最低买入价格，最高卖出价格减去最低买入价格即为最大利润class Solution { public int maxProfit(int[] prices) { int ans = 0; int minPrice = prices[0]; for (int i = 1; i < prices.length; i++) { if (prices[i] > minPrice) { ..

方法：贪心class Solution { public int maxSubArray(int[] nums) { int n = nums.length; if (n == 1) return nums[0]; int ans = Integer.MIN_VALUE; int sum = 0; //贪心的地方：如果 -2 1 在一起，计算起点的时候，一定是从1开始计算， //因为负数只会拉...

方法：贪心class Solution { public int wiggleMaxLength(int[] nums) { int n = nums.length; if (n < 2) return n; int preDif = 0; int ans = 1; for (int i = 1; i < n; i++) { //当前差值 int ..

方法：贪心(小饼干满足小胃口)class Solution { public int findContentChildren(int[] g, int[] s) { int ans = 0; Arrays.sort(g); Arrays.sort(s); int i = 0, j = 0; while (i < g.length && j < s.length) { ..

方法：回溯class Solution { List<List<Integer>> ans = new ArrayList<>(); List<Integer> path = new ArrayList<>(); public List<List<Integer>> subsetsWithDup(int[] nums) { Arrays.sort(nums); ..