刷题skill+编程cultivation+记录

AChris

注册一亩三分地论坛，查看更多干货！

您需要登录才可以下载或查看附件。没有帐号？注册账号

x

02/06/2019 第一天
Leetcode 59 Spiral Matrix II

这题主要是输入一个n，生成一个旋转上身的矩阵

解题思路：
暴力解决；
通过一个while loop嵌套四个for loop，每个for loop填满一行或一列；
每次一个for loop之后，改变 rowBegin, rowEnd, colBegin, colEnd

技巧：
通过 rowBegin, rowEnd, colBegin, colEnd 来记录未完成赋值到的区域

AChris

02/14/2019 Day9
LeetCode 60. Permutation Sequence

解题思路：这题主要是利用等价拆分排序的思想。
1. 首先想到，n个数，总共有n！种情况，第一位有n种情况，每种情况对应一个set，set相互之间有序，每个set有（n-1）！种情况。
2. 那么我们可以根据 k_index / (n-1) ！得到我们想要的数在第几个set里面
3. k_index % （n-1）！可以得到在那个set里面，我们要找第几个数

class Solution {
// method 1: 96.03% 100%
public String getPermutation(int n, int k) {
// time: O(n)
// space: O(n)
// {1,2,3,4}
// 1 -> {2,3,4}
// 2 -> {1,3,4}
// 3 -> {1,2,4}
// 4 -> {1,2,3}
//
// k = 18 -> k = 17
// index = k / fact[3] = 2; k = k % fact[3] = 5
// res = {1,2,4}
// k = 5
// index = k / fact[2] = 2; k = k % fact[2] = 1
//. res = {1,2}
// k = 1
// index = k / fact[1] = 1; k = k % fact[1] = 0
// res = {1}
// k = 0
// index = k / fact[0] = 0; k = k % fact[0] = 0
// res = {}
List<Integer> res = new ArrayList<Integer> ();
if (n == 0) new String ();
for (int i = 1; i <= n; i++) {
res.add(i);
}
//fact[i] to store i!
int[] fact = new int[n];
fact[0] = 1;
for (int i = 1; i < n; i++) {
fact[i] = fact[i-1] * i;
}
k = k - 1;
StringBuilder sb = new StringBuilder ();
for (int i = n - 1; i >= 0; i--) {
int index = k / fact[i];
k = k % fact[i];
sb.append(res.get(index));
res.remove(index);
}
return sb.toString();
}
// // method 2: 15.53% 100%
// // time: O(n*k)
// // space: O(n)
// public String getPermutation(int n, int k) {
// StringBuilder sb = new StringBuilder ();
// if (n == 0) return sb.toString();
// for (int i = 1; i <= n; i++) {
// sb.append((char)('0' + i));
// }
// for (int i = 1; i < k; i++) {
// increasePer(sb);
// }
// return sb.toString();
// }
// private void increasePer(StringBuilder sb) {
// int firstSmall = -1;
// for (int i = sb.length() - 2; i >= 0; i--) {
// if (sb.charAt(i) < sb.charAt(i+1)) {
// firstSmall = i;
// break;
// }
// }
// // System.out.println("*firstSmall*" + firstSmall);
// if (firstSmall == -1) {
// reverse(sb, 0, sb.length() - 1);
// }
// // firstLarge must exists since sb.charAt(firstSmall) < sb.charAt(firstSmall + 1)
// int firstLarge = -1;
// for (int i = sb.length() - 1; i >= firstSmall + 1; i--) {
// if (sb.charAt(i) > sb.charAt(firstSmall)) {
// firstLarge = i;
// break;
// }
// }
// // System.out.println("*firstLarge*" + firstLarge);
// swap(sb, firstSmall, firstLarge);
// reverse(sb, firstSmall + 1, sb.length() - 1);
// }
// private void reverse(StringBuilder sb, int i, int j) {
// while( i < j) {
// swap(sb, i++, j--);
// }
// }
// private void swap(StringBuilder sb, int i, int j) {
// char temp = sb.charAt(i);
// sb.setCharAt(i, sb.charAt(j));
// sb.setCharAt(j, temp);
// }
}

复制代码

AChris

03/08/2019 Day31

Leetcode 200. Number of Islands
Importance【5】

