第五章 字符串专题（下）
１、后缀数组
我在这里写的实在不形象，，推荐一篇blog吧，https://www.cnblogs.com/xiaoyh/p/10322424.html
import java.util.Arrays;
class test3{
public static void main(String[] args) {
match();
}
static void match(){
String s = "ABABABABB";
String p = "BABB";
suff[] sa = getsa(s); //生成后缀数组(就是已经排序好的)
int l=0;
int r = s.length()-1;
//二分查找
while (r>=l){
int mid = l+((l-r)>>1);
suff midsuff = sa[mid];
String suffer = midsuff.str;
int compare;
//将后缀与模式串比较
if(suffer.length()>=p.length()){
compare = suffer.substring(0,p.length()).compareTo(p); //与子串比
}else {
compare = suffer.compareTo(p);
}
if(compare == 0){
System.out.println(midsuff.index);
break;
}else if(compare<0){
l = mid+1;
}else {
r= mid-1;
}
}
}
static suff[] getsa(String src){
int strlength = src.length();
suff[] suffixarray = new suff[strlength]; //suffixarry是suff数组，这个suff有三个参数
for(int i=0;i{//这里自定义他的原因是对字符串排序的话排玩没有索引，所以这里给他们缝在一起
public String str;//str是字符串
public int index;//后缀的起始下标
public suff(String str,int index){
super();
this.str = str;
this.index = index;
}
@Override
public int compareTo(suff o2) {
return this.compareTo(o2);
}
@Override
public String toString() {
return "suff{" +
"str='" + str + '\'' +
", index=" + index +
'}';
}
}
} 倍增法
上面求后缀数组的方式时间复杂度为n²log(n)，一般来说，时间复杂度只要达到了n平方级别都要想办法降低，于是就有一种叫做倍增法的方法来求后缀数组（只是简化了求后缀数组的过程 他的排序）
import java.util.Arrays;
public class SuffixArray {
public static void main(String[] args) {
match(); // 得到结果是5
}
static void match(){
String s = "ABABABABB";
String p = "BABB";
// SuffixArray.Suff[] sa = SuffixArray.getSa(s); // 后缀数组
Suff[] sa = getSa2(s); // 后缀数组
int l = 0;
int r = s.length()-1;
// 二分查找 ，nlog(m)
while(r>=l){
int mid = l + ((r-l)>>1);
// 居中的后缀
Suff midSuff = sa[mid];
// String suffStr = midSuff.str;
String suffStr = s.substring(midSuff.index);
int compareRes;
// 将后缀和模式串比较，O(n);
if (suffStr.length()>=p.length()) {
compareRes = suffStr.substring(0, p.length()).compareTo(p);
}else {
compareRes = suffStr.compareTo(p);
}
// 相等了 输出后缀的起始位置
if(compareRes == 0){
System.out.println(midSuff.index);
break;
}else if (compareRes<0) {
l = mid + 1;
}else {
r = mid - 1;
}
}
}
/**
* nlg²n 构建后缀数组
*
* @param src
* @return
*/
public static Suff[] getSa2(String src) {
int n = src.length();
Suff[] sa = new Suff[n];
for (int i = 0; i < n; i++) {
sa[i] = new Suff(src.charAt(i), i, src);// 存单个字符,接下来排序
}
Arrays.sort(sa);
/** rk是下标到排名的映射 */
int[] rk = new int[n];// suffix array
rk[sa[0].index] = 1;
for (int i = 1; i < n; i++) {
rk[sa[i].index] = rk[sa[i - 1].index];
if (sa[i].c != sa[i - 1].c)
rk[sa[i].index]++;
}
// 倍增法
for (int k = 2; rk[sa[n - 1].index] < n; k *= 2) {
final int kk = k;
Arrays.sort(sa, (o1, o2) -> {
// 不是基于字符串比较,而是利用之前的rank
int i = o1.index;
int j = o2.index;
if (rk[i] == rk[j]) {// 如果第一关键字相同
if (i + kk / 2 >= n || j + kk / 2 >= n)
return -(i - j);// 如果某个后缀不具有第二关键字,那肯定较小,索引靠后的更小
return rk[i + kk / 2] - rk[j + kk / 2];
} else {
return rk[i] - rk[j];
}
});
/*---排序 end---*/
// 更新rank
rk[sa[0].index] = 1;
for (int i = 1; i < n; i++) {
int i1 = sa[i].index;
int i2 = sa[i - 1].index;
rk[i1] = rk[i2];
try {
if (!src.substring(i1, i1 + kk).equals(src.substring(i2, i2 + kk)))
rk[i1]++;
} catch (Exception e) {
rk[i1]++;
}
}
}
return sa;
}
public static class Suff implements Comparable {
public char c;// 后缀内容
private String src;
public int index;// 后缀的起始下标
public Suff(char c, int index, String src) {
this.c = c;
this.index = index;
this.src = src;
}
@Override
public int compareTo(Suff o2) {
return this.c - o2.c;
}
@Override
public String toString() {
return "Suff{" + "char='" + src.substring(index) + '\'' + ", index=" + index + '}';
}
}
} ３、高度数组：
这个难，，直接粘代码好了
static int[] getHeight(String src,Suff[] sa){
// Suff[] sa = getSa2(src);
int strLength = src.length();
int []rk = new int[strLength];
// 因为原来的sa数组是按照字符串相同排名相同，现在调整排名为不重复的排名，重新排名后得到数组rk。
// 将rank表示为不重复的排名即0~n-1
for (int i = 0; i < strLength; i++) {
rk[sa[i].index] = i;
}
int []height = new int[strLength];
// （存在的规律是上一个下标i假如有k个公共前缀，并且k>0，
// 那么下一个下标至少有一个k-1个公共前缀，那么前k个字符是不用比较的）
// 利用这一点就可以O(n)求出高度数组
int k = 0;
for(int i=0;i 0)
k--;
for (; j + k < strLength && i + k < strLength; k++) {
if (src.charAt(j + k) != src.charAt(i + k))
break;
}
height[rk_i] = k;
}
return height;
} ４、尺取法例题：
描述
如果一个字符串恰好包含2个'h'、1个'i'和1个'o'，我们就称这个字符串是hiho字符串。
例如"oihateher"、"hugeinputhugeoutput"都是hiho字符串。
现在给定一个只包含小写字母的字符串S，小Hi想知道S的所有子串中，最短的hiho字符串是哪个。
思路：借鉴之前的尺取法：
此题大坑：要刚好是那个数，不能多也不能少
import java.util.Arrays;
import java.util.Scanner;
class Kruskal{
static char[] pat = {'h','i','o'};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int n = hiho(s);
System.out.println(n);
}
static int hiho(String s){
int len = s.length();
int lo = Integer.MAX_VALUE;
char []s_ch = s.toCharArray();
int start = -1;
int end = -1;
int j=0;
for(int i=0;i=2&&c2>=1&&c3>=1;
}
} ５、ｎｅｘｔ数组问题：（ｎｅｘｔ数组的正确求法）
http://acm.hdu.edu.cn/showproblem.php?pid=1358
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class test2{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List list = new ArrayList<>();
while (true){
int n = sc.nextInt();
if (n == 0) {
break;
}
String s = sc.next();
list.add(s); //字符串ｓ可以一次性加入
}
for(int j=0;j1){
System.out.println(i+" "+i/t);
}
}
System.out.println();
}
}
static int[] next(String s){
if(s ==null || s.length()==0) return null;
int[] next = new int[s.length()+1];//这里有一点点特殊，因为这个缀要包含自己本身，所以这里多开一个空间
next[0] = -1;
if(s.length() ==1){
return next;
}
next[1] =0;
int j=1;
int k= next[j];
while (j ６、后缀数组的应用题：
１、求最长重复子串：（可重叠，可交叉）
２、求最长重复子串（不可重复，不可交叉）
训练题：
１、fjxmlhx每天都在被沼跃鱼刷屏，因此他急切的找到了你希望你写一个程序屏蔽所有句子中的沼跃鱼(“marshtomp”，不区分大小写)。为了使句子不缺少成分，统一换成 “fjxmlhx” 。
输入
输入包括多行。
每行是一个字符串，长度不超过200。
一行的末尾与下一行的开头没有关系。
输出
输出包含多行，为输入按照描述中变换的结果。
样例输入
The Marshtomp has seen it all before.
marshTomp is beaten by fjxmlhx!
AmarshtompB样例输出
The fjxmlhx has seen it all before.
fjxmlhx is beaten by fjxmlhx!
AfjxmlhxB
思路：存储两个字符串，一个是原始的str1，一个是将原始字符串中的大写字母都变成小写字母的字符串str2，每次匹配都是用str2去匹配，然后得到位置，然后替换的时候是str1和str2相同位置都替换掉，最后输出str1即可。
import java.util.Scanner;
class Main{
static char[] str_ch= new char[200];
static char[] lower_ch = new char[200];
String s1 = "marshtomp";
String s2 = "fjxmlhx";
static StringBuffer sb1;
static StringBuffer sb2;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true){
String str = sc.nextLine();
StringBuffer sb1 = new StringBuffer(str);
String lower = str.toLowerCase();
StringBuffer sb2 = new StringBuffer(lower);
int position = lower.indexOf("marshtomp"); //java 这里不能写变量，只能写成字符串
while (position!=-1){
sb1.replace(position,position+9,"fjxmlhx");//第一个参数是起始位置，第二个是终止位置，，StringBuffer可以去替换一个长度不相等的字符串，因为他是可变的
sb2.replace(position,position+9,"fjxmlhx");
position = sb2.indexOf("marshtomp");
}
System.out.println(sb1.toString());
}
}
}然而，，，我太复杂了
(?i)即匹配时不区分大小写。表示匹配时不区分大小写。
import java.util.Scanner;
public class test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
String str = scan.nextLine();
str = str.replaceAll("(?i)marshtomp","fjxmlhx" );//字符串不可变，但是可以用ｒｅｐｌａｃｅ函数将其变化
System.out.print(str);
System.out.println();
}
}
}