LeetCode 热题 100

LeetCode 热题 100

开始重新写力扣100题

哈希

两数之和1. 两数之和 - 力扣（LeetCode）

两数之和是力扣的第一题

有人相爱，有人夜里开车看海，有人leetcode第一题都做不出来。

题目介绍

给定数组，目标值，返回和为目标值的两个数的下标

解法一

暴力，双重循环，遍历寻找符合和为目标值的两个数的下标

python3的写法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n=len(nums)
        for i in range(n):
            for j in range(i+1,n):
                if nums[i]+nums[j]==target:
                    return [i,j]
        return []

cpp的写法

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n=nums.size();
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(nums[i]+nums[j]==target){
                    return {i,j};
                }
            }
        }
        return {0,0};
    }
};

时间复杂度O(n)

空间复杂度O(n)

可不可以优化一下时间复杂度

解法二

这里需要用的哈希映射

将target-nums[i]的值存入哈希表，键值对，键是target-nums[i],值是下标

遍历nums,如果target-nums[i]出现在哈希表中，则返回两个下标

python比较简单

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n=len(nums)
        map={}
        for i in range(n):
            if target-nums[i] in map:
                return [i,map[target-nums[i]]]
            else :
                map[nums[i]]=i
        return []

cpp需要用到unorder_map,以及find函数，后面会介绍

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>map;
        int n=nums.size();
        for(int i=0;i<n;i++){
            auto it=map.find(target-nums[i]);
            if (it!=map.end())return {i,it->second};
            //这里it->second 可以写成map[target-nums[i]],但是运行时间会慢3ms
            map[nums[i]]=i;
        }
        return {};
        
    }
};

字母异位词分组49. 字母异位词分组 - 力扣（LeetCode）

题目介绍

异位词：

以输入数据解释

["ate","eat","tea"]该组中的元素都是一个a，一个e，一个t，分到一组。

["nat","tan"]该组中的元素都是一个a，一个n，一个t，分到一组。

["bat"]单独一个组

解法：

可以运用键值对，键是排序后的字符串，值是原始的字符串，最后结果返回值就行

python3

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dd=defaultdict(list)
        for s in strs:
            dd["".join(sorted(s))].append(s)
        return list(dd.values())

这里面需要用到collections库中的defaultdict

from collections import defaultdict
strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
d=defaultdict(list)
for s in strs:
    print(sorted(s))
    print("".join(sorted(s)))
    print(type(s))
    print(type(sorted(s)))
    d["".join(sorted(s))].append(s)
print(d.keys())
print(d.values())
print(list(d.keys()))
print(list(d.values()))

可以注释一部分print,了解defaultdict怎么使用

如果不太想去使用第三方库，可以用python3的字典

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dict = {}
        for s in strs:
            sorted_s = ''.join(sorted(s))
            if sorted_s not in dict:
                dict[sorted_s] = []  
            dict[sorted_s].append(s)  
        return list(dict.values())

cpp

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string,vector<string>>m;
        for(auto&s:strs){
            string sorted_s=s;
            sort(sorted_s.begin(),sorted_s.end());
            m[sorted_s].push_back(s);
        }
        vector<vector<string>>ans;
        ans.reserve(m.size());
        for(auto&[keys,values]:m){
            ans.push_back(values);
        }
        return ans;

        
    }
};