feat: add solutions to lc problem: No.1604

yanglbme · yanglbme · commit 363a38ae99c1 · 2022-11-25T10:00:00.000+08:00
No.1604.Alert Using Same Key-Card Three or More Times in a One Hour
Period
diff --git a/solution/0800-0899/0809.Expressive Words/README.md b/solution/0800-0899/0809.Expressive Words/README.md
@@ -43,13 +43,13 @@ words = ["hello", "hi", "helo"]
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：双指针**
+**方法一：遍历计数 + 双指针**
 
-遍历数组 `words`，对于每个单词 $t$，判断当前单词 $t$ 是否可以通过扩张得到 $s$，如果可以，那么答案加一。
+我们可以遍历数组 `words`，对于数组中的每个单词 $t$，判断 $t$ 是否可以通过扩张得到 $s$，如果可以，那么答案加一。
 
 因此，问题的关键在于判断单词 $t$ 是否可以通过扩张得到 $s$。这里我们通过一个 $check(s, t)$ 函数来判断。函数的具体实现逻辑如下：
 
-我们首先用双指针 $i$ 和 $j$ 分别指向 $s$ 和 $t$，初始时 $i$ 和 $j$ 的值均为 $0$。
+首先判断 $s$ 和 $t$ 的长度关系，如果 $t$ 的长度大于 $s$，直接返回 `false`；否则，我们用双指针 $i$ 和 $j$ 分别指向 $s$ 和 $t$，初始时 $i$ 和 $j$ 的值均为 $0$。
 
 如果 $i$ 和 $j$ 指向的字符不同，那么 $t$ 无法通过扩张得到 $s$，直接返回 `false`；否则，我们需要判断 $i$ 指向的字符的连续出现次数 $c_1$ 和 $j$ 指向的字符的连续出现次数 $c_2$ 的关系。如果 $c_1 \lt c_2$ 或者 $c_1 \lt 3$ 并且 $c_1 \neq c_2$，那么 $t$ 无法通过扩张得到 $s$，直接返回 `false`；否则，将 $i$ 和 $j$ 分别右移 $c_1$ 和 $c_2$ 次。继续判断。
 
