73
73
74
74
### 方法一:拓扑排序
75
75
76
- BFS 实现。
76
+ 我们可以先遍历每个子序列 ` seq ` ,对于每个相邻的元素 $a$ 和 $b$,我们在 $a$ 和 $b$ 之间建立一条有向边 $a \to b$。同时统计每个节点的入度,最后将所有入度为 $0$ 的节点加入队列中。
77
+
78
+ 当队列中的节点个数等于 $1$ 时,我们取出队首节点 $i$,将 $i$ 从图中删除,并将 $i$ 的所有相邻节点的入度减 $1$。如果减 $1$ 后相邻节点的入度为 $0$,则将这些节点加入队列中。重复上述操作,直到队列的长度不为 $1$。此时判断队列是否为空,如果不为空,说明有多个最短超序列,返回 ` false ` ;如果为空,说明只有一个最短超序列,返回 ` true ` 。
79
+
80
+ 时间复杂度 $O(n + m)$,空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别是节点的个数和边的个数。
77
81
78
82
<!-- tabs:start -->
79
83
@@ -82,36 +86,36 @@ class Solution:
82
86
def sequenceReconstruction (
83
87
self , nums : List[int ], sequences : List[List[int ]]
84
88
) -> bool :
85
- g = defaultdict(list )
86
- indeg = [0 ] * len (nums)
89
+ n = len (nums)
90
+ g = [[] for _ in range (n)]
91
+ indeg = [0 ] * n
87
92
for seq in sequences:
88
93
for a, b in pairwise(seq):
89
- g[a - 1 ].append(b - 1 )
90
- indeg[b - 1 ] += 1
91
- q = deque([i for i, v in enumerate (indeg) if v == 0 ])
92
- while q:
93
- if len (q) > 1 :
94
- return False
94
+ a, b = a - 1 , b - 1
95
+ g[a].append(b)
96
+ indeg[b] += 1
97
+ q = deque(i for i, x in enumerate (indeg) if x == 0 )
98
+ while len (q) == 1 :
95
99
i = q.popleft()
96
100
for j in g[i]:
97
101
indeg[j] -= 1
98
102
if indeg[j] == 0 :
99
103
q.append(j)
100
- return True
104
+ return len (q) == 0
101
105
```
102
106
103
107
``` java
104
108
class Solution {
105
- public boolean sequenceReconstruction (int [] nums , int [][] sequences ) {
109
+ public boolean sequenceReconstruction (int [] nums , List< List< Integer > > sequences ) {
106
110
int n = nums. length;
107
111
int [] indeg = new int [n];
108
112
List<Integer > [] g = new List [n];
109
113
Arrays . setAll(g, k - > new ArrayList<> ());
110
- for (int [] seq : sequences) {
111
- for (int i = 1 ; i < seq. length ; ++ i) {
112
- int a = seq[ i - 1 ] - 1 , b = seq[i] - 1 ;
114
+ for (var seq : sequences) {
115
+ for (int i = 1 ; i < seq. size() ; ++ i) {
116
+ int a = seq. get( i - 1 ) - 1 , b = seq. get(i) - 1 ;
113
117
g[a]. add(b);
114
- indeg[b]++ ;
118
+ ++ indeg[b];
115
119
}
116
120
}
117
121
Deque<Integer > q = new ArrayDeque<> ();
@@ -120,18 +124,15 @@ class Solution {
120
124
q. offer(i);
121
125
}
122
126
}
123
- while (! q. isEmpty()) {
124
- if (q. size() > 1 ) {
125
- return false ;
126
- }
127
+ while (q. size() == 1 ) {
127
128
int i = q. poll();
128
129
for (int j : g[i]) {
129
130
if (-- indeg[j] == 0 ) {
130
131
q. offer(j);
131
132
}
132
133
}
133
134
}
134
- return true ;
135
+ return q . isEmpty() ;
135
136
}
136
137
}
137
138
```
@@ -141,8 +142,8 @@ class Solution {
141
142
public:
142
143
bool sequenceReconstruction(vector<int >& nums, vector<vector<int >>& sequences) {
143
144
int n = nums.size();
144
- vector<vector<int >> g(n);
145
145
vector<int > indeg(n);
146
+ vector<int > g[ n] ;
146
147
for (auto& seq : sequences) {
147
148
for (int i = 1; i < seq.size(); ++i) {
148
149
int a = seq[ i - 1] - 1, b = seq[ i] - 1;
@@ -151,42 +152,45 @@ public:
151
152
}
152
153
}
153
154
queue<int > q;
154
- for (int i = 0; i < n; ++i)
155
- if (indeg[ i] == 0) q.push(i);
156
- while (!q.empty()) {
157
- if (q.size() > 1) return false;
155
+ for (int i = 0; i < n; ++i) {
156
+ if (indeg[ i] == 0) {
157
+ q.push(i);
158
+ }
159
+ }
160
+ while (q.size() == 1) {
158
161
int i = q.front();
159
162
q.pop();
160
- for (int j : g[ i] )
161
- if (--indeg[ j] == 0) q.push(j);
163
+ for (int j : g[ i] ) {
164
+ if (--indeg[ j] == 0) {
165
+ q.push(j);
166
+ }
167
+ }
162
168
}
163
- return true ;
169
+ return q.empty() ;
164
170
}
165
171
};
166
172
```
167
173
168
174
```go
169
175
func sequenceReconstruction(nums []int, sequences [][]int) bool {
170
176
n := len(nums)
171
- g := make([][]int, n)
172
177
indeg := make([]int, n)
178
+ g := make([][]int, n)
173
179
for _, seq := range sequences {
174
- for i := 1; i < len(seq); i++ {
175
- a, b := seq[i-1]-1, seq[i]-1
180
+ for i, b := range seq[1:] {
181
+ a := seq[i] - 1
182
+ b -= 1
176
183
g[a] = append(g[a], b)
177
184
indeg[b]++
178
185
}
179
186
}
180
187
q := []int{}
181
- for i, v := range indeg {
182
- if v == 0 {
188
+ for i, x := range indeg {
189
+ if x == 0 {
183
190
q = append(q, i)
184
191
}
185
192
}
186
- for len(q) > 0 {
187
- if len(q) > 1 {
188
- return false
189
- }
193
+ for len(q) == 1 {
190
194
i := q[0]
191
195
q = q[1:]
192
196
for _, j := range g[i] {
@@ -196,7 +200,32 @@ func sequenceReconstruction(nums []int, sequences [][]int) bool {
196
200
}
197
201
}
198
202
}
199
- return true
203
+ return len(q) == 0
204
+ }
205
+ ```
206
+
207
+ ``` ts
208
+ function sequenceReconstruction(nums : number [], sequences : number [][]): boolean {
209
+ const n = nums .length ;
210
+ const g: number [][] = Array .from ({ length: n }, () => []);
211
+ const indeg: number [] = Array (n ).fill (0 );
212
+ for (const seq of sequences ) {
213
+ for (let i = 1 ; i < seq .length ; ++ i ) {
214
+ const [a, b] = [seq [i - 1 ] - 1 , seq [i ] - 1 ];
215
+ g [a ].push (b );
216
+ ++ indeg [b ];
217
+ }
218
+ }
219
+ const q: number [] = indeg .map ((v , i ) => (v === 0 ? i : - 1 )).filter (v => v !== - 1 );
220
+ while (q .length === 1 ) {
221
+ const i = q .pop ()! ;
222
+ for (const j of g [i ]) {
223
+ if (-- indeg [j ] === 0 ) {
224
+ q .push (j );
225
+ }
226
+ }
227
+ }
228
+ return q .length === 0 ;
200
229
}
201
230
```
202
231
0 commit comments