本文已参与「新人创作礼」活动，一起开启掘金创作之路。

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

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

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

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

输入: s = ""
输出: 0
 
提示：
0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size() == 0) return 0;

        unordered_map<char, int> map;
        int maxLen = 0;
        int curLen = 0;
        int startIndex = 0;
        int size = s.size();
        for(int i=0; i<size; i++) {//遍历字符串
            if(map.find(s[i]) == map.end()) {//如果没出现过该字符，加入子串,当前长度增加
                curLen++;
                map[s[i]] = i;
            }else {//如果出现过该字符，将当前长度与最大长度相比
                if(curLen > maxLen) {
                    maxLen = curLen;
                }
                //下标重新开始的地方是重复字符串出现的最后一次的下标
                //比如说：abbbcba
                //那么：第三个b就是重新开始的下标
                startIndex = max(map[s[i]], startIndex);
                curLen = i - startIndex;
                map[s[i]] = i;
            }
        }
        if(curLen > maxLen) {//这是最后一次当前长度和之前所有的最大长度来作比较，找出最大长度
            maxLen = curLen;
        }
        return maxLen;
    }
};

两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> map;
        int size = nums.size();

        for(int i=0; i<size; i++) {
            auto iter = map.find(target - nums[i]);
            if(iter != map.end()) {
                return {iter->second, i};
            }else {
                //map[nums[i]] = i;
                map.insert(pair<int, int> (nums[i], i));
            }
        }
        return {};
    }
};

三数之和

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> res;

        for(int i=0; i<nums.size(); i++) {
            if(nums[i] > 0) {
                return res;
            }
            if(i > 0 && nums[i] == nums[i-1]) {//去重
                continue;
            }

            int left = i + 1;
            int right = nums.size() - 1;

            while(left < right) {
                if(nums[i] + nums[left] > -nums[right]) {
                    right--;
                }else if(nums[i] + nums[left] < -nums[right]) {
                    left++;
                }else {
                    res.push_back(vector<int> {nums[i], nums[left], nums[right]});
                    //res.push_back(vector<int> (nums[i], nums[left], nums[right]));
                    //return vector<int, int> (nums[i], nums[left], nums[right]);

                    while(left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    while(left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }

                    //找到答案收缩双指针
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
};

四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        //int size = nums.size();

        for(int i=0; i<nums.size(); i++) {
            if(i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            for(int j=i+1; j<nums.size(); j++) {
                if(j > i+1 && nums[j] == nums[j-1]) {
                    continue;
                }

                int left = j+1;
                int right = nums.size() - 1;

                while(left < right) {
                    if(nums[i] + nums[j] > target - nums[left] - nums[right]) {
                        right--;
                    }else if(nums[i] + nums[j] < target - nums[left] - nums[right]) {
                        left++;
                    }else {
                        res.push_back(vector<int> {nums[i], nums[j], nums[left], nums[right]});
                        while(left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        while(left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }

                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
};