Question

最小窗口子字符串

这是来自Leetcode https://leetcode.com/problems/minimum-window-substring/

的问题

我找到了一个基于滑动窗口算法的解决方案，但我无法弄清楚时间复杂度。有人说它是O（N），但我认为不是。请帮助我，谢谢！

    public class Solution {
    // Minimum Window Algorithm, the algorithm must fit for specific problem, this problem is diff from ...words
    // 348ms
    public String minWindow(String s, String t) {
        int N = s.length(), M = t.length(), count = 0;
        String res = "";
        if (N < M || M == 0)    return res;
        int[] lib = new int[256], cur = new int[256];  // ASCII has 256 characters
        for (int i = 0; i < M; lib[t.charAt(i++)]++);  // count each characters in t
        for (int l = 0, r = 0; r < N; r++) {
            char c = s.charAt(r);
            if (lib[c] != 0) {
                cur[c]++;
                if (cur[c] <= lib[c])   count++;
                if (count == M) {
                    char tmp = s.charAt(l);
                    while (lib[tmp] == 0 || cur[tmp] > lib[tmp]) {
                        cur[tmp]--;
                        tmp = s.charAt(++l);
                    }
                    if (res.length() == 0 || r - l + 1 < res.length()) 
                        res = s.substring(l, r + 1);
                    count--;  // should add these three lines for the case cur[c] c is char in s but not the one visited
                    cur[s.charAt(l)]--;
                    l++;
                }
            }
        }
        return res;
    }
 }

Answer 1

有n个步骤将s中的每个字符添加到r位置

只有O（N）while个运算符 - 最多N个工作周期进行++l次运算，最多N次无价值检查while条件

如果我们不考虑s.substring，那么整体复杂性是线性的。

请注意，子串操作应该移出循环，我们必须只保留最佳索引对，并在最后获取子串。

Answer 2

check out my solution:

public class Solution {
    public String minWindow(String S, String T) {
        Map<Character, Integer> pattern = new HashMap<Character, Integer>();
        Map<Character, Integer> cur = new HashMap<Character, Integer>();
        Queue<Integer> queue = new LinkedList<Integer>();
        int min = Integer.MAX_VALUE;
        int begin = 0, end = 0;

        // fill in pattern by T
        for(int i = 0;i < T.length();i++) addToMap(pattern, T.charAt(i));

        // initialize current set
        for(int i = 0;i < T.length();i++) cur.put(T.charAt(i), 0);

        // go through S to match the pattern by minimum length
        for(int i = 0;i < S.length();i++){
            if(pattern.containsKey(S.charAt(i))){
                queue.add(i);
                addToMap(cur, S.charAt(i));
                // check if pattern is matched
                while(isMatch(pattern, cur)){  /* Important Code! */
                    if(i - queue.peek() < min){
                        min = i - queue.peek();
                        begin = queue.peek();
                        end = i+1;
                    }
                    cur.put(S.charAt(queue.peek()), cur.get(S.charAt(queue.peek()))-1);
                    queue.poll();
                }
            }
        }

        return end > begin?S.substring(begin, end):"";
    }

    private void addToMap(Map<Character, Integer> map, Character c){
        if(map.containsKey(c))
            map.put(c, map.get(c)+1);
        else
            map.put(c,1);
    }

    private boolean isMatch(Map<Character, Integer> p, Map<Character, Integer> cur){
        for(Map.Entry<Character, Integer> entry: p.entrySet())
            if(cur.get((char)entry.getKey()) < (int)entry.getValue()) return false;
        return true;
    }
}

最小窗口子串解我的解决方案的时间复杂度

2 个答案: