【字典树】小练

最新推荐文章于 2022-09-05 11:34:21 发布
最新推荐文章于 2022-09-05 11:34:21 发布
阅读量250 收藏
点赞数
分类专栏： 字典树 文章标签： hdu uva
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_35643793/article/details/77018003
版权

此小练都是一些裸的字典树的小练，主要是熟练字典树的运用；

题目参考自其他博客，在此就不一一贴出了；

字典树模板：点击打开链接



/****************************************字典树****************************************/

①uva1401 : remember the word  （dp+字典树）
题意：给一个长串，若干短串，问长串可以被短串构成的种数，短串可重复使用；

思路：dp+字典树，转移方程：dp[i]=sum{dp[i]+len(x)|x是i~len前缀}，具体看刘汝佳大白书209页；

转载 http://www.cnblogs.com/WABoss/p/5163511.html

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define NODE 1000006
#define mod 20071027

int nex[NODE][26];
int v[NODE];
int node;
int dp[NODE];

void init()
{
    node=1;
    memset(nex[0],0,sizeof(nex[0]));
    memset(dp,0,sizeof(dp));
}

int add(char *str)
{
    int cur=0,k;
    int len=strlen(str);
    for(int i=0; i<len; i++)
    {
        k=str[i]-'a';
        if(!nex[cur][k])
        {
            memset(nex[node],0,sizeof(nex[node]));
            v[node]=0; //清空操作；
            nex[cur][k]=node++;
        }
        cur=nex[cur][k];
    }
    v[cur]++;
}

int main()
{
    int n;
    char S[300005];
    char s[110];

    int cas=0;
    while(scanf("%s",S)!=EOF)
    {
        init();

        scanf("%d",&n);
        while(n--)
        {
            scanf("%s",s);
            add(s);
        }

        int len=strlen(S);
        dp[len]=1;
        for(int i=len-1; i>=0; i--)
        {
            int u=0,x;
            for(int j=i; j<len; j++)
            {
                x=S[j]-'a';
                if(nex[u][x]==0)
                    break;      //
                u=nex[u][x];    //
                if(v[u])
                    dp[i]=(dp[i]+dp[j+1])%mod;
            }
        }

        printf("Case %d: %d\n",++cas,dp[0]);
    }
    return 0;
}

②hdu1521：统计难题

题意：给定一个单词表的集合，然后给定询问串，问有多少个以询问串为前缀的单词；

代码：

#include<cstdio>
#include<cstring>

#define NODE 1000005

int next[NODE][26];
int v[NODE];
int node;

void init()  //初始化；
{
    node=1;  //节点个数；
    memset(next[0],0,sizeof(next[0]));
}

void add(char *str)  //加入
{
    int cur=0,k;
    int len=strlen(str);
    for(int i=0;i<len;i++)
    {
        k=str[i]-'a';
        if(next[cur][k]==0)
        {
            memset(next[node],0,sizeof(node));
            v[node]=0;  //清空操作；
            next[cur][k]=node++;
        }
        cur=next[cur][k];
        v[cur]++;
    }
}

int cal(char *str)  //查询
{
    int cur=0,k;
    int len=strlen(str);
    for(int i=0;i<len;i++)
    {
        k=str[i]-'a';
        if(next[cur][k])
            cur=next[cur][k];
        else
            return 0;
    }
    return v[cur];
}

int main()
{
    char str[20];
    init();
    while(1)
    {
        gets(str);
        if(str[0]=='\0')
            break;
        add(str);
    }

    while(scanf("%s",str)!=EOF)
    {
        printf("%d\n",cal(str));
    }
    return 0;
}

③ hdu1671：Phone List

题意：判断所给字串中是否有的字符串是其他字符串的前缀，有则输出NO；
思路：对于所有字符串先询问再插入，开标记数组标记字符串的末尾字符编号；
两种情况:1.寻找自己的过程中遇到完整的字符串，说明有字符串是他的前缀；
                 2.把自己找完了，发现最后一个字符还与其他字符相连，说明自己是其他字符串的前缀；

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

#define NODE 1000006

int nex[NODE][10];
int v[NODE],biao[NODE];
int node;
int flag;

void init()
{
    node=1;
    memset(nex[0],0,sizeof(nex[0]));
//    memset(biao,0,sizeof(biao));
}

