[关闭]
@Yano 2015-12-30T11:25:46.000000Z 字数 14623 阅读 7002

LeetCode之Backtracing题目汇总

LeetCode

我的博客：http://blog.csdn.net/yano_nankai
LeetCode题解：https://github.com/LjyYano/LeetCode

LeetCode 题目汇总

LeetCode之Array题目汇总
LeetCode之Hash Table题目汇总
LeetCode之Linked List题目汇总
LeetCode之Math题目汇总
LeetCode之String题目汇总
LeetCode之Binary Search题目汇总
LeetCode之Divide and Conquer题目汇总
LeetCode之Dynamic Programming题目汇总
LeetCode之Backtracing题目汇总
LeetCode之Stack题目汇总
LeetCode之Sort题目汇总
LeetCode之Bit Manipulation题目汇总
LeetCode之Tree题目汇总
LeetCode之Depth-first Search题目汇总
LeetCode之Breadth-first Search题目汇总
LeetCode之Graph题目汇总
LeetCode之Trie题目汇总
LeetCode之Design题目汇总

文章目录：

Combination Sum

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

For example, given candidate set 2,3,6,7 and target 7, 
A solution set is: 
[7] 
[2, 2, 3]

参考：LeetCode 039 Combination Sum

使用递归，注意保存结果时，应该新建一个ArrayList：result.add(new ArrayList< Integer>(cur))。否则result会指向一直变化的cur。

  1.     public List<List<Integer>> combinationSum(int[] candidates, int target) {
  3.         if (candidates == null || candidates.length == 0) {
  4.             return new ArrayList<List<Integer>>();
  5.         }
  7.         List<List<Integer>> result = new ArrayList<List<Integer>>();
  8.         ArrayList<Integer> cur = new ArrayList<Integer>();
  10.         Arrays.sort(candidates);
  11.         dfs(0, target, result, cur, candidates);
  13.         return result;
  14.     }
  16.     private void dfs(int start, int target, List<List<Integer>> result,
  17.             ArrayList<Integer> cur, int[] candidates) {
  19.         if (target == 0) {
  20.             result.add(new ArrayList<Integer>(cur));
  21.             return;
  22.         }
  24.         for (int i = start; i < candidates.length; i++) {
  26.             // candidates[i] > target，则递归结束，后面不可能是解
  27.             if (candidates[i] > target) {
  28.                 return;
  29.             }
  31.             cur.add(candidates[i]);
  32.             dfs(i, target - candidates[i], result, cur, candidates);
  33.             cur.remove(cur.size() - 1);
  34.         }
  35.     }

Combination Sum II

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Note:

For example, given candidate set 10,1,2,7,6,1,5 and target 8, 
A solution set is: 
[1, 7] 
[1, 2, 5] 
[2, 6] 
[1, 1, 6]

参考：LeetCode 040 Combination Sum II

  1. Combination Sum每个元素可以使用多次，所以递归是dfs(i, target - candidates[i], result, cur, candidates);
  2. Combination Sum II每个元素只能使用一次，所以递归是dfs(i + 1, target - candidates[i], rt, cur, candidates);因为解可能重复，所以使用set，最后转成list。
  1.     public List<List<Integer>> combinationSum2(int[] candidates, int target) {
  3.         if (candidates == null || candidates.length == 0) {
  4.             return new ArrayList<List<Integer>>();
  5.         }
  7.         Set<List<Integer>> rt = new HashSet<List<Integer>>();
  8.         ArrayList<Integer> cur = new ArrayList<Integer>();
  10.         Arrays.sort(candidates);
  11.         dfs(0, target, rt, cur, candidates);
  13.         return new ArrayList<List<Integer>>(rt);
  14.     }
  16.     private void dfs(int start, int target, Set<List<Integer>> rt,
  17.             ArrayList<Integer> cur, int[] candidates) {
  19.         if (target == 0) {
  20.             rt.add(new ArrayList<Integer>(cur));
  21.             return;
  22.         }
  24.         for (int i = start; i < candidates.length; i++) {
  26.             // candidates[i] > target，则递归结束，后面不可能是解
  27.             if (candidates[i] > target) {
  28.                 return;
  29.             }
  31.             cur.add(candidates[i]);
  32.             dfs(i + 1, target - candidates[i], rt, cur, candidates);
  33.             cur.remove(cur.size() - 1);
  34.         }
  35.     }

