Skip to content

Commit b720ab0

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc/lcof2 problem: Verifying an Alien Dictionary
1 parent f493f41 commit b720ab0

File tree

11 files changed

+450
-103
lines changed

11 files changed

+450
-103
lines changed

‎lcof2/剑指 Offer II 034. 外星语言是否排序/README.md

Lines changed: 108 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,129 @@
5252

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

55+
用数组或哈希表存放字母顺序。依次遍历单词列表，检测相邻两单词是否满足字典序。
56+
5557
<!-- tabs:start -->
5658

5759
### **Python3**
5860

5961
<!-- 这里可写当前语言的特殊实现逻辑 -->
6062

6163
```python
62-
64+
class Solution:
65+
def isAlienSorted(self, words: List[str], order: str) -> bool:
66+
index = {c: i for i, c in enumerate(order)}
67+
for i in range(len(words) - 1):
68+
w1, w2 = words[i], words[i + 1]
69+
l1, l2 = len(w1), len(w2)
70+
flag = False
71+
for j in range(max(l1, l2)):
72+
i1, i2 = -1 if j >= l1 else index[w1[j]], -1 if j >= l2 else index[w2[j]]
73+
if i1 > i2:
74+
# 说明不是按字典序排序，直接返回False
75+
return False
76+
if i1 < i2:
77+
# 说明当前两单词是按字典序排序，无需再往下进行循环比较
78+
break
79+
return True
6380
```
6481

6582
### **Java**
6683

6784
<!-- 这里可写当前语言的特殊实现逻辑 -->
6885

6986
```java
87+
class Solution {
88+
public boolean isAlienSorted(String[] words, String order) {
89+
int[] index = new int[26];
90+
for (int i = 0; i < index.length; ++i) {
91+
index[order.charAt(i) - 'a'] = i;
92+
}
93+
for (int i = 0; i < words.length - 1; ++i) {
94+
String w1 = words[i];
95+
String w2 = words[i + 1];
96+
int l1 = w1.length(), l2 = w2.length();
97+
for (int j = 0; j < Math.max(l1, l2); ++j) {
98+
int i1 = j >= l1 ? -1 : index[w1.charAt(j) - 'a'];
99+
int i2 = j >= l2 ? -1 : index[w2.charAt(j) - 'a'];
100+
if (i1 > i2) {
101+
// 说明不是按字典序排序，直接返回False
102+
return false;
103+
}
104+
if (i1 < i2) {
105+
// 说明当前两单词是按字典序排序，无需再往下进行循环比较
106+
break;
107+
}
108+
}
109+
}
110+
return true;
111+
}
112+
}
113+
```
114+
115+
### **C++**
116+
117+
```cpp
118+
class Solution {
119+
public:
120+
bool isAlienSorted(vector<string> &words, string order) {
121+
vector<int> index(26);
122+
for (int i = 0; i < index.size(); ++i)
123+
index[order[i] - 'a'] = i;
124+
for (int i = 0; i < words.size() - 1; ++i)
125+
{
126+
string w1 = words[i];
127+
string w2 = words[i + 1];
128+
int l1 = w1.size(), l2 = w2.size();
129+
for (int j = 0; j < max(l1, l2); ++j)
130+
{
131+
int i1 = j >= l1 ? -1 : index[w1[j] - 'a'];
132+
int i2 = j >= l2 ? -1 : index[w2[j] - 'a'];
133+
if (i1 > i2)
134+
return false;
135+
if (i1 < i2)
136+
break;
137+
}
138+
}
139+
return true;
140+
}
141+
};
142+
```
70143
144+
### **Go**
145+
146+
```go
147+
func isAlienSorted(words []string, order string) bool {
148+
index := make(map[byte]int)
149+
for i := range order {
150+
index[order[i]] = i
151+
}
152+
for i := 0; i < len(words)-1; i++ {
153+
w1, w2 := words[i], words[i+1]
154+
l1, l2 := len(w1), len(w2)
155+
flag := true
156+
for j := 0; j < min(l1, l2) && flag; j++ {
157+
i1, i2 := index[w1[j]], index[w2[j]]
158+
if i1 > i2 {
159+
return false
160+
}
161+
if i1 < i2 {
162+
flag = false
163+
}
164+
}
165+
if flag && l1 > l2 {
166+
return false
167+
}
168+
}
169+
return true
170+
}
171+
172+
func min(a, b int) int {
173+
if a < b {
174+
return a
175+
}
176+
return b
177+
}
71178
```
72179

73180
### **...**