void add(char *str)
{
    int cur=0,k;
    int len=strlen(str);

    for(int i=0; i<len; i++)
    {
        k=str[i]-'0';
        if(!nex[cur][k])
        {
            memset(nex[node],0,sizeof(nex[node]));
            v[node]=0,biao[node]=0; //清空操作；
            nex[cur][k]=node++;
        }
        cur=nex[cur][k];
        v[cur]++;
    }
    biao[cur]=1;
}

void cal(char *str)
{
    int cur=0,k;
    int len=strlen(str);

    for(int i=0; i<len; i++)
    {
        k=str[i]-'0';
        if(nex[cur][k])
        {
            cur=nex[cur][k];
            if(biao[cur]) flag=1;
        }
        else
            return;
    }
    if(v[cur]>=1) flag=1;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init();

        int n;
        scanf("%d",&n);

        flag=0;
        char s[20];
        for(int i=1; i<=n; i++)
        {
            scanf("%s",s);
            cal(s);
            add(s);
        }

        if(flag)
            puts("NO");
        else
            puts("YES");
    }
    return 0;
}

④uva11732 "strcmp()" Anyone?

题意：比较任意两个字符串，如果两个字符串相同则比较了（长度+1）*2次即（公共前缀*2+2）次，如果两个字符串不同则比较了（公共前缀*2+1）次；

思路：利用字典树，不过如果用儿子节点表示法的话，内存可能超限(试过了不超)，所以使用左儿子右兄弟的存储方法，利用此方法构成的是一棵二叉树。我们每要插入一字符串就会与之前所有插过的串相比。所有的串至少是要比一次的，如果串相同那就多比了一次，其他的就是：计算各字符的贡献！最后答案是ans+n*(n-1)/2;

代码：

#include<bits/stdc++.h>
#define N 4100000
#define ll long long

struct node
{
    char c;
    int l,r;
    int val;  //经过节点次数
    int cut;  //以节点为尾节点的次数
}trie[N];
int node;
ll ans=0;

void init()
{
    node=1;
    memset(trie,0,sizeof(trie));
}

void insert1(char *s)
{
    int rt,i;
    for(rt=0;*s;s++,rt=i)
    {
        for(i=trie[rt].l;i;i=trie[i].r)
        {
            if(trie[i].c==*s)
                break;
        }
        ans+=trie[i].val<<1;

        if(i==0)
        {
            trie[node].r=trie[rt].l;
            trie[node].l=0;
            trie[node].c=*s;
            trie[rt].l=node;
            i=node++;
        }
        trie[i].val++;
    }

    ans+=trie[rt].cut;
    trie[rt].cut++;
}

int main()
{
    int n,cas=1;
    char s[1100];
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0) break;

        ans=0;
        init();
        for(int i=0;i<n;i++)
        {
            scanf("%s",s);
            insert1(s);
//            printf("%d\n",ans);
        }

        printf("Case %d: %lld\n",cas++,ans+n*(n-1)/2);
    }
    return 0;
}

/*
2
a
b
4
mat
hat
sir
fat
2
nyoj
nyist
*/

耗内存的儿子节点表示法： 

#include<bits/stdc++.h>
#define ll long long
#define N 4100000

int nex[N][80];
int val[N],cut[N];
int node;

void init()
{
    memset(nex[0],0,sizeof(nex[0]));
    node=1;
}

ll ans=0;

void add(char *s,int T)
{
    int cur=0,k;
    int len=strlen(s);
    for(int i=0; i<len; i++)
    {
        k=s[i]-'0';
        if(!nex[cur][k])
        {
            memset(nex[node],0,sizeof(nex[node]));
            val[node]=0,cut[node]=0;

            nex[cur][k]=node++;
        }
        cur=nex[cur][k];

        ans+=val[cur]<<1;

        val[cur]++;
    }

    ans+=cut[cur];
    cut[cur]++;

//    printf("%d\n",ans);
}

int main()
{
    int n,cas=1;
    while(scanf("%d",&n)&&n)
    {
        init();
        char s[1100];

        ans=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%s",s);
            add(s,i);
        }

        printf("Case %d: %lld\n",cas++,ans+n*(n-1)/2);
    }
    return 0;
}


/****************************************01字典树****************************************/

题目类型：两两异或求异或所得最大值、连续子序列异或最大值

