LC 1.1 两数之和、两数相加、无重复字符的最长子串

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，
请你在该数组中找出 和为目标值 target  的那两个整数，
并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。
但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum

使用hash表解决，时间复杂度O(n)。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
       unordered_map<int,int> heap;
       for(int i = 0;i < nums.size(); i++){
           int r = target - nums[i];
           if(heap.count(r))
                return {heap[r],i};
            heap[nums[i]] = i;
       }
           return {}; // 这行不会执行，但是一定要有
    }

};

key 是值， value 是下标。 count ：返回匹配给定主键的元素的个数，count方法的参数是key 。

2. 两数相加

给你两个非空的链表，表示两个非负的整数。
它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        auto head = new ListNode(-1),cur = head;
        // head 虚拟头结点
        int t = 0;
        while(l1 || l2 ||t){
            if(l1) t += l1->val,l1 = l1->next;
            if(l2) t += l2->val,l2 = l2->next;
            cur->next = new ListNode(t%10);
            cur = cur->next;
            t /= 10;
        }
        return head->next;
    }
};

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

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

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

【解析】双指针算法
按子串的最后一个字母来分类，可以将子串分成n类，
子串的最后一个字母在字符串的第0个位置为第一类 …… 
在第 n - 1 个位置 为第 n 类。
每次处理一类，比如以字符串第 i 个字母为结尾的子串，
求第 i 类子串中的最长子串，
假设 j 指向 第 i 类子串的每个子串的第一个字符，那就要让 j 尽可能往左。
保证 j ~ i之间没有重复的元素。
（j指向子串的开头，i指向子串的结尾）
当 i 往后移动，j 只能保持不动，或往后移动，不可能往前移动。
这样两个指针都不会回溯，最长走的距离就是n，所以时间复杂度是O(n)。
用哈希表来维护 j 到 i 之间每个字符出现的次数。
每次 i 向后走一个，就把新的字母s[i+1] 加入进哈希表。
看表中是否有重复元素，如果有重复元素，
那么这个元素必然是s[i+1]，
我们只需要把 j 往后挪，直到把期中的某个与s[i+1]相同的字母挪出去为止。
用 max 记录哈希表中的元素个数最大的值，
每次 i 移动,j 配合 i 移动完（保证j~i之间无重复元素），都要更新这个max。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
         unordered_map<char,int> heap;
        // key 是字母,value 是字母出现的个数
        int res = 0;
        for(int i = 0,j = 0;i < s.size();i++){
            heap[s[i]] ++;
            while(heap[s[i]] > 1){
                heap[s[j++]]--;
            }
            res = max(res,i - j + 1);
        }
        return res;
    }
};