Leetcode 5281. 使结果不超过阈值的最小除数

又一次参赛，除了第一道Easy题和第二道Medium外，剩下的两道在有限时间内，要么没思路，要么思路不对，超时，要么有思路调试出错，还需多加练习！

（这次的第三题，在循环从1开始，直到找到满足地为止，早就预料到会超时，提交之后果然Time out，切换思路，二分查找，但是有限时间内，没有调试正确！这里做一下笔记，以便学习和提高！）

实际代码记录：

 #include <iostream>
 #include <vector>
 #include <map>
 #include <algorithm>
 #include <math.h>

 using namespace std;
 void init(vector<vector<int> > &vc,int m,int n)
 {
     vector<int> level;
     level.resize(n);
     vc.resize(m,level);
     for (int i = ; i < m; i++) {
         for (int j = ; j < n; j++) {
             cin >> vc[i][j];
         }
     }
 }

 void printvc(const vector<vector<int> > vc) {
     for (int i = ; i < vc.size(); i++)
     {
         for (int j = ; j < vc[].size(); j++)
         {
             cout << vc[i][j] << " ";
         }
         cout << endl;
     }
 }

 int subtractProductAndSum(int n) {
     if (n < ) return ;
     int he = , ji = ;
     int temp;
     temp = n % ;
     while (n) {
         he += temp;
         ji *= temp;
         n = n / ;
         temp = n % ;
     }
     cout << "he is " << he << endl;
     cout << "ji is " << ji << endl;
     return ji - he;
 }

 vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
     vector<vector<int>> res;
     vector<int> level;
     vector<int> a;
     a.resize(groupSizes.size(),);
     int count = ;
     while(count<groupSizes.size()){
         for (int i = ; i < groupSizes.size(); i++)
         {
             if (a[i] == ) //可用
             {
                 level.push_back(i);
                 a[i] = ;
                 count++;
                 if (level.size() != groupSizes[i])
                 {
                     for (int j = i + ; j < groupSizes.size(); j++)
                     {
                         if (groupSizes[j] == groupSizes[i] && a[j] == ) {
                             level.push_back(j);
                             a[j] = ;
                             count++;
                             if (level.size() == groupSizes[i])
                                 break;
                         }
                     }
                 }

                 res.push_back(level);
                 level.clear();
                 break;
             }
         }
     }

     return res;
 }

 bool isornot(vector<int> nums, int number, int threshold);
 int smallestDivisor(vector<int>& nums, int threshold) {
     //先排序
     sort(nums.begin(), nums.end());
     //然后二分查找一个满足的值
     int low = ;
     int high = nums[nums.size() - ];
     int res=nums[];
     int mid;
     while (low <= high) {
         mid = (low + high) / ;
         if (!isornot(nums, mid, threshold))  //如果mid不符合，说明，答案在右半个区间，更新low
             low = mid + ;
         else  //否则，在左半个区间，更新high
         {
             high = mid - ;
             res = mid;
         }
     }
     return res;
 }

 bool isornot(vector<int> nums,int number, int threshold) {
     int sum = ;
     for (int i = ; i < nums.size(); i++)
     {
         sum += ceil(nums[i] / (number*1.0));
         //cout<< number<<" sum is "<<sum<<endl;
         if (sum > threshold)
             return false;
     }
     return true;
 }
 int main()
 {
 //    vector<vector<int> > vc;
     //init(vc,3,4);
     //printvc(vc);

     /* 第一题
     int n;
     cin >> n;
     cout << subtractProductAndSum(n) << endl;
     return 0;
     */

     /* 第二题
     vector<int> a;
     int n;
     cin >> n;
     a.resize(n);
     for (int i = 0; i < n; i++)
     {
         cin >> a[i];
     }
     vector<vector<int>> res;
     res = groupThePeople(a);
     for (int j = 0; j < res.size(); j++)
     {
         for (int k = 0; k < res[j].size(); k++)
         {
             cout << res[j][k] << " ";
         }
         cout << endl;
     }
     return 0;
     */

     /*
     vector<int> a;
     int n;
     cin >> n;
     int threshold;
     cin >> threshold;
     a.resize(n);
     for (int i = 0; i < n; i++)
     {
         cin >> a[i];
     }
     int res = smallestDivisor(a,threshold);
     cout << res << endl;

     return 0;
     */

     return ;
 }

第166周赛题目列表：

分析：

　　第一题很简单，直接提出数字n的每一位，进行求和和求积，然后返回差即可！

　　第二题是说，每个人站在一个确定人数的分组里，那么，加入这个人在3个人的组group里，group.size()就等于每个人身上的号码。

　　第三题，就是一开始遍历所有值，但是超时，然后采用二分搜索的方式进行求解：

题目三：

　　给你一个整数数组 nums 和一个正整数 threshold  ，你需要选择一个正整数作为除数，然后将数组里每个数都除以它，并对除法结果求和。

　　请你找出能够使上述结果小于等于阈值 threshold 的除数中 最小 的那个。

　　每个数除以除数后都向上取整，比方说 7/3 = 3 ， 10/2 = 5 。

　　题目保证一定有解。

示例 1：

　　输入：nums = [1,2,5,9], threshold = 6
　　输出：5
　　解释：如果除数为 1 ，我们可以得到和为 17 （1+2+5+9）。
　　如果除数为 4 ，我们可以得到和为 7 (1+1+2+3) 。如果除数为 5 ，和为 5 (1+1+1+2)。

首先写一个函数，判断一个数是否满足数组nums和阈值threshold，

 bool isornot(vector<int> nums,int number, int threshold) {
     int sum = ;
     for (int i = ; i < nums.size(); i++)
     {
         sum += ceil(nums[i] / (number*1.0));
         //cout<< number<<" sum is "<<sum<<endl;
         if (sum > threshold)
             return false;
     }
     return true;
 }

然后，数组确定，二分查找这样的最小值即可；

 int smallestDivisor(vector<int>& nums, int threshold) {
     //先排序
     sort(nums.begin(), nums.end());
     //然后二分查找一个满足的值
     int low = ;
     int high = nums[nums.size() - ];
     int res=nums[];
     int mid;
     while (low <= high) {
         mid = (low + high) / ;
         if (!isornot(nums, mid, threshold))  //如果mid不符合，说明，答案在右半个区间，更新low
             low = mid + ;
         else  //否则，在左半个区间，更新high
         {
             high = mid - ;
             res = mid;
         }
     }
     return res;
 }

题目给定的值，一定满足有解，所以不用考虑无解的情况，因此，low=1，high=max(nums)，即当所有的商为1时，最终和最小，一定小于等于阈值；

(很遗憾，当时思路对，但是没有调试出来！)

题目四：

　　后续补充~~~