【leetcode刷题笔记（9）】

（1）152. 乘积最大子数组（错1）

题解思路：动态规划，同时存储到当前位置的最大和最小值，但遇到负数时，最大值和最小值交换后再乘当前数字。

class Solution {
    public int maxProduct(int[] nums) {
        int[] dp = new int[nums.length];
        int res = Integer.MIN_VALUE;
        int maxNum = 1;
        int minNum = 1;

        for(int i = 0; i < nums.length; i++){
            if(nums[i] < 0){
                int temp = maxNum;
                maxNum = minNum;
                minNum = temp;
            }
            dp[i] = Math.max(maxNum * nums[i], nums[i]);
            maxNum = Math.max(maxNum * nums[i], nums[i]);
            minNum = Math.min(minNum * nums[i], nums[i]);
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

（2）200. 岛屿数量

思路：dfs，使用一个二维数组记录每个数字是否被遍历过，遍历数字，当是岛屿且没有被遍历过时，使用dfs遍历与其联通的岛屿，并记录下来，以免重复遍历。
注意：框架很重要，做完题要进行归纳总结方法，记住常用框架

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

（3）1254. 统计封闭岛屿的数目（错1）

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

（4）1020. 飞地的数量

思路：先遍历岸边的数字，将与其连通的土地都置为0，再遍历填海后的数组，记录仍为土地的数量。

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

（5）695. 岛屿的最大面积

思路：使用一个全局变量记录当前探索岛屿所探索到的面积，深度优先遍历该岛屿，每次探索新岛屿时，将该全局变量置为0；

class Solution {
    int count;
    public int maxAreaOfIsland(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int maxArea = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == 1){
                    count = 0;
                    dfs(grid, i, j);
                    maxArea = Math.max(maxArea, count);
                }
            }
        }
        return maxArea;
    }
    public void dfs(int[][] grid, int i, int j){
        int n = grid.length;
        int m = grid[0].length;
        if(i < 0 || j < 0 || i >= n || j >= m){
            return;
        }
        if(grid[i][j] == 0){
            return;
        }
        grid[i][j] = 0;
        count++;
        dfs(grid, i-1, j);
        dfs(grid, i+1, j);
        dfs(grid, i, j-1);
        dfs(grid, i, j+1);
    }
}

（6）1905. 统计子岛屿

class Solution {
    boolean flag;
    public int countSubIslands(int[][] grid1, int[][] grid2) {
        int n2 = grid2.length;
        int m2 = grid2[0].length;
        int count = 0;
        for(int i = 0; i < n2; i++){
            for(int j = 0; j < m2; j++){
                if(grid2[i][j] == 1){
                    flag = true;
                    dfs(grid1, grid2, i, j);
                    if(flag){
                        count++;
                    }
                }
            }
        }
        return count;
    }
    public void dfs(int[][] grid1, int[][] grid2, int i, int j){
        int n = grid2.length;
        int m = grid2[0].length;
        if(i < 0 || j < 0 || i >= n || j >= m){
            return;
        }
        if(grid2[i][j] == 0){
            return;
        }
        if(grid1[i][j] == 0){
            flag = false;
        }
        grid2[i][j] = 0;
        dfs(grid1, grid2, i-1, j);
        dfs(grid1, grid2, i+1, j);
        dfs(grid1, grid2, i, j-1);
        dfs(grid1, grid2, i, j+1);
    }
}

（7）704. 二分查找

二分查找模板

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left <= right){  //注意
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid - 1;
            }
        }
        return -1;
    }
}

（8）34. 在排序数组中查找元素的第一个和最后一个位置

思路：二分查找左右边界的模板

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[2];
        if(nums.length == 0){
            return new int[]{-1,-1};
        }
        
        int left = 0;
        int right = nums.length;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                right = mid;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid;
            }
        }
        if(left >= 0 && left < nums.length && nums[left] == target){
            res[0] = left;
        }else{
            res[0] = -1;
            res[1] = -1;
            return res;
        }

        right = nums.length;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                left = mid + 1;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid;
            }
        }
        res[1] = left - 1;
        return res;
    }
}

模板二**

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums.length == 0){
            return new int[]{-1,-1};
        }
        int[] res = new int[2];
        int left = 0;
        int right = nums.length-1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid - 1;
            }else if(nums[mid] == target){
                right = mid - 1;
            }
        }
        if(left >= 0 && left < nums.length && nums[left] == target){
            res[0] = left;
        }else{
            return new int[]{-1,-1};
        }

        right = nums.length-1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid - 1;
            }else if(nums[mid] == target){
                left = mid + 1;
            }
        }

        if(right >= 0 && right< nums.length && nums[right] == target){
            res[1] = right;
        }else{
            return new int[]{-1,-1};
        }
        return res;
    }
}

（9）134. 加油站

题解思路：当到i站，油无法满足时，起点更改为i+1站

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int start = 0;
        int run = 0;
        int rest = 0;
        for(int i = 0; i < gas.length; i++){
            run += (gas[i] - cost[i]);
            rest += (gas[i] - cost[i]);
            if(run < 0){
                start = i + 1;
                run = 0;
            }
        }
        return rest < 0 ? -1: start;
    }
}

（10）316. 去除重复字母(错1)

题解思路：

String removeDuplicateLetters(String s) {
    Stack<Character> stk = new Stack<>();

    // 维护一个计数器记录字符串中字符的数量
    // 因为输入为 ASCII 字符，大小 256 够用了
    int[] count = new int[256];
    for (int i = 0; i < s.length(); i++) {
        count[s.charAt(i)]++;
    }

    boolean[] inStack = new boolean[256];
    for (char c : s.toCharArray()) {
        // 每遍历过一个字符，都将对应的计数减一
        count[c]--;

        if (inStack[c]) continue;

        while (!stk.isEmpty() && stk.peek() > c) {
            // 若之后不存在栈顶元素了，则停止 pop
            if (count[stk.peek()] == 0) {
                break;
            }
            // 若之后还有，则可以 pop
            inStack[stk.pop()] = false;
        }
        stk.push(c);
        inStack[c] = true;
    }

    StringBuilder sb = new StringBuilder();
    while (!stk.empty()) {
        sb.append(stk.pop());
    }
    return sb.reverse().toString();
}