hot100_双指针

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int sz = nums.size();
        vector<vector<int>> res;
        if (sz < 3)
            return {};
        sort(nums.begin(), nums.end());
        for (int i = 0; i < sz; i++)
        {
            if (i > 0 && nums[i] == nums[i-1])
                continue;
            int l = i+1, r = sz-1;
            while (l < r)
            {
                int val = nums[i] + nums[l] + nums[r];
                if (val == 0)
                {
                    res.push_back({nums[l], nums[i], nums[r]});
                    l++, r--;
                    while (l < r && nums[l] == nums[l-1])
                    {
                        l++;
                    }
                    while (l < r && nums[r] == nums[r+1])
                        r--;
                }
                else if (val < 0)
                    l++;
                else
                    r--;
            }
        }
        return res;
    }
};

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int sz = s.size();
        if(0 == sz)
            return 0;
        unordered_set<char> us;

        int max_len = INT_MIN;
        int left = 0;
        for (int i = 0; i < s.size(); i++)
        {
            while (us.find(s[i]) != us.end())
            {
                us.erase(s[left]);
                left++;
            }
            us.insert(s[i]);
            max_len = max(max_len, i-left+1);
        }
        return max_len;
    }
};

class Solution {
public:
    pair<int,int> expand_cent(string& s, int i, int j)
    {
        while (i >= 0 && j < s.size())
        {
            if (s[i] == s[j])
            {
                i--, j++;
            }
            else
            {
                break;
            }
        }
        return {i+1, j-1};
    }
    string longestPalindrome(string s) {
        pair<int,int>  p;
        for(int i = 0; i <s.size(); i++)
        {
            pair<int,int> p1 = expand_cent(s, i, i);
            if (p1.second-p1.first > p.second-p.first)
            {
                p = p1;
            }
            pair<int,int> p2 = expand_cent(s, i, i+1);
            if (p2.second-p2.first > p.second-p.first)
            {
                p = p2;
            }
        }
        return s.substr(p.first, p.second-p.first+1);
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTreeHelp(vector<int>& preorder, vector<int>& inorder, int& cur, int b, int e)
    {
        if (b > e)
        {
            return NULL;
        }
        TreeNode* root = new TreeNode(preorder[cur]);
        cur++;
        int i = b;
        while (i <= e)
        {
            if (inorder[i] == root->val)
            {
                break;
            }
            i++;
        }

        root->left = buildTreeHelp(preorder, inorder, cur, b, i-1);
        root->right = buildTreeHelp(preorder, inorder, cur, i+1, e);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int i = 0;
        return buildTreeHelp(preorder, inorder, i, 0, inorder.size()-1);
    }
};

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int row = matrix.size();
        int col = matrix[0].size();
        int l = 0, r = col-1;
        while (l < row && r >= 0)
        {
            if (matrix[l][r] == target)
                return true;
            else if (matrix[l][r] < target)
            {
                l++;
            }
            else
                r--;
        }
        return false;
    }
};