C++::猿辅导试题

1、用全部N(N<=10)个0-9的数字组成一个“有效”整数（即没有前置0的整数），求这些组成的数中能被K(0<K<10^10)整除的最小数字。

#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
    Solution(long long K,int N, long long maxvalue=2e10):K(K),N(N),result(maxvalue),maxvalue(maxvalue){}
    ~Solution(){}
    long long result;
    long long K;
    int N;
    int maxvalue;
    long long jiusandata(int arr[])
    {
        long long data = 0;int index = 0;
        for(int i=N-1;i>=0;i--)
        {
            data+=arr[i]*pow(10,index);
            index++;
        }
        return data;
    }
    void dfs(int arr[],int l,int r)
    {
        if(l==r){
            if(N!=1&&arr[0]==0) return;
            else{
                long long data = jiusandata(arr);
                if(data%K==0) result = min(result,data);
            }
            return;
        }
        else{
            for(int i = l; i <= r; i++)
                {
                    swap(arr[l],arr[i]);
                    dfs(arr,l+1,r);
                    swap(arr[l],arr[i]);
                }
        }
 
    }
};
int main()
{
    int N;cin>>N;
    long long K;cin>>K;
    int arr[N];
    for(int i=0;i<N;i++)
        cin>>arr[i];
    Solution sou(K,N);
    sou.dfs(arr, 0, N-1);
    if(sou.result==2e10) cout<<-1<<endl;
    else cout<<sou.result<<endl;
    return 0;
}

2、小猿非常热爱学习，所以他在猿辅导上购买了N节课来提升自己，每节课有一个开始时间S和结束时间E（S和E均用正整数表示）。买完课程后，粗心的小猿发现这些课程之间有些时间冲突，幸好小猿有一种“一心多用”的超能力，能同时兼顾K节课上课。当然是K越大，使用这种能力就越累。请问小猿最少需要一心几用，才能上完所有他买的课程呢？

这个题目我自己写了一个没有通过的有bug的代码，自测可以通过，但是整体通不过去，可能是给的测试数字太大内存超了。思路就是把所有的经过点赋值，最大值就是需要几用，但是要把最后的结束点去掉，不然就多加了。

#include <bits/stdc++.h>
using namespace std;
#define pii pair<int,int>

int main()
{
    int course_num; cin>>course_num;
    vector<pii> course(course_num,{0,0});
    for(int i = 0; i < course_num; i++)
    {
        cin>>course[i].first;
        cin>>course[i].second;
    }
    unordered_map<int,int> umap;
    for(int i = 0; i < course_num; i++)
    {
        while(course[i].first<course[i].second){//此处少等号即去掉最后点
            umap[course[i].first]++;
            course[i].first+=1;
        }
    }
    int result = 0;
    unordered_map<int,int>::iterator it = umap.begin();
    while(it!=umap.end())
    {
        result = max(result,it->second);
        it++;
    }
    cout<<result<<endl;
    return 0;
}

我又写了一个时间通不过的：

#include <bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
int main()
{
    int course_num; cin>>course_num;
    vector<pii> course(course_num,{0,0});
    int minv=INT_MAX,maxv=0;//找到最小值和最大值，规规矩矩
    for(int i = 0; i < course_num; i++)
    {
        cin>>course[i].first;
        minv = min(course[i].first,minv);
        cin>>course[i].second;
        maxv = max(course[i].second,maxv);
    }
    //cout<<minv<<" "<<maxv<<endl;
    //sort(course.begin(),course.end(),cmp);
    int result = 0;
    for(int value = minv; value <= maxv; value++)
    {
        int sum = 0;
        for(int j = 0; j < course_num; j++)
        {
            if(value>=course[j].first && value<course[j].second)
                sum++;
        }
        result = max(result,sum);
    }
    cout<<result<<endl;
    return 0;
}