leecode更新

Leecode/src/main/java/com/markilue/leecode/dynamic/second/T30_LongestCommonSubsequence.java

@@ -0,0 +1,64 @@
+package com.markilue.leecode.dynamic.second;
+
+import org.junit.Test;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.dynamic.second
+ *@Author: markilue
+ *@CreateTime: 2023-02-23  10:12
+ *@Description:
+ * TODO  力扣1143  最长公共子序列:
+ *  给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。
+ *  一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
+ *  例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
+ *  两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
+ *@Version: 1.0
+ */
+public class T30_LongestCommonSubsequence {
+
+    @Test
+    public void test(){
+        String text1 = "abcde", text2 = "ace";
+        System.out.println(longestCommonSubsequence(text2,text1));
+    }
+
+    /**
+     * 思路:不同之处在于子序列，所以可以删除
+     *  TODO DP五部曲:
+     *      1.dp定义: dp[i][j]表示从text1[0-i]和text2[0-j]的最长子序列长度
+     *      2.dp状态转移方程:
+     *                      1.if(text1[i]==text2[j])  dp[i][j]=dp[i-1][j-1]+1
+     *                      2.else  dp[i][j]=max(dp[i-1][j],dp[i][j-1])
+     *      3.dp初始化:考虑到初始化设置为text[i-1]==text[j-1]  则dp[i][0]全为0
+     *      4.dp遍历顺序:
+     *      5.dp举例推导:以 text1 = "abcde", text2 = "ace" 为例:
+     *                      text1 [ 0  a  b  c  d  e]
+     *                      0       0  0  0  0  0  0
+     *                      a       0  1  1  1  1  1
+     *                      c       0  1  1  2  2  2
+     *                      e       0  1  1  2  2  3
+     *        速度击败24.9%  内存击败33.8%   16ms
+     * @param text1
+     * @param text2
+     * @return
+     */
+    public int longestCommonSubsequence(String text1, String text2) {
+
+        if (text1.length() < text2.length()) {
+            longestCommonSubsequence(text2, text1);
+        }
+
+        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
+
+        for (int i = 1; i <= text1.length(); i++) {
+            for (int j = 1; j <= text2.length(); j++) {
+                if (text1.charAt(i-1) == text2.charAt(j-1)) dp[i][j] = dp[i - 1][j - 1] + 1;
+                else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+
+        return dp[text1.length()][text2.length()];
+
+    }
+}

Leecode/src/main/java/com/markilue/leecode/dynamic/second/T31_MaxUncrossedLines.java

@@ -0,0 +1,44 @@
+package com.markilue.leecode.dynamic.second;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.dynamic.second
+ *@Author: markilue
+ *@CreateTime: 2023-02-23  10:43
+ *@Description:
+ * TODO  力扣1035  不相交的线:
+ *  在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。
+ *  现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：
+ *    nums1[i] == nums2[j]
+ *   且绘制的直线不与任何其他连线（非水平线）相交。
+ *  请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。
+ *  以这种方法绘制线条，并返回可以绘制的最大连线数。
+ *@Version: 1.0
+ */
+public class T31_MaxUncrossedLines {
+
+    /**
+     * 思路:本质上也是一个子序列的题，因为这题要求上就是  可以删除不能过
+     * 加上最上面的if之后 速度击败99.16%  内存击败49.86%  4ms
+     * @param nums1
+     * @param nums2
+     * @return
+     */
+    public int maxUncrossedLines(int[] nums1, int[] nums2) {
+        if(nums1.length<nums2.length){
+            return maxUncrossedLines(nums2,nums1);
+        }
+
+        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
+
+        for (int i = 1; i < dp.length; i++) {
+            for (int j = 1; j < dp[0].length; j++) {
+                if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
+                else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+
+        return dp[nums1.length][nums2.length];
+
+    }
+}

Leecode/src/main/java/com/markilue/leecode/dynamic/second/T32_MaxSubArray.java

@@ -0,0 +1,98 @@
+package com.markilue.leecode.dynamic.second;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.dynamic.second
+ *@Author: markilue
+ *@CreateTime: 2023-02-23  10:59
+ *@Description:
+ * TODO  力扣53题  最大子数组和:
+ *  给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
+ *  子数组 是数组中的一个连续部分。
+ *@Version: 1.0
+ */
+public class T32_MaxSubArray {
+
+
+    /**
+     * 思路:注意子数组，所以不要当前数，就需要抛弃前面的所有数
+     *  TODO  DP五部曲:
+     *      1.dp定义: dp[i][0]表示不要nums[i]的最大和  dp[i][1]表示要nums[i]的最大和
+     *      2.dp状态转移方程:
+     *                      1.dp[i][0]  不要当前的数  分为  要之前的  和  都不要
+     *                          dp[i][0]=max(dp[i-1][1],0)
+     *                      2.dp[i-1][1]  要当前的数  分为  不要之前的  和  要之前的
+     *                          dp[i][1]=max(nums[i],dp[i-1][1]+nums[1])
+     *      3.dp初始化:dp[0][0]=max(nums[0],0);dp[0][1]=nums[0]
+     *      4.dp遍历顺序:
+     *      5.dp举例推导: 以nums = [-2,1,-3,4,-1,2,1,-5,4]为例
+     *                  [-2  1  -3  4  -1  2  1  -5  4]
+     *             i=0   0   0   1  0   4  3  5  6   1
+     *             i=1  -2   1  -2  4   3  5  6  1   5
+     *      速度击败40.89%  内存击败46.24%
+     * @param nums
+     * @return
+     */
+    public int maxSubArray(int[] nums) {
+
+
+        int[] dp = new int[nums.length];
+
+        dp[0] = nums[0];
+        int max = nums[0];
+
+        for (int i = 1; i < dp.length; i++) {
+            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
+            if (max < dp[i]) max = dp[i]; //子数组的题似乎都是在过程中寻找最值
+        }
+
+        return max;
+
+    }
+
+
+    /**
+     * 滚动数组优化
+     * 速度击败100%  内存击败63.24%
+     * @param nums
+     * @return
+     */
+    public int maxSubArray1(int[] nums) {
+
+        int dp0 = nums[0];
+        int max = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            dp0 = Math.max(nums[i], dp0 + nums[i]);
+            if (max < dp0) max = dp0; //子数组的题似乎都是在过程中寻找最值
+        }
+
+        return max;
+
+    }
+
+
+    /**
+     * 贪心
+     * 速度击败100%  内存击败23.49%  1ms
+     * @param nums
+     * @return
+     */
+    public int maxSubArray2(int[] nums) {
+
+        int max = nums[0];
+        int curValue = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            if (curValue < 0) {
+                curValue = 0;
+            }
+            curValue += nums[i];
+            if (max < curValue) max = curValue;
+        }
+
+
+        return max;
+
+    }
+}

Leecode/src/main/java/com/markilue/leecode/dynamic/second/T33_IsSubsequence.java

@@ -0,0 +1,99 @@
+package com.markilue.leecode.dynamic.second;
+
+import org.junit.Test;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.dynamic.second
+ *@Author: markilue
+ *@CreateTime: 2023-02-23  11:23
+ *@Description:
+ * TODO  力扣392题  判断子序列:
+ *  给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
+ *  字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
+ *  进阶：
+ *   如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+ *@Version: 1.0
+ */
+public class T33_IsSubsequence {
+
+    @Test
+    public void test(){
+        String s = "abc", t = "ahbgdc";
+        System.out.println(isSubsequence1(s,t));
+    }
+
+    /**
+     * 思路:判断子序列，实际上还是子序列的题  递推公式类似
+     *      TODO DP五部曲:
+     *          1.dp定义:  dp[i][j]表示使用t[0-i]是否是s[0-j]的父序列
+     *          2.dp状态转移方程:
+     *                          if(t[i]==s[j]) dp[i][j]=dp[i-1][j-1]  这两个相同就看看子序列是不是
+     *                          else   dp[i][j]=dp[i-1][j] 去除掉之后是不是  需要注意的是，这里没有dp[i][j-1]
+     *          3.dp初始化:为了递推方便  设置为t[i-1]=s[j-1]  则dp[i][0]=true  dp[0][j]=false
+     *          4.dp遍历顺序:
+     *          5.dp举例推导:
+     *          速度击败18.94%  内存击败10.33%  5ms
+     * @param s
+     * @param t
+     * @return
+     */
+    public boolean isSubsequence(String s, String t) {
+
+        boolean[][] dp = new boolean[t.length() + 1][s.length() + 1];
+        for (int i = 0; i < dp.length; i++) {
+            dp[i][0] = true;
+        }
+        for (int i = 1; i < dp.length; i++) {
+            for (int j = 1; j < dp[0].length; j++) {
+                if (t.charAt(i - 1) == s.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1];
+                else dp[i][j] = dp[i - 1][j];
+            }
+        }
+
+        return dp[t.length()][s.length()];
+    }
+
+
+    /**
+     * 一维dp优化
+     * 速度击败34.1%  内存击败68.5%
+     * @param s
+     * @param t
+     * @return
+     */
+    public boolean isSubsequence1(String s, String t) {
+
+        boolean[] dp = new boolean[s.length() + 1];
+        for (int i = 0; i < dp.length; i++) {
+            dp[0] = true;
+        }
+        for (int i = 1; i <= t.length(); i++) {
+            for (int j = s.length(); j >0; j--) {
+                if (t.charAt(i - 1) == s.charAt(j - 1)) dp[j] = dp[j - 1];
+            }
+        }
+
+        return dp[s.length()];
+    }
+
+
+    /**
+     * 双指针法：时间复杂度度O(M+N)
+     * 速度击败88%  内存击败52.96%  1ms
+     * @param s
+     * @param t
+     * @return
+     */
+    public boolean isSubsequence2(String s, String t) {
+        int n = s.length(), m = t.length();
+        int i = 0, j = 0;
+        while (i < n && j < m) {
+            if (s.charAt(i) == t.charAt(j)) {
+                i++;
+            }
+            j++;
+        }
+        return i == n;
+    }
+}

Leecode/src/main/java/com/markilue/leecode/dynamic/second/T34_NumDistinct.java

@@ -0,0 +1,21 @@
+package com.markilue.leecode.dynamic.second;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.dynamic.second
+ *@Author: markilue
+ *@CreateTime: 2023-02-23  11:52
+ *@Description:
+ * TODO  力扣115题  不同的子序列:
+ *  给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。
+ *  字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。
+ *  （例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）
+ *  题目数据保证答案符合 32 位带符号整数范围。
+ *@Version: 1.0
+ */
+public class T34_NumDistinct {
+
+    public int numDistinct(String s, String t) {
+
+    }
+}