jzoj 模拟赛总结（2017.07.13）

T1.
马农：
题目大意：
来自大草原的两兄弟决心成为超级“马农”，专门饲养战马。他们将可以养马的区域，分为 N*N 的单位面积的正方形，每块单位面积的收益为a[i,j]，收益a[i,j]可能是负数，养马也不是包赚的，马匹也可能出现生病死亡等意外。然后两人的马场都必须是矩形区域。同时，规定两个马场的矩形区域相邻，且只有一个交点。且两人希望两个马场的收益相当，希望你给他们设计马场，求共有多少种设计方案。

40%的数据， N<=10。
100%的数据， N<=50, -1000 < A(i,j)<1000

题解：
枚举每一个点为交点的情况，然后分成四部分：
左上部分，右上部分，左下部分，右下部分
然后枚举左上部分的全部可能出现的数塞进hash表中，并记录出现次数，
然后枚举其对应的右下部分出现的全部可能，然后在hash表中找。
右上，左下部分同理
不过要注意hash表的清空，每次找到一个数，要把这个数的hash表位置记录，然后清零的时候就不用清全部hash表，只需要清空使用过的位置，就可以达到优化，避免潮湿。
当然，这题数据小，开个大数组做桶去记录也可以水掉。

const    modn=300007;var    hash:array [0..modn,1..2] of longint;    p:array [0..modn] of longint;    sum:array [0..51,0..51] of longint;    n,i,j,k,l,m,cd,ans:longint;function insert(d:longint):longint;var    i:longint;begin    i:=abs(d) mod modn;    while (hash[i,1]<>0) and (hash[i,1]<>d) do    begin         inc(i);         if i>modn then i:=0;    end;    exit(i);end;begin    assign(input,'farmer.in'); reset(input);    assign(output,'farmer.out'); rewrite(output);    readln(n);    for i:=1 to n do    begin         for j:=1 to n do         begin              read(sum[i,j]);              sum[i,j]:=sum[i,j-1]+sum[i,j];         end;         readln;    end;    for i:=1 to n do      for j:=1 to n do      begin           p[0]:=0;           for k:=0 to j-1 do           begin                 l:=0;                 for m:=i downto 1 do                 begin                       l:=l+(sum[m,j]-sum[m,k]);                       inc(p[0]);                       p[p[0]]:=insert(l);                       hash[p[p[0]],1]:=l;                       inc(hash[p[p[0]],2]);                 end;           end;           for k:=j+1 to n do           begin                 l:=0;                 for m:=i+1 to n do                 begin                      l:=l+(sum[m,k]-sum[m,j]);                      cd:=insert(l);                      if hash[cd,1]=l then inc(ans,hash[cd,2]);                 end;           end;           for k:=1 to p[0] do           begin                hash[p[k],1]:=0;                hash[p[k],2]:=0;           end;           p[0]:=0;           for k:=j to n do           begin                 l:=0;                 for m:=i downto 1 do                 begin                       l:=l+(sum[m,k]-sum[m,j-1]);                       inc(p[0]);                       p[p[0]]:=insert(l);                       hash[p[p[0]],1]:=l;                       inc(hash[p[p[0]],2]);                 end;           end;           for k:=0 to j-2 do           begin                 l:=0;                 for m:=i+1 to n do                 begin                       l:=l+(sum[m,j-1]-sum[m,k]);                       cd:=insert(l);                       if hash[cd,1]=l then inc(ans,hash[cd,2]);                 end;           end;           for k:=1 to p[0] do           begin                 hash[p[k],1]:=0;                 hash[p[k],2]:=0;           end;      end;    writeln(ans);    close(input); close(output);end.

T2.
马语翻译：
有N个马种，机器人有 M 种，每种机器人能完成 K 个马种之间的语言翻译。问，利用这些机器人，能否实现 1 种群和 N 种群的马语翻译。 若可以，找到翻译过程至少需要用到多少种语言，求最少转换语言的次数。如果无法完成翻译，输出-1。

40%的数据 N<=100， 1<=K<=20， M<=40。
100%的数据 1<=N<=100000， 1<=K<=1000， 1<=M<=1000

题解：
有待完成。。。

T3.
马球比赛：
N个乡镇之间要进行马球联赛。每个乡镇有a[i]匹马，首先，所有乡镇都要求，本乡镇所有的马匹都必须参赛，或者都不参赛（若组队的马匹数量不是该镇马匹数量的约数，将无法参赛）。其次，在本乡镇，选出最佳球队，参加乡镇间联赛。比赛组织方希望满足所有参赛乡镇的要求，并且使得决赛的马匹尽可能多，请你设计每个球队马匹的数量，使得决赛马匹数最大。
注意，决赛至少有 2 个队伍晋级。

