小测试题解

一开始就想到一个暴力的做法（虽然也知道正解应该是后缀自动机）

把每一个字符串的每一个前缀都倒着加入字典树

然后就变成了经典的树博弈（根节点不能取，因为根是空的）

sg函数为，子树sg的xor和加权值（除根节点外权值都为1，因为每一个节点都只代表一个字符串）

但是这样是n方的，不过不会后缀自动机所以只好暴力

用后缀自动机的话就是建parent树，然后做带权值的树博弈（其实和普通的树博弈差不多，普通的只是权值都为1而已，权值为这个节点代表的字符串个数）

{$M 50000000}
const
    maxn=2000010;
type
    node=record
      go:array['0'..'9']of longint;
      step,fa:longint;
    end;

var
    sam:array[0..maxn]of node;
    first,stop,next,min:array[0..maxn]of longint;
    s,ans:ansistring;
    tot,last,t,num:longint;

procedure add(x:char);
var
    now,new,q:longint;
begin
    inc(tot);
    now:=tot;
    fillchar(sam[now].go,sizeof(sam[now].go),0);
    sam[now].step:=sam[last].step+1;
    while (last<>0)and(sam[last].go[x]=0) do
      begin
        sam[last].go[x]:=now;
        last:=sam[last].fa;
      end;
    if last=0 then sam[now].fa:=1
    else
      begin
        q:=sam[last].go[x];
        if sam[q].step=sam[last].step+1 then sam[now].fa:=q
        else
          begin
            inc(tot);
            new:=tot;
            sam[new]:=sam[q];
            sam[q].fa:=new;
            sam[now].fa:=new;
            sam[new].step:=sam[last].step+1;
            while (last<>0)and(sam[last].go[x]=q) do
              begin
                sam[last].go[x]:=new;
                last:=sam[last].fa;
              end;
          end;
      end;
    last:=now;
end;

procedure insert(x,y:longint);
begin
    inc(num);
    stop[num]:=y;
    next[num]:=first[x];
    first[x]:=num;
    min[y]:=sam[x].step+1;
end;

function dfs(x:longint):longint;
var
    i:longint;
begin
    dfs:=0;
    i:=first[x];
    while i<>0 do
      begin
        dfs:=dfs xor dfs(stop[i]);
        i:=next[i];
      end;
    inc(dfs,sam[x].step-min[x]+1);
end;

procedure main;
var
    i:longint;
begin
    readln(s);
    for i:=1 to tot do
      first[i]:=0;
    last:=1;
    tot:=1;
    fillchar(sam[1].go,sizeof(sam[1].go),0);
    for i:=1 to length(s) do
      add(s[i]);
    for i:=2 to tot do
      insert(sam[i].fa,i);
    if dfs(1)=1 then writeln('codechef')
    else writeln('topcoder');
end;

begin
assign(input,'game.in');
reset(input);
assign(output,'game.out');
rewrite(output);
    readln(t);
    while t<>0 do
      begin
        main;
        dec(t);
      end;
close(input);
close(output);
end.

2.期望面积

(qs.pas/c/cpp/in/out)

Description

给定平面上n个点及其出现的概率，问这n个点中出现的那些点组成的凸包面积期望是多少，如果凸包退化为直线则视其面积为0 保证不出现三点共线

 

Input

首先输入一个整数n (0 < n ≤ 100).，给定点的个数，之后n行每行输入两个整数x，y(-1000 ≤ x, y ≤ 1000)，和一个小数p(0 ≤ p ≤ 1)表示n个点的坐标及其出现的概率，输入数据保证p最多有4位小数

对于1%的数据n<=2

 对另外于29%的数据n<=3

对于100%的数据 0<n<=100, -1000 ≤ x, y ≤ 1000，0 ≤ p ≤ 1

Output

输出期望面积，答案保留6位小数，具体格式见sample output

 

Sample Input

3

0 0 0.1

1 0 0.1

1 1 0.1

 

Sample Output

0.000500

 

暴力想法，枚举每一种情况，然后计算凸包面积，再计算期望（考场上只想到拿前面的n<=3的情况）

虽然不可行，但是暴力总是提供基本思想

打完暴力就有想法了，求完凸包再求面积，我们是怎么求面积的呢，一般都是用叉积求的吧

然后我们发现当i->j这个有向线段算进面积的时候当且仅当i和j都出现且在i->j右边的点都没有出现

所以i->j这条有向线段的贡献就是叉积（点i，点j）*pi*pj*П（1-pk（k在i->j右方）），因为没有三点共线所以不要想太多，没有特殊情况

O（n^3）

 

const
    maxn=105;
var
    x,y,p:array[0..maxn]of double;
    n:longint;
    ans:double;

procedure init;
var
    i:longint;
begin
    read(n);
    for i:=1 to n do
      read(x[i],y[i],p[i]);
end;

function cj(x1,y1,x2,y2:double):double;
begin
    exit(x1*y2-y1*x2);
end;

procedure work;
var
    i,j,k:longint;
    s:double;
begin
    for i:=1 to n do
      for j:=1 to n do
        if i<>j then
        begin
          s:=cj(x[i],y[i],x[j],y[j])*p[i]*p[j];
          for k:=1 to n do
            if (k<>i)and(k<>j) then
            if cj(x[k]-x[i],y[k]-y[i],x[j]-x[i],y[j]-y[i])<=0 then s:=s*(1-p[k]);
          ans:=ans+s;
        end;
    write(abs(ans/2):0:6);
end;

begin
    init;
    work;
end.

第三题待码.........