Combination Sum III

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Ensure that numbers within the set are sorted in ascending order.

Example 1:

Input: k = 3, n = 7

Output:

  1. [[1,2,4]]

Example 2:

Input: k = 3, n = 9

Output:

  1. [[1,2,6], [1,3,5], [2,3,4]]

Credits: 
Special thanks to @mithmatt for adding this problem and creating all test cases.

参考：LeetCode 216 Combination Sum III

这次是指定了元素的个数，用一个变量记录即可。

  1.     public List<List<Integer>> combinationSum3(int k, int n) {
  3.         List<List<Integer>> rt = new ArrayList<List<Integer>>();
  5.         if (k < 1 || n < 1) {
  6.             return rt;
  7.         }
  9.         List<Integer> cur = new ArrayList<Integer>();
  10.         dfs(rt, cur, 0, k, n, 1);
  11.         return rt;
  12.     }
  14.     private void dfs(List<List<Integer>> rt, List<Integer> cur, int sum, int k,
  15.             int n, int level) {
  17.         if (sum == n && k == 0) {
  18.             rt.add(new ArrayList<Integer>(cur));
  19.             return;
  20.         } else if (sum > n || k <= 0) {
  21.             return;
  22.         }
  24.         for (int i = level; i <= 9; i++) {
  25.             cur.add(i);
  26.             dfs(rt, cur, sum + i, k - 1, n, i + 1);
  27.             cur.remove(cur.size() - 1);
  28.         }
  29.     }

Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

递归，选择数字k次，每次选择的数字都比前一个大。

  1.     int target;// 次数
  2.     Integer[] stack;// 存储每次排列
  3.     Integer[] nums;// 存储1~n
  5.     List<List<Integer>> rt;// 存储结果
  7.     public void search(int p) {
  9.         // 若长度为k，则stack是其中一个结果，保存结果
  10.         if (p == target) {
  11.             rt.add(new ArrayList<Integer>(Arrays.asList(stack)));
  12.             return;
  13.         }
  15.         // 对于nums(1~n)中的每个元素
  16.         for (Integer n : nums) {
  17.             // 找到nums中第一个比stack最后元素大的元素
  18.             if (p > 0 && n <= stack[p - 1]) {
  19.                 continue;
  20.             }
  22.             // 找到下一个元素，递归
  23.             stack[p] = n;
  24.             search(p + 1);
  25.         }
  26.     }
  28.     public List<List<Integer>> combine(int n, int k) {
  30.         target = k;
  31.         nums = new Integer[n];
  32.         stack = new Integer[k];
  34.         for (int i = 0; i < nums.length; i++) {
  35.             nums[i] = i + 1;
  36.         }
  38.         rt = new ArrayList<List<Integer>>();
  40.         search(0);
  42.         return rt;
  43.     }

Generate Parentheses

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

"((()))", "(()())", "(())()", "()(())", "()()()"

  1.     public List<String> generateParenthesis(int n) {
  3.         if (n <= 0) {
  4.             return new ArrayList<String>();
  5.         }
  7.         ArrayList<String> rt = new ArrayList<String>();
  8.         dfs(rt, "", n, n);
  9.         return rt;
  10.     }
  12.     void dfs(ArrayList<String> rt, String s, int left, int right) {
  14.         if (left > right) {
  15.             return;
  16.         }
  18.         if (left == 0 && right == 0) {
  19.             rt.add(s);
  20.         }
  22.         if (left > 0) {
  23.             dfs(rt, s + "(", left - 1, right);
  24.         }
  26.         if (right > 0) {
  27.             dfs(rt, s + ")", left, right - 1);
  28.         }
  29.     }