解题思路：
这题主要是暴力解决+DFS/BFS。
具体来说。暴力解决是指，遍历矩阵中的每一个点，看是否为1。然后对每一个点用 DFS/BFS 来搜索该点相邻的点，并将它们设置为其他数，表示这个岛屿已经被发现了。

设置成的数，可以是0，这样最快，最省空间，但不可以将grid回复到原来的样子。
如果要将 grid 在 count 完岛屿之后，恢复到原来的样子，可以将设置成的数变成是1、2然后在搜索之后进行恢复。

class Solution {
// method 1: DFS
public int numIslands(char[][] grid) {
// time: O(m*n) 99.99%
// space: O(m*n) 63.72% since the max depth of the dfs tree is m*n
if (grid == null || grid.length == 0 || grid[0] == null || grid[0].length == 0) return 0;
int rowNum = grid.length;
int colNum = grid[0].length;
int res = 0;
for (int i = 0; i < rowNum; i++) {
for (int j = 0; j < colNum; j++) {
if (grid[i][j] == '1') {
dfs(grid, i, j, rowNum, colNum);
res++;
}
}
}
return res;
}
private void dfs(char[][] grid, int i, int j, int rowNum, int colNum) {
if (i < 0 || i >= rowNum || j < 0 || j >= colNum || grid[i][j] == '0') return;
// if we do not want to restore the original graph, we can use 0
// if we want to restore the original graph, we should use another number except from 0
grid[i][j] = '0';
dfs(grid, i+1, j, rowNum, colNum);
dfs(grid, i-1, j, rowNum, colNum);
dfs(grid, i, j+1, rowNum, colNum);
dfs(grid, i, j-1, rowNum, colNum);
return;
}
// // method2 : BFS
// class Coordinate {
// int x;
// int y;
// public Coordinate (int x, int y) {
// this.x = x;
// this.y = y;
// }
// }
// public int numIslands(char[][] grid) {
// // time: O(m*n) 9.68%
// // space: O(m*n) 9.02%
// if (grid == null || grid.length == 0 || grid[0] == null || grid[0].length == 0) return 0;
// int rowNum = grid.length;
// int colNum = grid[0].length;
// int res = 0;
// Queue<Coordinate> queue = new LinkedList<> ();
// for (int i = 0; i < rowNum; i++) {
// for (int j = 0; j < colNum; j++) {
// if (grid[i][j] == '1') {
// // Initialize the BFS
// queue.add(new Coordinate(i, j));
// // use the BFS to set all num in this island to be 0
// while (!queue.isEmpty()) {
// Coordinate cur = queue.poll();
// int x = cur.x;
// int y = cur.y;
// if (x < 0 || x >= rowNum || y < 0 || y >= colNum || grid[x][y] == '0') {
// continue;
// } else {
// grid[x][y] = '0';
// queue.add(new Coordinate(x+1, y));
// queue.add(new Coordinate(x-1, y));
// queue.add(new Coordinate(x, y+1));
// queue.add(new Coordinate(x, y-1));
// }
// }
// res++;
// }
// }
// }
// return res;
// }
}

复制代码

AChris

02/10/2019 Day5

Leetcode 56. Merge Intervals

本题有两种算法，在本质上是一样的，都是通过考虑不同区间的叠加状况，来求解result

解题思路：方法一更优，是扫描线算法的一种。
确定start end，不断考虑下一个区间的情况。当不能合并当前interval和下一个interval时，添加interval。
然后，把下一个interval的起终作为start，end，继续loop

