【刷题】不同专题篇

小文目录:

      • 1、递归
        • L70:爬楼梯(斐波那契数列)
        • L112:路径总和
        • L509:斐波那契数列
      • 2、分治
        • L23:合并K个升序链表
        • L169:多数元素(超过一半的数字)
      • 3、单调栈
        • L84:柱状图中最大矩形
        • L85:最大矩形
        • L739:每日温度
        • L503: 下一个更大的元素
      • 4、并查集
      • 5、滑动窗口
        • L209:长度最小的子数组
        • L3:无重复字符的最长子串
        • L1004:最大连续1的个数 III
      • 6、前缀和
        • L724:寻找数组的中心下标
        • L560:和为K的子数组
        • L437:路径总和 III
        • L1248:统计优美子数组
      • 7、拆分(差分)
        • L1893:检查是否区域内所有整数都被覆盖
        • L1094:拼车
      • 8、拓扑排序
        • L210:课程表 II
      • 9、字符串
        • L5:回文子串
        • L20:有效括号
        • L43:字符串相乘
      • 10、二分查找
        • L33:搜索旋转排序数组
        • L34:在排序数组中查找元素的第一个和最后一个位置
      • 11、BFS
      • 12、DFS&回溯
      • 13、动态规划
      • 14、贪心
      • 15、字典树

递归: LeetCode70、112、509
分治: LeetCode23、169、240
单调栈: LeetCode84、85、739、503
并查集: LeetCode547、200、684
滑动窗口:LeetCode209、3、1004、1208
前缀和: LeetCode724、560、437、1248
差分: LeetCode1094、121、122
拓扑排序:LeetCode210
字符串: LeetCode5、20、43、93
二分查找:LeetCode33、34
BFS: LeetCode127、139、130、529、815
DFS&回溯::LeetCode934、685、1102、531、533、113、332、337
动态规划:LeetCode213、123、62、63、361、1230
贪心算法:LeetCode55、435、621、452
字典树: LeetCode820、208、648

1、递归

L70:爬楼梯(斐波那契数列)

【刷题】不同专题篇_第1张图片

L112:路径总和

【刷题】不同专题篇_第2张图片

L509:斐波那契数列

【刷题】不同专题篇_第3张图片

2、分治

L23:合并K个升序链表

分而治之
【刷题】不同专题篇_第4张图片

【刷题】不同专题篇_第5张图片

L169:多数元素(超过一半的数字)

【刷题】不同专题篇_第6张图片
【刷题】不同专题篇_第7张图片

3、单调栈

单调栈:判别是否需要使用单调栈,如果需要找到左边或者右边第一个比当前位置的数大或者小,则可以考虑使用单调栈

L84:柱状图中最大矩形

1、暴力解法:
【刷题】不同专题篇_第8张图片
【刷题】不同专题篇_第9张图片
2、+单调栈

【刷题】不同专题篇_第10张图片
上文中,定义了-1和8。表示当前柱子左侧/右侧最近的柱子没有比自己低的,故高度还是本身。

【刷题】不同专题篇_第11张图片

例如:[-1,0,-1,-1,3,4,5,3],当中的-1表示第0、2、3号柱子各自的左边(从左往右依次遍历时)都没有比自己低的柱子;[2,2,3,8,7,7,7,8]当中的8表示第7、3号柱子各自的右边(从右往左依次遍历时)都没有比自己低的柱子。
其他数字表示:例如[-1,0,-1,-1,3,4,5,3]中的0表示索引1号柱子左边离他最近比他低的柱子编号是0;5表示索引6号的柱子左边离他最近比他低的柱子编号是5;
例如[2,2,3,8,7,7,7,8]中的3表示索引2号的柱子右边最近比他低的是3号;
代码:

class Solution {
    public int largestRectangleArea(int[] heights) {
        int n = heights.length;
        Stack<Integer> stack = new Stack<>();
        int[] left = new int[n];//记录从左到右每个柱子的左边离他最近的比他低的柱子编号
        int[] right = new int[n];//记录从右到左每个柱子的右边离他最近的比他低的柱子编号

        //找左边的
        for(int i =0;i<n;i++){
            while(!stack.isEmpty() && heights[stack.peek()]>=heights[i]){
                stack.pop();
            }
            left[i] = stack.isEmpty()? -1 : stack.peek();
            stack.push(i);
        }
        stack.clear();
         //找右边的
        for(int i =n-1;i>=0;i--){
            while(!stack.isEmpty() && heights[stack.peek()]>=heights[i]){
                stack.pop();
            }
            right[i] = stack.isEmpty()? n : stack.peek();
            stack.push(i);
        }

        //计算面积
        int res =0;
        for(int i=0;i<n;i++){
            res=Math.max(res,(right[i]-left[i]-1)*heights[i]);//为什么是减1不是+1?
        }
        return res;
    }
}
L85:最大矩形

