Skip to content

Commit e40943c

Browse files
dingjikerbodingjikerbo
committed
fd
1 parent 5242eaa commit e40943c

File tree

4 files changed

+203
-55
lines changed

4 files changed

+203
-55
lines changed

‎google/src/main/java/com/leetcode/google/ReconstructItinerary.java‎

Lines changed: 127 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,142 @@
11
package com.leetcode.google;
22

3+
import java.util.ArrayList;
4+
import java.util.Arrays;
5+
import java.util.Collections;
36
import java.util.HashMap;
7+
import java.util.LinkedList;
48
import java.util.List;
9+
import java.util.Map;
10+
import java.util.PriorityQueue;
11+
import java.util.Stack;
512
import java.util.function.BiConsumer;
613
import java.util.function.Function;
714

815
/**
916
* Created by liwentian on 2017/9/2.
1017
*/
11-
18+
/**
19+
* 这题有两个前提
20+
* 1， 必须从JFK开始
21+
* 2， 解一定存在
22+
*/
23+
/**
24+
* 这题有两种解法：
25+
* 1， 常规是DFS暴力解法，面试能写出这种就行了
26+
* 2， 欧拉解法
27+
*/
1228
public class ReconstructItinerary {
1329

14-
public List<String> findItinerary(String[][] tickets) {
15-
return null;
30+
/**
31+
* 常规DFS暴力列出所有可能的路径，可以一次走遍所有的边
32+
*/
33+
public List<List<String>> findItinerary(String[][] tickets) {
34+
HashMap<String, ArrayList<String>> map = new HashMap<>();
35+
for (String[] ticket : tickets) {
36+
map.computeIfAbsent(ticket[0], k -> new ArrayList<>()).add(ticket[1]);
37+
}
38+
List<List<String>> result = new LinkedList<>();
39+
dfs("JFK", result, map, new LinkedList<>(Arrays.asList("JFK")), tickets.length);
40+
return result;
1641
}
1742

43+
void dfs(String airport, List<List<String>> result, HashMap<String, ArrayList<String>> map, LinkedList<String> route, int n) {
44+
if (route.size() == n + 1) {
45+
result.add(new ArrayList<>(route));
46+
return;
47+
}
48+
if (!map.containsKey(airport) || map.get(airport).isEmpty()) {
49+
return;
50+
}
51+
ArrayList<String> list = map.get(airport);
52+
for (int i = 0; i < list.size(); i++) {
53+
String target = list.remove(i);
54+
55+
route.add(target);
56+
dfs(target, result, map, route, n);
57+
route.removeLast();
58+
59+
list.add(i, target);
60+
}
61+
}
62+
63+
/**
64+
* 题目要求是列出字母顺序最小的
65+
*/
66+
public List<String> findItinerary2(String[][] tickets) {
67+
HashMap<String, ArrayList<String>> map = new HashMap<>();
68+
for (String[] ticket : tickets) {
69+
map.computeIfAbsent(ticket[0], k -> new ArrayList<>()).add(ticket[1]);
70+
}
71+
for (List<String> list : map.values()) {
72+
Collections.sort(list);
73+
}
74+
LinkedList<String> result = new LinkedList<>(Arrays.asList("JFK"));
75+
dfs("JFK", map, result, tickets.length);
76+
return result;
77+
}
78+
79+
boolean dfs(String airport, HashMap<String, ArrayList<String>> map, LinkedList<String> route, int n) {
80+
if (route.size() == n + 1) {
81+
return true;
82+
}
83+
if (!map.containsKey(airport) || map.get(airport).isEmpty()) {
84+
return false;
85+
}
86+
ArrayList<String> list = map.get(airport);
87+
for (int i = 0; i < list.size(); i++) {
88+
String target = list.remove(i);
89+
90+
route.add(target);
91+
if (dfs(target, map, route, n)) {
92+
return true;
93+
}
94+
route.removeLast();
95+
96+
list.add(i, target);
97+
}
98+
return false;
99+
}
100+
101+
/**
102+
* 欧拉递归解法如下
103+
*/
104+
public List<String> findItinerary3(String[][] tickets) {
105+
for (String[] ticket : tickets)
106+
targets.computeIfAbsent(ticket[0], k -> new PriorityQueue()).add(ticket[1]);
107+
visit("JFK");
108+
return route;
109+
}
110+
111+
Map<String, PriorityQueue<String>> targets = new HashMap<>();
112+
List<String> route = new LinkedList();
113+
114+
void visit(String airport) {
115+
while (targets.containsKey(airport) && !targets.get(airport).isEmpty())
116+
visit(targets.get(airport).poll());
117+
route.add(0, airport);
118+
}
119+
120+
/**
121+
* 欧拉迭代写法
122+
*/
123+
public List<String> findItinerary4(String[][] tickets) {
124+
for (String[] ticket : tickets)
125+
targets.computeIfAbsent(ticket[0], k -> new PriorityQueue()).add(ticket[1]);
126+
127+
Map<String, PriorityQueue<String>> targets = new HashMap<>();
128+
List<String> route = new LinkedList();
129+
130+
Stack<String> stack = new Stack<>();
131+
stack.push("JFK");
132+
133+
while (!stack.isEmpty()) {
134+
String s = stack.peek();
135+
while (targets.containsKey(s) && !targets.get(s).isEmpty())
136+
stack.push(targets.get(s).poll());
137+
route.add(0, stack.pop());
138+
}
139+
140+
return route;
141+
}
18142
}

‎solution/src/main/java/com/inuker/solution/CourseSchedule.java‎

Lines changed: 15 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -17,41 +17,29 @@ public class CourseSchedule {
1717
* 这题就是典型的拓扑排序
1818
*/
1919
public boolean canFinish(int numCourses, int[][] prerequisites) {
20-
int[] indegree = new int[numCourses];
20+
int[] indegrees = new int[numCourses];
2121
HashMap<Integer, Set<Integer>> map = new HashMap<>();
22-
for (int[] f : prerequisites) {
23-
int from = f[1], to = f[0];
24-
Set<Integer> set = map.get(from);
25-
if (set == null) {
26-
set = new HashSet<>();
27-
map.put(from, set);
28-
}
29-
/**
30-
* 这里要防止同一条边计了多次
31-
*/
32-
if (set.add(to)) {
33-
indegree[to]++;
22+
for (int[] pos : prerequisites) {
23+
Set<Integer> set = map.getOrDefault(pos[1], new HashSet<>());
24+
map.put(pos[1], set);
25+
if (set.add(pos[0])) {
26+
indegrees[pos[0]]++;
3427
}
3528
}
3629
Queue<Integer> queue = new LinkedList<>();
37-
List<Integer> list = new LinkedList<>();
38-
for (int i = 0; i < indegree.length; i++) {
39-
if (indegree[i] == 0) {
40-
queue.add(i);
30+
for (int i = 0; i < indegrees.length; i++) {
31+
if (indegrees[i] == 0) {
32+
queue.offer(i);
4133
}
4234
}
43-
while (!queue.isEmpty()) {
44-
Integer n = queue.poll();
45-
list.add(n);
46-
Set<Integer> set = map.get(n);
47-
if (set != null) {
48-
for (Integer k : set) {
49-
if (--indegree[k] == 0) {
50-
queue.add(k);
51-
}
35+
for ( ; !queue.isEmpty(); numCourses--) {
36+
int n = queue.poll();
37+
for (Integer k : map.getOrDefault(n, new HashSet<>())) {
38+
if (--indegrees[k] == 0) {
39+
queue.offer(k);
5240
}
5341
}
5442
}
55-
return list.size() == numCourses;
43+
return numCourses == 0;
5644
}
5745
}

‎test/src/main/java/com/inuker/test/Test2.java‎

Lines changed: 40 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,16 @@
11
package com.inuker.test;
22

3+
import java.util.ArrayList;
4+
import java.util.Arrays;
5+
import java.util.Collections;
36
import java.util.Comparator;
47
import java.util.HashMap;
8+
import java.util.HashSet;
9+
import java.util.LinkedList;
10+
import java.util.List;
511
import java.util.Map;
12+
import java.util.PriorityQueue;
13+
import java.util.Queue;
614
import java.util.TreeMap;
715

816
/**
@@ -11,15 +19,38 @@
1119

1220
public class Test2 {
1321

14-
public int subarraySum(int[] nums, int k) {
15-
HashMap<Integer, Integer> map = new HashMap<>();
16-
map.put(0, 1);
17-
int count = 0;
18-
for (int i = 0, sum = 0; i < nums.length; i++) {
19-
sum += nums[i];
20-
count += map.getOrDefault(sum - k, 0);
21-
map.put(sum, map.getOrDefault(sum, 0) + 1);
22+
public List<String> findItinerary(String[][] tickets) {
23+
HashMap<String, ArrayList<String>> map = new HashMap<>();
24+
for (String[] ticket : tickets) {
25+
map.computeIfAbsent(ticket[0], k -> new ArrayList<>()).add(ticket[1]);
2226
}
23-
return count;
27+
for (List<String> list : map.values()) {
28+
Collections.sort(list);
29+
}
30+
LinkedList<String> result = new LinkedList<>(Arrays.asList("JFK"));
31+
dfs("JFK", map, result, tickets.length);
32+
return result;
33+
}
34+
35+
boolean dfs(String airport, HashMap<String, ArrayList<String>> map, LinkedList<String> route, int n) {
36+
if (route.size() == n + 1) {
37+
return true;
38+
}
39+
if (!map.containsKey(airport) || map.get(airport).isEmpty()) {
40+
return false;
41+
}
42+
ArrayList<String> list = map.get(airport);
43+
for (int i = 0; i < list.size(); i++) {
44+
String target = list.remove(i);
45+
46+
route.add(target);
47+
if (dfs(target, map, route, n)) {
48+
return true;
49+
}
50+
route.removeLast();
51+
52+
list.add(i, target);
53+
}
54+
return false;
2455
}
2556
}

‎test/src/main/java/com/inuker/test/main.java‎

Lines changed: 21 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,10 @@
33
import com.leetcode.library.ListNode;
44
import com.leetcode.library.RandomListNode;
55
import com.leetcode.library.TreeNode;
6+
import com.leetcode.library.UndirectedGraphNode;
67

8+
import java.util.ArrayList;
9+
import java.util.Collections;
710
import java.util.HashMap;
811
import java.util.HashSet;
912
import java.util.Iterator;
@@ -23,23 +26,25 @@
2326
public class main {
2427

2528
public static void main(String[] args) {
26-
}
29+
String[][] strs = new String[][]{
30+
// {"MUC", "LHR"},
31+
// {"JFK", "MUC"},
32+
// {"SFO", "SJC"},
33+
// {"LHR", "SFO"}
34+
{"JFK", "SFO"},
35+
{"JFK", "ATL"},
36+
{"SFO", "ATL"},
37+
{"ATL", "JFK"},
38+
{"ATL", "SFO"},
39+
};
40+
List<String> lists = new Test2().findItinerary(strs);
41+
// List<String> lists = new Solution().findItinerary(strs);
42+
// for (String s : lists) {
43+
// System.out.print(s + " ");
44+
// }
2745

28-
public ListNode reverseKGroup(ListNode head, int k) {
29-
int n = 0;
30-
for (ListNode node = head; node != null; node = node.next, n++);
31-
ListNode dummy = new ListNode(0), cur = dummy, node = head;
32-
for ( ; n >= k; n -= k) {
33-
ListNode tail = node, next;
34-
for (int i = 0; i < k; i++) {
35-
next = node.next;
36-
node.next = cur.next;
37-
cur.next = node;
38-
node = next;
39-
}
40-
cur = tail;
46+
for (String s : lists) {
47+
System.out.print(s + " ");
4148
}
42-
cur.next = node;
43-
return dummy.next;
4449
}
4550
}

0 commit comments

Comments
 (0)