/**
* Definition for an interval.q
* public class Interval {
* int start;
* int end;
* Interval() { start = 0; end = 0; }
* Interval(int s, int e) { start = s; end = e; }
* }
*/
class Solution {
// method 1
public List<Interval> merge(List<Interval> intervals) {
// time: O(nlogn) 25.92%
// space: O(n) 41.53%
// |------| |-------|
// |-----| |---|
if (intervals == null || intervals.size() <= 1) return intervals;
Collections.sort(intervals, (a, b) -> a.start - b.start);
List<Interval> res = new ArrayList<> ();
int start = intervals.get(0).start;
int end = intervals.get(0).end;
for (Interval interval: intervals) {
if (interval.start <= end) {
end = Math.max(end, interval.end);
} else {
res.add(new Interval(start, end));
start = interval.start;
end = interval.end;
}
}
res.add(new Interval(start, end));
return res;
}
// // method2 : works
// public List<Interval> merge(List<Interval> intervals) {
// time: O(nlogn) + O(n) 10.83%
// space: O(n) 2.24%
//
// List<Interval> res = new ArrayList<Interval> ();
// //corner case
// if (intervals.size() == 0 || intervals == null) return res;
// Collections.sort(intervals, (a,b) -> a.start - b.start);
// List<Integer> starts = new ArrayList<> ();
// List<Integer> ends = new ArrayList<> ();
// for (Interval interval: intervals) {
// starts.add(interval.start);
// ends.add(interval.end);
// }
// while (ends.size() > 0) {
// int curStart = starts.get(0);
// starts.remove(0);
// int curEnd = ends.get(0);
// ends.remove(0);
// while ( starts.size() > 0 && ends.size() > 0 && curEnd >= starts.get(0)) {
// if (ends.get(0) <= curEnd) {
// starts.remove(0);
// ends.remove(0);
// } else if (ends.get(0) > curEnd && starts.get(0) <= curEnd) {
// starts.remove(0);
// curEnd = ends.get(0);
// ends.remove(0);
// }
// }
// res.add(new Interval(curStart, curEnd));
// }
// return res;
// }
}

复制代码

补充内容 (2019-2-11 10:04):
new一个list的时候记得用ArrayList
List只是interface，不能被new

AChris

02/07/2019 D2
Leetcode 54. Spiral Matrix

这题主要是输入一个m*n，按照spiral的规则遍历所有元素并返回一个list

解题思路：
暴力解决；
类似于上一题，但是由于输入的矩阵可能是不规则的m*n的矩阵，所以每个for loop 中沿着一行赋值的时候，一定要判断列begin end的条件满不满足
矩阵由于本身的对称性，所以loop 中一个条件就可以满足了

技巧：
注意corner case，尤其是输入是空集的情况

class Solution {
public List<Integer> spiralOrder(int[][] matrix) {

      // [[1, 2, 3, 4],
      //  [5, 6, 7, 8],
      //  [9, 10, 11, 12]]
      // rowBegin  rowEnd
      // 2       1
      // colBegin  colEnd
      // 1       1

      // time complexity: O(n) n elemnts
      // space complexity: O(n)

      if (matrix.length == 0) return new ArrayList<Integer>();

      List<Integer> res = new ArrayList<Integer> ();
      int rowBegin = 0, rowEnd = matrix.length - 1;
      int colBegin = 0, colEnd = matrix[0].length - 1;

      while (rowBegin <= rowEnd && colBegin <= colEnd) {
         for (int i = colBegin; i <= colEnd && rowBegin <= rowEnd; i++) res.add(matrix[rowBegin][i]);
         rowBegin++;

         for (int i = rowBegin; i <= rowEnd && colBegin <= colEnd; i++) res.add(matrix[i][colEnd]);
         colEnd--;

         for (int i = colEnd; i >= colBegin && rowBegin <= rowEnd; i--) res.add(matrix[rowEnd][i]);
         rowEnd--;

         for (int i = rowEnd; i>= rowBegin && colBegin <= colEnd; i--) res.add(matrix[i][colBegin]);
         colBegin++;
      }

      return res;
}
}

AChris

02/07/2017 Day 2

解题思路：首先，考虑两个数相乘，得到的结果最大会是几位数，然后创建相应的int[]用于存放结果。
然后，利用乘法，把两个多位数的乘法转化为很多个个位数的和。
个位数的加减乘除我们可以通过 ‘？’与 ‘0’ 相减来得到相应的int。

intuition：想到个位数的加乘可以通过char来实现，然后把多位数乘法往个位数乘法转化

class Solution {
public String multiply(String num1, String num2) {

      // time: O(m * n)
      // space: O(m + n)

      if (num1 == null || num2 == null) return "0";

      int[] digits = new int[num1.length() + num2.length()];
      for (int i = num1.length() - 1; i >= 0; i--) {
         for (int j = num2.length() - 1; j >= 0; j--) {
            int product = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
            int p1 = i + j, p2 = i + j + 1;
            int sum = digits[p2] + product;
            digits[p2] = sum % 10;
            digits[p1] += sum / 10;
            if (digits[p1] == 10) {
                  digits[p1] = 0;
                  digits[p1 - 1] += 1;
            }
         }
      }

      // do not forget the case where product is 0
      StringBuilder sb = new StringBuilder();
      for (int digit: digits) {
         if (!(digit == 0 && sb.length() == 0)) {
            sb.append(digit);
         }
      }

      return sb.length() == 0? "0" : sb.toString();

}
}

