(整理)字符串处理.

五、字符串编辑距离

给定一个源字符串和目标字符串，能够对源串进行如下操作：

1.在给定位置上插入一个字符

2.替换任意字符

3.删除任意字符

求通过以上操作使得源字符串和目标字符串一致的最小操作步数。

简单描述一下解该题的思想，源字符串和目标字符串分别为str_a、str_b，二者的长度分别为la、lb，定义f[i,j]为子串str_a[0...i]和str_b[0...j]的最小编辑距离，简单分析可知求得的str_a[0...i]和str_b[0...j]的最小编辑距离有一下三种可能：

（1）去掉str_a[0...i]的最后一个字符跟str_b[0...j]匹配，则f[i, j]的值等于f[i-1, j]+1；（2）去掉str_b[0...j]的最后一个字符跟str_a[0...i]匹配，则f[i, j]的值等于f[i, j-1]+1；（3）去掉str_a[0...i]和str_b[0...j]的最后一个字符，让二者匹配求得f[i-1, j-1]，计算f[i, j]时要考虑当前字符是否相等，如果str_a[i]==str_b[j]说明该字符不用编辑，所以f[i, j]的值等于f[i-1, j-1]，如果str_a[i]!=str_b[j]说明该字符需要编辑一次（任意修改str_a[i]或者str_b[j]即可），所以f[i, j]的值等于f[i-1, j-1]+1。

因为题目要求的是最小的编辑距离，所以去上面上中情况中的最小值即可，因此可以得到递推公式：

f[i, j] = Min ( f[i-1, j]+1, f[i, j-1]+1, f[i-1, j-1]+(str_a[i]==str_b[j] ? 0 : 1) )

维基百科中的描述如下：

1）递归方法(用到动态规划)

由上述的递归公式可以有以下代码：

[cpp]view plaincopy

1.//求两个字符串的编辑距离问题

2.//递归版本，备忘录C[i,j]表示strA[i]...strA[size_A-1]与strB[j]...strB[size_B-1]

的编辑距离

3.int editDistance_mem(char *strA,int size_A,char *strB,int size_B){

4.int **C=new int*[size_A+1];

5.for(int i=0;i<=size_A;i++){

6. C[i]=new int[size_B+1]();

7. }

8.//初始化

9.for(int i=0;i<=size_A;i++){

10.for(int j=0;j<=size_B;j++)

11. C[i][j]=INT_MAX;

12. }

13.int res=EDM(C,strA,0,size_A-1,strB,0,size_B-1);

14.//free mem

15.for(int i=0;i<=size_A;i++){

16.delete [] C[i];

17. }

18.delete [] C;

19.return res;

20.}

