code M资格赛补题

A：

音乐研究

时间限制：1秒

空间限制：32768K

美团外卖的品牌代言人袋鼠先生最近正在进行音乐研究。他有两段音频，每段音频是一个表示音高的序列。现在袋鼠先生想要在第二段音频中找出与第一段音频最相近的部分。

具体地说，就是在第二段音频中找到一个长度和第一段音频相等且是连续的子序列，使得它们的 difference 最小。两段等长音频的 difference 定义为：
difference = SUM(a[i] - b[i])2 (1 ≤ i ≤ n),其中SUM()表示求和
其中 n 表示序列长度，a[i], b[i]分别表示两段音频的音高。现在袋鼠先生想要知道，difference的最小值是多少？数据保证第一段音频的长度小于等于第二段音频的长度。

输入描述:

第一行一个整数n(1 ≤ n ≤ 1000)，表示第一段音频的长度。

第二行n个整数表示第一段音频的音高（0 ≤ 音高 ≤ 1000）。

第三行一个整数m(1 ≤ n ≤ m ≤ 1000)，表示第二段音频的长度。

第四行m个整数表示第二段音频的音高（0 ≤ 音高 ≤ 1000）。

输出描述:

输出difference的最小值

输入例子:

输出例子:

暴力跑就行，刚开始没看清题目写了非连续的浪费了好多时间：
红q添加了10w的数据量的解法，就是开方以后处理，并且加上FFT乘法把 $ \sum_{j=1}^{j<=n} a_i b_{i+j} $ 快速处理出来。
暴力版：

 #include<cstdio>

 #include<iostream>

 #include<cstring>

 #include<algorithm>

 #define clr(x) memset(x,0,sizeof(x))

 #define clrmax(x) memset(x,0x3f,sizeof(x))

 #define  LL long long

 using namespace std;

 LL dp[][];

 LL mindp[];

 int high1[],high2[];

 int main()

 {

     int n,m;

     clrmax(mindp);

     mindp[]=;

     clr(dp);

     scanf("%d",&n);

     for(int i=;i<=n;i++)

         scanf("%d",&high1[i]);

     scanf("%d",&m);

     for(int i=;i<=m;i++)

         scanf("%d",&high2[i]);

     LL sum;

     LL ans=1e18;

     for(int j=;j<=m-n+;j++)

     {

         sum=;

         for(int i=j;i<j+n;i++)

         {

             sum+=1LL*(high1[i-j+]-high2[i])*(high1[i-j+]-high2[i]);

         }

         if(sum<ans)

             ans=sum;

     }

     printf("%lld\n",ans);

     return ;

 }

B：

锦标赛

时间限制：1秒

空间限制：32768K

组委会正在为美团点评CodeM大赛的决赛设计新赛制。

比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为 m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生获胜者。获胜者获得参加下一轮的资格，输的人被淘汰。重复这个过程，直至决出冠军。

现在请问，参赛者小美最多可以活到第几轮（初始为第0轮）？

输入描述:

第一行一个整数 n (1≤n≤ 2^20)，表示参加比赛的总人数。

接下来 n 个数字（数字范围：-1000000…1000000），表示每个参赛者的积分。

小美是第一个参赛者。

输出描述:

小美最多参赛的轮次。

输入例子:

4

4 1 2 3

输出例子:

很明显算个 $ log_2 m $是多少，其中m是分数小于等于他的选手个数（包括她自己），就是答案。

 #include<cstdio>

 #include<iostream>

 #include<cstring>

 #include<algorithm>

 #define clr(x) memset(x,0,sizeof(x))

 using namespace std;

 int main()

 {

     int n,lower=,mei,p;

     scanf("%d",&n);

     scanf("%d",&p);

     mei=p;

     for(int i=;i<=n;i++)

     {

         scanf("%d",&p);

         if(p<=mei)

             lower++;

     }

     p=;

     while(lower)

     {

         lower/=;

         p++;

     }

     p--;

     printf("%d\n",p);

     return ;

 }

优惠券

时间限制：1秒

空间限制：32768K

美团点评上有很多餐馆优惠券，用户可以在美团点评App上购买。每张优惠券有一个唯一的正整数编号。当用户在相应餐馆就餐时，可以在餐馆使用优惠券进行消费。优惠券的购买和使用按照时间顺序逐行记录在日志文件中，运营人员会定期抽查日志文件看业务是否正确。业务正确的定义为：一个优惠券必须先被购买，然后才能被使用。

某次抽查时，发现有硬盘故障，历史日志中有部分行损坏，这些行的存在是已知的，但是行的内容读不出来。假设损坏的行可以是任意的优惠券的购买或者使用。

