3.3 字符串（1）

Trie 前缀树 字典树  

例题11  LA 3942 http://acm.hust.edu.cn/vjudge/problem/22109

字典树第一个例题我用set水过，先记录这个版本吧，题意是，给一个串，还有一些短串的集合，问有多少种不同的拆分方法使得拆分完后，每个子串都在集合中。

dp[len] 表示前len个有多少拆分法 dp[0]=1， 前0个字符有一种拆分法，空嘛。  dp[len] 就是答案，  转移就是， 如果接下来一段在集合中，那么就可以转移到长度加这段的长度。

 

起点有la=3e5，，对每一个起点，加的串可能有lbi=100，都要枚举，接下来就是判断这个串是否存在，用hash值判，o1，set查询logn ，n=4000， 总体复杂度 la*lb*logn 飘过2700ms。

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=3e5+10;
const LL MOD=20071027;
class String_Hash {///字符串哈希 init O(n) query O(1)
    typedef unsigned long long typec;///hash 值类型
    static const int MV=3e5+10;///串长度
    static const int key=137;///hash 种子值选素数好
    typec H[MV],xp[MV];
public:
    void init(char s[],int ls) { ///传入串数组和串长
        H[ls]=0;
        for(int i=ls-1; i>=0; i--) {
            H[i]=H[i+1]*key+s[i];
        }
        xp[0]=1;
        for(int i=1; i<=ls; i++) {
            xp[i]=xp[i-1]*key;
        }
    }
    typec get(int pos,int len) { ///传入初始位置 pos，串长 len，返回串 hash 值
        return H[pos]-H[pos+len]*xp[len];
    }
}Hash;
int n;
char a[M];
char b[4010][110];
LL dp[M];
set<unsigned long long> s;
int max_len;
void init_set() {
    s.clear();
    max_len=0;
    for(int i=0; i<n; i++) {
        int lb=strlen(b[i]);
        Hash.init(b[i],lb);
        s.insert(Hash.get(0,lb));
        max_len=max(max_len,lb);
    }
}
LL solve() {
    init_set();
    int len=strlen(a);
    for(int i=0; i<=len; i++) {
        dp[i]=0;
    }
    dp[0]=1;
    Hash.init(a,strlen(a));
    for(int i=0; i<len; i++) {
        if(dp[i]==0) continue;
        for(int j=0; j<max_len; j++) {
            if(!s.count(Hash.get(i,j+1))) continue;
            dp[i+j+1]+=dp[i];
            dp[i+j+1]%=MOD;
        }
    }
    return dp[len];
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    int cas=1;
    while(~scanf("%s%d",a,&n)) {
        for(int i=0; i<n; i++) {
            scanf("%s",b[i]);
        }
        printf("Case %d: %lld\n",cas++,solve());
    }
    return 0;
}

 

 字典树特别快72ms.  与上一种方法的差别就在于,用字典树存小串集合,然后还是枚举起点, 更新的时候就在字典树里更新, 遇到一个串就更新一个dp, 最坏情况复杂度 la*lb.

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=3e5+10;
const LL MOD=20071027;
class Trie_tree {   //字典树  前缀树
    struct node {
        int next[26],ptr,num;// ptr在字典中的位置，num此结点出现几次，
        void init() {
            ptr=-1;
            num=0;
            mt(next,0);
        }
    } s[M];
    int ls,p;
    int f(char c) {
        return c-'a';
    }
public:
    void init() {
        s[1].init();
        p=0;
        ls=2;
    }
    void Insert(char ch[]) {
        int head=1;
        for(int k=0; ch[k]; k++) {
            int id=f(ch[k]);
            if(!s[head].next[id]) {
                s[head].next[id]=ls;
                s[ls++].init();
            }
            head=s[head].next[id];
            s[head].num++;
        }
        s[head].ptr=p++;
    }
    int query(char ch[],int op) {
        int head=1;
        for(int k=0; ch[k]&&head; k++) {
            head=s[head].next[f(ch[k])];
        }
        if(op) { //op==1 查ptr
            if(head) return s[head].ptr;
            return -1;
        } else { //op==0 查num
            if(head) return s[head].num;
            return 0;
        }
    }
    void solve(int i,char ch[],LL dp[]){
        int head=1;
        for(int k=i;ch[k]&&head;k++){
            int id=f(ch[k]);
            if(!s[head].next[id]) return ;
            head=s[head].next[id];
            if(s[head].ptr!=-1){
                dp[k+1]+=dp[i];
                dp[k+1]%=MOD;
            }
        }
    }
} trie;
int n;
char a[M];
char b[4010][110];
LL dp[M];
void init_trie() {
    trie.init();
    for(int i=0; i<n; i++) {
        trie.Insert(b[i]);
    }
}
LL solve() {
    init_trie();
    int len=strlen(a);
    for(int i=0; i<=len; i++) {
        dp[i]=0;
    }
    dp[0]=1;
    for(int i=0; i<len; i++) {
        if(dp[i]==0) continue;
        trie.solve(i,a,dp);
    }
    return dp[len];
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    int cas=1;
    while(~scanf("%s%d",a,&n)) {
        for(int i=0; i<n; i++) {
            scanf("%s",b[i]);
        }
        printf("Case %d: %lld\n",cas++,solve());
    }
    return 0;
}

 

 