【刷题】不同专题篇_第12张图片

【刷题】不同专题篇_第13张图片

代码:

class Solution {
    public int maximalRectangle(char[][] matrix) {
        if(matrix.length==0) return 0;
        int[] heights = new int[matrix[0].length];//记录matrix每一列连续是1的高度
        int ans=0;

        //计算每一列的高度,即连续是1的高度
        for(int i=0;i<matrix.length;i++){
            //遍历每一列,更新高度
            for(int j=0;j<matrix[0].length;j++){
                if(matrix[i][j] == '1'){
                    heights[j] += 1;
                }else heights[j] =0;
                //这里是清空heights[j],而不是会保留上次的值;因为高度需要连续,即连续的1,只要中间有一个是0,则高度从0开始重新累计
            }
            ans =Math.max(ans,largeRecetangle(heights));//将计算好的heights送到84题,求heights[]的最大矩形面积
        }      
        return ans;

    }

    public int largeRecetangle(int[] heights){
        int n = heights.length;
        int[] left =new  int[n];
        int[] right =new  int[n];
        Stack<Integer> stack = new Stack<>();

        for(int i=0;i<n;i++){
            while(!stack.isEmpty() && heights[stack.peek()]>=heights[i]){
                stack.pop();
            }
            left[i] = stack.isEmpty()? -1: stack.peek();
            stack.push(i);
        }
        stack.clear();
        for(int i=n-1;i>=0;i--){
            while(!stack.isEmpty() && heights[stack.peek()]>=heights[i]){
                stack.pop();
            }
            right[i] = stack.isEmpty()? n: stack.peek();
            stack.push(i);
        }

        int res = 0;
        for(int i=0;i<n;i++){
            res = Math.max(res,(right[i]-left[i]-1)*heights[i]);
        }
        return res;
    }
}
L739:每日温度

【刷题】不同专题篇_第14张图片

L503: 下一个更大的元素

【刷题】不同专题篇_第15张图片

【刷题】不同专题篇_第16张图片
【刷题】不同专题篇_第17张图片

4、并查集

就是集合,能够快速合并,能够快速查询两个节点是否在同一集合中的一种数据结构。一般用树(数组)实现。(并查集基本上可以用DFS、BFS来解决)
【刷题】不同专题篇_第18张图片

5、滑动窗口

L209:长度最小的子数组

【刷题】不同专题篇_第19张图片
【刷题】不同专题篇_第20张图片
【刷题】不同专题篇_第21张图片

L3:无重复字符的最长子串

【刷题】不同专题篇_第22张图片

L1004:最大连续1的个数 III

【刷题】不同专题篇_第23张图片

【刷题】不同专题篇_第24张图片

【刷题】不同专题篇_第25张图片

6、前缀和

L724:寻找数组的中心下标

【刷题】不同专题篇_第26张图片
【刷题】不同专题篇_第27张图片

L560:和为K的子数组

【刷题】不同专题篇_第28张图片
【刷题】不同专题篇_第29张图片
前缀和+哈希表 的改进参考Hot100题解

L437:路径总和 III

【刷题】不同专题篇_第30张图片
【刷题】不同专题篇_第31张图片
【刷题】不同专题篇_第32张图片
【刷题】不同专题篇_第33张图片

【刷题】不同专题篇_第34张图片
【刷题】不同专题篇_第35张图片

L1248:统计优美子数组

【刷题】不同专题篇_第36张图片
【刷题】不同专题篇_第37张图片

7、拆分(差分)

L1893:检查是否区域内所有整数都被覆盖

【刷题】不同专题篇_第38张图片
【刷题】不同专题篇_第39张图片
【刷题】不同专题篇_第40张图片

【刷题】不同专题篇_第41张图片

【刷题】不同专题篇_第42张图片

【刷题】不同专题篇_第43张图片

L1094:拼车

在这里插入图片描述
【刷题】不同专题篇_第44张图片

8、拓扑排序

【刷题】不同专题篇_第45张图片

