LeetCode刷题（持续更新）持续个锤子，狗都不刷

1 两数之和

我的思路为双重for循环，暴力求解。

下面是评论区学到的哈希法：
std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。

同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

本题中并不需要key有序，选择std::unordered_map 效率更高！

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
        for(int i = 0; i < nums.size(); i++) {
            auto iter = map.find(target - nums[i]);
            if(iter != map.end()) {
                return {iter->second, i};
            }
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};

3 无重复字符的最长子串

很巧妙的操作，滑动窗口法，学起来。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 哈希集合，记录每个字符是否出现过
        unordered_set<char> occ;
        int n = s.size();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        // 枚举左指针的位置，初始值隐性地表示为 -1
        for (int i = 0; i < n; ++i) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.erase(s[i - 1]);
            }
            while (rk + 1 < n && !occ.count(s[rk + 1])) {
                // 不断地移动右指针
                occ.insert(s[rk + 1]);
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = max(ans, rk - i + 1);
        }
        return ans;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/solution/wu-zhong-fu-zi-fu-de-zui-chang-zi-chuan-by-leetc-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

9 回文数

1. 反转后半部分的数字。
2. 如何知道反转数字的位数已经达到原始数字位数的一半？
   由于整个过程我们不断将原始数字除以 10，然后给反转后的数字乘上 10，所以，当原始数字小于或等于反转后的数字时，就意味着我们已经处理了一半位数的数字了。

27 移除元素

简单题我重拳出击。

int removeElement(vector<int>& nums, int val) {
        int i=0,j=nums.size(),t;
        while(i<j)
        {
            if(nums[i]==val)
            {
                t=nums[i];
                nums[i]=nums[j-1];
                nums[j-1]=t;
                --i;
                --j;
            }
            ++i;
        }
        return j;
    }

187 重复的DNA序列

我是菜，赶紧看STL！！！

class Solution {
    const int L = 10;
public:
    vector<string> findRepeatedDnaSequences(string s) {
        vector<string> ans;
        unordered_map<string, int> cnt;
        int n = s.length();
        for (int i = 0; i <= n - L; ++i) {
            string sub = s.substr(i, L);
            if (++cnt[sub] == 2) {
                ans.push_back(sub);
            }
        }
        return ans;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/repeated-dna-sequences/solution/zhong-fu-de-dnaxu-lie-by-leetcode-soluti-z8zn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

223 矩形面积

计算重叠部分的面积，方法要记牢。

284 窥探迭代器

Iterator的API关于Iterator主要有三个方法：hasNext()、next()、remove()

hasNext：没有指针下移操作，只是判断是否存在下一个元素
next：指针下移，返回该指针所指向的元素
remove：删除当前指针所指向的元素，一般和next方法一起用，这时候的作用就是删除next方法返回的元素

414 第三大的数

set，set，set，重要的事情说三遍！

434 字符串中的单词数

评论区学到的方法，我想的很拉胯，这个方法惊呆我了，学到了！！！

class Solution {
public:
    int countSegments(string s) {
        stringstream ss(s);
        string word;
        int cnt(0);
        while(ss>>word)
            ++cnt;
        return cnt;
    }
};

482 密钥格式化

提交了3次，我是菜狗，思路是从后往前处理。
ps：写的好垃好繁琐。

class Solution {
public:
    string licenseKeyFormatting(string s, int k) {
        int n = s.length(),flag=0;
        string ans="";
        while(n--)
        {
            if(flag == k)
            {
                ans+='-';
                flag=0;
            }
            if(s[n]=='-')
                continue;
            else if (s[n]>='a'&&s[n]<='z')
            {
                s[n]-=32;
                ans+=s[n];
            }
            else
                ans+=s[n];
            flag++;
        }
        int l=0,r=ans.length()-1;
        while(l<r)
        {
            char t = ans[l];
            ans[l++]=ans[r];
            ans[r--]=t;
        }
        if(ans[0]=='-')
        {
            ans.erase(0,1);
        }
        return ans;
    }
};

704 二分查找

我的思路与二分查找相同，注意下标更新时的+1与-1，二分查找的条件是查找范围不为空，即left小于等于right，需要学复杂度分析。

复杂度
时间复杂度：O(logn)，其中 n 是数组的长度。
空间复杂度：O(1)。

1221 分割平衡字符串

思路很简单，要优化代码书写，写的简洁些。

int balancedStringSplit(string s) {
        int ans=0,d=0;
        for(char ch:s)
        {
            ch=='L'?d++:d--;
            if(d==0)
                ans++;
        }
        return ans;
    }

1689 十-二进制数的最少数目

看了评论区才明白是脑筋急转弯，流汗！

找一个字符串n中的最大数字方法：

int res = 0;
for(char c : n)
{
	res = res > c - 48 ? res : c - 48;
}
return res;