演算法知識梳理(3) 字串演算法第二部分

澤毛發表於2017-12-21
演算法字串

一、概要

本文介紹了有關字串的演算法第二部分的Java程式碼實現，所有程式碼均可通過 線上編譯器 直接執行，演算法目錄：

  • 查詢字串中的最長重複子串
  • 求長度為N的字串的最長迴文子串
  • 將字串中的*移到前部，並且不改變非*的順序
  • 不開闢用於交換的空間，完成字串的逆序C++
  • 最短摘要生成
  • 最長公共子序列

二、程式碼實現

2.1 查詢字串中的最長重複子串

問題描述

給定一個文字檔案作為輸入，查詢其中最長的重複子字串。例如，"Ask not what your country can do for you, but what you can do for your country"中最長的重複字串是“can do for you”，第二長的是"your country"。

解決思路

這裡解決問題的時候用到了 字尾陣列 的思想，它指的是字串所有右子集的集合，例如字串abcde，它的字尾陣列就為["abcde", "bcde", "cde", "de", "e"]。

解法分為三步：

  • 求得輸入字串p的字尾陣列，把它存放在一個List當中，這裡注意去掉空格的情況。
  • 對List中的所有元素進行快速排序。快速排序的目的不在於使得整個陣列有序，而在於 使得字首差異最小的兩個字串在陣列中位於相鄰的位置，對於上面的例子，其排序結果為：

字尾陣列的快速排序結果

  • 遍歷排序後的陣列，只需要對陣列中的 相鄰的兩個元素 從頭開始比較，計算出這兩個字串相同字首的長度。遍歷之後，取得的最大值就是最長重複子串的長度，而這兩個字串的相同字首就是最長重複子串。

實現程式碼

import java.util.ArrayList;
import java.util.List;
import java.lang.String;

class Untitled {

	static void quickSortStr(List<String> c, int start, int end){
		if(start >= end)
			return;
		int pStart = start;
		int pEnd = end;
		int pMid = start;
		String t = null;
		for (int j = pStart+1; j <= pEnd; j++) {
			if ((c.get(pStart)).compareTo(c.get(j)) > 0) {
				pMid++;
				t = c.get(pMid); 
				c.set(pMid, c.get(j)); 
				c.set(j, t);
			}
		}
		t = c.get(pStart); 
		c.set(pStart, c.get(pMid)); 
		c.set(pMid, t);
		quickSortStr(c, pStart, pMid-1);
		quickSortStr(c, pMid+1, pEnd);
	}
	
	//獲得兩個字串從第一個字元開始，相同部分的最大長度。
	static int comLen(String p1, String p2){
		int count = 0;
		int p1Index = 0;
		int p2Index = 0;
		while (p1Index < p1.length()) {
			if (p1.charAt(p1Index++) != p2.charAt(p2Index++))
				return count;
			count++;
		}
		return count;
	}

	static String longComStr(String p, int length){
		List<String> dic = new ArrayList<String>();
		int ml = 0 ;
		for (int i = 0; i < length; i++) {
			if (p.charAt(i) != ' ') {
				//構造所有的字尾陣列。
				dic.add(p.substring(i, p.length()));
			}
		}
		String mp = null;
		//對字尾陣列進行排序。
		quickSortStr(dic, 0, dic.size()-1);
		//列印排序後的陣列用於除錯。
		for (int i = 0; i < dic.size(); i++) {
			System.out.println("index=" + i + ",data=" + dic.get(i));
		}
		for (int i = 0; i < dic.size()-1; i++) {
			int tl = comLen(dic.get(i), dic.get(i+1));
			if (tl > ml) {
				ml = tl;
				mp = dic.get(i).substring(0, ml);
			}
		}
		return mp;
	} 

	public static void main(String[] args) {
		String source = "Ask not what your country can do for you, but what you can do for your country";
		System.out.println("result = " + longComStr(source, source.length()));
	}
}
複製程式碼

執行結果

>> result = can do for you
複製程式碼

2.2 求長度為 N 的字串的最長迴文子串

問題描述

長度為N的字串，求這個字串裡的最長迴文子串，迴文字串 簡單來說就是一個字串正著讀和反著讀是一樣的。

解決思路

這裡用到的是Manacher演算法，首先需要對原始的字串進行預處理，即在每個字元之間加上一個標誌位，這裡用#來表示，這會使得對於任意一個輸入，經過處理後的字串長度為2*len+1，也就是說 處理後的字串始終為奇數。

