一、不相交的线
题目：
在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。
现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：
-
nums1[i] == nums2[j] - 且绘制的直线不与任何其他连线（非水平线）相交。
请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。
以这种方法绘制线条，并返回可以绘制的最大连线数。
示例 1：
输入：nums1 = [1,4,2], nums2 = [1,2,4] 输出：2 解释：可以画出两条不交叉的线，如上图所示。 但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。
示例 2：
输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2] 输出：3
示例 3：
输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1] 输出：2
思路：
在经过审题之后，为了使线不相交，本题其实就转化为了最长公共子序列的问题，只不过加上了一层不可相交线的外衣，其本质与最长公共子序列并无区别
代码：
public int maxUncrossedLines(int[] nums1, int[] nums2) {
// 获取两个数组的长度
int n1 = nums1.length;
int n2 = nums2.length;
// 创建一个二维数组dp，dp[i][j]表示nums1前i个元素和nums2前j个元素的最长公共子序列的长度
int[][] dp = new int[n1 + 1][n2 + 1];
// 遍历dp数组填充数据
for (int i = 1; i <= n1; i++) {
for (int j = 1; j <= n2; j++) {
// 如果nums1的第i-1个元素等于nums2的第j-1个元素
if (nums1[i - 1] == nums2[j - 1]) {
// 更新dp[i][j]，表示在dp[i-1][j-1]的基础上增加1
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
// 否则dp[i][j]取dp[i-1][j]和dp[i][j-1]的最大值
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
// 返回最大不相交线条的数量，即最长公共子序列的长度
return dp[n1][n2];
}
n1和n2分别表示nums1和nums2的长度。- 创建一个二维数组
dp，大小为(n1 + 1) x (n2 + 1)。dp[i][j]用于存储nums1的前i个元素和nums2的前j个元素的最长公共子序列长度。数组大小加1是为了处理边界情况（即处理空数组）。 - 外层和内层循环遍历
dp数组，i和j分别表示nums1和nums2的索引。 - 当
nums1[i - 1]等于nums2[j - 1]时，dp[i][j]更新为dp[i - 1][j - 1] + 1，表示在dp[i-1][j-1]的基础上增加 1。 - 否则，
dp[i][j]取dp[i - 1][j]和dp[i][j - 1]的最大值，表示在nums1或nums2中剔除当前元素后的最长公共子序列长度。 - 返回
dp数组中的最后一个元素dp[n1][n2]，即nums1和nums2的最长公共子序列的长度。
二、最大子数组和
题目：
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组是数组中的一个连续部分。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1] 输出：1
示例 3：
输入：nums = [5,4,-1,7,8] 输出：23
思路：
首先明确dp数组的含义，本题中dp数组含义为以 i 为尾的nums[i]最大子数组和为dp[i]，定义初始结结果为第一个数的值，此后遍历数组，如果相加的值大于初始值，则更换为相加后的值，否则将初始值更替为当前遍历的值，因此递推关系式为
dp[i] = max(dp[i-1] + nums[i]，dp[i])
代码：
public int maxSubArray(int[] nums) {
// 如果输入数组为空，返回0
if (nums.length == 0)
return 0;
// 创建一个dp数组用于存储到当前位置的最大子数组和
int[] dp = new int[nums.length];
// 初始化第一个元素的最大子数组和
dp[0] = nums[0];
// 初始化结果为第一个元素
int res = nums[0];
// 遍历数组，从第二个元素开始
for (int i = 1; i < nums.length; i++) {
// dp[i]表示以nums[i]结尾的最大子数组和
// 可以选择将当前元素加到前一个子数组，或者从当前元素重新开始
dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
// 更新结果，保留当前最大的子数组和
res = Math.max(res, dp[i]);
}
// 返回找到的最大子数组和
return res;
}
- 首先检查输入数组是否为空。如果数组为空，直接返回 0。
- 创建一个
dp数组，用于存储以每个元素结尾的最大子数组和。 - 将
dp[0]初始化为nums[0]，因为以第一个元素结尾的子数组只有它自己。 - 另外，定义一个变量
res来存储当前找到的最大子数组和，初始值也是nums[0]。 - 从第二个元素开始遍历数组：
- 然后使用
res = Math.max(res, dp[i])更新当前的最大子数组和。 - 使用
Math.max(dp[i - 1] + nums[i], nums[i])判断两种情况：- 第一种情况是将当前元素
nums[i]加到之前的最大子数组和dp[i - 1]上； - 第二种情况是从当前元素
nums[i]开始新的子数组（即忽略之前的任何元素）。
- 第一种情况是将当前元素
dp[i]表示以nums[i]结尾的最大子数组和。
- 然后使用
- 遍历完数组后，返回找到的最大子数组和
res。
三、判断子序列
题目：
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
示例 1：
输入：s = "abc", t = "ahbgdc" 输出：true
示例 2：
输入：s = "axc", t = "ahbgdc" 输出：false
动归解法
思路：
采用动态规划的思路解决，此时的dp数组的含义为以i-1为结尾的字符串s和以j-1为结尾的字符串t的子序列长度为dp[i][j]，对于其中相同的元素，递推式为
dp[i][j] = dp[i-1][j-1] + 1
否则应该保留之前的值，子序列长度不变，因此递推式为
dp[i][j] = dp[i][j-1]
代码：
public boolean isSubsequence(String s, String t) {
// 获取字符串 s 和 t 的长度
int len1 = s.length();
int len2 = t.length();
// 创建一个二维数组 dp，dp[i][j] 代表 s 的前 i 个字符是否是 t 的前 j 个字符的子序列
int[][] dp = new int[len1 + 1][len2 + 1];
// 填充 dp 数组
for (int i = 1; i <= len1; i++) { // 遍历 s 的每个字符
for (int j = 1; j <= len2; j++) { // 遍历 t 的每个字符
if (s.charAt(i - 1) == t.charAt(j - 1)) { // 如果 s 的当前字符等于 t 的当前字符
dp[i][j] = dp[i - 1][j - 1] + 1; // s 的前 i 个字符中的第 i 个字符匹配上了 t 的第 j 个字符
} else {
dp[i][j] = dp[i][j - 1]; // 否则，当前字符不匹配，保留之前的值
}
}
}
// 最终检查是否 s 的所有字符都是 t 的子序列中的字符
return dp[len1][len2] == len1; // 如果 dp[len1][len2] 等于 len1，说明 s 是 t 的子序列
}
-
len1和len2分别表示字符串s和t的长度。dp是一个二维数组，其中dp[i][j]代表s的前i个字符是否可以在t的前j个字符中找到作为子序列。
-
动态规划填表：
- 外层循环遍历
s的每个字符（从i = 1到len1），内层循环遍历t的每个字符（从j = 1到len2）。 - 如果
s的第i个字符（s.charAt(i - 1)）等于t的第j个字符（t.charAt(j - 1)），则dp[i][j]的值等于dp[i - 1][j - 1] + 1。这表示如果前i-1个字符是t的前j-1个字符的子序列，那么当前字符也匹配，子序列的长度增加了 1。 - 如果当前字符不匹配，则
dp[i][j]等于dp[i][j - 1]，表示子序列长度不变，继续保持之前的值。
- 外层循环遍历
-
判断结果：
- 最后返回
dp[len1][len2] == len1，检查s是否能在t的全部字符中作为子序列。如果dp[len1][len2]的值等于len1，说明所有的字符都找到了匹配，s是t的子序列。
- 最后返回
双指针解法
public boolean isSubsequence(String s, String t) {
// 获取字符串 s 和 t 的长度
int n1 = s.length();
int n2 = t.length();
// 将字符串 s 和 t 转换为字符数组
char[] s1 = s.toCharArray();
char[] t1 = t.toCharArray();
// 初始化两个指针 i 和 j，用于遍历 s 和 t
int i = 0, j = 0;
// 使用 while 循环同时遍历 s 和 t，直到其中一个字符串被遍历完
while (i < n1 && j < n2) {
// 如果 s 的当前字符与 t 的当前字符相等
if (s1[i] == t1[j]) {
i++; // 移动 s 的指针到下一个字符
}
j++; // 始终移动 t 的指针到下一个字符
}
// 如果 i 等于 n1，说明 s 的所有字符都在 t 中找到了匹配
return i == n1;
}
-
获取长度：
int n1 = s.length();：获取字符串s的长度。int n2 = t.length();：获取字符串t的长度。
-
转换为字符数组：
char[] s1 = s.toCharArray();：将字符串s转换为字符数组s1。char[] t1 = t.toCharArray();：将字符串t转换为字符数组t1。
-
初始化指针：
int i = 0, j = 0;：初始化两个指针i和j，分别用来跟踪s和t中当前的字符位置。i用于指向s的字符，j用于指向t的字符。
-
遍历字符串：
while (i < n1 && j < n2)：当i小于n1且j小于n2时，继续执行循环，这意味着仍然有字符未被检查。- 在循环中，首先检查
s和t当前指针所指的字符是否相等：if (s1[i] == t1[j])：如果s的当前字符与t的当前字符相等，则说明找到了一个匹配。i++;：移动i指针到下一个字符，以便检查s中的下一个字符。
j++;：无论字符是否匹配，都将j指针移动到t中的下一个字符，继续遍历t。
-
结果判断：
return i == n1;：循环结束后，检查i是否等于n1。如果相等，说明字符串s中的所有字符都在t中找到了匹配，返回true；否则返回false。
今天的学习就到这里
