照葫芦画瓢的第一个后缀数组……

最新推荐文章于 2024-08-18 21:04:25 发布
最新推荐文章于 2024-08-18 21:04:25 发布
阅读量58 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ronaflx/archive/2011/07/20/2111829.html
版权
看了一上午看明白了后缀数组的DA构造方法，自己模拟写了一个，发现了一点问题
我的模板
ContractedBlock.gif ExpandedBlockStart.gif POJ 2774 
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <algorithm>
 4 #include <cstring>
 5 using namespace std;
 6 const int MAXN = 210000;
 7 struct Sfx
 8 {
 9     int i;
10     int key[2];
11     bool operator < (const Sfx& s) const
12     {
13         if(key[0] == s.key[0])
14             return key[1] < s.key[1];
15         return key[0] < s.key[0] ;
16     }
17 } sfxArray[MAXN], temp[MAXN];
18 int rank[MAXN], bucket[MAXN], height[MAXN];// rank from 0 to n - 1
19 //基数排序，先拍第二关键字，再第一关键字
20 void radixSort(Sfx* in, int n, int idx, Sfx* out)
21 {
22     memset(bucket, 0, sizeof(int) * (n + 1));
23     for (int i = 0; i < n; i++)
24         bucket[in[i].key[idx]]++;
25     for (int i = 1; i <= n; i++)
26         bucket[i] += bucket[i - 1];
27     for (int i = n - 1; i >= 0; i--)//for down
28         out[--bucket[in[i].key[idx]]] = in[i];
29 }
30 void buildSA(char* text, int n)
31 {
32     for (int i = 0; i < n; i++)
33     {
34         sfxArray[i].i = sfxArray[i].key[1] = i;
35         sfxArray[i].key[0] = text[i];
36     }
37     sort(sfxArray, sfxArray + n);
38     //radixSort(sfxArray, n, 1, temp);
39     //radixSort(sfxArray, n, 0, temp);
40     for (int i = 0; i < n; i++)//下面要比较，所以全变为0
41         sfxArray[i].key[1] = 0;
42     int wid = 1;
43     while (wid < n)
44     {
45         rank[sfxArray[0].i] = 0;
46         for (int i = 1; i < n; i++)
47             rank[sfxArray[i].i] = rank[sfxArray[i - 1].i] + (sfxArray[i - 1] < sfxArray[i]);
48         for (int i = 0; i < n; i++)
49         {
50             sfxArray[i].i = i;
51             sfxArray[i].key[0] = rank[i];
52             sfxArray[i].key[1] = i + wid < n ? rank[i + wid]: 0;
53         }
54         radixSort(sfxArray, n, 1, temp);
55         radixSort(temp, n, 0, sfxArray);
56         wid <<= 1;
57     }
58 }
59 void calHeight(char* text, int* rank, int n)
60 {//h[i] = height[rank[i]], h[i] >= h[i - 1] - 1;
61     for(int i = 0;i < n;i++)
62         rank[sfxArray[i].i] = i;
63     for(int i = 0, k = 0, j; i < n; i++)
64     {
65         if (rank[i] == 0)
66             height[rank[i]] = 0;
67         else
68         {
69             if(k > 0) k-- ;
70             for (j = sfxArray[rank[i] - 1].i; text[i + k] == text[j + k];k++);//+1 -1
71             height[rank[i]] = k;
72         }
73     }
74 }
75 char str1[MAXN], str2[MAXN];
76 int main()
77 {
78     scanf("%s %s", str1, str2);
79     int len1 = strlen(str1);
80     int len2 = strlen(str2);
81     int n = len1 + len2 + 1;
82     str1[len1] = '$', str1[len1 + 1] = 0;
83     strcat(str1, str2);
84     buildSA(str1, n);
85     calHeight(str1, rank, n);
86     int ans = 0;
87     for(int i = 1;i < n;i++)
88     {
89         if((sfxArray[i].i < len1 && sfxArray[i - 1].i > len1) ||
90            (sfxArray[i].i > len1 && sfxArray[i - 1].i < len1))
91             ans = max(ans, height[i]);
92     }
93     printf("%d\n", ans);
94     return 0;
95 }

膜拜注释的地方我感觉用radixSort代替sort是完全可以的，但是却不行，请过路过的大牛指点一下。

这题还有一个trick就是最后的h[i]一定要保证 sa[i].i 和sa[i - 1].i 不在同一个字符串里，纠结了很长时间google一下别人的代码……鄙视自己。

