字符串匹配---百度2018笔试

package school_employ_2018;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class ZiFuChuanPiPei {
    /**
     * 
     * 牛客网地址：https://www.nowcoder.com/questionTerminal/6e6ad6338289498da79b7afb60e823b3
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine();// 只有0和1
        String b = sc.nextLine();// 只有1 和 0 或者是？
        sc.close();
        /**
         * 输出有多少种可以再字符串中匹配
         */
        // 如果能匹配上，则去输入判断有几种可能
        int index = kmpStringMatch(a, b);
        // 判断b中有几个问号
        if (index == -1) {
            System.out.println(0);
            return;
        }
        int count = 0;//统计匹配的次数
        Set<String> elementSet = new HashSet<>();//根据Set不重复的特性，知道知道匹配的多少
        int start = kmpStringMatch(a, b);
        while (start != -1) {
            count++;
            elementSet.add(a.substring(start, start + b.length()));//往Set中添加数据
            a = a.substring(start+1);
            start = kmpStringMatch(a, b);
        }
        //System.out.println(count);
        System.out.println(elementSet.size());

    }
//KMP算法  网上找的
    public static int kmpStringMatch(String source, String pattern) {
        int i = 0;
        int j = 0;
        char[] s = source.toCharArray();
        char[] p = pattern.toCharArray();
        int slen = s.length;
        int plen = p.length;
        int[] next = getNext(p);
        while (i < slen && j < plen) {
            if (j == -1 || s[i] == p[j] || p[j] == '?') {
                ++i;
                ++j;
            } else {
                // 如果j != -1且当前字符匹配失败，则令i不变，
                // j = next[j],即让pattern模式串右移j - next[j]个单位
                j = next[j];
            }
        }
        if (j == plen)
            return i - j;
        else
            return -1;
    }

    private static int[] getNext(char[] p) {
        /**
         * 已知next[j] = k, 利用递归的思想求出next[j+1]的值 1.如果p[j] = p[k]，则next[j+1] = next[k] + 1;
         * 2.如果p[j] != p[k],则令k = next[k],如果此时p[j] == p[k],则next[j+1] = k+1
         * 如果不相等，则继续递归前缀索引，令k=next[k],继续判断，直至k=-1(即k=next[0])或者p[j]=p[k]为止
         */
        int plen = p.length;
        int[] next = new int[plen];
        int k = -1;
        int j = 0;
        next[0] = -1; // 这里采用-1做标识
        while (j < plen - 1) {
            if (k == -1 || p[j] == p[k]) {
                ++k;
                ++j;
                next[j] = k;
            } else {
                k = next[k];
            }
        }
        return next;
    }
}