‎lcof2/剑指 Offer II 034. 外星语言是否排序/Solution.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
bool isAlienSorted(vector<string> &words, string order) {
4+
vector<int> index(26);
5+
for (int i = 0; i < index.size(); ++i)
6+
index[order[i] - 'a'] = i;
7+
for (int i = 0; i < words.size() - 1; ++i)
8+
{
9+
string w1 = words[i];
10+
string w2 = words[i + 1];
11+
int l1 = w1.size(), l2 = w2.size();
12+
for (int j = 0; j < max(l1, l2); ++j)
13+
{
14+
int i1 = j >= l1 ? -1 : index[w1[j] - 'a'];
15+
int i2 = j >= l2 ? -1 : index[w2[j] - 'a'];
16+
if (i1 > i2)
17+
return false;
18+
if (i1 < i2)
19+
break;
20+
}
21+
}
22+
return true;
23+
}
24+
};

‎lcof2/剑指 Offer II 034. 外星语言是否排序/Solution.go

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
func isAlienSorted(words []string, order string) bool {
2+
index := make(map[byte]int)
3+
for i := range order {
4+
index[order[i]] = i
5+
}
6+
for i := 0; i < len(words)-1; i++ {
7+
w1, w2 := words[i], words[i+1]
8+
l1, l2 := len(w1), len(w2)
9+
flag := true
10+
for j := 0; j < min(l1, l2) && flag; j++ {
11+
i1, i2 := index[w1[j]], index[w2[j]]
12+
if i1 > i2 {
13+
return false
14+
}
15+
if i1 < i2 {
16+
flag = false
17+
}
18+
}
19+
if flag && l1 > l2 {
20+
return false
21+
}
22+
}
23+
return true
24+
}
25+
26+
func min(a, b int) int {
27+
if a < b {
28+
return a
29+
}
30+
return b
31+
}

‎lcof2/剑指 Offer II 034. 外星语言是否排序/Solution.java

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public boolean isAlienSorted(String[] words, String order) {
3+
int[] index = new int[26];
4+
for (int i = 0; i < index.length; ++i) {
5+
index[order.charAt(i) - 'a'] = i;
6+
}
7+
for (int i = 0; i < words.length - 1; ++i) {
8+
String w1 = words[i];
9+
String w2 = words[i + 1];
10+
int l1 = w1.length(), l2 = w2.length();
11+
for (int j = 0; j < Math.max(l1, l2); ++j) {
12+
int i1 = j >= l1 ? -1 : index[w1.charAt(j) - 'a'];
13+
int i2 = j >= l2 ? -1 : index[w2.charAt(j) - 'a'];
14+
if (i1 > i2) {
15+
return false;
16+
}
17+
if (i1 < i2) {
18+
break;
19+
}
20+
}
21+
}
22+
return true;
23+
}
24+
}

‎lcof2/剑指 Offer II 034. 外星语言是否排序/Solution.py

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def isAlienSorted(self, words: List[str], order: str) -> bool:
3+
index = {c: i for i, c in enumerate(order)}
4+
for i in range(len(words) - 1):
5+
w1, w2 = words[i], words[i + 1]
6+
l1, l2 = len(w1), len(w2)
7+
flag = False
8+
for j in range(max(l1, l2)):
9+
i1, i2 = -1 if j >= l1 else index[w1[j]], -1 if j >= l2 else index[w2[j]]
10+
if i1 > i2:
11+
return False
12+
if i1 < i2:
13+
break
14+
return True

‎solution/0900-0999/0953.Verifying an Alien Dictionary/README.md

Lines changed: 91 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -42,11 +42,12 @@
4242
<li>在&nbsp;<code>words[i]</code>&nbsp;和&nbsp;<code>order</code>&nbsp;中的所有字符都是英文小写字母。</li>
4343
</ol>
4444

45-
4645
## 解法
4746

4847
<!-- 这里可写通用的实现逻辑 -->
4948

49+
用数组或哈希表存放字母顺序。依次遍历单词列表，检测相邻两单词是否满足字典序。
50+
5051
<!-- tabs:start -->
5152