Gray Code

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

For example, given n = 2, return [0,1,3,2]. Its gray code sequence is:

00 - 0
01 - 1
11 - 3
10 - 2

Note:
For a given n, a gray code sequence is not uniquely defined.

For example, [0,2,3,1] is also a valid gray code sequence according to the above definition.

For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.

将数字i，转换成格雷码的公式是：

  1.     public List<Integer> grayCode(int n) {
  3.         List<Integer> rt = new ArrayList<Integer>();
  5.         if (n < 0) {
  6.             return rt;
  7.         }
  9.         for (int i = 0; i < Math.pow(2, n); i++) {
  10.             rt.add((i >> 1) ^ i);
  11.         }
  13.         return rt;
  14.     }

Letter Combinations of a Phone Number

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

Input: Digit string "23" 
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

Note: 
Although the above answer is in lexicographical order, your answer could be in any order you want.

  1.     static final char[][] CHAR_MAP = { {},// 0
  2.             {},// 1
  3.             { 'a', 'b', 'c' },// 2
  4.             { 'd', 'e', 'f' },// 3
  5.             { 'g', 'h', 'i' },// 4
  6.             { 'j', 'k', 'l' },// 5
  7.             { 'm', 'n', 'o' },// 6
  8.             { 'p', 'q', 'r', 's' },// 7
  9.             { 't', 'u', 'v' },// 8
  10.             { 'w', 'x', 'y', 'z' } // 9
  11.     };
  13.     List<String> result;
  14.     char[] stack;
  16.     public List<String> letterCombinations(String digits) {
  18.         if (digits == null || digits.length() == 0) {
  19.             return new ArrayList<String>();
  20.         }
  22.         result = new ArrayList<String>();
  23.         stack = new char[digits.length()];
  25.         dfs(digits.toCharArray(), 0);
  27.         return result;
  28.     }
  30.     private void dfs(char[] digits, int p) {
  32.         if (p == digits.length) {
  33.             result.add(new String(stack));
  34.         } else {
  36.             int num = digits[p] - '0';
  38.             for (char c : CHAR_MAP[num]) {
  39.                 stack[p] = c;
  40.                 dfs(digits, p + 1);
  41.             }
  42.         }
  43.     }

Palindrome Partitioning

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

For example, given s = "aab",
Return

[
    ["aa","b"],
    ["a","a","b"]
]

这个问题，明显可以分解成子问题的解。

分别求s[0..i]作为第一个字符串，如果是palindrome，则解为s[0..i] + partition(s[i+1…end])

  1.     public List<List<String>> partition(String s) {
  3.         List<List<String>> rt = new ArrayList<List<String>>();
  5.         if ("".equals(s)) {
  6.             return rt;
  7.         }
  9.         if (s.length() == 1) {
  10.             rt.add(Arrays.asList(s));
  11.             return rt;
  12.         }
  14.         for (int i = 0; i < s.length(); i++) {
  16.             String x = s.substring(0, i + 1);
  17.             List<List<String>> sub = new ArrayList<List<String>>();
  19.             if (isPal(x)) {
  20.                 sub = partition(s.substring(i + 1));
  22.                 if (sub.isEmpty()) {
  23.                     rt.add(Arrays.asList(x));
  24.                 } else {
  25.                     for (List<String> l : sub) {
  26.                         List<String> _l = new ArrayList<String>();
  27.                         _l.add(x);
  28.                         _l.addAll(l);
  29.                         rt.add(_l);
  30.                     }
  31.                 }
  32.             }
  34.         }
  36.         return rt;
  37.     }
  39.     static boolean isPal(String s) {
  41.         int st = 0, ed = s.length() - 1;
  43.         while (st < ed) {
  44.             if (s.charAt(st++) != s.charAt(ed--)) {
  45.                 return false;
  46.             }
  47.         }
  49.         return true;
  51.     }

Permutation Sequence

The set [1,2,3,…,_n_] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order, 
We get the following sequence (ie, for n = 3):

  1. "123"
  2. "132"
  3. "213"
  4. "231"
  5. "312"
  6. "321"

