jzoj 模拟赛总结（2017.07.08）

T1：
题目大意：
定义 GPT = GPA ×已修学分数。给出系里面每位同学的 GPT（只有一位小数），以及他们的已修学分。求排名 第 K 位的同学的 GPA 。

对于 100% 的数据：
1 ≤ K ≤ N ≤ 100000，GPT 小数点后至多 1 位，GPA 至多 4.0。
所有同学的学分都在 [1, 250] 的范围

题解：
因为知道 GPT = GPA ×已修学分数，所以我们可以发现GPA=GPT/已修学分，然后求出以后快排，注意从大到小，最后输出第K大。

时间复杂度：O(n)

var    a:Array [0..100001] of real;    n,k,i,j:longint;    x,y:real;procedure qsort(l,r:longint);var    i,j:longint;    mid:real;begin    if l>=r then exit;    i:=l; j:=r;    mid:=a[(l+r) div 2];    repeat         while a[i]>mid do inc(i);         while a[j]<mid do dec(j);         if i<=j then         begin              a[0]:=a[i];a[i]:=a[j];a[j]:=a[0];              inc(i); dec(j);         end;    until i>j;    qsort(i,r);    qsort(l,j);end;begin   assign(input,'sort.in'); reset(input);   assign(output,'sort.out'); rewrite(output);    readln(n,k);    for i:=1 to n do    begin         readln(x,y);         a[i]:=x/y;    end;    qsort(1,n);    writeln(a[k]:0:2);    close(input);close(output);end.

T2：
题目大意：
给出N个数a[i]，以及M个区间查询[l,r]即求出a[l]~a[r]的总和Σ。

对于 50% 的数据：1 ≤ N， M ≤ 100。
对于 100% 的数据：1 ≤ N，M ≤ 100000，0 ≤ Ai ≤ 10000，1 ≤ Li ≤ Ri ≤ N。

题解：
不难发现用前缀和O(N)随便搞搞，然后O(1)求解。
时间复杂度：O(N*M)

var   sum:array [0..1000001] of longint;   l,r,i,n,m:longint;begin   assign(input,'sum.in'); reset(input);   assign(output,'sum.out'); rewrite(output);   readln(n,m);   for i:=1 to n do   begin      read(sum[i]);      sum[i]:=sum[i]+sum[i-1];   end;   readln;     for i:=1 to m do     begin         readln(l,r);         writeln(sum[r]-sum[l-1]);     end;   close(input); close(output);end.

T3：
递推：
求从（1,1）走到（N,M)积分为P的方案，每次只能向下或者向右走，每个点的积分为1~10的整数a[i,j]，起点跟终点的积分也算。

递推式为f[i,j,k]=f[i,j,k]+f[i-1,j,k-a[i,j]]+f[i,j-1,k-a[i,j]]
初值：
f[i,1,Σa[i,1]]=1
f[1,i,Σa[1,i]]=1

相信大家会有一种错误的感觉，P最大是N*m*10即100*100*10，然后就P=100000，数组开到100*100*10000，费内存，浪费时间。
实则我们自己推理可以发现，到每个点(i,j)，只需要走(i-1)+(j-1)步，则(N,M)最大为（100,100）时，P最大为10*((100-1)+(100-1))，而远远没有100*100*10，这时我们就可以将数组的P开成2000。
当然大家如果觉得不够优美可以将N滚动滚动。
时间复杂度：O(NMP)

var    f:Array [0..101,0..101,0..2001] of longint;    a:array [0..101,0..101] of longint;    k,i,j,n,m,p:longint;begin    assign(input,'count.in'); reset(input);    assign(output,'count.out');rewrite(output);    readln(n,m,p);    for i:=1 to n do    begin        for j:=1 to m do read(a[i,j]);        readln;    end;    j:=0;    for i:=1 to m do    begin         j:=j+a[1,i];         f[1,i,j]:=1;    end;    j:=0;    for i:=1 to n do    begin         j:=j+a[i,1];         f[i,1,j]:=1;    end;    for i:=2 to n do      for j:=2 to m do        for k:=0 to p-a[i,j] do        f[i,j,k+a[i,j]]:=(f[i-1,j,k]+f[i,j-1,k]) mod 1000000007;    writeln(f[n,m,p]);    close(input);close(output);end.

