-Flyぁ梦- » 字符串 http://blog.11034.org Sun, 22 Jun 2025 08:59:05 +0000 zh-CN hourly 1 https://wordpress.org/?v=4.2.38 整理下字符串的一些数据结构和算法 http://blog.11034.org/2012-12/string.html http://blog.11034.org/2012-12/string.html#comments Thu, 06 Dec 2012 13:27:52 +0000 http://blog.stariy.org/?p=1412 别看字符串挺简单，还真牵扯到好多数据结构和算法啊，给跪了，要将所有的都好好掌握真心是一项艰难的任务。这里就列举下自己做zoj时候碰到过的一些，然后配合自己做过的例题讲一下。不过每种算法、数据结构具体的描述和代码，还请自己去搜索吧。

算法

KMP算法

字符串在普通项目中用得最多的必然是匹配和查询问题了，KMP算法通过O(M)的时间预处理短串，然后在O(N)的时间内搜索长串得到结果，算是最经典的字符串匹配算法了，其中预处理字符串next数组的方法非常具有扩展性。KMP并不太容易懂，推荐百度搜索“Matrix67 KMP”这篇文章，比较好懂。自己写一遍KMP再配合着OJ做一些题，就有感觉了。

zoj 2177 Period : 由重复子串不重叠构成的所有前缀。这里用到了next函数的思想。

zoj 2177 Crack : int值的KMP。搜索到串后，再分别往前往后继续匹配，比较最大值。

zoj 3587 Marlon’s String : 串A和串B，求出A[i1, j1] + A[i2, j2] = B有多少种。KMP中每一次i与j的匹配都意味着一个前缀的匹配，后缀通过字符串反序同理前缀处理。

zoj 3643 Keep Deleting : KMP和栈的结合。

最小表示法

一个字符串按照字典序的最小表示序列。可以用来判断某些字符串是否循环同构。

一开始看懂了，最近又忘了，不过知道有这个算法，应用起来套进去好像比较容易。

zoj 1729 Hidden Password : 求字符串的最小表示位于原字符串的位置。

Manacher算法

用来求一个字符串中最长回文子串的算法，比用后缀数组的方案既快又节约内存。没怎么看懂，好像也就这么个用途，勉强记得有这个算法吧 =.=。

poj 3974 Palindrome : 求最长回文子串的长度。

栈处理

主要是字符串里的括号匹配的问题，很容易想到用栈。

zoj 1423 (Your)((Term)((Project))) : 删除多余的括号。

zoj 2483 Boolean Expressions : 计算布尔表达式的值。

zoj 2704 Brackets : 判断带圆括号和方括号的表达式是否正确。

数据结构

Trie树

这算是最简单的了，很容易看懂和应用的数据结构。用来查找某些字符串是否存在于一个字符串集合当中，查找花费O(N)的时间（这里用Java的HashMap和String自带的hashCode方法，也比较不错）。Trie树适合被搜索对象是一个word，搜索其是否整体匹配单词源集合某一个。

zoj 1109 Language of FatMouse : Trie树最基础应用

zoj 1888 Zipf’s Law : 查找一段文章中出现次数为N的单词。也是Trie树普通运用，最后选择遍历Trie树也可以，当然也可以优化下。

zoj 2346 Shortest Prefixes : N个串，将每个串缩短至最短的前缀串来唯一表示这个串，但在N个串中不能有冲突。

AC自动机 – Trie树升级版

AC自动机，就是在Trie树的基础上给每个节点加一个fail指针，类似KMP的next数组的感觉，每次匹配失败后可以继续向前匹配。为什么叫自动机呢，学过计算理论应该还是比较好理解的。AC自动机的建立，在Trie树已经建立后，加一步建立fail指针的过程，需要通过bfs遍历一遍Trie树。然后搜索的时候没匹配一个节点，都要依次循着fail指针向上查询直到root节点查找是表示为串结尾的节点，这些都是符合的情况。

AC自动机适合处理那些一长段文字中去寻找某些个单词的情况，即适合被搜索对象是一个长串，搜索其部分匹配单词源集合。

附上一份自己写的AC自动机的代码，Click here。

zoj 3228 Searching the String : 可重叠和不可重叠地去查询某个串存在的次数。

zoj 3430 Detect the Virus : Base64解码后再匹配。题目比较恶心…然后这里字符集有256个，包括’\0’，所以用insert(char *s, int len)比较好，然后很恶心的一点习惯写Java后才发现C++的char默认是signed的…这里要转换成unsigned char，不然OJ上就不断地SF了。

