1、最长连续序列
128. 最长连续序列
给定一个未排序的整数数组，找出最长连续序列的长度。
要求算法的时间复杂度为 O(n)。
示例:
输入: [100, 4, 200, 1, 3, 2]
输出: 4
解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
class Solution {
Set<Integer> set = new HashSet<>();
int res = 0;
public int longestConsecutive(int[] nums) {
for (int num : nums) {
set.add(num);
}
for (int num : nums) {
int cur;
int maxLen = 1;
if (!set.contains(num - 1)) {
cur = num;
while (set.contains(cur + 1)) {
cur++;
maxLen++;
}
res = Math.max(res, maxLen);
}
}
return res;
}
}
2、无重复字符的最长子串
无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
import java.util.HashMap;
import java.util.Map;
class Solution {
Map<Character, Integer> map = new HashMap<>();
public int lengthOfLongestSubstring(String s) {
int start = 0;
int res = 0;
for (int end = 0; end < s.length(); end++) {
if (map.containsKey(s.charAt(end))) {
start = Math.max(start, map.get(s.charAt(end)) + 1);
}
map.put(s.charAt(end), end);
res = Math.max(res, end - start + 1);
}
return res;
}
}
3、最长公共子序列
1143. 最长公共子序列
给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
若这两个字符串没有公共子序列，则返回 0。
示例 1:
输入：text1 = "abcde", text2 = "ace"
输出：3
解释：最长公共子序列是 "ace"，它的长度为 3。
示例 2:
输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc"，它的长度为 3。
示例 3:
输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0。
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
int[][] dp = new int[text1.length() + 1][text2.length() + 1];
dp[0][0] = 0;
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()];
}
}
4、最长回文子串
最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：
输入: "cbbd"
输出: "bb"
class Solution {
public String longestPalindrome(String s) {
if(s == null || s.length() == 0)
return "";
boolean[][] dp = new boolean[s.length()][s.length()];
for (int i = 0; i < s.length(); i++) {
dp[i][i] = true;
}
int maxLen = 1;
int start = 0;
for (int j = 0; j < s.length(); j++) {
for (int i = 0; i < j; i++) {
if (s.charAt(i) != s.charAt(j))
dp[i][j] = false;
else {
if ((j - i) < 3)
dp[i][j] = true;
else
dp[i][j] = dp[i + 1][j - 1];
}
if (dp[i][j]) {
int curLen = j - i + 1;
if (curLen > maxLen) {
maxLen = curLen;
start = i;
}
}
}
}
s = s.substring(start, start + maxLen);
return s;
}
}
5、回文字符串个数
647. 回文子串
给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被计为是不同的子串。
示例 1:
输入: "abc"
输出: 3
解释: 三个回文子串: "a", "b", "c".
示例 2:
输入: "aaa"
输出: 6
说明: 6个回文子串: "a", "a", "a", "aa", "aa", "aaa".
class Solution {
int res = 0;
public int countSubstrings(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
for (int i = 0; i < s.length(); i++) {
dp[i][i] = true;
}
for (int j = 0; j < s.length(); j++) {
for (int i = 0; i <= j; i++) {
if (s.charAt(i) != s.charAt(j)) {
dp[i][j] = false;
} else {
if ((j - i) < 3) {
dp[i][j] = true;
} else
dp[i][j] = dp[i + 1][j - 1];
}
if (dp[i][j])
res++;
}
}
return res;
}
}
6、最长重复子数组
718. 最长重复子数组
给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。
示例：
输入：
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出：3
解释：
长度最长的公共子数组是 [3, 2, 1] 。
import java.util.Map;
class Solution {
public int findLength(int[] A, int[] B) {
if (A.length == 0 || B.length == 0)
return 0;
int[][] dp = new int[A.length + 1][B.length + 1];
int res = 0;
dp[0][0] = 0;
for (int i = 1; i <= A.length; i++) {
for (int j = 1; j <= B.length; j++) {
if (A[i - 1] == B[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
res = Math.max(res, dp[i][j]);
}
}
}
return res;
}
}
