CF#386(Div.2) 解题报告

最新推荐文章于 2024-07-15 17:55:50 发布
最新推荐文章于 2024-07-15 17:55:50 发布
阅读量539 收藏
点赞数
分类专栏： 题解 模拟 贪心 构造 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Clove_unique/article/details/53760067
版权
题解 同时被 3 个专栏收录
1097 篇文章 4 订阅
订阅专栏
线段树
70 篇文章 0 订阅
订阅专栏
贪心
57 篇文章 0 订阅
订阅专栏

A

题意

给出 a,b,c ，取3个数满足 0≤ca≤a,0≤cb≤b,0≤cc≤c,ca:cb:cc=1:2:4 ，并且使 ca,cb,cc 的总和最大。如果无法满足，输出0.

数据范围

0≤a,b,c≤1000

题解

随便乱搞搞…

   #include<algorithm>
   #include<iostream>
   #include<cstring>
   #include<cstdio>
   #include<cmath>
   #include<queue>
   #include<ctime>
   using namespace std;

   int a,b,c,ans;

   int main()
   {
    scanf("%d%d%d",&a,&b,&c);
    for (int i=a;i>=1;--i)
        if (i*2<=b&&i*4<=c) {ans=i+i*2+i*4;break;}
    printf("%d\n",ans);
   }

B

题意

一个长度为 n 的字符串的中间字符定义为s[⌊n−12⌋+1]，每次取出字符串的中间字符能拼成一个新的字符串。给出变换之后的字符串，求初始字符串。

数据范围

1≤n≤2000

题解

根据奇偶的不同加加减减
随便乱搞搞…

   #include<algorithm>
   #include<iostream>
   #include<cstring>
   #include<cstdio>
   #include<cmath>
   #include<queue>
   #include<ctime>
   using namespace std;
   #define N 5005

   int n,now;
   char s[N],ans[N];

   int main()
   {
    scanf("%d\n",&n);gets(s+1);
    now=(n-1)/2+1;
    for (int i=1;i<=n;++i)
    {
        ans[now]=s[i];
        if (n%2==0)
        {
            if (i%2) now+=i;
            else now-=i;
        }
        else
        {
            if (i%2) now-=i;
            else now+=i;
        }
    }
    for (int i=1;i<=n;++i) putchar(ans[i]);
    putchar('\n');
   }

C

题意

数据范围

2≤s≤100,0≤x1,x2≤s,x1≠x2,1≤t1,t2≤1000,1≤p≤s−1,0≤d≤1

题解

很显然这道题只是比较人和车谁跑得快而已…
那么根据 x1,x2,p 的位置以及方向 d 分类讨论计算就可以了。

   #include<algorithm>
   #include<iostream>
   #include<cstring>
   #include<cstdio>
   #include<cmath>
   #include<queue>
   #include<ctime>
   using namespace std;

   int s,x1,x2,t1,t2,p,d,ans1,ans2,ans;

   int main()
   {
    scanf("%d%d%d",&s,&x1,&x2);
    scanf("%d%d",&t1,&t2);
    scanf("%d%d",&p,&d);
    if (x1==x2)
    {
        puts("0");
        return 0;
    }
    if (x1<x2)
    {
        ans1=(x2-x1)*t2;
        if (d==1)
        {
            if (p<=x1) ans2=(x2-p)*t1;
            else ans2=(s-p+s+x2)*t1;
        }
        else ans2=(p+x2)*t1;
    }
    else
    {
        ans1=(x1-x2)*t2;
        if (d==1)
            ans2=(s-p+s-x2)*t1;
        else
        {
            if (p>=x1) ans2=(p-x2)*t1;
            else ans2=(p+s+s-x2)*t1;
        }
    }
    ans=min(ans1,ans2);
    printf("%d\n",ans);
   }

D

题意

给出a个‘G’b个‘B’共n个字母，将他们排列，问是否存在一种方案使得这两个字母连续都不超过k个。

数据范围

1≤n,k≤105,0≤a,b≤n,a+b=n

题解

构造体吖
首先如果a=b特判
然后先将所有少的分散来放，再将多的塞在中间，都只塞一个，形成类似GBGBG这种形状，然后再把多余的多的塞到可以塞的位置，要保证合法。这样做可以防止之前放多了后来不够的情况。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
#include<ctime>
using namespace std;
#define N 100005

