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 = , right = , count = K;

         while (right < S.size()) {
             if (hash[S.at(right)] == ) // 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 ( == 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)] == )
                     ++ 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 = {, , , };
     vector<string>  result;

     /*
      {wagl aglk glkn lkna knag gawu awun wuna unag nagw agwk kwag }
      {ab bc cd de ef }
      {}
      {}
      */
     for (auto i = ; i < sInputs.size(); ++ i) {
         result = testSolution.subStringKDist(sInputs[i], iInputs[i]);

         cout << "{";
         for (auto it : result)
             cout << it << " ";
         cout << "}" << endl;
     }

     return ;
 }