现在问这次抽查中业务是否正确。若有错，输出最早出现错误的那一行，即求出最大s，使得记录1到s-1满足要求；若没有错误，输出-1。

输入描述:

m 分别表示 m (1 ≤ m ≤ 5 * 10^5) 条记录。

下面有m行，格式为：

I x （I为Input的缩写，表示购买优惠券x）；

O x（O为Output的缩写，表示使用优惠券x）；

? （表示这条记录不知道）。

这里x为正整数，且x ≤ 10^5 。

输出描述:

-1 或 x(1 ≤ x ≤ m) 其中x为使得1到x-1这些记录合法的最大行号。

输入例子:

输出例子:

做的时候石乐志哦，没有想用set，然后手打平衡树失败。赛后补了set版。

对于未知记录，我们把它的位置插入set中，以便之后查找删除。

对于每条有效记录，使用或者获得了券x，我们先查询券X的上条记录状态，如果是与之相反的状态就变为当前状态，反之从上条记录的位置往后查询，找到第一个未知记录变为X的与现在状态相符的状态，并把这条状态的位置从set里删除。若没有找到未知状态，那么这条记录就是错误记录，这里就是最早出现错误的地方。

 #include<cstdio>

 #include<iostream>

 #include<cstring>

 #include<algorithm>

 #include<set>

 #define clr(x) memset(x,0,sizeof(x))

 using namespace std;

 int inf[],last[];

 set<int> tree;

 set<int>::iterator it;

 int main()

 {

     char c;

     int m,p,k;

     int mininf,flag;

     while(scanf("%d",&m)!=EOF)

     {

         clr(inf);

         clr(last);

         tree.clear();

         flag=;

         mininf=-;

         for(int i=;i<=m;i++)

         {

             scanf(" %c",&c);

             if(c=='?')

             {

                 if(flag) continue;

                 tree.insert(i);

                 continue;

             }

             scanf("%d",&p);

             if(flag) continue;

             if(c=='I')

             {

                 if(inf[p]==)

                 {

                     inf[p]=;

                 }

                 else if((it=tree.lower_bound(last[p]))!=tree.end())

                 {

                     tree.erase(it);

                 }

                 else

                 {

                     flag=;

                     mininf=i;

                 }

             }

             if(c=='O')

             {

                 if(inf[p]==)

                 {

                     inf[p]=;

                 }

                 else if((it=tree.lower_bound(last[p]))!=tree.end())

                 {

                     tree.erase(it);

                 }

                 else

                 {

                     flag=;

                     mininf=i;

                 }

             }

             last[p]=i;

         }

         printf("%d\n",mininf);

     }

     return ;

 }

送外卖

时间限制：1秒

空间限制：32768K

n 个小区排成一列，编号为从 0 到 n-1 。一开始，美团外卖员在第0号小区，目标为位于第 n-1 个小区的配送站。
给定两个整数数列 a[0]~a[n-1] 和 b[0]~b[n-1] ，在每个小区 i 里你有两种选择：
1) 选择a：向前 a[i] 个小区。
2) 选择b：向前 b[i] 个小区。

把每步的选择写成一个关于字符 ‘a’ 和 ‘b’ 的字符串。求到达小区n-1的方案中，字典序最小的字符串。如果做出某个选择时，你跳出了这n个小区的范围，则这个选择不合法。
• 当没有合法的选择序列时，输出 “No solution!”。
• 当字典序最小的字符串无限长时，输出 “Infinity!”。
• 否则，输出这个选择字符串。

字典序定义如下：串s和串t，如果串 s 字典序比串 t 小，则
• 存在整数 i ≥ -1，使得∀j，0 ≤ j ≤ i，满足s[j] = t[j] 且 s[i+1] < t[i+1]。
• 其中，空字符 < ‘a’ < ‘b’。

输入描述:

输入有 3 行。

第一行输入一个整数 n (1 ≤ n ≤ 10^5)。

第二行输入 n 个整数，分别表示 a[i] 。

第三行输入 n 个整数，分别表示 b[i] 。

−n ≤ a[i], b[i] ≤ n

输出描述:

输出一行字符串表示答案。

输入例子:

7

5 -3 6 5 -5 -1 6

-6 1 4 -2 0 -2 0

输出例子:

abbbb

为什么会无限长呢？最朴素的例子：从1号点选择a方案可到3号点，3号点选择a方案可到2号点，b方案可到n-1号点，那你肯定选择aaaaaaa……（无穷）b这样字典序最小，而不是ab或者aaab等等这样的方案，因为这样的方案字典序不是最小的。

