喝泉水的泉

总体来说是回溯法，模板，框架整起来，但是差别还是有的。//子集问题public class Test { static List<List<Integer>> res=new ArrayList<>(); public static void main(String[] args) { List<Integer> list= Arrays.asList(1,2,3); LinkedList<Intege

该公司是搞AI算法，面试官给我说要来一个图的算法题。然后是下面这道题。给了15分钟时间吧。然后我看题目看了几分钟，没跟图的知识联系起来。哈哈哈哈哈哈哈哈哈哈然后我就暴力解决了，最后结果是大数据过不去，时间复杂度是O（N*N）。面试官说让我下去再做一下，咋们接着继续。我学习了官方O（N）的解法，双指针。哈哈哈哈哈哈哈我的暴力解法class Solution { public int maxArea(int[] height) { int len=height.lengt

这题挺老套的，就是建立大根堆。然后依次交换第0和最后一个元素k-1次，第k大的数就在数组首部了。附上代码：class Solution { public int findKthLargest(int[] nums, int k) { int n=nums.length; getHeap(nums,n); for(int i=n-1;i>=n-k+1;i--){//取出前k-1个数 swap(nums,0,i);

解题思路：对于任意一个节点，假设左右子树路径长度已算出，最长路径等于什么呢？if（this.val==this.left.val&&this.val= =this.right.val）sum等于左子树长度加右子树长度+2if（this.val！=this.left.val&&this.val！=this.right.val）sum=0；还有两种情况不列大家也懂了吧。class Solution { int res; public int lon.

解题思路：二叉树的题目不用说，三行经典遍历。剩下的都是细节。递归函数的意义是什么呢？我们可以这样考虑，对任意一个节点，他的左子树多x个硬币，右子树多y个硬币，（x<0代表多负数个，即差几个）那么这个节点多x+y+this.val-1个节点。设置一个全局变量（属性，java里没有全局变量的概念，因为java是完全面向对象的，这里说全局变量是c带来的习惯，意思差不多，还是那根豆芽，叫什么不重要）记录移动的次数。代码如下：class Solution { int res; p.

题目很短，简单来说就是有两个节点位置不对，你得把它们交换回来。那么如何做呢？思路很简单，首先，得知道是哪两个节点吧。找到了需要交换的节点，节点值相互换一下不就好了。有了思路，大致框架就可以写出来了。public void recoverTree(TreeNode root) { dfs(root); int t=x.val; x.val=y.val; y.val=t; }dfs就是找节点的函数，关键是怎么找。分情况找，假..

解题思路：你变成我，走过我走过的路。我变成你，走过你走过的路。然后我们便相遇了…public ListNode getIntersectionNode(ListNode headA, ListNode headB) { ListNode h1=headA,h2=headB; while(h1!=h2){ if(h1!=null) h1=h1.next; else h1=headB; if(h2.

一晃一个月没写博客了，时间总是悄悄的向前啊。二叉树与链表的结合，二叉树与链表都是递归的宠儿。二叉树与链表问题是天然的递归问题，只有直击问题本质方能立于不败之地。这次给大家带来一道二叉树的中等题，也不难，就是练习练习递归，写的玩玩，练练手吧。题目一看完，心中大致框架就有了，分两步，第一步遍历树，只要树节点值等于链表的第一个节点的值，那就得开始匹配了吧，看看能不能匹配的上。第一步：树的遍历，闭着眼睛也能写吧。void dfs(TreeNode root,ListNode head){

来一道leetcode中等难度的题目。这一题我一看完题目，花了大概2分钟，写了个回溯算法，如下。class Solution { int max=0; public int maxScore(int[] cardPoints, int k) { back(cardPoints,0,k,0,0,cardPoints.length-1); return max; } void back(int[] cardPoints,int sum,int.

这一题方法很多，比如递归，动态规划。递归又分优化去重，不优化暴力。总体来说怎么弄可以。递归就是从自顶向下，动态规划就是自下而上。大同小异。如果数据量不大，这一题还可以用回溯算法。如何回溯？回溯思路：回溯其实很简单，我们先不管计算机，先想一下人怎么解题。最直接的方式不就是从第一行开始，把所有情况列出来，最后看条路径和最小么。回溯其实就是描述的这样的过程。我们先来看下回溯的代码class Solution { int min=Integer.MAX_VALUE; public int .

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。这一题可以采用回溯算法。我附上一段测试代码，帮助大家理解回溯的过程。而不是从理论上去讲递归怎么运行，递归运行只有一个结果，对递归不熟悉的朋友们根本无法理解。只有搞清递归运行的过程才能真正解决回溯问题，不然都是耍流氓。先附上递归每一步的操作。public class Solution { public static void main(String[] args) { int[] a=

现在程序员工作不好干，转行颇多。据说小偷还不错，一次挣好几万，可以考察一波。可以小偷也不好当啊，话说干一票少一票，常在河边走，哪有不湿鞋。出去一次应该考虑收益最大化吧，所以说，必要的筹谋少不了。普通街区抢劫思路：由于不能盗窃相邻的两家，我从第0到i家考虑，假设第i家我进去了，那么第i-1家我就不能进去了，不然被抓了，岂不是鸡飞蛋打。所以我只需要考虑怎么使得前面i-2家的收益最高。如果第i家没有进去，那我就可以去i-1家了，考虑如何使前i-1家收益最大。现在问题规模不知不觉就变小了，由i变成了i-2或.

先看一个例子，这是leetcode上一道中等难度的题。思路：根据中序遍历去找下一个节点就好，设置一个pre节点记录前一个位置。提供两种方法吧。第一种是设置类成员pre和ans，这种方法较为简单直接，因为不必考虑递归的返回值问题。class Solution { TreeNode pre,res; public TreeNode inorderSuccessor(TreeNode root, TreeNode p) { f(root,p); retur

方法总结：1.先聊一聊回溯算法，名字很高端，其实内容很朴实。就是穷举所有方案。再具体一点，可以理解为没有优化的动态规划。动态规划还可以消除一些重复项，优化算法，回溯直接全部举出来，没法优化。数学大佬高斯一生也没有解决8皇后问题，可想回溯算法时间复杂度有多高。2.解题模板其实也好说，如下 public void backtracking(){ if(){//括号里写满足的结束条件 res.add()//添加合适的路径 return; .

滑动窗口大致思路如下：1.对字符串s，初始化双指针，left=right=0；【left，right】区间称为窗口。2.不断增大right，一直到窗口中的字符串满足题目要求。3.停止增加right，增大left，直到窗口不再符合题意。4.重复2,3，一直遍历完s.5.简单来说就是先找解，再找最小的解。有了思路，我们来实操一下，先来一道leetcode的hard题目。class Solution { public String minWindow(String s, String t)

class Solution { public List<List<Integer>> threeSum(int[] nums) { List<List<Integer>> list=new ArrayList<>(); int n=nums.length; int j,k,sum; Arrays.sort(nums); for(int i=0;i<.

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

class Solution { public void merge(int[] A, int m, int[] B, int n) { int pa=m-1,pb=n-1; int resp=m+n-1; while(pa>=0&&pb>=0){ if(A[pa]>=B[pb]){ A[resp--]=A[pa--]; }else A.

class Solution { public int findDuplicate(int[] nums) { int fast=0,low=0; while(true){ low=nums[low]; fast=nums[nums[fast]]; if(fast==low) break; } low=0; while(fast!=low){ .

class Solution { public ListNode getKthFromEnd(ListNode head, int k) { ListNode fast,low; fast=low=head; while(k-->0){ fast=fast.next; } while(fast!=null){ fast=fast.next; .

class Solution { public int[] maxSlidingWindow(int[] nums, int k) { if(nums.length==0) return new int[0]; mydeque deque=new mydeque(); int n=nums.length; int[] res=new int[n-k+1]; for(int i=0;i<n;i++){ .

class MaxQueue { LinkedList<Integer> deque1,deque2; public MaxQueue() { deque1=new LinkedList<>(); deque2=new LinkedList<>(); } public int max_value() { if(deque2.isEmpty()) return -1; .

class Solution { public int[] nextGreaterElements(int[] nums) { Stack<Integer> stack=new Stack<>(); int n=nums.length; int[] res=new int[n]; for(int i=2*n-1;i>=0;i--){ while(!stack.empty()&amp.

class StockSpanner { Stack<Integer> stack1,stack2; public StockSpanner() { stack1=new Stack<>(); stack2=new Stack<>(); } public int next(int price) { int t=1; if(stack1.empty()){ .

class Solution { public int[] dailyTemperatures(int[] T) { LinkedList<Integer> stack=new LinkedList<>(); int length=T.length; int[] ans=new int[length]; for(int i=0;i<length;i++){ if(!stack.i.

class MyQueue { Stack<Integer> stack1,stack2; /** Initialize your data structure here. */ public MyQueue() { stack1=new Stack<>(); stack2=new Stack<>(); } /** Push element x to the back o.

class Solution { int i; public String decodeString(String s) { LinkedList<String> list=new LinkedList<>(); i=0; char c; while(i<s.length()){ c=s.charAt(i); if(Cha.

class Solution { public List<String> buildArray(int[] target, int n) { ArrayList<String> list=new ArrayList<>(); Stack<Integer> stack=new Stack<>(); for(int i=1,index=0;i<=n&&index<t.

class Solution { public String removeDuplicates(String S) { if(S.length()==1) return S; char c; Stack<Character> stack=new Stack<>(); StringBuffer list=new StringBuffer(); stack.push(S.charAt(0)); .

class Solution { public boolean backspaceCompare(String S, String T) { Stack<Character> sstack=new Stack<>(); Stack<Character> tstack=new Stack<>(); char c; for(int i=0;i<S.length();i++){ .

class MinStack { Stack<Integer> stack1; Stack<Integer> stack2; /** initialize your data structure here. */ public MinStack() { stack1=new Stack<>(); stack2=new Stack<>();; } public void push(int val) { if(stack1.e.

class Solution { public int[] nextGreaterElement(int[] nums1, int[] nums2) { if(nums2.length==0) return null; HashMap<Integer, Integer> map = new HashMap<>(); Stack<Integer> stack = new Stack<>(); .

class Solution { public int removeDuplicates(int[] nums) { if(nums.length==0) return 0; int i=0; for(int j=1;j<nums.length;j++){ if(nums[i]!=nums[j]){ nums[++i]=nums[j]; } } ..

#include <iostream>#include<bits/stdc++.h>using namespace std;int main(){ int arr[3][3]={{1,3,1},{1,5,1},{4,2,1}}; int dp[3][3]={0}; int i,j; dp[0][0]=arr[0][0]; for(i=1;i<3;i++){ dp[0][i]=dp[0][i-1]+arr[0][i];...

#include <iostream>#include<bits/stdc++.h>using namespace std;int a[10][10];int f(int i,int j){if(i==0||j==0) return 1;if(a[i][j]!=0) return a[i][j];a[i][j]=f(i,j-1)+f(i-1,j);return a[i][j];}int main(){ int re; r...

最大值情况只有三种可能：1.左边一半之中取的2.右边一半之中取的3.中间连续的取得#include <iostream>#include<bits/stdc++.h>using namespace std;int f(int *a,int from,int to);int main(){ int object[10]={1,-2,3,10,-4,7,2,-5};//目标数组 int re=0; re=f(object,0,7);...

class Solution { public int getKthMagicNumber(int k) { int[] result=new int[k]; result[0]=1; int x=0,y=0,z=0; for(int i=1;i<k;i++){ result[i]=Math.min(result[x]*3,Math.min(result[y]*5,result[z]*7)); ...

class MyCircularQueue { int[] queue; int front,rear,count,size; /** Initialize your data structure here. Set the size of the queue to be k. */ public MyCircularQueue(int k) { queue=new int[k]; front=rear=count=0; ...

class RecentCounter { int count; public RecentCounter() { this.count=0; } Queue<Integer> queue=new LinkedList<>(); public int ping(int t) { int c=0; queue.offer(t); Queue<Integer&g...

/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* reverseList(struct ListNode* head){ if(head==NULL||head->next==NULL) return head; struct ListNode *p,*q,*...