学习更新2021年10月
2021-10-19
一本通 1264：【例9.8】合唱队形
一本通的题，想明白了很简单，想不明白比较复杂。就是从左到右是升序子序列，而从右边到左也是升序子序列。两个dp数组，一个从左到右计算最大升序子序列。一个从右往左计算最大升序子序列。最后做一个合并。看每个位置dp1[i]+dp2[i] 的最大值，减去重复的i位置的值，就是最大值了。
public int res(int[] t) {
int dp1[] = new int[t.length];
int dp2[] = new int[t.length];
for (int i = 0; i < t.length; i++) {
dp1[i] = 1;
for (int j = 0; j < 1; j++) {
if (t[i] > t[j]) {
dp1[i] = Math.max(dp1[j] + 1, dp1[i]);
}
}
}
for (int i = t.length - 1; i >= 0; i--) {
dp2[i] = 1;
for (int j = t.length - 1; j > i; j--) {
if (t[i] > t[j]) {
dp2[i] = Math.max(dp2[j] + 1, dp2[i]);
}
}
}
int max = 1;
for (int i = 0; i < t.length; i++) {
max = Math.max(dp1[i] + dp2[i], max);
}
System.out.println(max-1);
return max - 1;
}
2021-10-20
516. 最长回文子序列
这题是非常经典的动态规划题，详细解析，后面补充。
回文串、序列 的题，通常你要先定义两个指针，一个是指向起始位置，一个指向结束位置。所以都是二位dp数组
- 1.dp[i][j]代表从索引 i到j位置的最长回文序列长度。则我们最终要求得最长回文序列为 dp[0][len-1]
- 2.回文特点是对称。则dp[i][j]和dp[i+1][j-1]产生递推关系
- 3.当i位置字符和j位置字符相同则 dp[i][j]=dp[i+1][j-1]+2,因为长度是在原来基础上增加2的
- 3.当i位置字符和j位置字符不同则 dp[i][j]这个的最大值与下面两个位置产生的最长回文相同，因为i和j无效，位置一：i+1到j，位置二：i~j-1位置
- 4.i如果从0开始遍历，则j在遍历过程中，比如i=0,j=3，则此时状态转移为 i=2，而此时i=2的dp我们还没计算出来，所以无法算得，所以i需要从len-1开始
class Solution {
public int longestPalindromeSubseq(String s) {
if (s == null) {
return 0;
}
int len = s.length();
char[] cs = s.toCharArray();
//状态转义方程式 当cs[i]==cs[j]
// 则有dp[i][j]= dp[i+1][j-1]。
// 否则dp[i][j] = Max(dp[i+1][j],dp[i][j-1])
int[][] dp = new int[len][len];
for (int i = len - 1; i >= 0; i--) {
dp[i][i]=1;
for (int j = i + 1; j < len; j++) {
if (cs[i] == cs[j]) {
dp[i][j] = dp[i + 1][j - 1]+2;
} else {
dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
return dp[0][len - 1];
}
}
2021-10-26
首先说这两天的纪念意义，2020年10月27日是我在力扣上提交通过的第一道题，知道今天我通过了刚好350题
P496. 下一个更大元素 I
P496. 下一个更大元素 I
这题暴力解法时间复杂度O(n2)，这里使用单调栈和map来降低时间复杂度
- 1.求得nums2每个位置上比当前位置大的元素的索引，并放入map
- 1.1 倒序遍历(必须倒序），把元素索引放入栈，使得栈索引对应值保持单调递减的，也就是当前的元素的下一个元素一定在栈顶。如果不满足单调，就一直弹栈，直到拿到比当前更大的元素
- 2.遍历nums1，找到其在map中对应的索引，去nums2取出来
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
//i - index ，i表示元素，index表示下一个比i大的数
//[1,3,4,2,5]
//用一个栈找到下一个比自己大的元素
//栈里面保持逐渐增大的
Map<Integer, Integer> map = new HashMap<>();
Stack<Integer> stack = new Stack<>();
for (int i = nums2.length - 1; i >= 0; i--) {
if (stack.isEmpty() || nums2[i] < nums2[stack.peek()]) {
map.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
stack.add(i);
} else {
while (!stack.isEmpty() && nums2[i] > nums2[stack.peek()]) {
stack.pop();
}
map.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
stack.add(i);
}
}
int res[] = new int[nums1.length];
for (int i = 0; i < nums1.length; i++) {
res[i] = map.get(nums1[i]) == -1 ? -1 : nums2[map.get(nums1[i])];
}
return res;
}
P503. 下一个更大元素 II
P503. 下一个更大元素 II
这题要注意一些细节，使用的元素的索引去映射，因为元素可能重复，这样map会被覆盖。这题在原来基础上，首先要构造一个nums2数组，循环数组直接拼接两个数组能达到循环数组的效果
class Solution {
public int[] nextGreaterElements(int[] nums) {
int nums2[] = new int[nums.length * 2];
System.arraycopy(nums, 0, nums2, 0, nums.length);
System.arraycopy(nums, 0, nums2, nums.length, nums.length);
Map<Integer, Integer> map = new HashMap<>();
Stack<Integer> stack = new Stack<>();
for (int i = nums2.length - 1; i >= 0; i--) {
if (stack.isEmpty() || nums2[i] < nums2[stack.peek()]) {
map.put(i, stack.isEmpty() ? -1 : stack.peek());
stack.add(i);
} else {
while (!stack.isEmpty() && nums2[i] >= nums2[stack.peek()]) {
stack.pop();
}
map.put(i, stack.isEmpty() ? -1 : stack.peek());
stack.add(i);
}
}
int res[] = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
res[i] = map.get(i) == -1 ? -1 : nums2[map.get(i)];
}
return res;
}
}
