Skip to content

Commit bf078d2

Browse files
yanglbmeyanglbme
committed
feat: add solutins to lc problem: No.1640
No.1640.Check Array Formation Through Concatenation
1 parent a377fa3 commit bf078d2

File tree

7 files changed

+224
-82
lines changed

7 files changed

+224
-82
lines changed

‎solution/1600-1699/1640.Check Array Formation Through Concatenation/README.md

Lines changed: 84 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,15 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55-
“哈希表”实现。
55+
**方法一：哈希表**
56+
57+
创建一个哈希表，键为 `pieces` 中每个数组项的首元素，值为数组项。
58+
59+
遍历 `arr`，如果当前元素在哈希表中不存在，直接返回 `false`；否则，取出哈希表中对应的数组项，判断其与 `arr` 中的元素是否相等，如果不相等，直接返回 `false`。
60+
61+
否则，遍历结束，返回 `true`。
62+
63+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 `arr` 的长度。
5664

5765
<!-- tabs:start -->
5866

@@ -63,16 +71,15 @@
6371
```python
6472
class Solution:
6573
def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
66-
mapper = {piece[0]: piece for piece in pieces}
74+
d = {p[0]: p for p in pieces}
6775
i, n = 0, len(arr)
6876
while i < n:
69-
if arr[i] not in mapper:
77+
if arr[i] not in d:
7078
return False
71-
vals = mapper[arr[i]]
72-
for val in vals:
73-
if arr[i] != val:
74-
return False
75-
i += 1
79+
p = d[arr[i]]
80+
if arr[i: i + len(p)] != p:
81+
return False
82+
i += len(p)
7683
return True
7784
```
7885

@@ -83,27 +90,76 @@ class Solution:
8390
```java
8491
class Solution {
8592
public boolean canFormArray(int[] arr, int[][] pieces) {
86-
Map<Integer, int[]> map = new HashMap<>();
87-
for (int[] piece : pieces) {
88-
map.put(piece[0], piece);
93+
Map<Integer, int[]> d = new HashMap<>();
94+
for (var p : pieces) {
95+
d.put(p[0], p);
8996
}
9097
for (int i = 0; i < arr.length;) {
91-
int[] vals = map.get(arr[i]);
92-
if (vals == null) {
98+
if (!d.containsKey(arr[i])) {
9399
return false;
94100
}
95-
for (int val : vals) {
96-
if (arr[i] != val) {
101+
var p = d.get(arr[i]);
102+
for (int v : d.get(arr[i])) {
103+
if (arr[i++] != v) {
97104
return false;
98105
}
99-
++i;
100106
}
101107
}
102108
return true;
103109
}
104110
}
105111
```
106112

113+
### **C++**
114+
115+
```cpp
116+
class Solution {
117+
public:
118+
bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
119+
unordered_map<int, vector<int>> d;
120+
for (auto& p : pieces) {
121+
d[p[0]] = p;
122+
}
123+
for (int i = 0; i < arr.size();) {
124+
if (!d.count(arr[i])) {
125+
return false;
126+
}
127+
auto& p = d[arr[i]];
128+
for (int& v : p) {
129+
if (arr[i++] != v) {
130+
return false;
131+
}
132+
}
133+
}
134+
return true;
135+
}
136+
};
137+
```
138+
139+
### **Go**
140+
141+
```go
142+
func canFormArray(arr []int, pieces [][]int) bool {
143+
d := map[int][]int{}
144+
for _, p := range pieces {
145+
d[p[0]] = p
146+
}
147+
for i := 0; i < len(arr); {
148+
p, ok := d[arr[i]]
149+
if !ok {
150+
return false
151+
}
152+
for _, v := range p {
153+
if arr[i] != v {
154+
return false
155+
}
156+
i++
157+
}
158+
}
159+
return true
160+
}
161+
```
162+
107163
### **JavaScript**
108164