例题12 uva 11732 http://acm.hust.edu.cn/vjudge/problem/28438

题意, 给n个字符串,用题目中的strcmp两两比较,需要执行多少次==判断.

暴力n2枚举, 最坏len计算次数.超时.

字典树做法,先把所有串插入字典树, 然后枚举一个串去字典树中查询, 对于串的每一位,都需要和所有串执行一次==,通过字典树节点记录的次数可以o1累加, 然后和该位置相等的串会多执行一次=='\0',也可以o1得到.

因为\0也会比较一次,而字典树中我没存,所以我在每个串后面加个#表示\0,这样比较时不需要特判他了.  然后每个串会多算一个和自己的次数,  扣去2倍的长度即可,因为和自己总是能比较到最后一位.  每一对会算两次,最后答案除2即可.

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=4e3+10;
class Trie_tree {   //字典树  前缀树
    struct node {
        int next[63],ptr,num;// ptr在字典中的位置，num此结点出现几次，
        void init() {
            ptr=-1;
            num=0;
            mt(next,0);
        }
    } s[M*1000];
    int ls,p;
    int f(char c) {
        if(c>='a'&&c<='z') return c-'a';
        if(c>='A'&&c<='Z') return c-'A'+26;
        if(c>='0'&&c<='9') return c-'0'+52;
        return 62;
    }
public:
    void init() {
        s[1].init();
        p=0;
        ls=2;
    }
    void Insert(char ch[]) {
        int head=1;
        for(int k=0; ch[k]; k++) {
            int id=f(ch[k]);
            if(!s[head].next[id]) {
                s[head].next[id]=ls;
                s[ls++].init();
            }
            head=s[head].next[id];
            s[head].num++;
        }
        s[head].ptr=p++;
    }
    int query(char ch[],int op) {
        int head=1;
        for(int k=0; ch[k]&&head; k++) {
            head=s[head].next[f(ch[k])];
        }
        if(op) { //op==1 查ptr
            if(head) return s[head].ptr;
            return -1;
        } else { //op==0 查num
            if(head) return s[head].num;
            return 0;
        }
    }
    LL solve(char ch[]){
        LL sum=0;
        int head=1;
        LL presum=-1;
        for(int k=0; ch[k]&&head; k++) {
            if(presum==-1){
                presum=0;
                for(int i=0;i<63;i++){
                    int next=s[head].next[i];
                    if(!next) continue;
                    presum+=s[next].num;
                }
            }
            sum+=presum;
            head=s[head].next[f(ch[k])];
            sum+=s[head].num;
            presum=s[head].num;
        }
        return sum;
    }
} trie;
int n;
char a[M][M];
LL solve(){
    trie.init();
    for(int i=0;i<n;i++){
        strcat(a[i],"#");
        trie.Insert(a[i]);
    }
    LL sum=0;
    for(int i=0;i<n;i++){
        sum+=trie.solve(a[i]);
        sum-=strlen(a[i])*2;
    }
    return sum/2;
}
int main(){
    #ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // txtout
    int cas=1;
    while(~scanf("%d",&n),n){
        for(int i=0;i<n;i++){
            scanf("%s",a[i]);
        }
        printf("Case %d: %lld\n",cas++,solve());
    }
    return 0;
}

 

 

 例题13 la 3026 http://acm.hust.edu.cn/vjudge/problem/29342

