LeetCode 100题（3）（10题）

1：141. 环形链表 - 力扣（LeetCode）

题意：给定一个链表，判断其是否有环，有环则返回true，反之则返回 false

思路：设定两个指针，一个快指针，一个慢指针，快指针每次走两个单位长度，慢指针每次走一个单位长度，如果最后它们能相遇则说明是有环的。

/*** Definition for singly-linked list.* class ListNode {*     int val;*     ListNode next;*     ListNode(int x) {*         val = x;*         next = null;*     }* }*/
public class Solution {public boolean hasCycle(ListNode head) {ListNode slow=  head;ListNode fast = head;while(fast != null){slow = slow.next;if(fast.next != null) fast = fast.next.next;else return false;if(fast == slow) return true;}return false;}
}

2：139. 单词拆分 - 力扣（LeetCode）

题意：给定一个字符串 S，和一个字符串数组，问你能不能用数组里面的字符串组成 S，可以则返回 true，反之返回 false;

思路：很经典的一道题目，我们首先用 set集合 将数组里面的字符串字符串存进去，然后要用到动态规划的思想，f[i] 的状态表示是：在S中，从第一个字母到第i个字母是否能够凑出来，状态转移见代码，还是比较好理解的

class Solution {public boolean wordBreak(String s, List<String> wordDict) {Set<String> set = new HashSet<>(wordDict);int maxn = 0;for(String ss : wordDict){maxn = Math.max(maxn, ss.length());}int n = s.length();boolean[] f = new boolean[n + 1];f[0] = true;for(int i = 1; i <= n; i ++){for(int j = i - 1; j >= Math.max(0, i - maxn); j --){if(f[j] && set.contains(s.substring(j, i))){f[i] = true;break;}}}return f[n];}
}

3：136. 只出现一次的数字 - 力扣（LeetCode）

题意：给定一个数组，其中某个元素只出现一次，别的元素都会出现两次，让你找出那个只出现一次的元素

思路：常规思路就是用 HashMap 来存每个元素出现的次数，就不多说了，最简单最快的做法是用位运算来考虑，因为两个相同的元素异或出来是0，所以这里面的每对相同的元素都会两两抵消成0，而最后0再和那个只出现一次的元素异或，最后答案就是那个只出现一次的元素。