int n,k,a,b;
bool flag;
int cnt[N];
char A,B;

int main()
{
    scanf("%d%d%d%d",&n,&k,&a,&b);
    if (a==b)
    {
        for (int i=1;i<=n;++i)
            if (i%2) putchar('G');
            else putchar('B');
        putchar('\n');
        return 0;
    }
    if (a<b) swap(a,b),flag=1;
    for (int i=1;i<=2*b+1;++i) cnt[i]=1;
    a-=b+1;
    for (int i=1;i<=2*b+1;i+=2)
    {
        if (a>=k-1)
        {
            cnt[i]+=k-1;
            a-=k-1;
        }
        else
        {
            cnt[i]+=a;
            a=0;
        }
        if (!a) break;
    }
    if (a)
    {
        puts("NO");
        return 0;
    }
    if (!flag) A='G',B='B';
    else A='B',B='G';
    for (int i=1;i<=2*b+1;++i)
    {
        if (i%2)
        {
            while (cnt[i]--) putchar(A);
        }
        else
        {
            while (cnt[i]--) putchar(B);
        }
    }
    putchar('\n');
}

E

题意

给出一列n个数，问能否从1~m这些数中选出一些数替换掉这n个数中的若干数使得这n个数中奇数和偶数的个数相等并且没有重复出现的数。如果可以，输出最少替换个数和方案，否则-1.

数据范围

2≤n≤2∗105,1≤m≤109,1≤ai≤109

题解

其实这道题没什么难的，就是有点麻烦。
首先统计出来要换多少个数，然后分奇偶找就可以了。需要注意的是不需要替换的数尽量找大的，这样1~m的限制更容易被满足，是一个贪心的思想。

   #include<algorithm>
   #include<iostream>
   #include<cstring>
   #include<cstdio>
   #include<cmath>
   #include<queue>
   #include<ctime>
   using namespace std;
   #define N 200005

   int n,m;
   struct hp{int val,id;bool flag;}a[N];
   int odd[N],even[N],cnt,cnto,cnte,anso[N],anse[N];

   int cmpval(hp a,hp b)
   {
    return a.val>b.val;
   }
   int cmpid(hp a,hp b)
   {
    return a.id<b.id;
   }
   int main()
   {
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i) scanf("%d",&a[i].val),a[i].id=i;
    sort(a+1,a+n+1,cmpval);
    a[0].val=0;odd[++odd[0]]=-1;even[++even[0]]=0;
    for (int i=1;i<=n;++i)
        if (a[i].val!=a[i-1].val)
        {
            if (a[i].val%2)
            {
                odd[++odd[0]]=a[i].val;
                if (odd[0]-1<=n/2) a[i].flag=true;
            }
            else
            {
                even[++even[0]]=a[i].val;
                if (even[0]-1<=n/2) a[i].flag=true;
            }
        }
    if (odd[0]-1<=n/2) cnto=n/2-odd[0]+1;
    if (even[0]-1<=n/2) cnte=n/2-even[0]+1;
    cnt=cnto+cnte;
    sort(odd+1,odd+odd[0]+1);
    sort(even+1,even+even[0]+1);

    for (int i=2;i<=odd[0];++i)
    {
        if (!cnto) break;
        for (int j=odd[i-1]+2;j<odd[i];j+=2)
        {
            anso[++anso[0]]=j;
            --cnto;
            if (!cnto) break;
        }
    }
    for (int i=odd[odd[0]]+2;i<=m;i+=2)
    {
        if (!cnto) break;
        anso[++anso[0]]=i;
        --cnto;
    }
    if (cnto)
    {
        puts("-1");
        return 0;
    }

    for (int i=2;i<=even[0];++i)
    {
        if (!cnte) break;
        for (int j=even[i-1]+2;j<even[i];j+=2)
        {
            anse[++anse[0]]=j;
            --cnte;
            if (!cnte) break;
        }
    }
    for (int i=even[even[0]]+2;i<=m;i+=2)
    {
        if (!cnte) break;
        anse[++anse[0]]=i;
        --cnte;
    }
    if (cnte)
    {
        puts("-1");
        return 0;
    }

    for (int i=1;i<=n;++i)
        if (!a[i].flag)
        {
            if (anso[0]) a[i].val=anso[anso[0]--];
            else a[i].val=anse[anse[0]--];
        }
    sort(a+1,a+n+1,cmpid);
    printf("%d\n",cnt);
    for (int i=1;i<=n;++i)
        printf("%d%c",a[i].val," \n"[i==n]);
   }

