jly0612的博客

题目链接解题思路此题其实就是一个数学题，求最大公约数的倍数。坑的话，就是0，0，0这组测试案例。其它没啥好说的直接上代码。解题代码public class Solution { public boolean canMeasureWater(int x, int y, int z) { int min=0,max=0; if(x==0 || y==0){

原题链接原题链接解题思路题目很熟悉，和以前做过的一道很类似，于是想都没想就知道肯定是动态规划。 建立一个dp数组。dp[i]表示当凑齐i时最少要多少个数字组成。状态转移方程dp[i] = Math.min(dp[i-k] + 1,dp[i]); 解释一下吧，dp[i-k]只要不等于Integer.MAX_VALUE，证明凑齐i-k，有解。并且前面已经算出来了，这时候再加上k的1位数字就行。为了保

原题链接原题链接解题思路刚开始想到了暴力遍历每一个数从头开始深度搜索。后面看了提示发现可以使用数组dp。 dp[i][j]表示以i行j列的数字为开头的最大长度。这样就可以把每个数字都记录下来（以空间换时间）。以免大量的重复。 总体思想就是dfs+dp。解题代码public class Solution { private int m; private int n; pri

原题链接原题链接解题思路简单的二分搜索，不做解释。解题代码/* The guess API is defined in the parent class GuessGame. @param num, your guess @return -1 if my number is lower, 1 if my number is higher, otherwise return 0

原题链接原题链接解题思路简单题。直接用hashmap去记录第一个字符串的字母及频率，再遍历第二个字符串找出答案。解题代码public class Solution { public char findTheDifference(String s, String t) { char[] ss = s.toCharArray(); char[] tt = t.to

原题链接原题链接解题思路用函数栈（递归）用来去完成字典序排序。解题代码public class Solution { public List<Integer> lexicalOrder(int n) { List<Integer> res = new ArrayList<>(); for (int i = 1;i < 10 ;i++ ) {

原题链接原题链接解题思路刚开始想用hashmap去存储，后来仔细审题发现只有小写字母，那就开个数组就能存储，简单方便。解题代码public class Solution { public boolean canConstruct(String ransomNote, String magazine) { char[] rs = ransomNote.toCharArray()

原题链接原题链接解题思路最开始的思路是维护一个最大值，复杂度是n^2。后来看题目要求可以做到n*lgn，提示二分。 首先建立一个数组dp，维护最长递增数组。遍历每个数字，二分查找dp数组获得该插入的地方。最后维护dp数组长度len即最后答案。解题代码public class Solution { public int lengthOfLIS(int[] nums) { in

原题链接原题链接解题思路第一感觉就是动态规划，但是还是难以将抽象的题目具体化，如何根据前面的状态推断现在这个状态（状态转移方程）。 根据题意可以明了，总共有三个状态，持有股票，卖掉股票，休息一天，后两种都可以归纳为未持有股票。状态有了，如何推断？ 再往下分析，未持有股票的状态，最大利润有两种可能。一，和昨天一样保持未持有；二，昨天持有股票今天卖掉。sdp[i] = Math.max(sdp[i-

原题链接原题链接解题思路简单题，只有小写字母。第一直觉开个数组记录。解题代码public class Solution { public int firstUniqChar(String s) { int[] cnt = new int[27]; int res = -1; char[] ss = s.toCharArray();

原题链接原题链接解题思路题目要求时间复杂度n，空间复杂度1。所以不能用排序或者数组记录。 a^b^b = a;由题意肯定有缺的数字，那最后一个数字就是n，此可得当所有数和下标进行异或运算，然后再最后异或n就得到缺的数字。解题代码public class Solution { public int missingNumber(int[] nums) { int xor = 0

原题链接原题链接解题思路常规方法可以使用BFS或者DFS，对每个点都遍历一遍，求出所有点组成的树的高度，然后找出哪些高度最小的节点，可以通过不断更新最低高度来进行剪枝。但是时间复杂度过高。 最终的解题思路采用了不断删除叶子节点，逐渐逼近根节点的方法，在删除叶子节点的同时，会有一些新的节点成为叶子节点，于是继续循环删除，直至不能删除为止，那么剩下的节点就是高度最小的根。 首先将图存储起来，并将每个

原题链接原题链接解题思路动态规划，建立数组dp。注意点：0的特殊性(0不能往下组合数字，不能连续出现两个0或者以0为开头)。 状态转移方程：如果不能和前面的数字组成合法数字dp[i] = dp[i - 1];如果可以则dp[i] = dp[i] + dp[i - 2];解题代码public class Solution { public int numDecodings(String s)

原题链接原题链接解题思路总体的思路是基于归并排序。 首先用快慢指针将链表分为两个部分，递归将两个部分进行归并排序。 归并排序主要和数组排序差不多，因为链表有指针相连，所以不用开辟另外的数据结构去存储（数组需要开辟一个数组去存储排序后的顺序）解题代码/** * Definition for singly-linked list. * public class ListNode { *

原题链接原题链接解题思路简单题，注意边界比如numRows==0时就可以了，主要是根据前面的List元素推断当前的List元素。解题代码public class Solution { public List<List<Integer>> generate(int numRows) { List<List<Integer>> res = new ArrayList<List<I

原题链接原题链接解题思路回溯剪枝。注意点就是两个相同的list处理。方法是先排序，这样相同的数字就紧挨着，当数字等于上一个数字时，表明上个同样的数字已经处理过，这个没必要再处理，continue就可以了。 其他的就看代码吧。解题代码public class Solution { public List<List<Integer>> combinationSum2(int[] candida

原题链接原题链接解题思路第一遍代码超时了。思路（递归左子树，右子树，找到左右子树是否含有目标的TreeNode）这里有个坑，刚开始我是对比TreeNode.val是否相等判断是否含有，后来发现测试案例有很多相等的val，才知道应该判断此treenode是否相等。 修改后的代码如下（AC），思路是一样的实现比第一遍简洁多了，也是递归。如果当前根和其中任一匹配，直接返回当前根，必然是当前根。 如果递

原题链接原题链接解题思路第一次题目没看清楚，以为是按值的奇偶来判断，然后导致只过了部分测试案例，后面仔细审题发现是按照位置的奇偶判断。 代码实现不是很难，为了警示自己审题，我还是两个代码都贴出来吧。解题代码（正解）public class Solution {public ListNode oddEvenList(ListNode head) { if (head != null) {

原题链接原题链接解题思路这道题参考了讨论区，连续遇到两个“#”，说明这是叶子节点，删去他们及他们的根节点，用一个’#‘代替，直到最后剩一个’#‘说明是二叉树。否则，返回false。 然后我就使用Stack来完成。 当遇到数字直接压入。遇到#，判断此堆中top是否为#，是就表明即将有两个#，为叶子节点，就连续pop两个（一个#，一个数字），再将此#压入（用一个#代替两个#和一个数字）。 直到最后

原题链接原题链接解题思路这道题用BFS+优先级队列（堆）。其实这道题和我前面写的一道题解题方法一模一样。题号是373。这里就不细讲了。解题代码public class Solution { public int kthSmallest(int[][] matrix, int k) { PriorityQueue<Num> q = new PriorityQueue<>()

题目链接解题思路使用Map将数字和对应的频率按照键值对存储起来使用TreeMap和HashMap进行利用value值进行排序按照题目要求输出前K大使用的方法不够好。后面又使用了另外的方法另建一个对象存储数字和对应的频率，然后将此对象作为value存储在map和list中，对list进行排序。代码就不贴了。解题代码public class Solution { public List<

原题链接解题思路很简单找出通项公式，递推求解。解题代码public class Solution { public int countNumbersWithUniqueDigits(int n) { if(n==0) return 1; if(n==1) return 10; int ans=10;int num = 9;int t=9;

原题链接解题思路首先将元音存储在一个list中，方便判断。（包括大小写）遍历原字符串将里面的元音记录到StringBuilder中，并反转遍历原字符串，将反转后的StringBuilder里的char写入char数组中将char数组转化为String返回解题代码public class Solution { public String reverseVowels(String s)

原题链接解题思路刚开始想了很多，后来寻思着找规律吧。然后列了2到10的答案，最后发现从7开始答案等于ans[i] = ans[i-3]*3;解题代码public class Solution { public int integerBreak(int n) { if(n==2) return 1; if(n==3) return 2; if(n

原题链接解题思路刚开始题目理解错了，不过仔细审题后轻松解决首先把特殊数字处理了，即非正数和1将要处理的数字num & (num-1)。这样可以得出其总共有几个1（二进制）若只有最高位为1，那再判断其二进制0的总个数是否是2的倍数。（4的二进制是两个0）。得出答案。解题代码public class Solution { public boolean isPowerOfFour(int

原题链接原题链接解题思路原题说不能用加减法，所以我们第一个先想到可不可以使用位与运算。具体思路：根据以前所学的知识 a xor b 即1+1 =0 0+0 = 0 1+0=1，这就是不带进位的加法运算。若想将a xor b进位，即1+1 =1 0+0 = 0 1+0=0，用a & b，当然在向左移一位达到进位。得到式子（a xor b）+ （(a & b) << 1），当然还有可能进位，这时候

原题链接原题链接解题思路可以用动态规划来解决. 为了使得问题可以转化为子问题, 最好将数组排列, 然后当nums[i]%nums[j]==0的时候就可以得到一个状态转移方程dp[i] = max(dp[i], dp[j]+1),nums[i] > nums[j],并且之前能够被nums[i]整除的数, 也必然能够被nums[j]整除, 这就保证了状态转移方程的正确性. 首先将数组排序，并建立dp数

原题链接原题链接解题思路这题非常明显，不能用sqrt，那就用二分法解决。本题还是有坑的，就是使用long，因为给的num可能非常大，导致两数相乘超过int。我在这里刚开始考虑没到，错了几次，二分法经典步骤。先设left = 0; right = num;循环left <= right ;当mid×mid == num，true退出。当mid×mid < num ; left = mid + 1

原题链接原题链接解题思路第一次提交的代码效率很差，排名很靠后。 后面重新去思考了一下题目，将一部分数字展开二进制，发现有如下规律ans[i] = ans[(i & i-1)] + 1; 解题代码public class Solution { public int[] countBits(int num) { int[] ans = new int[num+1];

原题链接原题链接解题思路找了一下午的突破口。后面根据其他人的答案找到了。遗憾不是自己独立完成的。 此题考察dfs和动态规划吧。子问题：每一个节点都有两种操作，选自己或不选自己。两种操作对应了两个最大值。然后dfs到最深处，再自底向上的解决整个问题。创建dfs方法。根据题意，如果选了自己，则不能选他的孩子，则得到选自己的最大值等于自己的值加上孩子没选自己的最大值。详见代码如果没选自己，则可以选

原题链接原题链接解题思路题目要求在n时间复杂度，一次遍历搞定。设定min，mid两个指示值。搞定mid的取值。（用flag来找，第一个比min大的数就是mid）只要有大于mid返回true，结束。解题代码public class Solution { public boolean increasingTriplet(int[] nums) { if(nums.leng

原题链接原题链接解题思路考察图以及深度搜索。dfs算法（也就是递归）注意一个是边界点，一个是状态恢复的过程。此题很明显当ans.size() == tickets.length+1结束。用Map存储图。存储后并将其列表按排序。dfs算法遍历整个图。并且将遍历结果存储到list返回。解题代码public class Solution { Map<String,List<String>>

原题链接原题链接解题思路解这道题花了一点时间。发现用PriorityQueue来解决这问题就变得简单了。先用一个类封装了row，col，val，并实现compareTo方法，方便用PriorityQueue排序。先将最小值0,0,nums1[0]+nums2[0]压入优先队列。算法思想是bfs，从优先队列取出最小值并加入List解题代码public class Solution { pu

原题链接原题链接解题思路刚开始并不是很理解题意，然后去看了看讨论区的大神们。大概明白了。 对于每一个数字x在数组[i~j],我们算他的花费为 x + max{DP([i~x-1]), DP([x+1, j])}。 the max意思是无论你猜哪个数字，这个数字的反馈都是最差的，需要花费很多。 the min是指在这么多最差反馈里挑出最少的花费。 数组dp[i][j] 表示i～j的minmax

原题链接原题链接解题思路贪心。我用了min，max，flag，res保存状态。 遍历数组，对于每一个数作出判断具体判断看代码注释吧。解题代码public class Solution { public int wiggleMaxLength(int[] nums) { if(nums.length < 1 || null == nums) { ret

原题链接原题链接解题思路刚看到题目的我是一脸懵逼的。看题目的标签是动态规划，可见自己的动态规划很弱，需要加强。 首先构造数组dp[i]用来表示target等于i时有多少种类。并且定义dp[0] = 1。 状态转移方程是dp[i] = sum(dp[i - nums[k]]) (k<=i);为什么将dp[0] = 1,就很明显了，因为当一个数字和target相等，此数字只有一种排列。 这样直到求

原题链接原题链接解题思路单列表题。只要任一列表节点不为空，还有进位数字不为0就一直循环执行。维护好进位就行了。不难。解题代码/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x