做网站的是不是程序员网站的结构与布局优化

（1）

思路

1. 动态规划定义：定义一个二维数组 dp，其中 dp[i][j] 表示以 nums1[i] 和 nums2[j] 开头的最长公共子数组的长度。
2. 状态转移方程：
   • 如果 nums1[i] 等于 nums2[j]，则 dp[i][j] 等于 dp[i+1][j+1] + 1。
   • 否则，dp[i][j] 为 0。
3. 遍历方向：由于每个状态 dp[i][j] 依赖于 dp[i+1][j+1]，我们需要从后向前遍历数组，即从 i = n-1 到 0，从 j = m-1 到 0。
4. 结果记录：在遍历过程中，记录遇到的最大 dp[i][j] 值，即为最长公共子数组的长度。

代码

class Solution {public int findLength(int[] nums1, int[] nums2) {int n = nums1.length, m = nums2.length;int[][] dp = new int[n + 1][m + 1];int ans = 0;for (int i = n - 1; i >= 0; i--) {for (int j = m - 1; j >= 0; j--) {dp[i][j] = nums1[i] == nums2[j] ? dp[i + 1][j + 1] + 1 : 0;ans = Math.max(ans, dp[i][j]);}}return ans;}
}

解释

• 初始化：创建一个 (n+1) x (m+1) 的二维数组 dp，其中 dp[n][j] 和 dp[i][m] 初始化为 0，用于处理边界情况。
• 状态转移：遍历每个可能的起始位置 (i, j)，如果当前元素相等，则更新 dp[i][j] 为后续公共子数组长度加 1，否则为 0。
• 结果更新：在每次更新 dp[i][j] 后，检查是否为当前最长的公共子数组长度，并更新结果 ans。

dp[i][j]=nums1[i]==nums2[j]?dp[i+1][j+1]+1:0;

这段代码实现了一个经典的动态规划解法，用于计算两个序列的最长公共子串（Longest Common Substring）的长度。

• 状态定义：dp[i][j] 表示以 nums1[i] 和 nums2[j] 开头的最长公共子串的长度。
• 状态转移：
  • 如果 nums1[i] 等于 nums2[j]，则 dp[i][j] 等于 dp[i+1][j+1] + 1。
  • 否则，dp[i][j] 为 0（因为当前字符不匹配，无法构成公共子串）。
• 结果：遍历所有可能的起始位置 (i, j)，取最大值即为最长公共子串的长度。

dp[i+1][j+1] 的使用与状态转移的方向有关。这里采用的是从后向前的遍历方式，因此当前状态 dp[i][j] 需要依赖于后续状态 dp[i+1][j+1]。

实例说明：

假设 nums1 = [1, 2, 3]，nums2 = [2, 3, 4]，公共子串是 [2, 3]。
动态规划数组 dp 的填充过程如下：

i\j	0	1	2
0	0	0	0
1	2	0	0	← dp[1][0] = dp[2][1] + 1 = 1 + 1 = 2
2	0	1	0	← dp[2][1] = dp[3][2] + 1 = 0 + 1 = 1

• 当 i=1, j=0 时，nums1[1] == nums2[0] == 2，因此 dp[1][0] 等于 dp[2][1] + 1。
  • dp[2][1] 表示以 nums1[2] 和 nums2[1] 开头的最长公共子串长度（即 3 和 3，长度为 1）。
  • 因此，dp[1][0] = 1 + 1 = 2，对应公共子串 [2, 3]。

为什么不是 i-1？

如果使用 dp[i-1][j-1]，则状态定义会变为以 nums1[i-1] 和 nums2[j-1] 结尾的最长公共子串，此时需要从前向后遍历（i 和 j 从小到大递增）

def longest_common_substring(nums1, nums2):m, n = len(nums1), len(nums2)dp = [[0] * (n + 1) for _ in range(m + 1)]max_len = 0for i in range(1, m + 1):for j in range(1, n + 1):if nums1[i-1] == nums2[j-1]:  # 注意索引调整dp[i][j] = dp[i-1][j-1] + 1  # 依赖前一个状态max_len = max(max_len, dp[i][j])return max_len

（2）

思路和算法

1. 排序：首先对单词列表进行排序，排序规则为先按长度升序排列，如果长度相同则按字典序降序排列。这样可以确保我们在遍历过程中先处理较短的单词，并且在长度相同时优先考虑字典序较小的单词。
2. 哈希集合：使用一个哈希集合来存储所有可以由其他单词逐步构建的单词。初始时，集合中只包含空字符串。
3. 遍历检查：遍历排序后的单词列表，对于每个单词，检查它去掉最后一个字母后的子串是否存在于哈希集合中。如果存在，则将当前单词加入哈希集合，并更新最长单词的结果。

代码

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;class Solution {public String longestWord(String[] words) {// 先按长度升序，长度相同按字典序降序Arrays.sort(words, (a, b) -> {if (a.length() != b.length()) {return a.length() - b.length();} else {return b.compareTo(a);}});Set<String> set = new HashSet<>();set.add("");String longest = "";for (String word : words) {String prefix = word.substring(0, word.length() - 1);if (set.contains(prefix)) {set.add(word);longest = word;}}return longest;}
}

代码解释

1. 排序：使用 Arrays.sort 对单词列表进行自定义排序，确保较短的单词排在前面，长度相同的单词按字典序降序排列。
2. 哈希集合初始化：创建一个哈希集合 set，并添加空字符串作为初始元素，因为空字符串是所有单词的基础。
3. 遍历检查：遍历排序后的单词列表，对于每个单词，提取其前缀（即去掉最后一个字母的子串），检查该前缀是否存在于哈希集合中。如果存在，则将当前单词添加到集合中，并更新最长单词为当前单词。

自定义排序

Arrays.sort(words, (a, b) -> {if (a.length() != b.length()) {return a.length() - b.length();} else {return b.compareTo(a);}});

使用了 Lambda 表达式定义排序规则。排序规则解析

1. 按长度升序：如果两个字符串长度不同，较短的字符串排在前面。
2. 按字典序降序：如果两个字符串长度相同，字典序较大的字符串排在前面。

具体来说：

• a.length() - b.length()：当a比b短时返回负数，a排在b前；反之则b排在a前。
• b.compareTo(a)：当b的字典序比a大时返回正数，b排在a前（即字典序降序）。

考虑示例输入：["a", "ab", "abc", "abd"]
排序后顺序为：["a", "ab", "abd", "abc"]（长度相同的abc和abd按字典序降序排列）。
当遍历到"abc"时，由于"ab"已存在于集合中，"abc"会被加入结果；而"abd"虽然也符合条件，但由于排在后面，不会覆盖"abc"。