博客记录-day152-力扣+分布式

一、力扣

1、最长重复子数组

dp[i][j]定义为以nums1的i结尾和以nums2的j结尾的最长重复子数组长度。

java 复制代码

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m=nums1.length,n=nums2.length;
        int[][] dp=new int[m+1][n+1];
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(nums1[i]==nums2[j]){
                    dp[i+1][j+1]=dp[i][j]+1;
                }else{
                    dp[i+1][j+1]=0;
                }
                res=Math.max(res,dp[i+1][j+1]);
            }
        }
        return res;
    }
}

2、删除排序链表中的重复元素 II

82. 删除排序链表中的重复元素 II

思路：当出现两个数相等后，删除第一个数，继续下一个

java 复制代码

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode pre=dummy;
        while(pre.next!=null&&pre.next.next!=null){
            int cur=pre.next.val;
            ListNode sec=pre.next.next;
            if(sec.val==cur){
                while(pre.next!=null&&pre.next.val==cur){
                    pre.next=pre.next.next;
                }
            }else{
                pre=pre.next;
            }
        }
        return dummy.next;
    }
}

3、 K 个一组翻转链表

25. K 个一组翻转链表

java 复制代码

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        int n=0;
        for(ListNode temp=head;temp!=null;temp=temp.next) n++;
        ListNode pre=dummy;
        ListNode cur=head;
        for(;n>=k;n-=k){
            ListNode las=null;
            for(int i=0;i<k;i++){
                ListNode nextcur=cur.next;
                cur.next=las;
                las=cur;
                cur=nextcur;
            }
            ListNode nextpre=pre.next;
            nextpre.next=cur;
            pre.next=las;
            pre=nextpre;
        }
        return dummy.next;
    }
}

4、和为 K 的子数组

560. 和为 K 的子数组

java 复制代码

class Solution {
    public int subarraySum(int[] nums, int k) {
        int res=0;
        int sum=0;
        Map<Integer,Integer> map=new HashMap<>();
        map.put(0,1);
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
            res+=map.getOrDefault(sum-k,0);
            map.merge(sum,1,Integer::sum);
        }
        return res;
    }
}

5、最大数

179. 最大数

java 复制代码

class Solution {
    public String largestNumber(int[] nums) {
        int n=nums.length;
        String[] ans=new String[n];
        for(int i=0;i<n;i++){
            ans[i]=""+nums[i];
        }
        Arrays.sort(ans,(a,b)->{
            String temp1=a+b;
            String temp2=b+a;
            return temp2.compareTo(temp1);
        });
        StringBuilder res=new StringBuilder();
        for(String s:ans){
            res.append(s);
        }
        int len=res.length();
        int point=0;
        while(point<len-1&&res.charAt(point)=='0'){
            point++;
        }
        return res.substring(point);
    }
}

6、合并区间

56. 合并区间

java 复制代码

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(a,b)->{
            if(a[0]==b[0]){
                return a[1]-b[1];
            }else{
                return a[0]-b[0];
            }
        });
        ArrayDeque<int[]> stack=new ArrayDeque<>();
        stack.push(new int[]{intervals[0][0],intervals[0][1]});
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]>stack.peek()[1]){
                stack.push(new int[]{intervals[i][0],intervals[i][1]});
            }else{
                stack.peek()[1]=Math.max(stack.peek()[1],intervals[i][1]);
            }
        }
        int[][] res=new int[stack.size()][2];
        int point=0;
        while(!stack.isEmpty()){
            res[point++]=stack.pollLast();
        }
        return res;
    }
}

7、用最少数量的箭引爆气球

452. 用最少数量的箭引爆气球

java 复制代码

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points,(a,b)->{
            if(a[0]==b[0]) return Integer.compare(a[1],b[1]);
            return Integer.compare(a[0],b[0]);
        });
        ArrayDeque<int[]> stack=new ArrayDeque<>();
        for(var e:points){
            if(!stack.isEmpty()){
                if(e[0]>stack.peek()[1]){
                    stack.push(e);
                }else{
                    stack.peek()[1]=Math.min(stack.peek()[1],e[1]);
                }
            }else{
                stack.push(e);
            }
        }
        return stack.size();
    }
}

8、无重叠区间

435. 无重叠区间

java 复制代码

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        // 按照区间的起始点升序排序，如果起始点相同则按结束点升序排序
        // 这样排序的目的是优先选择起始点靠左且结束点更早的区间，以便为后续区间留出更多空间
        Arrays.sort(intervals, (a, b) -> {
            if (a[0] == b[0]) {
                return Integer.compare(a[1], b[1]); // 起始点相同，结束点小的在前
            }
            return Integer.compare(a[0], b[0]);     // 起始点升序排列
        });

        int res = 0; // 记录需要移除的区间数量
        int pre = intervals[0][1]; // 初始化前一个区间的结束点为第一个区间的结束点

        // 从第二个区间开始遍历
        for (int i = 1; i < intervals.length; i++) {
            // 当前区间的起始点小于前一个区间的结束点，说明有重叠
            if (intervals[i][0] < pre) {
                res++; // 需要移除当前区间，计数加一
                // 更新前一个区间的结束点为当前区间结束点和前一个结束点的较小值
                // 这样可以尽量让后续区间有更多空间，减少后续重叠的可能
                pre = Math.min(pre, intervals[i][1]);
            } else {
                // 无重叠，更新前一个区间的结束点为当前区间的结束点
                pre = intervals[i][1];
            }
        }

        return res;
    }
}