有时间详细写一下我对后缀数组的理解吧，抓紧多做几道题先！

ContractedBlock.gif ExpandedBlockStart.gif 男人八题之后缀数组 
  1 /*
  2  * =====================================================================================
  3  *
  4  *       Filename:  DA.cpp
  5  *
  6  *    Description:
  7  *
  8  *        Version:  1.0
  9  *        Created:  2011/7/20 19:26:09
 10  *       Revision:  none
 11  *       Compiler:  gcc
 12  *
 13  *         Author:  ronaflx 
 14  *        Company:  hit-acm-group
 15  *
 16  * =====================================================================================
 17  */
 18 #include <iostream>
 19 #include <cstdio>
 20 #include <cstring>
 21 #include <cstdlib>
 22 #include <algorithm>
 23 #include <numeric>
 24 #include <iterator>
 25 using namespace std;
 26 const int MAXN = 210000;
 27 
 28 struct Sfx
 29 {
 30     int i;
 31     int key[2];
 32     bool operator < (const Sfx& s) const
 33     {
 34         if(key[0] == s.key[0])
 35             return key[1] < s.key[1];
 36         return key[0] < s.key[0] ;
 37     }
 38 } sfxArray[MAXN], temp[MAXN];
 39 int rank[MAXN], bucket[MAXN], height[MAXN], h[MAXN];// rank from 0 to n - 1
 40 //基数排序，先拍第二关键字，再第一关键字
 41 void radixSort(Sfx* in, int n, int idx, Sfx* out)
 42 {
 43     memset(bucket, 0, sizeof(int) * (n + 1));
 44     for (int i = 0; i < n; i++)
 45         bucket[in[i].key[idx]]++;
 46     for (int i = 1; i <= n; i++)
 47         bucket[i] += bucket[i - 1];
 48     for (int i = n - 1; i >= 0; i--)//for down
 49         out[--bucket[in[i].key[idx]]] = in[i];
 50 }
 51 void buildSA(int* text, int n)
 52 {
 53     for (int i = 0; i < n; i++)
 54     {
 55         sfxArray[i].i = sfxArray[i].key[1] = i;
 56         sfxArray[i].key[0] = text[i];
 57     }
 58     sort(sfxArray, sfxArray + n);
 59     for (int i = 0; i < n; i++)//下面要比较，所以全变为0
 60         sfxArray[i].key[1] = 0;
 61     int wid = 1;
 62     while (wid < n)
 63     {
 64         rank[sfxArray[0].i] = 0;
 65         for (int i = 1; i < n; i++)
 66             rank[sfxArray[i].i] = rank[sfxArray[i - 1].i] + (sfxArray[i - 1] < sfxArray[i]);
 67         for (int i = 0; i < n; i++)
 68         {
 69             sfxArray[i].i = i;
 70             sfxArray[i].key[0] = rank[i];
 71             sfxArray[i].key[1] = i + wid < n ? rank[i + wid]: 0;
 72         }
 73         radixSort(sfxArray, n, 1, temp);
 74         radixSort(temp, n, 0, sfxArray);
 75         wid <<= 1;
 76     }
 77 }
 78 void calHeight(int* text, int* rank, int n)
 79 {//h[i] = height[rank[i]], h[i] >= h[i - 1] - 1;
 80     for(int i = 0;i < n;i++)
 81         rank[sfxArray[i].i] = i;
 82     for(int i = 0, k = 0, j; i < n; i++)
 83     {
 84         if (rank[i] == 0)
 85             height[rank[i]] = 0;
 86         else
 87         {
 88             if(k > 0) k-- ;
 89             for (j = sfxArray[rank[i] - 1].i; text[i + k] == text[j + k];k++);
 90             height[rank[i]] = k;
 91         }
 92     }
 93 }
 94 
 95 int num[MAXN], tmp[MAXN];
 96 
 97 
 98 bool judge(int n, int k)
 99 {
100     int minn = sfxArray[0].i, maxn = sfxArray[0].i;
101     for(int i = 1;i < n;i++)
102     {
103         if(height[i] < k) minn = maxn = sfxArray[i].i;
104         else
105         {
106             minn = min(minn, sfxArray[i].i);
107             maxn = max(maxn, sfxArray[i].i);
108         }
109         if(maxn - minn > k) return true;
110     }
111     return false;
112 }
113 
114 
115 int binary_search(int low, int high, int n)
116 {
117     int reach = 0;
118     while(low <= high)
119     {
120         int mid = (low + high) / 2;
121         if(judge(n, mid))
122         {
123             reach = mid;
124             low = mid + 1;
125         }
126         else high = mid - 1;
127     }
128     return reach;
129 }
130 int main()
131 {
132     int n;
133     while(scanf("%d", &n) == 1 && n)
134     {
135         for(int i = 0;i < n;i++)
136             scanf("%d", &num[i]);
137         adjacent_difference(num, num + n, tmp);
138         transform(tmp, tmp + n, num, bind2nd(minus<int>(), *min_element(tmp, tmp + n) - 1));
139         num[n] = 0;
140         buildSA(num, n);
141         calHeight(num, rank, n);
142         int ans = binary_search(1, n / 2, n) + 1;
143         printf("%d\n", ans >= 5 ? ans : 0);
144     }
145     return 0;
146 }

