Skip to content

Commit aa8d52a

Browse files
yennanliuyennanliu
committed
update 207 java, progress
1 parent 983533a commit aa8d52a

File tree

5 files changed

+235
-81
lines changed

5 files changed

+235
-81
lines changed

‎README.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -917,8 +917,8 @@
917917
127| [Word Ladder](https://leetcode.com/problems/word-ladder/)| [Python](./leetcode_python/Breadth-First-Search/word-ladder.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/WordLadder.java) | _O(n * d)_ | _O(d)_ | Hard/Medium |good basic, check #126 Word Ladder II, `bfs`, `UBER`, `amazon`, `M$`, `fb`| AGAIN************** (9)
918918
130| [Surrounded Regions](https://leetcode.com/problems/surrounded-regions/)| [Python](./leetcode_python/Breadth-First-Search/surrounded-regions.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/SurroundedRegions.java) | _O(m + n)_ | | Medium |`bfs`, `dfs`,`union find`,good basic, `amazon`| AGAIN*********** (5)
919919
133| [Clone Graph](https://leetcode.com/problems/clone-graph/)| [Python](./leetcode_python/Breadth-First-Search/clone-graph.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Graph/CloneGraph.java) | _O(n)_ | _O(n)_ | Medium |Curated Top 75, good trick, `check #138 Copy List with Random Pointer `,`graph`,`dfs`,`bfs`, `UBER`, `google`,`amazon`,`fb`| AGAIN**************** (10) (MUST)
920-
207| [Course Schedule](https://leetcode.com/problems/course-schedule/)| [Python](./leetcode_python/Breadth-First-Search/course-schedule.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/CourseSchedule.java) | _O(\|V\| + \|E\|)_ | _O(\|E\|)_ | Medium |Curated Top 75, Topological Sort, backtrack, `good trick`,`dfs`, `bfs` , `amazon`,`fb`| AGAIN**************** (13) (MUST)
921-
210| [Course Schedule II](https://leetcode.com/problems/course-schedule-ii/)| [Python](./leetcode_python/Breadth-First-Search/course-schedule-ii.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/CourseSchedule2.java) | _O(\|V\| + \|E\|)_ | _O(\|E\|)_ | Medium |Topological Sort,check `# 207 Course Schedule ` first, `dfs`, `bfs` ,`amazon` ,`fb` | AGAIN********* (10) (again)
920+
207| [Course Schedule](https://leetcode.com/problems/course-schedule/)| [Python](./leetcode_python/Breadth-First-Search/course-schedule.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/CourseSchedule.java) | _O(\|V\| + \|E\|)_ | _O(\|E\|)_ | Medium |Curated Top 75, Topological Sort, LC 210, `good trick`,`dfs`, `bfs` , `amazon`,`fb`| AGAIN**************** (14) (MUST)
921+
210| [Course Schedule II](https://leetcode.com/problems/course-schedule-ii/)| [Python](./leetcode_python/Breadth-First-Search/course-schedule-ii.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/CourseSchedule2.java) | _O(\|V\| + \|E\|)_ | _O(\|E\|)_ | Medium |Topological Sort,LC 207, dfs ,`amazon` ,`fb` | AGAIN********* (10) (again)
922922
261| [Graph Valid Tree](https://leetcode.com/problems/graph-valid-tree/)| [Python](./leetcode_python/Breadth-First-Search/graph-valid-tree.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/GraphValidTree.java) | _O(\|V\| + \|E\|)_ | _O(\|V\| + \|E\|)_ | Medium | Curated Top 75, AGAIN, bfs, dfs, grpah, 🔒, `graph`,`quick union`,`union find` ,`google`,`amazon`,`fb`| AGAIN************* (11)(MUST)
923923
286| [Walls and Gates](https://leetcode.com/problems/walls-and-gates/)| [Python](./leetcode_python/Breadth-First-Search/walls-and-gates.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/BFS/WallsAndGates.java)| _O(m * n)_ | _O(g)_ | Medium | 🔒, `dfs`, `bfs` , `good basic`, `google`,`amazon`,`FB`| AGAIN******** (7)
924924
310| [Minimum Height Trees](https://leetcode.com/problems/minimum-height-trees/)| [Python](./leetcode_python/Breadth-First-Search/minimum-height-trees.py) | _O(n)_ | _O(n)_ | Medium |`complex`| AGAIN (3) (not start)

‎data/progress.txt‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
20241110: 53,210
2-
20241109: 207,444
1+
20241110: 53,210,207
2+
20241109: 444
33
20241108: 1188,130,855(again)
44
20241104: 207
55
20241103: 900

‎data/to_review.txt‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,39 +1,39 @@
1-
2025-01-04 -> ['53,210']
2-
2025-01-03 -> ['207,444']
1+
2025-01-04 -> ['53,210,207']
2+
2025-01-03 -> ['444']
33
2025-01-02 -> ['1188,130,855(again)']
44
2024-12-28 -> ['900']
55
2024-12-27 -> ['26,27', '802,1197,26']
66
2024-12-21 -> ['855,846']
77
2024-12-20 -> ['932']
88
2024-12-18 -> ['951,792']
9-
2024-12-14 -> ['53,210', '163,1048']
10-
2024-12-13 -> ['207,444', '298,729']
9+
2024-12-14 -> ['53,210,207', '163,1048']
10+
2024-12-13 -> ['444', '298,729']
1111
2024-12-12 -> ['1188,130,855(again)', '1146']
1212
2024-12-08 -> ['737']
1313
2024-12-07 -> ['900', '686,734,737']
1414
2024-12-06 -> ['26,27', '802,1197,26', '353']
1515
2024-12-05 -> ['528,334']
1616
2024-12-03 -> ['1145']
17-
2024-12-01 -> ['53,210']
18-
2024-11-30 -> ['207,444', '855,846', '1145,1219']
17+
2024-12-01 -> ['53,210,207']
18+
2024-11-30 -> ['444', '855,846', '1145,1219']
1919
2024-11-29 -> ['1188,130,855(again)', '932']
2020
2024-11-27 -> ['951,792', '524,221,889']
2121
2024-11-26 -> ['743,889']
2222
2024-11-25 -> ['837']
2323
2024-11-24 -> ['900']
24-
2024-11-23 -> ['53,210', '26,27', '802,1197,26', '163,1048', '981']
25-
2024-11-22 -> ['207,444', '298,729', '1087']
24+
2024-11-23 -> ['53,210,207', '26,27', '802,1197,26', '163,1048', '981']
25+
2024-11-22 -> ['444', '298,729', '1087']
2626
2024-11-21 -> ['1188,130,855(again)', '1146']
2727
2024-11-20 -> ['939']
28-
2024-11-18 -> ['53,210', '430']
29-
2024-11-17 -> ['207,444', '855,846', '737', '363']
28+
2024-11-18 -> ['53,210,207', '430']
29+
2024-11-17 -> ['444', '855,846', '737', '363']
3030
2024-11-16 -> ['1188,130,855(again)', '900', '932', '686,734,737', '1032,844,1011']
31-
2024-11-15 -> ['53,210', '26,27', '802,1197,26', '353', '947']
32-
2024-11-14 -> ['207,444', '951,792', '528,334']
33-
2024-11-13 -> ['53,210', '1188,130,855(again)']
34-
2024-11-12 -> ['53,210', '207,444', '1145', '753']
35-
2024-11-11 -> ['53,210', '207,444', '1188,130,855(again)', '900', '727']
36-
2024-11-10 -> ['207,444', '1188,130,855(again)', '26,27', '802,1197,26', '163,1048']
31+
2024-11-15 -> ['53,210,207', '26,27', '802,1197,26', '353', '947']
32+
2024-11-14 -> ['444', '951,792', '528,334']
33+
2024-11-13 -> ['53,210,207', '1188,130,855(again)']
34+
2024-11-12 -> ['53,210,207', '444', '1145', '753']
35+
2024-11-11 -> ['53,210,207', '444', '1188,130,855(again)', '900', '727']
36+
2024-11-10 -> ['444', '1188,130,855(again)', '26,27', '802,1197,26', '163,1048']
3737
2024-11-09 -> ['1188,130,855(again)', '855,846', '298,729', '1145,1219']
3838
2024-11-08 -> ['900', '932', '1146']
3939
2024-11-07 -> ['26,27', '802,1197,26']

‎leetcode_java/src/main/java/LeetCodeJava/BFS/CourseSchedule.java‎

Lines changed: 85 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,13 +6,96 @@
66

77
public class CourseSchedule {
88

9-
// V0
9+
// IDEA : TOPOLOGICAL SORT
10+
// LC 210
11+
public boolean canFinish(int numCourses, int[][] prerequisites) {
12+
if (prerequisites.length==0){
13+
return true;
14+
}
15+
16+
if (TopologicalSort(numCourses, prerequisites) == null){
17+
return false;
18+
}
19+
20+
return true;
21+
}
22+
23+
public List<Integer> TopologicalSort(int numNodes, int[][] edges) {
24+
// Step 1: Build the graph and calculate in-degrees
25+
Map<Integer, List<Integer>> graph = new HashMap<>();
26+
int[] inDegree = new int[numNodes];
27+
28+
for (int i = 0; i < numNodes; i++) {
29+
graph.put(i, new ArrayList<>());
30+
}
31+
32+
for (int[] edge : edges) {
33+
int from = edge[0];
34+
int to = edge[1];
35+
graph.get(from).add(to);
36+
inDegree[to]++;
37+
}
38+
39+
// Step 2: Initialize a queue with nodes that have in-degree 0
40+
Queue<Integer> queue = new LinkedList<>();
41+
for (int i = 0; i < numNodes; i++) {
42+
/**
43+
* NOTE !!!
44+
*
45+
* we add ALL nodes with degree = 0 to queue at init step
46+
*/
47+
if (inDegree[i] == 0) {
48+
queue.offer(i);
49+
}
50+
}
51+
52+
List<Integer> topologicalOrder = new ArrayList<>();
53+
54+
// Step 3: Process the nodes in topological order
55+
while (!queue.isEmpty()) {
56+
/**
57+
* NOTE !!!
58+
*
59+
* ONLY "degree = 0" nodes CAN be added to queue
60+
*
61+
* -> so we can add whatever node from queue to final result (topologicalOrder)
62+
*/
63+
int current = queue.poll();
64+
topologicalOrder.add(current);
65+
66+
for (int neighbor : graph.get(current)) {
67+
inDegree[neighbor] -= 1;
68+
/**
69+
* NOTE !!!
70+
*
71+
* if a node "degree = 0" means this node can be ACCESSED now,
72+
*
73+
* -> so we need to add it to the queue (for adding to topologicalOrder in the following while loop iteration)
74+
*/
75+
if (inDegree[neighbor] == 0) {
76+
queue.offer(neighbor);
77+
}
78+
}
79+
}
80+
81+
// If topologicalOrder does not contain all nodes, there was a cycle in the graph
82+
if (topologicalOrder.size() != numNodes) {
83+
//throw new IllegalArgumentException("The graph has a cycle, so topological sort is not possible.");
84+
return null;
85+
}
86+
87+
/** NOTE !!! reverse ordering */
88+
Collections.reverse(topologicalOrder);
89+
return topologicalOrder;
90+
}
91+
92+
// V0'
1093
// IDEA : DFS (fix by gpt)
1194
// NOTE !!! instead of maintain status (0,1,2), below video offers a simpler approach
1295
// -> e.g. use a set, recording the current visiting course, if ANY duplicated (already in set) course being met,
1396
// -> means "cyclic", so return false directly
1497
// https://www.youtube.com/watch?v=EgI5nU9etnU
15-
public boolean canFinish(int numCourses, int[][] prerequisites) {
98+
public boolean canFinish_0_0(int numCourses, int[][] prerequisites) {
1699
// Initialize adjacency list for storing prerequisites
17100
/**
18101
* NOTE !!!

‎leetcode_java/src/main/java/dev/workspace5.java‎

Lines changed: 130 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -2726,85 +2726,156 @@ public boolean canFinish(int numCourses, int[][] prerequisites) {
27262726
if (prerequisites.length==0){
27272727
return true;
27282728
}
2729-
// if (prerequisites.length==1){
2730-
// return true;
2731-
// }
2732-
2733-
return false;
2734-
}
27352729

2736-
/**
2737-
* int[][] prerequisites: [1, 2], so 1 is 2's prerequisite
2738-
*
2739-
*/
2740-
private List<Integer> topoSort(int numCourses, int[][] prerequisites){
2730+
if (TopologicalSort(numCourses, prerequisites) == null){
2731+
return false;
2732+
}
27412733

2742-
//int[] tSorting = new int[]{numCourses};
2734+
return true;
2735+
}
27432736

2744-
// init : 1) preList 2) degree
2745-
Map<Integer, List<Integer>> preList = new HashMap<>();
2746-
List<Integer> degrees = new ArrayList<>();
2747-
List<Integer> res = new ArrayList<>();
2737+
public List<Integer> TopologicalSort(int numNodes, int[][] edges) {
2738+
// Step 1: Build the graph and calculate in-degrees
2739+
Map<Integer, List<Integer>> graph = new HashMap<>();
2740+
int[] inDegree = new int[numNodes];
27482741

2749-
// init all degree as 0
2750-
for (int i = 0; i < numCourses; i++){
2751-
degrees.add(i);
2742+
for (int i = 0; i < numNodes; i++) {
2743+
graph.put(i, new ArrayList<>());
27522744
}
27532745

2754-
// init preList and update degrees
2755-
for (int[] x : prerequisites){
2756-
int pre = x[0];
2757-
int cur = x[1]; // ???
2758-
2759-
// update degrees
2760-
degrees.set(cur, degrees.get(cur)+1); // ???
2761-
// update PreList
2762-
if (!preList.containsKey(pre)){
2763-
preList.put(pre, new ArrayList<>());
2764-
}else{
2765-
List<Integer> curItems = preList.get(pre);
2766-
curItems.add(cur);
2767-
preList.put(pre, curItems);
2768-
//preList.put(pre, preList.get(pre).add(cur));
2769-
}
2746+
for (int[] edge : edges) {
2747+
int from = edge[0];
2748+
int to = edge[1];
2749+
graph.get(from).add(to);
2750+
inDegree[to]++;
27702751
}
27712752

2772-
2773-
Queue<Integer> queue = new LinkedList();
2774-
// add all node with degree=0 to queue
2775-
for (int j = 0; j < degrees.size(); j++){
2776-
if (degrees.get(j).equals(0)){
2777-
queue.add(j);
2753+
// Step 2: Initialize a queue with nodes that have in-degree 0
2754+
Queue<Integer> queue = new LinkedList<>();
2755+
for (int i = 0; i < numNodes; i++) {
2756+
/**
2757+
* NOTE !!!
2758+
*
2759+
* we add ALL nodes with degree = 0 to queue at init step
2760+
*/
2761+
if (inDegree[i] == 0) {
2762+
queue.offer(i);
27782763
}
27792764
}
27802765

2781-
// int idx = 0;
2782-
// tSorting[idx] = 0;
2783-
2784-
while(!queue.isEmpty()){
2785-
Integer curNode = queue.poll();
2786-
// NOTE !!! add node poll from queue to final result
2787-
res.add(curNode);
2766+
List<Integer> topologicalOrder = new ArrayList<>();
27882767

2789-
for (Integer subNode : preList.get(curNode)){
2790-
// if (degrees.get(subNode).equals(0)){
2791-
// idx += 1;
2792-
// tSorting[idx] = subNode;
2793-
// degrees.set(subNode, degrees.get(subNode)-1);
2794-
// }
2768+
// Step 3: Process the nodes in topological order
2769+
while (!queue.isEmpty()) {
2770+
/**
2771+
* NOTE !!!
2772+
*
2773+
* ONLY "degree = 0" nodes CAN be added to queue
2774+
*
2775+
* -> so we can add whatever node from queue to final result (topologicalOrder)
2776+
*/
2777+
int current = queue.poll();
2778+
topologicalOrder.add(current);
27952779

2796-
//preList[subNode] -= 1;
2797-
degrees.set(subNode, degrees.get(subNode)-1);
2798-
if (degrees.get(subNode).equals(0)){
2799-
queue.add(subNode);
2780+
for (int neighbor : graph.get(current)) {
2781+
inDegree[neighbor] -= 1;
2782+
/**
2783+
* NOTE !!!
2784+
*
2785+
* if a node "degree = 0" means this node can be ACCESSED now,
2786+
*
2787+
* -> so we need to add it to the queue (for adding to topologicalOrder in the following while loop iteration)
2788+
*/
2789+
if (inDegree[neighbor] == 0) {
2790+
queue.offer(neighbor);
28002791
}
28012792
}
28022793
}
28032794

2804-
return res;
2795+
// If topologicalOrder does not contain all nodes, there was a cycle in the graph
2796+
if (topologicalOrder.size() != numNodes) {
2797+
//throw new IllegalArgumentException("The graph has a cycle, so topological sort is not possible.");
2798+
return null;
2799+
}
2800+
2801+
/** NOTE !!! reverse ordering */
2802+
Collections.reverse(topologicalOrder);
2803+
return topologicalOrder;
28052804
}
28062805

28072806

2807+
/**
2808+
* int[][] prerequisites: [1, 2], so 1 is 2's prerequisite
2809+
*
2810+
*/
2811+
// private List<Integer> topoSort(int numCourses, int[][] prerequisites){
2812+
//
2813+
// //int[] tSorting = new int[]{numCourses};
2814+
//
2815+
// // init : 1) preList 2) degree
2816+
// Map<Integer, List<Integer>> preList = new HashMap<>();
2817+
// List<Integer> degrees = new ArrayList<>();
2818+
// List<Integer> res = new ArrayList<>();
2819+
//
2820+
// // init all degree as 0
2821+
// for (int i = 0; i < numCourses; i++){
2822+
// degrees.add(i);
2823+
// }
2824+
//
2825+
// // init preList and update degrees
2826+
// for (int[] x : prerequisites){
2827+
// int pre = x[0];
2828+
// int cur = x[1]; // ???
2829+
//
2830+
// // update degrees
2831+
// degrees.set(cur, degrees.get(cur)+1); // ???
2832+
// // update PreList
2833+
// if (!preList.containsKey(pre)){
2834+
// preList.put(pre, new ArrayList<>());
2835+
// }else{
2836+
// List<Integer> curItems = preList.get(pre);
2837+
// curItems.add(cur);
2838+
// preList.put(pre, curItems);
2839+
// //preList.put(pre, preList.get(pre).add(cur));
2840+
// }
2841+
// }
2842+
//
2843+
//
2844+
// Queue<Integer> queue = new LinkedList();
2845+
// // add all node with degree=0 to queue
2846+
// for (int j = 0; j < degrees.size(); j++){
2847+
// if (degrees.get(j).equals(0)){
2848+
// queue.add(j);
2849+
// }
2850+
// }
2851+
//
2852+
//// int idx = 0;
2853+
//// tSorting[idx] = 0;
2854+
//
2855+
// while(!queue.isEmpty()){
2856+
// Integer curNode = queue.poll();
2857+
// // NOTE !!! add node poll from queue to final result
2858+
// res.add(curNode);
2859+
//
2860+
// for (Integer subNode : preList.get(curNode)){
2861+
//// if (degrees.get(subNode).equals(0)){
2862+
//// idx += 1;
2863+
//// tSorting[idx] = subNode;
2864+
//// degrees.set(subNode, degrees.get(subNode)-1);
2865+
//// }
2866+
//
2867+
// //preList[subNode] -= 1;
2868+
// degrees.set(subNode, degrees.get(subNode)-1);
2869+
// if (degrees.get(subNode).equals(0)){
2870+
// queue.add(subNode);
2871+
// }
2872+
// }
2873+
// }
2874+
//
2875+
// return res;
2876+
// }
2877+
2878+
28082879
// private int[] topoSort(int numCourses, int[][] prerequisites){
28092880
// int[] tSorting = new int[]{numCourses};
28102881
//

0 commit comments

Comments
 (0)