Cellphone Typing

Time Limit: 5000ms

Memory Limit: 131072KB

This problem will be judged on UVA. Original ID: 12526
64-bit integer IO format: %lld Java class name: Main

Prev Submit Status Statistics Discuss Next

Font Size: + -

Type:
None

Graph Theory

2-SAT

Articulation/Bridge/Biconnected Component

Cycles/Topological Sorting/Strongly Connected Component

Shortest Path

Bellman Ford

Dijkstra/Floyd Warshall

Euler Trail/Circuit

Heavy-Light Decomposition

Minimum Spanning Tree

Stable Marriage Problem

Trees

Directed Minimum Spanning Tree

Flow/Matching

Graph Matching

Bipartite Matching

Hopcroft–Karp Bipartite Matching

Weighted Bipartite Matching/Hungarian Algorithm

Flow

Max Flow/Min Cut

Min Cost Max Flow

DFS-like

Backtracking with Pruning/Branch and Bound

Basic Recursion

IDA* Search

Parsing/Grammar

Breadth First Search/Depth First Search

Advanced Search Techniques

Binary Search/Bisection

Ternary Search

Geometry

Basic Geometry

Computational Geometry

Convex Hull

Pick's Theorem

Game Theory

Green Hackenbush/Colon Principle/Fusion Principle

Nim

Sprague-Grundy Number

Matrix

Gaussian Elimination

Matrix Exponentiation

Data Structures

Basic Data Structures

Binary Indexed Tree

Binary Search Tree

Hashing

Orthogonal Range Search

Range Minimum Query/Lowest Common Ancestor

Segment Tree/Interval Tree

Trie Tree

Sorting

Disjoint Set

String

Aho Corasick

Knuth-Morris-Pratt

Suffix Array/Suffix Tree

Math

Basic Math

Big Integer Arithmetic

Number Theory

Chinese Remainder Theorem

Extended Euclid

Inclusion/Exclusion

Modular Arithmetic

Combinatorics

Group Theory/Burnside's lemma

Counting

Probability/Expected Value

Others

Tricky

Hardest

Unusual

Brute Force

Implementation

Constructive Algorithms

Two Pointer

Bitmask

Beginner

Discrete Logarithm/Shank's Baby-step Giant-step Algorithm

Greedy

Divide and Conquer

Dynamic Programming

Tag it!

[PDF Link]

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:

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.
If a non-empty succession of letters c₁c₂...c_n has been input, and there is a letter c such that every word in the dictionary which starts with c₁c₂...c_n also starts with c₁c₂...c_nc, 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 ( 1N10⁵). 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

题意:
先给你一些字符串，也就是所谓的字典；
然后先求查询每个单词最少要输入几个单词；
如
4
hello
hell
heaven
goodbye
如果输入g,那只有唯一一个g开头的，所以只要1个就可以。
输入h，由于h开头的都有e，所以e不需要输入，再输入l，相同理由此l不需要输入，再输入o，才能找到hello

解法:

对于每一个单词，至少要找到他，那就要找到他与其他单词不同的地方。hello hell 不同于最后的o。

可以再trie结构体里面多加几个条件，way表示接下去的种数，sum表示该单词使用次数，flag表示是否有单词；

如果该点的way>1，表示有多种路可以走。那此时ans+=p->sum,因为每个单词都要输入下面那个单词，如果现在这个位置有完整的一个字符串了，那ans--，因为他不用再输入了；如果此时way==1，并且这里有完整的单词时，那就要ans+=p->sum-1。(要注意这里的sum表示的意思)

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#define maxn 26

struct trie

{

    trie *next[maxn];

    int sum;

    int way;//记录分支的数量

    int flag;//标记

};

char str[];

trie *root;

void init()

{

    root=(trie*)malloc(sizeof(trie));

    for(int i=;i<maxn;i++)

        root->next[i]=NULL;

    root->sum=;

    root->flag=;

    root->way=;

}

void insert(char s[])

{

    trie *p=root,*q;

    int i,j,len=strlen(s);

    for(i=;i<len;i++)

    {

        int id=s[i]-'a';

        if(p->next[id]==NULL)

        {

            p->way++;

            q=(trie*)malloc(sizeof(trie));

            for(j=;j<maxn;j++)

                q->next[j]=NULL;

            q->sum=;

            q->flag=;

            q->way=;

            p->next[id]=q;

        }

        p=p->next[id];

        p->sum++;

        if(i==len-)

            p->flag=;

    }

}

int getans(trie *p)

{

    int i,j,ans=;

    for(i=;i<;i++)

    {

        if(p->next[i]!=NULL)

        {

            ans+=getans(p->next[i]);

        }

    }

    if(p->way>)

    {

        if(p->flag>)

        {

            ans--;

        }

        ans+=p->sum;

    }

    else if(p->flag>)

    {

        ans+=p->sum-;//如果为串尾;

    }

    free(p);

    return  ans;

}

int main()

{

    int i,j,t,m;

    while(scanf("%d",&t)!=EOF)

    {

        init();

        m=t;

        while(t--)

        {

            scanf("%s",str);

            insert(str);

        }

        int ans=getans(root)+m;

        printf("%.2lf\n",ans*1.0/m);

    }

}