补充内容 (2019-2-8 10:07):
Leetcode 43. Multiply Strings

AChris

02/08/2019 Day 3

LeetCode 17. Letter Combinations of a Phone Number

解题思路：利用DFS的递归对所有可能的结果进行遍历，将最底层符合要求的String添加到result中去

技巧：
1.要用递归的时候，把 Recursion Tree 画出来！！然后对着树写
2.递归的时候，首先写base case，然后写递归的具体内容，然后记住要recover！！！
3.生成一些辅助性的hashmap的时候，可以专门可以写一个method construct他，这样结构清楚

public List<String> letterCombinations(String digits) {
/*
root
/. |. \
level 0: "2" 'a' 'b' 'c'
/. |. \
level 1: "3" 'ad' 'ae' 'af'
*/
// time: O(4**n) n is length of digits
// complexity: O(n) sb is dynamic with length at most n, other is constant
List<String> res = new ArrayList<String> ();
// corner case
if (digits == null || digits.length() == 0) return res;
StringBuilder sb = new StringBuilder ();
Map<Character, String> numToString = constructNumToString();
dfsHelper(res, 0, sb, numToString, digits);
return res;
}
private void dfsHelper(List<String> res, int level, StringBuilder sb, Map<Character, String> numToString, String digits) {
// base case
if (level == digits.length()) {
res.add(sb.toString());
return;
}
// recursion
for (char ch: numToString.get(digits.charAt(level)).toCharArray()) {
sb.append(ch);
dfsHelper(res, level+1, sb, numToString, digits);
// recover
sb.deleteCharAt(sb.length() - 1);
}
return;
}
private Map<Character, String> constructNumToString() {
Map<Character, String> numToString = new HashMap<> ();
numToString.put('0', "");
numToString.put('1', "");
numToString.put('2', "abc");
numToString.put('3', "def");
numToString.put('4', "ghi");
numToString.put('5', "jkl");
numToString.put('6', "mno");
numToString.put('7', "pqrs");
numToString.put('8', "tuv");
numToString.put('9', "wxyz");
return numToString;
}

复制代码

补充内容 (2019-2-9 11:33):
按照格式添加进去的java代码间距怎么突然这么大，下次还是直接粘贴文本吧

补充内容 (2019-2-9 11:34):
刷新一下格式又好了hhh

AChris

02/09/2019 Day 4

LeetCode 31. Next Permutation

解题思路：本题利用当前已有的数字，通过交换数字，刚好找到比当前数字大的数字。比如
123 -> 132 -> 213 -> 231 -> 312 -> 321 --|
^ /
\--------------------------------------------------

具体的思路是，
step1:
找到firstSmall, firstSmall之后的所有书，是一个依次递减的数列，这个数列的数字排列处于最大的状态，没法增加

step2:
找到firstSmall之后的数列中，刚好比firstSmall大的数字，称作firstLarge

step3:
交换firstSmall 和 firstLarge，然后就得到了一个新的数字，比原来数字大，但此时，firstSmall后的依旧为一个递减数列，处于数列最大状态

step4:
reverse firstSmall之后的数列，使其成为递增数列，处于最小状态

over。

class Solution {
public void nextPermutation(int[] nums) {
// 1 2 3 7 5 8 6 3 2
// ^ firstSmall
// nums after firstSmall are sorted reversely, cannot be increased more
// 1 2 3 7 5 8 6 3 2
// ^ firstLarge
// first Large must exist, in worse case, it will be firstSmall + 1
// 1 2 3 7 6 8 5 3 2
// ^ ^ exchange
// 1 2 3 7 6 2 3 5 8
// ^| reverse nums
// time: O(n)
// space: O(1)
//corner case
if (nums == null || nums.length == 0) return;
// step 1:
int firstSmall = -1;
for (int i = nums.length - 2; i >= 0; i--) {
// use < since we need to find a descending subarrays where the value cannot be increased
if (nums[i] < nums[i+1]) {
firstSmall = i;
break;
}
}
if (firstSmall == -1) {
reverse(nums, 0, nums.length - 1);
return;
}
// step 2:
int firstLarge = -1;
for (int i = nums.length - 1; i > firstSmall; i--) {
if (nums[i] > nums[firstSmall]) {
firstLarge = i;
break;
}
}
// step 3:
swap(nums, firstSmall, firstLarge);
// step 4:
reverse(nums, firstSmall + 1, nums.length - 1);
return;
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
return;
}
private void reverse(int[] nums, int start, int end) {
while (start < end) {
swap(nums, start++, end--);
}
return;
}
}