①hdu5269 ZYB loves Xor I

参考：http://blog.csdn.net/chy20142109/article/details/50704324

题意：输入一个含n个元素的序列A，求所有lowbit(Ai xor Aj)   ( i,j∈[1,n]) 的和；

思路：先考虑 lowbit ( ) 的性质：lowbit等于从低位儿开始第一个不等于0的位置对应的值，比如lowbit(13)=1,13=1101，第一个不等于0的就是第一位儿。那么我们就

是统计它一路到底与它的同位儿相异的个数*该位儿的值（贡献）

这一题存的01串要从低位儿开始存，样例模拟一下：10 12 4

代码：

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

using namespace std;
#define por(i,j,k) for(int i=j;i<=k;i++)
#define nor(i,j,k) for(int i=j;i>=k;i--)
#define clean(x,y) memset(x,y,sizeof(x))
#define ll long long
#define mod 998244353
#define N 1550000

int nex[N][2];
int val[N];
int node;

void init()
{
    node=1;
    clean(nex[0],0);
    val[0]=0;
}

void add(int c)
{
    int cur=0,k;
    por(i,0,29)
    {
        k=c&1;
        if(!nex[cur][k])
        {
            clean(nex[node],0);
            val[node]=0;

            nex[cur][k]=node++;
        }
        cur=nex[cur][k];
        val[cur]++;
        c>>=1;
    }
}

ll cal(int c)
{
    int cur=0,k;
    ll ans=0,value=1;
    por(i,0,29)
    {
        k=c&1;
        ans+=val[nex[cur][1-k]]*value;
        cur=nex[cur][k];
        value<<=1;
        c>>=1;
    }
    return ans;
}

int main()
{
    int t,cas=0;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        ll ans=0;

        init();

        scanf("%d",&n);
        por(i,1,n)
        {
            int x;
            scanf("%d",&x);
            add(x);
            ans+=cal(x);
//cout<<ans<<endl;
            if(ans>=mod) ans%=mod;
        }
        printf("Case #%d: ",++cas);
        printf("%I64d\n",ans*2%mod);
    }
    return 0;
}

② hdu 5536 Chip Factory

题意：输入长为n的序列，计算 maxi,j,k(si+sj)⊕sk，其中i , j , k各不相同；

思路：先把序列的所有元素存到字典树中，然后枚举i，j 删除si，sj，查询完之后再加进去；

求与x异或后的最大值找到与其二进制不同的最多的那个数来异或；
//学习到了思路，枚举删除的思路
//学习到了字典树的标记；：
1.标记经过某个节点的次数；
2.标记某个节点作为结尾的次数；
3.本题就是每个数都是按照30位二进制插入，到最后第三十层每一个数都有自己的结尾节点，在结尾节点保存的就是这个数的十进制值！

代码：

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

using namespace std;
#define por(i,j,k) for(int i=j;i<=k;i++)
#define nor(i,j,k) for(int i=j;i>=k;i--)
#define clean(x,y) memset(x,y,sizeof(x))
#define ll long long
#define mod 998244353
#define N 50005



int nex[N][2];
int num[N],val[N];
int a[N];
int node;

void init()
{
    node=1;
    clean(nex,0);
    clean(num,0);
    clean(val,0);
}

void add(int c)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;
        if(!nex[cur][k])
            nex[cur][k]=node++;

        cur=nex[cur][k];
        num[cur]++;
    }
    val[cur]=c;
}

ll cal(int c)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;
        if(nex[cur][1-k]&&num[nex[cur][1-k]])
            cur=nex[cur][1-k];
        else
            cur=nex[cur][k];
    }
    return c^val[cur];
}

void del(int c,int d)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;

        cur=nex[cur][k];
        num[cur]+=d;
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init();

        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            add(a[i]);
        }

        ll maxx=0;
        for(int i=1;i<n;i++)
        {
            del(a[i],-1);
            for(int j=i+1;j<=n;j++)
            {
                del(a[j],-1);
                maxx=max(maxx,cal(a[i]+a[j]));
                del(a[j],1);
            }
            del(a[i],1);
        }

        printf("%I64d\n",maxx);

    }
    return 0;
}

③ hdu 4825 Xor Sum

题意：给定一个n元素的集合，m次询问每次给定一个数，问与集合中那个数异或值最大并输出那个数字；