T4：
题目大意：
小x有n个小姊妹(根据典故，我们假设n≤3000)。每个小姊妹有自己的名字，他觉得小姊妹的魅力和她们的名字有密切联系，于是他觉得所有有相似的名字的小姊妹必须排在一起。
相似是指，名字的开头一个或若干个连续字母相同。
于是，小x定下了如下规则：
在任何以同样的字母序列开头的名字之间，所有名字开头必须是同样的字母序列。
比如，像MARTHA和MARY这两个名字，它们都以MAR开头，所以像MARCO或MARVIN这样的名字可以插入这两个名字中间，而像MAY这样的就不行。
显然，按字典序排序是一个合法的排序方案，但它不是唯一的方案。你的任务就是计算出所有合法的方案数。考虑到答案可能很大，输出答案 mod 1 000 000 007。

对于60%的数据：3 ≤ n ≤ 10。
对于100%的数据：
3 ≤ n ≤ 3000
1 ≤ 字符串长度 ≤ 3000，并且只含有大写字母。

题解：
DFS+数学+排序+分治
先找出名字的最大长度，然后每个根据这个补位
然后按字典序排序名字
设f[i]为i个数的排列方案 那么f[i]=i!
递推式：
f[0]:=1
f[i]:=f[i-1]*i
//题目数据大，要注意取模以及开int64 / long long
然后dfs分治
从第dep个字母开始，向后寻找不等于的名字的位置，然后分段处理
//初始dep=1
如果第dep位的字母，第l个到第r个名字相同则分为1组，递归分治
dfs:=dfs*dfs(dep+1,l,r)
直到N个名字的第dep位都分到自己的“段”
//每个dfs初始=1
若每次分了gd段，则dfs=dfs*f[gd]
因为分了gd段，我们就看成gd个整体，即gd个不同的数去处理，因为字母相同，所以可以打乱顺序，则要*排列方案f[gd]

const    modn=1000000007;var    k:array [0..3001] of ansistring;    f:array [0..3001] of int64;    i,j,n,m,maxl:longint;function dfs(dep,l,r:longint):int64;var    i,j,gd:longint;begin    if l=r then exit(1);    if dep>maxl       then exit(f[r-l+1]);    dfs:=1; j:=l; gd:=1;    for i:=l to r do       if k[i][dep]<>k[j][dep]          then begin                   inc(gd);                   dfs:=dfs*dfs(dep+1,j,i-1) mod modn;                   j:=i;               end;    if k[r][dep]=k[j][dep]       then dfs:=dfs*dfs(dep+1,j,r) mod modn;    dfs:=dfs*f[gd] mod modn;    exit(dfs);end;procedure qsort(l,r:longint);var    i,j:longint;    mid:ansistring;begin    if l>=r then exit;    i:=l; j:=r;    mid:=k[(l+r) div 2];    repeat         while k[i]<mid do inc(i);         while k[j]>mid do dec(j);         if i<=j then         begin              k[0]:=k[i];              k[i]:=k[j];              k[j]:=k[0];              inc(i); dec(j);         end;    until i>j;    qsort(i,r);    qsort(l,j);end;begin    assign(input,'ranking.in'); reset(input);    assign(output,'ranking.out');rewrite(output);    readln(n);    f[0]:=1;    for i:=1 to n do    begin        readln(k[i]);        if length(k[i])>maxl           then maxl:=length(k[i]);    end;    for i:=1 to 3000 do        f[i]:=(f[i-1]*i) mod modn;    for i:=1 to n do      for j:=1 to maxl-length(k[i]) do k[i]:=k[i]+'0';    qsort(1,n);    writeln(dfs(1,1,n));    close(input); close(output);end.