lintcode--最小子串覆盖

题目描述：
给定一个字符串source和一个目标字符串target，在字符串source中找到包括所有目标字符串字母的子串。

注意事项：
如果在source中没有这样的子串，返回”“，如果有多个这样的子串，返回起始位置最小的子串。

说明:
在答案的子串中的字母在目标字符串中是否需要具有相同的顺序？
——不需要。

样例：
给出source = “ADOBECODEBANC”，target = “ABC” 满足要求的解 “BANC”

思路讲解：
我们首先将目标字符串映射到一个大小为128的hash_target数组，然后我们建立一个同样的hash数组，然后遍历source这个字符串，并用两个指针begin和end，每次都将字符与target的没以恶搞字符比较，然后将其在hash中对应的位置加一，并将其与hash_target比较，如果是，则说明找到一个子串可以包含target的，然后我们将从begin开始，逐个删除字符（这一步是为了得到最小的子串包含target的），如果删除之后，hash还是比hash_target大，说明找到了一个较小的子串；如果没有就从end开始继续遍历source，这样就可以得到了最小的子串。
举个栗子：
ADOBECODEBANC
a.当begin=0时，hash为空，显然不满足子串，则将end后移直至end=5时。此时hash的计数为A=1，B=1，C=1，满足子串要求，此时最小子串为ADOBEC，长度为6。最后将A的计数减1，此时hash的计数为A=0，B=1，C=1。
b.当begin=1时，由于hash不满足子串要求，则继续步骤a直至end=10。此时hash的计数为A=1，B=2，C=1，最小子串为DOBECODEBA，长度为10。然后将D去掉，此时hash的计数为A=1，B=2，C=1。
c.当begin=2时，最小子串为OBECODEBA，直至begin=6时，hash的计数为A=1，B=2，C=0，将end继续向后移动至最后一位，hash重新满足子串要求。再继续重复上述步骤可获取最小子串。

代码详解：

class Solution {public:    /*     * @param source : A string     * @param target: A string     * @return: A string denote the minimum window, return "" if there is no such a string     */    string minWindow(string &source , string &target) {        // write your code here        int length=target.length();        if(source=="")        return "";        vector<int> hash(128,0);        vector<int> hash_target(128,0);        for(int i=0;i<length;i++)//初始化target的映射        {            hash_target[target[i]]++;        }        int begin,end;        begin=0,end=0;        int sublength=INT_MAX,low=0,high=0;        while(end<source.length())        {            if(!judge_contain_target(hash,hash_target))//如果没有找到子串，就继续找            {                for(int i=0;i<length;i++)                {                    if(target[i]==source[end]){                        hash[target[i]]++;                        break;                    }                }                end++;            }            if(judge_contain_target(hash,hash_target)){//如果找到子串，就看是否存在较短的子串                if(sublength>(end-begin)){                    sublength=end-begin;                    low=begin;                    high=end;                }                for(int i=0;i<length;i++)                {                    if(target[i]==source[begin]){                        hash[target[i]]--;                        break;                    }                }                begin++;            }        }        while(judge_contain_target(hash,hash_target))//特殊情况的处理例如：aaaaaaaabcd和abcd        {           if(sublength>(end-begin)){                    sublength=end-begin;                    low=begin;                    high=end;                }                for(int i=0;i<length;i++)                {                    if(target[i]==source[begin]){                        hash[target[i]]--;                        break;                    }                }                begin++;         }        if(sublength==INT_MAX){            return "";        }        else{            return source.substr(low,sublength);        }    }    bool judge_contain_target(vector<int>hash,vector<int>hash_target)//判断是否找到了子串    {        for(int i=0;i<128;i++)        {            if(hash[i]<hash_target[i]){                return false;            }        }        return true;    }};