那么解法显而易见：

这道题从n-1号点反向dfs下，找出所有能到达n-1的点，标记下。然后看看0号点能到达n-1号点吗，不能就 no solution。

然后从0号点出发也做一遍dfs，这个dfs是先选a方案在选b方案的，并且标记经过的点。若在dfs中遇到标记点，并且该标记点可达n-1号点（前面的dfs已经找出这些点了），那么中便是无限长的方案。否则就退出继续dfs直到找到一个可到达n-1号点的方案。该方案就是有限长最终方案。

 #include<cstdio>

 #include<iostream>

 #include<cstring>

 #define clr(x) memset(x,0,sizeof(x))

 #define clr_1(x) memset(x,-1,sizeof(x))

 using namespace std;

 int a[],b[];

 char s[];

 int head[],size,inf[],inf2[],n;

 struct edg

 {

     int next,to;

 }edge[];

 void addedge(int u,int v)

 {

     edge[++size].to=v;

     edge[size].next=head[u];

     head[u]=size;

     return ;

 }

 void dfs1(int u)

 {

     inf[u]=;

     int p;

     for(int i=head[u];i!=-;i=edge[i].next)

     {

         p=edge[i].to;

         if(inf[p]==)

             dfs1(p);

     }

     return ;

 }

 int dfs2(int u,int dep)

 {

     if(u==n-)

     {

         s[dep]='\0';

         printf("%s\n",s);

         return ;

     }

     if(inf2[u]==)

     {

         if(inf[u]==)

         {

             printf("Infinity!\n");

             return -;

         }

         else

             return ;

     }

     inf2[u]=;

     int k=;

     if(u+a[u]<=n- && u+a[u]>=)

     {

         s[dep]='a';

         k=dfs2(u+a[u],dep+);

     }

     if(k> && u+b[u]<=n- && u+b[u]>=)

     {

         s[dep]='b';

         k=dfs2(u+b[u],dep+);

     }

     return k;

 }

 int main()

 {

     size=;

     scanf("%d",&n);

     clr_1(head);

     clr(inf);

     for(int i=;i<n;i++)

     {

         scanf("%d",&a[i]);

         if(i+a[i]<=n-)

             addedge(i+a[i],i);

     }

     for(int i=;i<n;i++)

     {

         scanf("%d",&b[i]);

         if(i+b[i]<=n-)

             addedge(i+b[i],i);

     }

     dfs1(n-);

     if(inf[]==)

         printf("No solution!\n");

     else

     {

         clr(inf2);

         clr(s);

         dfs2(,);

     }

     return ;

 }

E：

数码

时间限制：1秒

空间限制：32768K

给定两个整数 l 和 r ，对于所有满足1 ≤ l ≤ x ≤ r ≤ 10^9 的 x ，把 x 的所有约数全部写下来。对于每个写下来的数，只保留最高位的那个数码。求1～9每个数码出现的次数。

输入描述:

一行，两个整数 l 和 r (1 ≤ l ≤ r ≤ 10^9)。

输出描述:

输出9行。

第 i 行，输出数码 i 出现的次数。

输入例子:

1 4

输出例子:

 #include<cstdio>

 #include<iostream>

 #include<cstring>

 #include<cmath>

 #define clr(x) memset(x,0,sizeof(x))

 #define LL long long

 using namespace std;

 LL n,m,l,r;

 LL min(LL a,LL b)

 {

     return a<b?a:b;

 }

 LL max(LL a,LL b)

 {

     return a>b?a:b;

 }

 LL sum(LL n,LL m)

 {

     LL sqrtn=(LL)sqrtl(n);

     LL ans=;

     LL k=n/(sqrtn+),beg=n/(k+);

     for(LL i=;i<=min(beg,m);i++)

         ans+=n/i;

     if(beg>=m)

     {

 //        printf("%d %d %d\n",n,m,ans);

         return ans;

     }

     for(LL i=k;i>=n/m;i--)

     {

         ans+=i*(min(m,n/i)-n/(i+));

     }

     return ans;

 }

 LL deal(int p,LL n)

 {

     LL q;

     LL ans=,ten=;

     for(int i=;i<=;i++)

     if((LL)p*ten-<n)

     {

         ans+=sum(n,min((LL)(p+)*ten-,n))-sum(n,(LL)p*ten-);

         ten*=;

     }

     return ans;

 }

 int main()

 {

     scanf("%lld%lld",&l,&r);

     for(int i=;i<=;i++)

     {

         LL ans=deal(i,r)-deal(i,l-);

         printf("%lld\n",ans);

     }

     return ;

 }