Skip to content

Commit fc81f96

Browse files
metanetmetanet
committed
practice
1 parent d4864d6 commit fc81f96

File tree

6 files changed

+181
-65
lines changed

6 files changed

+181
-65
lines changed

‎src/problems/leetcode/CourseSchedule.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,6 @@ public boolean equals(Object obj) {
138138
public static boolean canFinish(int numCourses, int[][] prerequisites) {
139139
// course -> preq course
140140
Map<Integer, List<Integer>> edges = new HashMap<>();
141-
142141
for (int[] p : prerequisites) {
143142
edges.computeIfAbsent(p[0], (k) -> new ArrayList<>()).add(p[1]);
144143
}

‎src/problems/leetcode/CourseScheduleII.java‎

Lines changed: 50 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,8 @@ private List[] buildAdjList(int numCourses, int[][] prerequisites) {
4949
return preLists;
5050
}
5151

52-
private void DFS(int course, List[] preLists, Set<Integer> visited, boolean[] done, List<Integer> completedCourses) {
52+
private void DFS(int course, List[] preLists, Set<Integer> visited, boolean[] done,
53+
List<Integer> completedCourses) {
5354
visited.add(course);
5455
done[course] = true;
5556
List<Integer> preCourses = preLists[course];
@@ -65,13 +66,58 @@ private void DFS(int course, List[] preLists, Set<Integer> visited, boolean[] do
6566
}
6667

6768
visited.remove(course);
68-
6969
completedCourses.add(course);
7070
}
7171

72+
public int[] findOrder2(int numCourses, int[][] prerequisites) {
73+
// course -> preq course
74+
Map<Integer, List<Integer>> edges = new HashMap<>();
75+
for (int[] p : prerequisites) {
76+
edges.computeIfAbsent(p[0], (k) -> new ArrayList<>()).add(p[1]);
77+
}
78+
79+
try {
80+
boolean[] done = new boolean[numCourses];
81+
boolean[] currentPath = new boolean[numCourses];
82+
List<Integer> completed = new ArrayList<>();
83+
for (int course = 0; course < numCourses; course++) {
84+
if (!done[course]) {
85+
tpl(edges, course, done, completed, currentPath);
86+
}
87+
}
88+
89+
// System.out.println("completed=" + completed);
90+
return completed.stream()
91+
.mapToInt(Integer::intValue)
92+
.toArray();
93+
} catch (IllegalArgumentException e) {
94+
return new int[0];
95+
}
96+
}
97+
98+
private void tpl(Map<Integer, List<Integer>> edges, int course, boolean[] done, List<Integer> completed, boolean[] currentPath) {
99+
currentPath[course] = true;
100+
done[course] = true;
101+
List<Integer> preqs = edges.get(course);
102+
if (preqs != null) {
103+
for (int preq : preqs) {
104+
if (currentPath[preq]) {
105+
throw new IllegalArgumentException();
106+
} else if (!done[preq]) {
107+
tpl(edges, preq, done, completed, currentPath);
108+
}
109+
}
110+
}
111+
completed.add(course);
112+
currentPath[course] = false;
113+
}
114+
72115
public static void main(String[] args) {
73-
int[] order = new CourseScheduleII().findOrder(5, new int[][]{{0, 1}, {1, 2}, {1, 3}, {3, 4}, {4, 3}});
74-
// int[] order = new CourseScheduleII().findOrder(3, new int[][] {{0, 1}, {0, 2}, {1, 2}});
116+
// int[] order = new CourseScheduleII().findOrder(5, new int[][]{{0, 1}, {1, 2},
117+
// {1, 3}, {3, 4}, {4, 3}});
118+
// int[] order = new CourseScheduleII().findOrder(3, new int[][] {{0, 1}, {0,
119+
// 2}, {1, 2}});
120+
int[] order = new CourseScheduleII().findOrder(3, new int[][] { { 0, 1 }, { 1, 0 } });
75121
System.out.println(Arrays.toString(order));
76122
}
77123

‎src/problems/leetcode/HIndex.java‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
package problems.leetcode;
2+
3+
// https://leetcode.com/problems/h-index/
4+
public class HIndex {
5+
6+
// https://leetcode.com/problems/h-index/solutions/70768/java-bucket-sort-o-n-solution-with-detail-explanation/
7+
public int hIndex(int[] citations) {
8+
int n = citations.length;
9+
int[] buckets = new int[n+1];
10+
for (int c : citations) {
11+
if (c >= n) {
12+
buckets[n]++;
13+
} else {
14+
buckets[c]++;
15+
}
16+
}
17+
int count = 0;
18+
for(int i = n; i >= 0; i--) {
19+
count += buckets[i];
20+
if (count >= i) {
21+
return i;
22+
}
23+
}
24+
25+
return 0;
26+
}
27+
28+
}

‎src/problems/leetcode/ImplementStackUsingQueues.java‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
package problems.leetcode;
2+
3+
import java.util.ArrayDeque;
4+
import java.util.Deque;
5+
6+
// https://leetcode.com/problems/implement-stack-using-queues/submissions/
7+
public class ImplementStackUsingQueues {
8+
9+
private static class MyStack {
10+
11+
// push 1
12+
// push 2
13+
// push 3
14+
// peek -> 3
15+
// pop 3
16+
// push 4
17+
// peek -> 4
18+
19+
// 1 -> 2 -> 3 -> 4
20+
21+
private Deque<Integer> queue1 = new ArrayDeque<>();
22+
private Deque<Integer> queue2 = new ArrayDeque<>();
23+
24+
public MyStack() {
25+
26+
}
27+
28+
public void push(int x) {
29+
queue1.addLast(x);
30+
}
31+
32+
public int pop() {
33+
while (queue1.size() > 1) {
34+
queue2.addLast(queue1.removeFirst());
35+
}
36+
37+
int i = queue1.removeFirst();
38+
Deque<Integer> temp = queue1;
39+
queue1 = queue2;
40+
queue2 = temp;
41+
return i;
42+
}
43+
44+
public int top() {
45+
int i = pop();
46+
push(i);
47+
return i;
48+
}
49+
50+
public boolean empty() {
51+
return queue1.isEmpty();
52+
}
53+
}
54+
55+
public static void main(String[] args) {
56+
MyStack stack = new MyStack();
57+
stack.push(1);
58+
System.out.println(stack.pop());
59+
System.out.println(stack.empty());
60+
}
61+
62+
}

‎src/problems/leetcode/KthSmallestElementInBST.java‎

Lines changed: 10 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -17,45 +17,24 @@ private static class TreeNode {
1717
}
1818
}
1919

20-
// public int kthSmallest(TreeNode root, int k) {
21-
// List<Integer> visited = new ArrayList<>();
22-
// kthSmallest(root, k, visited);
23-
// return visited.get(k - 1);
24-
// }
20+
private int i;
21+
private int value;
2522

2623
public int kthSmallest(TreeNode root, int k) {
27-
kthSmallest2(root, k);
28-
return found.val;
24+
traverse(root, k);
25+
return value;
2926
}
3027

31-
private void kthSmallest(TreeNode node, int k, List<Integer> visited) {
32-
if (node == null) {
28+
private void traverse(TreeNode root, int k) {
29+
if (root == null) {
3330
return;
3431
}
35-
36-
kthSmallest(node.left, k, visited);
37-
visited.add(node.val);
38-
if (visited.size() < k) {
39-
kthSmallest(node.right, k, visited);
40-
}
41-
}
42-
43-
private int count;
44-
private TreeNode found;
45-
46-
private void kthSmallest2(TreeNode node, int k) {
47-
if (node == null) {
32+
traverse(root.left, k);
33+
if (++i == k) {
34+
value = root.val;
4835
return;
4936
}
50-
51-
kthSmallest2(node.left, k);
52-
53-
if (found == null && ++count == k) {
54-
found = node;
55-
return;
56-
}
57-
58-
kthSmallest2(node.right, k);
37+
traverse(root.right, k);
5938
}
6039

6140
}

‎src/problems/leetcode/LowestCommonAncestorOfBinaryTree.java‎

Lines changed: 31 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -34,53 +34,55 @@ public static void main(String[] args) {
3434
root.left.right.left = new TreeNode(7);
3535
root.left.right.right = new TreeNode(4);
3636

37-
TreeNode ancestor = new LowestCommonAncestorOfBinaryTree().lowestCommonAncestor(root, new TreeNode(6), new TreeNode(4));
37+
TreeNode ancestor = new LowestCommonAncestorOfBinaryTree().lowestCommonAncestor(root, new TreeNode(6),
38+
new TreeNode(4));
3839

3940
System.out.println(ancestor.val);
4041
}
4142

42-
private List<List<TreeNode>> knownPaths = new ArrayList<>();
43-
4443
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
4544
if (root == null || root.val == p.val || root.val == q.val) {
4645
return root;
4746
}
4847

49-
lowestCommonAncestor(root, p, q, new ArrayList<>());
50-
51-
assert knownPaths.size() == 2;
52-
53-
List<TreeNode> path1 = knownPaths.get(0), path2 = knownPaths.get(1);
54-
TreeNode ancestor = path1.get(0);
55-
for (int i = 1; i < Math.min(path1.size(), path2.size()); i++) {
56-
TreeNode node1 = path1.get(i), node2 = path2.get(i);
57-
if (node1 == node2) {
58-
ancestor = node1;
59-
} else {
60-
break;
61-
}
48+
TreeNode l = lowestCommonAncestor(root.left, p, q);
49+
TreeNode r = lowestCommonAncestor(root.right, p, q);
50+
if (l == null) {
51+
return r;
52+
} else if (r == null) {
53+
return l;
6254
}
55+
56+
return root;
57+
}
6358

59+
private TreeNode ancestor;
60+
61+
public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
62+
traverse(root, p.val, q.val);
6463
return ancestor;
6564
}
6665

67-
private void lowestCommonAncestor(TreeNode node, TreeNode p, TreeNode q, List<TreeNode> path) {
68-
if (node == null || knownPaths.size() == 2) {
69-
return;
66+
private boolean traverse(TreeNode root, int p, int q) {
67+
if (root == null) {
68+
return false;
7069
}
7170

72-
path.add(node);
73-
74-
if (node.val == p.val) {
75-
knownPaths.add(new ArrayList<>(path));
76-
} else if (node.val == q.val) {
77-
knownPaths.add(new ArrayList<>(path));
71+
if (root.val < Math.min(p, q)) {
72+
return traverse(root.right, p, q);
73+
} else if (root.val > Math.max(p, q)) {
74+
return traverse(root.left, p, q);
7875
}
7976

80-
lowestCommonAncestor(node.left, p, q, path);
81-
lowestCommonAncestor(node.right, p, q, path);
77+
boolean foundHere = (root.val == p || root.val == q);
78+
boolean foundLeft = traverse(root.left, p, q);
79+
boolean foundRight = traverse(root.right, p, q);
80+
// System.out.println("val=" + root.val + ", here=" + foundHere + ", left=" +
81+
// foundLeft + ", right=" + foundRight);
82+
if ((foundHere && (foundLeft || foundRight)) || (foundLeft && foundRight)) {
83+
ancestor = root;
84+
}
8285

83-
path.remove(path.size() - 1);
86+
return foundHere || foundLeft || foundRight;
8487
}
85-
8688
}

0 commit comments

Comments
 (0)