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 = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> vc[i][j];
        }
    }
}

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

int subtractProductAndSum(int n) {
    if (n < 10) return 0;
    int he = 0, ji = 1;
    int temp;
    temp = n % 10;
    while (n) {
        he += temp;
        ji *= temp;
        n = n / 10;
        temp = n % 10;
    }
    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(),0);
    int count = 0;
    while(count<groupSizes.size()){
        for (int i = 0; i < groupSizes.size(); i++)
        {
            if (a[i] == 0) //可用
            {
                level.push_back(i);
                a[i] = 1;
                count++;
                if (level.size() != groupSizes[i])
                {
                    for (int j = i + 1; j < groupSizes.size(); j++)
                    {
                        if (groupSizes[j] == groupSizes[i] && a[j] == 0) {
                            level.push_back(j);
                            a[j] = 1;
                            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 = 1;
    int high = nums[nums.size() - 1];
    int res=nums[0];
    int mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (!isornot(nums, mid, threshold))  //如果mid不符合，说明，答案在右半个区间，更新low
            low = mid + 1;
        else  //否则，在左半个区间，更新high
        {
            high = mid - 1;
            res = mid;
        }
    }
    return res;
}

bool isornot(vector<int> nums,int number, int threshold) {
    int sum = 0;
    for (int i = 0; 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 0;
}

第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 = 0;
    for (int i = 0; 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 = 1;
    int high = nums[nums.size() - 1];
    int res=nums[0];
    int mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (!isornot(nums, mid, threshold))  //如果mid不符合，说明，答案在右半个区间，更新low
            low = mid + 1;
        else  //否则，在左半个区间，更新high
        {
            high = mid - 1;
            res = mid;
        }
    }
    return res;
}

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

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

题目四：

　　后续补充~~~