weixin_39248750的博客

int[] res; int count=0; public int[] printNumbers(int n){ res=new int[(int)Math.pow(10,n)-1]; for(int digit=1;digit<=n;digit++){ for(char first='1';first<='9';first++){ char[] num=new char[...

方法一：动态规划dp[i]表示长度为i的绳子剪后的最大值。分情况讨论将长度为i的绳子剪下长度为[2,i)的一段后最大乘积。比如剪下的长度为j，剩下(i-j)的长度是否再剪，如果不剪，就是两段，i和i-j相乘，如果剪，就是i和dp[i-j]相乘。public int cuttingRope(int n){ int[] dp=new int[n+1]; dp[2]=1; for(int i=3;i<=n;i++){ fo

public int lastRemaining(int n, int m){ int index=0; //反推，从数组长度为2开始 for(int len=2;len<=n;len++){ index=(index+m)%len; } return index; }

思路：线性遍历数组并添加字符到结果中，使用取余的算法。public String reverseLeftWords(String s, int n){ String res=""; for(int i=n;i<s.length()+n;i++){ res+=s.charAt(i%s.length()); } return res; }...

思路：双指针，分别指向数组的头和尾，根据两指针指向的数之和移动指针。public int[] twoSum(int[] nums, int target){ int left=0; int right=nums.length-1; while(left<right){ int sum=nums[left]+nums[right]; if(sum<target){ .

思想：滑动窗口。窗口内左闭右开。public int[][] findContinuousSequence(int target){ int left=1; int right=1; int sum=0; List<int[]> res=new ArrayList<>(); while(left<=target/2){ if(sum<target){ .

思路：在已有的丑数序列上每一个数都必须乘2， 乘3， 乘5， 这样才不会漏掉某些丑数。假设已有的丑数序列为[1, 2, 3, ..., n1, n2], 如果单纯的让每个丑数乘2， 乘3， 乘5顺序排列的话肯定会有问题，比如如果按照这样的顺序排列下去肯定有问题[1*2, 1*3, 1*5, 2*2, 2*3, 2*5, 3*2, 3*3, 3*5, ... , n1 *2, n1 * 3, n1 * 5, n2 * 2, n3* 3, n2 * 5]，因为后面乘2的数据可能会比前面乘3乘5的数据要小，那

public String minNumber(int[] nums){ String[] array=new String[nums.length]; for(int i=0;i<nums.length;i++){ array[i]=String.valueOf(nums[i]); } Arrays.sort(array,(x,y)->(x+y).compareTo(y+x)); St...

public static int countDigitOne(int n){ int base=1; int a=n/base/10; int b=n%base; int cur=n/base%10; int sum=0; while(a!=0||cur!=0){ if(cur>1){ sum+=(a+1)*base; ...

public int[] exchange(int[] nums){ int left=0; int right=nums.length-1; while(left<right){ while(left<right&&nums[right]%2==0) right--; while(left<right&&nums[left]%2==1) left++; .

public String replaceSpace(String s) { StringBuffer res=new StringBuffer(); for(Character c:s.toCharArray()){ if(c==' '){ res.append("%20"); } else res.append(c); } return.

思路：一个字母出现的次数大于 1 次就不符合要求了，这个时候使用 Fasle 标记状态相对于 Integer 的不断递增更合理，也更省空间。public char firstUniqChar(String s){ Map<Character,Boolean> dic=new HashMap<>(); char[] array=s.toCharArray(); for(char c:array){ dic.p

先计算B的下三角，乘入B[]中，再计算上三角。public static int[] constructArr(int[] a){ int len=a.length; if(len==0) return new int[0]; int[] b=new int[len]; b[0]=1; int temp=1; //下三角 for(int i=1;i<len;i++){ ...

public boolean isNumber(String s){ if(s==null||s.length()==0) return false; boolean numSeen=false; boolean eSeen=false; boolean dotSeen=false; char[] array=s.trim().toCharArray(); for(int i=0;i<array.leng.

在每轮数字拼接前，判断 resres 在此轮拼接后是否超过 2147483647，若超过则加上符号位直接返回。设数字拼接边界 bndry=2147483647 // 10=214748364，则以下两种情况越界：res>bndry 情况一：执行拼接10×res≥2147483650越界res=bndry，x>7 情况二：拼接后2147483648或2147483649public int strToInt(String str...

public boolean isStraight(int[] nums){ Arrays.sort(nums); int joker=0; for(int i=0;i<nums.length;i++){ if(nums[i]==0) joker++; //判断排序后的数组有没有重复 else if(nums[i]==nums[i-1]) return false; ...

public int[] spiralOrder(int[][] matrix) { if(matrix.length==0) return new int[0]; int left=0; int right=matrix[0].length-1; int top=0; int down=matrix.length-1; int[] res=new int[(right+1)*(down+1)]; .

思路：本题需要实现 “当n=1n=1时终止递归” 的需求，可通过短路效应实现。int res=0; public int sumNums(int n) { boolean sum=(n>1)&&sumNums(n-1)>0; res+=n; return res; }

public int[] singleNumbers(int[] nums) { int m=0;//异或结果 for(int num:nums){ m^=num; } int n=1; while((n&m)==0){ n<<=1; } //将数组分成两组 int team1=0; int ...

public double myPow(double x, int n) { long b=n; if(b<0){ x=1/x; b=-b; } double res=1.0; while(b>0){ if((b&1)==1){ res*=x; } x*...

public int hammingWeight(int n) { int res=0; while(n!=0){ n=n&(n-1); res++; } return res; }

public int add(int a, int b) { while(b!=0){ int c=(a&b)<<1;//计算进位 a^=b;//没有进位的和 b=c; } return a; }

题目要求获取一个数据流排序后的中位数，那么可以使用两个优先队列（堆）实现。本题使用一个大顶堆和一个小顶堆：大顶堆用来存放较小的那一半值，小顶堆用来存放较大的那一半值。输入数组元素中，需要保持两个堆的长度相等，如果数组长度为奇数，就使小顶堆为长度更大的那一个，最后中位数就是小顶堆的堆顶。如果直接把值插入到堆里，因为无法确定这个值是较大的那一半还是较小的那一半，如果是较大的那一半，直接放入小顶堆不会破坏顺序，反之如果是较小的那一半，会破坏堆内的顺序，所以：当两个堆长度一样时，先放入大顶堆，大顶堆重新

public int[] getLeastNumbers(int[] arr, int k){ quickSort(arr,0,arr.length-1); return Arrays.copyOf(arr,k); } public void quickSort(int[] arr,int left,int right){ if(left>=right) return; int low=left; in.

public int findRepeatNumber(int[] nums) { int index=0; while(index<nums.length){ if(nums[index]==index){ index++; continue; } if(nums[index]==nums[nums[index]]) retur...

方法一：dfsvisited[i][j]=true;没有再回溯是因为k的值是不变的，遍历后一旦不符合就是永远不符合要求，不用回溯。public int movingCount(int m, int n, int k){ boolean[][] visited=new boolean[m][n]; return dfs(visited,m,n,k,0,0); } public int dfs(boolean[][] visited,int m,int

public boolean exist(char[][] board, String word){ char[] array=word.toCharArray(); for(int i=0;i<board.length;i++){ for(int j=0;j<board[0].length;j++){ if(dfs(i,j,0,array,board)) return true; .

方法一：动态规划+哈希表public int lengthOfLongestSubstring(String s){ HashMap<Character,Integer> map=new HashMap<>(); int lastDp=0; int res=0; for(int i=0;i<s.length();i++){ int lastIndex=map.getOrDefaul

public int maxValue (int[][] grid) { int m=grid.length; int n=grid[0].length; int[][] dp=new int[m+1][n+1]; for(int i=1;i<=m;i++){ for(int j=1;j<=n;j++){ dp[i][j]+=Math.max(dp[i-1][j],dp[i].

public boolean isMatch(String A, String B) { int n = A.length(); int m = B.length(); boolean[][] f = new boolean[n + 1][m + 1]; for (int i = 0; i <= n; i++) { for (int j = 0; j <= m; j++) { ...

剑指offer69 跳台阶public int Fibonacci(int n) { int a=0,b=1,sum; for(int i=0;i<n;i++){ sum=a+b; a=b; b=sum; } return a; }剑指offer10 Fib opublic int climbStairs(int n) { ..

线性动态规划public int maxSubArray(int[] nums) { int res=nums[0]; for(int i=1;i<nums.length;i++){ nums[i]+=nums[i-1]>0?nums[i-1]:0; res=Math.max(res,nums[i]); } return res; }

确定所求数字在该数字范围中的第n个数位public int findNthDigit(int n){ int digit=1; long start=1; long count=9; while (n>count){ n-=count; start*=10; digit+=1; count=start*digit*9; .

public boolean findNumberIn2DArray(int[][] matrix, int target){ int i=matrix.length-1; int j=0; while(i>=0&&j<matrix[0].length){ if(matrix[i][j]>target) i--; else if(matrix[i][j]<target) .

遍历数组时的规律：因此，队列始终是一个降序队列，队首一定是当前窗口最大值。每一次窗口向前滑动，是右边界向右移，左边界向右移。右边界是对比数组中下一个数的大小来实现，左边界需要将当前坐标-窗口长度得到的坐标和队首元素进行对比，如果相同，说明已经不在窗口区间内，需要删掉队首元素，以达到窗口右移的效果。public int[] maxSlidingWindow(int[] nums, int k) { //代码分成窗口形成前和窗口形成后 if(nums.le...

public String reverseWords(String s) { String[] strings=s.trim().split(" "); StringBuilder sb=new StringBuilder(); for(int i=strings.length-1;i>=0;i--){ if(strings[i]=="") continue; sb.append(strings[i]+".

public boolean validateStackSequences(int[] pushed, int[] popped){ Stack<Integer> stack=new Stack<>(); int i=0; for(int num:pushed){ stack.push(num); while(!stack.isEmpty()&&stack.peek()=.

class MinStack { Stack<Integer> A, B; public MinStack() { A = new Stack<>(); B = new Stack<>(); } public void push(int x) { A.add(x); if(B.empty() || B.peek() >= x) B.add(x);.

LinkedList<Integer> A; LinkedList<Integer> B; public CQueue() { A=new LinkedList<>(); B=new LinkedList<>(); } public void appendTail(int value) { A.addLast(value); } pub...

方法一：递归public TreeNode mergeTrees(TreeNode t1,TreeNode t2){ if(t1==null||t2==null){ return t1==null?t2:t1; } t1.val+=t2.val; t1.left=mergeTrees(t1.left,t2.left); t1.right=mergeTrees(t1.right,t2.right);