思路：

代码：

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

using namespace std;
#define por(i,j,k) for(int i=j;i<=k;i++)
#define nor(i,j,k) for(int i=j;i>=k;i--)
#define clean(x,y) memset(x,y,sizeof(x))
#define ll long long
#define mod 998244353
#define N 5000000

int nex[N][2];
int num[N];
int val[N];
int node;

void init()
{
    node=1;
    clean(nex,0);
    clean(num,0);
    clean(val,0);
}

void add(int c)
{
    int cur=0,k;
    nor(i,31,0)
    {
        k=(c>>i)&1;
        if(!nex[cur][k])
            nex[cur][k]=node++;
        cur=nex[cur][k];
        num[cur]++;
    }
    val[cur]=c;
}

int cal(int c)
{
    int cur=0,k;
    nor(i,31,0)
    {
        k=(c>>i)&1;
        if(nex[cur][1-k]&&num[nex[cur][1-k]])
            cur=nex[cur][1-k];
        else
            cur=nex[cur][k];
    }
    return val[cur]; //
}

int main()
{
    int t,cas=0;
    scanf("%d",&t);
    while(t--)
    {
        init();

        int n,m;
        scanf("%d%d",&n,&m);
        por(i,1,n)
        {
            int x;
            scanf("%d",&x);
            add(x);
        }

        printf("Case #%d:\n",++cas);
        por(i,1,m)
        {
            int x;
            scanf("%d",&x);
            printf("%d\n",cal(x));
        }
    }
    return 0;
}

④poj 3764 The xor-longest Path

题意：给定一棵数，每条边都有边权，一条路径的异或长度就是这条路径上所有边的异或值

从三号节点到7号节点也是一条路径~

思路：异或性质 x^y = (0^x) ^ (0^y) ；以0点为源点，保存各节点到源点这条路径的异或长度值到a[]。这个问题就转化为求a数组两两异或值的最大值！

代码：

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

using namespace std;
#define por(i,j,k) for(int i=j;i<=k;i++)
#define nor(i,j,k) for(int i=j;i>=k;i--)
#define clean(x,y) memset(x,y,sizeof(x))
#define ll long long
#define mod 998244353
#define N 3005000

int ch[N][2];
int val[N];
int node,cnt;

int head[100010],nod[100010];
struct info
{
    int to,v;
    int nex;
} edge[100010];

void add_edge(int from,int to,int val)
{
    edge[++cnt].to=to;
    edge[cnt].v=val;
    edge[cnt].nex=head[from];
    head[from]=cnt;
}

void init()
{
    cnt=0;
    node=1;
    clean(ch[0],0);

    clean(edge,0);
    clean(nod,0);
    clean(head,0);
}

void add(int c)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;
        if(!ch[cur][k])
        {
            clean(ch[node],0);
            val[node]=0;

            ch[cur][k]=node++;
        }
        cur=ch[cur][k];
    }
    val[cur]=c;
}

ll cal(int c)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;
        if(ch[cur][1-k])
            cur=ch[cur][1-k];
        else
            cur=ch[cur][k];
    }
    return val[cur]^c;
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        init();

        por(i,1,n-1)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(min(a,b),max(a,b),c);
        }

        for(int i=0; i<n; i++)
            for(int j=head[i]; j; j=edge[j].nex)
                nod[edge[j].to]=nod[i]^edge[j].v;

        ll maxx=0;
        por(i,1,n)
        {
            add(nod[i]);
            maxx=max(maxx,cal(nod[i]));
        }
        printf("%I64d\n",maxx);
    }
    return 0;
}

⑤bzoj 4260 Codechef REBXOR

题意：输入有n个元素的序列，从序列中找到两个不想交的区间，求两个区间的异或值的和的最大值；

思路：分别序列的前缀异或和与后缀异或和；然后枚举序列中元素计算  【1~i 的异或和   +   (i+1)~n的异或和】

代码：

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


using namespace std;
#define por(i,j,k) for(int i=j;i<=k;i++)
#define nor(i,j,k) for(int i=j;i>=k;i--)
#define clean(x,y) memset(x,y,sizeof(x))
#define ll long long
#define mod 998244353
#define N 15000000


int nex[N][2];
int val[N];
int a[500005],pre[500005],suf[500005];
ll dp[500005];
int node;


