字符串之最

字符串裏有一類問題經常遇到，就是最長問題。歸納爲：最長公共子串、最長公共子序列、最長迴文子串、最長重複子串、最長不重複子串問題。這一篇在這裏做個總結，給出每個問題的解題思路。

1.最長公共子串

最長公共子串和最長公共子序列非常類似，但是子串要求在原字符串中是連續的。而最長公共子序列則並不要求連續。

方法一：平移法：引用自博客http://blog.csdn.net/hackbuteer1/article/details/6686931

將字符串s1和s2分別寫在兩把直尺上面(我依然用s1，s2來表示這兩把直尺)，然後將s1固定，s2的頭部和s1的尾部對齊，然後逐漸移動直尺s2，比較重疊部分的字符串中的公共子串的長度，直到直尺s2移動到s1的頭部。在這個過程中求得的最大長度就是s1、s2最大子串的長度。

下圖是求解過程的圖示（下圖有點錯誤，應該是將s2從右往左移動），藍色部分表示重疊的字符串，紅色的部分表示重疊部分相同的子串

其中s1="shaohui"，s2="ahui"，最後求得的結果爲3。

string MaxSubStr(const string& s1, const string& s2)
{
	size_t len1 = s1.size();
	size_t len2 = s2.size();
	size_t len = len1 + len2;
	int maxLen = 0;
	int startPos = 0;
	for(size_t i = 0; i < len; ++i)
	{
		int startS1, startS2;
		startS1 = startS2 = 0;
		if(i < len1)
			startS1 = len1 - i;
		else
			startS2 = i - len1;
		
		int tmpLen = 0;	
		int idx;
		for(idx = 0; (startS1+idx < len1) && (startS2+idx < len2); ++idx)
		{
			if(s1[startS1+idx] == s2[startS2+idx])
				++tmpLen;
			else
			{
				if(tmpLen > maxLen)
				{
					maxLen = tmpLen;
					startPos = startS1+idx-maxLen;
				}
				tmpLen = 0;
			}
		}
		if(tmpLen > maxLen)
		{
			maxLen = tmpLen;
			startPos = startS1+idx-maxLen;
		}
	}
	string result(s1, startPos, maxLen);
	return result;
}

方法二：

其實這是一個序貫決策問題，可以用動態規劃來求解。我們採用一個二維矩陣來記錄中間的結果。這個二維矩陣怎麼構造呢？直接舉個例子吧："bab"和"caba"(當然我們現在一眼就可以看出來最長公共子串是"ba"或"ab")

　　 b　　a　　b

c　　0　　0　　0

a　　0　　1　　0

b　　1　　0　　1

a　　0　　1　　0

我們看矩陣的斜對角線最長的那個就能找出最長公共子串。

不過在二維矩陣上找最長的由1組成的斜對角線也是件麻煩費時的事，下面改進：當要在矩陣是填1時讓它等於其左上角元素加1。

　　 b　　a　　b

c　　0　　0　　0

a　　0　　1　　0

b　　1　　0　　2

a　　0　　2　　0

這樣矩陣中的最大元素就是最長公共子串的長度。（兩段代碼都沒有考慮存在重複最大子串，可以用數組保存實現所有的最大子串輸出）。

string MaxSubStr(const string& s1, const string& s2)
{
	size_t len1 = s1.size();
	size_t len2 = s2.size();
	int martrix[len1][len2] = {0};
	int maxLen = 0;
	int startPos = 0;
	string result, tmp;
	for(int i = 0; i < len1; ++i)
	{
		for(int j = 0; j < len2; ++j)
		{
			if(s1[i] == s2[j])
			{
				if(i == 0 || j == 0)
					martrix[i][j] = 1;
				else
					martrix[i][j] = martrix[i-1][j-1]  + 1;
			}
			else
				martrix[i][j] = 0;
		
			if(martrix[i][j] > maxLen)
			{
				maxLen = martrix[i][j];
				startPos = i - maxLen + 1;
			}
		
		}
	}
	return string(s1, startPos, maxLen);
}

2.最大公共子序列

字符序列的子序列是指從給定字符序列中隨意地（不一定連續）去掉若干個字符（可能一個也不去掉）後所形成的字符序列。令給定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一個嚴格遞增下標序列<i0，i1，…，ik-1>，使得對所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一個子序列。

考慮最長公共子序列問題如何分解成子問題，設A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，並Z=“z0，z1，…，zk-1”爲它們的最長公共子序列。不難證明有以下性質：

（1）如果am-1=bn-1，則zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一個最長公共子序列；

（2）如果am-1!=bn-1，則若zk-1!=am-1，蘊涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一個最長公共子序列；

（3）如果am-1!=bn-1，則若zk-1!=bn-1，蘊涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一個最長公共子序列。

這樣，在找A和B的公共子序列時，如有am-1=bn-1，則進一步解決一個子問題，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一個最長公共子序列；如果am-1!=bn-1，則要解決兩個子問題，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一個最長公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一個最長公共子序列，再取兩者中較長者作爲A和B的最長公共子序列。

求解：

