Find substring with K distinct characters

Given a string and number K, find the substrings of size K with K distinct characters. If no, output empty list. Remember to emit the duplicate substrings, i.e. if the substring repeated twice, only output once.

• 字符串中等题。Sliding window algorithm + Hash。
• 使用移动窗口算法，两个指针标记window起点left/终点right，还有一个计数器count记录hit count，初始值为K。另外还有一个hash数组来记录当前window中所有char。
• 注意hit的条件是hash[i] == 0，代表当前window中没有重复char。如果hit，则-- count代表找到一个满足条件char。
• ++ hash[right]来标记已经在当前window中出现过，并扩展right。
• 如果window size为K，那么就可以判断如果count == 0，代表已经找到K个不重复的char，可以放入结果集。这里注意下需要用STL算法find()去重。
• 接着要把window往右移，同时对right char做过的操作进行恢复。
• 注意如果hash[left] == 1，代表以前满足过hash[right] == 0，所以需要-- count来恢复。而对于hash[left] > 1，因为重复char只会hit一次，只会对count + 1，所以不需要-- count，只要等到hash[left] == 1的时候再count - 1就行。同时因为left要移出window了，所以-- hash[left]来恢复，并右移left扩展到下一个window。
• find - C++ Reference
  • http://www.cplusplus.com/reference/algorithm/find/?kw=find

//
//  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<string> subStringKDist(string S, int K) {
        vector<string> vResult;
        
        // corner case
        if (S.empty()) return vResult;
        
        unordered_map<char, int>    hash;
        
        // window start/end pointer, hit count
        int left = 0, right = 0, count = K;
        
        while (right < S.size()) {
            if (hash[S.at(right)] == 0) // hit the condition 1 dup char
                -- count;
            
            ++ hash[S.at(right)]; // increase hash value to mark that the char exists in the current window
            
            ++ right; // move window end pointer rightward
            
            // window size reaches K
            if (right - left == K) {
                if (0 == count) { // find K distinct chars
                    if (find(vResult.begin(), vResult.end(), S.substr(left, K)) == vResult.end()) // using STL find() to avoid dup
                        vResult.push_back(S.substr(left, K));
                }

                // be careful for the restore condition. Count is only increased when hash[i] == 0, so only hash[i] == 1 means that count was increased.
                if (hash[S.at(left)] == 1)
                    ++ count;
                
                -- hash[S.at(left)]; // decrease to restore hash value
                
                ++ left; // move window start pointer rightward
            }
        }
        
        return vResult;
    }
};

int main(int argc, char* argv[])
{
    Solution    testSolution;
    
    vector<string>  sInputs = {"awaglknagawunagwkwagl", "abccdef", "", "aaaaaaa"};
    vector<int>     iInputs = {4, 2, 1, 2};
    vector<string>  result;
    
    /*
     {wagl aglk glkn lkna knag gawu awun wuna unag nagw agwk kwag }
     {ab bc cd de ef }
     {}
     {}
     */
    for (auto i = 0; i < sInputs.size(); ++ i) {
        result = testSolution.subStringKDist(sInputs[i], iInputs[i]);
        
        cout << "{";
        for (auto it : result)
            cout << it << " ";
        cout << "}" << endl;
    }

    return 0;
}