Given n and k, return the kth permutation sequence.

Note: Given n will be between 1 and 9 inclusive.

首先想到的是递归，按照顺序寻找字符串，然后计数，计算到第k个就是所求字符串。但是这样太慢，在n=9，k很大时会超时。

然后根据规律来，我们发现当n=3时排列是3! = 6组，其中以“1”，“2”，“3”开头的分别有2组。

以“1”开头的排列中，第2位是“2”、“3”的分别有1组。

如果n=4呢？会发现以1开头的排列有6组，其中以2为第2位的排列有2组。

总结规律：第一位数字在数组中的序号肯定是：

k1/(n−1)!

k1=k

第二位数字在剩余数组中的序号肯定是：

k2/(n−2)!

k2=k1

  1.     public String getPermutation(int n, int k) {
  3.         if (n <= 0 || k <= 0) {
  4.             return "";
  5.         }
  7.         String rt = "";
  9.         List<Integer> list = new ArrayList<Integer>();
  10.         int fact = 1;
  12.         for (int i = 1; i <= n; i++) {
  13.             list.add(i);
  14.             fact *= i;
  15.         }
  17.         k--;
  19.         for (int i = 0; i < n; i++) {
  20.             fact /= (n - i);
  21.             int index = k / fact;
  22.             rt += list.get(index);
  23.             list.remove(index);
  24.             k %= fact;
  25.         }
  27.         return rt;
  28.     }

Permutations

