LeetCode 424替换后的最长重复字符
题目描述:给你一个字符串 s 和一个整数 k 。你可以选择字符串中的任一字符,并将其更改为任何其他大写英文字符。该操作最多可执行 k 次。
在执行上述操作后,返回包含相同字母的最长子字符串的长度。
示例 1:
输入:s = “ABAB”, k = 2
输出:4
解释:用两个’A’替换为两个’B’,反之亦然。
示例 2:
输入:s = “AABABBA”, k = 1
输出:4
解释:
将中间的一个’A’替换为’B’,字符串变为 “AABBBBA”。
子串 “BBBB” 有最长重复字母, 答案为 4。
一、我们可以枚举字符串中的每一个位置作为右端点,然后找到其最远的左端点的位置,满足该区间内除了出现次数最多的那一类字符之外,每次从左至右遍历计算其出现次数,到剩余的字符(即非最长重复字符)数量不超过k个。
这样我们可以想到使用双指针维护这些区间,每次右指针右移,如果区间仍然满足条件,那么左指针不移动,否则左指针至多右移一格,保证区间长度不减小。
因为一直都有right++,所以碰到最大的之后长度至少都会是最大,不满足条件的会left++和right++,长度仍不变
- ABB和ABA中len-maxn都为1满足条件的
- 维持一个最大值
maxn = Math.max(maxn, num[s.charAt(right) - 'A']);
//求窗口中曾出现某字母的最大次数
//计算某字母出现在某窗口中的最大次数,窗口长度只能增大或者不变(注意后面left指针只移动了0-1次)
//这样做的意义:我们求的是最长,如果找不到更长的维持长度不变返回结果不受影响
二、实际代码中,由于字符串中仅包含大写字母,我们可以使用一个长度为 26 的数组维护每一个字符的出现次数。
每次区间右移,我们更新右移位置的字符出现的次数,然后尝试用它更新重复字符出现次数的历史最大值,最后我们使用该最大值计算出区间内非最长重复字符的数量,以此判断左指针是否需要右移即可
可执行完整代码
public class 第424替换后的最长重复字符 {
public int characterReplacement(String s, int k) {
int left = 0, right = 0; // 左右下标
int n = s.length();
int maxn = 0; // 通过下面的if维持窗口中曾出现某个字母的最大次数,窗口长度只能增大(因为我们要找的是最长,所以不影响)
int[] nums = new int[26];
while (right < n) {
nums[s.charAt(right) - 'A']++;
maxn = Math.max(maxn, nums[s.charAt(right) - 'A']);
if (right - left + 1 - maxn > k) {
nums[s.charAt(left) - 'A']--;
left++;
}
right++; // 走完这里的时候,其实right会多走一步
}
return right - left; // 因为right已经多走一步了,所以不用再+1,结果为(right-1)-left+1==right-left
}
}
LeetCode 24两两交换链表中的节点
题目描述:给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例1
输入:head = [1,2,3,4]
输出:[2,1,4,3]
示例 2:
示例2
输入:head = []
输出:[]
示例 3:
示例3
输入:head = [1]
输出:[1]
一、迭代的方法空间复杂度为1,时间复杂度n。创建哑结点 dummyHead,令 dummyHead.next = head
。令 temp 表示当前到达的节点,初始时 temp = dummyHead。
每次需要交换 temp 后面的两个节点。如果 temp 的后面没有节点或者只有一个节点,则没有更多的节点需要交换,因此结束交换
。否则,获得 temp 后面的两个节点 node1 和 node2,通过更新节点的指针关系实现两两交换节点。
二、while循环中的交换过程,先temp.next = node2
,然后才可以切分node1.next = node2.next;然后node2.next = node1。最后将temp引用移动到交换后的节点node1那儿。
完整可执行代码如下
public class 第24题两两交换链表中的节点 {
public ListNode swapPairs(ListNode head) {
ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode temp = dummyHead;
while (temp.next != null && temp.next.next != null) {
ListNode node1 = temp.next;
ListNode node2 = temp.next.next;
temp.next = node2;
node1.next = node2.next;
node2.next = node1;
temp = node1;
}
return dummyHead.next;
}
}
LeetCode 215数组中的第K个最大元素(快排变形,时间复杂度On,空间复杂度logN【递归使用栈空间的空间代价的期望为 O(\log n)O(logn)。】)
题目描述:
给定整数数组 nums 和整数 k,请返回数组中第 k 个最大的元素。
请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
一、因为是random了一个基准元素下标index,从left开始覆盖,所以要nums[index]=nums[left]。【如果是直接使用left作为基准就可以直接tem=nums[l]】
二、外层while和内层while中,nums[r]<=temp的时候r–,将小的元素放再右边;nums[l]>=tem的时候l++,大的元素放在左边,这样外层while找完位置后,就可以直接判断if(l == k-1)直接return nums[l]。else if(l < k - 1) 右侧l+1,right递归,else左侧left,l-1递归。
PS:直接使用left作为基准函数设计为quickSrot(int[] nums, int left, int right);如果自己random基准元素下标的话,也设计为quickSort(int[] nums, int left, int right) ,如果判断k就把k加入进参数中去。
random.nextInt()的用法
带参的nextInt(int x)则会生成一个范围在0~x(不包含X)内的任意正整数
例如:int x=new Random.nextInt(100);
则x为一个0~99的任意整数
可通过完整代码:
public class 第215题数组中的第K个最大元素 {
Random rand = new Random();
public int findKthLargest(int[] nums, int k) {
return quickSort(nums, k, 0, nums.length - 1);
}
private int quickSort(int[] nums, int k, int left, int right) { // nums[i]修改下标i处的元素值
int index = rand.nextInt(right - left +1) + left; // random取一个基准元素,取个数移动left(+left)
int temp = nums[index]; // 将基准元素值存起来
nums[index] = nums[left]; // 随机基准的话,因为首先交换要覆盖nums[l],所以要把left存给nums[index]
int l = left, r = right; // 将left和right保存一份用于移动位置,原始的left和right用于最后的quickSort递归
while (l < r) {
while (l < r && nums[r] <= temp) r--; // 小的在右边
nums[l] = nums[r];
while (l < r && nums[l] >= temp) l++; // 大的在左边,方便左边下标第一个是第1大的元素
nums[r] = nums[l];
}
nums[l] = temp;
if (l == k - 1) return nums[l];
else if (l < k - 1) return quickSort(nums, k, l + 1, right);
else return quickSort(nums, k, left, l - 1);
}
}
LeetCode 53最大子数组和(动态规划)
原题链接:最大子序和
一、我们考虑让nums[i]加入上一段f(n-1)或者自己成一段,作为f(n)的最大值
可通过完整代码如下:
public static int maxSubArray(int[] nums) {
int pre = 0, ans = nums[0];
for (int x : nums) {
pre = Math.max(pre + x, x);
ans = Math.max(pre, ans);
}
return ans;
}
LeetCode46全排列(因为数组不含重复数字,所以不用考虑去重)
题目描述:给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2:
输入:nums = [0,1]
输出:[[0,1],[1,0]]
示例 3:
输入:nums = [1]
输出:[[1]]
一、每次dfs中for循环交换0与[0,1,2…]、1与[1,2,3…]、2与[2,3,4…]【每次后面的内容和本次的first交换】。且因为for循环中是遍历多次,所以dfs后output要有恢复操作
时间复杂度:
java.util.Collections类的swap()方法
可执行完整代码:
public class 第46题全排列 {
public static List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> output = new ArrayList<>();
for (int num : nums) {
output.add(num);
}
int n = nums.length;
dfs(n, output, res, 0);
return res;
}
private static void dfs(int n, List<Integer> output, List<List<Integer>> res, int first) {
if (first == n) res.add(new ArrayList<>(output));
for (int i = first; i < n; i++) {
Collections.swap(output, first, i); // 交换操作0-0及0以后、1-1及1以后、2-2及2以后...
dfs(n, output, res, first + 1); // 继续递归填下一个数
Collections.swap(output, first, i); // 因为for中要遍历多个,所以要有撤销操作方便下一次的for循环正常进行
}
}
public static void main(String[] args) {
permute(new int[]{1,2,3});
}
}