20%的数据 2<=N<=100， 1<=a(i)<=10000。
50%的数据 2<=N<=20000。
100%的数据 2<=N<=200000， 1<=a(i)<= 2000000

题解：
这题呢，其实可以递推

首先设f[i]表示以i为参赛标准时，有多少只队伍能参赛。
可以推出：
f[j]=f[j]+f[i] j为i的约数
同理，f[i div j]=f[i div j]+f[i]
然后容易被卡常，就自行脑补

时间复杂度：O（max（a[i]）*Σtrunc（sqrt（i）））
//i为1~max(a[i])

var    sum:array [0..2000001] of int64;    a:array [0..200001] of longint;    cmax,p,q,n,i,j:longint;    mmax:int64;function max(aa,bb:int64):int64;begin    if aa>bb then exit(aa);    exit(bb);end;begin    assign(input,'polo.in'); reset(input);    assign(output,'polo.out');rewrite(output);    read(n);    cmax:=0;    for i:=1 to n do    begin         read(a[i]);         inc(sum[a[i]]);         cmax:=max(cmax,a[i]);    end;    mmax:=n;    if cmax=2000000 then cmax:=cmax div 20;    for i:=2 to cmax do    if sum[i]<>0 then    begin       for j:=2 to trunc(sqrt(i)) do         if (i mod j=0)  then         begin              sum[j]:=sum[j]+sum[i];              if j*j<>i then                 sum[i div j]:=sum[i div j]+sum[i];         end;    end;    if cmax=100000 then cmax:=cmax*20;    for i:=2 to cmax do      if sum[i]>1 then mmax:=max(mmax,sum[i]*i);    writeln(mmax);    close(input); close(output);end.

T4.
数列：
题目大意：
给定一个长度为N的数列，求一段连续的子数列满足该子数列中的各元素的平均数大于A，输出可行方案的总数。

对于60%的数据 N <= 1000
对于100%的数据 N <= 100000
所有数据包括都在longint范围内。

题解：
其实对于每一次的输入的数a[i]，我们都将它减去平均数A，然后全部做一遍前缀和。
首先我们知道对于某个前缀和sum[i]，如果它>0就先给答案+1
然后如果sum[i] < sum[j]，i < j就代表在区间[l,r]内的总和是绝对比A大的，就累加1
然后我们怎么去处理sum[j]>sum[i]的情况呢，我们发现如果强行去枚举
时间复杂度就是O（Σ N），很明显会炸时间
然后我们可以想到树状数组，
先将处理出来的sum全部离散，因为离散后其的大小关系如sum[i] < sum[j]是不变的，然后离散后其的最坏情况最大值就是N，即100000，树状数组就只需要开到100000了，
然后枚举sum，
每次对于一个sum[i]
ans累加其树状数组中1~i-1的值，用x-x and (-x)去递减
然后将这个数丢进树状内
用x+x and (-x）去 递进，tree[x]=tree[x]+1

然后这样的时间复杂度就做到了O（N log N）

var   d,rp,sum:array [0..100001] of longint;   x,i,j,n,m,pd:longint;   ans:int64;procedure qsort(l,r:longint);var   mid,i,j:longint;begin   if l>=r then exit;   i:=l; j:=r;   mid:=sum[(l+r) div 2];   repeat        while sum[i]<mid do inc(i);        while sum[j]>mid do dec(j);        if i<=j then        begin              sum[0]:=sum[i]; d[0]:=d[i];              sum[i]:=sum[j]; d[i]:=d[j];              sum[j]:=sum[0]; d[j]:=d[0];              inc(i); dec(j);        end;   until i>j;   qsort(i,r);   qsort(l,j);end;begin    assign(input,'sequence.in'); reset(input);    assign(output,'sequence.out'); rewrite(output);    readln(n,m);    ans:=0;    for i:=1 to n do    begin        read(x);        sum[i]:=sum[i-1]+(x-m);        if sum[i]>0 then inc(ans);        d[i]:=i;    end;    qsort(1,n);    i:=1; j:=1;    while i<=n do    begin         rp[d[i]]:=j;         while sum[i]=sum[i+1] do         begin              inc(i);              rp[d[i]]:=j;         end;         inc(i); inc(j);    end;    dec(j);    for i:=0 to j do sum[i]:=0;    for i:=1 to n do    begin          pd:=rp[i]-1;          while pd>0 do          begin               ans:=ans+sum[pd];               pd:=pd-pd and (-pd);          end;          pd:=rp[i];          while pd<=j do          begin               sum[pd]:=sum[pd]+1;               pd:=pd+pd and (-pd);          end;    end;    writeln(ans);    close(input); close(output);end.