【刷题】不同专题篇

递归： 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：爬楼梯（斐波那契数列）

L112：路径总和

L509：斐波那契数列

2、分治

L23：合并K个升序链表

分而治之

L169：多数元素（超过一半的数字）

3、单调栈

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

L84：柱状图中最大矩形

1、暴力解法：


2、+单调栈

上文中，定义了-1和8。表示当前柱子左侧/右侧最近的柱子没有比自己低的，故高度还是本身。

例如：[-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：最大矩形

代码：

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：每日温度

L503: 下一个更大的元素

4、并查集

就是集合，能够快速合并，能够快速查询两个节点是否在同一集合中的一种数据结构。一般用树（数组）实现。（并查集基本上可以用DFS、BFS来解决）

5、滑动窗口

L209：长度最小的子数组

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

L1004:最大连续1的个数 III

6、前缀和

L724:寻找数组的中心下标

L560：和为K的子数组

前缀和+哈希表 的改进参考Hot100题解

L437：路径总和 III

L1248:统计优美子数组

7、拆分(差分）

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

L1094：拼车

8、拓扑排序

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

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

L210：课程表 II

入度：指向当前节点的边，有几条入度就是几

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：回文子串

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

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

代码：

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;
    }
}

动态规划：

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：有效括号

L43：字符串相乘

主要是有大数

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：搜索旋转排序数组

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：在排序数组中查找元素的第一个和最后一个位置

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

代码：

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：被包围的区域

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

L200：岛屿数量

思路：深度优先dfs

代码：

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：路径总和||

L332：

L337: 打家劫舍|||

思路：

代码：

/**
 * 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的结果，选择大的那个即可

L123：

L62：不同路径

思路：动态规划
每次只能向右或向下走

优化：
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

L：361

L：1230

14、贪心

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

遍历数组每个数，每次更新当前可到达的最远位置，即索引，如果遇到最远位置(索引)超过数组末尾索引，说明可以达到；如果遍历完了，最远位置的记录值小于最后一个位置，则不可达。【注意】最远位置即数组的索引值，而不是说当前数后移多少个位置。

L：435

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: 任务调度器

思路：填桶

代码：

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

15、字典树

L820：单词的压缩编码

L208：

L648：