[tire+最短路]Bless You Autocorrect!

[tire+最短路]Bless You Autocorrect!

Typing on phones can be tedious. It is easy to make typing mistakes, which is why most phones come with an autocorrect feature. Autocorrect not only fixes common typos, but also suggests how to finish the word while you type it. Jenny has recently been pondering how she can use this feature to her advantage, so that she can send a particular message with the minimum amount of typing.

The autocorrect feature on Jenny’s phone works like this: the phone has an internal dictionary of words sorted by their frequency in the English language. Whenever a word is being typed,autocorrect suggests the most common word (if any) starting with all the letters typed so far. By pressing tab, the word being typed is completed with the autocorrect suggestion. Autocorrect can only be used after the first character of a word has been typed –it is not possible to press tab before having typed anything. If no dictionary word starts with the letters typed so far, pressing tab has no effect.

Jenny has recently noticed that it is sometimes possible to use autocorrect to her advantage even when it is not suggesting the correct word, by deleting the end of the autocorrected word. For instance, to type the word “autocorrelation”, Jenny starts typing “aut”, which then autocorrects to “autocorrect” (because it is such a common word these days!) when pressing tab. By deleting the last two characters (“ct”) and then typing the six letters “lation”, the whole word can be typed using only 3 (“aut”) + 1 (tab) + 2 (backspace twice) + 6 (“lation”) = 12 keystrokes, 3 fewer than typing “autocorrelation” without using autocorrect.

Given the dictionary on the phone and the words Jenny wants to type, output the minimum number of keystrokes required to type each word. The only keys Jenny can use are the letter keys, tab and backspace.

输入

The first line of input contains two positive integers n (1 ≤ n ≤ 105 ), the number of words in the dictionary, and m (1 ≤ m ≤ 10 5 ), the number of words to type. Then follow n lines with one word per line, sorted in decreasing order of how common the word is (the first word is the most common). No word appears twice in the dictionary. Then follow m lines, containing the words to type.

The dictionary and the words to type only use lower case letters ‘ a ’-‘ z ’. The total size of the input file is at most 1 MB.

输出

For each word to type, output a line containing the minimum number of keystrokes required to type the corresponding word.

样例输入

5 5

austria

autocorrect

program

programming

computer

autocorrelation

programming

competition

zyx

austria

样例输出

12

4

11

3

2

建个tire树，然后连边，跑最短路。

看懂题不难

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e6+10;
const int inf=0x3f3f3f3f;
struct Tire{
    int nex[maxn][26],l,val[maxn],dist[maxn];
    bool vis[maxn];
    struct Edge{
        int v,cost;
        Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
    };
    struct qnode{
        int v,c;
        qnode(int _v=0,int _c=0):v(_v),c(_c){}
        bool operator<(const qnode &r)const{
            return c>r.c;
        }
    };
    vector<Edge>vt[maxn];
    int newnode(){
        for(int i=0;i<26;++i){
            nex[l][i]=-1;
        }
        dist[l]=inf;
        l++;
        return l-1;
    }
    void init(){
        l=0;
        newnode();
        memset(val,0,sizeof(val));
    }
    void add(int u,int v,int w){
        vt[u].push_back(Edge(v,w));
    }
    void Insert(char *buf){
        int len=strlen(buf);
        int now=0,en;
        for(int i=0;i<len;i++){
            if(nex[now][buf[i]-'a']==-1){
                nex[now][buf[i]-'a']=newnode();
            }
            add(now,nex[now][buf[i]-'a'],1);
            add(nex[now][buf[i]-'a'],now,1);
            now=nex[now][buf[i]-'a'];
            val[now]++;
        }
        int temp;en=now;
        now=0;
        for(int i=0;i<len-1;i++){
            temp=nex[now][buf[i]-'a'];
            if(val[temp]==1)
            add(temp,en,1);
            now=temp;
        }
    }
    void dijkstra(){
        memset(vis,0,sizeof(vis));
        priority_queue<qnode>que;
        dist[0]=0;
        que.push(qnode(0,0));
        qnode tmp;
        while(!que.empty()){
            tmp=que.top();que.pop();
            int u=tmp.v;
            if(vis[u])continue;
            vis[u]=true;
            int len=vt[u].size();
            for(int i=0;i<len;++i){
                int v=vt[u][i].v;
                int cost=vt[u][i].cost;
                if(!vis[v]&&dist[v]>dist[u]+cost){
                    dist[v]=dist[u]+cost;
                    que.push(qnode(v,dist[v]));
                }
            }
        }
    }
    int solve(char *buf){
        int len=strlen(buf);
        int now=0,i;
        for(i=0;i<len;++i){
            if(nex[now][buf[i]-'a']==-1){
                break;
            }
            now=nex[now][buf[i]-'a'];
        }
        return dist[now]+len-i;
    }
}st;
char s[maxn];
int Scan() { int res = 0, flag = 0;char ch;if ((ch = getchar()) == '-') { flag = 1; }
    else if(ch >= '0' && ch <= '9')
    {
        res = ch - '0';
    }
    while ((ch = getchar()) >= '0' && ch <= '9')
    {
        res = res * 10 + (ch - '0');
    }
    return flag ? -res : res;
}
int main()
{
    int n,m;n=Scan();m=Scan();
    st.init();
    for(int i=1;i<=n;++i){
        scanf("%s",s);
        st.Insert(s);
    }
    st.dijkstra();
    for(int i=1;i<=m;i++){
        scanf("%s",s);
        printf("%d\n",st.solve(s));
    }
    return 0;
}