以太坊trie樹編碼

『壹』 c++ trie樹與指針

性質：
1.根節點不包含字元，除根節點外的每一個節點都只包含一個字元。
2.從根節點到某一節點，路徑上經過的字元連接起來，為該節點對應的字元串。
3.每個節點的所有子節點包含的字元都不相同。
優點：
1.查詢快。對於長度為m的鍵值，最壞情況下只需花費O(m)的時間；而BST需要O(m log n)的時間。
2.當存儲大量字元串時，Trie耗費的空間較少。因為鍵值並非顯式存儲的，而是與其他鍵值共享子串。
操作：
1.初始化或清空：遍歷Trie，刪除所有節點，只保留根節點。

『貳』 soweth為什麼常用到 而字典上有沒有這個詞

撒種 sow 的古英語拼寫

『叄』 TRIE 理論 是什麼

Trie又稱字典樹，是重要的數據結構，也是AC自動機的基礎，因此在這里簡單的說下什麼是字典數，並且列舉Trie上的操作。Trie的形式如下圖所示：

對於每一個節點，從根遍歷到他的過程就是一個單詞，如果這個節點被標記為紅色，就表示這個單詞存在，否則不存在。

那麼，對於一個單詞，我只要順著他從跟走到對應的節點，再看這個節點是否被標記為紅色就可以知道它是否出現過了。把這個節點標記為紅色，就相當於插入了這個單詞。

這樣一來我們詢問和插入可以一起完成，所用時間僅僅為單詞長度，在這一個樣例，便是10。

我們可以看到，trie樹每一層的節點數是26^i級別的。所以為了節省空間。我們用動態鏈表，或者用數組來模擬動態。空間的花費，不會超過單詞數×單詞長度。

基本性質可以歸納為：

1.根節點不包含字元，除根節點外每一個節點都只包含一個字元。

2.從根節點到某一節點，路徑上經過的字元連接起來，為該節點對應的字元串。

3.每個節點的所有子節點包含的字元都不相同。

我們可以動態存儲和靜態數組模擬，對於這兩種情況我們分別用POJ2001和POJ3630進行解釋！

『肆』 字典樹trie的時間復雜度是多少

又稱單詞查找樹，Trie樹，是一種樹形結構，是一種哈希樹的變種。典型應用是用於統計，排序和保存大量的字元串（但不僅限於字元串），所以經常被搜索引擎系統用於文本詞頻統計。

『伍』 trie樹 C語言

http://ke..com/view/1436495.htm 你看懂定義後就知道了。

『陸』 雙數組 Trie 的檢索速度比鏈式 Trie 快么

不考慮極端情況，一般情況下是的。在設計層面，鏈式trie中每一個節點用一個鏈表來管理它的下一級子節點，舉例來說，假設一顆trie中存儲了baby，badge，bachelar三個詞，其中存儲字元a的節點會有三個子節點分別存儲字元b，d，c，它們的指針都會存在鏈表中，當我們有查詢需求時，每次都要遍歷整個鏈表才能確定所要找的字元是不是存在，這個時間正比於鏈表的長度。而雙數組鏈表，在設計上保證了你去查詢下一個字元時可以一次操作找到。
實際上，常規trie樹中節點對下一級節點的管理方法分為兩種，鏈表式和數組式。鏈表的優點是空間利用率高，但是查詢速度慢，數組的優點是查詢速度快，但是空間利用率低。雙數組trie可以說兼顧了二者的優點，避免了二者的缺點，代價是：實現復雜。

『柒』 "Witnesseth" 此字用於買賣合約中, 請問是什麼意思 字典中查無此字. 謝了!

Save that the Holy Ghost in every city witnesseth to me, saying: That bands and afflictions wait for me at Jerusalem.
我只知道聖神在各城中向我指明說：有鎖鏈和患難在等待我。

Witness 目擊證人，目擊者，witnesseth 表示目擊的第三人稱單數的現在時
-eth基本釋義-eth1 [iθ]
suf.
[加於以母音y結尾的基數詞後，構成序數詞]:

