每日一念
改掉自己想到哪写哪的坏习惯
子串
java
class Solution {
/**
有点像找出和为0的子数组，只不过这里和变成了k
不太对，尝试使用双指针+滑动窗口，完全过不去样例
正确做法
hashmap存放 sum -- count
对nums中的数字进行遍历sum累加
sum[j] - sum[i] = k，则表示此时存在一个范围i - j使得和为k
*/
public int subarraySum(int[] nums, int k) {
HashMap<Integer, Integer> map = new HashMap();
map.put(0, 1);
int sum = 0;
int count = 0;
for(int num: nums) {
sum += num;
if(map.containsKey(sum - k)) {
count += map.get(sum - k);
}
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
return count;
}
}
java
class Solution {
/**
这题总该是双指针+滑动窗口了吧
还是不对。。超时
LinkedList创建双端队列
queue控制后面的元素加进队尾
如果新元素大于队中所有元素
弹出所有元素，加入新元素（确保队首元素始终是最大值）
控制长度 > k 弹出队首元素
只要i >= k - 1，每次都记录res[i] = 队首
*/
public int[] maxSlidingWindow(int[] nums, int k) {
int[] res = new int[nums.length - k + 1];
if(nums == null || nums.length == 0) {
return res;
}
LinkedList<Integer> dequeue = new LinkedList();
for(int i = 0; i < nums.length; i++) {
while(!dequeue.isEmpty() && nums[i] > nums[dequeue.peekLast()]) {
dequeue.pollLast();
}
dequeue.offerLast(i);
if(i - dequeue.peekFirst() + 1 > k) {
dequeue.pollFirst();
}
if(i - k + 1 >= 0) {
res[i - k + 1] = nums[dequeue.peekFirst()];
}
}
return res;
}
}
java
// 困难题，真是头皮发麻普通数组
java
class Solution {
/**
dp[i]表示以nums[i]结尾的最大和的连续子数组
dp[i] -- dp[i - 1](nums[i - 1]结尾的)
*/
public int maxSubArray(int[] nums) {
int[] dp = new int[nums.length];
dp[0] = nums[0];
for(int i = 1; i < dp.length; i++) {
dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
}
int max = dp[0];
for(int i = 0; i < dp.length; i++) {
if(dp[i] > max) {
max = dp[i];
}
}
return max;
}
}
java
class Solution {
/**
start, end表示要存入的合并的区间起点&终点
初始化为intervals[0] intervals[1]
遍历intervals数组进行比较合并（intervals数组首先要对intervals[i][0]进行排序）
*/
public int[][] merge(int[][] intervals) {
// Arrays.sort(intervals, new Comparator<int[]>(){
// public int compare(int[] a, int[] b) {
// return Integer.compare(a[0], b[0]);
// }
// });
// Arrays.sort(intervals, (a, b) -> {
// return Integer.compare(a[0], b[0]);
// });
for(int i = 0; i < intervals.length - 1; i++) {
for(int j = 0; j < intervals.length - 1 - i; j++) {
if(intervals[j][0] > intervals[j + 1][0]) {
int[] temp = intervals[j];
intervals[j] = intervals[j + 1];
intervals[j + 1] = temp;
}
}
}
// for(int i = 0; i < intervals.length; i++) {
// System.out.println("interval数组的值" + intervals[i][0] + intervals[i][1]);
// }
List<List<Integer>> res = new ArrayList();
int start = intervals[0][0];
int end = intervals[0][1];
for(int i = 1; i < intervals.length; i++) {
// i = 1的【i】【0】比i = 0大，进行合并
if(intervals[i][0] <= end) {
end = Math.max(end, intervals[i][1]);
}
else {
List<Integer> path = new ArrayList();
path.add(start);
path.add(end);
res.add(path);
start = intervals[i][0];
end = intervals[i][1];
}
}
List<Integer> path = new ArrayList();
path.add(start);
path.add(end);
res.add(path);
// System.out.println(res.size());
int[][] ans = new int[res.size()][2];
for(int i = 0; i < res.size(); i++) {
ans[i][0] = res.get(i).get(0);
ans[i][1] = res.get(i).get(1);
}
return ans;
}
}
java
class Solution {
/**
循环从队尾拿
然后插入队头
使用双端队列linkedlist
然后发现函数返回void，说明应该要直接在nums基础上改动
*/
public void rotate(int[] nums, int k) {
int len = nums.length;
int[] nums1 = new int[len];
for(int i = 0; i < len; i++) {
nums1[i] = nums[i];
}
for(int i = 0; i < len; i++) {
nums[(i + k)% len] = nums1[i];
}
}
}
java
// 双端队列，超时
java
class Solution {
/**
again双端队列？
不要思维定势啊喂
首先将nums中所有<0 & >n+1的全部设置为不可达的值n+1
用res存
*/
public int firstMissingPositive(int[] nums) {
int n = nums.length;
int[] res = new int[nums.length];
for(int i = 0; i < nums.length; i++) {
if(nums[i] <= 0 || nums[i] > n) {
nums[i] = n + 1;
}
}
for(int i = 0; i < n; i++) {
if(nums[i] != n + 1) {
res[nums[i] - 1] = nums[i];
}
}
for(int i = 0; i < res.length; i++) {
// System.out.print("第" + i + "个数为" + res[i]);
if(res[i] != i + 1) {
return i + 1;
}
}
return n + 1;
}
}矩阵
java