KMP.Manacher.滑动窗口.单调栈

KMP

算法描述

分析

在两字符串str1和srt2长度内从0开始比较，i1和i2表示下标，若当前字符相等，下标同时++，若当前字符不等，如果next[i2]为-1，表示str2中比对的位置不能再向前跳了，此时i1++，表示从下一位置，从新开始比较，若不为-1，表示有值，让i2 = next[i2]进行比较，循环结束，表示找到下标或者没找到，如果i2 == str2.length表示找到最后，返回i1 - i2即为开始位置，否则返回-1表示未找到

next数组求法
next数组表示当前位置前面字符串的前后缀最大相等长度，所以0位置为-1，表示没有，1位置为0，所以从2位置开始找，每个位置可由前面位置得出如i位置可通过判断 i-1位置的值下一位和i-1比较如果相等表示i位置值为i-1位置 + 1，不等则继续将i - 1的值继续得出next中的值c，判断下一位是否等一i-1，相等则表示为当前i的值为c + 1，不等则继续如此，知道next为0表示无法通过前面的值得出，则i的next值为0

Code

public class Code01_KMP {

	public static int getIndexOf(String s, String m) {
		if (s == null || m == null || m.length() < 1 || s.length() < m.length()) {
			return -1;
		}
		char[] str1 = s.toCharArray();
		char[] str2 = m.toCharArray();
		int i1 = 0;
		int i2 = 0;
		int[] next = getNextArray(str2);
		while (i1 < str1.length && i2 < str2.length) {
			if (str1[i1] == str2[i2]) {
				i1++;
				i2++;
			} else if (next[i2] == -1) {
				i1++;
			} else {
				i2 = next[i2];
			}
		}
		return i2 == str2.length ? i1 - i2 : -1;
	}

	public static int[] getNextArray(char[] ms) {
		if (ms.length == 1) {
			return new int[] { -1 };
		}
		int[] next = new int[ms.length];
		next[0] = -1;
		next[1] = 0;
		int i = 2;
		int cn = 0;
		while (i < next.length) {
			if (ms[i - 1] == ms[cn]) {
				next[i++] = ++cn;
			} else if (cn > 0) {
				cn = next[cn];
			} else {
				next[i++] = 0;
			}
		}
		return next;
	}

	public static void main(String[] args) {
		String str = "abcabcababaccc";
		String match = "ababa";
		System.out.println(getIndexOf(str, match));

	}

}

Manacher

算法描述

分析

Code

public class Code02_Manacher {

	public static char[] manacherString(String str) {
		char[] charArr = str.toCharArray();
		char[] res = new char[str.length() * 2 + 1];
		int index = 0;
		for (int i = 0; i != res.length; i++) {
			res[i] = (i & 1) == 0 ? '#' : charArr[index++];
		}
		return res;
	}

	public static int maxLcpsLength(String str) {
		if (str == null || str.length() == 0) {
			return 0;
		}
		char[] charArr = manacherString(str);// 1221 -> #1#2#2#2#1#
		int[] pArr = new int[charArr.length]; //回文半径数组
		int C = -1;//中心
		int R = -1;//回文右边界再往右一个位置，最右的有效区是R-1位置
		int max = Integer.MIN_VALUE;//扩初来的最大值
		for (int i = 0; i != charArr.length; i++) {//每一个为位置都求回文半径

			pArr[i] = R > i ? Math.min(pArr[2 * C - i], R - i) : 1;
			while (i + pArr[i] < charArr.length && i - pArr[i] > -1) {
				if (charArr[i + pArr[i]] == charArr[i - pArr[i]])
					pArr[i]++;
				else {
					break;
				}
			}
			if (i + pArr[i] > R) {
				R = i + pArr[i];
				C = i;
			}
			max = Math.max(max, pArr[i]);
		}
		return max - 1;
	}

	public static void main(String[] args) {
		String str1 = "abc1234321ab";
		System.out.println(maxLcpsLength(str1));
	}

}

滑动窗口

算法描述

分析