复制代码

AChris

02/10/2019 Day5

Leetcode 118. Pascal's Triangle

解题思路：这是一道easy难度的recursion题目。
主要是注意写recursion 的时候有两个base case，最底层和最高层（因为最高层只需要加1次1，中间层需要手动加两次1）
每次进入下一个recursion后，记得return

class Solution {
public List<List<Integer>> generate(int numRows) {
// create n elements
// time: O(n)
// space: O(n)
List<List<Integer>> res = new ArrayList<List<Integer>> ();
if (numRows == 0) return res;
createLayer(res, 0, numRows);
return res;
}
private void createLayer(List<List<Integer>> res, int level, int numRows) {
// base case
if (level == numRows) return;
List<Integer> curRow = new ArrayList<Integer> ();
curRow.add(1);
if (level == 0) {
res.add(curRow);
// System.out.println(curRow);
createLayer(res, level+1, numRows);
return;
}
//recursion
List<Integer> lastRow = res.get(res.size() - 1);
for (int i = 0; i <= lastRow.size() - 2; i++) {
// System.out.print(i);
curRow.add(lastRow.get(i) + lastRow.get(i+1));
}
curRow.add(1);
res.add(curRow);
// System.out.println(curRow);
createLayer(res, level+1, numRows);
return;
}
}

复制代码

AChris

02/11/2019 Day6

Leetcode 62. Unique Paths

解题思路：本题自己用了3种方法来解。最后的一个方法由于时间复杂度k太大，没有过，因为递归过程中造成了重复计算
第一种方法就是简单的DP思路，用res[][]来存起点到各个点的路线数
第二种是对第一种的空间复杂度简化，因为每次每一行的值用一次就行了，所以用一个一位数组就好
第三种是利用排列组合的方法，写的时候res用double型，防止溢出，也要防止 1/i 时 i 太大得到0

class Solution {
// // method 1:
// // time: O(m*n)
// // space: O(n)
// public int uniquePaths(int m, int n) {
// int[][] res = new int[m][n];
// for (int j = 0; j < n; j++) res[0][j] = 1;
// for (int i = 1; i < m; i++) res[i][0] = 1;
// for (int i = 1; i < m; i++) {
// for (int j = 1; j < n; j++) {
// res[i][j] = res[i-1][j] + res[i][j-1];
// }
// }
// return res[m-1][n-1];
// }
// // method 2:
// // simplify space complexity since a lot of info are temporarily useful
// // time: O(m*n)
// // space: O(n)
// public int uniquePaths(int m, int n) {
// int[] res = new int[n];
// for (int j = 0; j < n; j++) res[j] = 1;
// for (int i = 1; i < m; i++) {
// for (int j = 1; j < n; j++) {
// res[j] = res[j] + res[j - 1];
// }
// }
// return res[n-1];
// }
// method 3:
// Use combination
// time: O(m), space: O(1)
// in total, we have m+n-2 step including m-1 down steps
// result is combination(m+n-2, m-1)
// for combination (count, k)
// count! / k!(count-k)! = (count - k + 1) * (count - k + 2) ......* count / k!
public int uniquePaths(int m, int n) {
int count = m + n - 2;
int k = m - 1;
// use double res to avoid overflow
double res = 1;
for (int i = 1; i <= k; i++) {
// put i at last instead of res / i * (count - k + i)
// since res / i may be 0 when i is too large
res = res * (count - k + i) / i;
}
return (int)res;
}
// // method 4
// // time limit exceed
// // time:O(2 * m * n)
// public int uniquePaths(int m, int n) {
// int numPath = 0;
// numPath = dpHelper(0, 0, m, n);
// return numPath;
// }
// private int dpHelper(int i, int j, int m, int n) {
// // base case
// int numPath = 0;
// if (i == m - 1 && j == n - 1) {
// return 1;
// }
// // recursion
// if (i < m - 1 && j < n - 1){
// numPath = numPath + dpHelper(i+1, j, m, n) + dpHelper(i, j+1, m, n);
// } else if (i >= m - 1 && j < n - 1) {
// numPath = numPath + dpHelper(i, j+1, m, n);
// } else if (i < m - 1 && j >= n - 1) {
// numPath = numPath + dpHelper(i+1, j, m, n);
// }
// return numPath;
// }
}

