EOJ 3261 字典树+dp 字典树模版

Problem #3261 分词
题目

Time limit per test: 1.0 seconds
Time limit all tests: 1.0 seconds
Memory limit: 256 megabytes

有一句句子因为粘贴的时候出现了一点问题空格全部丢失了。现在给一本字典，每个词都对应这个词出现的频率（每十亿）。根据这个频率，我们可以根据下面的公式算出这个词带来的收益 P(word)：

P(word)=len2(word)⋅ln(frequency(word))
其中 frequency 就是上面所提到的频率。len 指的是单词的长度。

特别的，对于字典中没有出现过的词，P(word)=0。

请对句子进行适当的分割，使得分割得到的所有词收益之和最大。同一个词可以重复出现，收益算作多次。

单词和句子可能会有大小写字母，但是匹配的时候不区分大小写，所以要把他们都转换成小写字母进行处理，但最后输出的时候要输出没有经过大小写转换的最初的句子。

思路：
用字典树存下所有单词和他们的收益
dp[i]：=句子前i个字母的最大收益和
dp[i] = max{dp[i-1], dp[j]+P(s[j~i])} (0<=j<=i)
如果直接查询每个P(s[j~i])的值，效率可能会太低。
所以从对于每个i，从s[i]开始沿着字典树向下，每遇到一个单词，就比较看能否更新dp[i]，一直到树的最末尾或s[0]
因为是从s[i]往s[0] 方向查找的，方向是反的，所以就要把一开始给的单词反向插入字典树，方便查找

//http://acm.ecnu.edu.cn/problem/3261/

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>

using namespace std;

const int MAXN = 10000;
char w[40], s[MAXN], ts[MAXN];
double dp[MAXN];
int x[MAXN];

struct node
{
    double v;
    node * nxt[26];
    node()
    {
        v=-1;
        fill(nxt, nxt+26, nullptr);
    }
};
node * root;

void insert_word(const char s[], double v)
{
    node * t = root;
    int len = strlen(s);
    for(int i=len-1; i>=0; --i)
    {
        if(t->nxt[s[i]-'a']==nullptr) t->nxt[s[i]-'a'] = new node;
        t = t->nxt[s[i]-'a'];
    }
    t->v = v;
}

void print(int n, bool flag)
{
    if(n==0) return;
    int t = x[n];
    print(t, 0);
    for(int i=t; i<n; ++i) putchar(ts[i]);
    if(flag) putchar('\n');
    else putchar(' ');

}

int main()
{
    int n;
    scanf("%d", &n);
    root = new node;
    double v;
    for(int i=0; i<n; ++i)
    {
        scanf("%s%lf", w, &v);
        for(int i=0; w[i]!='\0'; ++i) if(isupper(w[i])) w[i] = tolower(w[i]);
        v = strlen(w)*strlen(w) * log(v);
        insert_word(w, v);
    }
    scanf("%d", &n);
    for(int i=0; i<n; ++i)
    {
        scanf("%s", s);
        int len = strlen(s);
        strcpy(ts, s);
        for(int i=0; i<len; ++i) if(isupper(s[i])) s[i] = tolower(s[i]);
        fill(dp, dp+len+10, 0);
        for(int i=0; i<len; ++i)
        {
            node * t = root;
            dp[i+1] = dp[i];
            for(int j=i; j>=0; --j)
            {
                if(t->nxt[s[j]-'a'] == nullptr) break;
                t = t->nxt[s[j]-'a'];
                if(t->v > 0 && dp[j]+t->v > dp[i+1])
                {
                    x[i+1] = j;
                    dp[i+1] = dp[j] + t->v;
                }
            }
            if(dp[i+1] == dp[i]) x[i+1] = i;
        }
        printf("%.10f\n", dp[len]);
        print(len, 1);
    }

    return 0;
}

字典树模版

