纪中OJ 2019.01.25【NOIP提高组】模拟 B 组 T2 数字对

声明

数字对

Time Limits: 2000 ms Memory Limits: 262144 KB

Description

　　　　小 H 是个善于思考的学生，现在她又在思考一个有关序列的问题。
　　　　她的面前浮现出一个长度为 n 的序列 {ai}，她想找出一段区间 [L, R] (1 <= L <= R <= n)。
　　　　这个特殊区间满足，存在一个 k (L <= k <= R)，并且对于任意的 i (L <= i <= R)，ai 都能被 ak 整除。这样的一个特殊区间 [L, R] 价值为 R - L。
　　　　小H想知道序列中所有特殊区间的 最大价值 是多少，而有多少个这样的区间呢？这些区间又分别是哪些呢？你能帮助她吧。

Input

　　　　第一行，一个整数 n.
　　　　第二行，n 个整数，代表 ai.

Output

　　　　第一行两个整数，num 和 val,表示价值最大的特殊区间的个数以及最大价值。
　　　　第二行 num 个整数，按升序输出每个价值最大的特殊区间的 L.

Sample Input

　　　　输入1：

　　　　 4 6 9 3 6

　　　　输入2：

　　　　 2 3 5 7 11

Sample Output

　　　　输出1：

　　　　 1 3

　　　　输出2：

　　　　 5 0

　　　　 1 2 3 4 5

Data Constraint

　　　　30%: 1 <= n <= 30 , 1 <= ai <= 32.
　　　　60%: 1 <= n <= 3000 , 1 <= ai <= 1024.
　　　　80%: 1 <= n <= 300000 , 1 <= ai <= 1048576.
　　　　100%: 1 <= n <= 500000 , 1 <= ai < 2 ^ 31.

　　最近发现有用暴力等水法A掉这题的，如从头到尾枚举 ak ，然后再向两边搜索的水法。

　　然而如果所有的 ai 都相同的话，时间复杂度就为O（n²），完全过不了。

　　如：

　　500000

　　后面 500000 个 1

　　此时时间复杂度为O（500000²），不知道运行到猴年马月，直接卡掉水法。

　　接下来看正解（可能有其他更简单的方法，但这种方法绝对不会被卡掉！）：二分+rmq+hash

分析：

　　　　看到了最大价值，即求最优解，脑海中立马想到了：贪心、dp、优化的搜索（或暴力）和 二分答案。显然，此题是在序列中操作，数据范围大，贪心条件不满足，明显的二分答案！！！

　　　　于是用二分答案求出序列的最大长度，但如何判断答案 mid 的可行性和计算序列个数与开头位置呢？

　　　　这样，问题就转化成如何判断某个区间是否存在：对于任意的 i (L <= i <= R)，ai 都能被 ak 整除了。

　　　　显然，搜索是最普遍的选择，那这里我就讲讲搜索的优化方案：

　　　　或许你们会问：不仅要询问每个区间（O（n）)，又要找出其中有没有 ak 存在（O（ n²）），时间复杂度不是 n³吗，怎么过？？？

优化方案：

　　　　优化一：

　　　　　　对于任意的 i (L <= i <= R)，ai 都能被 ak 整除中的 ak，是很好求出来的，就是区间几个数的最大公约数（gcd），在询问前预处理一下，线上调用即可。

　　　　　　但是，对于一般的预处理（除前缀和和其他玄学预处理外），复杂度都是O（n²）的，一样过不了（哭笑不得~）。。。

　　　　　　但是，在序列的维护中，自然想到线段树、树状数组、rmq 啦~（对于前两项此题应该也能维护 gcd 吧？！~）

　　　　　　我们了解过的 rmq 都是维护最大最小值的，以其速度快，范围广而出名。此题，一样可以维护区间的 gcd 。

　　　　　　举个栗子： 4 6 9

　　　　　　若已求出前两个数的 gcd 为2（rmq[1,1]=2），后一个数的 gcd 为 9（rmq[3,0]=a[3]=9），那区间的 gcd 就是 gcd（2,9）=1 啦~

　　　　　　预处理时间复杂度降到 O（n log₂ n）啦，在搜索时直接 O（1）的复杂度就能算出区间最小公约数（和 rmq 求最大最小值一样的，换成 gcd 了而已）。

　　　　优化二：