F

题意

有 n 首歌，每个歌有一个喜悦值ai，以及时间 ti 。每首歌可以选择听一半或者听完。听一半的话时间定义为 ⌈ti2⌉ 。一共有 k 分钟，至多选择w首歌听一半，可以从任意一首歌开始听，但是不能跳歌，问获得的最大的喜悦值是多少。

数据范围

1 ≤ w ≤ n ≤ 2⋅105,1 ≤ k ≤ 2⋅109,1 ≤ ai ≤ 104,2 ≤ ti ≤ 104

题解

这道题可以用左右两个指针来解决，也就是单调地移动区间。
首先脑子正常的人都明白只要在 w 之内能听一半就听一半一定是更优的。如果区间长度小于或等于w的话一定是所有的歌都听一半，如果区间长度大于 w 的话那么应该选择这个区间里前w个大的来听一半，这样时间一定是更优的。
但是不能跳歌，也就是说如果一首歌无论如何都听不了的话后面的也就听不了了。所以无论何时端点移动的时候都必须满足要么区间里的所有歌都听一半， w 可以有剩余，要么听区间里的前w大的歌。
这样每一次找最大值和最小值替换的时候就需要用到数据结构来维护，线段树就可以。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
#include<ctime>
using namespace std;
#define N 200005

int n,w,k;
int inf,l,r,sum,val,ans;
int a[N],f[N],_f[N],h[N],_h[N];

namespace Min
{
    int minn[N*4];
    void update(int now)
    {
        if (_h[minn[now<<1]]<=_h[minn[now<<1|1]])
            minn[now]=minn[now<<1];
        else minn[now]=minn[now<<1|1];
    }
    void build(int now,int l,int r)
    {
        int mid=(l+r)>>1;
        if (l==r)
        {
            minn[now]=l;
            return;
        }
        build(now<<1,l,mid);
        build(now<<1|1,mid+1,r);
        update(now);
    }
    void change(int now,int l,int r,int x)
    {
        int mid=(l+r)>>1;
        if (l==r)
        {
            minn[now]=x;
            return;
        }
        if (x<=mid) change(now<<1,l,mid,x);
        else change(now<<1|1,mid+1,r,x);
        update(now);
    }
    int query(int now,int l,int r,int lrange,int rrange)
    {
        if (lrange>rrange) return 0;
        int mid=(l+r)>>1,ans=0;
        if (lrange<=l&&r<=rrange) return minn[now];
        if (lrange<=mid)
        {
            int q=query(now<<1,l,mid,lrange,rrange);
            if (_h[ans]>_h[q]) ans=q;
        }
        if (mid+1<=rrange)
        {
            int q=query(now<<1|1,mid+1,r,lrange,rrange);
            if (_h[ans]>_h[q]) ans=q;
        }
        return ans;
    }
}
namespace Max
{
    int maxn[N*4];
    void update(int now)
    {
        if (_f[maxn[now<<1]]>=_f[maxn[now<<1|1]])
            maxn[now]=maxn[now<<1];
        else maxn[now]=maxn[now<<1|1];
    }
    void build(int now,int l,int r)
    {
        int mid=(l+r)>>1;
        if (l==r)
        {
            maxn[now]=l;
            return;
        }
        build(now<<1,l,mid);
        build(now<<1|1,mid+1,r);
        update(now);
    }
    void change(int now,int l,int r,int x)
    {
        int mid=(l+r)>>1;
        if (l==r)
        {
            maxn[now]=x;
            return;
        }
        if (x<=mid) change(now<<1,l,mid,x);
        else change(now<<1|1,mid+1,r,x);
        update(now);
    }
    int query(int now,int l,int r,int lrange,int rrange)
    {
        if (lrange>rrange) return 0;
        int mid=(l+r)>>1,ans=0;
        if (lrange<=l&&r<=rrange) return maxn[now];
        if (lrange<=mid)
        {
            int q=query(now<<1,l,mid,lrange,rrange);
            if (_f[ans]<_f[q]) ans=q;
        }
        if (mid+1<=rrange)
        {
            int q=query(now<<1|1,mid+1,r,lrange,rrange);
            if (_f[ans]<_f[q]) ans=q;
        }
        return ans;
    }
}