void init()
{
    clean(nex[0],0);
    node=1;
}


void add(int c)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;
        if(!nex[cur][k])
        {
            clean(nex[node],0);
            val[node]=0;


            nex[cur][k]=node++;
        }
        cur=nex[cur][k];
    }
    val[cur]=c;
}


ll cal(int c)
{
    int cur=0,k;
    nor(i,30,0)
    {
        k=(c>>i)&1;
        if(nex[cur][1-k])
            cur=nex[cur][1-k];
        else
            cur=nex[cur][k];
    }
    return val[cur]^c;
}


int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        pre[0]=suf[n+1]=0;
        por(i,1,n) scanf("%d",&a[i]);
        por(i,1,n) pre[i]=pre[i-1]^a[i];
        nor(i,n,1) suf[i]=suf[i+1]^a[i];


        clean(dp,0);
        add(pre[0]);
        por(i,1,n)
        {
            dp[i]=max(dp[i-1],cal(pre[i]));
            add(pre[i]);
        }


        ll maxx=0;
        init();
        add(suf[n+1]);
        nor(i,n,1)
        {
            maxx=max(maxx,dp[i-1]+cal(suf[i]));
            add(suf[i]);
        }


        printf("%lld\n",maxx);
    }
    return 0;
}

⑥ usaco training 6.1.3 Cow XOR

题意：输入一个含n个元素的序列，求子序列异或值最大值是多少，并且输出此子序列的开头结尾下标，如果子序列的值一样，选择结尾下标较小的，还是相同？选择较短的那条序列！

思路：利用前缀异或值数组；计算出连续子序列异或值最大是多少，因为是按序输入所以不用处理结尾下标较小，如果有两个前缀值相同，则后来的回更新前面已经存在的，这会保证选择的是较短的那条序列；

代码：

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

using namespace std;
#define por(i,j,k) for(int i=j;i<=k;i++)
#define nor(i,j,k) for(int i=j;i>=k;i--)
#define clean(x,y) memset(x,y,sizeof(x))
#define ll long long
#define mod 998244353
#define N 2005000

int nex[N][2];
struct info
{
    int v,id;
}val[N];
int node;
int pre[100100];

void init()
{
    node=1;
    clean(nex[0],0);

    clean(pre,0);
}

void add(int c,int idx)
{
    int cur=0,k;
    nor(i,20,0)
    {
        k=(c>>i)&1;
        if(!nex[cur][k])
        {
            clean(nex[node],0);
            val[node].id=0,val[node].v=0;

            nex[cur][k]=node++;
        }
        cur=nex[cur][k];
    }
    val[cur].id=idx;
    val[cur].v=c;
}

info cal(int c)
{
    int cur=0,k;
    nor(i,20,0)
    {
        k=(c>>i)&1;
        if(nex[cur][1-k])
            cur=nex[cur][1-k];
        else
            cur=nex[cur][k];
    }

    return val[cur];
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        por(i,1,n)
        {
            int x;
            scanf("%d",&x);
            pre[i]=pre[i-1]^x;
        }

//        por(i,1,n)
//        cout<<pre[i]<<" ";
//        cout<<endl;

        int ans=0,ans_l=0,ans_r=0;
        info an;
        add(pre[0],0);
        por(i,1,n)
        {
            add(pre[i],i);
            an=cal(pre[i]),an.v^=pre[i];

            if(an.v>ans)  //选最大的
            {
                ans=an.v;
                ans_l=(an.id+1);
                ans_r=i;
//                printf("%d : ans:%d l:%d\n",i,an.v,an.id);
            }
        }
        printf("%d %d %d\n",ans,ans_l,ans_r);
    }
    return 0;
}
就是因为这一题才开始学了字典树；01二进制思想的运用：01字典树。

学习时间有点长了，近一周