PS.此题网上的大多数程序貌似都有问题，如下数据

11

1 2 3 4 5 6 7 8 9 10 11　　

答案是5

具体的算法参考09罗某后缀数组论文中的分析，后缀数组height的性质NB呀！！无限仰慕此数据结构。接下来的任务是继续学习后缀数组。然后复习图论网络流以及DP，开学前再看几何！

07.27更新

最长回文串

ContractedBlock.gif ExpandedBlockStart.gif ural 1297 
  1 /*
  2  * =====================================================================================
  3  *
  4  *       Filename:  suffixArray.cpp
  5  *
  6  *    Description:  
  7  *
  8  *        Version:  1.0
  9  *        Created:  2011年07月27日 13时31分08秒
 10  *       Revision:  none
 11  *       Compiler:  gcc
 12  *
 13  *         Author:  ronaflx 
 14  *        Company:  hit-ACM-Group
 15  *
 16  * =====================================================================================
 17  */
 18 
 19 #include <cstdlib>
 20 #include <cctype>
 21 #include <cstring>
 22 #include <cstdio>
 23 #include <cmath>
 24 #include <ctime>
 25 #include <climits>
 26 #include <algorithm>
 27 #include <functional>
 28 #include <numeric>
 29 #include <vector>
 30 #include <map>
 31 #include <set>
 32 #include <queue>
 33 #include <stack>
 34 #include <bitset>
 35 #include <list>
 36 #include <string>
 37 #include <iostream>
 38 #include <sstream>
 39 #include <fstream>
 40 #include <iomanip>
 41 #include <stdexcept>
 42 #include <utility>
 43 #include <cassert>
 44 #include <complex>
 45 using namespace std;
 46 #define LEFT(i) ((i) << 1)
 47 #define RIGHT(i) (((i) << 1) | 1)
 48 #define MID(i) ((l[i] + r[i]) >> 1)
 49 #define CC(i, v) memset(i, v, sizeof(i))
 50 #define REP(i, l, n) for(int i = l;i < int(n);++i)
 51 #define FOREACH(con, i) for(__typeof(con.begin()) i = con.begin();i != con.end();++i)
 52 const int MAXN = 21000;
 53 
 54 struct Sfx
 55 {
 56     int i;
 57     int key[2];
 58     bool operator < (const Sfx& s) const
 59     {
 60         if(key[0] == s.key[0])
 61             return key[1] < s.key[1];
 62         return key[0] < s.key[0] ;
 63     }
 64 } sfxArray[MAXN], temp[MAXN];
 65 int __rank[MAXN], bucket[MAXN], height[MAXN], h[MAXN];// __rank from 0 to n - 1
 66 //基数排序，先拍第二关键字，再第一关键字
 67 void radixSort(Sfx* in, int n, int idx, Sfx* out)
 68 {
 69     memset(bucket, 0, sizeof(int) * (n + 1));
 70     for (int i = 0; i < n; i++)
 71         bucket[in[i].key[idx]]++;
 72     for (int i = 1; i <= n; i++)
 73         bucket[i] += bucket[i - 1];
 74     for (int i = n - 1; i >= 0; i--)//for down
 75         out[--bucket[in[i].key[idx]]] = in[i];
 76 }
 77 void buildSA(const char* text, int n)
 78 {
 79     for (int i = 0; i < n; i++)
 80     {
 81         sfxArray[i].i = sfxArray[i].key[1] = i;
 82         sfxArray[i].key[0] = text[i];
 83     }
 84     sort(sfxArray, sfxArray + n);
 85     for (int i = 0; i < n; i++)//下面要比较，所以全变为0
 86         sfxArray[i].key[1] = 0;
 87     int wid = 1;
 88     while (wid < n)
 89     {
 90         __rank[sfxArray[0].i] = 0;
 91         for (int i = 1; i < n; i++)
 92             __rank[sfxArray[i].i] = __rank[sfxArray[i - 1].i] + (sfxArray[i - 1] < sfxArray[i]);
 93         for (int i = 0; i < n; i++)
 94         {
 95             sfxArray[i].i = i;
 96             sfxArray[i].key[0] = __rank[i];
 97             sfxArray[i].key[1] = i + wid < n ? __rank[i + wid]: 0;
 98         }
 99         radixSort(sfxArray, n, 1, temp);
100         radixSort(temp, n, 0, sfxArray);
101         wid <<= 1;
102     }
103 }
104 void calHeight(const char* text, int* __rank, int n)
105 {//h[i] = height[__rank[i]], h[i] >= h[i - 1] - 1;
106     for(int i = 0;i < n;i++)
107         __rank[sfxArray[i].i] = i;
108     for(int i = 0, k = 0, j; i < n; i++)
109     {
110         if (__rank[i] == 0)
111             height[__rank[i]] = 0;
112         else
113         {
114             if(k > 0) k-- ;
115             for (j = sfxArray[__rank[i] - 1].i; text[i + k] == text[j + k];k++);
116             height[__rank[i]] = k;
117         }
118     }
119 }
120 int RMQ[MAXN][20];
121 void buildRMQ(int n, int* height)
122 {
123     for(int i = 1;i <= n;i++) RMQ[i][0] = height[i - 1];
124     for (int j = 1; j <= log(n + 0.00) / log(2.0); j++)
125         for (int i = 1; i + (1 << j) - 1 <= n; i++)
126             RMQ[i][j] = min(RMQ[i][j - 1], RMQ[i + (1 << (j - 1))][j - 1]);
127 }
128 int queryRMQ(int a, int b)
129 {
130     int len = log(b - a + 1.0) / log(2.0);
131     return min(RMQ[a][len], RMQ[b - (1 << len) + 1][len]);
132 }
133 int queryLCP(int a, int b)
134 {
135     a = __rank[a] + 1;
136     b = __rank[b] + 1;
137     if(a > b) swap(a, b);
138     return queryRMQ(a + 1, b);
139 }
140 int main()
141 {
142     string str;
143     while(cin >> str)
144     {
145         int n = str.size(), m = str.size();
146         string tmp = str;
147         reverse(tmp.begin(), tmp.end());
148         str = str + '#' + tmp;
149         n = (n << 1) + 1;
150         buildSA(str.data(), n);
151         calHeight(str.data(), __rank, n);
152         buildRMQ(n, height);
153         int ans = 0, idx;
154         for(int i = 0;i < m;i++)
155         {
156             int j = queryLCP(i, n - i);
157             if(i > 0 && j * 2 > ans)//偶数回文
158                 ans = j * 2, idx = i - j;
159             j = queryLCP(i, n - i - 1);
160             if(j * 2 - 1 > ans)//奇数回文
161                 ans = j * 2 - 1, idx = i - j + 1;
162         }
163         reverse(tmp.begin(), tmp.end());
164         printf("%s\n", tmp.substr(idx, ans).data());
165     }
166     return 0;
167 }

