第五章 字符串专题（下）

１、后缀数组

我在这里写的实在不形象，，推荐一篇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<strlength;i++){
            String suffi = src.substring(i);
            suffixarray[i] = new suff(suffi,i); //把字符串和源字符串的下标同时存入
        }
        Arrays.sort(suffixarray);//根据ｓｕｆｆ的比较规则进行排序
        return suffixarray;
    }
    public static class suff implements Comparable<suff>{//这里自定义他的原因是对字符串排序的话排玩没有索引，所以这里给他们缝在一起
        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<Suff> {
        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<strLength;i++){
            int rk_i = rk[i];  // i后缀的排名
            if (rk_i==0) {
                height[0] = 0;
                continue;
            }
            int rk_i_1 = rk_i - 1;
            int j = sa[rk_i_1].index;// j是i串字典序靠前的串的下标
            if (k > 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<len;i++){ // 字符串的每一个字母都在ｈｉｈｏ中查找一下，判断他是不是关键字
            char c = s_ch[i];
            int index = Arrays.binarySearch(pat,c);
            if(index <0){
                continue;
            }
            if(j==0) j = i+1;
            for(;j<len;){
                char c2 = s_ch[j];
                index  = Arrays.binarySearch(pat,c2);
                if(index <0 ){
                    j++;
                    continue;
                }
                if(containall(s_ch,i,j)){
                    if(check(s_ch,i,j) && j-i+1<lo){
                            lo = j-i+1;
                    }
                    break;  //如果这里发现的话直接跳过ｊ的循环就好了，直接从下一个ｉ开始就ｏｋ
                }
                j++;
            }
        }
        return lo;
    }
    static boolean check(char[] array,int i,int j){
        int c1=0,c2 =0,c3 =0;
        for(int k=i;k<=j;k++){
            if(array[k]=='h') c1++;
            if(array[k] =='i')c2++;
            if(array[k]=='o') c3++;
        }
        return c1==2 &&c2==1&& c3==1;
    }

    static boolean containall(char[] array,int i,int j){
        int c1=0,c2=0,c3=0;
        for(int k =i;k<=j;k++){
            if(array[k] == 'h') c1++;
            if(array[k] =='i')c2++;
            if(array[k]=='o') c3++;
        }
        return c1>=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<String > list = new ArrayList<>();
        while (true){
            int n = sc.nextInt();
            if (n == 0) {
                break;
            }
            String s = sc.next();
            list.add(s); //字符串ｓ可以一次性加入
        }
        for(int j=0;j<list.size();j++){
            String s = list.get(j);

            int[] next = next(s);
            System.out.println("The case # "+(j+1));
            boolean flag = false;
            for(int i =2;i<next.length;i++){
                int k = next[i];
                int t = i-k;
                if(i%t==0 && i/t>1){
                    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<s.length()){
            if(k==-1 || s.charAt(j) ==s.charAt(k)){
                next[++j] = ++k;
            }else {
                k = next[k];
            }
        }
        return next;
    }
}

６、后缀数组的应用题：

１、求最长重复子串：（可重叠，可交叉）

２、求最长重复子串（不可重复，不可交叉）

 

训练题：

１、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();
        }
    }
}