在上面我們已經介紹過，迴文串中最左或最右位置的字元與其對稱軸的距離稱為 迴文半徑，Manacher定義了一個陣列RL[i]，它表示 第i個字元為對稱軸的迴文串 的 最右一個字元與字元i的閉區間所包含的字元個數，以google為例，經過處理後的字串為#g#o#o#g#l#e，那麼RL[i]的值為：

演算法知識梳理(3) 字串演算法第二部分
而RL[i]-1的值就是原始字串中，以位置i為對稱軸的最長迴文串的長度，那麼接下來的問題就變成如何計算RL[i]陣列。

首先，我們需要兩個輔助的變數maxidR和maxid，它表示當前計算的迴文字串中，所能觸及到的最右位置，而maxid則表示該回文串的對稱軸所在位置，而RL[maxid]為該回文串的距離。

假設我們此時遍歷到了第i個字元，那麼這時候有兩種情況：

(1) i < maxidR

在這種情況下，我們知道p[maxid+1, .., maxid+RL[maxid]-1]和p[maxid-1, .., maxid-RL[maxid]+1]部分是關於p[maxid]對稱的，利用這個有效資訊，可以避免一些不必要的判斷。

現在，我們獲得i關於maxid的對稱點j，這個點位於maxid的左側，因此，我們已經計算過以它為中心的迴文字串長度RL[j]，對於以p[j]為中心的迴文字串有兩種情況：

  • 以j為中心的迴文字元的最左邊j-(RL[j]-1) 大於等於 maxidR關於maxid的對稱點maxid-(maxidR-maxid)，在這種情況下，我們可以推斷出以i為對稱點的RL[i]的值最小為RL[j]。
  • 大於的情況，可以保證以i為對稱點的RL[i]至少為(maxidR-i)+1。

當然這上面只是推測出的 最小情況，之後仍然要繼續遍歷來更新RL[i]的值。

(2) i >= maxidR

這時候沒有任何的已知資訊，我們只能從i的左右兩邊慢慢遍歷。

實現程式碼

class Untitled {
	
	static int maxSynStr(char ip[], int len) {
		int size = 2*len + 1;
		char a[] = new char[size];
		int RL[] = new int[size];
		int i = 0;
		int n;
		while (i < len) {
			a[(i<<1)+1] = ip[i];
			a[(i<<1)+2] = '#';
			i++;
		}
		a[0] = '#';
		//最遠字元的中心對稱點。
		int maxid = 0;
		//探索到的最遠字元。
		int maxidR = 0;
		int ans = 0;
		RL[0] = 1;
		for (i = 1; i < size; i++) {
			//首先推測出i為中心的最小回文半徑。
			int offset = 0;
			if (i < maxidR) {
				//j是關於maxid在左邊的對稱點。
				int j = maxid-(i-maxid);
				//獲取之前計算出的以j為中心的迴文半徑。
				if (j-(RL[j]-1) >= maxid-(maxidR-maxid)) {
					offset = RL[j]-1;
				} else {
					offset = maxidR-maxid;
				} 
			}
			do {
				offset++;
			} while(i-offset >= 0 && i+offset < size && a[i+offset] == a[i-offset]);
			//最後一次是匹配失敗的，因此要減去1。
			offset--;
			//RL[i]的值包括了自己，因此要加1。
			RL[i] = offset+1;
			//更新當前最大的迴文半徑。
			if (i+offset > maxidR){
				maxidR = i+offset;
				maxid = i;
			}
			if (RL[i] > ans) {
				ans = RL[i];
			}
		}
		return ans-1;
	} 
	
	public static void main(String[] args) {
		char[] source = "google".toCharArray();
		System.out.println("result=" + maxSynStr(source, 6));
	}
}
複製程式碼

執行結果：

>> result=4
複製程式碼

2.3 將字串中的 * 移到前部，並且不改變非 * 的順序

問題描述

將字串中的*移到前部，並且不改變非*的順序，例如ab**cd**e*12，處理後為*****abcde12。

解決思路

我們可以將整個陣列分為兩個部分：有可能包含*字元的部分和一定不包含*字元的部分。初始時候，整個陣列只有有 有可能包含*字元的部分，那麼我們就可以 從後往前 遍歷，每遇到一個非*的字元就把它放到 一定不包含*字元的部分，由於需要保持非*的順序，因此需要將它插入到該部分的首部。

