+ problem 1655

Author: fruit-in

Problemset/1655-Distribute Repeating Integers/README.md

@@ -0,0 +1,64 @@
+# 1655. Distribute Repeating Integers
+You are given an array of `n` integers, `nums`, where there are at most `50` unique values in the array. You are also given an array of `m` customer order quantities, `quantity`, where `quantity[i]` is the amount of integers the <code>i<sup>th</sup></code> customer ordered. Determine if it is possible to distribute `nums` such that:
+* The <code>i<sup>th</sup></code> customer gets **exactly** `quantity[i]` integers,
+* The integers the <code>i<sup>th</sup></code> customer gets are **all equal**, and
+* Every customer is satisfied.
+
+Return `true` *if it is possible to distribute* `nums` *according to the above conditions*.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4], quantity = [2]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The 0th customer cannot be given two different integers.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> nums = [1,2,3,3], quantity = [2]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The 0th customer is given [3,3]. The integers [1,2] are not used.
+</pre>
+
+#### Example 3:
+<pre>
+<strong>Input:</strong> nums = [1,1,2,2], quantity = [2,2]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The 0th customer is given [1,1], and the 1st customer is given [2,2].
+</pre>
+
+#### Constraints:
+* `n == nums.length`
+* <code>1 <= n <= 10<sup>5</sup></code>
+* `1 <= nums[i] <= 1000`
+* `m == quantity.length`
+* `1 <= m <= 10`
+* <code>1 <= quantity[i] <= 10<sup>5</sup></code>
+* There are at most `50` unique values in `nums`.
+
+## Solutions (Python)
+
+### 1. Solution
+```Python
+class Solution:
+    def canDistribute(self, nums: List[int], quantity: List[int]) -> bool:
+        def dfs(i: int) -> bool:
+            if i == len(quantity):
+                return True
+
+            for j in range(len(count)):
+                if count[j] >= quantity[i] and (j == 0 or count[j] != count[j - 1]):
+                    count[j] -= quantity[i]
+                    if dfs(i + 1):
+                        return True
+                    count[j] += quantity[i]
+
+            return False
+
+        count = sorted(collections.Counter(nums).values())[-len(quantity):]
+
+        if count[-1] < max(quantity) or sum(count) < sum(quantity):
+            return False
+
+        return dfs(0)
+```

Problemset/1655-Distribute Repeating Integers/README_CN.md

@@ -0,0 +1,64 @@
+# 1655. 分配重复整数
+给你一个长度为 `n` 的整数数组 `nums` ，这个数组中至多有 `50` 个不同的值。同时你有 `m` 个顾客的订单 `quantity` ，其中，整数 `quantity[i]` 是第 `i` 位顾客订单的数目。请你判断是否能将 `nums` 中的整数分配给这些顾客，且满足：
+* 第 `i` 位顾客 **恰好** 有 `quantity[i]` 个整数。
+* 第 `i` 位顾客拿到的整数都是 **相同的** 。
+* 每位顾客都满足上述两个要求。
+
+如果你可以分配 `nums` 中的整数满足上面的要求，那么请返回 `true` ，否则返回 `false` 。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> nums = [1,2,3,4], quantity = [2]
+<strong>输出:</strong> false
+<strong>解释:</strong> 第 0 位顾客没办法得到两个相同的整数。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> nums = [1,2,3,3], quantity = [2]
+<strong>输出:</strong> true
+<strong>解释:</strong> 第 0 位顾客得到 [3,3] 。整数 [1,2] 都没有被使用。
+</pre>
+
+#### 示例 3:
+<pre>
+<strong>输入:</strong> nums = [1,1,2,2], quantity = [2,2]
+<strong>输出:</strong> true
+<strong>解释:</strong> 第 0 位顾客得到 [1,1] ，第 1 位顾客得到 [2,2] 。
+</pre>
+
+#### 提示:
+* `n == nums.length`
+* <code>1 <= n <= 10<sup>5</sup></code>
+* `1 <= nums[i] <= 1000`
+* `m == quantity.length`
+* `1 <= m <= 10`
+* <code>1 <= quantity[i] <= 10<sup>5</sup></code>
+* `nums` 中至多有 `50` 个不同的数字。
+
+## 题解 (Python)
+
+### 1. 题解
+```Python
+class Solution:
+    def canDistribute(self, nums: List[int], quantity: List[int]) -> bool:
+        def dfs(i: int) -> bool:
+            if i == len(quantity):
+                return True
+
+            for j in range(len(count)):
+                if count[j] >= quantity[i] and (j == 0 or count[j] != count[j - 1]):
+                    count[j] -= quantity[i]
+                    if dfs(i + 1):
+                        return True
+                    count[j] += quantity[i]
+
+            return False
+
+        count = sorted(collections.Counter(nums).values())[-len(quantity):]
+
+        if count[-1] < max(quantity) or sum(count) < sum(quantity):
+            return False
+
+        return dfs(0)
+```

Problemset/1655-Distribute Repeating Integers/Solution.py