后缀树和后缀自动机

将一个字符串的所有后缀作为不同的串，插入到Trie树形成的树，同理再加上fail指针就是后缀自动机。后缀树和后缀自动机都是对一个长串进行某些处理，比如寻找某些子串、寻找最长回文子串、寻找两个串的某些共同属性（比如最长公共部分等）。但是后缀树算法和程序比较复杂，做题的时候好像很少用到，而是用较为简易的后缀数组的来代替。

后缀数组

后缀树的简化版本，用几个数组来记录后缀串的不同属性。网上流行的模板代码里，sa数组按字典顺序记录后缀的序号（ra[rk] = index），rank数组与sa数组互逆，按照后缀序号记录后缀的字典序大小（rank[index] = rk）。然后为了模拟后缀树，还有height数组，记录height[i] = LCP(ra[i – 1], ra[i])，LCP为Longest Common Prefix（最长公共前缀），即有了后缀树里的Least Common Ancestors（最近公共祖先）的意思。后缀数组开了这么多数组比较耗费内存，所以不适合字符串长度很长（超过一百万）的题目。

建立后缀数组，有两种比较复杂难懂的算法，倍增算法和DC3算法，前者O(NlogN)后者O(N)的复杂度，反正LZ看不懂也不会写用的也是网上找的模板。计算height值是O(N)的算法，也不懂。任意两个后缀的LCP值是它们sa值之间的height值的最小值，这里包含了一个RMQ（Range Minimum Query）问题。

后缀数组的详细可以看一下《后缀数组—处理字符串的有力工具》这篇高中生写的论文，膜拜…虽然觉得里面某些代码和题解有点问题，不过算法描述很详细很值得去读而理解。

附上一份网上找的蛮好用的后缀数组代码，Click here。

ural 1297 Palindrome : 求最长回文子串。poj也有类似一题但是数据量太大，可以用前面提到的Manacher算法求解。

zoj 2737 Occurrence : 求串B所有的循环同构串在串A中出现的次数和。解决循环的办法就是设B’ = B + B，S = B’ + ‘$’ + A，然后对S进行后缀数组处理。

zoj 3199 Longest Repeated Substring : 含有不可重叠且连续子串的子串。

zoj 3296 Connecting the Segments : 这道题真是牛逼了，结合了后缀数组、RMQ、贪心之最小区间覆盖，很经典很值得一练的题。后缀数组的作用并不是求出所有的回文子串（无法求出被真包含的回文子串，比如aabaa，aabaa本身是回文子串，其中真包含的aba也是回文子串，aba就无法得到），但是不影响区间覆盖。

zoj 3395 Stammering Aliens : 可重叠子串多于k个。这里需要将height数组分组，很多后缀数组的题目都需要如此处理，原因就是上面提到的LCP取最小值。

学习后缀数组真心花了好多天，一开始只会按照套路和题解去套用后缀数组的方法解题，做了几个题目就慢慢理解后缀数组的意义所在，就能自己想办法去利用后缀数组了。不做题，不coding，理解不了，但是痛苦的是一段时间不做的话又会忘了，这个怎么破 T_T。

——————————-to be continued——————————

 

看看 字符串 , 树

看看 ACM , 数据结构和算法

  • 2013-05-27 -- java.util中几个Map的性能测试
  • 2013-05-07 -- 判断矩形是否重叠
  • 2013-01-15 -- 背包练习小集合
  • 2012-12-06 -- 一套可用的后缀数组代码
  • 2012-12-06 -- 一个OOP的AC自动机代码
    • ]]> http://blog.11034.org/2012-12/string.html/feed 3 一套可用的后缀数组代码 http://blog.11034.org/2012-12/suffix_array.html http://blog.11034.org/2012-12/suffix_array.html#comments Thu, 06 Dec 2012 13:14:53 +0000 http://blog.stariy.org/?p=1420 后缀数组的代码算法难度比较高，反正没怎么看也不打算看懂，从网上找了好久找到一份比较好用的代码，效率也比较高，据说是用的倍增算法？看不懂 =.= 

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

    // r : 为字符串转化成的int数组, 0 - len-1 为源字符串, r[len] = 0
