Warm up 13 [C] Cellphone Typing

Cellphone Typing

Time Limit: 5000ms, Special Time Limit:12500ms, Memory Limit:65536KB

Total submit users: 20, Accepted users: 18

Problem 12750 : Special judge

Problem description

A research team is developing a new technology to save time when typing text messages in mobile devices. They are working on a new model that has a complete keyboard, so users can type any single letter by pressing the corresponding key. In this way, a user needs P keystrokes to type a word of length P.
However, this is not fast enough. The team is going to put together a dictionary of the common words that a user may type. The goal is to reduce the average number of keystrokes needed to type words that are in the dictionary. During the typing of a word, whenever the following letter is uniquely determined, the cellphone system will input it automatically, without the need for a keystroke. To be more precise, the behavior of the cellphone system will be determined by the following rules:

1. The system never guesses the first letter of a word, so the first letter always has to be input manually by pressing the corresponding key.

1. If a non-empty succession of letters c1c2 : : : cn has been input, and there is a letter c such that every word in the dictionary which starts with c1c2 : : : cn also starts with c1c2 : : : cnc, then the system inputs c automatically, without the need of a keystroke. Otherwise, the system waits for the user.

For instance, if the dictionary is composed of the words \hello", \hell", \heaven" and \goodbye", and the user presses \h", the system will input \e" automatically, because every word which starts with \h" also starts with \he". However, since there are words that start with \hel" and with \hea", the system now needs to wait for the user. If the user then presses \l", obtaining the partial word \hel", the system will input a second \l" automatically. When it has \hell" as input, the system cannot guess, because it is possible that the word is over, or it is also possible that the user may want to press \o" to get \hello". In this fashion, to type the word \hello" the user needs three keystrokes, \hell" requires two, and \heaven" also requires two, because when the current input is \hea" the system can automatically input the remainder of the word by repeatedly applying the second rule. Similarly, the word \goodbye" needs just one keystroke, because after pressing the initial \g" the system will automatically fill in the entire word. In this example, the average number of keystrokes needed to type a word in the dictionary is then (3 + 2 + 2 + 1)=4 = 2:00.
Your task is, given a dictionary, to calculate the average number of keystrokes needed to type a word in the dictionary with the new cellphone system.

Input

Each test case is described using several lines. The first line contains an integer N representing the number of words in the dictionary (1 ≤ N ≤ 10⁵). Each of the next N lines contains a non-empty string of at most 80 lowercase letters from the English alphabet, representing a word in the dictionary. Within each test case all words are different, and the sum of the lengths of all words is at most 10⁶.

Output

For each test case output a line with a rational number representing the average number of keystrokes needed to type a word in the dictionary. The result must be output as a rational number with exactly two digits after the decimal point, rounded if necessary.

Sample Input

4
hello
hell
heaven
goodbye
3
hi
he
h
7
structure
structures
ride
riders
stress
solstice
ridiculous

Sample Output

2.00
1.67
2.71

Problem Source

Latin American 2012

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <map>
#include <queue>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define maxn 450005
#define ll long long
#define INF 0x7fffffff
char str[100001];
int n, m;
double ans;
int ch[maxn][26];
int val[maxn];
int tsize[maxn];
struct Trie{
    int sz;
    Trie(){ sz = 1; memset(ch[0], 0, sizeof ch[0]); }
    void insert(char *s, int v){
        int u = 0, n = strlen(s);
        for (int i = 0; i<n; i++){
            int c = s[i] - 'a';
            if (!ch[u][c]){
                tsize[u]++;
                memset(ch[sz], 0, sizeof ch[sz]);
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] += v;
    }
};
void dfs(int u, double s){
    for (int i = 0; i < 26; i++){
        if (ch[u][i]){
            int v = ch[u][i];
            if (tsize[v]>1 && val[v] == 0)s++;
            if (val[v]){
                s += val[v]; ans += s;
            }
            dfs(v, s);
            if(tsize[v]>1&&val[v]==0)s --;
            if (val[v])s -= val[v];
        }
    }
}
int main(){
    int cas = 1;
    while (~scanf("%d", &n)){
        Trie tree;
        ans = 0;
        memset(tsize, 0, sizeof tsize);
        for (int i = 0; i < n; i++){
            scanf("%s", str);
            tree.insert(str, 1);
        }
        dfs(0, 0);
        printf("%.2lf\n", ans / n);
    }
    return 0;
}