引進一個二維數組c[][]，用c[i][j]記錄X[i]與Y[j] 的LCS 的長度，b[i][j]記錄c[i][j]是通過哪一個子問題的值求得的，以決定搜索的方向。
我們是自底向上進行遞推計算，那麼在計算c[i,j]之前，c[i-1][j-1]，c[i-1][j]與c[i][j-1]均已計算出來。此時我們根據X[i] = Y[j]還是X[i] != Y[j]，就可以計算出c[i][j]。

問題的遞歸式寫成：

回溯輸出最長公共子序列過程：

<span style="font-size:14px;">string CreateLCS(int** path, const string& str, int m, int n)
{
	static string result = "";
	if(m == 0 || n == 0)
		return "";
		
	if(path[m][n] == 0)
	{
		CreateLCS(path, str, m-1, n-1);
		result += str[m-1];
	}
	else if(path[m][n] == 1)
		CreateLCS(path, str, m-1, n);
	else
		CreateLCS(path, str, m, n-1);
		
	return result;
}

string LCS(const string& s1, const string& s2)
{
	int maxLen = 0;
	size_t len1 = s1.size();
	size_t len2 = s2.size();
	//申請(len2+1)*(len1+1)的二維數組，length存放子序列長度，path存放回溯路徑
	int **length = new int*[len2+1];
	int **path = new int*[len2+1];
	for(int i = 0; i < len2+1; ++i)
	{
		length[i] = new int[len1+1];
		path[i] = new int[len1+1];
	}
	
	for(int i = 0; i < len1+1; ++i)
		length[0][i] = 0;
	for(int j = 1; j < len2+1; ++j)
		length[j][0] = 0;
		
	for(int i = 1; i < len2+1; ++i)
	{
		for(int j = 1; j < len1+1; ++j)
		{
			if(s2[i-1] == s1[j-1])
			{
				length[i][j] = length[i-1][j-1]+1;
				path[i][j] = 0;                        //回溯到左上角
				maxLen = length[i][j] > maxLen ? length[i][j] : maxLen;
			}
			else if(length[i-1][j] >= length[i][j-1])
			{
				length[i][j] = length[i-1][j];
				path[i][j] = 1;                       //往左回溯記爲1；
			}
			else
			{
				length[i][j] = length[i][j-1];
				path[i][j] = -1;
			}
		}
	}
	
	cout << "最大公共子序列長度爲：" << maxLen << endl;
	//打印最大子序列
	string LCS = CreateLCS(path, s2, len2, len1);
	
	for(int i = 0; i < len2+1; ++i)
	{
		delete[] length[i];
		delete[] path[i];
	}
	delete[] *length;
	delete[] *path;
	return LCS;
}</span>

3.最長重複子串

後綴數組解決這個問題，先求出字符串的所有後綴數組，然後排序，比較相鄰的後綴數組的相同字符串長度，就是最長的重複子串。

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

int ComLen(char* p, char* q)
{
	int len = 0;
	while(*p && (*p++ == *q++))
		++len;
	return len;
}

int cmp(const void* a, const void* b)
{
	return strcmp(*(char* const*)a, *(char* const*)b);
}

char* LongestReSubStr(char* str, char* result)
{
	int len = strlen(str);
	char** suffix = new char*[len];
	for(int i = 0; i < len; ++i)
		suffix[i] = str + i;
		
	qsort(suffix, len, sizeof(char*), cmp);
	int maxLen = 0;
	int pos = 0;
	for(int i = 0; i < len - 1; ++i)
	{
		int comLen = ComLen(suffix[i], suffix[i+1]);
		if(comLen > maxLen)
		{
			maxLen = comLen;
			pos = i;
		}
	}
	
	strncpy(result, suffix[pos], maxLen);
	result[maxLen] = '\0';
	delete[] suffix;
	
	return result;
}

int main() {
	// your code goes here
	char str[] = "banana";
	char* result = new char[strlen(str)+1];
	char* s = LongestReSubStr(str, result);
	cout << s << endl;
	delete[] result;
	return 0;
}

4.最長不重複子串

解法一：hash法，如果用從頭到尾遍歷的方式，由於字符的個數只有256個，所以可以申請一個大小爲256的數組，訪問過的字符在數組的對應位置上標記爲1，如果碰到已經標記的字符，就退出本層循環，時間複雜度O(n^2)。

void LNRS(char* str, char* result)
{
	if(str == NULL)
		return;
		
	int visit[256];
	int len = strlen(str);
	int maxLen = 0;
	int start = 0;
	for(int i = 0; i < len; ++i)
	{
		memset(visit,0,sizeof(visit));
		visit[str[i]] = 1;
		int j;
		for(j = i + 1; j < len; ++j)
		{
			if(visit[str[j]] == 0)
				visit[str[j]] = 1;
			else
				break;
		}
		if(j-i > maxLen)
		{
			maxLen = j - i;
			start = i;
		}
	}
	
	strncpy(result, str+start, maxLen);
	result[maxLen] = '\0';
}

5.最長迴文字串

避免篇幅過長，最長迴文字串見另一篇博文：

DAPPER 事務 TRANSACTION

返回二叉樹的鏡像

字符串之最

按升序對棧進行排序

鏈表分割問題

二叉樹的遞歸和非遞歸遍歷方法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結