// sa : 1 - len有效, 值从0到len-1表示后缀序号
// rank : 0 - len-1有效, 值从1到len表示后缀字典序大小
// height : 2 - len有效, height[i] 为 sa[i]和sa[i-1]的LCP值
 
// da : n为字符串长度+1, m为字符集大小（用于基数排序）
// calh : n为字符串长度
 
#define MAX 40010
int height[MAX],rank[MAX],r[MAX],sa[MAX];
int ts[MAX],ta[MAX],tb[MAX],tv[MAX],pos;
bool cmp(int *y,int a,int b,int l){
    return y[a]==y[b]&&y[a+l]==y[b+l];
}
//计算sa和rank数组
void da(int n,int m){
    int i,j,*x=ta,*y=tb,p;
    for(i=0;i<m;i++) ts[i]=0;
    for(i=0;i<n;i++) ts[x[i]=r[i]]++;
    for(i=1;i<m;i++) ts[i]+=ts[i-1];
    for(i=n-1;i>=0;i--) sa[--ts[x[i]]]=i;
    for(j=1,p=1;p<n;j*=2,m=p){
        p=0;
        for(i=n-j;i<n;i++) y[p++]=i;
        for(i=0;i<n;i++) if(sa[i]>=j) y[p++]=sa[i]-j;
        for(i=0;i<m;i++) ts[i]=0;
        for(i=0;i<n;i++) tv[i]=x[y[i]];
        for(i=0;i<n;i++) ts[tv[i]]++;
        for(i=1;i<m;i++) ts[i]+=ts[i-1];
        for(i=n-1;i>=0;i--) sa[--ts[tv[i]]]=y[i];
        swap(x,y);
        x[sa[0]]=0;
        p=1;
        for(i=1;i<n;i++){
            if(cmp(y,sa[i-1],sa[i],j)) x[sa[i]]=p-1;
            else x[sa[i]]=p++;
        }
    }
}
//计算height数组
void calh(int n){
    int i,k,tmp;
    for(i=1;i<=n;i++) rank[sa[i]]=i;
    k=0;
    for(i=0;i<n;i++){
        tmp=sa[rank[i]-1];
        for(;r[i+k]==r[tmp+k];k++) ;
        height[rank[i]]=k;
        k?--k:0;
    }
}
 
 
int main(){
	int N, len;
	char line[MAX];
	while(scanf("%d", &N) != EOF && N > 0){
		getchar();
		gets(line);
		len = strlen(line);
		for(int i = 0;i < len;i++) r[i] = line[i] - 'a' + 1;	// 须保证r数组的值都 > 0
		r[len] = 0;
		da(len + 1, 27); // 27表示所有r数组内的值必须小于这个值, r从1到26 (基数排序)
		calh(len);
	}
}

    看看 字符串

    看看 数据结构和算法

    • 2013-05-27 -- java.util中几个Map的性能测试
    • 2013-05-07 -- 判断矩形是否重叠
    • 2013-01-15 -- 背包练习小集合
    • 2012-12-06 -- 整理下字符串的一些数据结构和算法
    • 2012-12-06 -- 一个OOP的AC自动机代码
      • ]]> http://blog.11034.org/2012-12/suffix_array.html/feed 5 一个OOP的AC自动机代码 http://blog.11034.org/2012-12/ac_automachine.html http://blog.11034.org/2012-12/ac_automachine.html#comments Thu, 06 Dec 2012 12:56:18 +0000 http://blog.stariy.org/?p=1416 网上代码很多，但是大多ACMer的风格，呃不是我说，代码可读性和封装性是比较欠缺的…也许Java出身的码农也就这点还有些优势了吧…纯自己手动敲的，build_ac函数（建立fail指针的过程）学习了网上的教程后模仿着写的，而且带clear()释放内存。

      AC自动机基于Trie树，Trie树基于字符表，宏定义SIZE表明字符集大小，宏定义MINCHAR表明字符集中最小的字符，这里的定义只适合26个英文小写字母。

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

      #define SIZE 26
#define MINCHAR ('a')
struct TrieNode{
	int tail;		//表明此节点为某一字符串结尾
	TrieNode* fail;		//失败指针
	TrieNode* nodes[SIZE];	//节点指针的数组
	TrieNode(){
		for(int i = 0;i < SIZE;i++) nodes[i] = NULL;
		tail = 0, fail = NULL;
	}
	void clear(){
		for(int i = 0;i < SIZE;i++){
			if(nodes[i] != NULL){
				nodes[i]->clear();
				delete nodes[i];
				nodes[i] = NULL;
			}
		}
	}
};
struct Trie{
	TrieNode* root;
 
