<p>Given two strings <code>s</code> and <code>t</code> of lengths <code>m</code> and <code>n</code> respectively, return <em>the <strong>minimum window</strong></em> <span data-keyword="substring-nonempty"><strong><em>substring</em></strong></span><em> of </em><code>s</code><em> such that every character in </em><code>t</code><em> (<strong>including duplicates</strong>) is included in the window</em>. If there is no such substring, return <em>the empty string </em><code>&quot;&quot;</code>.</p>

<p>The testcases will be generated such that the answer is <strong>unique</strong>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;ADOBECODEBANC&quot;, t = &quot;ABC&quot;
<strong>Output:</strong> &quot;BANC&quot;
<strong>Explanation:</strong> The minimum window substring &quot;BANC&quot; includes &#39;A&#39;, &#39;B&#39;, and &#39;C&#39; from string t.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;a&quot;, t = &quot;a&quot;
<strong>Output:</strong> &quot;a&quot;
<strong>Explanation:</strong> The entire string s is the minimum window.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;a&quot;, t = &quot;aa&quot;
<strong>Output:</strong> &quot;&quot;
<strong>Explanation:</strong> Both &#39;a&#39;s from t must be included in the window.
Since the largest window of s only has one &#39;a&#39;, return empty string.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == s.length</code></li>
	<li><code>n == t.length</code></li>
	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
	<li><code>s</code> and <code>t</code> consist of uppercase and lowercase English letters.</li>
</ul>

<p>&nbsp;</p>
<p><strong>Follow up:</strong> Could you find an algorithm that runs in <code>O(m + n)</code> time?</p>

class Solution {
bool isValid(vector<int> &tHash, vector<int> &sHash){
    for(int i=0;i<256;i++){
        if(tHash[i]!=0 && tHash[i]>sHash[i]) return false;
    }
    return true;
}
public:
    string minWindow(string s, string t) {
        int maxLen=INT_MAX;
        int maxStart=-1, maxEnd=-1;

        vector<int> tHash(256, 0);
        // save all frequency of pattern T
        for(auto ch:t) tHash[ch]++;
        vector<int> sHash(256, 0);
        int l(0), r(0);

        // traverse in S
        while(r<s.size()){
            sHash[s[r]]++;
            // while char present at left has more instance then in pattern T
            // increment L
            while(sHash[s[l]]>tHash[s[l]] && l<r) {
                sHash[s[l]]--;
                l++;
            }
            // if tHash and sHash contains required number of character 
            // update len if needed
            if(isValid(tHash, sHash)){
                if(maxLen>r-l+1){
                    maxStart = l; maxEnd = r;
                    maxLen = r-l+1;
                }
            }
            r++;
        }
        // this is for edge case when r ends and given
        // l and r window is valid
        if(isValid(tHash, sHash)){
            if(maxLen>r-l){
                maxStart = l; maxEnd = r-1;
                maxLen = r-l;
            }
        }
        if(maxStart==-1) return "";
        string str = s.substr(maxStart, maxEnd-maxStart+1);
        return str;
    }
};
10700