Find minimum continuous subsequence tags

Given targetList, a list of strings representing the desired tags, and availableTagList, a list of strings representing the sequence of all available tags. Find the start index and end index of the minimus continuous subsequence containing all the desired tags in any order. If more that one results, return the one with the smaller start index.

Note:

• No dup tags in targetList.
• Returned subsequence may include additional tags beyond those in targetList.
• Consider only alphanumeric characters.
• Output 0 if no match. 

---

• 字符串中等题。Sliding window algorithem + Hash。
• 思想跟其他滑动窗口题一样，不同的是此题没有给出window size，而是要找最小window。还是对targetList建立hash表，然后扩展window end point去找到能包含所有targetList tags的window。找到之后，再移动window start point。这里跟其他题目不一样的地方是，window size并不固定，而且需要找最小window size，所以在满足count == 0条件下，扩展start point来缩小window，直到当前window已经不能包含所有tags。

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    vector<int> subSequenceTags(vector<string> targetList, vector<string> availableTagList) {
        vector<int> vResult;
        
        // corner case
        if (targetList.empty() || availableTagList.empty()) {
            vResult.push_back(0);
            return vResult;
        }
        
        unordered_map<string, int>  hash;
        
        for (auto & it : targetList)
            ++ hash[it];
        
        // window start/end point, hit count ( sum { positive hash[i] } ), min result length, result start index
        int left = 0, right = 0, count = targetList.size(), len = INT_MAX, start = 0;
        
        while (right < availableTagList.size()) {
            if (hash[availableTagList.at(right)] > 0) // could use == 1 as well coz that no dup in targetList
                -- count;
            
            -- hash[availableTagList.at(right)];
            
            ++ right;
            
            // continue move window start point rightward to minimize window until condition not valid
            while (0 == count) {
                if (right - left < len) {
                    len = right - left;
                    start = left;
                }
                
                if (hash[availableTagList.at(left)] >= 0) // could change the condition to == 0 if condition for -- count varies
                    ++ count;
                
                ++ hash[availableTagList.at(left)];
                
                ++ left;
            }
        }

        if (len != INT_MAX) {
            vResult.push_back(start);
            vResult.push_back(start + len - 1);
        } else
            vResult.push_back(0);   // Don't miss the empty result if no match
            
        return vResult;
    }
};

int main(int argc, char* argv[])
{
    Solution    testSolution;
    
    vector<vector<string>>  tInputs = {{"made", "in", "spain"}, {"2abc","bcd", "cab"}, {"in", "the", "spain"}, {"in"}, {}, {"in"}};
    vector<vector<string>>  aInputs = {{"made", "weather", "forecast", "says", "that", "made", "rain", "in", "spain", "stays"},
                                        {"dbc", "2abc", "cab", "bcd", "bcb"},
                                        {"the", "spain", "that", "the", "rain", "in", "spain", "stays", "forecast", "in", "the"},
                                        {"aa", "bb", "cc"},
                                        {"aa", "bb", "cc"},
                                        {}};
    vector<int>  result;
    
    /*
     5 8
     1 3
     3 6
     0
     0
     0
     */
    for (auto i = 0; i < tInputs.size(); ++ i) {
        result = testSolution.subSequenceTags(tInputs[i], aInputs[i]);
        
        for (auto it : result)
            cout << it << " ";
        cout << endl;
    }
    
    return 0;
}