kmp例题, 又拿hash水过了, 发现hash虽然理论上有概率冲突,有概率出错, 但是实际使用起来, 很好.  

这题对每一个前缀,想知道该前缀最多能分成几块, 使得每一块都相等, 如果块数大于1,就输出.

hash解法, 枚举一个前缀, 然后枚举该前缀往后能有多少段相等, 每找到一个相等, 就能更新一次. 复杂度 n *( 1/1 + 1/2 + 1/n) 调和级数 并不大。 好像ln n吧？ 

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e6+10;
class String_Hash {///字符串哈希 init O(n) query O(1)
    typedef unsigned long long typec;///hash 值类型
    static const int MV=1e6+10;///串长度
    static const int key=137;///hash 种子值选素数好
    typec H[MV],xp[MV];
public:
    void init(char s[],int ls) { ///传入串数组和串长
        H[ls]=0;
        for(int i=ls-1; i>=0; i--) {
            H[i]=H[i+1]*key+s[i];
        }
        xp[0]=1;
        for(int i=1; i<=ls; i++) {
            xp[i]=xp[i-1]*key;
        }
    } typec get(int pos,int len) { ///传入初始位置 pos，串长 len，返回串 hash 值
        return H[pos]-H[pos+len]*xp[len];
    }
} gx;
int n;
char a[M];
int b[M];
typedef pair<int,int> pii;
vector<pii> answer;
void init() {
    int la=strlen(a);
    for(int i=0; i<la; i++) {
        b[i]=1;
    }
    gx.init(a,la);
}
void solve() {
    init();
    int la=strlen(a);
    for(int i=0;i<la;i++){
        int len=i+1;
        for(int j=i+1;j+len-1<la;j+=len){
            if(gx.get(0,len)!=gx.get(j,len)) break;
            b[j+len-1]=max(b[j+len-1],(j+len)/len);
        }
    }
    answer.clear();
    for(int i=0;i<la;i++){
        if(b[i]>1){
            answer.push_back(make_pair(i+1,b[i]));
        }
    }
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    int cas=1;
    while(~scanf("%d",&n),n) {
        scanf("%s",a);
        solve();
        printf("Test case #%d\n",cas++);
        for(int i=0; i<answer.size(); i++) {
            printf("%d %d\n",answer[i].first,answer[i].second);
        }
        puts("");
    }
    return 0;
}

 

 白书kmp不是很容易理解 ,  先记录一下吧.

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e6+10;
int n;
char a[M];
int f[M];
typedef pair<int,int> pii;
vector<pii> answer;
void getFail(char* P,int* f){
    int m=strlen(P);
    f[0]=0;
    f[1]=0;
    for(int i=1;i<m;i++){
        int j=f[i];
        while(j&&P[i]!=P[j]) j=f[j];
        f[i+1]=P[i]==P[j]?j+1:0;
    }
}
void solve() {
    getFail(a,f);
    answer.clear();
    int la=strlen(a);
    for(int i=0;i<=la;i++){
        if(f[i]>0&&i%(i-f[i])==0){
            answer.push_back(make_pair(i,i/(i-f[i])));
        }
    }
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    int cas=1;
    while(~scanf("%d",&n),n) {
        scanf("%s",a);
        solve();
        printf("Test case #%d\n",cas++);
        for(int i=0; i<answer.size(); i++) {
            printf("%d %d\n",answer[i].first,answer[i].second);
        }
        puts("");
    }
    return 0;
}

 

 

