1655. Distribute Repeating Integers

问题：

给定一组数，将其分配给多个用户，

每个用户要求quantity[i]个相同的数。

问是否能够分配完。

Example 1:
Input: nums = [1,2,3,4], quantity = [2]
Output: false
Explanation: The 0th customer cannot be given two different integers.

Example 2:
Input: nums = [1,2,3,3], quantity = [2]
Output: true
Explanation: The 0th customer is given [3,3]. The integers [1,2] are not used.

Example 3:
Input: nums = [1,1,2,2], quantity = [2,2]
Output: true
Explanation: The 0th customer is given [1,1], and the 1st customer is given [2,2].

Example 4:
Input: nums = [1,1,2,3], quantity = [2,2]
Output: false
Explanation: Although the 0th customer could be given [1,1], the 1st customer cannot be satisfied.

Example 5:
Input: nums = [1,1,1,1,1], quantity = [2,3]
Output: true
Explanation: The 0th customer is given [1,1], and the 1st customer is given [1,1,1].
 
Constraints:
n == nums.length
1 <= n <= 105
1 <= nums[i] <= 1000
m == quantity.length
1 <= m <= 10
1 <= quantity[i] <= 105
There are at most 50 unique values in nums.

　　

解法：Backtracking（回溯算法）

状态：第pos个用户，被分配的数字。

选择：数字中个数>=该pos用户要求的个数，的所有数字选择。

递归退出条件：pos==用户数quantity.size

 

⚠️ 注意：简单的回溯，会导致超时。

因此将用户要求按数字多的->少的进行DESC降序排序，首先满足要求多的。

 

代码参考：

class Solution {
public:
   // int count = 0;
   // void print_intend() {
   //     for(int i=0; i<count; i++)
   //         printf("  ");
   // }
    void backtrack(bool& res, int pos, vector<int>& quantity, vector<int>& nc) {
        if(pos==quantity.size()) {
    //        print_intend();
    //        printf("return true\n");
            res = true;
            return;
        }
       // int idx = lower_bound(nc.begin(), nc.end(), quantity[pos])-nc.begin();
       // print_intend();
       // printf("lower_bound idx:[%d]\n",idx);
        //for(int i=idx; i<nc.size(); i++) {
        for(int i=0; i<nc.size(); i++) {
            if(nc[i]<quantity[pos]) continue;
            nc[i]-=quantity[pos];
      //      count++;
      //      print_intend();
      //      printf("pos:%d, idx:%d, nc[998]:%d ,nc[999]:%d\n", pos, i, nc[998], nc[999]);
            backtrack(res, pos+1, quantity, nc);
      //      count--;
            nc[i]+=quantity[pos];
            if(res==true) return;
        }
        //print_intend();
        //printf("return [try all finished]\n");
        return;
    }
    bool canDistribute(vector<int>& nums, vector<int>& quantity) {
        bool res = false;
        vector<int> nc;
        unordered_map<int, int> ncount;
        for(int n:nums) {
            ncount[n]++; // count
        }
        for(auto nct:ncount) {
            nc.push_back(nct.second);
        }
        sort(quantity.rbegin(), quantity.rend());
        backtrack(res, 0, quantity, nc);
        return res;
    }
};