拓扑排序实际上应用的是贪心算法,贪心算法简而言之:每一步最优,则全局最优

拓扑排序保证了每个活动(如“课程”)的所有前驱活动都排在该活动的前面,并且可以完成所有活动。

L210:课程表 II

【刷题】不同专题篇_第46张图片

【刷题】不同专题篇_第47张图片
【刷题】不同专题篇_第48张图片
【刷题】不同专题篇_第49张图片

入度:指向当前节点的边,有几条入度就是几

class Solution {
    List<List<Integer>> edegs;//存储有向图
    int[] indeg;//存储每个节点的入度(即指向该节点的点的个数)
    int[] res;//存储答案
    int index;//答案的下标,用来循环后移

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        edegs = new ArrayList<List<Integer>>();
        for(int i=0;i<numCourses;i++){
            edegs.add(new ArrayList<>());//初始化,先给每个点创造边
        }
        indeg = new int[numCourses];
        res = new int[numCourses];
        index = 0;

        for(int[] info : prerequisites){
            //info存储每个点的矩阵[a,b],a表示当前课程,b表示a前面需有的课
            edegs.get(info[1]).add(info[0]);
            //给当前点的须有点b(info[1])添加边,指向当前点a(info[0])
            indeg[info[0]]++;//当前点的入度+1
        }

        Queue<Integer> queue = new LinkedList<Integer>();
        //将所有入度为0的节点添加到队列当中
        for(int i=0;i<numCourses;i++){//∵拓扑排序有多种结果,所以这些节点入队的顺序没有要求
            if(indeg[i]==0) queue.offer(i);
        }
        while(!queue.isEmpty()){
            int u = queue.poll();//从队首取出一个节点
            res[index++] = u;//加入到结果集
            for(int v : edegs.get(u)){//找到u节点的邻接点v
                indeg[v]--;//v的入度-1
                if(indeg[v] == 0){
                    queue.offer(v);
                }
            }
        }
        if(index!=numCourses) return new int[0];
        return res;

    }
}

9、字符串

L5:回文子串

【刷题】不同专题篇_第50张图片

思路:中心扩展法
假设字符串的每个字符为一种初始中心,然后分别向这个字符左右两侧扩展,即判断两边的字符是否相同。如果两边的字母相同,我们就可以继续扩展;如果两边的字母不同,我们就可以停止扩展,因为在这之后的子串都不能是回文串了。我们枚举所有的「回文中心」并尝试「扩展」,直到无法扩展为止,此时的回文串长度即为此「回文中心」下的最长回文串长度。我们对所有的长度求出最大值,即可得到最终的答案。

例如:str = acdbdaastr=acdbbdaa,当中心索引是3时,对应字符b,然后分别从其两边扩展,d==d、c!=a,结束,返回长度3

【刷题】不同专题篇_第51张图片

代码:

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1){
            return "";
        }
        // 初始化最大回文子串的起点和终点
        int start = 0;
        int end   = 0;

        // 遍历每个位置,当做中心位
        for (int i = 0; i < s.length(); i++) {
            // 分别拿到奇数偶数的回文子串长度
            int len_odd = expandCenter(s,i,i);//情况1、当子串中心是一个字符,eg.abcba  中心是c
            int len_even = expandCenter(s,i,i + 1);//情2、当子串中心是两个字符eg.abccba中心是cc
            // 对比最大的长度
            int len = Math.max(len_odd,len_even);
            // 计算对应最大回文子串的起点和终点
            if (len > end - start){
        //eg.len=12(偶数,说明中间两个字符作为中心),i=6,则start=i-5=1;end=i+6=12; 
        //      区间为[1,12],中心位置是i=6、7
        //eg.len= 1(奇数,说明中间1个字符作为中心),i=6,则start=i-5=1;end=i+5=11; 
        //      区间为[1,11],中心位置是i=6
                start = i - (len - 1)/2;
                end = i + len/2;
            }
        }
        // 注意:这里的end+1是因为 java自带的左闭右开的原因
        return s.substring(start,end + 1);
    }
    private int expandCenter(String s,int left,int right){
        // left = right 的时候,此时回文中心是一个字符,回文串的长度是奇数
        // right = left + 1 的时候,此时回文中心是一个空隙,回文串的长度是偶数
        // 跳出循环的时候恰好满足 s.charAt(left) != s.charAt(right)
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
            left--;
            right++;
        }
        //因为跳出循环时,s.charAt(left)!= s.charAt(right),即不包括此时的left和right,所以应该是[left+1,right-1],即(right-1)-(left+1)+1=right-left-1
        //回文串的长度是right-left+1-2 = right - left - 1
        return right - left - 1;
    }
}

动态规划:【刷题】不同专题篇_第52张图片

class Solution {
    public String longestPalindrome(String s) {
        if(s.length()<2) return s;

        int n = s.length();
        boolean[][] dp = new boolean[n][n];//dp[i][j]:字符串从i到j是否为回文

        int max_len = 1;//最长回文长度至少是1,∵一个字符也是回文
        int start=0;//最长回文起点
        int end=0;//最长回文终点
        for(int r=1;r<n;r++){
            for(int l=0;l<r;l++){
                if(s.charAt(l) == s.charAt(r) && (r-l<3 || dp[l+1][r-1])){
                    dp[l][r] = true;
                    if(r-l+1>max_len){
                        max_len = r-l+1;
                        start=l;
                        end = r;
                    }   
                }
            }
        }
        return s.substring(start,end+1);

    }
}
L20:有效括号

【刷题】不同专题篇_第53张图片

L43:字符串相乘

【刷题】不同专题篇_第54张图片

【刷题】不同专题篇_第55张图片
主要是有大数

class Solution {
    public String multiply(String num1, String num2) {
        if(num1.equals("0") || num2.equals("0")) return "0";
        String res = "0";

        for(int i=num2.length()-1;i>=0;i--){
            int carry = 0;
            StringBuilder temp = new StringBuilder();//记录num2的当前i位上的数与nums1乘积的结果
            //补0
            for(int ii=0;ii<num2.length()-1-i;ii++){
                temp.append(0);
            }
            int n2 = num2.charAt(i)-'0';//num2的当前i位上的数

            //num2 的第 i 位数字 n2 与 num1 相乘
            for(int j=num1.length()-1;j>=0 || carry!=0;j--){//∵存在j=-1(最低位前),但是进位carry上仍有数
                int n1= j<0? 0 : num1.charAt(j)-'0';
                int product = (carry+n1*n2)%10;//余数放到product
                temp.append(product);
                carry = (carry+n1*n2)/10;
            }            
            res = addStrings(res,temp.reverse().toString());//将当前结果与新计算的结果求和作为新的结果
        }
        return res;        
    }

    //对两个字符串数字进行相加,返回字符串形式的和
    public String addStrings(String num1, String num2){
        StringBuilder builder = new StringBuilder();
        int carry=0;
        for(int i=num1.length()-1,j=num2.length()-1;i>=0 || j>=0 || carry!=0;i--,j--){
            int x = i<0? 0 : num1.charAt(i)-'0';
            int y = j<0? 0 : num2.charAt(j)-'0';
            int sum = (x+y+carry)%10;
            builder.append(sum);
            carry = (x+y+carry)/10;
        }
        return builder.reverse().toString();
    }
}

10、二分查找

L33:搜索旋转排序数组

【刷题】不同专题篇_第56张图片

【刷题】不同专题篇_第57张图片

class Solution {
    public int search(int[] arr, int target) {
        int start = 0;
        int end = arr.length-1;
        int mid;

        if(arr == null || arr.length == 0) return -1;
        if(arr.length == 1) return target==arr[0]? 0: -1;

        while(start <= end){
            mid = start+(end-start)/2;

            if(arr[mid] == target) return mid;

            if(arr[mid]>= arr[start]){//情形1:左边有序
                if(target >= arr[start] && target < arr[mid]){//情形1.1:target位于左边
                    end = mid-1;//左边右届缩小
                }else{//情形1.2:target位于右边
                    start = mid +1;//右边左届缩小
                }
            }else{//情形2:右边有序
                if(target> arr[mid] && target <= arr[end]){//情形2.1:target位于右边
                    start = mid+1;//右边左届缩小
                }else{//情形2.2:target位于左边
                    end = mid-1;//左边右届缩小
                }
            }
        }
        return -1;
    }
}
L34:在排序数组中查找元素的第一个和最后一个位置

【刷题】不同专题篇_第58张图片

思路:
参考传送门,首先找到target-1的右边界,即target的起始第一个位置start,然后找到target的右边界,即target+1的起始位置xx,end=xx-1即target的最后一个位置,返回[start,end]

【刷题】不同专题篇_第59张图片

