长网址转短网址网站_设计公司详情_百度推广话术全流程_如何做平台推广赚钱

---

1、赎金信

1.1 题目链接

点击跳转到题目位置

1.2 题目描述

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

提示：

• 1 <= ransomNote.length, magazine.length <= 10⁵
• ransomNote 和 magazine 由小写英文字母组成

1.3 解题代码

class Solution {public boolean canConstruct(String ransomNote, String magazine) {int[] hash1 = new int[26];int[] hash2 = new int[26];for(int i = 0; i < ransomNote.length(); ++i){hash1[ransomNote.charAt(i) - 'a']++;}for(int i = 0; i < magazine.length(); ++i){hash2[magazine.charAt(i) - 'a']++;}for(int i = 0; i < 26; ++i){if(hash1[i] > hash2[i]){return false;}}return true;}
}

1.4 解题思路

1. 用哈希表统计ransomNote和magazine中的字符的数量。
2. 如果ransomNote中的某个字符数量大于了magazine中该字符的数量，则返回false。

2、同构字符串

2.1 题目链接

点击跳转到题目位置

2.2 题目描述

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

2.3 解题代码

class Solution {public boolean isIsomorphic(String s, String t) {Map<Character, Character> hash1 = new HashMap<Character, Character>();Map<Character, Character> hash2 = new HashMap<Character, Character>();for(int i = 0; i < s.length(); ++i){char ch1 = s.charAt(i);char ch2 = t.charAt(i);if(hash1.containsKey(ch1) && hash1.get(ch1) != ch2|| hash2.containsKey(ch2) && hash2.get(ch2) != ch1){return false;}hash1.put(ch1, ch2);hash2.put(ch2, ch1);}return true;}
}

2.4 解题思路

1. 用哈希表用来存储s和t中的字符对应关系，s和t应该满足双射关系。
2. s中的字符a对应t中的字符b，t中的字符b也应该对应字符a（这样才能保证同一个字符不会对应多个字符）

3、单词规律

3.1 题目链接

点击跳转到题目位置

3.2 题目描述

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

提示:

• 1 <= pattern.length <= 300
• pattern 只包含小写英文字母
• 1 <= s.length <= 3000
• s 只包含小写英文字母和 ’ ’
• s 不包含 任何前导或尾随对空格
• s 中每个单词都被 单个空格 分隔

3.3 解题代码

class Solution {public boolean wordPattern(String pattern, String s) {Map<Character, String> hash1 = new HashMap<Character, String>();Map<String, Character> hash2 = new HashMap<String, Character>();ArrayList<String> strList = new ArrayList<String>();     StringBuffer sb = new StringBuffer();sb.delete(0, sb.length()); for(int i = 0; i < s.length(); ++i){if(s.charAt(i) == ' '){strList.add(sb.toString());sb.delete(0, sb.length());} else{sb.append(s.charAt(i));}}   if(sb.length() > 0){strList.add(sb.toString());}if(strList.size() != pattern.length()){return false;}for(int i = 0; i < pattern.length(); ++i){char ch = pattern.charAt(i);String str = strList.get(i);if(hash1.containsKey(ch) && !hash1.get(ch).equals(str)|| hash2.containsKey(str) && hash2.get(str) != pattern.charAt(i)){return false;}hash1.put(ch, str);hash2.put(str, ch);}return true;}
}

3.4 解题思路

1. 使用哈希表来解决问题，解题思路和第2题一致。
2. 需要先将所有的字符串用字符串数组存储起来。
3. 注意判断patten的长度和字符串数组是否相同，如果不相同需要返回false。

4、有效的字母异位词

4.1 题目链接

点击跳转到题目位置

4.2 题目描述

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的 字母异位词（字母异位词是通过重新排列不同单词或短语的字母而形成的单词或短语，并使用所有原字母一次）。

提示:

• 1 <= s.length, t.length <= 5 * 10⁴
• s 和 t 仅包含小写字母

4.3 解题代码

class Solution {public boolean isAnagram(String s, String t) {if(s.length() != t.length()){return false;}int[] hash1 = new int[26];int[] hash2 = new int[26];for(int i = 0; i < s.length(); ++i){hash1[s.charAt(i) - 'a']++;hash2[t.charAt(i) - 'a']++;}for(int i = 0; i < 26; ++i){if(hash1[i] != hash2[i]){return false;}}return true;}
}

4.4 解题思路

