bzoj 4567 [Scoi2016]背单词

Lweb面临众多英语单词的学习任务,在凤老师的指导下通过优化单词学习顺序以减少学习成本。本篇介绍了如何通过构建字典树(Trie)并采用贪心算法来找到最佳单词学习路径,以达到最小化额外努力的目标。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

http://www.elijahqi.win/archives/3267
Description

Lweb 面对如山的英语单词,陷入了深深的沉思,“我怎么样才能快点学完,然后去玩三国杀呢?”。这时候睿智
的凤老师从远处飘来,他送给了 Lweb 一本计划册和一大缸泡椒,他的计划册是长这样的:
—————
序号 单词
—————
1
2
……
n-2
n-1
n
—————

然后凤老师告诉 Lweb ,我知道你要学习的单词总共有 n 个,现在我们从上往下完成计划表,对于一个序号为 x
的单词(序号 1…x-1 都已经被填入):
1) 如果存在一个单词是它的后缀,并且当前没有被填入表内,那他需要吃 n×n 颗泡椒才能学会;
2) 当它的所有后缀都被填入表内的情况下,如果在 1…x-1 的位置上的单词都不是它的后缀,那么你吃 x 颗泡
椒就能记住它;
3) 当它的所有后缀都被填入表内的情况下,如果 1…x-1的位置上存在是它后缀的单词,所有是它后缀的单词中
,序号最大为 y ,那么你只要吃 x-y 颗泡椒就能把它记住。
Lweb 是一个吃到辣辣的东西会暴走的奇怪小朋友,所以请你帮助 Lweb ,寻找一种最优的填写单词方案,使得他
记住这 n 个单词的情况下,吃最少的泡椒。

Input

输入一个整数 n ,表示 Lweb 要学习的单词数。接下来 n 行,每行有一个单词(由小写字母构成,且保证任意单
词两两互不相同)1≤n≤100000, 所有字符的长度总和 1≤|len|≤510000

Output

Lweb 吃的最少泡椒数

Sample Input

2
a
ba
Sample Output

2
HINT

Source

考虑如果第一种情况 如果第一种情况存在那么一定不会是最优的情况 因为可以考虑将单词重新安排一下肯定可以避免这种情况的出现

那么考虑第二种情况和第三种情况 怎么安排 那么将原题给定的那些串反过来 分别插在trie树上 然后找一个后缀中最晚出现的编号的那个串是哪个串即可 考虑将其他没用的节点先删去 然后 将每个节点结尾的位置标记出来重新建一棵新的树 这时候就该考虑如何标号使得我这个节点的编号减去我父节点编号的差最小

有一个贪心的想法 按照子树的大小size排序 然后每次先给子树大小小的排序

证明的话 蒟蒻感觉如果考虑当前这个节点和所有儿子节点的贡献的话可以发现先走size小的那些地方可以减少我这个节点后面儿子对我造成的贡献可以尽量的减少到最小 同理大概可以推广到整棵树的吧..

注意本题需要开long long..