實現程式碼

class Untitled {

	static void moveNullCharPos(char p[], int length) {
		if (length > 1) {
			char t;
			char c;
			int lastCharIndex = length;
			//必須要從後向前掃描。
			for(int j = length-1; j >=0 ;j--) {
				if ((c = p[j]) != '*') {
					lastCharIndex--;
					t = p[lastCharIndex]; p[lastCharIndex] = p[j]; p[j] = t;
				}
			}
		}
		System.out.println(p);
	}

	public static void main(String[] args) {
		char[] source = "ab**cd**e*12".toCharArray();
		moveNullCharPos(source, source.length);
	}
}
複製程式碼

執行結果：

>> *****abcde12
複製程式碼

2.4 不開闢用於交換的空間，完成字串的逆序（C++）

問題描述

不開闢用於交換的空間，完成字串的逆序。

解決思路

這裡利用的是 兩次亦或等於本身 的思想。

實現程式碼

#include <iostream>
using namespace std;

void reverWithoutTemp(char *p, int length){
	int i = 0;
	int j = length-1;
	while (i < j) {
		p[i] = p[i]^p[j];  
		//實際上是p[i]^p[j]^p[j]，這裡的p[i]和p[j]指的是原始陣列中的值。
		p[j] = p[i]^p[j];  
		//實際上是(p[i]^(p[i]^p[j]^p[j]))^(p[i]^p[j]^p[j])，這裡的p[i]和p[j]指的是原始陣列中的值。
		p[i] = p[i]^p[j];  
		i++;j--;
	}
	std::cout << p << std::endl;
}

int main() {
	char p[] = "1234566";
	reverWithoutTemp(p, 7);
	return 0;
}
複製程式碼

執行結果：

>> 6654321
複製程式碼

2.5 最短摘要生成

問題描述

給定一段描述w和一組關鍵字q，我們從這段描述中找出包含所有關鍵字的最短字元序列，這個最短字元序列就稱為 最短摘要：

  • 最短字元序列必須包含所有的關鍵字
  • 最短字元序列中關鍵字的順序可以是隨意的

解決思路

假設我們的輸入序列如下所示，其中w表示非關鍵字的字串，而q則表示關鍵字的字串：

w0,w1,w2,w3,q0,w4,w5,q1,w6,w7,w8,q0,w9,q1
複製程式碼

這裡，我們引入額外的三個變數pStart、pEnd和flag陣列，flag陣列用於統計pStart和pEnd之間關鍵字的命中情況。

這裡說明一下flag陣列的作用，flag陣列和關鍵字p陣列的長度相同，每命中一個關鍵字，就將flag陣列的對應位置+1，而flagSize只有在每次遇到一個新的關鍵字時才更新，因此它表示flag陣列中 不重複的關鍵字的個數。

演算法的步驟如下：

  • 第一步：我們將pEnd從w[0]開始移動，每發現一個命中的關鍵字，就更新flag[]陣列，直到w[pStart,..,pEnd] 包含了所有的關鍵字，即w0,w1,w2,w3,q0,w4,w5,q1。
  • 第二步：開始移動pStart，這時候pStart,..,pEnd之間的長度將會逐漸變短，在移動的過程中，同時更新flag[]陣列，直到pStart,...,pEnd之間 不再包含所有的關鍵字，這時候就可以求得 目前為止的最短摘要長度，即q0,w4,w5,q1。
  • 第三步：重複第一步的操作，移動pEnd使得pStart,...,pEnd重新 包含所有的關鍵字，再執行第二步的操作來 更新最短摘要長度，直到pEnd遍歷到w的最後一個元素。

實現程式碼

class Untitled {

	static int findKey(String[] p1, String p2) {
		int len = p1.length;
		for(int i = 0; i < len; i++) {
			if(p1[i].equals(p2))
				return i;
		}
		return -1;
	}
	