-eth2 [iθ]
suf.
[古語、詩歌用語][附於動詞後，構成陳述語氣第三人稱單數現在時]:

『捌』 Python裡面用什麼trie樹實現模塊比較好

三種方法：
正則表達式，python中re模塊，python自帶；

pyquery，需另外安裝；
beautifulsoup，需另外安裝。
具體使用上，對於比較復雜的獲取，後兩者操作更方便，前者效率更高。

『玖』 Trie單詞查找樹 pascal 實現

Trie樹就是字元樹，其核心思想就是空間換時間。我以前用過的資料 網上關於這個字典樹的資料挺少的
給你100000個長度不超過10的單詞。對於每一個單詞，我們要判斷他出沒出現過，如果出現了，第一次出現第幾個位置。
這題當然可以用hash來，但是我要介紹的是trie樹。在某些方面它的用途更大。比如說對於某一個單詞，我要詢問它的前綴是否出現過。這樣hash就不好搞了，而用trie還是很簡單。
現在回到例子中，如果我們用最傻的方法，對於每一個單詞，我們都要去查找它前面的單詞中是否有它。那麼這個演算法的復雜度就是O(n^2)。顯然對於100000的范圍難以接受。現在我們換個思路想。假設我要查詢的單詞是abcd，那麼在他前面的單詞中，以b，c，d，f之類開頭的我顯然不必考慮。而只要找以a開頭的中是否存在abcd就可以了。同樣的，在以a開頭中的單詞中，我們只要考慮以b作為第二個字母的……這樣一個樹的模型就漸漸清晰了……
假設有b，abc，abd，bcd，abcd，efg，hii這6個單詞，我們構建的樹就是這樣的。

對於每一個節點，從根遍歷到他的過程就是一個單詞，如果這個節點被標記為紅色，就表示這個單詞存在，否則不存在。
那麼，對於一個單詞，我只要順著他從跟走到對應的節點，再看這個節點是否被標記為紅色就可以知道它是否出現過了。把這個節點標記為紅色，就相當於插入了這個單詞。
這樣一來我們詢問和插入可以一起完成，所用時間僅僅為單詞長度，在這一個樣例，便是10。
我們可以看到，trie樹每一層的節點數是26^i級別的。所以為了節省空間。我們用動態鏈表，或者用數組來模擬動態。空間的花費，不會超過單詞數×單詞長度。
程序非常好實現，區區幾行，我就不寫了，自己琢磨吧。
如果還是不懂請留言。

下面提供一個查找單詞是否在給定的字典中的標程：
program trie;
type
rec=record
Got:boolean;
next:array['a'..'z'] of Longint;
end;
var
n,i,j,Now,Tn:Longint;
s:string;
T:array[1..1000] of rec;
flag:boolean;
begin
Readln(n);
Tn:=1;
T[1].Got:=False;
fillchar(T[1].next,sizeof(T[1].next),0);
for i:=1 to n do
begin
readln(s);
Now:=1;
for j:=1 to length(s) do
if T[now].Next[s[j]]<>0 then now:=t[now].next[s[j]] else
begin
Inc(Tn);
T[tn].Got:=false;
fillchar(T[tn].next,sizeof(T[tn].next),0);
T[Now].next[s[j]]:=Tn;
Now:=Tn;
end;
T[now].Got:=true;
end;
readln(s);
while s<>'exit' do
begin
Now:=1;flag:=true;
for j:=1 to length(s) do
if T[now].Next[s[j]]<>0 then now:=t[now].next[s[j]] else
begin
flag:=false;
break;
end;
if flag then
if T[now].Got=false then flag:=false;
if flag then writeln('the word is in the tree') else
writeln('can''t find it!');
Readln(s);
end;
end.

一個單詞前綴樹的題，但是我卻用trie樹+bm演算法簡化版做的