Given a collection of distinct numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:
[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

这里写图片描述

  1.     public List<List<Integer>> permute(int[] nums) {
  3.         if (nums == null || nums.length == 0) {
  4.             return new ArrayList<List<Integer>>();
  5.         }
  7.         ArrayList<List<Integer>> rt = new ArrayList<List<Integer>>();
  9.         if (nums.length == 1) {
  10.             rt.add(new ArrayList<Integer>(Arrays.asList(nums[0])));
  11.         } else {
  13.             for (int i = 0; i < nums.length; i++) {
  14.                 for (List<Integer> l : permute(resetof(nums, i))) {
  15.                     l.add(nums[i]);
  16.                     rt.add(l);
  17.                 }
  18.             }
  19.         }
  21.         return rt;
  22.     }
  24.     private int[] resetof(int[] nums, int index) {
  26.         int[] rt = new int[nums.length - 1];
  28.         int s = 0;
  29.         for (int i = 0; i < nums.length; i++) {
  30.             if (i != index) {
  31.                 rt[s++] = nums[i];
  32.             }
  33.         }
  35.         return rt;
  36.     }

Permutations II

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

For example,
[1,1,2] have the following unique permutations:
[1,1,2], [1,2,1], and [2,1,1].

使用LeetCode 046 Permutations的方法，只是把rt变成Set，最后转成List，但是会超时。

参考自：http://leetcode.tgic.me/permutations-ii/index.html

  1.     void swap(int x[], int a, int b) {
  2.         int t = x[a];
  3.         x[a] = x[b];
  4.         x[b] = t;
  5.     }
  7.     public boolean nextPermutation(int[] num) {
  9.         if (num.length < 2)
  10.             return false;
  12.         int p = -1;
  14.         for (int i = num.length - 1; i > 0; i--) {
  15.             if (num[i] > num[i - 1]) {
  16.                 p = i - 1;
  17.                 break;
  18.             }
  19.         }
  21.         if (p == -1) {
  22.             Arrays.sort(num);
  23.             return false;
  24.         }
  26.         int c = -1;
  27.         for (int i = num.length - 1; i >= 0; i--) {
  28.             if (num[i] > num[p]) {
  29.                 c = i;
  30.                 break;
  31.             }
  32.         }
  34.         swap(num, p, c);
  35.         Arrays.sort(num, p + 1, num.length);
  37.         return true;
  38.     }
  40.     List<Integer> asList(int[] num) {
  41.         ArrayList<Integer> l = new ArrayList<Integer>(num.length);
  42.         for (int i = 0; i < num.length; i++)
  43.             l.add(num[i]);
  45.         return l;
  46.     }
  48.     public List<List<Integer>> permuteUnique(int[] num) {
  49.         Arrays.sort(num);
  51.         ArrayList<List<Integer>> found = new ArrayList<List<Integer>>();
  52.         found.add(asList(num));
  54.         while (nextPermutation(num)) {
  55.             found.add(asList(num));
  56.         }
  58.         return found;
  59.     }

Restore IP Addresses

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

For example: 
Given "25525511135",

return ["255.255.11.135", "255.255.111.35"]. (Order does not matter)

  1.     List<String> rt = new ArrayList<String>();
  2.     String[] stack = new String[4];
  4.     public List<String> restoreIpAddresses(String s) {
  6.         if (s == null || s.length() == 0) {
  7.             return new ArrayList<String>();
  8.         }
  9.         dfs(s, 0, 0);
  10.         return rt;
  11.     }
  13.     /**
  14.      * 
  15.      * @param s
  16.      * @param p
  17.      *            :指针
  18.      * @param pstack
  19.      *            :stack的下标
  20.      */
  21.     public void dfs(String s, int p, int pstack) {
  23.         if (pstack == 4) {
  25.             // 如果stack长度为4，且s的字符全部用上
  26.             // 则stack[0...3]存了一个结果
  27.             if (p >= s.length()) {
  28.                 String ip = String.join(".", stack);
  29.                 rt.add(ip);
  30.             }
  31.             return;
  32.         }
  34.         // 获取1~3个字符
  35.         for (int i = 1; i <= 3; i++) {
  37.             // 如果超过字符串长度，返回
  38.             if (p + i > s.length()) {
  39.                 return;
  40.             }
  42.             // 若选取的第一个字符是0，则停止选取
  43.             if (i > 1 && s.charAt(p) == '0') {
  44.                 continue;
  45.             }
  47.             String number = s.substring(p, p + i);
  49.             // 如果number<=255，递归
  50.             if (Integer.parseInt(number) <= 255) {
  51.                 stack[pstack] = number;
  52.                 dfs(s, p + i, pstack + 1);
  53.             }
  54.         }
  55.     }

Subsets

Given a set of distinct integers, nums, return all possible subsets.

Note:

For example, 
If nums = [1,2,3], a solution is:

  1. [
  2.   [3],
  3.   [1],
  4.   [2],
  5.   [1,2,3],
  6.   [1,3],
  7.   [2,3],
  8.   [1,2],
  9.   []
  10. ]
  1.     int target;// 次数
  2.     Integer[] stack;// 存储每次排列
  4.     List<List<Integer>> rt;// 存储结果
  6.     public void search(int p, int[] nums) {
  8.         // 若长度为k，则stack是其中一个结果，保存结果
  9.         if (p == target) {
  10.             rt.add(new ArrayList<Integer>(Arrays.asList(stack)));
  11.             return;
  12.         }
  14.         for (int i = 0; i < nums.length; i++) {
  16.             if (p > 0 && nums[i] <= stack[p - 1]) {
  17.                 continue;
  18.             }
  20.             stack[p] = nums[i];
  21.             search(p + 1, nums);
  22.         }
  23.     }
  25.     public List<List<Integer>> subsets(int[] nums) {
  27.         Arrays.sort(nums);
  29.         rt = new ArrayList<List<Integer>>();
  31.         // 分别做0~num.length长度的组合
  32.         for (int i = 0; i <= nums.length; i++) {
  33.             target = i;
  34.             stack = new Integer[i];
  35.             search(0, nums);
  36.         }
  38.         return rt;
  39.     }

Subsets II

Given a collection of integers that might contain duplicates, nums, return all possible subsets.

Note:

For example, 
If nums = [1,2,2], a solution is:

  1. [
  2.   [2],
  3.   [1],
  4.   [1,2,2],
  5.   [2,2],
  6.   [1,2],
  7.   []
  8. ]

使用二进制，不需要递归。对于二进制中的每一位，0表示不选择，1表示选择。则有2^n种情况。

使用HashSet，能够直接过滤重复情况（先对数组排序，题目中也要求每个list非降序排列）。

  1.     public List<List<Integer>> subsetsWithDup(int[] nums) {
  3.         if (nums == null) {
  4.             return null;
  5.         }
  7.         if (nums.length == 0) {
  8.             return new ArrayList<List<Integer>>();
  9.         }
  11.         Set<List<Integer>> set = new HashSet<List<Integer>>();
  13.         // 题目中要求每个list是非降序，所以要先从小到大排序
  14.         Arrays.sort(nums);
  16.         // 对于n位，有2^n种情况
  17.         for (int i = 0; i < Math.pow(2, nums.length); i++) {
  19.             List<Integer> list = new ArrayList<Integer>();
  20.             int tmp = i;
  22.             // 对于每种情况，分别求得二进制中1的个数
  23.             // 0代表不选择，1代表选择
  24.             for (int j = 0; j < nums.length; j++) {
  25.                 int bit = tmp & 1;
  26.                 tmp >>= 1;
  27.                 if (bit == 1) {
  28.                     list.add(nums[j]);
  29.                 }
  30.             }
  31.             set.add(list);
  32.         }
  34.         return new ArrayList<List<Integer>>(set);
  35.     }

Word Search

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

For example,
Given board =

[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

word = "ABCCED", -> returns true,
word = "SEE", -> returns true,
word = "ABCB", -> returns false.

典型问题，回溯法（深度优先搜索DFS），暴力破解。以每一个字符为起点，分别判断上下左右四个字符是否符合条件。符合条件则一直向下寻找，否则回退。

  1.     public boolean exist(char[][] board, String word) {
  3.         if (board == null || board[0].length == 0 || board.length == 0
  4.                 || word == null) {
  5.             return false;
  6.         }
  8.         int rows = board.length;
  9.         int cols = board[0].length;
  10.         boolean[] visited = new boolean[rows * cols];
  12.         int pathLength = 0;
  13.         for (int row = 0; row < rows; row++) {
  14.             for (int col = 0; col < cols; col++) {
  16.                 // 以row,col为开始，能够遍历得到结果
  17.                 if (dfs(board, rows, cols, row, col, word, pathLength, visited)) {
  18.                     return true;
  19.                 }
  20.             }
  21.         }
  23.         return false;
  24.     }
  26.     public boolean dfs(char[][] board, int rows, int cols, int row, int col,
  27.             String word, int pathLength, boolean[] visited) {
  29.         // 如果pathLength的长度已经是查找字串的长度，则已经找到
  30.         if (pathLength == word.length()) {
  31.             return true;
  32.         }
  34.         boolean hasPath = false;
  36.         // 符合条件的情况下：
  37.         // 1. 行、列均在矩阵范围内
  38.         // 2. board[row][col]是所要找的字符
  39.         // 3. board[row][col]没有遍历过
  40.         if (row >= 0 && row < rows && col >= 0 && col < cols
  41.                 && board[row][col] == word.charAt(pathLength)
  42.                 && !visited[row * cols + col]) {
  44.             pathLength++;
  45.             visited[row * cols + col] = true;
  47.             hasPath = dfs(board, rows, cols, row, col - 1, word, pathLength,
  48.                     visited)
  49.                     || dfs(board, rows, cols, row - 1, col, word, pathLength,
  50.                             visited)
  51.                     || dfs(board, rows, cols, row, col + 1, word, pathLength,
  52.                             visited)
  53.                     || dfs(board, rows, cols, row + 1, col, word, pathLength,
  54.                             visited);
  56.             // 若board[row][col]的前后左右没有满足条件的字符，则回退
  57.             if (!hasPath) {
  58.                 pathLength--;
  59.                 visited[row * cols + col] = false;
  60.             }
  61.         }
  63.         return hasPath;
  64.     }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注