1.有效的字母异位词
242. 有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例1
输入: s = "anagram", t = "nagaram"
输出: true
示例2
输入: s = "rat", t = "car"
输出: false
思路
解法一：非常暴力的方法，使用两个map，分别存储两个字符串，然后比较两个map的key和value是否相等。
解法二：对解法一进行优化，题目中“判断 t 是否是 s 的字母异位词”，在本题中只需要定义一个map，将存储s的字符串。在逐个遍历t的过程中，保证t的k在s中存在，并且值是非0即可。
解法三：本题有个潜在的条件：字母构成的字符串，因此我们可以考虑大小确定的数组充当map。数组相对于map，节省空间。通过(-'a')方式
解法一
func isAnagram(s string, t string) bool {
smap:=make(map[byte]int)
tmap:=make(map[byte]int)
for i:=0;i<len(s);i++{
smap[s[i]]++
}
for i:=0;i<len(t);i++{
tmap[t[i]]++
}
for k,v:=range smap{
if tmap[k]!=v{
return false
}
}
for k,v:=range tmap{
if smap[k]!=v{
return false
}
}
return true
}
解法二
func isAnagram(s string, t string) bool {
if len(s)>len(t){
return false
}
hashMap:=make(map[byte]int)
for i:=0;i<len(s);i++{
hashMap[s[i]]++
}
for i:=0;i<len(t);i++{ // 逐个遍历t，判断key存在且value非0，直至遍历结束
if v,ok:=hashMap[t[i]];v>=1 && ok {
hashMap[t[i]]--
}else{
return false
}
}
return true
}
解法三
func isAnagram(s string, t string) bool {
num:=[26]int{} // 定义一个数组叫做num用来上记录字符串s里字符出现的次数。因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
for _,v:=range s{
num[v-rune('a')]++ // 通过v-rune('a')的方式找到在长度为26数组中的相对位置
}
for _,v:=range t{
num[v-rune('a')]-- // 通过减法的方式，查看t中的字符是否在s中都存在
}
return num==[26]int{} // 根据数组是否为空判断字母异位词
}
相关题目
383. 赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
示例1
输入： ransomNote = "a", magazine = "b"
输出： false
示例2
输入： ransomNote = "aa", magazine = "ab"
输出： false
思路
这个题目和上述242题很类似，同样可使用上述的两种方法解决。
解法一
func canConstruct(ransomNote string, magazine string) bool {
exits:=make(map[byte]int) // 用map存储magazine的字符
for i:=0;i<len(magazine);i++{
exits[magazine[i]]++
}
for i:=0;i<len(ransomNote);i++{
if v,ok:=exits[ransomNote[i]];v>=1 && ok{
exits[ransomNote[i]]--
}else{
return false
}
}
return true
}
解法二
func canConstruct(ransomNote string, magazine string) bool {
grams:=[26]int{} // 用数组存储magazine的字符
for _,v:=range magazine{
grams[v-rune('a')]++
}
for _,v:=range ransomNote{
grams[v-rune('a')]--
if grams[v-rune('a')]<0{
return false
}
}
return true
}
49. 字母异位词分组
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。
示例1
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
示例2
输入: strs = [""]
输出: [[""]]
思路
题目中“字母异位词组合在一起”，互为字母异位词的两个字符串包含的字母相同。
对两个字符串分别进行排序之后得到的字符串一定是相同的。
故本题将将排序之后的字符串作为map的key。map的key所对应的value为同字母异位词的列表。
解法
func groupAnagrams(strs []string) [][]string {
res:=[][]string{}
grams:=map[string][]string{}
for i:=0;i<len(strs);i++{
temp:=[]byte(strs[i])
sort.Slice(temp,func(k,j int)bool{ // 字母异位词排序后，结果应该是相同的
return temp[k]<temp[j]
})
grams[string(temp)]=append(grams[string(temp)],strs[i])
}
for _,v:=range grams{
res=append(res,v) // map的value为同为字母异位词的结果列表
}
return res
}
438. 找到字符串中所有字母异位词
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。
示例1
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
示例2
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
思路
题目中“找到s中所有p的异位词的子串”，涉及到子串问题，通常可以想到使用滑动窗口方法解决。
解法
func findAnagrams(s string, p string) []int {
pmap:=make(map[byte]int)
for i:=0;i<len(p);i++{
pmap[p[i]]++
}
left:=0
smap:=make(map[byte]int)
match:=0
res:=[]int{}
for i:=0;i<len(s);i++{
//扩张滑动窗口
smap[s[i]]++
//窗口内数据更新
if _,ok:=pmap[s[i]];ok{
if smap[s[i]]==pmap[s[i]]{
match++
}
if match==len(pmap){
res=append(res,left)
}
}
//缩小滑动窗口
for i-left+1>=len(p){
if _,ok:=pmap[s[left]];ok && smap[s[left]]==pmap[s[left]]{
match--
}
smap[s[left]]--
left++
}
}
return res
}
567. 字符串的排列
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。
换句话说，s1 的排列之一是 s2 的 子串 。
示例1
输入： s1 = "ab" s2 = "eidbaooo"
输出： true
解释： s2 包含 s1 的排列之一 ("ba").
示例2
输入： s1= "ab" s2 = "eidboaoo"
输出： false
思路
1.题目中“找到s中所有p的异位词的子串”，涉及到子串问题，通常可以想到使用滑动窗口方法解决。
2.异位词考虑map
3.题目中“s2是否包含s1的排列”，因此需要维护的滑动窗口大小是s1的长度。
4.滑动窗口三要素：4.1 扩充滑动窗口：右指针右移，s2map[s2[i]]++；4.2 更新滑动窗口数据：检查窗口内数据是否已经满足异位词子串的条件，更新当前的窗口内各类字符的个数; 4.3 缩小滑动窗口：i-left+1>=len(s1)，一旦满足上述条件，则左移滑动窗口。
解法
func checkInclusion(s1 string, s2 string) bool {
s1map:=make(map[byte]int)
for i:=0;i<len(s1);i++{
s1map[s1[i]]++
}
s2map:=make(map[byte]int)
left:=0
match:=0 // 异位词种类数目
for i:=0;i<len(s2);i++{
// 扩张滑动窗口
s2map[s2[i]]++
// 更新窗口内数据
if _,ok:=s1map[s2[i]];ok{
if s1map[s2[i]]==s2map[s2[i]]{ // 异位词考虑各类数的个数
match++
}
if match==len(s1map){ // 如果各种类的数据数目一样，则返回true
return true
}
}
// 缩小滑动窗口
for i-left+1>=len(s1){
if _,ok:=s1map[s2[left]];ok && s1map[s2[left]]==s2map[s2[left]]{ // 左指针的数据正好了异位词中的一个，则种类数减一
match--
}
s2map[s2[left]]--
left++
}
}
return false
}
3. 无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例1
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例2
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
思路
1.题目中“不含有重复字符的最长子串的长度”，子串说明可以考虑滑动窗口解决。
2.“无重复”，考虑使用map。
3.滑动窗口三要素：3.1 扩张滑动窗口:map扩充，smap[s[i]]++；3.2 更新滑动窗口数据：滑动窗口始终保持无重复字符串，因此maxValue=max(maxValue,i-left+1)；3.3 缩小滑动窗口：只要smap[s[i]]>1,说明在当前的字符串中有重复的字符串出现，不断右移左指针，直到当前字符串无重复。
解法
func lengthOfLongestSubstring(s string) int {
smap:=make(map[byte]int)
left:=0
maxValue:=math.MinInt64
for i:=0;i<len(s);i++{
// 扩张滑动窗口
smap[s[i]]++ // 右指针，扩充
// 缩小滑动窗口
for smap[s[i]]>1{ // 始终维持窗口内数据无重复
smap[s[left]]--
if smap[s[left]]==0{
delete(smap,s[left])
}
left++ // 右移左指针，直到无重复
}
// 更新滑动窗口内数据
maxValue=max(maxValue,i-left+1)
}
if maxValue==math.MinInt64{
return 0
}
return maxValue
}
func max(a,b int)int{
if a>b{
return a
}
return b
}
2.两个数组的交集
349. 两个数组的交集
给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例1
输入： nums1 = [1,2,2,1], nums2 = [2,2]
输出： [2]
示例2
输入： nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出： [9,4]
解释： [4,9] 也是可通过的
思路
输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序，因此可以考虑使用map。
解法
func intersection(nums1 []int, nums2 []int) []int {
res:=[]int{}
map1:=make(map[int]struct{})
for i:=0;i<len(nums1);i++{
map1[nums1[i]]=struct{}{} // key存储nums1的数据类别
}
for i:=0;i<len(nums2);i++{
if _,ok:=map1[nums2[i]];ok{
res=append(res,nums2[i])
delete(map1,nums2[i]) // 为了去重，考虑nums2中存在重复数据
}
}
return res
}
相关题目
350. 两个数组的交集 II
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
示例1
输入： nums1 = [1,2,2,1], nums2 = [2,2]
输出： [2,2]
示例2
输入： nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出： [4,9]
思路
和上述题目类似，区别在于返回结果是未去重的。
解法
func intersect(nums1 []int, nums2 []int) []int {
res:=[]int{}
map1:=make(map[int]int)
for i:=0;i<len(nums1);i++{
map1[nums1[i]]++
}
for i:=0;i<len(nums2);i++{
if v,ok:=map1[nums2[i]];ok && v>0{
res=append(res,nums2[i])
map1[nums2[i]]-- // 返回结果无需去重
}
}
return res
}
3.快乐数
202. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是无限循环 但始终变不到 1。 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
示例1
输入： n = 19
输出： true
解释： 12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
示例2
输入： n = 2
输出： false
思路
1.“无限循环”说明，可能是求和的过程中，sum会重复出现！！！
2.判断一个数据是否重复出现，考虑map。
解法
func isHappy(n int) bool {
sumMap:=make(map[int]bool)
for n!=1 && !sumMap[n]{
sumMap[n]=true
n=getSum(n)
}
return n==1 // 如果已经出现过且n不等于1，则返回false
}
func getSum(n int)int{ // 求各位数的平方和
sum:=0
for n>0 {
sum=sum+(n%10)*(n%10)
n=n/10
}
return sum
}
4.两数之和
1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例1
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例2
输入： nums = [3,2,4], target = 6
输出： [1,2]
思路
1.最暴力的方法是双层循环。
2.换个角度想：a+b==target，找到满足和为target的a，也可以求target-b是否存在。
3.结果是返回索引，因此定义map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标。
解法
func twoSum(nums []int, target int) []int {
numsMap:=make(map[int]int)
for i:=0;i<len(nums);i++{
if v,ok:=numsMap[target-nums[i]];ok && v!=i{ // 防止同一个数被重复使用
return []int{v,i}
}
numsMap[nums[i]]=i
}
return []int{}
}
5.四数相加
454. 四数相加 II
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例1
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例2
输入： nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出： 1
思路
1.最暴力的方法是四层循环，但是超时。因此考虑降复杂度。
2.本题中求满足a+b+c+d==0的a,b,c,d. 换个角度想：a+b+c+d==0,也可以求(a+b)+c+d==0是否存在满足条件的(a+b)和c,d。
解法
func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {
count:=0 // 统计次数
numsMap:=make(map[int]int)
for i:=0;i<len(nums1);i++{
for j:=0;j<len(nums2);j++{
numsMap[nums1[i]+nums2[j]]++
}
}
for k:=0;k<len(nums3);k++{
for l:=0;l<len(nums4);l++{
target:=nums3[k]+nums4[l]
if v,ok:=numsMap[-target];ok{
count=count+v
}
}
}
return count
}
6.四数相加II
454. 四数相加 II
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例1
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例2
输入： nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出： 1
思路
1.最暴力的方法是四层循环，但是超时。因此考虑降复杂度。
2.本题中求满足a+b+c+d==0的a,b,c,d. 换个角度想：a+b+c+d==0,也可以求(a+b)+c+d==0是否存在满足条件的(a+b)和c,d。
解法
func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {
count:=0 // 统计次数
numsMap:=make(map[int]int)
for i:=0;i<len(nums1);i++{
for j:=0;j<len(nums2);j++{
numsMap[nums1[i]+nums2[j]]++
}
}
for k:=0;k<len(nums3);k++{
for l:=0;l<len(nums4);l++{
target:=nums3[k]+nums4[l]
if v,ok:=numsMap[-target];ok{
count=count+v
}
}
}
return count
}
7.赎金信
383. 赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
示例1
输入： ransomNote = "a", magazine = "b"
输出： false
示例2
输入： ransomNote = "aa", magazine = "ab"
输出： false
思路
思路见上方。
解法
func canConstruct(ransomNote string, magazine string) bool {
grams:=[26]int{}
for _,v:=range magazine{
grams[v-rune('a')]++
}
for _,v:=range ransomNote{
grams[v-rune('a')]--
if grams[v-rune('a')]<0{
return false
}
}
return true
}
8.三数之和
15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例1
输入： nums = [-1,0,1,2,-1,-4]
输出： [[-1,-1,2],[-1,0,1]]
示例2
输入： nums = []
输出： []
思路
1.两层for循环就可以确定a和b的数值了，可以使用map来确定 0-(a+b) 是否在数组里出现过，其实这个思路是正确的，但是题目中说的不可以包含重复的三元组。把符合条件的三元组放进列表中，然后再去重，这样是非常费时的，很容易超时。
2.因此，在本题考虑使用双指针和排序去重，在本题中求a+b+c=0，定义双向指针left和right，即a=nums[i],
b=nums[left],c=nums[right]。
解法
func threeSum(nums []int) [][]int {
res:=[][]int{}
sort.Ints(nums) // 排序，方便去重
for i:=0;i<=len(nums)-3;i++{
if i>0 && nums[i]==nums[i-1]{ // 去重
continue
}
left:=i+1
right:=len(nums)-1
for left<right{
if nums[i]+nums[left]+nums[right]==0{
res=append(res,[]int{nums[i],nums[left],nums[right]})
left++
right--
// 结果层去重测试
for left<right && nums[left]==nums[left-1]{ // 去重，可能当前的left和left-1一样
left++
}
for left<right && nums[right]==nums[right+1]{// 去重，可能当前的right和right+1一样
right--
}
}else if nums[i]+nums[left]+nums[right]<0{
left++
}else{
right--
}
}
}
return res
}
8.四数之和
18. 四数之和
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n a、b、c 和 d 互不相同 nums[a] + nums[b] + nums[c] + nums[d] == target 你可以按 任意顺序 返回答案 。
示例1
输入： nums = [1,0,-1,0,-2,2], target = 0
输出： [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例2
输入： nums = [2,2,2,2,2], target = 8
输出： [[2,2,2,2]]
思路
1.三层for循环就可以确定a,b,c的数值了，可以使用map来确定 0-(a+b+c) 是否在数组里出现过，其实这个思路是正确的，但是题目中说的不可以包含重复的四元组。把符合条件的四元组放进列表中，然后再去重，这样是非常费时的，很容易超时。
2.因此，在本题考虑使用双指针和排序去重，在本题中求a+b+c+d=0，定义双向指针left和right，即a=nums[i],
b=nums[j],c=nums[left],d=nums[right]。
解法
func fourSum(nums []int, target int) [][]int {
sort.Ints(nums) // 排序，方便去重
res:=[][]int{}
for i:=0;i<=len(nums)-4;i++{
if i>0 && nums[i]==nums[i-1]{
continue
}
for j:=i+1;j<=len(nums)-3;j++{
if j>i+1 && nums[j]==nums[j-1]{
continue
}
left:=j+1
right:=len(nums)-1
for left<right{
if nums[i]+nums[j]+nums[left]+nums[right]==target{
res=append(res,[]int{nums[i],nums[j],nums[left],nums[right]})
left++
right--
for left<right && nums[left]==nums[left-1]{
left++
}
for left<right && nums[right]==nums[right+1]{
right--
}
}else if nums[i]+nums[j]+nums[left]+nums[right]<target{
left++
}else{
right--
}
}
}
}
return res
}