109165
```js
@@ -113,19 +169,19 @@ class Solution {
113169
* @return {boolean}
114170
*/
115171
var canFormArray = function (arr, pieces) {
116-
let mapper = new Map();
117-
for (let i = 0; i < pieces.length; i++) {
118-
mapper.set(pieces[i][0], pieces[i]);
172+
const d = new Map();
173+
for (const p of pieces) {
174+
d.set(p[0], p);
119175
}
120-
let i = 0,
121-
n = arr.length;
122-
while (i < n) {
123-
let cur = arr[i];
124-
let nums = mapper.get(cur);
125-
if (nums == undefined) return false;
126-
for (let num of nums) {
127-
if (arr[i] != num) return false;
128-
i++;
176+
for (let i = 0; i < arr.length; ) {
177+
if (!d.has(arr[i])) {
178+
return false;
179+
}
180+
const p = d.get(arr[i]);
181+
for (const v of p) {
182+
if (arr[i++] != v) {
183+
return false;
184+
}
129185
}
130186
}
131187
return true;

‎solution/1600-1699/1640.Check Array Formation Through Concatenation/README_EN.md

Lines changed: 75 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -54,16 +54,15 @@
5454
```python
5555
class Solution:
5656
def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
57-
mapper = {piece[0]: piece for piece in pieces}
57+
d = {p[0]: p for p in pieces}
5858
i, n = 0, len(arr)
5959
while i < n:
60-
if arr[i] not in mapper:
60+
if arr[i] not in d:
6161
return False
62-
vals = mapper[arr[i]]
63-
for val in vals:
64-
if arr[i] != val:
65-
return False
66-
i += 1
62+
p = d[arr[i]]
63+
if arr[i: i + len(p)] != p:
64+
return False
65+
i += len(p)
6766
return True
6867
```
6968

@@ -72,27 +71,76 @@ class Solution:
7271
```java
7372
class Solution {
7473
public boolean canFormArray(int[] arr, int[][] pieces) {
75-
Map<Integer, int[]> map = new HashMap<>();
76-
for (int[] piece : pieces) {
77-
map.put(piece[0], piece);
74+
Map<Integer, int[]> d = new HashMap<>();
75+
for (var p : pieces) {
76+
d.put(p[0], p);
7877
}
7978
for (int i = 0; i < arr.length;) {
80-
int[] vals = map.get(arr[i]);
81-
if (vals == null) {
79+
if (!d.containsKey(arr[i])) {
8280
return false;
8381
}
84-
for (int val : vals) {
85-
if (arr[i] != val) {
82+
var p = d.get(arr[i]);
83+
for (int v : d.get(arr[i])) {
84+
if (arr[i++] != v) {
8685
return false;
8786
}
88-
++i;
8987
}
9088
}
9189
return true;
9290
}
9391
}
9492
```
9593

94+
### **C++**
95+
96+
```cpp
97+
class Solution {
98+
public:
99+
bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
100+
unordered_map<int, vector<int>> d;
101+
for (auto& p : pieces) {
102+
d[p[0]] = p;
103+
}
104+
for (int i = 0; i < arr.size();) {
105+
if (!d.count(arr[i])) {
106+
return false;
107+
}
108+
auto& p = d[arr[i]];
109+
for (int& v : p) {
110+
if (arr[i++] != v) {
111+
return false;
112+
}
113+
}
114+
}
115+
return true;
116+
}
117+
};
118+
```
119+
120+
### **Go**
121+
122+
```go
123+
func canFormArray(arr []int, pieces [][]int) bool {
124+
d := map[int][]int{}
125+
for _, p := range pieces {
126+
d[p[0]] = p
127+
}
128+
for i := 0; i < len(arr); {
129+
p, ok := d[arr[i]]
130+
if !ok {
131+
return false
132+
}
133+
for _, v := range p {
134+
if arr[i] != v {
135+
return false
136+
}
137+
i++
138+
}
139+
}
140+
return true
141+
}
142+
```
143+
96144
### **JavaScript**
97145

98146
```js
@@ -102,19 +150,19 @@ class Solution {
102150
* @return {boolean}
103151
*/
104152
var canFormArray = function (arr, pieces) {
105-
let mapper = new Map();
106-
for (let i = 0; i < pieces.length; i++) {
107-
mapper.set(pieces[i][0], pieces[i]);
153+
const d = new Map();
154+
for (const p of pieces) {
155+
d.set(p[0], p);
108156
}
109-
let i = 0,
110-
n = arr.length;
111-
while (i < n) {
112-
let cur = arr[i];
113-
let nums = mapper.get(cur);
114-
if (nums == undefined) return false;
115-
for (let num of nums) {
116-
if (arr[i] != num) return false;
117-
i++;
157+
for (let i = 0; i < arr.length; ) {
158+
if (!d.has(arr[i])) {
159+
return false;
160+
}
161+
const p = d.get(arr[i]);
162+
for (const v of p) {
163+
if (arr[i++] != v) {
164+
return false;
165+
}
118166
}
119167
}
120168
return true;

‎solution/1600-1699/1640.Check Array Formation Through Concatenation/Solution.cpp

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
class Solution {
2+
public:
3+
bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
4+
unordered_map<int, vector<int>> d;
5+
for (auto& p : pieces) {
6+
d[p[0]] = p;
7+
}
8+
for (int i = 0; i < arr.size();) {
9+
if (!d.count(arr[i])) {
10+
return false;
11+
}
12+
auto& p = d[arr[i]];
13+
for (int& v : p) {
14+
if (arr[i++] != v) {
15+
return false;
16+
}
17+
}
18+
}
19+
return true;
20+
}
21+
};

‎solution/1600-1699/1640.Check Array Formation Through Concatenation/Solution.go

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
func canFormArray(arr []int, pieces [][]int) bool {
2+
d := map[int][]int{}
3+
for _, p := range pieces {
4+
d[p[0]] = p
5+
}
6+
for i := 0; i < len(arr); {
7+
p, ok := d[arr[i]]
8+
if !ok {
9+
return false
10+
}
11+
for _, v := range p {
12+
if arr[i] != v {
13+
return false
14+
}
15+
i++
16+
}
17+
}
18+
return true
19+
}

‎solution/1600-1699/1640.Check Array Formation Through Concatenation/Solution.java

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,18 @@
11
class Solution {
22
public boolean canFormArray(int[] arr, int[][] pieces) {
3-
Map<Integer, int[]> map = new HashMap<>();
4-
for (int[] piece : pieces) {
5-
map.put(piece[0], piece);
3+
Map<Integer, int[]> d = new HashMap<>();
4+
for (var p : pieces) {
5+
d.put(p[0], p);
66
}
77
for (int i = 0; i < arr.length;) {
8-
int[] vals = map.get(arr[i]);
9-
if (vals == null) {
8+
if (!d.containsKey(arr[i])) {
109
return false;
1110
}
12-
for (int val : vals) {
13-
if (arr[i] != val) {
11+
var p = d.get(arr[i]);
12+
for (int v : d.get(arr[i])) {
13+
if (arr[i++] != v) {
1414
return false;
1515
}
16-
++i;
1716
}
1817
}
1918
return true;

‎solution/1600-1699/1640.Check Array Formation Through Concatenation/Solution.js

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -4,19 +4,19 @@
44
* @return {boolean}
55
*/
66
var canFormArray = function (arr, pieces) {
7-
let mapper = new Map();
8-
for (let i = 0; i < pieces.length; i++) {
9-
mapper.set(pieces[i][0], pieces[i]);
7+
const d = new Map();
8+
for (const p of pieces) {
9+
d.set(p[0], p);
1010
}
11-
let i = 0,
12-
n = arr.length;
13-
while (i < n) {
14-
let cur = arr[i];
15-
let nums = mapper.get(cur);
16-
if (nums == undefined) return false;
17-
for (let num of nums) {
18-
if (arr[i] != num) return false;
19-
i++;
11+
for (let i = 0; i < arr.length; ) {
12+
if (!d.has(arr[i])) {
13+
return false;
14+
}
15+
const p = d.get(arr[i]);
16+
for (const v of p) {
17+
if (arr[i++] != v) {
18+
return false;
19+
}
2020
}
2121
}
2222
return true;

0 commit comments

Comments
 (0)