不要摆，没事干就刷题，只有好处，没有坏处，实在不行，看看竞赛题

面试经典 150 题 - 2

面试经典 150 题

210. 课程表 II

210. 课程表 II

• 一眼拓扑排序. 好久没写过拓扑排序了，写得特别糟糕

public int[] findOrder(int n, int[][] prerequisites) {
   int[] order = new int[n];
   if (prerequisites == null) {
       for (int i = 0; i < n; i++) order[i] = i;
       return order;
   }

   // 创建邻接表 和 入度数组
   ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
   for (int i = 0; i < n; i++) {
       adj.add(new ArrayList<>());
   }
   int[] inDegree = new int[n];
   for (int[] prerequisite : prerequisites) {
       adj.get(prerequisite[1]).add(prerequisite[0]);
       inDegree[prerequisite[0]]++;
   }

   // 入度队列 （不需要栈）
   Stack<Integer> s = new Stack<>();
   for (int i = 0; i < inDegree.length; i++) {
       if (inDegree[i] == 0) s.push(i);
   }

   // 拓扑排序
   int cnt = 0;
   for (int i = 0; i < n; i++) {
       if (s.isEmpty()) break;
       Integer pop = s.pop();
       order[cnt++] = pop;
       for (Integer x : adj.get(pop)) {
           inDegree[x]--;
           if (inDegree[x] == 0) {
               s.push(x);
           }
       }
   }

   if (cnt < n) return new int[0];
   return order;
}

• 看了下大佬的做法，发现确实有几处值得修改

主要就是度为0的不必非要用栈，用队列也行，队列直接作为拓扑排序的终止条件即可
没有前置关系时不需要要特判，全是度为0的节点，也可以照常执行
不要用statck，继承了Vector, 有很多锁，效率很低

修改后4ms,差不多了吧

public int[] findOrder(int n, int[][] prerequisites) {
    // 创建邻接表 和 入度数组
    ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
    for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
    int[] inDegree = new int[n];
    for (int[] prerequisite : prerequisites) {
        adj.get(prerequisite[1]).add(prerequisite[0]);
        inDegree[prerequisite[0]]++;
    }

    // 入度队列 （不需要栈）
    Deque<Integer> q = new LinkedList<>();
    for (int i = 0; i < inDegree.length; i++) {
        if (inDegree[i] == 0) q.offer(i);
    }

    // 拓扑排序
    int[] order = new int[n];
    int cnt = 0;
    while (!q.isEmpty()){
        Integer pop = q.poll();
        order[cnt++] = pop;
        for (Integer x : adj.get(pop)) {
            inDegree[x]--;
            if (inDegree[x] == 0) q.push(x);
        }
    }

    if (cnt < n) return new int[0];
    return order;
}

909. 蛇梯棋

909. 蛇梯棋

一眼望去，D/BFS都行，BFS应该更加节省时间
先用BFS试试，就是每次维护下一层就是了，6叉树而已

自己做法，6ms, 感觉比较麻烦，依靠3个测试数据修改了3次错误

public int snakesAndLadders(int[][] board) {
    int n = board.length;

    Deque<Integer> q = new LinkedList<>();
    q.offer(1);

    int k = 0;
    HashSet<Integer> set = new HashSet<>();//如果队的就不要重复入了 反正只会更长
    set.add(1);
    while (!q.isEmpty()) {
        int size = q.size();
        k++;
        if (k > n * n / 6 + 1) return -1;//有可能到达不了
        for (int i = 0; i < size; i++) {
            int top = q.poll();
            // 下层6个子结点
            for (int j = top + 1; j <= top + 6; j++) {
                int x = (n - 1) - (j - 1) / n;
                int y = (j - 1) % n;//先假设从左往右
                if((j - 1) / n % 2 == 1) y = (n - 1) - y; //结果是从右往左
                int next = board[x][y] == -1 ? j : board[x][y];
                if (!set.contains(next)) {
                    set.add(next);
                    q.offer(next);
                    if (next == n * n) {
                        return k;
                    }
                }

            }
        }
    }
    return -1;
}

看了下官解，思路完全一样，唯一差别就是hashSet换成了Boolean[]数组，速度上快几毫秒，换过来之后才3ms了

public int snakesAndLadders(int[][] board) {
   int n = board.length;

   Deque<Integer> q = new LinkedList<>();
   q.offer(1);

   int k = 0;
   boolean[] visited = new boolean[n * n + 1];//如果队的就不要重复入了 反正只会更长
   visited[1] = true;
   while (!q.isEmpty()) {
       int size = q.size();
       k++;
       if (k > n * n / 6 + 1) return -1;//有可能到达不了
       for (int i = 0; i < size; i++) {
           int top = q.poll();
           // 下层6个子结点
           for (int j = top + 1; j <= top + 6; j++) {
               int x = (n - 1) - (j - 1) / n;
               int y = (j - 1) % n;//先假设从左往右
               if ((j - 1) / n % 2 == 1) y = (n - 1) - (j - 1) % n; //结果是从右往左
               int next = board[x][y] == -1 ? j : board[x][y];
               if (!visited[next]){
                   visited[next] = true;
                   q.offer(next);
                   if (next == n * n) {
                       return k;
                   }
               }

           }
       }
   }
   return -1;
}