转载于:https://www.cnblogs.com/ronaflx/archive/2011/07/20/2111829.html

weixin_34390996
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常用气象格式的数据读取及可视化
03-12
介绍了气象研究(非业务使用)中的常用的数据格式，读写操作和数据可视化方法。
11.罗穗骞《后缀数组——处理字符串的有力工具》.zip
08-08
后缀数组是字符串处理中的一个重要概念，它在解决与字符串相关的问题时表现出强大的威力。罗穗骞的《后缀数组——处理字符串的有力工具》详细介绍了这一数据结构及其应用，包含算法源码和解题源码，对于学习者来说是...
NCL的示例1：常见符号的用法
热门推荐
网海水手
08-22 2万+
NCL的示例1： ; =================================================; ; LearnNCL1.ncl ; =================================================; load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl" ; ===
ncl与linux的关系,告别NCL，拥抱Python
weixin_36179933的博客
05-16 731
NCL官网发布重要通告，他们决定不再更新NCL转而向python发展。但做出这种选择确实也是有一定道理的，python在地球科学社区中的应用越来越广泛，很多优秀的团队还有大牛基于python开发出了不少地球科学相关的库。得益于这些优秀的库，近些年python在地球科学领域快速发展，并逐渐成为未来的趋势。现在python不但可以替代NCL而且还能提供很多NCL不具备的功能。NCL to Python...
Java后缀数组之求sa数组的实例代码
08-27
在上面的代码中，我们定义了几个数组来存储相关信息，包括原始字符串suffix、字符串长度n、排名数组rank、sa数组sa、height数组height、h数组h、计数排序辅助数组ws、第二关键字rank数组y和rank的辅助数组x。...
后缀数组——处理字符串的有力工具.pdf
08-10
后缀数组是一个整数数组，其中每个元素保存了一个特定后缀在原字符串中的起始位置，并且这些位置是经过排序的。 1.2 倍增算法 倍增算法是一种构造后缀数组的高效方法，其基本思想是在已有的后缀数组的基础上，通过...
后缀数组1
08-03
后缀数组是一种用于字符串处理的强大数据结构，它存储了一个字符串的所有后缀按字典序排序后的起始位置。在本文中，作者许智磊主要探讨了后缀数组的基本概念、构建算法以及其在模式匹配和寻找最长回文子串等问题上的...
string_structure.rar_后缀数组
09-22
在后缀数组中，字符串的所有后缀构成了一个有序数组，使得我们可以快速地进行字符串的比较和搜索操作。例如，对于字符串"ABCDCDC"，其后缀数组为["C", "DC", "CDC", "DCDC", "DCD", "CDE", "CDEA"]。后缀数组的构建...
机器学习（3）-- 一元线性回归
m0_74896766的博客
08-18 632
本篇介绍了如何实现一元线性回归，其中需要注意的是，对于相关系数过小的数据，我们要进行选择调整。
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 331
Java | Leetcode Java题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 335
C++ | Leetcode C++题解之第337题打家劫舍III
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 768
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
noip2001数的划分
no_play_no_games的博客
08-18 76
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
牛客竞赛数据结构专题班树状数组、线段树练习题
最新发布
Landing_on_Mars的博客
08-18 197
令 f[i][0/1] 表示从第 1 层的左边（0）或右边（1）到第 i 层的左边（0）或右边（1）的方案数。不能发现这个问题如果不带修改则可以用 dp+前缀和（矩阵乘法）解决，带修改则可以用线段树维护区间和。我们可以将每一层的转移状态用矩阵表示，
算法：DFS之记忆化搜索
一名还在努力学习技术的程序员的博客
08-18 456
本篇博客是关于 记忆化搜索 的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
数据结构与算法--图的应用
wumingzei的博客
08-15 698
普里姆 (Prim) 算法和克鲁斯卡尔 (Kruskal) 算法构造最小生成树的方法。狄杰斯特拉 (Dijkstra) 算法求解单源点最短路径。拓扑排序的应用。
【深度学习实战】利用Linear Regression预测房价
weixin_55939638的博客
08-15 815
我衷心希望这篇关于使用PyTorch进行线性回归模型训练的博客文章能够对您有所帮助。
汉诺塔 && 合并有序链表
FZC206的博客
08-17 104
【代码】汉诺塔 && 合并有序链表。
Redis合集 第一章 数据结构 第一节 String数据结构
weixin_64260010的博客
08-15 175
String 的分类 String 普通字符串 int 整数 可以做自增 自减 float 浮点类型 可以做自增 自减 注意： 底层都是用字节数组存储 只不过编码的方式不同 常用命令 set 新增或修改key的value get 得到key的value mset 设置多个键值对 mget 得到多个key的value incr 让一个int的key增加1 incrby 让一个int的key自增并指定步长 incrbyfloat 让一个浮点数的数字自增并指定步长 setnt 添加一个String类型的键值对
后缀数组构造与应用详解
"后缀数组是数据结构中一种用于高效处理字符串的重要工具，它将字符串的所有后缀按字典序排序并存储在一个数组中。后缀数组的构建涉及到字符串的比较和排序，通常有朴素算法、倍增算法等多种方法。在实际应用中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值