int main()
{
    scanf("%d%d%d",&n,&w,&k);
    for (int i=1;i<=n;++i) scanf("%d",&a[i]);
    for (int i=1;i<=n;++i)
    {
        scanf("%d",&f[i]);
        _f[i]=f[i];
        h[i]=(f[i]-1)/2+1;
    }
    memset(_h,127,sizeof(_h));inf=_h[0];
    Max::build(1,1,n);
    Min::build(1,1,n);
    while (l<=n)
    {
        if (l<=r)
        {
            val-=a[l];
            if (_h[l]!=inf)
            {
                sum-=h[l];
                int loc=Max::query(1,1,n,l,r);
                if (loc)
                {
                    sum-=f[loc]-h[loc];
                    _f[loc]=0;_h[loc]=h[loc];
                    Max::change(1,1,n,loc);Min::change(1,1,n,loc);
                }
                else ++w;
            }
            else sum-=f[l];
        }
        ++l;
        r=max(r,l-1);
        while (r<n)
        {
            if (w)
            {
                if (sum+h[r+1]<=k)
                {
                    sum+=h[r+1];
                    _f[r+1]=0;_h[r+1]=h[r+1];
                    Max::change(1,1,n,r+1);
                    Min::change(1,1,n,r+1);
                    --w;
                    val+=a[++r];
                }
                else break;
            }
            else
            {
                int loc=Min::query(1,1,n,l,r);
                if (loc&&f[loc]-h[loc]<f[r+1]-h[r+1]&&sum-h[loc]+f[loc]+h[r+1]<=k)
                {
                    sum+=f[loc]-h[loc];
                    _f[loc]=f[loc];_h[loc]=inf;
                    Max::change(1,1,n,loc);Min::change(1,1,n,loc);
                    sum+=h[r+1];
                    _f[r+1]=0;_h[r+1]=h[r+1];
                    Max::change(1,1,n,r+1);Min::change(1,1,n,r+1);
                    val+=a[++r];
                }
                else if (sum+f[r+1]<=k)
                {
                    sum+=f[r+1];
                    val+=a[++r];
                }
                else break;
            }
        }
        ans=max(ans,val);
    }
    printf("%d\n",ans);
}

G

题意

构造一棵有 n 个节点，以1为根的树，满足共有t+1层， k 个叶子节点，第i+1层有 ai 个节点。

数据范围

1≤n≤2∗105,1≤t,k<n,1≤ai<n

题解

怎么又是一道构造题…
首先如果这一层的节点数 ai 比下一层 ai+1 要多，那么这一层一定会有 ai−ai+1 个叶子节点。
最后一层的节点一定都是叶子节点。
那么我们可以计算出来最少的叶子节点有多少个，然后指定一些为一定为叶子节点。然后在剩余的点中建树，如果叶子节点不够的话就把儿子都往一个父亲上连，产生一些叶子节点，如果够了的话就一个儿子连一个父亲。

  #include<algorithm>
  #include<iostream>
  #include<cstring>
  #include<cstdio>
  #include<cmath>
  #include<queue>
  #include<ctime>
  using namespace std;
  #define N 200005

  int n,t,k,must,last,now;
  int a[N],b[N],s[N],f[N];

  int main()
  {
    scanf("%d%d%d",&n,&t,&k);a[0]=s[0]=1;
    for (int i=1;i<=t;++i)
    {
        scanf("%d",&a[i]);
        s[i]=s[i-1]+a[i];
        if (a[i]<a[i-1]) must+=a[i-1]-a[i],b[i-1]=a[i-1]-a[i];
    }
    must+=a[t];
    if (s[t]!=n||must>k)
    {
        puts("-1");
        return 0;
    }
    k-=must;
    last=1,now=2;
    for (int i=1;i<=t;++i)
    {
        if (k<=a[i-1]-1-b[i-1])
        {
            last+=k;
            while (last<=s[i-1]-b[i-1]&&now<=s[i])
            {
                f[now]=last;
                ++now,++last;
            }
            while (now<=s[i])
            {
                f[now]=last-1;
                ++now;
            }
            k=0;
        }
        else
        {
            last+=a[i-1]-1-b[i-1];
            while (last<=s[i-1]-b[i-1]&&now<=s[i])
            {
                f[now]=last;
                ++now,++last;
            }
            while (now<=s[i])
            {
                f[now]=last-1;
                ++now;
            }
            k-=a[i-1]-1-b[i-1];
        }
        last=s[i-1]+1;
        now=s[i]+1;
    }
    if (k)
    {
        puts("-1");
        return 0;
    }
    printf("%d\n",n);
    for (int i=2;i<=n;++i) printf("%d %d\n",f[i],i);
    return 0;
  }