	//p1為原始資料，p2為所有的關鍵詞。
	static int calMinAbst(String[] p1, String[] p2) {
		int p1Len = p1.length;
		int p2Len = p2.length;
		int r;
		int shortAbs = Integer.MAX_VALUE;
		int tAbs = 0;
		int pBegin = 0;
		int pEnd = 0;
		int absBegin = 0;
		int absEnd = 0;
		int flagSize = 0;
		int flag[] = new int[p2Len];
		//初始化標誌位陣列。
		for (int i = 0; i < p2Len; i++) {
			flag[i] = 0;
		}
		while (pEnd < p1Len) {
			//只有先找到全部的關鍵詞才退出迴圈。
			while (flagSize != p2Len && pEnd < p1Len) {
				r = findKey(p2, p1[pEnd++]);
				if (r != -1) {
					if (flag[r] == 0) {
						flagSize++;
					}
					flag[r]++;
				}
			}
			while (flagSize == p2Len) {
				if ((tAbs = pEnd-pBegin) < shortAbs) {
					shortAbs = tAbs;
					absBegin = pBegin;
					absEnd = pEnd-1;
				}
				r = findKey(p2, p1[pBegin++]);
				if (r != -1) {
					flag[r]--;
					if (flag[r] == 0) {
						flagSize--;
					}
				}
			}
		}
		for (int i = absBegin; i <= absEnd; i++) {
			System.out.print(p1[i] + ",");
		}
		System.out.println("\n最短摘要長度=" + tAbs);
		return shortAbs;
	}

	public static void main(String[] args) {
		String keyword[] = {"微軟", "計算機", "亞洲"};
		String str[] = { 
			"微軟","亞洲","研究院","成立","於","1998","年","，","我們","的","使命",
			"是","使","未來","的","計算機","能夠","看","、","聽","、","學","，",
			"能","用","自然語言","與","人類","進行","交流","。","在","此","基礎","上",
			"，","微軟","亞洲","研究院","還","將","促進","計算機","在","亞太","地區",
			"的","普及","，","改善","亞太","使用者","的","計算","體驗","。","”"
		};
		calMinAbst(str, keyword);
	}
}
複製程式碼

執行結果

>> 微軟,亞洲,研究院,還,將,促進,計算機,
>> 最短摘要長度=7
複製程式碼

2.6 最長公共子序列

問題描述

經典的LCS問題，這裡主要解釋一下最長公共子序列的含義。最長公共子串和最長公共子序列的區別：子串是 串的一個連續的部分，子序列則是 不改變序列的順序，而從序列中去掉任意的元素 而獲得的新序列。

解決思路

經典的LCS問題，原理可以參考這篇被廣泛轉載的文章 程式設計師程式設計藝術第十一章：最長公共子序列問題，這裡給出簡要介紹一下基本的思想。

LCS基於下面這個定理：

LCS 演算法定理
最終目的是構建類似於下面的一個矩陣：

LCS 矩陣

  • 對於矩陣，定義c[i][j]：它表示字串序列A的前i個字元組成的序列A和字串序列B的前j個字元組成的序列B之間的最長公共子序列的長度，其中i<=A.len，並且j<=B.len。
  • 如果A[i]=B[j]，那麼A與B之間的最長公共子序列的最後一項一定是這個元素，也就是c[i][j] = c[i-1][j-1]+1。
  • 如果A[i]!=B[j]，則c[i][j]= max(c[i-1][j], c[i][j-1])。
  • 初始值為：c[0][j]=c[i][0]=0。

程式碼實現

class Untitled {

	static void LCS(char a[], int aLen, char b[], int bLen){
		int c[][] = new int[bLen+1][aLen+1];
		for (int i = 1; i < bLen+1; i++) {
			for (int j = 1; j < aLen+1; j++) {
				if (a[j-1] == b[i-1]) {
					c[i][j] = c[i-1][j-1] + 1;
				} else {
					c[i][j] = (c[i-1][j]>c[i][j-1]) ? c[i-1][j]:c[i][j-1];
				}
			}
		}
		int csl = c[bLen][aLen];
		char p[] = new char[csl+1];
		int i = bLen, j = aLen;
		while (i > 0 && j > 0 && c[i][j] > 0) {
			if (c[i][j] == c[i-1][j]) {
				i--;
			} else if(c[i][j] == c[i][j-1]) {
				j--;
			} else if(c[i][j] > c[i-1][j-1]) {
				p[c[i][j]] = a[j-1];
				i--;j--;
			}
		}
		for (i = 1; i <= csl; i++) {
			System.out.print(p[i]);
		}
	} 

	public static void main(String[] args) {
		char p1[] = "aadaae".toCharArray();
		char p2[] = "adaaf".toCharArray();
		LCS(p1, p1.length, p2, p2.length);
	}
}
複製程式碼

執行結果

>> adaa
複製程式碼

更多文章，歡迎訪問我的 Android 知識梳理系列：

相關文章