1 长度最小的子数组

1.1 题目链接

209. 长度最小的子数组

1.2 题目描述

给定一个含有 n ****个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 ****target ****的长度最小的 ****

子数组

 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度 。 如果不存在符合条件的子数组，返回 0 。

 

示例 1：

输入： target = 7, nums = [2,3,1,2,4,3]
输出： 2
解释： 子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入： target = 4, nums = [1,4,4]
输出： 1

示例 3：

输入： target = 11, nums = [1,1,1,1,1,1,1,1]
输出： 0

1.3 解法（滑动窗⼝）：

算法思路：

由于此问题分析的对象是⼀段连续的区间，因此可以考虑滑动窗⼝的思想来解决这道题。让滑动窗⼝满⾜：从 i 位置开始，窗⼝内所有元素的和⼩于 target （那么当窗⼝内元素之和第⼀次⼤于等于⽬标值的时候，就是 i 位置开始，满⾜条件的最⼩⻓度）。

做法：将右端元素划⼊窗⼝中，统计出此时窗⼝内元素的和：

• 如果窗⼝内元素之和⼤于等于 target ：更新结果，并且将左端元素划出去的同时继续判断是否满⾜条件并更新结果（因为左端元素可能很⼩，划出去之后依旧满⾜条件）
• 如果窗⼝内元素之和不满⾜条件： right++ ，另下⼀个元素进⼊窗⼝。

相信科学（这也是很多题解以及帖⼦没告诉你的事情：只给你说怎么做，没给你解释为什么这么做）：为何滑动窗⼝可以解决问题，并且时间复杂度更低？

• 这个窗⼝寻找的是：以当前窗⼝最左侧元素（记为 left1 ）为基准，符合条件的情况。也就是在这道题中，从 left1 开始，满⾜区间和 sum >= target 时的最右侧（记为right1 ）能到哪⾥。
• 我们既然已经找到从 left1 开始的最优的区间，那么就可以⼤胆舍去 left1 。但是如果继续像⽅法⼀⼀样，重新开始统计第⼆个元素（ left2 ）往后的和，势必会有⼤量重复的计算（因为我们在求第⼀段区间的时候，已经算出很多元素的和了，这些和是可以在计算下次区间和的时候⽤上的）。
• 此时， rigth1 的作⽤就体现出来了，我们只需将 left1 这个值从 sum 中剔除。从right1 这个元素开始，往后找满⾜ left2 元素的区间（此时 right1 也有可能是满⾜的，因为 left1 可能很⼩。 sum 剔除掉 left1 之后，依旧满⾜⼤于等于target ）。这样我们就能省掉⼤量重复的计算。
• 这样我们不仅能解决问题，⽽且效率也会⼤⼤提升。 时间复杂度：虽然代码是两层循环，但是我们的 left 指针和 right 指针都是不回退的，两者

最多都往后移动 n 次。因此时间复杂度是 O(N) 。

1.4 C++算法代码：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0, len = INT_MAX;
        int n = nums.size();
        for(int left = 0, right = 0; right < n; right++)
        {
            sum += nums[right];  //进窗口
            while(sum >= target)  //判断
            {
                len = min(len, right - left +1);  //更新结果
                sum -= nums[left++];  //出窗口
            }
        }
        return len == INT_MAX ? 0 : len;
    }
};

2 无重复字符的最长子串

2.1 题目链接

3. 无重复字符的最长子串

2.2 题目描述

给定一个字符串 s ，请你找出其中不含有重复字符的 **最长 **

子串

****的长度。

 

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列， 不是子串。

2.3 解法（滑动窗⼝）：

算法思路：

研究的对象依旧是⼀段连续的区间，因此继续使⽤滑动窗⼝思想来优化。

让滑动窗⼝满⾜：窗⼝内所有元素都是不重复的。

做法：右端元素 ch 进⼊窗⼝的时候，哈希表统计这个字符的频次：