密碼破譯
【問題描述】
由於最近功課過於繁忙，Tim竟然忘記了自己電腦的密碼，幸運的是Tim在設計電腦密碼的時候，用了一個非常特殊的方法記錄下了密碼。這個方法是：Tim把密碼和其它的一些假密碼共同記錄在了一個本子上面。為了能夠從這些字元串中找出正確的密碼，Tim又在另外一個本子上面寫了一個很長的字元串，而正確的密碼就是在這個字元串中出現次數最多的一個密碼。例如串ababa，假若密碼是abab和aba，那麼正確的密碼是aba，因為aba在這個字元串中出現了2次。
現在你得到了Tim的這兩個本子，希望你能夠編寫一個程序幫助Tim找出正確的密碼。
【輸入】
輸入由兩個部分組成。其中第一部分由若干行組成，每一行記錄了一個密碼，密碼的均長度小於等於255位，並且都由小寫字母組成。然後一個空行，第二部分記錄了一個很長的字元串，並且以』.』結束，其中只包含了小寫字母。

【輸出】
輸出文件名為Pass.out。輸出文件由僅有一行，為一個整數，表示正確密碼在字元串中出現的次數。如果這個出現次數為0，輸出「No find」。

【樣例】：
Pass.in Pass.out
ab 6
abc
bdc
abcd

.

program pass;
const
filein='pass.in';
fileout='pass.out';
type
rec=record
which:Longint;
Next:array['a'..'z'] of Longint;
end;
var
o,now,i,Tn,Dn,temp,Ans:Longint;
s:string;
c:char;
T:array[1..1000000] of REc;
data:array[1..5000] of string;
dLong:array[1..5000] of longint;
use:array[1..5000] of boolean;
d:array[1..3000000] of char;
Appear:array['a'..'z'] of Longint;
Long:Longint;
f:boolean;
function Compare(x:Longint):Longint;
var
s,i,Now,L,temp:Longint;
begin
s:=0;
fillchar(appear,sizeof(appear),0);
L:=length(data[x]);
for i:=1 to L do
Appear[data[x][i]]:=i;
Now:=L;
while NOw<=Long do
begin
if D[now]<>data[x][L] then Inc(now,L-Appear[D[now]]) else
begin
temp:=L-1;
while (temp>0) and (Data[x][temp]=d[Now-(L-temp)]) do dec(temp);
if temp=0 then Inc(s);
Inc(Now);
end;
end;
Compare:=S;
end;
procere sort(l,r:Longint);
var
i,j,x:Longint;
sy:string;
ly:Longint;
begin
i:=l;j:=r;x:=dLong[(l+r) div 2];
repeat
while dLong[i]<x do inc(i);
while dlong[j]>x do dec(j);
if i<=j then
begin
sy:=data[i];
data[i]:=data[j];
data[j]:=sy;
ly:=dlong[i];
dlong[i]:=dlong[j];
dlong[j]:=ly;
inc(i);
dec(j);
end;
until i>j;
if i<r then sort(i,r);
if j>l then sort(l,j);
end;
begin
fillchar(use,sizeof(use),true);
fillchar(t,sizeof(t),0);
Assign(input,filein);
Assign(output,fileout);
rewrite(output);
reset(input);
tn:=1;
readln(s);
Dn:=0;
while s<>'' do
begin
Inc(dn);
data[dn]:=s;
dLong[dn]:=length(s);
readln(s);
end;
sort(1,Dn);
for o:=1 to Dn do
begin
s:=data[o];
NOw:=1;
f:=true;
for i:=1 to Length(s) do
if t[now].Next[s[i]]<>0 then
begin
Now:=t[now].next[s[i]];
if t[now].which<>0 then
begin
f:=false;
break
end;
end else
begin
Inc(tn);
t[now].next[s[i]]:=tn;
now:=tn;
end;
if f then t[now].which:=o;
if not f then use[o]:=false;
end;
Long:=0;
repeat
read(c);
if c<>'.' then
begin
Inc(Long);
d[Long]:=c;
end;
until c='.';
for i:=1 to Dn do
begin
if use[i] then
begin
temp:=Compare(i);
if temp>ans then ans:=temp;
end;
end;
if ans=0 then writeln('No find') else
writeln(Ans);
close(input);
close(output);
end.

『拾』 ···Trie樹相對於C++的map有什麼優勢

快唄，復雜度的優勢