【Android春招每日一练】（三十） LeetCode Hot 5题

概览

LeetCode Hot：多数元素、打家劫舍、岛屿数量、反转链表、课程表

LeetCode Hot

2.56 多数元素

同剑指offer38题 摩尔投票法

2.57 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

//DP
//dp[n+1] = max(dp[n],dp[n-1]+num)
class Solution {
    public int rob(int[] nums) {
        int pre = 0, cur = 0, tmp;       //pre表示当前房间的上一间的上一间房，cur（未更新前）表示当前房间上一间房
        for(int num : nums) {
            tmp = cur;
            cur = Math.max(pre + num, cur); //偷当前这间（pre+num）和不偷这间（cur）中取最大的
            pre = tmp;
        }
        return cur;
    }
}

2.58 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

//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
                    dfs(grid, i, j);
                    count++;			//岛屿数量++
                }
            }
        }
        return count;
    }
    private 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';		//已经搜索过当前网格，将网格清除（置为0）
        dfs(grid, i + 1, j);	//继续搜索为1的网格，直到周围全是0，从而组成1个岛屿
        dfs(grid, i, j + 1);
        dfs(grid, i - 1, j);
        dfs(grid, i, j - 1);
    }
}

2.59 反转链表

同剑指offer22题 双指针

2.60 课程表

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：
输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

//DFS，拓扑排序
/*
i == 0 ： 干净的，未被 DFS 访问
i == -1：其他节点启动的 DFS 访问过了，路径没问题，不需要再访问了
i == 1  ：本节点启动的 DFS 访问过了，一旦遇到了也说明有环了
*/
class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<List<Integer>> adjacency = new ArrayList<>();
        for(int i = 0; i < numCourses; i++)
            adjacency.add(new ArrayList<>());
        int[] flags = new int[numCourses];
        for(int[] cp : prerequisites)		//建立邻接表
            adjacency.get(cp[1]).add(cp[0]);
        for(int i = 0; i < numCourses; i++)//遍历每个节点开始dfs
            if(!dfs(adjacency, flags, i)) return false;
        return true;
    }
    private boolean dfs(List<List<Integer>> adjacency, int[] flags, int i) {
        if(flags[i] == 1) return false;  //先判断再修改标志位
        if(flags[i] == -1) return true;  //别的dfs路径访问过了，我不需要访问了
        flags[i] = 1;   //只有这个标志位是干净的，别人还没有动过，我才能标记为1，说明本次dfs我遍历过它
        for(Integer j : adjacency.get(i))
           if(!dfs(adjacency, flags, j))
               return false;
        flags[i] = -1;    //只有一次DFS完整结束了，才能执行到这一步，标记为-1，说明这条路没问题，再遇到不需要遍历了
        return true;
    }
}

总结

1.复习ing…