zhang_han666的博客

题目: 207. 课程表思路:深搜:判断是否有环。每个节点有三种状态,未访问0,正在访问1,已经访问2.深搜过程中,第一次遇到该节点,把状态置为1;若本次深搜再次遇到状态为1的,说明有环,结束;若某个节点往下已经搜索完了都没有环,就把状态置为2,表示已经访问结束.广搜:需要给每个节点建立一个入度表,表示有多少个节点指向本节点.建立一个队列,首先把入度为0的节点入队列,然后若队列不为空,则弹出队头元素,更新入度表,把队头元素指向的节点的入度减一,此时如果有节点入度变为1,就加入队列.根据这个算

题目：75. 颜色分类思路：双指针。一个指针指向0应该在的位置，一个指针指向2应该在的位置。遍历数组，把0交换到前面，把2交换到后面。代码：class Solution { public void sortColors(int[] nums) { int n = nums.length; int cur = 0, left = 0, right = n - 1; while (cur <= right) { if

题目：74. 搜索二维矩阵思路：二分。先二分查找所在行，再二分该行查找数字。代码：class Solution { public boolean searchMatrix(int[][] matrix, int target) { int row = matrix.length; int col = matrix[0].length; int left = 0; int right = row - 1; int

题目：73. 矩阵置零思路：借助第一行和第一列来存储某行、列是否需要置零。好累哦，就这样吧，具体看代码。最近都不想刷题了，，，烦烦烦~代码：class Solution { public void setZeroes(int[][] matrix) { boolean flagcol = false; boolean flagrow = false; // 判断第一行和第一列需不需要全部置零 int row = matrix.length

题目：72. 编辑距离思路：动态规划。一共三种操作：插入、删除、替换。一对字符串a和b：对a插入相等于对b删除；对a删除相当于对b插入；对a替换相当于对b替换。所以，转移方程：如果s1[i] == s2[j]，则 dp[i][j] = dp[i - 1][j - 1]。即，如果当前字符相等，那么此时不需要额外操作；如果s1[i] != s2[j]，则 dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j -

题目： 71. 简化路径思路：栈首先，用split()函数把/去掉；然后，借助栈：如果是路径名就压栈；如果是.，不做处理；如果是..，就从栈里pop一个目录。代码：class Solution { public String simplifyPath(String path) { Stack<String> stack = new Stack<>(); String[] strs = path.split("/");

题目：70. 爬楼梯思路： 一个斐波那契数列。代码：class Solution { public int climbStairs(int n) { int p = 0, q = 1, r = 0; for (int i = 0; i < n; i ++) { r = p + q; p = q; q = r; } return r; }}

题目：69. x 的平方根思路：二分。某个数的平方根一定小于本身，二分枚举从1到x的数。代码：class Solution { public int mySqrt(int x) { int left = 0; int right = x; int res = 0; while (left <= right) { int mid = (left + right) / 2; //

题目：67. 二进制求和思路：模拟加法即可。代码：class Solution { public String addBinary(String a, String b) { int carry = 0; StringBuilder res = new StringBuilder(); for (int i = a.length() - 1, j = b.length() - 1; i >= 0 || j >= 0; i --, j

题目：66. 加一思路：题目是加一，所以只有9会受到影响。如果没有遇到9，就可以结束了；如果全是9，就重新开辟一个数组，最高位置0即可。参考 这篇题解代码：class Solution { public int[] plusOne(int[] digits) { for (int i = digits.length - 1; i >= 0; i --) { digits[i] ++; digits[i] %= 10;

题目：64. 最小路径和思路：动态规划。仍然与上一题类似，某个位置的路径和只依赖上方和左方，取二者较小的一个，加上当前位置的值即为该位置的最小路径和。代码：class Solution { public int minPathSum(int[][] grid) { int m = grid.length; int n = grid[0].length; int[] dp = new int[n + 1]; Arrays.fill

题目：63. 不同路径 II思路：动态规划。在上一题的基础上，加一条判断，如果有障碍，dp置为0即可。代码：class Solution { public int uniquePathsWithObstacles(int[][] obstacleGrid) { int m = obstacleGrid.length; int n = obstacleGrid[0].length; int[] dp = new int[n]; d

题目：62. 不同路径思路：动态规划。很显然，二维数组的转移方程：dp[i][j] = dp[i-1][j] + dp[i][j-1]优化：当前位置的路径数，指取决于数组中它的上方和左方，因此，一个n维数组即可满足需求。转移方程：dp[j] = dp[j] + dp[j - 1]方程右侧：dp[j]是上一行的值，即上方；dp[j - 1]是本行已经更新的值，即左方。代码：class Solution { public int uniquePaths(int m, int n) {

题目：61. 旋转链表思路：找到链表长度；链表首尾连成环；根据k断开链表。代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode n

题目：187. 重复的DNA序列思路：固定一个长度为10的窗口，找到所有序列，用集合判断出现次数是否大于1.代码：class Solution { public List<String> findRepeatedDnaSequences(String s) { Set<String> set = new HashSet<>(); List<String> list = new ArrayList<>(

题目：59. 螺旋矩阵 II**思路：**模拟螺旋，用4个遍历分别指示 最大行列、最小行列。代码：class Solution { public int[][] generateMatrix(int n) { int[][] res = new int[n][n]; int maxrow = n - 1, minrow = 0; int maxcol = n - 1, mincol = 0; int num = 1;

题目：58. 最后一个单词的长度思路：可以借助trim()函数去掉首尾空格，然后用split()函数按照空格分隔，得到最后一个单词。也可以从后扫描字符串，寻找第一个单词。代码：class Solution { public int lengthOfLastWord(String s) { String[] strs = s.trim().split("\\s"); if (strs.length == 0) { return 0;

题目：57. 插入区间思路：可以按照上一题的思路，把新的区间加入区间列表，然后排序。也可以逐个与区间列表里的区间合并。代码：class Solution { public int[][] insert(int[][] intervals, int[] newInterval) { int l = newInterval[0]; int r = newInterval[1]; boolean placed = false;

题目：56. 合并区间思路：首先，对所有区间按照第一个数升序排列；把第一个区间放入结果集，接着遍历剩下的元素：如果当前遍历的元素的左值，大于结果集最后一个元素的右值，那么二者必然不能合并，把当前元素加入结果集；否则，二者可以合并，右值取二者右值更大的一个即可。代码：class Solution { public int[][] merge(int[][] intervals) { if (intervals.length == 0) { r

题目：179. 最大数思路：自定义排序。参考 官方题解。希望高位数字越大越好，官方题解定义了一个比较函数，很巧妙，把两个数字当作字符串拼起来。详细证明过程参见该题解。代码：class Solution { public String largestNumber(int[] nums) { String[] strs = new String[nums.length]; for (int i = 0; i < nums.length; i ++) {

题目：174. 地下城游戏思路：动态规划。假设有一条路径：-2，-5，10，30，-5。如果正向找初始值，我们需要存两个值，满足需求的起点健康值和达到每个位置时需要的最少健康值：每个位置需要的最少健康值依赖前一个位置；满足需求的起点健康值就是在每个位置需要的最少健康值中取最大的（1也参与比较，因为有可能路径全为正值）。如果反向找：下图从右到左看。我们无需额外计算起点健康值，在起点处的值就是我们想要的答案。所以，我们动态规划是从终点开始搜索。dp[i][j]表示坐标(i,j)到达终点需要的健

题目：173. 二叉搜索树迭代器思路：栈。题目要求从小到大返回节点的值，那就是中序遍历，我们可以用一个数组，存储中序遍历的结果，这样可以满足需求，空间复杂度是O(n)，n是节点数。可以借助栈实现树的中序遍历。按照这个思路，栈顶元素总是当前的最小值，每弹出一个元素，若不是叶节点，就要再次进行压栈。代码：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNo

题目：172. 阶乘后的零思路：参考 这篇题解。总结一下，即0是通过相乘得到10来的，即2*5，某个数字包含2的个数一定大于包含5的个数，每5个数字出现一个5，每5*5个数出现两个5，每5*5*5个数会出现三个5……，以此类推，最终5的个数为：n/5 + n/25 + n/125 + ······代码：class Solution { public int trailingZeroes(int n) { if (n < 5) { return

题目：171. Excel表列序号思路：26进制转10进制。代码：class Solution { public int titleToNumber(String columnTitle) { int n = columnTitle.length(); int res = 0; for (int i = 0; i < n; i ++) { res += (columnTitle.charAt(i) + 1 - 'A'

题目：169. 多数元素思路：首先，借助哈希表可以很容易得到结果，空间复杂度是O(n)；投票法可以把空间复杂度降到O(1)，思路如下：把第一个数字当作候选数字，用变量count记录候选数字出现的相对次数，如果遇到相同的数，count就加1，遇到不同的数，count就减1。若count减到了0，说明当前数字不是我们要的结果，我们更新候选数字和count继续寻找。代码：class Solution { public int majorityElement(int[] nums) {

题目：168. Excel表列名称思路：进制转换。进制之间相互转换，A进制转为B进制，一般的做法就是取余：数字不断对B取余。一般进制都是从0开始，而题目是从1开始，所以我们每次取余前先给这个数减一，避免如下这种情况：数字是26的倍数，如果不减1，那么取余之后为0，所以不能取余，因此我们得额外判断是不是26的倍数；相反，如果减去1，那么余数的范围就是0~25，这样不用额外判断。代码：class Solution { public String convertToTitle(int colu

题目：167. 两数之和 II - 输入有序数组思路：双指针。一个指针在数组头，另一个指针在数组尾，根据指向的两数的和与target的大小更新指针。代码：class Solution { public int[] twoSum(int[] numbers, int target) { int[] res = new int[]{-1, -1}; int left = 0; int right = numbers.length - 1;

题目：55. 跳跃游戏思路：贪心。维护一个当前可以到达的最远位置，遍历的过程中更新它。如果最远位置大于数组长度，那么可以到达；如果当前位置大于最远位置，说明不可达到，因为当前位置已经不可到达了。代码：class Solution { public boolean canJump(int[] nums) { int n = nums.length; int maxPos = 0; for (int i = 0; i < n; i ++) {

题目：54. 螺旋矩阵思路：模拟矩阵旋转。代码：class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> res = new ArrayList<>(); if (matrix.length ==0) { return res; } int minRow = 0;

题目：53. 最大子序和思路：动态规划。dp[i]表示，数组以索引i结尾的最大字序和，很显然：dp[i] = Math.max(nums[i], nums[i] + dp[i - 1])由于dp[i]只和前一个值dp[i -1]有关，因此可以对空间进行优化。代码：优化class Solution { public int maxSubArray(int[] nums) { int n = nums.length; int dp = nums[0];

题目：52. N皇后 II思路：回溯。不需要打印棋盘，所以只需要一个变量记录找到的解即可。代码：class Solution { public int res = 0; public int totalNQueens(int n) { int[] queen = new int[n]; Arrays.fill(queen, -1); backtrack(queen, 0, n); return res; }

题目：51. N 皇后思路：回溯用一个n维数组存储皇后位置，数组索引表示皇后所在的行，索引处存的是皇后所在的列，这样很容易保证皇后不在同一行和列，同时需要保证对角线不重复：两个点（i，j）（k，l）：观察数组不难发现，若两点在斜对角，有i + j == k + l、i - j == k - l，推导可得：i - k == l - j、i - k == j - l代码：class Solution { public List<List<String>> solve

题目：50. Pow(x, n)思路：快速幂Java实现的过程中，需要把int转long，因为负数会溢出。代码：class Solution { public double myPow(double x, int n) { long N = n; if (n < 0) { return 1.0 / Pow(x, -N); } return Pow(x, N); } public d

题目：49. 字母异位词分组思路：借助哈希表。字母异位词包含的单词一定是一致的，所以，把排序好的字符作为key，value是列表，存储字母异位的单词。代码：class Solution { public List<List<String>> groupAnagrams(String[] strs) { Map<String, List<String>> map = new HashMap<>(); f

题目：48. 旋转图像思路：首先按对角线对称翻转，再把每一行逆序。代码：class Solution { public void rotate(int[][] matrix) { int n = matrix.length; for (int i = 0; i < n; i ++) { for (int j = i; j < n; j++) { int temp = matrix[i][j];

题目：165. 比较版本号思路：用正则表达式把版本号分开后挨个比较即可。代码：class Solution { public int compareVersion(String version1, String version2) { String[] array1 = version1.split("\\."); String[] array2 = version2.split("\\."); int n1 = array1.length;

题目：164. 最大间距思路：题目要求线性时间复杂度和空间复杂度的条件下解决此问题。官方题解 给了 桶排序的算法。还没看懂，以后再补。代码：class Solution { public int maximumGap(int[] nums) { if (nums.length <= 1) { return 0; } Arrays.sort(nums); int max = Integer.MIN_

题目：162. 寻找峰值思路：题目有一点很重要：对于所有有效的 i 都有 nums[i] != nums[i + 1]。同时，峰值只要求大于相邻的数。线性查找：从头开始，只需要判断是否大于下一个数；如果不大于下一个数，那么我们会继续查找，也就是说，只要来到了当前位置，就已经保证了当前位置大于前一个位置。二分：找出中点mid，判断mid与mid+1处值的大小如果nums[mid] > nums[mid + 1]：说明峰值在左区间，我们更新右区间为mid；如果nums[mid] < n

题目：160. 相交链表思路：双指针。对于两条链表a，b，a+b的节点数等于b+a的节点数。所以，我们用两个指针分别指向两个链表，遍历他们。如果a指针到了a链表最后一个节点，那么把a指针指向b链表；对b链表和b指针也是如此。如果两个链表有交点，那么上述遍历方式两个指针会同时到达起始交点；如果两个链表没有交点，那么当两个指针会同时到达对方的末节点。代码：/** * Definition for singly-linked list. * public class ListNode {

题目： 155. 最小栈思路：主要考察如何返回栈里的最小值，我们另外新建一个栈，来保持原栈中的最小值。两个栈同步更新，原栈压入元素时，最小值栈也压入当前的最小值。代码：class MinStack { Stack<Integer> stack; Stack<Integer> minstack; /** initialize your data structure here. */ public MinStack() { sta