w维护一个双端队列表示滑动窗口，存储目标数组的下标，队列永远从大到小，每次窗口移动，即增加一个和删除一个，从队尾比较，如果小于队尾直接加入，否则polltail继续比较，直到大于队尾或队列为空，加入，然后判断当前队首存活时间，即list.peekFirst是否等于i-w，w为窗口大小，若相等表示存活了滑动窗口大小的次数，应该出队列，在增加删除操作完成后即可获取队首的元素即为滑动窗口当前位置最大值

Code

public static int[] getMaxWindow(int[] arr, int w) {
		if (arr == null || w < 1 || arr.length < w) {//判断界限
			return null;
		}
		LinkedList<Integer> qmax = new LinkedList<Integer>();//永远由大到小
		int[] res = new int[arr.length - w + 1];
		int index = 0;
		for (int i = 0; i < arr.length; i++) {
			while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[i]) {//R右移 不符合顺序剔除
				qmax.pollLast();
			}
			qmax.addLast(i);
			if (qmax.peekFirst() == i - w) {
				qmax.pollFirst();
			}
			if (i >= w - 1) {
				res[index++] = arr[qmax.peekFirst()];
			}
		}
		return res;
	}

单调栈

算法描述

分析

设单调栈stack从大到小，记录目标数组的下标，先将 5，4，3顺序入栈，然后到6，6 > 3所以3弹出，3的右边即是6 左边即为3的下一个元素4，记录对应下标，现在还是6 > 4所以4弹出，4的右边即是6 左边即为下一个元素5 ，现在是6 > 5 ,弹出5，5的右边即是6 左边为下一个元素 此时栈空所以为-1表示没有，重复上述步骤即可获得
当遍历结束，栈内不为空，依次弹出，左边通过下一个判断，右边由于已经遍历结束，都为-1，表示没有
对于重复元素的情况，可将栈维护的对象更改为一条链表，记录下标，重复的元素，加入链表，弹出时只弹出一条记录，左边依旧通过下一条链表判断 如果链表里面有相同的值 就取最晚加入的 即代表离上一个最近的

Code

// O(n)，无重复元素的单调栈
public static int[][] getNearLessNoRepeat(int[] arr) {
    int[][] res = new int[arr.length][2];
    Stack<Integer> stack = new Stack<>(); // 单调栈
    for (int i = 0; i < arr.length; i++) {
        while (!stack.isEmpty() && arr[i] < stack.peek()) { // 若当前位置元素[小于]栈顶位置元素，则一直弹出栈顶元素，直到不小于为止
            int popIndex = stack.pop();
            int leftLessIndex = stack.isEmpty() ? -1 : stack.peek(); // 栈中当前元素上方的元素
            res[popIndex][0] = leftLessIndex; // 记录弹出元素[左边]，[第一个小于弹出元素的元素]的下标
            res[popIndex][1] = i;             // 记录弹出元素[右边]，[第一个小于弹出元素的元素]的下标
        }
        stack.push(i); // 当前元素入栈
    }
    // 遍历完成，对栈中剩余元素进行清算
    while (!stack.isEmpty()) {
        int popIndex = stack.pop();
        int leftIndex = stack.isEmpty() ? -1 : stack.peek();
        res[popIndex][0] = leftIndex;
        res[popIndex][1] = -1;
    }
    return res;
}
//有重复元素的单调栈
public static int[][] getNearLess(int[] arr) {
		int[][] res = new int[arr.length][2];
		Stack<List<Integer>> stack = new Stack<>();
		for (int i = 0; i < arr.length; i++) {
			while (!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]) {
				List<Integer> popIs = stack.pop();
				// 取位于下面位置的列表中，最晚加入的那个
				int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(
						stack.peek().size() - 1);
				for (Integer popi : popIs) {
					res[popi][0] = leftLessIndex;
					res[popi][1] = i;
				}
			}
			if (!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]) {
				stack.peek().add(Integer.valueOf(i));
			} else {
				ArrayList<Integer> list = new ArrayList<>();
				list.add(i);
				stack.push(list);
			}
		}
		while (!stack.isEmpty()) {
			List<Integer> popIs = stack.pop();
			// 取位于下面位置的列表中，最晚加入的那个
			int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(
					stack.peek().size() - 1);
			for (Integer popi : popIs) {
				res[popi][0] = leftLessIndex;
				res[popi][1] = -1;
			}
		}
		return res;
	}
	```