Codeforces Round #333 (Div. 1)

---

problem C. Kleofáš and the n-thlon 或者601C

• description：
  m的全排列随机选n个得到n行m列的矩阵。第j列的得分为该列所有数的和。第j列排名为得分比它小的列数+1。给定该列的n个数，求其排名期望。
• solution：这n个数的和为score，就是说有多少列的得分小于score。其他m-1个数是无分别的，因此只需要求某一列得分小于score的概率，然后乘以m-1。最后答案+1。
• code

#include <bits/stdc++.h>

#define i64 long long
#define clr(x,y) memset(x,y,sizeof(x))
using namespace std;
const int INF=1000000005;
const int N=100005;
double f[100005];
double p[100005];

int n,m,a[111];

int main()
{
    cin >> n >> m;
    int S=0;
    for(int i=1;i<=n;i++) scanf("%d",a+i),S+=a[i];
    if(m==1){
        puts("1");
        return 0;
    }
    for(int i=1;i<=m;i++) if(i!=a[1]) f[i]=1.0/(m-1);
    for(int i=1;i<=S;i++) f[i]+=f[i-1];
    for(int i=2;i<=n;i++){
        int t=a[i];
        for(int j=S;j>=1;j--){
            if(j<=t){
                p[j]=f[j-1]/(m-1);
            }else{
                if(j-1<=m) p[j]=(f[j-1]-f[j-t]+f[j-t-1])/(m-1);
                else p[j]=(f[j-1]-f[j-m-1]-f[j-t]+f[j-t-1])/(m-1);
            }
        }
        f[0]=0;
        for(int j=1;j<=S;j++) f[j]=f[j-1]+p[j];
    }
    double ans=f[S-1];
    printf("%.13lf\n",ans*(m-1)+1);
    return 0;
}

---

problem D. D. Acyclic Organic Compounds 或者601D

• description：
  一棵有根树，每个结点一个字符$st_v$和一个权值$c_v$。定义$dif(v)$为从$v$出发到达其后代(包括$v$)所能构成的不同字符串的数量。求$dif(v)+c_v的最大值。$
• solution A：
  暴力一点就是对每棵子树构造trie，此时，$dif(v)$就是对应的$trie_v$的结点数量。然后可以通过合并所有儿子的$trie$来得到父亲的$trie$。这么做起来复杂度貌似是$O(n^2)$的。
  题解给了个类似树链剖分的方法：将重儿子的trie直接传给父亲，而不需要与父亲的trie合并。剩下的所有儿子再依次合并。
  然后实现的时候，发现重儿子根本是没所谓的——题解的时间和空间复杂度貌似都高了。关键在于，将字典树$T_v$合并到$T_u$里面的时候，如果单词$w只在T_v$中出现，我们只需要将$w$对应的结点插入到$T_u$，而不用将$w$下面的整棵子树复制到$T_u$下面。所以，合并的复杂度等于两棵trie的交集的规模。
  但是，具体复杂度的计算貌似比较复杂，但是从效果来看，是优于$O(nlog(n))$的树链剖分这部分的。

还有一点是:数组比结构体快

• code

#include <bits/stdc++.h>
#include <stack>
#include <algorithm>
using namespace std;

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

const int mm = 300005;
typedef long long LL;

/*
struct trie{
    int son[27];
    int sz;
}T[mm];
*/
int sn[mm][27];
int c[mm];
char st[mm];
vector<int> g[mm];
int sz[mm];

int n;

void input(){
    for(int i = 1; i <= n; i++){
        scanf("%d",c+i);
    }
    scanf("%s",st + 1);
    for(int i = 1; i <= n; i++) st[i] -= 'a';
    for(int i = 1; i < n; i++){
        int x,y;
        scanf("%d%d",&x,&y);
        g[x].push_back(y);
        g[y].push_back(x);
    }
}


int up = 'z'-'a';
int upd(int u,int v){
    int &su = sn[u][st[v]];
    if(su == 0){
        su = v;
        sz[u] += sz[v];
        return sz[v];
    }
    int res = 0;
    for(int i = 0; i <= up; i++)
    if(sn[v][i] != 0){
        int &sv = sn[v][i];
        res += upd(su,sv);
    }
    sz[u] += res;
    return res;
}

int Max,cnt;

void dfs_trie(int u,int fa = -1){
    sz[u] = 1;
    for(int i = 0; i < (int)g[u].size(); i++){
        int &v = g[u][i];
        if(v == fa) continue;
        dfs_trie(v,u);
        upd(u,v);
    }
    if(sz[u]+c[u] > Max){
        Max = sz[u] + c[u];
        cnt = 1;
    }else if(sz[u] + c[u] == Max) cnt++;
}

int main(){
    while(cin >> n){
        input();
        int root = 1;
        Max = 0,cnt = 0;
        dfs_trie(root);
        cout << Max << endl << cnt << endl;
    }
    return 0;
}

• solution B：
  某大神的做法是hash。把每棵子树的单词hash到一个set里面。然后合并儿子的set。然后有个问题是，合并完儿子的set之后得到一个集合s，对于s里面每个单词，还要把父亲的字符给接进去。复杂度又变成$O(n^2)$。但是有个tip，就是用从根节点$root$到$u$来表示结点$u$这个单词，那么其实这个单词在$u$的所有祖先的字典树里作用是完全一样的。其实这种做法是给所有字典树$T_u$加了公共前缀：$从root到u构成的前缀$。然后答案是一致的。
  引用自http://codeforces.com/contest/601/submission/14452773
  Hash用的真是一个6。