代码:

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums.length==0) return new int[]{-1,-1};

        int start = helper(nums,target-1);//target第一个位置
        int end = helper(nums,target)-1;//target最后一个位置
        if(start>end) return new int[]{-1,-1};//说明没找到
        return new int[]{start,end};
    }

    public int helper(int[] nums,int target){
        int i=0;
        int j=nums.length-1;
        while(i<=j){
            int mid = (i+j)>>1;
            if(nums[mid]<=target){
                i = mid+1;
            }else{
                j = mid-1;
            }
        }
        return i;
    }
}

11、BFS

L127:

L:139

L130:被包围的区域
【刷题】不同专题篇_第60张图片

【刷题】不同专题篇_第61张图片
在这里插入图片描述

class Solution {
    int[] dx = {1,-1,0,0};//下,上,
    int[] dy = {0,0,1,-1};//右,左
    public void solve(char[][] board) {
        int n = board.length;
        int m = board[0].length;
        if(n==0) return;

        Queue<int[]> queue = new LinkedList<int[]>();

        for(int i=0;i<n;i++){//列边界上的0
            if(board[i][0]=='O'){
                queue.offer(new int[]{i,0});
                board[i][0]='A';
            }
            if(board[i][m-1]=='O'){
                queue.offer(new int[]{i,m-1});
                board[i][m-1]='A';
            }
        }
        for(int j=0;j<m;j++){//行边界上的0
            if(board[0][j]=='O'){
                queue.offer(new int[]{0,j});
                board[0][j]='A';
            }
            if(board[n-1][j]=='O'){
                queue.offer(new int[]{n-1,j});
                board[n-1][j]='A';
            }
        }

        while(!queue.isEmpty()){//搜索每个边界上的0  的直接或间接相邻的0 标记位A
            int[] tmp = queue.poll();
            int x = tmp[0], y =tmp[1];
            for(int i=0;i<4;i++){
                int mx = x+dx[i], my = y+dy[i];
                if(mx<0 || my<0 || mx>=n || my >=m || board[mx][my]!='O') continue;
                queue.offer(new int[]{mx,my});
                board[mx][my]='A';
            }
        }

        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(board[i][j]=='A') board[i][j]='O';
                else if (board[i][j] == 'O') board[i][j]='X';
            }
        }
    }
}

L529:扫雷游戏

L:815

12、DFS&回溯

L934:最短的桥 DFS+BFS
【刷题】不同专题篇_第62张图片

L200:岛屿数量
【刷题】不同专题篇_第63张图片

思路:深度优先dfs
【刷题】不同专题篇_第64张图片

代码:

class Solution {
    public int numIslands(char[][] grid) {
        int count =0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j]=='1'){
                    dfs(grid,i,j);
                    count++;
                }
            }
        }
        return count;
    }
    public void dfs(char[][] grid,int i,int j){
        if(i<0 || j<0 || i>=grid.length|| j >=grid[0].length || grid[i][j]== '0') return;

        grid[i][j]='0';//考虑到连续岛屿,即连续的1
        dfs(grid,i+1,j);
        dfs(grid,i,j+1);
        dfs(grid,i,j-1);
        dfs(grid,i-1,j);
    }
}

L;685

L113:路径总和||
【刷题】不同专题篇_第65张图片

L332:

L337: 打家劫舍|||
【刷题】不同专题篇_第66张图片
思路:
【刷题】不同专题篇_第67张图片
代码:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        int[] res = dfs(root);
        return Math.max(res[0],res[1]); 
    }

    public int[] dfs(TreeNode node){
        if(node==null) return new int[]{0,0};

        // 由于需要后序遍历,所以先计算左右子结点,然后计算当前结点的状态值
        int[] left = dfs(node.left);
        int[] right = dfs(node.right);

        int select = node.val+left[1]+right[1];//选择当前节点,则它的左右孩子都不能选
        int NotSelect = Math.max(left[0],left[1])+Math.max(right[0],right[1]);
        //不选该节点,它的左右孩子可以选,而且可以都选

        return new int[]{select,NotSelect};
    }
}

13、动态规划

L213:打家劫舍||

  • 和T198相比(首尾不相邻),只是多了选大小的语句
  • 首尾相邻,结果只有两种情况;
    1、选第一个,最后一个不选,那么在【0,n-2】区间进行T198的计算
    2、不选第一个,最后一个选,那么在【1,n-1】区间进行T198的计算
  • 然后针对1和2的结果,选择大的那个即可