#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=550000;
int num,n,trans[N][26],cnt=1,ed[N],size[N],dfn[N];
vector<int>son[N];char s[N];long long ans;
inline void insert1(char *s,int id){
    int p=1;
    for (int i=strlen(s+1),nxt;i;--i){
        if (!trans[p][s[i]-'a']) trans[p][s[i]-'a']=nxt=++cnt;
        else nxt=trans[p][s[i]-'a'];p=nxt;
    }ed[p]=id;
}
inline void dfs(int x,int fa){
    if (ed[x]&&ed[x]!=ed[fa]) son[ed[fa]].push_back(ed[x]),fa=x;
    for (int i=0;i<26;++i)
        if (trans[x][i]) dfs(trans[x][i],fa);
}
inline void dfs1(int x){
    size[x]=1;
    for (int i=0;i<son[x].size();++i) dfs1(son[x][i]),size[x]+=size[son[x][i]];
}
inline bool cmp(const int &a,const int &b){
    return size[a]<size[b];
}
inline void dfs2(int x,int fa){
    sort(son[x].begin(),son[x].end(),cmp);dfn[x]=++num;if (x!=fa)ans+=dfn[x]-dfn[fa];
    for (int i=0;i<son[x].size();++i) dfs2(son[x][i],x);
}
int main(){
    freopen("bzoj4567.in","r",stdin);
    scanf("%d",&n);ed[1]=1;
    for (int i=1;i<=n;++i) scanf("%s",s+1),insert1(s,i+1);
    dfs(1,1);dfs1(1);dfs2(1,1);printf("%lld\n",ans);
    return 0;
}
### BZOJ 2905 背单词 解决方案 #### 问题分析 BZOJ 2905 是一道涉及字符串匹配和动态规划的经典题目。该题的核心在于通过构建 **AC 自动机** 和利用 **线段树** 来优化状态转移过程,从而高效解决多个字符串之间的关系及其权值计算。 以下是基于已有引用内容以及专业知识对该问题的解答: --- #### 数据结构与算法设计 1. 构建 AC 自动机: 使用 Trie 树存储所有输入的字符串,并在此基础上建立 fail 指针构成 AC 自动机。这一步可以快速定位某个字符串是否为另一个字符串的后缀[^3]。 2. 建立 Fail 树: 将 AC 自动机中的节点按照 fail 指针的关系构建成一棵树(称为 Fail 树)。Fail 树上的父子关系表示某些字符串之间可能存在后缀关系[^3]。 3. 处理 DFS 序列: 对 Fail 树进行深度优先遍历 (DFS),并记录每个节点在 DFS 过程中的进入时间和退出时间。这些时间戳可以帮助我们将子树范围映射成一段连续区间[^3]。 4. 动态规划与线段树优化: 定义 `dp[i]` 表示以第 `i` 个字符串结尾时所能获得的最大收益。对于每个字符串,在其对应 Trie 节点上查找能够成为其后缀的所有祖先节点的最大收益值,并将其加到当前字符串的权值之上。 此处的关键操作是在沿着 Trie 树路径向上回溯的同时,查询 Fail 树中某棵子树范围内已知最大收益值。这一部分可以通过线段树实现高效的单点修改和区间最值查询[^3]。 --- #### 实现代码 以下是一个整的 Python 实现: ```python from collections import deque, defaultdict class Node: def __init__(self): self.children = {} self.fail = None self.output = [] self.id = -1 self.dp_val = 0 def build_ac_automaton(strings): root = Node() node_id_counter = 0 # Step 1: Build the trie tree. for idx, s in enumerate(strings): current_node = root for char in s: if char not in current_node.children: new_node = Node() current_node.children[char] = new_node current_node = current_node.children[char] current_node.output.append(idx) queue = deque([root]) while queue: parent = queue.popleft() for child_char, child in parent.children.items(): if parent is root: child.fail = root else: state = parent.fail while state and child_char not in state.children: state = state.fail if state: child.fail = state.children[child_char] else: child.fail = root queue.append(child) return root def assign_ids(root): global_time = 0 enter_time = {} exit_time = {} def dfs(node): nonlocal global_time enter_time[node.id] = global_time global_time += 1 for next_node in node.children.values(): dfs(next_node) exit_time[node.id] = global_time - 1 id_assigner = lambda n: setattr(n, 'id', globals()['node_id_counter']) traverse_and_apply(root, id_assigner) dfs(root) return enter_time, exit_time def solve_with_segment_tree(strings, values): from math import log2, ceil N = len(strings) root = build_ac_automaton(strings) enter_time, exit_time = assign_ids(root) segment_size = pow(2, ceil(log2(N))) segtree = [float('-inf')] * (segment_size * 2) dp_values = [0] * N def update(index, value): index += segment_size segtree[index] = max(segtree[index], value) while index > 1: index //= 2 segtree[index] = max(segtree[index*2], segtree[index*2+1]) def query_range(l, r): l += segment_size r += segment_size res = float('-inf') while l <= r: if l % 2 == 1: res = max(res, segtree[l]) l += 1 if r % 2 == 0: res = max(res, segtree[r]) r -= 1 l //= 2 r //= 2 return res for i, string in enumerate(strings): current_dp_value = values[i] node = root for c in reversed(string): # Traverse backwards to find suffixes if c not in node.children: break node = node.children[c] ancestor_start = enter_time.get(node.id, -1) ancestor_end = exit_time.get(node.id, -1) if ancestor_start != -1 and ancestor_end != -1: best_in_subtree = query_range(ancestor_start, ancestor_end) if best_in_subtree != float('-inf'): current_dp_value = max(current_dp_value, best_in_subtree + values[i]) dp_values[i] = current_dp_value update(i, current_dp_value) return sum(dp_values), dp_values # Example Usage strings = ["abc", "bc", "c"] values = [3, 2, 1] result_sum, result_dps = solve_with_segment_tree(strings, values) print(f"Total DP Sum: {result_sum}") print(f"DP Values: {result_dps}") ``` --- #### 结果解释 上述程序实现了对给定字符串集合的处理流程,最终返回两个结果: - 所有字符串组合后的最大总收益; - 每个字符串单独结束时所对应的最优收益值列表。 此方法的时间复杂度接近于 \(O(\text{总串长} \times \log N)\)[^3],适用于较大规模的数据集。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值