21.int EDM(int **C,char *strA,int i,int A_end,char *strB,int j,int B_end){

22.if(C[i][j]

23.return C[i][j];

24.if(i>A_end){

25.if(j>B_end)

26. C[i][j]=0;

27.else

28. C[i][j]=B_end-j+1;

29. }else if(j>B_end){

30.if(i>A_end)

31. C[i][j]=0;

32.else

33. C[i][j]=A_end-i+1;

34. }

35.else if(strA[i]==strB[j])

36. C[i][j]=EDM(C,strA,i+1,A_end,strB,j+1,B_end);

37.else{

38.int a=EDM(C,strA,i+1,A_end,strB,j+1,B_end);

39.int b=EDM(C,strA,i,A_end,strB,j+1,B_end);

40.int c=EDM(C,strA,i+1,A_end,strB,j,B_end);

41. C[i][j]=min(a,b,c)+1;

42. }

43.return C[i][j];

44.}

2）矩阵标记法

递推方法（也可称为矩阵标记法），通过分析可知可以将f[i, j]的计算在一个二维矩阵中进行，上面的递推式实际上可以看做是矩阵单元的计算递推式，只要把矩阵填满了，f[la-1, lb-1]的值就是要求得最小编辑距离。代码如下：

[cpp]view plaincopy

1.//求两个字符串的编辑距离问题

2.//递推版本 C[i,j]表示strA[i]...strA[size_A-1]与strB[j]...strB[size_B-1]的编辑

距离

3.int editDistance_iter(char *strA,int size_A,char *strB,int size_B){

4.int **C=new int*[size_A+1];

5.for(int i=0;i<=size_A;i++){

6. C[i]=new int[size_B+1]();

7. }

8.for(int i=size_A;i>=0;i--){

9.for(int j=size_B;j>=0;j--){

10.if(i>size_A-1){

11.if(j>size_B-1)

12. C[i][j]=0;

13.else

14. C[i][j]=size_B-j;

15. }else if(j>size_B-1){

16.if(i>size_A-1)

17. C[i][j]=0;

18.else

19. C[i][j]=size_A-i;

20. }else if(strA[i]==strB[j])

21. C[i][j]=C[i+1][j+1];

22.else

23. C[i][j]=min(C[i+1][j+1],C[i+1][j],C[i][j+1])+1;

24. }

25. }

26.int res=C[0][0];

27.//free mem

28.for(int i=0;i<=size_A;i++){

29.delete [] C[i];

30. }

31.delete [] C;

32.return res;

33.}

六、最长不重复子串

很好理解，即求一个串内最长的不重复子串。

1）使用Hash

要求子串中的字符不能重复，判重问题首先想到的就是hash，寻找满足要求的子串，最直接的方法就是遍历每个字符起始的子串，辅助hash，寻求最长的不重复子串，由于要遍历每个子串故复杂度为O(n^2)，n为字符串的长度，辅助的空间为常数hash[256]。代码如下：

[cpp]view plaincopy

1./* 最长不重复子串我们记为 LNRS */

2.int maxlen;

3.int maxindex;

4.void output(char * arr);

5./* LNRS 基本算法 hash */

6.char visit[256];

7.void LNRS_hash(char * arr, int size)

8.{

9.for(int i = 0; i < size; ++i)

10. {

11. memset(visit,0,sizeof(visit));

12. visit[arr[i]] = 1;

13.for(int j = i+1; j < size; ++j)

14. {

15.if(visit[arr[j]] == 0)

16. {

17. visit[arr[j]] = 1;

18. }

19.else

20. {

21.if(j-i > maxlen)

22. {

23. maxlen = j - i;

24. maxindex = i;

25. }

26.break;

27. }

28. }

29. }

30. output(arr);

31.}

2）动态规划法

字符串的问题，很多都可以用动态规划处理，比如这里求解最长不重复子串，和前面讨论过的最长递增子序列问题就有些类似，在LIS(最长递增子序列)问题中，对于当前的元素，要么是与前面的LIS构成新的最长递增子序列，要么就是与前面稍短的子序列构成新的子序列或单独构成新子序列。

这里我们采用类似的思路：某个当前的字符，如果它与前面的最长不重复子串中的字符没有重复，那么就可以以它为结尾构成新的最长子串；如果有重复，那么就与某个稍短的子串构成新的子串或者单独成一个新子串。

我们来看看下面两个例子：

1）字符串“abcdeab”，第二个a之前的最长不重复子串是“abcde”，a与最长子串中的字符有重复，但是它与稍短的“bcde”串没有重复，于是它可以与其构成一个新的子串，之前的最长不重复子串“abcde”结束；

2）字符串“abcb”，跟前面类似，最长串“abc”结束，第二个字符b与稍短的串“c”构成新的串；

我们貌似可以总结出一些东西：当一个最长子串结束时（即遇到重复的字符），新的子串的长度是与（第一个重复的字符）的下标有关的。

于是类似LIS，对于每个当前的元素，我们“回头”去查询是否有与之重复的，如没有，则最长不重复子串长度+1，如有，则是与第一个重复的字符之后的串构成新的最长不重复子串，新串的长度便是当前元素下标与重复元素下标之差。

可以看出这里的动态规划方法时间复杂度为O(N^2)，我们可以与最长递增子序列的动态规划方案进行对比，是一个道理的。代码如下：

[cpp]view plaincopy

1./* LNRS 动态规划求解 */

2.int dp[100];

3.void LNRS_dp(char * arr, int size)

4.{

5.int i, j;

6. maxlen = maxindex = 0;

7. dp[0] = 1;

8.for(i = 1; i < size; ++i)

9. {

10.for(j = i-1; j >= 0; --j)

11. {

12.if(arr[j] == arr[i])

13. {

14. dp[i] = i - j;

15.break;

16. }

17. }

18.if(j == -1)

19. {

20. dp[i] = dp[i-1] + 1;

21. }

22.if(dp[i] > maxlen)

23. {

24. maxlen = dp[i];

25. maxindex = i + 1 - maxlen;

26. }

27. }

28. output(arr);

29.}

3）动态规划和hash结合

我们发现在动态规划方法中，每次都要“回头”去寻找重复元素的位置，所以时间复杂度徒增到O(n^2)，结合方法1）中的Hash思路，我们可以用hash记录元素是否出现过，我们当然也可以用hash记录元素出现过的下标，，这样就不必“回头”了，而时间复杂度必然降为O(N)，只不过需要一个辅助的常数空间visit[256]，这也是之前我另外一篇文章找工作笔试面试那些事儿(15)---互联网公司面试的零零种种和多家经验提到的的空间换时间思路，不过一般我们的面试里面优先考虑时间复杂度，所以这是可取的方法。

[cpp]view plaincopy

1./* LNRS 动态规划 + hash 记录下标 */

2.void LNRS_dp_hash(char * arr, int size)

3.{

4. memset(visit, -1, sizeof visit); //visit数组是-1的时候代表这个字符没有在集

合中

5. memset(dp, 0, sizeof dp);

6. maxlen = maxindex = 0;

7. dp[0] = 1;

8. visit[arr[0]] = 0;

9.for(int i = 1; i < size; ++i)

10. {

11.if(visit[arr[i]] == -1) //表示arr[i]这个字符以前不存在

12. {

13. dp[i] = dp[i-1] + 1;

14. visit[arr[i]] = i; /* 记录字符下标 */

15. }else

16. {

17. dp[i] = i - visit[arr[i]];

18. visit[arr[i]] = i; /* 更新字符下标 */

19. }

20.if(dp[i] > maxlen)

21. {

22. maxlen = dp[i];

23. maxindex = i + 1 - maxlen;

24. }

25. }

26. output(arr);

27.}

4）空间再优化

上面的方法3）已经将时间复杂度降到了O(n)，可是这时面试官又发言了，说你用的辅助空间多了，还有优化方法吗，我们仔细观察动态规划最优子问题解的更新方程：

dp[i] = dp[i-1] + 1;

dp[i-1]不就是更新dp[i]当前的最优解么？这又与之前提到的最大子数组和问题的优化几乎同出一辙，我们不需要O(n)的辅助空间去存储子问题的最优解，而只需O(1)的空间就可以了，至此，我们找到了时间复杂度O(N)，辅助空间为O(1)（一个额外变量与256大小的散列表）的算法，代码如下：

[cpp]view plaincopy

1./* LNRS 动态规划+hash，时间复杂度O(n) 空间复杂度O(1)算法*/

2.void LNRS_dp_hash_ultimate(char * arr, int size)

3.{

4. memset(visit, -1, sizeof visit);

5. maxlen = maxindex = 0;

6. visit[arr[0]] = 0;

7.int curlen = 1;

8.for(int i = 1; i < size; ++i)

9. {

10.if(visit[arr[i]] == -1)

11. {

12. ++curlen;

13. visit[arr[i]] = i; /* 记录字符下标 */

14. }

15.else

16. {

17. curlen = i - visit[arr[i]];

18. visit[arr[i]] = i; /* 更新字符下标 */

19. }

20.if(curlen > maxlen)

21. {

22. maxlen = curlen;

23. maxindex = i + 1 - maxlen;

24. }

25. }

26. output(arr);

27.}

七、最长回文子串

给出一个字符串S，找到一个最长的连续回文串。例如串babcbabcbaccba 最长回文

是:abcbabcba

1）自中心向两端寻找

回文是一种特殊的字符串，我们可以以源字符串的每个字符为中心，依次寻找出最长回文子串P0, P1,...,Pn。这些最长回文子串中的最长串Pi = max(P1, P2,...,Pn)即为所求。核心代码如下：

[cpp]view plaincopy

1.string find_lps_method1(const string &str)

2.{

3.int center = 0, max_len = 0;

4.for(int i = 1; i < str.length()-1; ++i)

5. {

6.int j = 1;

7.//以str[i]为中心，依次向两边扩展，寻找最长回文Pi

8.while(i+j < str.length() && i-j >= 0 && str[i+j] == str[i-j])

9. ++j;

10. --j;

11.if(j > 1 && j > max_len)

12. {

13. center = i;

14. max_len = j;

15. }

16. }

17.return str.substr(center-max_len, (max_len << 1) + 1);

18.}

2）利用最长公共字串的方法

这里用到了一个我们观察出来的结论：对于串S, 假设它反转后得到的串是S', 那么S 的最长回文串是S和S'的最长公共字串。

例如S = babcbabcbaccba, S' = abccabcbabcbab，S和S'的最长公共字串

是abcbabcba也是S的最长回文字串。

代码这个地方就不写了，用首指针++，尾指针--很容易实现串的翻转，再结合前面写过的最长公共子串代码可得到最后结果。

3）利用栈的性质

这是一个不成熟的想法，博主只是觉得比较好的想法需要拿出来分享一下，对于长度为偶数的最长回文，可以采用这样一种思路求得：

将字符串中的字符从左至右逐个入栈，出现情况：1）若栈顶字符和要入栈的字符相同，则该字符不入栈且栈pop出栈顶字符，回文长度加一。2）若栈顶字符与要入栈的字符不相同，直接入栈。则依次入栈出栈，求最长连续出栈序列即可。

因为对于奇数长度的字符串，博主没有想到时间复杂度低的类似处理方法，所以这里就不写代码了，大家有好的解法或者思路欢迎留言。

4）著名的Manacher’s Algorithm算法

算法首先将输入字符串S，转换成一个特殊字符串T，转换的原则就是将S的开头结尾以及每两个相邻的字符之间加入一个特殊的字符，例如#

例如: S = “abaaba”, T = “#a#b#a#a#b#a#”.

为了找到最长的回文字串，例如我们当前考虑以Ti为回文串中间的元素，如果要找到最长回文字串，我们要从当前的Ti扩展使得Ti-d … Ti+d 组成最长回文字串. 这里d其实和以Ti为中心的回文串长度是一样的. 进一步解释就是说，因为我们这里插入了# 符号，

对于一个长度为偶数的回文串，他应该是以#做为中心的，然后向两边扩，对于长度是奇数的回文串，它应该是以一个普通字符作为中心的。通过使用#，我们将无论是奇数还是偶数的回文串，都变成了一个以Ti为中心，d为半径两个方向扩展的问题。并且d就是回文串的长度。

例如#a#b#a#, P = 0103010, 对于b而言P的值是3，是最左边的#，也是延伸的最左边。这个值和当前的回文串是一致的。

如果我们求出所有的P值，那么显然我们要的回文串，就是以最大P值为中心的回文串。

T = # a # b # a # a # b # a #

P = 0 1 0 3 0 1 6 1 0 3 0 1 0

例如上面的例子，最长回文是“abaaba”, P6 = 6.

根据观察发现，如果我们在一个位置例如abaaba的中间位置，用一个竖线分开，两侧的P值是对称的。当然这个性质不是在任何时候都会成立，接下来就是分析如何利用这个性质，使得我们可以少算很多P的值。

下面的例子S = “babcbabcbaccba”存在更多的折叠回文字串。

C表示当前的回文中心，L和R处的线表示以C为中心可以到达的最左和最右位置，如果知道这些，我们如何可以更好的计算C后面的P[i].

假设我们当前计算的是i = 13, 根据对称性，我们知道对称的那个下标i' = 9.

根据C对称的原则，我们很容易得到如下数

据P[ 12 ] = P[ 10 ] = 0, P[ 13 ] = P[ 9 ] = 1, P[ 14 ] = P[ 8 ] = 0).

