- 记录于2019年5月17日
4. 寻找两个有序数组的中位数
① 题目描述
- 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
- 请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为
O(log(m + n))。 - 你可以假设 nums1 和 nums2 不会同时为空。
- 示例 1:
nums1 = [1, 3] nums2 = [2]
则中位数是 2.0
- 示例 2:
nums1 = [1, 2] nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5
② 暴力解法
- 先考虑nums1或nums2长度为0的情况，直接返回另一个数组的中位数。
- 遍历nums1和nums2，将数据存储到另一个数组中，使用
Arrays.sort()对新的数组排序，然后返回其中位数。 - 时间复杂度：遍历全部数组，
O(lm + n)。 - 空间复杂度：开辟了一个数组，保存合并后的两个数组，
O(m + n)。 - 代码如下（竟然神奇的通过了！）：
public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
int m = nums1.length, n = nums2.length;
if (m == 0) {
if (n % 2 == 0) {
return (nums2[n / 2] + nums2[n / 2 - 1]) / 2.0;
} else {
return (double) nums2[(n - 1) / 2];
}
}
if (n == 0) {
if (m % 2 == 0) {
return (nums1[m / 2] + nums1[m / 2 - 1]) / 2.0;
} else {
return (double) nums1[(m - 1) / 2];
}
}
int[] temp = new int[m + n];
int i = 0;
for (; i < m; i++) {
temp[i] = nums1[i];
}
for (int j = 0; j < n; j++) {
temp[i + j] = nums2[j];
}
Arrays.sort(temp);
int len = temp.length;
if (len % 2 == 0) {
return (temp[len / 2] + temp[len / 2 - 1]) / 2.0;
} else {
return (double) temp[(len - 1) / 2];
}
}
5. 最长回文子串
① 题目描述
- 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
- 示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
- 示例 2：
输入: “cbbd”
输出: “bb”
② 暴力解法（Time Limit Exceeded）
- 首先判断s为空或者长度为1的情况，直接返回s。
- 编写
helper()方法，用于判断sub是否为回文子串。 - 暴力查找回文子串，注意：
helper()方法返回结果true时，需要比较当前子串和中间结果的length。 - 由于暴击查找时，判断的起始长度为2，所以如果最后
max=0，说明没有找到长度大于等于2的回文子串，直接返回s的第一个字符。
- 代码如下：
public String longestPalindrome(String s) {
int len = s.length();
if (len == 0 || len == 1) {
return s;
}
String result = new String("");
int max = 0;
for (int i = 0; i < len - 1; i++) {
for (int j = i + 1; j < len; j++) {
String temp = s.substring(i, j + 1);
if (helper(temp) && max < temp.length()) {
result = temp;
max = temp.length();
}
}
}
if (max == 0) {
return s.substring(0, 1);
}
return result;
}
public boolean helper(String s) {
int start = 0, end = s.length() - 1;
while (start <= end) {
if (s.charAt(start) == s.charAt(end)) {
start++;
end--;
} else {
return false;
}
}
return true;
}
③ 动态规划
- 动态规划一般使用二维数组存储，以空间换时间。
- 观察到，要知道
P(i, j)得先知道P(i+1, j-1)，所以外层循环i应该倒序遍历，从n-1, ...., 0；内层循环j起始值应该为i（因为不可能出现2, 0的情况，只能从前往后找字符串），j应该顺序遍历，一方面保证从前往后找子串，另一方面保证P(i+1, j-1)先被求解。
public String longestPalindrome(String s) {
int len = s.length();
int max = 0;
String result = new String("");
boolean[][] d = new boolean[len][len];
for (int i = len - 1; i >= 0; i--) {
for (int j = i; j < len; j++) {
if (i == j) {
d[i][j] = true;
} else if (i + 1 == j) {
d[i][j] = (s.charAt(i) == s.charAt(j)) ? true : false;
} else {
d[i][j] = (d[i + 1][j - 1] && s.charAt(i) == s.charAt(j)) ? true : false;
}
if (d[i][j] && (j - i + 1) > max) {
result = s.substring(i, j + 1);
max = j - i + 1;
}
}
}
return result;
}
10. 正则表达式匹配
① 题目描述
- 给定一个字符串 (s) 和一个字符模式 §。实现支持 ‘.’ 和 ‘*’ 的正则表达式匹配。
'.'匹配任意单个字符。'*'匹配零个或多个前面的元素。- 匹配应该覆盖整个字符串 (s) ，而不是部分字符串。
- 说明:
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
- 示例 1:
输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。
- 示例 2:
输入:
s = “aa”
p = “a*”
输出: true
解释: ‘*’ 代表可匹配零个或多个前面的元素, 即可以匹配 ‘a’ 。因此,重复 ‘a’ 一次, 字符串可变为 “aa”。
- 示例 3:
输入:
s = “ab”
p = “."
输出: true
解释: ".” 表示可匹配零个或多个(’*’)任意字符(’.’)。
- 示例 4:
输入:
s = “aab”
p = “cab”
输出: true
解释: ‘c’ 可以不被重复, 'a’可以被重复一次。因此可以匹配字符串 “aab”。
- 示例 5:
输入:
s = “mississippi”
p = “misisp*.”
输出: false
② 使用java.String的API
public boolean isMatch(String s, String p) {
if (s==null){
if (p==null){
return true;
}else{
return false;
}
}
if (p==null){
return false;
}
return s.matches(p);
}
③ 动态规划（不理解！）
- 参考博客：第10题 正则表达式匹配（动态规划）
public boolean isMatch(String s, String p) {
int m = s.length(), n = p.length();
boolean[][] dp = new boolean[m + 1][n + 1];
dp[0][0] = true;//考虑s和p均为空的情况
// 考虑s为空,p不为空的情况，遇到'*'，p的下标-2
for (int i = 0; i < n; i++) {
if (p.charAt(i) == '*' && dp[0][i - 1]) {
dp[0][i + 1] = true;// 考虑了s和p均为空的情况，下标为i时对应dp中为i+1
}
}
// 正常情况
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (p.charAt(j) == s.charAt(i) || p.charAt(j) == '.') {
dp[i + 1][j + 1] = dp[i][j];
}
if (p.charAt(j) == '*') {
// 遇到‘*’，比较p的j-1字符与s的当前字符，不相等则比较p的j-2字符与s的当前字符
if (p.charAt(j - 1) != s.charAt(i) && p.charAt(j - 1) != '.') {
dp[i + 1][j + 1] = dp[i + 1][j - 1];
} else {
dp[i + 1][j + 1] = (dp[i + 1][j] || dp[i][j + 1] || dp[i + 1][j - 1]);
}
}
}
}
// 最后返回是s下标为m-1，p下标为n-1的结果
return dp[m][n];
}