yshuoo的博客

看完题目第一想法应该是一个动态规划递推的题，示例已经给了"DID"的答案，接下来我们考虑一下在此基础上怎么得到"DIDI"的答案（"DIDD"的情况十分类似，大家可以自己推导一下）。1、首先，在[0,1,2,3]的基础上多出了一个数字4，显然将4加到"DID"的所有序列后面都能构成一个升序。2、但这还不是所有的新序列，因为"DIDI"序列的最后一个数字也可以不是4，可能是3或者2或者1。我们假设最后一个数字是3，那么前面就需要由[0,1,2,4]构成一个"DID"序列，并且这个序列的最后一个...

本题是一道分析给定数据的模拟题，它的思维难度不高，但需要一定的代码功底。

题目的规则里排除了IL和IM的情况，那整个罗马数字转换的时候就是如果前一个数字比后一个数字小那就做减法解法一：用HashMap把字母对应的数字保存下来，之后从前往后遍历，判断做加法还是减法class Solution { public static HashMap<String,Integer> map = new HashMap(); static { map.put("I",1); map.put("V",...

class Solution { public int maxSubArray(int[] nums) { int pre = 0, maxAns = nums[0]; for (int x : nums) { pre = Math.max(pre + x, x); maxAns = Math.max(maxAns, pre); } return maxAns; }}...

这道题的解法是比较巧妙的：先对宽度 w 进行升序排序，如果遇到 w 相同的情况，则按照高度 h 降序排序。之后把所有的 h 作为一个数组，在这个数组上计算 LIS 的长度就是答案。public int lengthOfLIS(int[] nums) { int[] dp = new int[nums.length]; int len = 0; for (int num : nums) { int i = Arrays...

要注意记录个数，有的子序列的长度会重复，所以单独使用一个数组记录比如 1,3,5,4,71,3,4,7和1,3,5,7都是以7结尾的，但是数量有两个public int findNumberOfLIS(int[] nums) { if (nums.length == 0 || nums.length == 1){ return nums.length; } int[] dp = new int[nums.length]..

class Solution { public int lengthOfLIS(int[] nums) { if (nums.length == 0){ return 0; } int[] dp = new int[nums.length]; int max = 0; for (int j = 0; j < nums.length; j++){ dp[j] ...

忘记了node也要等于他的下一个才行public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode node = new ListNode(-1); ListNode head = node; while (l1 != null && l2 != null){ if (l1.val >= l2.val){ ..

需要注意边界条件 public int reverse(int x) { int num = 0; while (x != 0){ int before = x % 10; if (num > Integer.MAX_VALUE/10 || (num == Integer.MAX_VALUE/10 && before > 7)){ return 0; ..

从前往后遍历找到第一个递减的位置，从后往前找到递增的位置，最后看这两个位置是不是一样public boolean validMountainArray(int[] A) { if (A == null || A.length < 3){ return false; } int before = 0; int after = 0; for (int i = 0; i+1 < A....

一、先排序，然后用两个指针查找相同的元素class Solution { public int[] intersection(int[] nums1, int[] nums2) { Set<Integer> set1 = new HashSet<>(); Set<Integer> set2 = new HashSet<>(); for (int num : nums1){ ..

public class Solution { public int[] findRedundantDirectedConnection(int[][] edges) { // 边的条数（在这个问题里等于结点个数） int len = edges.length; // 步骤 1：预处理入度数组（记录指向某个结点的边的条数） int[] inDegree = new int[len + 1]; ...

基本的递归就可以解答分解成交换左子树与右子树的子问题public TreeNode invertTree(TreeNode root) { if (root == null){ return root; } TreeNode mid = root.left; root.left = root.right; root.right = mid; invertTree(root.l..

无情的看题解机器思路就一条，按照人解数独的方式去尝试去回溯class Solution { // 数字在行里出现过 private boolean[][] line = new boolean[9][9]; // 数字在列里出现过 private boolean[][] clomn = new boolean[9][9]; // 数字在3X3宫内出现过 private boolean[][][] block = new boolea

字典树写法：class Solution { //使用字典树（也叫前缀树）来解决此问题 //首先构建字典树，实现insert和search方法 class Node{ //表示字母在字典树中的索引 int[] pos = new int[26]; //flag表示当前字符串对应的words中的索引 int flag; public Node(){ flag = ...

本题是一道简单的递归题目，想要看两个树是不是相同，就是去看两个树的左子树和右字树以及根节点是否相同public boolean isSameTree(TreeNode p, TreeNode q) { if (p == null && q == null){ return true; } if (p == null && q!=null){ return false..

class Solution { Map<TreeNode, Integer> f = new HashMap<TreeNode, Integer>(); Map<TreeNode, Integer> g = new HashMap<TreeNode, Integer>(); public int rob(TreeNode root) { dfs(root); return Math.max(...

把题目看成是一个图的拓扑排序，其实就是看图有没有环先转换成临接矩阵，方便计算private List<List<Integer>> gridList; private boolean target = true; private int[] vector; public boolean canFinish(int numCourses, int[][] prerequisites) { gridList = new..

1、从后往前遍历两个字符串2、用字符串来保存加法的值，target保存进位要注意边界条件，给出的字符串均比较大，所以不能用数字型保存public String addStrings(String num1, String num2) { StringBuilder sb = new StringBuilder(); int target = 0; char[] cArray1 = num1.toCharArray(); cha..

美好的8月从一到困难破坏这个题还是一头雾水，只能看官方题解了class Solution { public int[] smallestRange(List<List<Integer>> nums) { int rangeLeft = 0, rangeRight = Integer.MAX_VALUE; int minRange = rangeRight - rangeLeft; int max = Integ..

直接遍历这个数组的最差情况比较简单，但是如果不存在这样的数字，那么就得遍历整个数组我们可以使用剪枝的二分搜索来提前结束遍历class Solution { public int findMagicIndex(int[] nums) { return getAnswer(nums, 0, nums.length - 1); } public int getAnswer(int[] nums, int left, int right) { ..

这个题如果想到，一个整数的拆解出的乘积最大，取决于这个整数拆解出的整数的乘积最大就可以想到用动态规划来做了public int integerBreak(int n) { int [] dp = new int[n+1]; dp[0] = 0; dp[1] = 0; for (int i = 2; i <= n; i++){ int max = Integer.MIN_VALUE; ..

这个题完全没有思路，只能看题解了：class Solution { int[] dx = {1, -1, 0, 0}; int[] dy = {0, 0, 1, -1}; int n, m; public int minimalSteps(String[] maze) { n = maze.length; m = maze[0].length(); // 机关 & 石头 List&lt

以某一节点为根，他的最大深度就是左子树深度与右子树深度比较大的那一个+1，那么递归就很简单public int maxDepth(TreeNode root) { if (root == null){ return 0; } return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1; }我们也可以用「广度优先搜索」的方法来解决这道题目，但我...

题目要求是不连续的子序列，所以不能直接index因为要求是有序，所以找到第一个字母，如果存在子序列，那么中间有多少个第一个字母，他的第二个字母肯定都在后面，所以不用考虑回溯，一次遍历即可public boolean isSubsequence(String s, String t) { if (s == null || t ==null){ return false; } if (s.equals("")){ ..

递归：public boolean divisorGame(int N) { boolean [] f = new boolean[N+2]; f[1] = false; f[2] = true; for (int i = 3; i <= N; i++){ for (int j = 1; j < i; j++){ if ((j % i == 0) &&..

先使用dfs进行计算往左走的到达右下角的值与往下走到达右下脚的值比较小的那个就是最终的结果public int minPathSum(int[][] grid) { if (grid.length == 1 && grid[0].length == 1){ return grid[0][0]; } return dfs(grid, 0, 0); } private int dfs(int[..

旋转数组有可能就是递增数组本身，这种情况需要考虑进去，如果发生过旋转，那么最小数字就是第一个发生递减的数字public int minArray(int[] numbers) { int slow = 0; int fast = 1; while (fast < numbers.length){ if (numbers[fast] < numbers[slow]){ return n..

第一次解也是循环枚举的思想，只是因为数组有序，那么在两数相加已经大于target的情况下，以这个数字左右首元素的情况，不会再出现相加等于target的情况，所以提前结束循环public int[] twoSum(int[] numbers, int target) { if (numbers == null || numbers.length <= 1){ return null; } int [] num = new ..

完全没思路，直接去看了题解题目本身是一道动态规划的题目，其实和二叉搜索树的性质关联不大public int numTrees(int n) { int G[] = new int[n+1]; G[0] = 1; G[1] = 1; // 第一个循环起到逐步计算的作用 for (int i = 2; i <= n; i++){ for (int j = 1; j <= ..

比较直观的想法是，使用一个数组来保存每次计算路径的最小值，这样顺序遍历下来，最后求一遍这个数组的最小元素就是最短路径的值public int minimumTotal(List<List<Integer>> triangle) { if (triangle == null || triangle.size() == 0){ return 0; } int size = triangle.size();..

因为数组中有重复数字，所以每个重复数字都要看成独立的元素，所以使用map保存一个数组中的结果，key为数组的值，value为出现的次数，这样先遍历一遍构造map，再遍历一遍找map中有没有相同的数public int[] intersect(int[] nums1, int[] nums2) { if (nums1 == null || nums2 == null){ return null; } if (nums1.leng..

要注意两个链表的长度不同，也可能发生连续进位的情况，比如，1->9->9 和 9长度不同时把短的链表的值当成0，再用一个整数保存进位，这样当长链表走完时，如果进位还有值就要新建一个节点接上去public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode node = new ListNode(0); ListNode cur = node; int head = 0..

初步想法是拿到一个数，在剩余的数中找target减这个数的值public int[] twoSum(int[] nums, int target) { if (nums == null){ return null; } int[] array = new int[2]; for (int i = 0; i < nums.length; i++){ int value = nums[..

爬楼梯也是一个斐波那契数列问题这里可以只用两个常量保存状态，就可以计算出最终结果public int climbStairs(int n) { if (n == 1 || n==2){ return n; } int first = 1; int second = 2; int i = 3; while (i <= n){ int three =..

题目规定了N的取值范围，所以即便使用简单的递归也不会发生超时public int fib(int N) { if (N == 0 || N == 1){ return N; } return fib(N-1) + fib(N-2); }上面的递归算法简单，实现也不复杂，但是会出现大量重复计算可以使用记忆化技术来进一步减少重复计算public int fib(int N) { int[] ..

迭代解法：1、首先将head指向null2、然后对next往下遍历的同时让他指向前一个3、为了保证往下指向，使用temp暂存next.next public ListNode reverseList(ListNode head) { if (head == null || head.next == null){ return head; } ListNode next = head.next; he..

学习递归的基本思想：图示给的三角形形状是为了看起来更直观一点，实际上如果是用list保存的话，这个三角形的形状应该是这样的这就不难看出f(i,j)的含义了代码按部就班将这个递归实现public List<List<Integer>> generate(int numRows) { List<List<Integer>> triangleList = new ArrayList<>(numRows);..

递归的基本思想：public ListNode swapPairs(ListNode head) { // 1. 终止条件：当前没有节点或者只有一个节点，肯定就不需要交换了 if (head == null || head.next == null) return head; // 2. 调用单元 // 需要交换的两个节点是 head 和 head.next ListNode firstNode = head..

首先尝试用BFS算法，遍历到不同的钥匙，总房间数减一，最终房间数等于0，就是全部能进去public boolean canVisitAllRooms(List<List<Integer>> rooms) { if (rooms == null || rooms.isEmpty()){ return false; } int roomNum = rooms.size(); if(roo..