# Course Schedule

## Problem

There are a total of n courses you have to take, labeled from 0 to n – 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

``````2, [[1,0]]
``````

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

``````2, [[1,0],[0,1]]
``````

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

One simple way to represent a graph is just a list, or array, of |E| edges, which we call an edge list. To represent an edge, we just have an array of two vertex numbers, or an array of objects containing the vertex numbers of the vertices that the edges are incident on. If edges have weights, add either a third element to the array or more information to the object, giving the edge’s weight. Since each edge contains just two or three numbers, the total space for an edge list is Θ(E).

## Solution

### Graph using HashMap Queue

``````public class Solution {
public boolean canFinish(int n, int[][] p) {
Map<Integer, List<Integer>> graph = new HashMap<>();
int[] in = new int[n];
for (int i = 0; i < p.length; i  ) {
if (!graph.containsKey(p[i][1])) graph.put(p[i][1], new ArrayList<>());
in[p[i][0]]  ;
}
for (int i = 0; i < in.length; i  ) {
if (in[i] == 0) q.offer(i);
}
int count = 0;
while (!q.isEmpty()) {
Integer from = q.poll();
count  ;
List<Integer> to = graph.get(from);
if (to == null) continue;
for (Integer i: to) {
in[i]--;
if (in[i] == 0) q.offer(i);
}
}
return count == n;
}
}``````

### Graph using Queue

``````public class Solution {
public boolean canFinish(int n, int[][] p) {
int[] in = new int[n];
for (int i = 0; i < p.length; i  ) {
in[p[i][0]]  ;
}
for (int i = 0; i < in.length; i  ) {
if (in[i] == 0) q.offer(i);
}
while (!q.isEmpty()) {
int cur = q.poll();
for (int i = 0; i < p.length; i  ) {
if (cur == p[i][1]) {in[p[i][0]]--;
if (in[p[i][0]] == 0) q.offer(p[i][0]);}
}
}
for (int i = 0; i < in.length; i  ) {
if (in[i] != 0) return false;
}
return true;
}
}``````

# Course Schedule II

## Problem

There are a total of n courses you have to take, labeled from 0 to n – 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

For example:

2, [[1,0]]
There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1]

4, [[1,0],[2,0],[3,1],[3,2]]
There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].

## Solution

``````public class Solution {
public int[] findOrder(int n, int[][] p) {
int[] res = new int[n];
int[] in = new int[n];
for (int i = 0; i < p.length; i  ) {
in[p[i][0]]  ;
}
for (int i = 0; i < in.length; i  ) {
if (in[i] == 0) q.offer(i);
}
int index = 0;
while (!q.isEmpty()) {
Integer cur = q.poll();
res[index  ] = cur;
for (int i = 0; i < p.length; i  ) {
if (p[i][1] == cur) {
in[p[i][0]]--;
if (in[p[i][0]] == 0) q.offer(p[i][0]);
}
}
}
return index == n ? res: new int[0];
}
}
``````

# Alien Dictionary

## Problem

There is a new alien language which uses the latin alphabet. However, the order among letters are unknown to you. You receive a list of words from the dictionary, where words are sorted lexicographically by the rules of this new language. Derive the order of letters in this language.

For example,
Given the following words in dictionary,

``````[
"wrt",
"wrf",
"er",
"ett",
"rftt"
]
``````

The correct order is: “wertf”.

Note:
You may assume all letters are in lowercase.
If the order is invalid, return an empty string.
There may be multiple valid order of letters, return any one of them is fine.