C++博客-Thinking in zmllegtui.-随笔分类-Algorithm & DS

Trie树

zml_cnnk — Tue, 28 Oct 2008 12:18:00 GMT

转载自http://epic.32o.cn/article.asp?id=47

今天在vijos有人问我trie树怎么弄。索性就写详细点，让众多新手参考一下。
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

abcabcabcdbdabcbabdbcabdbdbdbd.

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;
procedure 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]           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     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.

zml_cnnk 2008-10-28 20:18 发表评论

螺旋队列

zml_cnnk — Tue, 28 Oct 2008 11:58:00 GMT

// 问题

43 44 45 46 47 48 49

42 21 22 23 24 25 26

41 20 7 8 9 10 27

40 19 6 1 2 11 28

39 18 5 4 3 12 29

38 17 16 15 14 13 30

37 36 35 34 33 32 31

以上数字的排列规律，设1点的坐标是（0，0），x方向向右为正，y方向向下为正。例如，7的坐标为

(-1,-1)，2的坐标为（1，0），3的坐标为（1，1）。编程实现输入任意一点坐标（x,y），输出所对应的数字。

// 解答

右向x方向，下向y方向。从图中不难发现，右上角vc=(2*t+1)(2*t+1),t为该圈x,y绝对值的最大值。例如vc=9、25、49、81........，算出vc后，就分4个判断区域，分别判断点落在该圈4条边的哪条边上，直接使用if语句，利用x、y与t的关系，从而计算出具体坐标点的值。该问题，如果让中学生用自然语言来写伪代码，估计会很快。

zml_cnnk 2008-10-28 19:58 发表评论

Hash

zml_cnnk — Tue, 28 Oct 2008 06:44:00 GMT

摘要: Hashing定义了一种将字符组成的字符串转换为固定长度(一般是更短长度)的数值或索引值的方法，称为散列法，也叫哈希法。由于通过更短的哈希值比用原始值进行数据库搜索更快，这种方法一般用来在数据库中建立索引并进行搜索，同时还用在各种解密算法中。
设所有可能出现的关键字集合记为U(简称全集)。实际发生(即实际存储)的关键字集合记为K（|K|比|U|小得多）。|K|是集合K中元素的个数。
散列方法是使用函数hash将U映射到表T[0..m-1]的下标上（m=O(|U|)）。这样以U中关键字为自变量，以h为函数的运算结果就是相应结点的存储地址。从而达到在O(1)时间内就可完成查找。
……

阅读全文

zml_cnnk 2008-10-28 14:44 发表评论

Merge Sort

zml_cnnk — Tue, 28 Oct 2008 06:34:00 GMT

合并算法的核心操作就是将一维数组中前后相邻的两个两个有序序列合并成一个有序序列。合并算法也可以采用递归算法来实现，形式上较为简单,但实用性很差。

合并算法的合并次数是一个非常重要的量,根据计算当数组中有3到4个元素时,合并次数是2次,当有5到8个元素时,合并次数是3次,当有9到16个元素时,合并次数是4次，按照这一规律,当有N个子序列时可以推断出合并的次数是X(2 >=N,符合此条件的最小那个X)。

源程序：

program hebing;

const

n=10;

var

a:array[1..n] of integer;

i:integer;

procedure init;

var

i:integer;

begin

for i:=1 to n do read(a[i]);

readln;

end;

procedure merge(low,mid,high:integer);

var

h,i,j,k:integer;

b:array[1..n] of integer;

begin

h:=low; i:=low; j:=mid+1;

while (h<=mid) and (j<=high) do

begin

if (a[h]<=a[j]) then

begin

b[i]:=a[h]; h:=h+1;

end

else

begin

b[i]:=a[j]; j:=j+1;

end;

i:=i+1;

end;

if h>mid then

for k:=j to high do

begin

b[i]:=a[k]; i:=i+1;

end

else

for k:=h to mid do

begin

b[i]:=a[k]; i:=i+1;

end;

for k:=low to high do

a[k]:=b[k];

end;

procedure mergesort(low,high:integer);

var

mid:integer;

begin

if low

begin

mid:=(low+high) div 2;

mergesort(low,mid);

mergesort(mid+1,high);

merge(low,mid,high);

end;

zml_cnnk 2008-10-28 14:34 发表评论

质数判断算法

zml_cnnk — Sun, 26 Oct 2008 03:52:00 GMT

摘要: 有人做过这样的验算：1^2+1+41=43,2^2+2+41=47,3^2+3+41=53……于是就可以有这样一个公式：设一正数为n，则n^2+n+41的值一定是一个质数。这个式子一直到n=39时，都是成立的。但n=40时，其式子就不成立了，因为40^2+40+41=1681=41*41。

研究发现质数除2以外都是奇数，而奇数除了【奇数*奇数】(或再加“*奇数”）都是质数。那么用计算机先把【奇数*奇数】(或再加“*奇数”）（比如9，15，21，25，27，33，35，39……）都求出来，再找奇数中上面没提到的那些数，那些数就是素数。

有近似公式： x 以内质数个数约等于 x / ln(x) .ln是自然对数的意思。准确的质数公式尚未给出。10 以内共 4 个质数。100 以内共 25 个质数。
……

阅读全文

zml_cnnk 2008-10-26 11:52 发表评论

计算二进制位"1"的个数

zml_cnnk — Sun, 26 Oct 2008 03:42:00 GMT

摘要: 写一个函数，返回数字中二进制位为'1'的个数。
方法1：分别判断各个位
方法2：循环中直接计算1的数量
方法3：并行计算的

PS：
这些方法是计算二进制形式1的个数，如果用来判断一个数是否是2的整数次幂，可以用这些方法，但是对此还有更好的方法，就是 A xor (A-1) == 0。

阅读全文

zml_cnnk 2008-10-26 11:42 发表评论

01背包问题的贪婪算法

zml_cnnk — Sun, 26 Oct 2008 03:32:00 GMT

摘要: 0/1背包问题有好几种贪婪策略，每个贪婪策略都采用多步过程来完成背包的装入，在每一步过程中利用贪婪准则选择一个物品装入背包。

1、从剩余的物品中，选出可以装入背包的价值最大的物品。利用这种规则，价值最大的物品首先被装入（假设有足够容量），然后是下一个价值最大的物品，如此继续下去。这种策略不能保证得到最优解。例如，n=2, weight=[100, 10, 10], prize=[20, 15, 15], count=105。当利用价值贪婪准则时，获得的解为x= [1, 0, 0]，这种方案的总价值为20。而最优解为[0, 1, 1]，其总价值为30。
……

阅读全文

zml_cnnk 2008-10-26 11:32 发表评论