Clove_unique
关注
专栏目录
Cf386B
weixin_30872789的博客
07-10 95
/* B - Fly, freebies, fly! Time Limit:1000MS Memory Limit:262144KB 64bit IO Format:%I64d & %I64u Submit Status Practice CodeForces 386B Description Everyone loves a freebi...
RMQ(ST表)的一些应用 CF475D&&CF386C
ACM, deep love
07-12 911
Range Minimum/Maximum Query是指处理多次查询一段区间内最大最小值的算法。ST表可以o(nlogn)预处理,o(1)查询。建表过程如下for(int j=1;j<=19;j++) { for(int i=0;i<n;i++) { if(i+(1<<j)-1<n)
CF#771 Div.2 A~C 题解
DM010maker的博客
02-20 429
CF #771 div.2 A. Reverse(思维) 题目大意 给定长度为n的序列 可以翻转任意一段 输出他的最小字典序排列 解题思路 因为要最小字典序 所以从n = 1开始向后枚举 如果说q[i] != i 那就说明把 i 换回这里字典序最小（贪心 很重要的一点是因为我的程序鲁棒性不够强 所以导致了数组越界 达到了负的下标 以后一定要注意在模拟reverse的时候不能越界 代码 int q[510], n; void solve() { cin >> n; for(int
CF#772 Div.2 A~C 题解
DM010maker的博客
02-23 201
A. Min Or Sum(位运算 + 构造) Description: ​ 对一个数组 任意选择ai aj 用 x y替换他们 不限次数 ​ 要求ai | aj == x | y ​ 问操作完毕后数组和的最小值 Method: ​ 将ai aj换到最小 指的是尽量让每个位数上只有一个1 ​ 5|6 – > min(0|7) ​ 所以使数列的全部数得到min 但是又要保证位上原有的1不发生改变 那么删去多出来的1即可 ​ 在代码上的体现就是|全部数 Code: void solve() { int
cf #681 Div. 2 A B C
m0_47328850的博客
11-03 176
A题 题目链接 题目大意 幼儿园有n个小朋友，4n个座位（从1号开始，4n号结束），我们需要帮助小朋友排座位，不符合要求的座位安排： 1.gcd(a,b)=1 （任意两个小朋友的座位号的最大公约数不能等于1） 2.a%b=0或b%a=0（任意两个小朋友的座位号不能被对方整除） 输入 第一行为正整数t(1≤t≤100)——测试用例数。 每个测试用例包含一行包含整数n(1≤n≤100)——孩子的数量。 输出 输出t行，它包含从1到4n的n个不同的整数——孩子们在相应的测试用例中应该占据的椅子的数量。如果有多
CodeForces CF #500 Div.2 (D,E已更新)
qq_42778110的博客
07-31 285
这次的题目真玄学啊。。。半个小时A掉了ABC题，然后就坐着喝了两个小时的茶 A. Piles With Stones 题意，给你n个数字，ai表示在i-th的位置上有ai块石头。已知现在有两种操作，分别是把某个石头移到另一个位置，或者拿走一块。 然后。。。再给你n个数字，问你是否在足量次操作后可以变成后面的状态。 我写代码的时间还没读题的时间长。。。。就是上面求和，下面求和，然后比大小。。...
CF #308 Div.2 C题 Vanya and Scales 解题报告
qq_23862985的博客
06-19 398
原题： Vanya has a scales for weighing loads and weights of masses w0, w1, w2, ..., w100 grams where w is some integer not less than 2 (exactly one weight of each nominal value). Vanya wonders
CF #762 Div.3(A ~ E)
DM010maker的博客
03-07 160
CF #762 Div.3 A Square String?(翻译) Description: ​ A string is called square if it is some string written twice in a row. ​ 如果一个字符串是某个连续写了两次的字符串，则称为square ​ 给定字符串 判断字符串是否是square Method: ​ 一开始没有读懂题目 也没有仔细看样例 所以草率地认为是含有奇数个字符时 NO ​ 其实就是扫一遍判断是否是由两个相同字符串构成 Code:
Codeforces Round #956 (Div. 2) and ByteRace 2024
最新发布
HKUST_ZJH的博客
07-15 1089
Codeforces Round #956 (Div. 2) and ByteRace 2024
Codeforces Round #672 (Div.2) 解题报告
一个蒟蒻的博客
09-25 444
Codeforces Round #672 (Div.2) A. 冒泡排序最差情况是逆序，交换操作为n(n−1)/2n(n-1)/2n(n−1)/2 次，因此该题判断一下是否完全逆序即可。 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int maxn = 1e5+5; int arr[maxn]; int main() { ios::sync_with_stdio(false);
【Codeforces Round #569 (Div. 2) A - E】解题报告
我是谁 --- 卡比兽
07-14 125
CF569A 题意 定义第一阶菱形是一个正方形 n阶就是n-1阶菱形表面有多少个边加多少个 一开始没看懂题 以为中间是正方形 盲猜了一发 n==1?1:(2n-2)(2*n-2)+4; 后来发现其实规律是 ans[i] = ans[i-1]+(i-1)*4 因为每次多贡献四个边 /* if you can't see the repay Why not just work step...
Codeforces Round #343 (Div. 2) 解题报告
Linoy
02-25 1054
Codeforces Round #343 (Div. 2)
codeforces round #760 (div. 3)
03-16
Codeforces Round #760 (Div. 3) 是 Codeforces 在2022年1月29日举办的一个比赛。这是一个针对参赛者等级较低的比赛，难度为Div. 3，即Cf划分为三个等级之一的最低...比赛结果和解题报告可以在 Codeforces 网站上查看。
Educational Codeforces Round 112 (Rated for Div. 2) ABCDE 解题思路
StelaYuri's Blog
07-31 548
Educational Codeforces Round 112 (Rated for Div. 2) 只做了ABCDE，但被AE卡了我是没想到的，CE分别一发RE也傻了 A - PizzaForces 题意 做小尺寸的pizza可以切成666片，要花151515​分钟 做中尺寸的pizza可以切成888​片，要花202020​分钟 做大尺寸的pizza可以切成101010​​片，要花252525​​分钟 现在Petya家来了nnn位客人，他想让每个客人都至少能吃到一块pizza 问做出符合需求数量的p
[BZOJ3196]二逼平衡树（线段树套splay）
zyf2000
04-29 2847
花费了不知多少页来描述我们的心情 却不知为何填不满一行的空白
【codevs1279】Guard 的无聊
zyf2000
01-13 1894
茕茕白兔，东奔西顾。衣不如新，人不如故。
[BZOJ2161]布娃娃（扫描线+线段树）
zyf2000
04-19 1860
题目描述传送门题目大意：第i个布娃娃有一个耐心值P[i]以及一个魅力值C[i]，并且还有能够忍受的耐心值的上限R[i]以及下限L[i]。当一个布娃娃j满足L[j] ≤ P[i]并且P[i] ≤ R[j]，那么布娃娃j喜欢布娃娃i。求第i个布娃娃想知道喜欢它的布娃娃中，魅力值第i大的布娃娃的魅力值是多少。题解将C离散，然后PLR实际上是一个东西可以看作一维 将区间拆成左端点和右端点，将所有的点排序，
[BZOJ4408][Fjoi 2016]神秘数（可持久化线段树）
zyf2000
03-04 1408
题目描述传送门题解首先考虑O(mnlogn)O(mnlogn)的做法 将询问的一段区间由小到大排序，假设现在已经用前k个数组合出了[1..x]中的所有整数，那么现在考虑加入第k+1个数 若k<=x+1，那么我们一定可以组合出[1..x+k]的所有整数，不会出现断层 若k>x+1，那么x+1这个整数是无论如何都无法组合的，就可以确定答案了那么如果不排序有没有办法做呢？ 同样假设当前已经组合好了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值