//#include <iostream>
//#include <algorithm>
//#include <vector>
//#include <cstdio>
//
//using namespace std;
//
//const int MAXN = 1E5 + 100;
//struct node
//{
//    bool flag;
//    int dp;
//    node * nxt[26];
//    node()
//    {
//        dp = 0;
//        flag = 0;
//        fill(nxt, nxt+26, nullptr);
//    }
//};
//node * root;
//void insert(const char * s)
//{
//    node * p = root;
//    for(int i=0; s[i]!='\0'; ++i)
//    {
//        if(p->nxt[s[i]-'a'] == nullptr) p->nxt[s[i]-'a'] = new node;
//        p = p->nxt[s[i]-'a'];
//    }
//    p->flag = 1;
//}
//int n, k;
//char s[MAXN];
//
//void dfs(node * root)
//{
//    vector<int> dps;
//    for(int i=0; i<26; ++i)
//    {
//        if(root->nxt[i] != nullptr)
//        {
//            dfs(root->nxt[i]);
//            dps.push_back(root->nxt[i]->dp);
//        }
//    }
//    sort(dps.begin(), dps.end(), greater<int>());
//    for(int i=0; i<(int)dps.size(); ++i)
//    {
//        if(dps[i]+i+1 > root->dp) root->dp = dps[i]+i+1;
//    }
//}
//
//void solve(node * root)
//{
//    vector<pair<int, int>> dps;
//    for(int i=0; i<26; ++i)
//        if(root->nxt[i] != nullptr) dps.push_back({root->nxt[i]->dp, i});
//    sort(dps.begin(), dps.end(), greater<pair<int, int>>());
//    for(int i=0; i<(int)dps.size(); ++i)
//    {
//        cout << char(dps[i].second+'a') <<endl;
//        int ans;
//        cin >> ans;
//        if(ans)
//        {
//            solve(root->nxt[dps[i].second]);
//            break;
//        }
//    }
//}
//
//int main()
//{
//    root = new node;
//    cin >> n >> k;
//    for(int i=0; i<n; ++i)
//    {
//        cin >> s;
//        insert(s);
//    }
//    dfs(root);
//    solve(root);
//
//    return 0;
//}

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>

using namespace std;

const int MAXN = 1E6;
const int MAXC = 26;

struct Trie
{
    bool flag;
    Trie * nxt[MAXC];
    Trie()
    {
        flag = 0;
        fill(nxt, nxt+MAXC, nullptr);
    }
};
Trie * root;
int val(char ch) { return ch - 'a'; }
void trie_insert(const char s[])
{
    Trie * t = root;
    for(int i=0; s[i]!='\0'; ++i)
    {
        if(t->nxt[val(s[i])] == nullptr) t->nxt[val(s[i])] = new Trie;
        t = t->nxt[val(s[i])];
    }
    t->flag = 1;
}
bool trie_search(const char s[])
{
    Trie * t = root;
    for(int i=0; s[i]!='\0'; ++i)
    {
        if(t->nxt[val(s[i])] == nullptr) return 0;
        t = t->nxt[val(s[i])];
    }
    return t->flag;
}
void trie_del(Trie * root)
{
    for(int i=0; i<MAXC; ++i) if(root->nxt[i] != nullptr) trie_del(root->nxt[i]);
    delete root;
}

int main()
{
    char tmp[50];
    root = new Trie;
    cout << " 请输入初始化字典树的字符串(字符0结束）：" << endl;
    while(cin >> tmp)
    {
        if(tmp[0] == '0' && tmp[1] =='\0') break;
        trie_insert(tmp);
    }
    cout << " 请输入要查找的字符串：" << endl;
    while(cin >> tmp)
    {
        if(tmp[0] == '0' && tmp[1] =='\0') break;
        if(trie_search(tmp)) cout << " 查找成功！再次输入查找，字符0结束查找：" << endl;
        else cout << " 查找失败！再次输入查找，字符0结束查找：" << endl;
    }
    trie_del(root);
    return 0;
}

Written with StackEdit.