　　　　　　通过优化一算出区间的 ak 后，我们就要开始找区间内有没有这个 ak 了~

　　　　　　然而我们发现，每个区间的搜索 O（n）不可省，而找 ak 又要 O（n），那岂不是 O（n²）吗（虽然达不到，但也接近了，加上预处理和二分答案等，绝对过不了）

　　　　　　于是进一步优化：

　　　　　　毕竟我们只找一个数 ak，很容易想到出现一个数就在 flag 数组打个标记，找有没有 ak 时直接判断 flag[ak] 是否打过标记就行了。

　　　　　　而区间的移动一次的话，就 O（1）把新的那个数打一个标记，把出区间的那个删掉标记即可~

　　　　　　此过程时间复杂度将至 O（1），效率极高，是在某个区间搜某些数时的常用方法，可以经常拿来用。

　　　　优化三：

　　　　　　光有优化二是不行的，因为它用空间换时间，会 MLE 的。（毕竟 ak 可达 20 多亿，数组开得了那么多吗？？？）

　　　　　　所以，在用了优化二后，常常用这种方法解决空间问题：哈希表~（它俩基本绑定了，哈希是利用无用的空间存有用的数。不会的自己学，不必多说）

　　　　　　但是，这里的哈希有三种模式： 1. 查询某数在哈希表中的位置（用于删标记）； 2. 把某数存进哈希表（用于打标记）； 3. 查询某数是否存在（用于查询区间内是否有 ak）。

　　　　　　于是，我们用哈希表的稀少时间换了大量的空间~~~

　　所以总体说，预处理 O（n log₂ n），二分 O（log₂ n*check），在 check 中，区间询问 O（n），找 ak O（hash）（hash 是哈希的时间复杂度，常数级别）

　　这样，我们就把 O（n³）的时间复杂度将至 O（n log₂ n+n log₂ n*hash），粗略说就是 O（n log₂ n），只是有点常数而已，不用卡常都能过（毕竟 2 秒时限）~~~

　　下附标程，我就不写注释了~

 uses math;

 const

         mo=;

 var

         l,r,mid,i,n,j,t,cnt:longint;

         a,b,h,ans:array[..] of longint;

         rmq:array[..,..] of longint;

 function gcd(x,y:longint):longint;

 begin

         if y= then exit(x) else exit(gcd(y,x mod y));

 end;

 function hash(x,mode:longint):boolean;

 var

         k:longint;

 begin

         k:=x mod mo;

         while (h[k]<>) and (h[k]<>x) do

         begin

                 inc(k);

                 if k>mo then k:=;

         end;

         if mode= then cnt:=k else

                 if mode= then h[k]:=x else

                         if h[k]=x then exit(true) else exit(false);

 end;

 function check(x:longint):boolean;

 var

         l,t,j,flag,r:longint;

 begin

         fillchar(h,sizeof(h),);

         for i:= to x do

                 hash(a[i],);

         flag:=;

         for l:= to n-x+ do

         begin

                 hash(a[l-],);

                 h[cnt]:=;

                 r:=l+x-;

                 hash(a[r],);

                 t:=trunc(ln(r-l+)/ln());

                 j:=gcd(rmq[l,t],rmq[r-(<<t)+,t]);

                 if hash(j,) then

                 begin

                         flag:=;

                         inc(ans[x]);

                         b[ans[x]]:=l;

                 end;

         end;

         if flag= then exit(false) else exit(true);

 end;

 begin

         readln(n);

         for i:= to n do

         begin

                 read(a[i]);

                 rmq[i,]:=a[i];

         end;

         readln;

         t:=trunc(ln(n)/ln())+;

         for j:= to t do

                 for i:= to n do

                         if i+(<<j)-<=n then

                                 rmq[i,j]:=gcd(rmq[i,j-],rmq[i+(<<(j-)),j-]);

         l:=;                               // l，r，mid 存的是区间长度

         r:=n;

         while l<r do

         begin

                 mid:=(l+r) div +;

                 if check(mid) then l:=mid else r:=mid-;

         end;

         if ans[l]= then

         begin

                 writeln(n,'');

                 for i:= to n- do

                         write(i,' ');

                 writeln(n);

                 halt;

         end;

         writeln(ans[l],' ',l-);            //要输出价值，就是长度-

         for i:= to ans[l]- do

                 write(b[i],' ');

         writeln(b[ans[l]]);

 end.

标程