例题14 la 4670 http://acm.hust.edu.cn/vjudge/problem/19224

ac自动机例题 不会, 但是kmp可以水过.  求出现次数最多的子串. 暴力一个个kmp看出现次数.

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e6+10;
class KMP { ///模式匹配(kmp)O(ls+lp)
    typedef char typec;///文本元素的类型
    static const int MV=1e6+10;///字符串的长度
    int next[MV];
public:///匹配串长度 ls，str 存待匹配文本,模式串长度 lp,pat 存模式串
    int kmp(int ls,typec str[],int lp,typec pat[],int res[]) { ///返回匹配次数,res 中存储每个匹配的初始位置
        int i=0,j=-1,cnt=0;
        next[0]=-1;
        while(i<lp) {
            if(j==-1||pat[i]==pat[j]) {
                next[++i]=++j;
                continue;
            }
            j=next[j];
        }
        i=j=0;
        while(i<ls) {
            while(j!=lp&&str[i]==pat[j]) {
                i++;
                j++;
            }
            if(!j) {
                i++;
                continue;
            }
            if(j==lp) {
                res[cnt++]=i-j;
            }
            j=next[j];
        }
        return cnt;
    }
} gx;
int n;
struct Q{
    char a[128];
    int time;
}q[210];
char b[M];
int res[M];
int answer;
void solve(){
    answer=0;
    int lb=strlen(b);
    for(int i=0;i<n;i++){
        q[i].time=gx.kmp(lb,b,strlen(q[i].a),q[i].a,res);
        answer=max(answer,q[i].time);
    }
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    while(~scanf("%d",&n),n) {
        for(int i=0; i<n; i++) {
            scanf("%s",q[i].a);
        }
        scanf("%s",b);
        solve();
        printf("%d\n",answer);
        for(int i=0;i<n;i++){
            if(q[i].time==answer){
                puts(q[i].a);
            }
        }
    }
    return 0;
}

ac自动机代码 need to write.

 

 

 例题15 uva 11468 

ac自动机  need to write.

 

例题16  uva 11019

 