Here_jiaxinwei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正交采样Matlab代码-zero-tree_OMP:具有小波启发的零树字典的正交匹配追踪
06-08
受小波零树启发的正交匹配追踪。 该存储库包含用于测试零树 OMP 并将其与传统 OMP 进行比较的脚本。 内容 tools/包含运行零树 OMP、传统 OMP 和其他脚本来训练字典的代码。 还有一些针对 BLAS 和 LAPACK 编译的 mex ...
algorithm:数据结构|数组队列堆栈链表哈希表堆字典树；算法|排序贪心动态规划分治回溯；欢迎给建议~~
05-30
字典树 树 图 算法 I II III IV V VI VII VIII IX X XI XII IX X 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 计数排序 桶排序 基数排序 递归 查找算法 贪心算法 分治算法 参考资料 JavaScript ...
字典树小结
03-06 963
没有见到过字典树的时候，以为会很神秘。 其实，如果链表学的差不多了，实现字典树那就是手到擒来。 做了几道题，效果还好。。 第一道： NYOJ 290 动物统计加强版 点击打开链接 典型的字典树。裸的字典树。还是比较好的。不是太坑。算是练手了吧。直接就写了，也不用放内存什么的。但是，最好的还是把内存给放了吧，要不太占内存。 直接代码： #include #includ
字典树萌新总结
ONE MORE TRY
10-06 445
字典树(Trie树)： 利用字符串的公共前缀来节约存储空间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。  引入一张图片： 利用公共前缀； Trie树的定义： struct Trie{ Trie* next[LENGTH]; //每层有多少种类，例如：数字(10种)，字母(26种)； int num; //表示字典树到此有多少种前
c语言实现数据结构--深入了解字典树和双数组字典树
m0_62598965的博客
09-05 587
字典树 一种误区 节点 双数组字典树 完全二叉树对于空间的节省 双数组字典树
字典树 —— 字符串分析算法
三钻 - 之前端到全栈之路
11-19 3274
这篇文章我们就来一起学习，剩下的几个字符串中比较细节的算法。
【图解算法】模板+变式——带你彻底搞懂字典树(Trie树)
热门推荐
丧心病狂Loli控的博客
07-12 1万+
  啥是字典树？ 【字典树】(Trie Tree) 是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串）。 它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。                                                     ——百度 · 百科 so？所以到底什么是字典树？   还好，它还有其他的名字，更能表述出它的实质： 前缀树、单词查找树 &nbs
快速单词拼写程序（JAVA源码）
07-17
快速单词拼写检错程序 使用字典树搜索算法； 导入词库，导入需要检错的文章，检查错误提示错误单词的行数；
机器学习+决策树+python实现对率回归决策树
04-28
通过dealanddraw(n0, pngname)函数将数组转化为字典类型，绘制决策树，将决策树以图片形式保存在程序的同一目录下。 收获 通过该代码读者能够掌握机器学习课程中对率回归决策树的基本绘制方法，能够根据自己的需求...
chi_sim.traineddata字典包
09-17
2021-9最新官方下载中文识别包,包含了chi_sim.traineddata,chi_sim_vert.traineddata,chi_tra.traineddata,chi_tra_vert.traineddata
电信塔施工方案.doc
04-27
5G通信行业、网络优化、通信工程建设资料。
29-【智慧城市与政府治理分会场】10亿大数据助推都市治理-30页.pdf
04-27
29-【智慧城市与政府治理分会场】10亿大数据助推都市治理-30页.pdf
ABB IRC5 Compact 机器人产品手册
04-27
ABB IRC5 Compact 机器人产品手册
LTE容量优化高负荷小区优化指导书.docx
04-27
5G通信行业、网络优化、通信工程建设资料
施工工艺及质量检查记录表.docx
04-27
5G通信行业、网络优化、通信工程建设资料。
25G无源波分安装规范指导.docx
04-27
5G通信、网络优化与通信建设
基于Springboot+Vue在线宠物用品交易网站毕业源码案例设计.zip
04-27
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。系统化是必要的，设计网上系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于信息的维护和检索也不需要花费很多时间，非常的便利。 网上系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时，也能及时通过数据输入的有效性规则检测出错误数据，让数据的录入达到准确性的目的，进而提升数据的可靠性，让系统数据的错误率降至最低。 关键词：vue；MySQL；SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
通信各专业(管道、线路、设备)安全操作规程.docx
04-27
5G通信行业、网络优化、通信工程建设资料
node-v12.13.1-x86.msi
最新发布
04-27
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
100个python小技巧!
09-17
7. 使用字典可以进行键值对的映射。 8. 使用切片可以快速获取列表、字符串的子序列。 9. 使用函数可以封装可复用的代码块。 10. 使用类可以实现面向对象的编程。 11. 使用模块可以组织和管理代码。 12. 使用异常处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值