【刷题】不同专题篇_第68张图片

L123:

【刷题】不同专题篇_第69张图片
【刷题】不同专题篇_第70张图片
【刷题】不同专题篇_第71张图片
【刷题】不同专题篇_第72张图片

L62:不同路径
【刷题】不同专题篇_第73张图片

思路:动态规划
每次只能向右或向下走
【刷题】不同专题篇_第74张图片
优化:
cur[j] = cur[j-1] + cur[j]
未赋值之前右边的cur[j] 始终表示当前行第i行的上一行(i-1行)第j列的值,i
赋值之后左边的cur[j]表示当前行第i行第j列的值,cur[j-1] 表示当前行第i行第j-1列的值(cur[j-1] 在计算cur[j]之前就已经计算了,所以表示的是当前行而不是上一行 )

代码:

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];

        for(int i=0;i<m;i++){ dp[i][0] =1;}
        for(int i=0;i<n;i++){ dp[0][i] =1;}
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j] = dp[i][j-1] + dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
}

优化:

class Solution {
    public int uniquePaths(int m, int n) {
        int[] cur = new int[n];

        Arrays.fill(cur,1);
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                cur[j] = cur[j] + cur[j-1];
                //第一个cur[j]:当第i行j列的;第二个cur[j]:当前行的上一行和第j列的,即i-行,j列;
                // cur[j-1]:当前行,j-1列,即i行j-1列
            }           
        }
        return cur[n-1];
    }
}

L:63
【刷题】不同专题篇_第75张图片

【刷题】不同专题篇_第76张图片

L:361

L:1230

14、贪心

做出在当前看来是最好的选择 以迭代的方法做出相继的贪心选择,每做一次贪心选择,就将所求问题简化为一个规模更小的子问题,通过每一步贪心选择,可得到问题的一个最优解。虽然每一步上都要保证能获得局部最优解,但由此产生的全局解有时不一定是最优的,所以贪心算法不要回溯。
L:55

【刷题】不同专题篇_第77张图片

遍历数组每个数,每次更新当前可到达的最远位置,即索引,如果遇到最远位置(索引)超过数组末尾索引,说明可以达到;如果遍历完了,最远位置的记录值小于最后一个位置,则不可达。【注意】最远位置即数组的索引值,而不是说当前数后移多少个位置。
【刷题】不同专题篇_第78张图片
【刷题】不同专题篇_第79张图片

L:435
【刷题】不同专题篇_第80张图片

【刷题】不同专题篇_第81张图片

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        int count=0;//记录重叠区间的个数
        if(intervals.length==0) return 0;

        Arrays.sort(intervals,new Comparator<int[]>(){
            public int compare(int[] o1,int[] o2){
                return o1[1] - o2[1];
            }
        });

        int rightEnd = intervals[0][1];//排序后首个区间的右端点
        for(int i =1;i<intervals.length;i++){
            if(intervals[i][0]>=rightEnd){//说明没有重叠,更新区间
                rightEnd = intervals[i][1];
            }else count++;
        }
        return count;
    }
}

L621: 任务调度器
【刷题】不同专题篇_第82张图片
【刷题】不同专题篇_第83张图片

思路:填桶
【刷题】不同专题篇_第84张图片
【刷题】不同专题篇_第85张图片
【刷题】不同专题篇_第86张图片
【刷题】不同专题篇_第87张图片

代码:

class Solution {
    public int leastInterval(char[] tasks, int n) {
        int[] buckets = new int[26];
        //统计每个任务出现的次数
        for(char task : tasks){
            buckets[task - 'A'] +=1;
        }

        int max=0;//计算出现次数最多的任务
        for(int i=0;i<26;i++){
            max = Math.max(buckets[i],max);
        }

        //计算maxCount
        int maxCount=0;//这个是0,而不是初始化为1
        for(int i=0;i<26;i++){//因为遍历时把26个都遍历了,包括最大任务,所以最后maxCount必>=1;
            if(buckets[i]==max){
                maxCount++;
            }
        }

        int res=0;
        res = Math.max( (max-1)*(n+1)+maxCount, tasks.length);

        return res;
    }
}

L:452

【刷题】不同专题篇_第88张图片
【刷题】不同专题篇_第89张图片

15、字典树

L820:单词的压缩编码

L208:

L648:

你可能感兴趣的:(求职路,算法,leetcode)