第一组

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

大概思路：

1. 本题可以采用双指针算法，时间复杂度为o(n)。
2. 用数组或者哈希表来维护双指针指向区间的每个字母出现的次数，区间中所有字母出现次数小于等于1即为一个合法区间。
3. 每次右指针右移，一个新字母加入区间，则区间中该字母数量加1，若该字母数量大于1，则左指针左移，直到该字母在区间的数量为1。
4. 区间具有一种单调性，若右指针右移，则左指针要么不动，要么也向右移动，因此算法时间复杂度为o(n)

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int>size;
        int res = 0;
        for(int i = 0, j = 0; i < s.size(); i++)
        {
            size[s[i]]++;
            while(size[s[i]] > 1)size[s[j++]]--;
            if(i - j + 1 > res)res = i - j + 1;
        }
        return res;
    }
};

---

2. LeetCode 4. 寻找两个正序数组的中位数

大概思路：

1. 将问题看作是求第k个数，通过分类讨论将大问题递归为子问题

2. 核心递归思路就是从两个正序数组A和B中各拿出k/2个数

   1. 若A[k/2]<B[k/2]，则A的前k/2个数一定在AB合并后前k个数中
   2. 若B[k/2]<A[k/2]，参考第一点
   3. 若A[k/2]=B[k/2]，则A[k/2]正好等于AB合并后第k个数

   （类比于一根木棍折断成两半，要么其中一根长度超过原长一半，要么两根长度均为原长一半）

3. 每次递归后，k大体上会除以2，总共大约递归log(k)次，k=m+n

4. 总之，从两个数组中分别取出两堆k/2个数，则一定至少有一堆在前k个数中，于是可以将问题简化

class Solution {
public:
	//从nums1第i个数和nums2第j个数为起点，求合并后的第k个数
    int findKth(vector<int>nums1, int i, vector<int>nums2, int j, int k)
    {
    	//保证nums1长度小于等于nums2，避免一些分类讨论的情况
        if(nums1.size() - i > nums2.size() - j)return findKth(nums2, j, nums1, i, k);
        //若num1为空，则可从nums2得到第k个数
        if(nums1.size() == i)return nums2[j + k - 1];
        //若递归到最后k=1则直接返回
        if(k == 1)return min(nums1[i], nums2[j]);
        //si，sj分别为分别两种情况的新的起点，其中nums1的长度可能小于k/2
        int si = min((int)nums1.size(), i + k / 2), sj = j + k / 2;
        if(nums1[si - 1] < nums2[sj - 1])
            return findKth(nums1, si, nums2, j, k - (si - i));
        else
            return findKth(nums1, i, nums2, sj, k - (sj - j));
    }
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int total = nums1.size() + nums2.size();
        if(total % 2)//长度为奇数
            return findKth(nums1, 0, nums2, 0, total / 2 + 1);
        else//长度为偶数
        {
            int l = findKth(nums1, 0, nums2, 0, total / 2);
            int r = findKth(nums1, 0, nums2, 0, total / 2 + 1);
            return (l + r) / 2.0;	//注意除以浮点数
        }
    }
};

---

3. LeetCode 5. 最长回文子串

大概思路：

1. 枚举字符串s中字符作为可能回文串的中心（分奇数长度回文串和偶数长度回文串）
2. 时间复杂度为o(n²)

class Solution {
public:
    string longestPalindrome(string s) {
        string res;
        for(int i = 0; i < s.size(); i++)
        {
            int l = i - 1, r = i + 1;
            while(l >= 0 && r <= s.size() && s[l] == s[r])l--, r++;
            if(r - 1 - l > res.size())res = s.substr(l + 1, r - 1 - l);

            l = i, r = i + 1;
            while(l >= 0 && r <= s.size() && s[l] == s[r])l--, r++;
            if(r - 1 - l > res.size())res = s.substr(l + 1, r - 1 - l);
        }
        return res;
    }
};

4. LeetCode 6. Z 字形变换

大概思路：

1. 找规律，找到一个循环节，将循环节字母分为若干类，分类讨论。
2. 所有种类字母只有起点不同，同种类任意两个字母距离为循环节长度
3. 从上到下，从左到右按行输出。

class Solution {
public:
    string convert(string s, int n) {
        string res;
        if(n == 1)return s; //2 * n - 2 = 0死循环
        for(int i = 0; i < n; i++)
        {
            if(i == 0 || i == n - 1)
                for(int j = i; j < s.size(); j += 2 * n - 2)
                    res += s[j];
            else
            {
                for(int j = i, k = 2 * n - 2 - i; j < s.size() || k < s.size(); j += 2 * n - 2, k += 2 * n - 2)
                {
                    if(j < s.size())res += s[j];
                    if(k < s.size())res += s[k];
                }
            }
        }
        return res;
    }
};

---

5. LeetCode 10. 正则表达式匹配

大概思路：

1. 动态规划，f[i[j]表示s的前i个字符与p的前j个字符匹配，值为true或false。
2. 研究状态转移可根据p[j]字符的种类进行划分，"*“为一类，数字或”."为第二类。
3. 第一类：((p[j-1]为"."或与s[i]相等)且f[i-1][j]为真)或f[i][j-2]为真，则f[i][j]为真。
4. 第二类：(p[j]为"."或与s[i]相等)且f[i-1][j-1]为真,则f[i][j]为真。
5. 根据某个字符串字符种类进行状态划分。

class Solution {
public:
    bool isMatch(string s, string p) {
        bool f[1005][1005] = {false};
        f[0][0] = true;
        s = " " + s, p = " " + p;
        int n = s.size(), m = p. size();
        for(int i = 0; i <= n; i++)
            for(int j = 1; j <= m; j++)
            {
                if(i && p[j] != '*')
                    f[i][j] = f[i][j] || (f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '.'));
                else if(p[j] == '*')
                {
                    f[i][j] = f[i][j] || f[i][j - 2] || (i && f[i - 1][j] && (s[i] == p[j - 1] || p[j - 1] == '.'));
                }
                
            }
        return f[n][m];
    }
};