1. 用哈希表解决该问题。
2. 如果s的长度和t的长度不相等，直接返回false。
3. 用哈希表hash1来记录s中每个字符的数量，用哈希表hash2来记录t中每个字符的数量，如果s和t中每一种字符数量都相等，返回true，否则返回false。

5、字母异位词分组

5.1 题目链接

点击跳转到题目位置

5.2 题目描述

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

提示：

• 1 <= strs.length <= 10⁴
• 0 <= strs[i].length <= 100
• strs[i] 仅包含小写字母

5.3 解题代码

class Solution {public List<List<String>> groupAnagrams(String[] strs) {Map<String, List<String>> map = new HashMap<String, List<String>>();for (String str : strs) {char[] array = str.toCharArray();Arrays.sort(array);String key = new String(array);List<String> list = map.getOrDefault(key, new ArrayList<String>());list.add(str);map.put(key, list);}return new ArrayList<List<String>>(map.values());}
}

5.4 解题思路

1. 对字符按照字典序排序后再存放进哈希表中。
2. 字符串数组遍历完毕后哈希表就将字母异位词分组完毕了。

6、两数之和

6.1 题目链接

点击跳转到题目位置

6.2 题目描述

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

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

提示：

• 2 <= nums.length <= 10⁴
• -109 <= nums[i] <= 10⁹
• -109 <= target <= 10⁹
• 只会存在一个有效答案

6.3 解题代码

class Solution {public int[] twoSum(int[] nums, int target) {Map<Integer, Integer> hash = new HashMap<Integer, Integer>();for(int i = 0; i < nums.length; ++i){if(hash.containsKey(target - nums[i])){return new int[]{hash.get(target - nums[i]), i};}hash.put(nums[i], i);}return new int[]{0, 1};}
}

6.4 解题思路

1. 利用哈希表，哈希表用来存储数字nums[i]对应的下标i。
2. 一次遍历，如果哈希表中存在target - nums[i]的值，则返回结果，否则将当前数字的下标i用哈希表存放起来。

7、快乐数

7.1 题目链接

点击跳转到题目位置

7.2 题目描述

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

提示：

• 1 <= n <= 2³¹ - 1

7.3 解题代码

class Solution {public boolean isHappy(int n) {Map<Integer, Integer> hash = new HashMap<Integer, Integer>();while(true){if(n == 1){return true;}if(hash.containsKey(n)){return false;}hash.put(n, 1);int num = 0;while(n > 0){num += (n % 10) * (n % 10);n /= 10;}n = num;}}
}

7.4 解题思路

1. 直接按照题目要求进行模拟。
2. 每次模拟前先判断该数是否在哈希表中出现，如果出现了则返回false，否则将该数放入哈希表中。
3. 直到返回false或者是模拟后数字等于1。

8、存在重复元素 II

8.1 题目链接

点击跳转到题目位置

8.2 题目描述

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

提示：

• 1 <= nums.length <= 10⁵
• -10⁹ <= nums[i] <= 10⁹
• 0 <= k <= 105

8.3 解题代码

class Solution {public boolean containsNearbyDuplicate(int[] nums, int k) {Map<Integer, Integer> hash = new HashMap<Integer, Integer>();int n = nums.length;for(int i = 0; i < n; ++i){if(hash.containsKey(nums[i])){if(i - hash.get(nums[i]) <= k){return true;} }hash.put(nums[i], i);}return false;}
}

8.4 解题思路

1. 与两数之和的解题思路一致。
2. 用哈希表记录当前数字所在的坐标，如果当前数字在哈希表有值，则计算坐标差是否满足题目要求，满足返回true，不满足则更新哈希表。

9、

9.1 题目链接

点击跳转到题目位置

9.2 题目描述

9.3 解题代码

class Solution {public int longestConsecutive(int[] nums) {int n = nums.length;Set<Integer> num_set = new HashSet<Integer>();for(int num : nums){num_set.add(num);}int maxLen = 0;for(int num : num_set){if(!num_set.contains(num - 1)){int currentNum = num;int len = 1;while(num_set.contains(currentNum + 1)){len++;currentNum++;}maxLen = Math.max(maxLen, len);}}return maxLen;}
}

9.4 解题思路

1. 先用集合去重。
2. 之后遍历所有的数num，只需要判断集合中不存在num - 1的num，接着一直判断集合中是否存在num + 1，如果存在则更新当前num，长度+1，否则直接更新最大长度maxLen。
3. 所有的数遍历完毕后返回最大长度即可。