当时当i = 15的时候，却只能得到回文“a#b#c#b#a”,长度是5，而对称i ' = 7 的长度是7.

如上图所示，如果以i, i' 为中心，画出对称的区域如图，其中以i‘ = 7 对称的区域是实心绿色+ 虚绿色和左侧，虚绿色表示当前的对称长度已经超过之前的对称中心C。而之前的P对称性质成立的原因是i 右侧剩余的长度R - i 正好比以i‘为中心的回文小。

这个性质可以这样归纳，对于i 而言，因为根据C对称的最右是R，所以i的右侧有R - i 个元素是保证是i' 左侧是对称的。而对于i' 而言他的P值，也就是回文串的长度，可能会比R-i 要大。如果大于R - i, 对于i而言，我们只能暂时的先填

写P[i] = R - i, 然后依据回文的属性来扩充P[i] 的值；如果P[i '] 小于R-i，那么说明在对称区间C内，i的回文串长度和i' 是一样长的。例如我们的例子中i = 15, 因为R = 20，所以i右侧在对称区间剩余的是R - 15 = 5, 而i’ = 7 的长度是7. 说明i' 的回文长度已经超出对称区间。我们只能使得P[i] 赋值为5，然后尝试扩充P[i].

if P[ i' ] ≤R –i,

then P[ i ] ←P[ i' ]

else P[ i ] ≥R –i. (这里下一步操作是扩充P[ i ].

扩充P[i] 之后，我们还要做一件事情是更新R 和C，如果当前对称中心的最右延伸大于R，我们就更新C和R。在迭代的过程中，我们试探i的时候，如果P[i'] <= R - i, 那么只要做一件事情。如果不成立我们对当前P[i] 做扩展，因为最大长度是n，扩展最多就做n次，所以最多做2*n。所以最后算法复杂度是O(n)

具体实现的代码如下：

[cpp]view plaincopy

1.// 转换S 到 T.

2.// 例如, S = "abba", T = "^#a#b#b#a#$".

3.// ^ 和 $ 作为哨兵标记加到两端以避免边界检查

4.string preProcess(string s) {

5.int n = s.length();

6.if (n == 0) return"^$";

7. string ret = "^";

8.for (int i = 0; i < n; i++)

9. ret += "#" + s.substr(i, 1);

10.

11. ret += "#$";

12.return ret;

13.}

14.

15.string longestPalindrome(string s) {

16. string T = preProcess(s);

17.int n = T.length();

18.int *P = new int[n];

19.int C = 0, R = 0;

20.for (int i = 1; i < n-1; i++) {

21.int i_mirror = 2*C-i; // equals to i' = C - (i-C)

22.

23. P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;

24.

25.// Attempt to expand palindrome centered at i

26.while (T[i + 1 + P[i]] == T[i - 1 - P[i]])

27. P[i]++;

28.

29.

30.

31.// If palindrome centered at i expand past R,

32.

33.// adjust center based on expanded palindrome.

34.if (i + P[i] > R) {

35. C = i;

36. R = i + P[i];

37.

38. }

39. }

40.

41.// Find the maximum element in P.

42.

43.int maxLen = 0;

44.int centerIndex = 0;

45.

46.for (int i = 1; i < n-1; i++) {

47.if (P[i] > maxLen) {

48. maxLen = P[i];

49.

50. centerIndex = i;

51.

52. }

53.

54. }

55.delete[] P;

56.

57.return s.substr((centerIndex - 1 - maxLen)/2, maxLen);

58.

59.}