题目大意:
就是现在给出n (n <= 20000)个单词, 每个单词由一些小写字母组成, 现在这些单词按照输入的顺序给定, 每个单词还有一个权值, 当然可能出现某个单词出现了两次, 即两个串完全一样但是多次出现, 权值还可能不同, 那么如果将这n个单词删掉一些之后, 剩下的单词满足按照原本输入的顺序排列, 上面一个是下面一个的子串, 这种删除方法是合法的, 求在所有合法的删除方案中剩下的单词的权值和最大是多少, 输入的单词总长度不超过30W
大致思路:
首先不难想到建立n个串的AC自动机, 用dp[i]表示最终剩下的串以第i个串结尾的的方案中权值和的最大值
那么dp[i] = max(dp[j] + w[i]) 1 <= j < i, dp[i]至少是0
显然如果这么直接dp的话讲所有穿建立自动机然后遍历, 直接DP时间复杂度是O(n*n + m), m是字符串总长度
那么由于n的限制, 这个方案是不接受的
于是这里需要用到fail树了, 这个题也是第一次遇到的AC自动机上利用fail树的性质的题
对于AC自动机上的L个点, 每个点只有一个fail指针, 且多个点之间的fail指针一定不会形成环(不含根节点), 那么按照fail指针的关系建立出fail树, 树上父亲节点是子节点的子串, 于是问题变成了, 对于第i个串, 当我们确定出其dp[i]时, 将其在AC自动机上对应的点标记一个值, 对于接下来的查询的次j个串, 其在AC自动机上进行遍历时经过的点和其fail树上的父亲节点代表的都是其子串, 于是问题变成, 对于一棵树上一些点已经被标记出值, 接下来会询问对于某个点, 其父亲结点中被标记出的值最大时多少
于是就变成的一个经典的用时间戳和线段树解决的问题, 建立fail树, dfs出其每个点的时间戳然后用线段树维护, 区间更新, 单点查询....祭奠一下我好久没写过的线段树...
这个做法的时间复杂度是O(m + n + mlogn)
具体细节参见代码吧(刚开始我线段树根节点顺手打成了以0开始计数...真是跪了...)
代码如下:
Result : Accepted Memory : 28436 KB Time : 2262 ms
/*
* Author: Gatevin
* Created Time: 2015/5/20 18:40:59
* File Name: Rin_Tohsaka.cpp
*/
//防爆栈...
#pragma comment(linker, "/STACK:16777216")
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++e)
#define SHOW_MEMORY(x) cout<<sizeof(x)/(1024*1024.)<<"MB"<<endl
struct Segment_Tree
{
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
int val[300010 << 2];
bool flag[300010 << 2];//延迟标记
void build(int l, int r, int rt)
{
val[rt] = flag[rt] = 0;
if(l == r) return;
int mid = (l + r) >> 1;
build(lson);
build(rson);
}
void pushDown(int rt)//向下更新延迟标记, 其实这题可以不用延迟标记的...
{
if(flag[rt])
{
val[rt << 1] = max(val[rt << 1], val[rt]);
val[rt << 1 | 1] = max(val[rt << 1 | 1], val[rt]);
flag[rt << 1] = flag[rt << 1 | 1] = 1;
flag[rt] = 0;
return;
}
}
//将区间[L, R]中的最大值更新
void update(int l, int r, int rt, int L, int R, int value)
{
if(l >= L && r <= R)
{
val[rt] = max(val[rt], value);
flag[rt] = 1;
return;
}
int mid = (l + r) >> 1;
if(mid >= L) update(lson, L, R, value);
if(mid + 1 <= R) update(rson, L, R, value);
}
int query(int l, int r, int rt, int pos)
{
if(l == r) return val[rt];
pushDown(rt);
int mid = (l + r) >> 1;
if(mid >= pos) return query(lson, pos);
if(mid + 1 <= pos) return query(rson, pos);
return -233333333;
}
};
struct Trie
{
int next[300010][26], fail[300010];
int L, root;
int n;//字符串个数
vector <string> V;//存储输入的字符串
vector <int> G[300010];//存储fail树
int left[300010], right[300010];//[left[i], right[i]]对应自动机上节点i在fail树上对应线段树的时间戳
int w[20010];//字符串权值
Segment_Tree seg;
int newnode()
{
for(int i = 0; i < 26; i++)
next[L][i] = -1;
L++;
return L - 1;
}
void init()
{
L = 0;
root = newnode();
}
void insert(int id)
{
for(int now = root, i = 0, sz = V[id].size(); i < sz; i++)
{
if(next[now][V[id][i] - 'a'] == -1)
next[now][V[id][i] - 'a'] = newnode();
now = next[now][V[id][i] - 'a'];
}
return;
}
void build()
{
fail[root] = root;
queue <int> Q;
Q.push(root);
while(!Q.empty())
{
int now = Q.front();
Q.pop();
for(int i = 0; i < 26; i++)
if(next[now][i] == -1)
next[now][i] = now == root ? root : next[fail[now]][i];
else
{
fail[next[now][i]] = now == root ? root : next[fail[now]][i];
Q.push(next[now][i]);
}
}
return;
}
int time;
void dfs(int now)
{
left[now] = ++time;
for(int i = 0, sz = G[now].size(); i < sz; i++)
dfs(G[now][i]);
right[now] = time;
}
void construct()
{
for(int i = 0; i < L; i++) G[i].clear();
for(int i = 1; i < L; i++)//找出fail树
G[fail[i]].push_back(i);
time = 0;
dfs(root);//得到各个节点在线段树上对应的时间戳(区间代表)
return;
}
int answer()
{
scanf("%d", &n);
V.clear();
string tmp;
init();
for(int i = 0; i < n; i++)
{
cin>>tmp>>w[i];
V.push_back(tmp);
insert(i);
}
build();
construct();
seg.build(1, time, 1);
int ans = 0;
for(int i = 0; i < n; i++)
{
int tmp = 0;
int now = root;
for(int j = 0, sz = V[i].size(); j < sz; j++)
{
now = next[now][V[i][j] - 'a'];
tmp = max(tmp, seg.query(1, time, 1, left[now]) + w[i]);
}
seg.update(1, time, 1, left[now], right[now], tmp);
ans = max(ans, tmp);
}
return ans;
}
};
Trie AC;
int main()
{
ios::sync_with_stdio(0);
int T;
scanf("%d", &T);
for(int cas = 1; cas <= T; cas++)
printf("Case #%d: %d\n", cas, AC.answer());
return 0;
}