• 如果这个字符出现的频次超过 1 ，说明窗⼝内有重复元素，那么就从左侧开始划出窗⼝，直到 ch 这个元素的频次变为 1 ，然后再更新结果。
• 如果没有超过 1 ，说明当前窗⼝没有重复元素，可以直接更新结果

2.4 C++算法代码：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int left = 0, right = 0, n = s.size();
        int ret = 0;
        int hash[128] = { 0 };  // 使⽤数组来模拟哈希表
        while(right < n)
        {
            hash[s[right]]++;  //进窗口
            while(hash[s[right]] > 1)  //判断
                hash[s[left++]]--;  //出窗口
            ret = max(ret, right - left + 1);  //更新结果
            right++;  //让下一个元素进入窗口
        }
        return ret;
    }
};

3 最大连续1的个数 III

3.1 题目链接

1004. 最大连续1的个数 III

3.2 题目描述

给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。

 

示例 1：

输入： nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出： 6
解释： [1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。

示例 2：

输入： nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出： 10
解释： [0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。

3.3 解法（滑动窗⼝）：

算法思路：

不要去想怎么翻转，不要把问题想的很复杂，这道题的结果⽆⾮就是⼀段连续的 1 中间塞了 k个 0 嘛。

因此，我们可以把问题转化成：求数组中⼀段最⻓的连续区间，要求这段区间内 0 的个数不超过 k 个。

既然是连续区间，可以考虑使⽤「滑动窗⼝」来解决问题。

算法流程：

• a. 初始化⼀个⼤⼩为 2 的数组就可以当做哈希表 hash 了；初始化⼀些变量 left = 0 ,right = 0 , ret = 0 ；
• b. 当 right ⼩于数组⼤⼩的时候，⼀直下列循环：
  • i. 让当前元素进⼊窗⼝，顺便统计到哈希表中；
  • ii. 检查 0 的个数是否超标：
    • 如果超标，依次让左侧元素滑出窗⼝，顺便更新哈希表的值，直到 0 的个数恢复正常；
  • iii. 程序到这⾥，说明窗⼝内元素是符合要求的，更新结果；
  • iv. right++ ，处理下⼀个元素；
• c. 循环结束后， ret 存的就是最终结果。

3.4 C++算法代码：

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int ret = 0;
        for(int left = 0, right = 0, zero = 0; right < nums.size(); right++)
        {
            if(nums[right] == 0) zero++;  //进窗口
            while(zero > k)  //判断
                if(nums[left++] == 0) zero--;  //出窗口
            ret = max(ret, right - left + 1);  //更新结果
        }
        return ret;
    }
};

4 将 x 减到 0 的最小操作数

4.1 题目链接

1658. 将 x 减到 0 的最小操作数

4.2 题目描述

给你一个整数数组 nums 和一个整数 x 。每一次操作时，你应当移除数组 nums 最左边或最右边的元素，然后从 x 中减去该元素的值。请注意，需要 修改 数组以供接下来的操作使用。

如果可以将 x 恰好 减到 0 ，返回 最小操作数 ；否则，返回 -1 。

 

示例 1：

输入： nums = [1,1,4,2,3], x = 5
输出： 2
解释： 最佳解决方案是移除后两个元素，将 x 减到 0 。

示例 2：

输入： nums = [5,6,7,8,9], x = 4
输出： -1

示例 3：

输入： nums = [3,2,20,1,1,3], x = 10
输出： 5
解释： 最佳解决方案是移除后三个元素和前两个元素（总共 5 次操作），将 x 减到 0 。

4.3 解法（滑动窗⼝）：

算法思路：

题⽬要求的是数组左端+右端两段连续的、和为 x 的最短数组，信息量稍微多⼀些，不易理清思路；我们可以转化成求数组内⼀段连续的、和为 sum(nums) - x 的最⻓数组。此时，就是熟悉的滑动窗⼝问题了。

算法流程：

• a. 转化问题：求 target = sum(nums) - x 。如果 target < 0 ，问题⽆解；
• b. 初始化左右指针 l = 0 , r = 0 （滑动窗⼝区间表⽰为[l,r)，左右区间是否开闭很重要，必须设定与代码⼀致），记录当前滑动窗⼝内数组和的变量 sum = 0 ，记录当前满⾜条件数组的最⼤区间⻓度 maxLen = -1 ；
• c. 当 r ⼩于等于数组⻓度时，⼀直循环：
  • i. 如果 sum < target ，右移右指针，直⾄变量和⼤于等于 target ，或右指针已经移到头；
  • ii. 如果 sum > target ，右移左指针，直⾄变量和⼩于等于 target ，或左指针已经移到头；
  • iii. 如果经过前两步的左右移动使得 sum == target ，维护满⾜条件数组的最⼤⻓度，并让下个元素进⼊窗⼝；
• d. 循环结束后，如果 maxLen 的值有意义，则计算结果返回；否则，返回 -1 。

4.4 C++算法代码：

class Solution {
public:
    int minOperations(vector<int>& nums, int x) {
        int sum = 0;
        for(auto e : nums) sum += e;
        int target = sum - x;
        if(target < 0) return -1;  // 细节问题
        int ret =-1;
        for(int left = 0, right = 0, tmp = 0; right < nums.size(); right++)
        {
            tmp += nums[right]; //进窗口
            while(tmp > target) tmp -= nums[left++];  //判断 出窗口
            if(tmp == target) ret = max(ret, right - left + 1);  //更新结果
        }
        return ret == -1 ? -1 : nums.size() - ret;
    }
};

5 水果成篮

5.1 题目链接

904. 水果成篮

5.2 题目描述

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

• 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
• 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
• 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

 

示例 1：

输入： fruits = [1,2,1]
输出： 3
解释： 可以采摘全部 3 棵树。

示例 2：

输入： fruits = [0,1,2,2]
输出： 3
解释： 可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：

输入： fruits = [1,2,3,2,2]
输出： 4
解释： 可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：

输入： fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出： 5
解释： 可以采摘 [1,2,1,1,2] 这五棵树。

5.3 解法（滑动窗⼝）：

算法思路：

研究的对象是⼀段连续的区间，可以使⽤「滑动窗⼝」思想来解决问题。

让滑动窗⼝满⾜：窗⼝内⽔果的种类只有两种。

做法：右端⽔果进⼊窗⼝的时候，⽤哈希表统计这个⽔果的频次。这个水果进来后，判断哈希表的⼤⼩：

• 如果⼤⼩超过 2：说明窗⼝内⽔果种类超过了两种。那么就从左侧开始依次将⽔果划出窗⼝，直到哈希表的⼤⼩⼩于等于 2，然后更新结果；
• 如果没有超过 2，说明当前窗⼝内⽔果的种类不超过两种，直接更新结果 ret。

算法流程：

• a. 初始化哈希表 hash 来统计窗⼝内⽔果的种类和数量；
• b. 初始化变量：左右指针 left = 0，right = 0，记录结果的变量 ret = 0；
• c. 当 right ⼩于数组⼤⼩的时候，⼀直执⾏下列循环：
  • i. 将当前⽔果放⼊哈希表中；
  • ii. 判断当前⽔果进来后，哈希表的⼤⼩：
    • 如果超过 2：
      • 将左侧元素滑出窗⼝，并且在哈希表中将该元素的频次减⼀；
      • 如果这个元素的频次减⼀之后变成了 0，就把该元素从哈希表中删除；
      • 重复上述两个过程，直到哈希表中的⼤⼩不超过 2；
  • iii. 更新结果 ret；
  • iv. right++，让下⼀个元素进⼊窗⼝；
• d. 循环结束后，ret 存的就是最终结果。

5.4 C++算法代码：

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int, int> hash;  // 统计窗⼝内出现了多少种⽔果
        int ret = 0;
        for(int left = 0, right = 0; right < fruits.size(); right++)
        {
            hash[fruits[right]]++;  //进窗口
            while(hash.size() > 2)  //判断
            {
                //出窗口
                hash[fruits[left]]--;
                if(hash[fruits[left]] == 0)
                    hash.erase(fruits[left]);
                left++;
            }
            ret = max(ret, right - left + 1);
        }
        return ret;
    }
};

6 找到字符串中所有字母异位词

6.1 题目链接

438. 找到字符串中所有字母异位词

6.2 题目描述

给定两个字符串 s 和 p，找到 s ****中所有 p ****的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

 

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

6.3 解法（滑动窗⼝ + 哈希表）：

算法思路：

• 因为字符串 p 的异位词的⻓度⼀定与字符串 p 的⻓度相同，所以我们可以在字符串 s 中构造⼀个⻓度为与字符串 p 的⻓度相同的滑动窗⼝，并在滑动中维护窗⼝中每种字⺟的数量；
• 当窗⼝中每种字⺟的数量与字符串 p 中每种字⺟的数量相同时，则说明当前窗⼝为字符串 p的异位词；
• 因此可以⽤两个⼤⼩为 26 的数组来模拟哈希表，⼀个来保存 s 中的⼦串每个字符出现的个数，另⼀个来保存 p 中每⼀个字符出现的个数。这样就能判断两个串是否是异位词。

6.4 C++算法代码：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> ret;
        int hash1[26] = { 0 };  // 统计字符串 p 中每个字符出现的个数
        for(auto e : p) hash1[e-'a']++;

        int hash2[26] = { 0 };  // 统计窗⼝⾥⾯的每⼀个字符出现的个数
        int n = p.size();
        for(int left = 0, right = 0, count = 0; right < s.size(); right++)
        {
            char in = s[right];
            // 进窗⼝ + 维护 count
            // hash2[in - 'a']++;
            if(++hash2[in - 'a'] <= hash1[in - 'a']) count++;
            if(right - left + 1 > n)  // 判断
            {
                char out = s[left++];  // 出窗⼝ + 维护 count
                if(hash2[out - 'a']-- <= hash1[out - 'a']) count--;
            }
            // 更新结果
            if(count == n) ret.push_back(left);
        }
        return ret;
    }
};

7 串联所有单词的子串

7.1 题目链接

30. 串联所有单词的子串

7.2 题目描述

给定一个字符串 s ****和一个字符串数组 words 。 words 中所有字符串 长度相同。

 s ****中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。

• 例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。

返回所有串联子串在 s ****中的开始索引。你可以以 任意顺序 返回答案。

 

示例 1：

输入： s = "barfoothefoobarman", words = ["foo","bar"]
输出： [0,9]
解释： 因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
输出顺序无关紧要。返回 [9,0] 也是可以的。

示例 2：

输入： s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出： []
解释： 因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。

示例 3：

输入： s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出： [6,9,12]
解释： 因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。

7.3 解法

算法思路：

如果我们把每⼀个单词看成⼀个⼀个字⺟，问题就变成了找到字符串中所有的字⺟异位词。⽆⾮就是之前处理的对象是⼀个⼀个的字符，我们这⾥处理的对象是⼀个⼀个的单词。

7.4 C++算法代码：

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> ret;
        unordered_map<string, int> hash1; // 保存 words 里面所有单词的频次
        for(auto e : words) hash1[e]++;

        int len = words[0].size(),m = words.size();
        for(int i = 0;i < len; i++) // 执行 len 次
        {
            unordered_map<string, int> hash2; // 维护窗口内单词的频次
            for(int left = i, right = i, count = 0; right +len <= s.size(); right += len)
            {
                // 进窗口 + 维护 count
                string in = s.substr(right, len);
                hash2[in]++;
                if(hash1.count(in) && hash2[in] <= hash1[in]) count++;
                // 判断
                if(right - left + 1 > len * m)
                {
                    // 出窗口 + 维护 count
                    string out = s.substr(left, len);
                    if(hash1.count(out) && hash2[out] <= hash1[out]) count--;
                    hash2[out]--;
                    left += len;
                }
                // 更新结果
                if(count == m) ret.push_back(left);
            }
        }
        return ret;
    }
};

8 最小覆盖子串

8.1 题目链接

76. 最小覆盖子串

8.2 题目描述

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

 

注意：

• 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
• 如果 s 中存在这样的子串，我们保证它是唯一的答案。

 

示例 1：

输入： s = "ADOBECODEBANC", t = "ABC"
输出： "BANC"
解释： 最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

输入： s = "a", t = "a"
输出： "a"
解释： 整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

8.3 解法（滑动窗⼝ + 哈希表）：

算法思路：

• 研究对象是连续的区间，因此可以尝试使⽤滑动窗⼝的思想来解决。
• 如何判断当前窗⼝内的所有字符是符合要求的呢？
  • 我们可以使⽤两个哈希表，其中⼀个将⽬标串的信息统计起来，另⼀个哈希表动态的维护窗⼝内字符串的信息。
  • 当动态哈希表中包含⽬标串中所有的字符，并且对应的个数都不⼩于⽬标串的哈希表中各个字符的个数，那么当前的窗⼝就是⼀种可⾏的⽅案。

算法流程：

• a. 定义两个全局的哈希表： 1 号哈希表 hash1 ⽤来记录⼦串的信息， 2 号哈希表 hash2⽤来记录⽬标串 t 的信息；
• b. 实现⼀个接⼝函数，判断当前窗⼝是否满⾜要求：
  • i. 遍历两个哈希表中对应位置的元素：
    • 如果 t 中某个字符的数量⼤于窗⼝中字符的数量，也就是 2 号哈希表某个位置⼤于1 号哈希表。说明不匹配，返回 false ；
    • 如果全都匹配，返回 true 。

主函数中：

• a. 先将 t 的信息放⼊ 2 号哈希表中；
• b. 初始化⼀些变量：左右指针： left = 0，right = 0 ；⽬标⼦串的⻓度： len =INT_MAX ；⽬标⼦串的起始位置： retleft ；（通过⽬标⼦串的起始位置和⻓度，我们就能找到结果）
• c. 当 right ⼩于字符串 s 的⻓度时，⼀直下列循环：
  • i. 将当前遍历到的元素扔进 1 号哈希表中；
  • ii. 检测当前窗⼝是否满⾜条件：
    • 如果满⾜条件：
      • 判断当前窗⼝是否变⼩。如果变⼩：更新⻓度 len ，以及字符串的起始位置retleft ；
      • 判断完毕后，将左侧元素滑出窗⼝，顺便更新 1 号哈希表；◦ 重复上⾯两个过程，直到窗⼝不满⾜条件；
  • iii. right++ ，遍历下⼀个元素；
• d. 判断 len 的⻓度是否等于 INT_MAX ：
  • i. 如果相等，说明没有匹配，返回空串；
  • ii. 如果不想等，说明匹配，返回 s 中从 retleft 位置往后 len ⻓度的字符串。

8.4 C++算法代码：

class Solution {
public:
    string minWindow(string s, string t) {
        int hash1[128] = { 0 };  // 统计字符串t中每一个字符的频次
        int kinds = 0;  // 统计有效字符有多少种
        for(auto e : t)
            if(hash1[e]++ == 0) kinds++;
        int hash2[128] = { 0 };  // 统计窗口内每个字符的频次

        int minlen = INT_MAX, begin = -1;
        for(int left = 0, right = 0, count = 0; right < s.size(); right++)
        {
            char in =s[right];
            //hash2[in]++;
            if(++hash2[in] == hash1[in]) count++;  // 进窗口 + 维护 count
            while(count == kinds)  // 判断条件
            {
                if(right - left + 1 < minlen)  // 更新结果
                {
                    minlen = right - left + 1;
                    begin = left;
                }
                char out = s[left++];
                if(hash2[out]-- == hash1[out]) count--;  // 出窗口 + 维护 count
            } 
        }
        if(begin == -1) return "";
        else return s.substr(begin, minlen);
    }
};