复制代码

AChris

02/12/2019 Day7

Leetcode 22. Generate Parentheses

解题思路：利用dfs解决的backtracking问题
time complexity不太确定
了解一下卡特兰数catalan number
https://en.wikipedia.org/wiki/Catalan_number

class Solution {
public List<String> generateParenthesis(int n) {
// root
// / \
// ( )
// / \ |
// ( ) terminates
// time: O(2^n)
// space: O(n)
List<String> res = new ArrayList<String> ();
if (n == 0) return res;
dfsHelper(res, "", n, n);
return res;
}
private void dfsHelper(List<String> res, String s, int left, int right) {
if (left > right) return;
if (left == 0 && right == 0) res.add(s);
if (left > 0) {
dfsHelper(res, s + "(", left - 1, right);
}
if (right > 0) {
dfsHelper(res, s+")", left, right - 1);
}
}
// private void dfsHelper(List<String> res, StringBuilder sb, int left, int right) {
// if (left > right) return;
// if (left == 0 && right == 0) res.add(sb.toString());
// if (left > 0) {
// sb.append("(");
// dfsHelper(res, sb, left - 1, right);
// // recover
// sb.deleteCharAt(sb.length() - 1);
// }
// if (right > 0) {
// sb.append(")");
// dfsHelper(res, sb, left, right - 1);
// // recover
// sb.deleteCharAt(sb.length() - 1);
// }
// }
}

复制代码

AChris

02/12/2019 Day7
LeetCode 39. Combination Sum

解题思路：用dfs进行深度优先搜索。
有一个技巧是，在传参数的时候加入start，之后每次递归下一层都从start开始，这样就保证了遍历所有情况的同时，得到的result cur不经过sort也是有序的。

本题的时间空间复杂度也有一点点tricky，具体分析在代码备注中。

用另外一种方法还写了一遍，但test case总是过不了，正在想原因中。

class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
// p = target / min(candidates[]) + 1
// n = size of candidates
// C(n,r) = n! / (r! * (n-r)!)
// time: O(C(n,1) + C(n,2) + ... + C(n, p))
// space: O(path + recursion stack) = O(p)
List<List<Integer>> res = new ArrayList<> ();
// corner case
if (candidates == null || candidates.length == 0 || target == 0) return res;
dfsHelper(res, candidates, target, new ArrayList<> (), 0);
return res;
}
private void dfsHelper(List<List<Integer>> res, int[] candidates, int target, List<Integer> cur, int start) {
// base case
if (target < 0) return;
if (target == 0) res.add(new ArrayList<>(cur));
// recursion
for (int i = start; i < candidates.length; i++) {
cur.add(candidates[i]);
dfsHelper(res, candidates, target - candidates[i], cur, i);
//recover
cur.remove(cur.size() - 1);
}
return;
}
// method2: why wrong?
// public List<List<Integer>> combinationSum(int[] candidates, int target) {
// List<List<Integer>> res = new ArrayList<> ();
// // corner case
// if (candidates == null || candidates.length == 0 || target == 0) return res;
// dfsHelper(res, candidates, target, new ArrayList<> (), 0);
// return res;
// }
// private void dfsHelper(List<List<Integer>> res, int[] candidates, int target, List<Integer> cur, int sum) {
// // base case
// if (sum == target) {
// Collections.sort(cur);
// System.out.println(target);
// if (!res.contains(cur)) {
// res.add(new ArrayList<> (cur));
// }
// return;
// } else if (sum > target) {
// return;
// }
// // recursion
// for (int i = 0; i < candidates.length; i++) {
// cur.add(candidates[i]);
// sum += candidates[i];
// System.out.println("****");
// System.out.println(cur);
// System.out.println(sum);
// dfsHelper(res, candidates, target, cur, sum);
// //recover
// sum = sum - candidates[i];
// cur.remove(cur.size() - 1);
// }
// return;
// }
}

复制代码

刷题skill+编程cultivation+记录

注册一亩三分地论坛，查看更多干货！

评分

相关帖子

浏览过的版块