滑动窗口（最小覆盖子串）

package zsh;

import java.util.HashMap;
import java.util.Map;
/**
 * 76. 最小覆盖子串
 * 给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 ""
 * 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
 * 如果 s 中存在这样的子串，我们保证它是唯一的答案。
 *
 * 输入：s = "ADOBECODEBANC", t = "ABC"
 * 输出："BANC"
 */
public class MoveWindowLeecode76 {
    public static String minWindow(String s, String t) {
        int left = 0;
        int right = 0;
        int[] window = new int[128];  //滑动窗口中对应字母匹配的数量
        int min = Integer.MAX_VALUE;  //最小长度
        int start = 0;  //保存最小长度起始点
        int valid = 0;  //符合匹配字母数量
        Map<Character, Integer> map = new HashMap<Character, Integer>();  //存储匹配序列
        for(char c : t.toCharArray()){
            map.put(c, map.getOrDefault(c, 0)+1);
        }
        while(right < s.length()){
            char charR = s.charAt(right);
            right++;  //扩大右边
            if(map.containsKey(charR)){
                window[charR]++;
                if(window[charR] == map.get(charR)){
                    valid++;
                }
            }
            while(valid == map.size()){  //全部匹配
                if(right - left < min){
                    min = right - left;  //存储最短
                    start = left;
                }
                char charL = s.charAt(left);  //左边缩小
                left++;
                if(map.containsKey(charL)){  //和右操作相反
                    if(window[charL] == map.get(charL)){
                        valid--;
                    }
                    window[charL]--;
                }
            }
        }
        if(min != Integer.MAX_VALUE){
            return s.substring(start, start+min);
        }
        return "";
    }

    public static void main(String[] args) {
        String s = "ADOBECODEBANC";
        String t = "ABBC";
        String res = minWindow(s, t);
        System.out.println(res);
    }
}

二、数组匹配
对于两个单调递增序列s1，s2，在其中可能存在这样的子序列ss1，ss2。对于任意i有（ss1[i+1]-ss1[i]）=（ss2[i+1]-ss2[i]），请找出这些子序列中元素个数最多的子序列。
子序列定义：对于长度为N的序列S，从其中删除n个（0<=n<=N）元素后就得到一个子序列SS

输入
两个单挑递增序列，单个元素取值范围-10^9 到 10^9，0<N<=10000

输出
如果能找到子序列，则第一行输出子序列长度，第二三行输出子序列
如果有多个满足条件的子序列，输出元素最小子序列
如果找不到子序列，输出0

样例
样例1：
输入

1 2 3 4 5
2 4 6 8
1
2
输出

3
1 3 5
2 4 6
1
2
3
样例2
输入

1 2 3 4 5
2 7 12 17
1
2
输出

0
1
参考代码
用了双指针做，代码过了65%测试用例
————————————————
版权声明：本文为CSDN博主「Huntermanwp」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Huntermanwp/article/details/118380214

package zsh;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class MatchDifference {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s1 = scanner.nextLine();
        String[] ss1 = s1.trim().split(" ");
        int[] a1 = new int[ss1.length];
        for(int i = 0; i < ss1.length; i++){
            a1[i] = Integer.parseInt(ss1[i]);
        }
        String s2 = scanner.nextLine();
        String[] ss2 = s2.trim().split(" ");
        int[] a2 = new int[ss2.length];
        for(int i = 0; i < ss2.length; i++){
            a2[i] = Integer.parseInt(ss2[i]);
        }

        int pre1 = a1[0];
        int pre2 = a2[0];
        List<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        list1.add(a1[0]);
        list2.add(a2[0]);
        int count = 1;
        int i = 1, j = 1;
        while(i < a1.length && j < a2.length){
                int d1 = a1[i] - pre1;
                int d2 = a2[j] - pre2;
                if(d2 > d1){
                    i++;
                }
                else if(d2 < d1){
                    j++;
                }
                else{
                    pre1 = a1[i];
                    pre2 = a2[j];
                    list1.add(a1[i]);
                    list2.add(a2[j]);
                    i++;
                    j++;
                    count++;
                }
        }
        if(count == 1){
            System.out.println(0);
        }
        else {
            System.out.println(count);
            for (int k = 0; k < list1.size(); k++) {
                if (k == list1.size() - 1) {
                    System.out.println(list1.get(k));
                }
                else {
                    System.out.print(list1.get(k) + " ");
                }
            }
            for (int k = 0; k < list2.size(); k++) {
                if (k == list2.size() - 1) {
                    System.out.println(list2.get(k));
                }
                else {
                    System.out.print(list2.get(k) + " ");
                }
            }
        }
    }
}