【LeetCode - 727】最小窗口子序列

1、题目描述

2、解题思路

  把子序列的左右索引的区间称为窗口 window，它是一个只包含两个数字的数组，widow[0] 表示起始索引，window[1] 表示结束索引。

  先找出所有可能的 window。

  例如，T = “abcd”，那么，我就把 S 中所有的字符 ‘a’ 都先当成 window，窗口的起始索引和末尾索引都是 ‘a’ 所在的索引。

  如果 S = “abacadabcd”，则 windows = {{0，0}, {2,2}, {4,4}, {6,6}}

  接着对 T 的剩余元素，依次从 S 中找到距离起始索引最近的，更新 window 的末尾索引。

  例如，现在就是找 T 的第二个字符 ‘b’。

  对于 {0,0} 来说，最近它的 ‘b’ 就是索引 1 ，于是 {0,0} 更新为 {0，1};

  其他窗口以此类推，直到遍历完 T 的所有字符。

  最终对找齐 T 所有字符的窗口，找出区间最短的那个即可。

  通过思路可知，我们需要两个数组来帮助我们找齐 T 的所有字符。

  ‘a’ - ‘z’ 用数字 0 - 25 表示。

  定义一个一维数组 last[] 来保存每个字母第一次出现的位置，如 last[2] 表示字符串 S 中，‘c’ 字符从左到右第一次出现的索引。

  定义一个二维数组 next[][] 来保存最近的目标字母的位置，如 next[2][3] 表示字符串 S 的第 2 个索引开始到末尾，第一个出现的字符 ‘d’ 的索引。

  遍历字符串 S ，找出所有可能的 window，即把 S.charAt(i) == T.charAt(0) 的所有 i 都记录下来，变成 window = {i, i}。

  接着遍历 T 的剩余字符，为每一个 window 找到下一个字符。

  详细实现看代码。

3、解题代码

class Solution {
    public String minWindow(String S, String T) {
        int N = S.length();
        int[] last = new int[26];
        int[][] next = new int[N][26];
        Arrays.fill(last, -1);
        // 从后往前遍历
        for (int i = N - 1; i >= 0; i--) {
            // last[0] 表示第一个 'a' 的索引，last[2] 表示第一个 'c' 的索引
            last[S.charAt(i) - 'a'] = i;
            for (int k = 0; k < 26; k++) {
                // next[i][letter]，使其表示 S[i:] 中第一个出现的 letter 的位置，如果不存在则用 -1 表示
                // 例如 next[0][3] 表示 S 的第 i 位（包括第 i 位）后面第一个字符 'd' 的索引
                next[i][k] = last[k];
            }
        }

        // 记录所有可能的窗口的开头
        // 每个窗口就是一个两个元素的数组，window[0] 表示子序列开头索引，window[1] 表示子序列结尾索引
        List<int[]> windows = new ArrayList<>();
        for (int i = 0; i < N; ++i) {
            if (S.charAt(i) == T.charAt(0)) {
                windows.add(new int[]{i, i});
            }
        }

        for (int j = 1; j < T.length(); j++) {
            int letterIndex = T.charAt(j) - 'a';    // 字符 T.charAt(j) 在数组中的索引，'a' - 'z' 分别为 0 - 25
            // 遍历所有可能的窗口，给所有窗口不断寻找下一个末尾
            for (int[] window : windows) {
                if (window[1] < N - 1 && next[window[1] + 1][letterIndex] >= 0) {
                    // 窗口不能超出 S 的边界，并且有所需的下一个字符
                    window[1] = next[window[1] + 1][letterIndex];
                } else {
                    // 窗口超出边界，或者当前窗口的子序列没有所需的下一个字符
                    // 窗口作废，跳出当前 for
                    // 后面的窗口也不用处理了，因为当前窗口都没有下一个字符，后面的窗口更没有
                    window[0] = window[1] = -1;
                    break;
                }
            }
        }

        int[] ans = {-1, S.length()};
        for (int[] window : windows) {
            if (window[0] == -1) break; // -1 的就是已经无效的窗口
            if (window[1] - window[0] < ans[1] - ans[0]) {
                // 不断覆盖 ans，保证 ans 是 windows 中区间最小的那个
                ans = window;
            }

        }
        // 只要有满足要求的 window ，ans的区间就是有效值
        return ans[0] >= 0 ? S.substring(ans[0], ans[1] + 1) : "";
    }
}