5253
### **Python3**
@@ -56,22 +57,19 @@
5657
```python
5758
class Solution:
5859
def isAlienSorted(self, words: List[str], order: str) -> bool:
59-
index = {v: k for k, v in enumerate(order)}
60+
index = {c: i for i, c in enumerate(order)}
6061
for i in range(len(words) - 1):
61-
word1, word2 = words[i], words[i + 1]
62-
len1, len2 = len(word1), len(word2)
63-
flag = True
64-
for j in range(min(len1, len2)):
65-
diff = index[word1[j]] - index[word2[j]]
66-
if diff > 0:
62+
w1, w2 = words[i], words[i + 1]
63+
l1, l2 = len(w1), len(w2)
64+
flag = False
65+
for j in range(max(l1, l2)):
66+
i1, i2 = -1 if j >= l1 else index[w1[j]], -1 if j >= l2 else index[w2[j]]
67+
if i1 > i2:
6768
# 说明不是按字典序排序，直接返回False
6869
return False
69-
if diff < 0:
70+
if i1 < i2:
7071
# 说明当前两单词是按字典序排序，无需再往下进行循环比较
71-
flag = False
7272
break
73-
if flag and len1 > len2:
74-
return False
7573
return True
7674
```
7775

@@ -83,29 +81,96 @@ class Solution:
8381
class Solution {
8482
public boolean isAlienSorted(String[] words, String order) {
8583
int[] index = new int[26];
86-
for (int i = 0; i < 26; ++i) {
84+
for (int i = 0; i < index.length; ++i) {
8785
index[order.charAt(i) - 'a'] = i;
8886
}
89-
for (int i = 0, m = words.length; i < m - 1; ++i) {
90-
String word1 = words[i];
91-
String word2 = words[i + 1];
92-
int len1 = word1.length();
93-
int len2 = word2.length();
94-
boolean flag = true;
95-
for (int j = 0, n = Math.min(len1, len2); j < n && flag; ++j) {
96-
int diff = index[word1.charAt(j) - 'a'] - index[word2.charAt(j) - 'a'];
97-
// 说明不是按字典序排序，直接返回False
98-
if (diff > 0) return false;
99-
// 说明当前两单词是按字典序排序，无需再往下进行循环比较
100-
if (diff < 0) flag = false;
87+
for (int i = 0; i < words.length - 1; ++i) {
88+
String w1 = words[i];
89+
String w2 = words[i + 1];
90+
int l1 = w1.length(), l2 = w2.length();
91+
for (int j = 0; j < Math.max(l1, l2); ++j) {
92+
int i1 = j >= l1 ? -1 : index[w1.charAt(j) - 'a'];
93+
int i2 = j >= l2 ? -1 : index[w2.charAt(j) - 'a'];
94+
if (i1 > i2) {
95+
// 说明不是按字典序排序，直接返回False
96+
return false;
97+
}
98+
if (i1 < i2) {
99+
// 说明当前两单词是按字典序排序，无需再往下进行循环比较
100+
break;
101+
}
101102
}
102-
if (flag && len1 > len2) return false;
103103
}
104104
return true;
105105
}
106106
}
107107
```
108108

109+
### **C++**
110+
111+
```cpp
112+
class Solution {
113+
public:
114+
bool isAlienSorted(vector<string> &words, string order) {
115+
vector<int> index(26);
116+
for (int i = 0; i < index.size(); ++i)
117+
index[order[i] - 'a'] = i;
118+
for (int i = 0; i < words.size() - 1; ++i)
119+
{
120+
string w1 = words[i];
121+
string w2 = words[i + 1];
122+
int l1 = w1.size(), l2 = w2.size();
123+
for (int j = 0; j < max(l1, l2); ++j)
124+
{
125+
int i1 = j >= l1 ? -1 : index[w1[j] - 'a'];
126+
int i2 = j >= l2 ? -1 : index[w2[j] - 'a'];
127+
if (i1 > i2)
128+
return false;
129+
if (i1 < i2)
130+
break;
131+
}
132+
}
133+
return true;
134+
}
135+
};
136+
```
137+
138+
### **Go**
139+
140+
```go
141+
func isAlienSorted(words []string, order string) bool {
142+
index := make(map[byte]int)
143+
for i := range order {
144+
index[order[i]] = i
145+
}
146+
for i := 0; i < len(words)-1; i++ {
147+
w1, w2 := words[i], words[i+1]
148+
l1, l2 := len(w1), len(w2)
149+
flag := true
150+
for j := 0; j < min(l1, l2) && flag; j++ {
151+
i1, i2 := index[w1[j]], index[w2[j]]
152+
if i1 > i2 {
153+
return false
154+
}
155+
if i1 < i2 {
156+
flag = false
157+
}
158+
}
159+
if flag && l1 > l2 {
160+
return false
161+
}
162+
}
163+
return true
164+
}
165+
166+
func min(a, b int) int {
167+
if a < b {
168+
return a
169+
}
170+
return b
171+
}
172+
```
173+
109174
### **...**
110175

111176
```

0 commit comments

Comments
 (0)