示例 1：
输入：orders = [["David","3","Ceviche"],["Corina","10","Beef Burrito"],["David","3","Fried Chicken"],["Carla","5","Water"],["Carla","5","Ceviche"],["Rous","3","Ceviche"]] -输出：[["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]] +输出：[["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]] 解释： 点菜展示表如下所示： Table,Beef Burrito,Ceviche,Fried Chicken,Water @@ -42,13 +42,13 @@ tags: 10 ,1 ,0 ,0 ,0 对于餐桌 3：David 点了 "Ceviche" 和 "Fried Chicken"，而 Rous 点了 "Ceviche" 而餐桌 5：Carla 点了 "Water" 和 "Ceviche" -餐桌 10：Corina 点了 "Beef Burrito" +餐桌 10：Corina 点了 "Beef Burrito"
示例 2：
输入：orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]
-输出：[["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]
+输出：[["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]
解释：
对于餐桌 1：Adam 和 Brianna 都点了 "Canadian Waffles"
而餐桌 12：James, Ratesh 和 Amadeus 都点了 "Fried Chicken"
@@ -78,7 +78,19 @@ tags:
-### 方法一
+### 方法一：哈希表 + 排序
+
+我们可以用一个哈希表 $\textit{tables}$ 来存储每张餐桌点的菜品，用一个集合 $\textit{items}$ 来存储所有的菜品。
+
+遍历 $\textit{orders}$，将每张餐桌点的菜品存入 $\textit{tables}$ 和 $\textit{items}$ 中。
+
+然后我们将 $\textit{items}$ 排序，得到 $\textit{sortedItems}$。
+
+接下来，我们构建答案数组 $\textit{ans}$，首先将标题行 $\textit{header}$ 加入 $\textit{ans}$，然后遍历排序后的 $\textit{tables}$，对于每张餐桌，我们用一个计数器 $\textit{cnt}$ 来统计每种菜品的数量，然后构建一行 $\textit{row}$，将其加入 $\textit{ans}$。
+
+最后返回 $\textit{ans}$。
+
+时间复杂度 $O(n + m \times \log m + k \times \log k + m \times k)$，空间复杂度 $O(n + m + k)$。其中 $n$ 是数组 $\textit{orders}$ 的长度，而 $m$ 和 $k$ 分别表示菜品种类数和餐桌数。
@@ -87,22 +99,18 @@ tags:
```python
class Solution:
def displayTable(self, orders: List[List[str]]) -> List[List[str]]:
- tables = set()
- foods = set()
- mp = Counter()
- for _, table, food in orders:
- tables.add(int(table))
- foods.add(food)
- mp[f'{table}.{food}'] += 1
- foods = sorted(list(foods))
- tables = sorted(list(tables))
- res = [['Table'] + foods]
- for table in tables:
- t = [str(table)]
- for food in foods:
- t.append(str(mp[f'{table}.{food}']))
- res.append(t)
- return res
+ tables = defaultdict(list)
+ items = set()
+ for _, table, foodItem in orders:
+ tables[int(table)].append(foodItem)
+ items.add(foodItem)
+ sorted_items = sorted(items)
+ ans = [["Table"] + sorted_items]
+ for table in sorted(tables):
+ cnt = Counter(tables[table])
+ row = [str(table)] + [str(cnt[item]) for item in sorted_items]
+ ans.append(row)
+ return ans
```
#### Java
@@ -110,35 +118,34 @@ class Solution:
```java
class Solution {
public List> displayTable(List> orders) {
- Set tables = new HashSet<>();
- Set foods = new HashSet<>();
- Map mp = new HashMap<>();
- for (List order : orders) {
- int table = Integer.parseInt(order.get(1));
- String food = order.get(2);
- tables.add(table);
- foods.add(food);
- String key = table + "." + food;
- mp.put(key, mp.getOrDefault(key, 0) + 1);
+ TreeMap> tables = new TreeMap<>();
+ Set items = new HashSet<>();
+ for (List o : orders) {
+ int table = Integer.parseInt(o.get(1));
+ String foodItem = o.get(2);
+ tables.computeIfAbsent(table, k -> new ArrayList<>()).add(foodItem);
+ items.add(foodItem);
}
- List t = new ArrayList<>(tables);
- List f = new ArrayList<>(foods);
- Collections.sort(t);
- Collections.sort(f);
- List> res = new ArrayList<>();
- List title = new ArrayList<>();
- title.add("Table");
- title.addAll(f);
- res.add(title);
- for (int table : t) {
- List tmp = new ArrayList<>();
- tmp.add(String.valueOf(table));
- for (String food : f) {
- tmp.add(String.valueOf(mp.getOrDefault(table + "." + food, 0)));
+ List sortedItems = new ArrayList<>(items);
+ Collections.sort(sortedItems);
+ List> ans = new ArrayList<>();
+ List header = new ArrayList<>();
+ header.add("Table");
+ header.addAll(sortedItems);
+ ans.add(header);
+ for (Map.Entry> entry : tables.entrySet()) {
+ Map cnt = new HashMap<>();
+ for (String item : entry.getValue()) {
+ cnt.merge(item, 1, Integer::sum);
+ }
+ List row = new ArrayList<>();
+ row.add(String.valueOf(entry.getKey()));
+ for (String item : sortedItems) {
+ row.add(String.valueOf(cnt.getOrDefault(item, 0)));
}
- res.add(tmp);
+ ans.add(row);
}
- return res;
+ return ans;
}
}
```
@@ -149,36 +156,31 @@ class Solution {
class Solution {
public:
vector> displayTable(vector>& orders) {
- unordered_set tables;
- unordered_set foods;
- unordered_map mp;
- for (auto& order : orders) {
- int table = stoi(order[1]);
- string food = order[2];
- tables.insert(table);
- foods.insert(food);
- ++mp[order[1] + "." + food];
+ map> tables;
+ set sortedItems;
+ for (auto& o : orders) {
+ int table = stoi(o[1]);
+ string foodItem = o[2];
+ tables[table].push_back(foodItem);
+ sortedItems.insert(foodItem);
}
- vector t;
- t.assign(tables.begin(), tables.end());
- sort(t.begin(), t.end());
- vector f;
- f.assign(foods.begin(), foods.end());
- sort(f.begin(), f.end());
- vector> res;
- vector title;
- title.push_back("Table");
- for (auto e : f) title.push_back(e);
- res.push_back(title);
- for (int table : t) {
- vector tmp;
- tmp.push_back(to_string(table));
- for (string food : f) {
- tmp.push_back(to_string(mp[to_string(table) + "." + food]));
+ vector> ans;
+ vector header = {"Table"};
+ header.insert(header.end(), sortedItems.begin(), sortedItems.end());
+ ans.push_back(header);
+ for (auto& [table, items] : tables) {
+ unordered_map cnt;
+ for (string& item : items) {
+ cnt[item]++;
+ }
+ vector row;
+ row.push_back(to_string(table));
+ for (const string& item : sortedItems) {
+ row.push_back(to_string(cnt[item]));
}
- res.push_back(tmp);
+ ans.push_back(row);
}
- return res;
+ return ans;
}
};
```
@@ -187,43 +189,74 @@ public:
```go
func displayTable(orders [][]string) [][]string {
- tables := make(map[int]bool)
- foods := make(map[string]bool)
- mp := make(map[string]int)
+ tables := make(map[int]map[string]int)
+ items := make(map[string]bool)
for _, order := range orders {
- table, food := order[1], order[2]
- t, _ := strconv.Atoi(table)
- tables[t] = true
- foods[food] = true
- key := table + "." + food
- mp[key] += 1
- }
- var t []int
- var f []string
- for i := range tables {
- t = append(t, i)
+ table, _ := strconv.Atoi(order[1])
+ foodItem := order[2]
+ if tables[table] == nil {
+ tables[table] = make(map[string]int)
+ }
+ tables[table][foodItem]++
+ items[foodItem] = true
}
- for i := range foods {
- f = append(f, i)
+ sortedItems := make([]string, 0, len(items))
+ for item := range items {
+ sortedItems = append(sortedItems, item)
}
- sort.Ints(t)
- sort.Strings(f)
- var res [][]string
- var title []string
- title = append(title, "Table")
- for _, e := range f {
- title = append(title, e)
+ sort.Strings(sortedItems)
+ ans := [][]string{}
+ header := append([]string{"Table"}, sortedItems...)
+ ans = append(ans, header)
+ tableNums := make([]int, 0, len(tables))
+ for table := range tables {
+ tableNums = append(tableNums, table)
}
- res = append(res, title)
- for _, table := range t {
- var tmp []string
- tmp = append(tmp, strconv.Itoa(table))
- for _, food := range f {
- tmp = append(tmp, strconv.Itoa(mp[strconv.Itoa(table)+"."+food]))
+ sort.Ints(tableNums)
+ for _, table := range tableNums {
+ row := []string{strconv.Itoa(table)}
+ for _, item := range sortedItems {
+ count := tables[table][item]
+ row = append(row, strconv.Itoa(count))
}
- res = append(res, tmp)
+ ans = append(ans, row)
}
- return res
+ return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function displayTable(orders: string[][]): string[][] {
+ const tables: Record> = {};
+ const items: Set = new Set();
+ for (const [_, table, foodItem] of orders) {
+ const t = +table;
+ if (!tables[t]) {
+ tables[t] = {};
+ }
+ if (!tables[t][foodItem]) {
+ tables[t][foodItem] = 0;
+ }
+ tables[t][foodItem]++;
+ items.add(foodItem);
+ }
+ const sortedItems = Array.from(items).sort();
+ const ans: string[][] = [];
+ const header: string[] = ['Table', ...sortedItems];
+ ans.push(header);
+ const sortedTableNumbers = Object.keys(tables)
+ .map(Number)
+ .sort((a, b) => a - b);
+ for (const table of sortedTableNumbers) {
+ const row: string[] = [table.toString()];
+ for (const item of sortedItems) {
+ row.push((tables[table][item] || 0).toString());
+ }
+ ans.push(row);
+ }
+ return ans;
}
```
diff --git a/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md b/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md
index 79d27902b765f..8280934e6cc8f 100644
--- a/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md
+++ b/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md
@@ -34,7 +34,7 @@ tags:
Input: orders = [["David","3","Ceviche"],["Corina","10","Beef Burrito"],["David","3","Fried Chicken"],["Carla","5","Water"],["Carla","5","Ceviche"],["Rous","3","Ceviche"]]
-Output: [["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]]
+Output: [["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]]
Explanation:
@@ -52,7 +52,7 @@ For the table 3: David orders "Ceviche" and "Fried Chicken",
For the table 5: Carla orders "Water" and "Ceviche".
-For the table 10: Corina orders "Beef Burrito".
+For the table 10: Corina orders "Beef Burrito".
@@ -62,9 +62,9 @@ For the table 10: Corina orders "Beef Burrito".
Input: orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]
-Output: [["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]
+Output: [["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]
-Explanation:
+Explanation:
For the table 1: Adam and Brianna order "Canadian Waffles".
@@ -106,7 +106,19 @@ For the table 12: James, Ratesh and Amadeus order "Fried Chicken".
-### Solution 1
+### Solution 1: Hash Table + Sorting
+
+We can use a hash table $\textit{tables}$ to store the dishes ordered at each table, and a set $\textit{items}$ to store all the dishes.
+
+Traverse $\textit{orders}$, storing the dishes ordered at each table in $\textit{tables}$ and $\textit{items}$.
+
+Then we sort $\textit{items}$ to get $\textit{sortedItems}$.
+
+Next, we construct the answer array $\textit{ans}$. First, add the header row $\textit{header}$ to $\textit{ans}$. Then, traverse the sorted $\textit{tables}$. For each table, use a counter $\textit{cnt}$ to count the number of each dish, then construct a row $\textit{row}$ and add it to $\textit{ans}$.
+
+Finally, return $\textit{ans}$.
+
+The time complexity is $O(n + m \times \log m + k \times \log k + m \times k)$, and the space complexity is $O(n + m + k)$. Here, $n$ is the length of the array $\textit{orders}$, while $m$ and $k$ represent the number of dish types and the number of tables, respectively.
@@ -115,22 +127,18 @@ For the table 12: James, Ratesh and Amadeus order "Fried Chicken".
```python
class Solution:
def displayTable(self, orders: List[List[str]]) -> List[List[str]]:
- tables = set()
- foods = set()
- mp = Counter()
- for _, table, food in orders:
- tables.add(int(table))
- foods.add(food)
- mp[f'{table}.{food}'] += 1
- foods = sorted(list(foods))
- tables = sorted(list(tables))
- res = [['Table'] + foods]
- for table in tables:
- t = [str(table)]
- for food in foods:
- t.append(str(mp[f'{table}.{food}']))
- res.append(t)
- return res
+ tables = defaultdict(list)
+ items = set()
+ for _, table, foodItem in orders:
+ tables[int(table)].append(foodItem)
+ items.add(foodItem)
+ sorted_items = sorted(items)
+ ans = [["Table"] + sorted_items]
+ for table in sorted(tables):
+ cnt = Counter(tables[table])
+ row = [str(table)] + [str(cnt[item]) for item in sorted_items]
+ ans.append(row)
+ return ans
```
#### Java
@@ -138,35 +146,34 @@ class Solution:
```java
class Solution {
public List