diff --git a/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/README.md b/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/README.md
@@ -65,22 +65,135 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：哈希表 + 排序**
+
+我们先用哈希表 $d$ 记录每个员工的所有打卡时间。
+
+然后遍历哈希表，对于每个员工，我们先判断员工的打卡次数是否大于等于 3，如果不是，则跳过该员工。否则，我们将该员工的所有打卡时间按照时间先后排序，然后遍历排序后的打卡时间，判断下标距离为 $2$ 的两个时间是否在同一小时内，如果是，则将该员工加入答案数组。
+
+最后，将答案数组按照字典序排序，即可得到答案。
+
+时间复杂度 $O(n \times \log n)$，其中 $n$ 是数组 $keyName$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def alertNames(self, keyName: List[str], keyTime: List[str]) -> List[str]:
+        d = defaultdict(list)
+        for name, t in zip(keyName, keyTime):
+            t = int(t[:2]) * 60 + int(t[3:])
+            d[name].append(t)
+        ans = []
+        for name, ts in d.items():
+            if (n := len(ts)) > 2:
+                ts.sort()
+                for i in range(n - 2):
+                    if ts[i + 2] - ts[i] <= 60:
+                        ans.append(name)
+                        break
+        ans.sort()
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public List<String> alertNames(String[] keyName, String[] keyTime) {
+        Map<String, List<Integer>> d = new HashMap<>();
+        for (int i = 0; i < keyName.length; ++i) {
+            String name = keyName[i];
+            String time = keyTime[i];
+            int t = Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3));
+            d.computeIfAbsent(name, k -> new ArrayList<>()).add(t);
+        }
+        List<String> ans = new ArrayList<>();
+        for (var e : d.entrySet()) {
+            var ts = e.getValue();
+            int n = ts.size();
+            if (n > 2) {
+                Collections.sort(ts);
+                for (int i = 0; i < n - 2; ++i) {
+                    if (ts.get(i + 2) - ts.get(i) <= 60) {
+                        ans.add(e.getKey());
+                        break;
+                    }
+                }
+            }
+        }
+        Collections.sort(ans);
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<string> alertNames(vector<string>& keyName, vector<string>& keyTime) {
+        unordered_map<string, vector<int>> d;
+        for (int i = 0; i < keyName.size(); ++i) {
+            auto name = keyName[i];
+            auto time = keyTime[i];
+            int a, b;
+            sscanf(time.c_str(), "%d:%d", &a, &b);
+            int t = a * 60 + b;
+            d[name].emplace_back(t);
+        }
+        vector<string> ans;
+        for (auto& [name, ts] : d) {
+            int n = ts.size();
+            if (n > 2) {
+                sort(ts.begin(), ts.end());
+                for (int i = 0; i < n - 2; ++i) {
+                    if (ts[i + 2] - ts[i] <= 60) {
+                        ans.emplace_back(name);
+                        break;
+                    }
+                }
+            }
+        }
+        sort(ans.begin(), ans.end());
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func alertNames(keyName []string, keyTime []string) (ans []string) {
+	d := map[string][]int{}
+	for i, name := range keyName {
+		var a, b int
+		fmt.Sscanf(keyTime[i], "%d:%d", &a, &b)
+		t := a*60 + b
+		d[name] = append(d[name], t)
+	}
+	for name, ts := range d {
+		n := len(ts)
+		if n > 2 {
+			sort.Ints(ts)
+			for i := 0; i < n-2; i++ {
+				if ts[i+2]-ts[i] <= 60 {
+					ans = append(ans, name)
+					break
+				}
+			}
+		}
+	}
+	sort.Strings(ans)
+	return
+}
 ```
 
 ### **...**
diff --git a/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/README_EN.md b/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/README_EN.md
@@ -50,13 +50,116 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def alertNames(self, keyName: List[str], keyTime: List[str]) -> List[str]:
+        d = defaultdict(list)
+        for name, t in zip(keyName, keyTime):
+            t = int(t[:2]) * 60 + int(t[3:])
+            d[name].append(t)
+        ans = []
+        for name, ts in d.items():
+            if (n := len(ts)) > 2:
+                ts.sort()
+                for i in range(n - 2):
+                    if ts[i + 2] - ts[i] <= 60:
+                        ans.append(name)
+                        break
+        ans.sort()
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public List<String> alertNames(String[] keyName, String[] keyTime) {
+        Map<String, List<Integer>> d = new HashMap<>();
+        for (int i = 0; i < keyName.length; ++i) {
+            String name = keyName[i];
+            String time = keyTime[i];
+            int t = Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3));
+            d.computeIfAbsent(name, k -> new ArrayList<>()).add(t);
+        }
+        List<String> ans = new ArrayList<>();
+        for (var e : d.entrySet()) {
+            var ts = e.getValue();
+            int n = ts.size();
+            if (n > 2) {
+                Collections.sort(ts);
+                for (int i = 0; i < n - 2; ++i) {
+                    if (ts.get(i + 2) - ts.get(i) <= 60) {
+                        ans.add(e.getKey());
+                        break;
+                    }
+                }
+            }
+        }
+        Collections.sort(ans);
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<string> alertNames(vector<string>& keyName, vector<string>& keyTime) {
+        unordered_map<string, vector<int>> d;
+        for (int i = 0; i < keyName.size(); ++i) {
+            auto name = keyName[i];
+            auto time = keyTime[i];
+            int a, b;
+            sscanf(time.c_str(), "%d:%d", &a, &b);
+            int t = a * 60 + b;
+            d[name].emplace_back(t);
+        }
+        vector<string> ans;
+        for (auto& [name, ts] : d) {
+            int n = ts.size();
+            if (n > 2) {
+                sort(ts.begin(), ts.end());
+                for (int i = 0; i < n - 2; ++i) {
+                    if (ts[i + 2] - ts[i] <= 60) {
+                        ans.emplace_back(name);
+                        break;
+                    }
+                }
+            }
+        }
+        sort(ans.begin(), ans.end());
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func alertNames(keyName []string, keyTime []string) (ans []string) {
+	d := map[string][]int{}
+	for i, name := range keyName {
+		var a, b int
+		fmt.Sscanf(keyTime[i], "%d:%d", &a, &b)
+		t := a*60 + b
+		d[name] = append(d[name], t)
+	}
+	for name, ts := range d {
+		n := len(ts)
+		if n > 2 {
+			sort.Ints(ts)
+			for i := 0; i < n-2; i++ {
+				if ts[i+2]-ts[i] <= 60 {
+					ans = append(ans, name)
+					break
+				}
+			}
+		}
+	}
+	sort.Strings(ans)
+	return
+}
 ```
 
 ### **...**
diff --git a/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.cpp b/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<string> alertNames(vector<string>& keyName, vector<string>& keyTime) {
+        unordered_map<string, vector<int>> d;
+        for (int i = 0; i < keyName.size(); ++i) {
+            auto name = keyName[i];
+            auto time = keyTime[i];
+            int a, b;
+            sscanf(time.c_str(), "%d:%d", &a, &b);
+            int t = a * 60 + b;
+            d[name].emplace_back(t);
+        }
+        vector<string> ans;
+        for (auto& [name, ts] : d) {
+            int n = ts.size();
+            if (n > 2) {
+                sort(ts.begin(), ts.end());
+                for (int i = 0; i < n - 2; ++i) {
+                    if (ts[i + 2] - ts[i] <= 60) {
+                        ans.emplace_back(name);
+                        break;
+                    }
+                }
+            }
+        }
+        sort(ans.begin(), ans.end());
+        return ans;
+    }
+};
diff --git a/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.go b/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.go
@@ -0,0 +1,23 @@
+func alertNames(keyName []string, keyTime []string) (ans []string) {
+	d := map[string][]int{}
+	for i, name := range keyName {
+		var a, b int
+		fmt.Sscanf(keyTime[i], "%d:%d", &a, &b)
+		t := a*60 + b
+		d[name] = append(d[name], t)
+	}
+	for name, ts := range d {
+		n := len(ts)
+		if n > 2 {
+			sort.Ints(ts)
+			for i := 0; i < n-2; i++ {
+				if ts[i+2]-ts[i] <= 60 {
+					ans = append(ans, name)
+					break
+				}
+			}
+		}
+	}
+	sort.Strings(ans)
+	return
+}
diff --git a/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.java b/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.java
@@ -0,0 +1,27 @@
+class Solution {
+    public List<String> alertNames(String[] keyName, String[] keyTime) {
+        Map<String, List<Integer>> d = new HashMap<>();
+        for (int i = 0; i < keyName.length; ++i) {
+            String name = keyName[i];
+            String time = keyTime[i];
+            int t = Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3));
+            d.computeIfAbsent(name, k -> new ArrayList<>()).add(t);
+        }
+        List<String> ans = new ArrayList<>();
+        for (var e : d.entrySet()) {
+            var ts = e.getValue();
+            int n = ts.size();
+            if (n > 2) {
+                Collections.sort(ts);
+                for (int i = 0; i < n - 2; ++i) {
+                    if (ts.get(i + 2) - ts.get(i) <= 60) {
+                        ans.add(e.getKey());
+                        break;
+                    }
+                }
+            }
+        }
+        Collections.sort(ans);
+        return ans;
+    }
+}
diff --git a/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.py b/solution/1600-1699/1604.Alert Using Same Key-Card Three or More Times in a One Hour Period/Solution.py
@@ -0,0 +1,16 @@
+class Solution:
+    def alertNames(self, keyName: List[str], keyTime: List[str]) -> List[str]:
+        d = defaultdict(list)
+        for name, t in zip(keyName, keyTime):
+            t = int(t[:2]) * 60 + int(t[3:])
+            d[name].append(t)
+        ans = []
+        for name, ts in d.items():
+            if (n := len(ts)) > 2:
+                ts.sort()
+                for i in range(n - 2):
+                    if ts[i + 2] - ts[i] <= 60:
+                        ans.append(name)
+                        break
+        ans.sort()
+        return ans