	Trie(){ root = new TrieNode(); }
 
	//清空Trie树，释放内存
	void clear(){ root->clear(); }
 
	//插入一个字符串
	void insert(char *s, int len){
		TrieNode* N = root;
		int idx;
		for(int i = 0;i < len;i++){
			idx = (unsigned char)s[i] - MINCHAR;
			if(N->nodes[idx] == NULL){
				N->nodes[idx] = new TrieNode();
			}
			N = N->nodes[idx];
		}
		N->tail = 1;
	}
 
	//插入字符串完毕后，建立fail指针
	void build_ac(){
		queue<TrieNode*> q;
		TrieNode *nd, *child, *pt;
		root->fail = NULL;
		q.push(root);
		while(!q.empty()){
			nd = q.front();
			q.pop();
			pt = NULL;
			for(int i = 0;i < SIZE;i++){
				child = nd->nodes[i];
				if(child != NULL){
					if(nd == root) child->fail = root;
					else{
						pt = nd->fail;
						while(pt != NULL){
							if(pt->nodes[i] != NULL){
								child->fail = pt->nodes[i];
								break;
							}
							pt = pt->fail;
						}
						if(pt == NULL) child->fail = root;
					}
					q.push(child);
				}
			}
		}
	}
 
	//建立fail指针完毕后，在指定的字符串文本数据中来搜索匹配串
	void process(char *s, int len){
		TrieNode *nd = root, *nd2;
		int idx;
		for(int i = 0;i < len;i++){
			idx = (unsigned char)s[i] - MINCHAR;
			while(nd != root && nd->nodes[idx] == NULL) nd = nd->fail;
			if(nd->nodes[idx] != NULL) {
				nd = nd->nodes[idx];
				nd2 = nd;
				while(nd2 != root){
					if(nd2->tail == 1){
						//找到一个匹配
					}
					nd2 = nd2->fail;
				}
			}
		}
	}
};

      看看 oop , 字符串 , 树

      看看 数据结构和算法

      • 2013-05-27 -- java.util中几个Map的性能测试
      • 2013-05-07 -- 判断矩形是否重叠
      • 2013-01-15 -- 背包练习小集合
      • 2012-12-06 -- 整理下字符串的一些数据结构和算法
      • 2012-12-06 -- 一套可用的后缀数组代码
        • ]]> http://blog.11034.org/2012-12/ac_automachine.html/feed 1 敏感词过滤，PHP实现的Trie树 http://blog.11034.org/2012-07/trie_in_php.html http://blog.11034.org/2012-07/trie_in_php.html#comments Tue, 03 Jul 2012 14:43:25 +0000 http://blog.stariy.org/?p=1174 项目需求，要做敏感词过滤，对于敏感词本身就是一个CRUD的模块很简单，比较麻烦的就是对各种输入的敏感词检测了。用Trie树来实现是比较通用的一种办法吧，之前一直没机会用过这种数据结构，正好试着写了一下。

        因为用PHP实现，关联数组用的很舒服。第一个要解决的是字符集的问题，如果在Java中就比较好办统一的Unicode，在PHP中因为常用UTF-8字符集，默认有1-4个字节不同的长度来表示一个字符，于是写了个Util类来将普通的UTF-8字符串转换成字符数组，每一个元素是一个UTF-8串形成的字符。这一点比较容易实现的，根据UTF-8字符集的格式而来就好。

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

        public static function get_chars($utf8_str){
	$s = $utf8_str;
	$len = strlen($s);
	if($len == 0) return array();
	$chars = array();
	for($i = 0;$i < $len;$i++){
		$c = $s[$i];
		$n = ord($c);
		if(($n >> 7) == 0){		//0xxx xxxx, asci, single
			$chars[] = $c;
		}
		else if(($n >> 4) == 15){ 	//1111 xxxx, first in four char
			if($i < $len - 3){
				$chars[] = $c.$s[$i + 1].$s[$i + 2].$s[$i + 3];
				$i += 3;
			}
		}
		else if(($n >> 5) == 7){ 	//111x xxxx, first in three char
			if($i < $len - 2){
				$chars[] = $c.$s[$i + 1].$s[$i + 2];
				$i += 2;
			}
		}
		else if(($n >> 6) == 3){ 	//11xx xxxx, first in two char
			if($i < $len - 1){
				$chars[] = $c.$s[$i + 1];
				$i++;
			}
		}
	}
	return $chars;
}

        字符单位确认以后，就是写Trie树了。简单的算法，从根路径开始给每个字符建一个关联数组，当字符串结束的时候，用一个null表示结尾。

        删除一个串，只要找到串中任意一个字符的子元素数量为1，就表示只有这个串了，整个删除就好了；若子元素数量大于1，则继续根据字符找下去，直到末尾的null。

        查找一个串（完全匹配），一直根据字符找到null为止就表明存在，任一字符不存在就表明串不存在。

        验证一个长串是否含有任一串，这边算法比较挫，按照每个字符开始都在Trie树种搜索一遍，走的回头路比较多，复杂度有O(n * m)，n为长串长度，m为Trie树深度，不过因为中文Trie树深度很浅，勉强还过得去（英文字符串深度很长）。

        然后因为PHP没有全局缓存的机制，每次都要从数据库中读取全部的敏感词，然后建立Trie树再去匹配串的话太麻烦了，采取的办法是将Trie内部的关联数组序列化后直接保存在数据库中，每次只要读取这条数据，然后反序列化，Trie树就回来了。当然进行串的插入和删除，将更新这个序列化数据。

        可改进的地方：

        1. 当某一条路径只有这个串即关联数组数量为1时，可以压缩子树
        2. 改进Trie树为AC自动机，即每个节点都添加一个失败指针，指向匹配失败后回到树的哪个节点，这样就仅仅是O(n)的复杂度了。建树的过程比较复杂，对每个插入的串的子串进行处理，运行时查询的效率非常高

        贴代码：

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

        class TrieTree{
 
	public $tree = array();
 
	public function insert($utf8_str){
		$chars = &UTF8Util::get_chars($utf8_str);
		$chars[] = null;	//串结尾字符
		$count = count($chars);
		$T = &$this->tree;
		for($i = 0;$i < $count;$i++){
			$c = $chars[$i];
			if(!array_key_exists($c, $T)){
				$T[$c] = array();	//插入新字符，关联数组
			}
			$T = &$T[$c];
		}
	}
 
	public function remove($utf8_str){
		$chars = &UTF8Util::get_chars($utf8_str);
		$chars[] = null;
		if($this->_find($chars)){	//先保证此串在树中
			$chars[] = null;
			$count = count($chars);
			$T = &$this->tree;
			for($i = 0;$i < $count;$i++){
				$c = $chars[$i];
				if(count($T[$c]) == 1){		//表明仅有此串
					unset($T[$c]);
					return;
				}
				$T = &$T[$c];
			}
		}
	}
 
	private function _find(&$chars){
		$count = count($chars);
		$T = &$this->tree;
		for($i = 0;$i < $count;$i++){
			$c = $chars[$i];
			if(!array_key_exists($c, $T)){
				return false;
			}
			$T = &$T[$c];
		}
		return true;
	}
 
	public function find($utf8_str){
		$chars = &UTF8Util::get_chars($utf8_str);
		$chars[] = null;
		return $this->_find($chars);
	}
 
	public function contain($utf8_str, $do_count = 0){
		$chars = &UTF8Util::get_chars($utf8_str);
		$chars[] = null;
		$len = count($chars);
		$Tree = &$this->tree;
		$count = 0;
		for($i = 0;$i < $len;$i++){
			$c = $chars[$i];
			if(array_key_exists($c, $Tree)){	//起始字符匹配
				$T = &$Tree[$c];
				for($j = $i + 1;$j < $len;$j++){
					$c = $chars[$j];
					if(array_key_exists(null, $T)){
						if($do_count){
							$count++;
						}
						else{
							return true;
						}
					}
					if(!array_key_exists($c, $T)){
						break;
					}
					$T = &$T[$c];
				}
			}
		}
		if($do_count){
			return $count;
		}
		else{
			return false;
		}
	}
 
	public function contain_all($str_array){
		foreach($str_array as $str){
			if($this->contain($str)){
				return true;
			}
		}
		return false;
	}
 
	public function export(){
		return serialize($this->tree);
	}
 
	public function import($str){
		$this->tree = unserialize($str);
	}
 
}

        看看 Trie , UTF-8 , 字符串 , 数据结构

        看看 PHP