class Solution {public int singleNumber(int[] nums) {// int n = nums.length;// Map<Integer, Integer> mp = new HashMap<>();// for(int i = 0; i < n; i ++){//     if(mp.containsKey(nums[i])){//         int cnt = mp.get(nums[i]);//         mp.put(nums[i], cnt + 1);//     }else{//         mp.put(nums[i], 1);//     }// }// for(Integer num : mp.keySet()){//     int cnt = mp.get(num);//     if(cnt == 1){//         return num;//     }// }// return -1;int ans = 0;for(int num : nums){ans ^= num;}return ans;}
}

4：647. 回文子串 - 力扣（LeetCode）

题意：给定一个字符串，判断其中回文子串的个数

思路：也是比较经典的问题，考虑dp，设 dp[i][j]，状态表示为：索引 i 到 索引 j 是否为回文子串，状态转移方程见代码，还是比较好理解的，当然官方还给了一个中心拓展法，时间复杂度是更优的，但是我个人是比较讨厌这种找规律找出来的方法

class Solution {public int countSubstrings(String s) {//1：动态规划法int n = s.length();int ans = 0;boolean[][] dp = new boolean[n + 1][n + 1];for(int j = 0; j < n; j ++){for(int i = 0; i <= j; i ++){if(s.charAt(i) == s.charAt(j) && (j - i < 2 || dp[i + 1][j - 1])){dp[i][j] = true;ans ++;}}}return ans;//2：中心扩展法//     for(int i = 0; i < n * 2 - 1; i ++){//         int left = i / 2;//         int right = left + (i % 2);//         while(left >= 0 && right < n && s.charAt(left) == s.charAt(right)){//             ans ++;//             left --;//             right ++;//         }//     }//     return ans;}
}

5：128. 最长连续序列 - 力扣（LeetCode）

题意：给定一个未排序的整数数组，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

思路：我还是选择用 dp 来做，因为题目的意思是忽略原数组中数字的索引，所以我们可以直接排序，dp[i]的状态表示为：截止到索引 i ，这个索引位置能凑出的最优解，状态转移见代码，还是比较简单的

class Solution {public int longestConsecutive(int[] nums) {int n = nums.length;if(n == 0){return 0;}int ans = 1;Arrays.sort(nums);int[] dp = new int[n];dp[0] = 1;for(int i = 1; i < n; i ++){if(nums[i] - nums[i - 1] == 1){dp[i] = dp[i - 1] + 1;}else if(nums[i] == nums[i - 1]){dp[i] = dp[i - 1];}else{dp[i] = 1;}ans = Math.max(ans, dp[i]);}return ans;}
}

6：124. 二叉树中的最大路径和 - 力扣（LeetCode）

题意：给定一个二叉树，让你算出它的最大路径和，说的通俗点，这里的路径就是不能走回头路，也就是一笔到底，一个点不能走两遍，我一开始就是没审清题目的意思卡了好久；

思路：考虑 dfs，因为是二叉树，所以我每个点最多走一遍，正常来说时间复杂度是满足的，然后我们将最上面我们要取的点称作答案顶点，就比如下图中的 “20” 这个点，也就是说我们的全局变量 ans 会从这个顶点开始的路径中得到，那么对于每个答案顶点，我们的ans 一定是这个答案顶点的 val + 左子树和右子树的值，那么如果左子树或者右子树有负数，那答案不就错了吗？很简单，我们直接让左右子树的最大值永远大于0即可。

那么对于非答案顶点来说呢？因为每个点我只能走一遍，所以这个非答案顶点的点所能做出的贡献最大只能是自身的val加上他左右子树其中之一的最大的最大值，就比如这个 “15” 就是非答案顶点，那么它只能在 5 或 6 中选一个最大值，并加上自身的 val 再返回。

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {private int ans = Integer.MIN_VALUE;public int maxPathSum(TreeNode root){dfs(root);return ans;}public int dfs(TreeNode node){if(node == null) return 0;int leftMaxn = Math.max(dfs(node.left), 0);int rightMaxn = Math.max(dfs(node.right), 0);int tmp = node.val + leftMaxn + rightMaxn;ans = Math.max(ans, tmp);return node.val + Math.max(leftMaxn, rightMaxn);}/**题目读错了 太 2B 了 ! ! !*/
}

7：322. 零钱兑换 - 力扣（LeetCode）

题意：给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数amount，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。你可以认为每种硬币的数量是无限的

思路：完全背包问题的板子题，注意完全背包和01背包的区别就是，完全背包在对于容量那一层循环进行遍历的时候是正着遍历，而01背包是倒着遍历，原因就是完全背包的每个物品可以用无数次

class Solution {public int coinChange(int[] coins, int amount) {int[] dp = new int[amount + 2];Arrays.fill(dp, 10005);dp[0] = 0;int n = coins.length;for(int i = 0 ; i < n; i ++){for(int j = coins[i]; j <= amount; j ++){dp[j] = Math.min(dp[j - coins[i]] + 1, dp[j]);}}if(dp[amount] == 10005) return -1;else return dp[amount];}
}

8：494. 目标和 - 力扣（LeetCode）

题意：给定一个非负的整数数组，和一个目标值 tar，然后你可以在每个元素前面设置 "+" 或者 “-”

，然后把这些元素全部加起来，有几种方法可以凑成 tar;

思路：很简单的爆搜模板题

class Solution {private int ans = 0;public int findTargetSumWays(int[] nums, int target) {int n = nums.length;dfs(0, n, 0, target, nums);return ans;}public void dfs(int cnt, int n, int sum, int target, int[] nums){if(cnt == n){if(sum == target) ans ++;return;}dfs(cnt + 1, n, sum + nums[cnt], target, nums);dfs(cnt + 1, n, sum - nums[cnt], target, nums);}
}

9：461. 汉明距离 - 力扣（LeetCode）

题意：两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目，给你两个整数 x 和 y，计算并返回它们之间的汉明距离

思路：直接异或两个数，然后把异或后的这个数当成二进制来看，里面有几个1距离就是几

class Solution {public int hammingDistance(int x, int y) {int ans = 0;int tar = x ^ y;while(tar > 0){int tmp = tar % 2;tar /= 2;if(tmp == 1) ans ++;}return ans;}
}

10：448. 找到所有数组中消失的数字 - 力扣（LeetCode）

题意：给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果

思路：我这里是用双指针慢慢找的，写的比较屎山代码，官方的代码比较简单，也很好懂，就是把nums 当成哈希表存，最后遍历一遍 nums 就可以了

class Solution {public List<Integer> findDisappearedNumbers(int[] nums) {int n = nums.length;Arrays.sort(nums);List<Integer> ans = new ArrayList<>();int st = 1;int ed = nums[0];for(int k = st; k < ed; k ++) ans.add(k);for(int i = 0; i < n; i ++){for(int j = i + 1; j < n; j ++){if(nums[j] != nums[i]){if(nums[j] != nums[i] + 1){st = nums[i];ed = nums[j];for(int k = st + 1; k < ed; k ++) ans.add(k);}if(j == n - 1){st = nums[j];ed = n;for(int k = st + 1; k <= ed; k ++) ans.add(k);}i = j - 1;break;}if(j == n - 1){st = nums[i];ed = n;for(int k = st + 1; k <= ed; k ++) ans.add(k);i = j;break;}}}return ans;}
}

class Solution {public List<Integer> findDisappearedNumbers(int[] nums) {int n = nums.length;for (int num : nums) {int x = (num - 1) % n;if (nums[x] <= n) {nums[x] += n;}}List<Integer> ret = new ArrayList<Integer>();for (int i = 0; i < n; i++) {if (nums[i] <= n) {ret.add(i + 1);}}return ret;}
}作者：力扣官方题解
链接：https://leetcode.cn/problems/find-all-numbers-disappeared-in-an-array/solutions/601946/zhao-dao-suo-you-shu-zu-zhong-xiao-shi-d-mabl/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。