暴力kmp加bitset 水过.  求一个字符矩阵在一个大字符矩阵出现几次.  枚举每一行, bitset每一位 1 表示该位为起点匹配上了, x行与运算, 1的个数就是矩阵匹配次数, 中间也可以break 剪枝.

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e3+10;
class KMP { ///模式匹配(kmp)O(ls+lp)
    typedef char typec;///文本元素的类型
    static const int MV=1e3+10;///字符串的长度
    int next[MV];
public:///匹配串长度 ls，str 存待匹配文本,模式串长度 lp,pat 存模式串
    int kmp(int ls,typec str[],int lp,typec pat[],int res[]) { ///返回匹配次数,res 中存储每个匹配的初始位置
        int i=0,j=-1,cnt=0;
        next[0]=-1;
        while(i<lp) {
            if(j==-1||pat[i]==pat[j]) {
                next[++i]=++j;
                continue;
            }
            j=next[j];
        }
        i=j=0;
        while(i<ls) {
            while(j!=lp&&str[i]==pat[j]) {
                i++;
                j++;
            }
            if(!j) {
                i++;
                continue;
            }
            if(j==lp) {
                res[cnt++]=i-j;
            }
            j=next[j];
        }
        return cnt;
    }
} gx;
int n,m,x,y;
char a[M][M];
char b[M][M];
int la[M];
int lb[M];
bitset<1000> b1,b2;
int res[M];
int solve(){
    for(int i=0;i<n;i++){
        la[i]=strlen(a[i]);
    }
    for(int i=0;i<x;i++){
        lb[i]=strlen(b[i]);
    }
    int sum=0;
    for(int i=0;i+x-1<n;i++){
        b1.reset();
        for(int j=0;j<m;j++){
            b1.set(j);
        }
        for(int j=0;j<x;j++){
            int time=gx.kmp(la[i+j],a[i+j],lb[j],b[j],res);
            if(time==0){
                b1.reset();
                break;
            }
            b2.reset();
            for(int k=0;k<time;k++){
                b2.set(res[k]);
            }
            b1&=b2;
            if(b1.count()==0) break;
        }
        sum+=b1.count();
    }
    return sum;
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    int t;
    while(~scanf("%d",&t)) {
        while(t--){
            scanf("%d%d",&n,&m);
            for(int i=0;i<n;i++){
                scanf("%s",a[i]);
            }
            scanf("%d%d",&x,&y);
            for(int i=0;i<x;i++){
                scanf("%s",b[i]);
            }
            printf("%d\n",solve());
        }
    }
    return 0;
}

 

 不用bitset会慢一些, 常数

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e3+10;
class KMP { ///模式匹配(kmp)O(ls+lp)
    typedef char typec;///文本元素的类型
    static const int MV=1e3+10;///字符串的长度
    int next[MV];
public:///匹配串长度 ls，str 存待匹配文本,模式串长度 lp,pat 存模式串
    int kmp(int ls,typec str[],int lp,typec pat[],int res[]) { ///返回匹配次数,res 中存储每个匹配的初始位置
        int i=0,j=-1,cnt=0;
        next[0]=-1;
        while(i<lp) {
            if(j==-1||pat[i]==pat[j]) {
                next[++i]=++j;
                continue;
            }
            j=next[j];
        }
        i=j=0;
        while(i<ls) {
            while(j!=lp&&str[i]==pat[j]) {
                i++;
                j++;
            }
            if(!j) {
                i++;
                continue;
            }
            if(j==lp) {
                res[cnt++]=i-j;
            }
            j=next[j];
        }
        return cnt;
    }
} gx;
int n,m,x,y;
char a[M][M];
char b[M][M];
int la[M];
int lb[M];
bool b1[M];
bool b2[M];
int res[M];
int solve(){
    for(int i=0;i<n;i++){
        la[i]=strlen(a[i]);
    }
    for(int i=0;i<x;i++){
        lb[i]=strlen(b[i]);
    }
    int sum=0;
    for(int i=0;i+x-1<n;i++){
        int one=m;
        for(int j=0;j<m;j++){
            b1[j]=true;
        }
        for(int j=0;j<x;j++){
            int time=gx.kmp(la[i+j],a[i+j],lb[j],b[j],res);
            if(time==0){
                one=0;
                break;
            }
            for(int k=0;k<m;k++){
                b2[k]=false;
            }
            for(int k=0;k<time;k++){
                b2[res[k]]=true;
            }
            for(int k=0;k<m;k++){
                if(b1[k]&&b2[k]) continue;
                if(b1[k]&&!b2[k]){
                    b1[k]=false;
                    one--;
                    if(one==0) break;
                }
            }
            if(one==0) break;
        }
        sum+=one;
    }
    return sum;
}
int main() {
#ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif // txtout
    int t;
    while(~scanf("%d",&t)) {
        while(t--){
            scanf("%d%d",&n,&m);
            for(int i=0;i<n;i++){
                scanf("%s",a[i]);
            }
            scanf("%d%d",&x,&y);
            for(int i=0;i<x;i++){
                scanf("%s",b[i]);
            }
            printf("%d\n",solve());
        }
    }
    return 0;
}

 

ac自动机 need to write.

 

 

 

 

end