[LeetCode] 1419. Minimum Number of Frogs Croaking

Posted 2023-05-06 CNoodle

You are given the string croakOfFrogs, which represents a combination of the string "croak" from different frogs, that is, multiple frogs can croak at the same time, so multiple "croak" are mixed.

Return the minimum number of different frogs to finish all the croaks in the given string.

A valid "croak" means a frog is printing five letters \'c\', \'r\', \'o\', \'a\', and \'k\' sequentially. The frogs have to print all five letters to finish a croak. If the given string is not a combination of a valid "croak" return -1.

Example 1:

Input: croakOfFrogs = "croakcroak"
Output: 1 
Explanation: One frog yelling "croak" twice.

Example 2:

Input: croakOfFrogs = "crcoakroak"
Output: 2 
Explanation: The minimum number of frogs is two. 
The first frog could yell "crcoakroak".
The second frog could yell later "crcoakroak".

Example 3:

Input: croakOfFrogs = "croakcrook"
Output: -1
Explanation: The given string is an invalid combination of "croak" from different frogs.

Constraints:

• 1 <= croakOfFrogs.length <= 105
• croakOfFrogs is either \'c\', \'r\', \'o\', \'a\', or \'k\'.

数青蛙。

给你一个字符串 croakOfFrogs，它表示不同青蛙发出的蛙鸣声（字符串 "croak" ）的组合。由于同一时间可以有多只青蛙呱呱作响，所以 croakOfFrogs 中会混合多个 “croak” 。

请你返回模拟字符串中所有蛙鸣所需不同青蛙的最少数目。

要想发出蛙鸣 "croak"，青蛙必须 依序 输出 ‘c’, ’r’, ’o’, ’a’, ’k’ 这 5 个字母。如果没有输出全部五个字母，那么它就不会发出声音。如果字符串 croakOfFrogs 不是由若干有效的 "croak" 字符混合而成，请返回 -1 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-number-of-frogs-croaking
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路是模拟。注意题目描述的蛙鸣声，一定是依序输出 croak 这五个字母，如果中间出现次序颠倒则返回 -1。同时因为题目允许多个青蛙同时开始发出蛙鸣声，所以这道题的难点在于如何区分到底是多个青蛙同时开始蛙鸣还是中间出现了次序颠倒。我的做法是创建一个长度为 5 的数组 map，在遍历 input 字符串的过程中记录五个字母各自出现的次数，同时我需要一个 frog 变量记录当前同时发出蛙鸣声的青蛙数量，以及一个 max 变量记录全局最多需要的青蛙数。

• 如果出现的是 c，因为这是蛙鸣声的第一个字母，所以我必须需要一个青蛙，frog++
• 如果出现的是 k，因为这是蛙鸣声的最后一个字母，所以此时我可以减去一个青蛙，frog--
• 如果出现的是其他字母，比如出现的是 a，我需要判断在蛙鸣声序列里在 a 之前出现的那个字母 o 的出现次数是否大于 0，如果小于 0，则说明出现了一个无效的序列，直接返回 -1

最后判断 frog == 0，因为如果 input 是一个合法的序列，最后所有青蛙都会因为输出了自己的 k 而被减去。如果 frog != 0，说明有青蛙没有结束他的蛙鸣声，这是一个不合法的 input。

时间O(n)

空间O(1) - 只用了一个长度为 5 的 map 数组

Java实现

 class Solution 
     public int minNumberOfFrogs(String croakOfFrogs) 
         int[] map = new int[5];
         String s = "croak";
         int frogs = 0;
         int max = 0;
         for (char letter : croakOfFrogs.toCharArray()) 
             // 记录每个字母的出现次数
             int index = s.indexOf(letter);
             map[index]++;
             // 如果是c，则frog必须++，需要多一个青蛙
             if (index == 0) 
                 frogs++;
                 max = Math.max(max, frogs);
             
             // 如果是中间的字母，则检查序列中前一个字母是否够用
             else if (--map[index - 1] < 0) 
                 return -1;
             
             // 如果是k，则说明理论上有一个青蛙已经结束他的序列了，frog--
             else if (index == 4) 
                 frogs--;
             
         
         return frogs == 0 ? max : -1;
     
 

 

LeetCode 题目总结

LeetCode 939. Minimum Area Rectangle

原题链接在这里：https://leetcode.com/problems/minimum-area-rectangle/

题目：

Given a set of points in the xy-plane, determine the minimum area of a rectangle formed from these points, with sides parallel to the x and y axes.

If there isn\'t any rectangle, return 0.

Example 1:

Input: [[1,1],[1,3],[3,1],[3,3],[2,2]]
Output: 4

Example 2:

Input: [[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
Output: 2

Note:

1. 1 <= points.length <= 500
2. 0 <= points[i][0] <= 40000
3. 0 <= points[i][1] <= 40000
4. All points are distinct.

题解：

Use a HashMap to maintain all y of the same x.

Then try to find the diagonal nodes, get one node from x and one node from y, if x[0] == y[0] || x[1] == y[1], skip, they can\'t be diagonal nodes.

Else if in x[0] HashMap entry contains y[1] and in y[0] HashMap entry contains x[1], then x and y could diagonal nodes. Use it to update rectangle size.

Note: check res == Integer.MAX_VALUE before return.

Time Complexity: O(n ^ 2). n = points.length.

Space: O(n).

AC Java:

 1 class Solution {
 2     public int minAreaRect(int[][] points) {
 3         if(points == null || points.length < 4){
 4             return 0;
 5         }
 6         
 7         HashMap<Integer, Set<Integer>> hm = new HashMap<>();
 8         for(int [] p : points){
 9             hm.putIfAbsent(p[0], new HashSet<>());
10             hm.get(p[0]).add(p[1]);
11         }
12         
13         int res = Integer.MAX_VALUE;
14         for(int [] p1 : points){
15             for(int [] p2 : points){
16                 if(p1[0] == p2[0] || p1[1] == p2[1]){
17                     continue;
18                 }
19                 
20                 if(hm.get(p1[0]).contains(p2[1]) && hm.get(p2[0]).contains(p1[1])){
21                     res = Math.min(res, Math.abs(p2[0] - p1[0]) * Math.abs(p2[1] - p1[1]));
22                 }
23             }
24         }
25         
26         return res == Integer.MAX_VALUE ? 0 : res;
27     }
28 }

跟上Minimum Area Rectangle II.