For a fixed-size window the trick is to compute the first window in O(k), then slide one position at a time by adding the new right-hand element and subtracting the one that fell off the left. The running sum stays correct without re-summing K elements per step, which drops the runtime from O(n*k) to O(n). The same shape works for any aggregate that can be updated incrementally: count of true values, max via a monotonic deque, or a Counter for character frequencies. Always handle k > n and empty inputs explicitly.

Variable-size windows expand the right pointer one step at a time and shrink the left pointer in an inner while loop until the window is no longer valid (or no longer optimal). The amortized cost stays O(n) because each index enters the window at most once and leaves at most once. This template fits 'shortest / longest contiguous subarray that satisfies a constraint': sum, count of distinct, max minus min. The shape requires the constraint to be monotone in window size, which is why it does not work for arbitrary predicates.

When the constraint is 'all characters unique', a hash map of char -> last_seen_index lets you jump the left pointer past the previous occurrence in O(1). Guarding the jump with last[ch] >= left is what makes 'dvdf' return 3 instead of 2: an old occurrence of 'd' lives outside the current window and must not pull left backwards. This pattern generalizes to 'at most K distinct characters' (replace the dict check with a len(window_counter) > k shrink loop) and 'all from a target multiset' (Minimum Window Substring). The structure is the same; only the validity test changes.