@@ -0,0 +1,21 @@
+class Solution:
+    def canDistribute(self, nums: List[int], quantity: List[int]) -> bool:
+        def dfs(i: int) -> bool:
+            if i == len(quantity):
+                return True
+
+            for j in range(len(count)):
+                if count[j] >= quantity[i] and (j == 0 or count[j] != count[j - 1]):
+                    count[j] -= quantity[i]
+                    if dfs(i + 1):
+                        return True
+                    count[j] += quantity[i]
+
+            return False
+
+        count = sorted(collections.Counter(nums).values())[-len(quantity):]
+
+        if count[-1] < max(quantity) or sum(count) < sum(quantity):
+            return False
+
+        return dfs(0)

README.md

@@ -1127,6 +1127,7 @@
 [1652][1652l]|[Defuse the Bomb][1652]                                                               |![rb]  ![rs]
 [1653][1653l]|[Minimum Deletions to Make String Balanced][1653]                                     |![rs]
 [1654][1654l]|[Minimum Jumps to Reach Home][1654]                                                   |![rs]
+[1655][1655l]|[Distribute Repeating Integers][1655]                                                 |![py]
 [1656][1656l]|[Design an Ordered Stream][1656]                                                      |![py]
 [1657][1657l]|[Determine if Two Strings Are Close][1657]                                            |![py]
 [1658][1658l]|[Minimum Operations to Reduce X to Zero][1658]                                        |![rb]  ![rs]
@@ -2867,6 +2868,7 @@
 [1652]:Problemset/1652-Defuse%20the%20Bomb/README.md#1652-defuse-the-bomb
 [1653]:Problemset/1653-Minimum%20Deletions%20to%20Make%20String%20Balanced/README.md#1653-minimum-deletions-to-make-string-balanced
 [1654]:Problemset/1654-Minimum%20Jumps%20to%20Reach%20Home/README.md#1654-minimum-jumps-to-reach-home
+[1655]:Problemset/1655-Distribute%20Repeating%20Integers/README.md#1655-distribute-repeating-integers
 [1656]:Problemset/1656-Design%20an%20Ordered%20Stream/README.md#1656-design-an-ordered-stream
 [1657]:Problemset/1657-Determine%20if%20Two%20Strings%20Are%20Close/README.md#1657-determine-if-two-strings-are-close
 [1658]:Problemset/1658-Minimum%20Operations%20to%20Reduce%20X%20to%20Zero/README.md#1658-minimum-operations-to-reduce-x-to-zero
@@ -4601,6 +4603,7 @@
 [1652l]:https://leetcode.com/problems/defuse-the-bomb/
 [1653l]:https://leetcode.com/problems/minimum-deletions-to-make-string-balanced/
 [1654l]:https://leetcode.com/problems/minimum-jumps-to-reach-home/
+[1655l]:https://leetcode.com/problems/distribute-repeating-integers/
 [1656l]:https://leetcode.com/problems/design-an-ordered-stream/
 [1657l]:https://leetcode.com/problems/determine-if-two-strings-are-close/
 [1658l]:https://leetcode.com/problems/minimum-operations-to-reduce-x-to-zero/

README_CN.md

@@ -1127,6 +1127,7 @@
 [1652][1652l]|[拆炸弹][1652]                                            |![rb]  ![rs]
 [1653][1653l]|[使字符串平衡的最少删除次数][1653]                        |![rs]
 [1654][1654l]|[到家的最少跳跃次数][1654]                                |![rs]
+[1655][1655l]|[分配重复整数][1655]                                      |![py]
 [1656][1656l]|[设计有序流][1656]                                        |![py]
 [1657][1657l]|[确定两个字符串是否接近][1657]                            |![py]
 [1658][1658l]|[将 x 减到 0 的最小操作数][1658]                          |![rb]  ![rs]
@@ -2867,6 +2868,7 @@
 [1652]:Problemset/1652-Defuse%20the%20Bomb/README_CN.md#1652-拆炸弹
 [1653]:Problemset/1653-Minimum%20Deletions%20to%20Make%20String%20Balanced/README_CN.md#1653-使字符串平衡的最少删除次数
 [1654]:Problemset/1654-Minimum%20Jumps%20to%20Reach%20Home/README_CN.md#1654-到家的最少跳跃次数
+[1655]:Problemset/1655-Distribute%20Repeating%20Integers/README_CN.md#1655-分配重复整数
 [1656]:Problemset/1656-Design%20an%20Ordered%20Stream/README_CN.md#1656-设计有序流
 [1657]:Problemset/1657-Determine%20if%20Two%20Strings%20Are%20Close/README_CN.md#1657-确定两个字符串是否接近
 [1658]:Problemset/1658-Minimum%20Operations%20to%20Reduce%20X%20to%20Zero/README_CN.md#1658-将-x-减到-0-的最小操作数
@@ -4601,6 +4603,7 @@
 [1652l]:https://leetcode.cn/problems/defuse-the-bomb/
 [1653l]:https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced/
 [1654l]:https://leetcode.cn/problems/minimum-jumps-to-reach-home/
+[1655l]:https://leetcode.cn/problems/distribute-repeating-integers/
 [1656l]:https://leetcode.cn/problems/design-an-ordered-stream/
 [1657l]:https://leetcode.cn/problems/determine-if-two-strings-are-close/
 [1658l]:https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero/