LeetCode_刷题第一周

寻找两个有序数组的中位数
寻找最长回文子串
Z变换
水池问题
三数之和
删除链表倒数第n个节点
括号匹配问题
交换链表的节点
查找元素在排序数组中的开始位置和结束位置
实现子串的查找
下一个排列
数独问题

寻找两个有序数组的中位数

思想：

  1. 将两个数组看为一个数组，找中位数就等于找总排序完的len/2位置，或者中间两数的平均数。
  2. 两个序列拿出前 k/2 舍去，这部分是一定不可能的。剩下二序列头元素更小的哪一个就是要求中位数
  3. 但是存在一个数组的长度不够k/2的情况，因此如果一个数组长度len1 < k/2 ,找 总数组k位置的问题，减小为找舍去更小数组所有元素后，第 k - len1 长度的元素 的问题。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Solution {
    //solution : 分别查找到k/2处，判断该位置的两个列表元素的大小，舍弃更小的一方，因为在该位置和它以前一定不是中间位置
    //方法本质：分治法
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        //解决两个数字之和有奇数和偶数的差别
        int len1 = nums1.length;
        int len2 = nums2.length;
        int llen = (len1+len2+1)/2;
        int rlen = (len1+len2+2)/2;
         //如果长度之和是奇数，计算两次同样的值
        return (getKth(nums1,0,len1-1,nums2,0,len2-1,llen) + getKth(nums1,0,len1-1,nums2,0,len2-1,rlen))*0.5;
    }
    //得到第K大的元素
    private double getKth(int[] nums1,int start1,int end1,int[] nums2,int start2,int end2,int k){
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;
        //交换顺序，保证nums1是最短的，方便判断，放置溢出
        if(len1 > len2) return getKth(nums2,start2,end2,nums1,start1,end1,k);
        if(len1 == 0) return nums2[start2 + k -1];
        if(k == 1) return Math.min(nums1[start1],nums2[start2]);

        int pos1 = start1 + Math.min(len1,k/2)-1;
        int pos2 = start2 + Math.min(len2,k/2)-1;
        if(nums1[pos1]<=nums2[pos2]){
            return getKth(nums1,pos1+1,end1,nums2,start2,end2,k-(pos1 - start1 +1));
        }else{
            return getKth(nums1,start1,end1,nums2,pos2+1,end2,k-(pos2 - start2 +1));
        }
    }
}

寻找最长回文子串

思想：

  1. 关键在于回文串长度可能是奇数 也可能是偶数
  2. 将序列划分成 2N-1 个比较点（两字符的间隙也视为开始判断的起点）
  3. 每次都从一个切片点开始扩展，遇到不满足回文的子序列时，下次就从该位置开始判断。
  4. 时间复杂度为O（n）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Solution {
    public String longestPalindrome(String s) {
       if(s.length()<=1) return s;
       int maxLen = 0;
       int posStart = 0;

       for(int i = 0 ;i < s.length(); i++){
           int len1 = centerExpand(s,i,i);
           int len2 = centerExpand(s,i,i+1);
           if(maxLen < Math.max(len1,len2)){
               maxLen = Math.max(len1,len2);
               if(maxLen%2 != 0) posStart = i - maxLen/2;
               else posStart = i - (maxLen - 1)/2;
           }
       }

       return s.substring(posStart,posStart+maxLen);
    }
    private int centerExpand(String s,int left,int right){
        while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
            left --;
            right ++;
        }
        return right - left -1 ;
    }
}

Z 变换

题干：

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：

L C I R
E T O E S I I G
E D H N
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：”LCIRETOESIIGEDHN”。

来源：力扣（LeetCode）

关键：

  1. 要找到 Z 字字符放置位置的关系
  2. 总间隔为gap = N+N-2
  3. 每一行，一个Z的字符间隙之和都是gap，gap1=gap-2i，gap2=2i，gap2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    public String convert(String s, int numRows) {
        if(numRows == 1) return s;
        StringBuffer strbuff = new StringBuffer("");
        int gap = numRows + numRows -2 ;
        for(int i =0; i < numRows; i++){
            int[] dist = new int[2];
            dist[1] = gap - 2*i;
            dist[0] = 2*i;
            if(i==0 || i== numRows-1){
                dist[0] = gap;
                dist[1] = gap;
            }
            int num = 0;//表示奇偶次数
            for(int j = i; j < s.length(); j+=dist[num%2]){
                strbuff.append(s.charAt(j));
                num++;
            }
            
        }
        return strbuff.toString();
    }
}

水池问题

题干：

给定 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

来源：力扣（LeetCode）

思想——典型的动态规划

随着宽度减小，只有高度更小的柱体高度变高才会有可能让体积变大

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
     public int maxArea(int[] height) {
        int len = height.length;
        int maxC = 0;
        int left = 0, right = height.length -1;
        while(left < right){
            maxC = Math.max(maxC , (right - left)*Math.min(height[left] , height[right]));
            if(height[right]>=height[left]){
                left++;
            }else{
                right--;
            }

        }
        return maxC;
    }
}

三数之和

题干：

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

来源：力扣（LeetCode）

思想：降维，让三维变为二维

排序
确定一个数（非负数）让另外连个比它大的数之和等于它的相反数（避免重复）
三数之和最接近问题：就是三数之和变体，多记录一个差值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //先将数组排序
        Arrays.sort(nums);
        //找到正负交界
        int splitDis =0;
        while(splitDis<nums.length && nums[splitDis++]<=0);

        ArrayList<List<Integer>> ls = new ArrayList<>();
        //选择一个当作标准
        for(int i = 0;i<Math.min(splitDis-1, nums.length-2);i++){
            //避免重复
            if(i==0 ||i>0 && nums[i] !=nums[i-1]){
                int low = i + 1,high = nums.length - 1,sum  = -1*nums[i];
                while(low < high){
                    if((nums[low]+nums[high])==sum){
                        ls.add(Arrays.asList(nums[i],nums[low],nums[high]));
                        while(low<high && nums[low] == nums[low+1]) low++;
                        while(low<high && nums[high] == nums[high-1]) high--;
                        low++;
                        high--;
                    }else if((nums[low]+nums[high])< sum){
                        while(low<high && nums[low]==nums[low+1]) low++;
                        low++;
                    }else{
                        while(low<high && nums[high] == nums[high-1]) high--;
                        high--;
                    }
                }
            }
        }
        return ls;
    }
    
}

删除链表倒数第n个节点

题干：

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

来源：力扣（LeetCode）

思想

遍历一遍，增加一个记录gap的量，当未达到n删除指针不动,gap加一
gap等于n时候，删除指针也不断移动，gap不变。
到最后，用删除指针删除节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    //一遍扫描
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null) return null;
        int gap = 0;
        ListNode general = head;
        ListNode soldier = head;
        //找到 倒数n+1 个节点
        while(soldier.next != null){
            if(gap < n){
                gap++;
                soldier = soldier.next;
            }else{
                soldier =soldier.next;
                general = general.next;
            }
        }
        if(gap == n-1){
            head = head.next;
        }else{
            general.next = general.next.next;
        }
        return head;
    }
}

括号匹配问题

模式匹配的一种
包含多种题型
本质都是动态规划或者加上栈的运用

有效括号匹配

问题：

给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class Solution {
   
    public boolean isValid(String s) {
        if(s.length()==0) return true;
        if(s.length() % 2 == 1) return false;
        Stack<Character> stack = new Stack<Character>();
        int p = 0;
        while(p<s.length()){
            char c = s.charAt(p);
            if(c=='('|| c=='{' || c =='['){
                stack.push(c);
            }else{
                if(stack.empty())   return false;
                char b = stack.pop();
                if(!isMatch(b,c)){
                    return false;
                }
            }
            p++;
        }
        
        return stack.empty();
    }
    private boolean isMatch(char a , char b){
        boolean flag = false;
        switch(a){
            case '(':
                if(b==')') flag = true;
                break;
            case '{':
                if(b=='}') flag = true;
                break;
            case '[':
                if(b ==']') flag = true;
                break;
            default:
                break;
        }
        return flag;
    }
}

括号的生成

本质：DFS

题目：

给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Solution {
    public List<String> lstr = new ArrayList<>();
    //用len来代替栈的功能
    public int len = 0;
    //本质是找出出栈的所有组合,用DFS
    public List<String> generateParenthesis(int n) {
        if(n == 0) return lstr;
        StringBuffer str = new StringBuffer("");
        DFS(str,n,n);
        return lstr;
    }
    //left = 剩下左括号的数目，right = 剩下右括号多少
    public void DFS(StringBuffer strBuff,int left,int right){
        if(left == 0 && right == 0){
            lstr.add(strBuff.toString());
            return;
        }
        if(left != 0){
            if(left > right) return;
            len++;
            strBuff.append("(");
            DFS(strBuff,left -1,right);
            strBuff.deleteCharAt(strBuff.length()-1);
            len--;
           
        }
        if(right != 0){
            if(len == 0) return;
            len--;
            strBuff.append(")");
            DFS (strBuff,left,right -1);
            strBuff.deleteCharAt(strBuff.length()-1);
           len++;
        }
        return ;

    }
}

最长有效括号

给定一个只包含 ‘(‘ 和 ‘)’ 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: “(()”
输出: 2
解释: 最长有效括号子串为 “()”
示例 2:

输入: “)()())”
输出: 4
解释: 最长有效括号子串为 “()()”

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Solution {
    //类似于KMP模式匹配的next数组的构建
    public int longestValidParentheses(String s) {
        if(s.length() <= 1) return 0;
        int maxNum = 0; 
        int[] next = new int[s.length()];
        int p = -1 ,left =0;
        for(int i = 0 ;i< s.length();i++){
            if(s.charAt(i) == '('){
                left++;
                next[i] = p ;
                p = i;
            }else{
                next[i] = i;
                if(left == 0){
                    p = i;
                }else{
                    maxNum = Math.max(maxNum,i - next[p]);
                    p = next[p];
                    left--;
                }
            }
        }
        return maxNum;
        
    }
}

合并K个有序链表

题目：

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    //类似于2路归并排序,时间超出限制
    /*
    public ListNode mergeKLists(ListNode[] lists) {
        int len = lists.length;
        while(len > 1){
            int p = 0;
            for(int i = 0;i+1< len ;i+=2){
                lists[p] = mergeTwo(lists[i],lists[i+1]);
            }
            len = (len + 1)/2 ;
        }
        return lists[0];


    }
    public ListNode mergeTwo(ListNode l1,ListNode l2){
            ListNode root = new ListNode(-1);
            ListNode worker = root;
            while(l1!=null && l2 != null){
                if(l1.val <= l2.val){
                    worker.next = l1;
                    l1 = l1.next;
                }else{
                    worker.next = l2;
                    l2 = l2.next;
                }
                worker = worker.next;
            }
            if(l1 != null) worker.next = l1;
            if(l2 !=null) worker.next = l2;
            return root.next;
    }
    */
     public ListNode mergeKLists(ListNode[] lists) {
         return mergeAll(lists);
     }
    //时间复杂度为n的算法
    public ListNode mergeAll(ListNode[] lists){
        int len = lists.length;
        ListNode root = new ListNode(-1);
        ListNode worker = root;
        int cursor = 0;
        while(cursor<len){
            if(lists[cursor] == null){
                lists[cursor] = lists[--len];
            }else{
                cursor++;
            }
        }
        if(len == 0) return null;
        
        while(len > 1){
            int key = findMin(lists,len);
            worker.next = lists[key];
            worker = worker.next;
            lists[key] = lists[key].next;
            if(lists[key] == null) {
                ListNode tmp = lists[key];
                lists[key] = lists[len-1];
                lists[len-1] = tmp;
                len--;
            }
        }
        worker.next = lists[0];
        return root.next;

    }
    public int findMin(ListNode[] lists,int len){
        int minKey = 0;
        int minVal = 100;
        for(int i =0 ;i< len ;i++){
            if(lists[i].val < minVal){
                minKey = i;
                minVal = lists[i].val;
            }
        }
        return minKey;
    }
}

交换链表的节点

利用O（N）的时间完成任务

两两交换链表中的节点

题干:

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null || head.next == null) return head;
        ListNode root = new ListNode(-1);
        root.next = head;
        ListNode left = root, right = head;
        while(right!= null && right.next != null){
            right= right.next;
            left.next.next = right.next;
            right.next = left.next;
            left.next = right;
            left = right.next;
            right = left.next;
        }
        return root.next;
    }
}

K 组一个翻转

题干：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public ListNode reverseKGroup(ListNode head, int k) {
        ListNode root = new ListNode(0),post , pre = root;
        root.next = head;
        int length = 0;
        while(head!= null){
            length++;
            head = head.next;
        }
        head = root.next;
        for(int i =0;i<length/k;i++){
            for(int j = 0; j< k-1 ;j++){ 
                post = head.next;
                head.next = post.next;
                post.next = pre.next;
                pre.next = post;
            }
            pre = head;
            head = pre.next;
        }
        return root.next;
    }

实现子串的查找

题干：

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll”
输出: 2
示例 2:

输入: haystack = “aaaaa”, needle = “bba”
输出: -1
说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Solution {

    public int strStr(String haystack, String needle) {
        return KMPMatch(haystack,needle);
    }
    //KMP 方法
    public int KMPMatch(String haystack, String needle){
        if(needle.length() == 0) return 0;
        int[] next = getNext(needle);
        int p = 0;  //记录字串待匹配的配置
        for(int i = 0;i<haystack.length();i++){
                while(p!=0 && haystack.charAt(i) != needle.charAt(p)){
                    p = next[p -1];
                }
                if (haystack.charAt(i) == needle.charAt(p)){
                    p++;
                }
           if(p == needle.length())   return i - p + 1 ;
            
        }
        return -1;
    }
    public int[] getNext(String needle){
        int [] next = new int[needle.length()];
        next[0] = 0;            //首字母匹配长度一定为0
        int record = 0;  
        for(int i = 1;i< needle.length();i++){
            while(record !=0 && needle.charAt(i) != needle.charAt(record)){
                record = next[record -1];
            }
            
            if(needle.charAt(i) == needle.charAt(record)){
                record++;
            }
            next[i] = record ; 
        }
        return next;
    }
}

下一个排列

题干：

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Solution {
    public void nextPermutation(int[] nums) {
        if(nums.length <= 1){
            return;
        }
        for(int p = nums.length -2;p>=0;p--){
            if(nums[p]<nums[p+1]){
                reverse(nums,p+1,nums.length-1);
                int tmp = nums[p],i=1;
                for(;p+i < nums.length && nums[p+i] <= nums[p] ;i++) ;
                nums[p] = nums[p + i];
                nums[p+i] = tmp;
                return;
            }
        }
        reverse(nums,0,nums.length-1);
        return;

    }
    public void reverse(int[] nums,int i,int j){
        while(i< j){
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
            i++;
            j--;
        }
    }
    
}

查找元素在排序数组中的开始位置和结束位置

题干：

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] pos = {Integer.MAX_VALUE,-1};
        int low = 0, high = nums.length -1;
        //先找开始位置
        while(low<=high){
            int mid = (low+high)/2;
            if(nums[mid] == target){
                pos[0] = mid;
                high = mid -1; //继续缩小左端点范围
            }else if(nums[mid] > target){
                high = mid -1;
            }else{
                low = mid + 1;
            }
        }
        if(pos[0] == Integer.MAX_VALUE){
            pos[0] = -1;
            return pos;
        }
        high = nums.length -1;
        low = pos[0]+1;
        pos[1] = pos[0];
        //找结束位置
        while(low<=high){
            int mid = (low+high)/2;
            if(nums[mid]==target){
                pos[1] = mid;
                low = mid +1; //继续缩小右端点范围
            }else if(nums[mid] < target){
                low = mid +1;
            }else{
                high = mid -1;
            }
        }
        return pos;
    }
}

数独问题

有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

来源：力扣（LeetCode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    //建立3 个 set[9] 分别放入每一行，列，3*3中出现的元素
    public boolean isValidSudoku(char[][] board) {
        Set[] row = new HashSet[board.length];
        Set[] colum = new HashSet[board.length];
        Set[] minBoard = new HashSet[board.length];
        for(int i = 0;i<board.length;i++){
            row[i] = new HashSet<Character>();
            colum[i] = new HashSet<Character>();
            minBoard[i] = new HashSet<Character>();
        }
        for(int i =0;i<board.length;i++){
            for(int j =0;j<board.length;j++){
                if(board[i][j] != '.'){
                    if(!row[i].add(board[i][j])) return false;
                    if(!colum[j].add(board[i][j])) return false;
                    if(!minBoard[(i/3)*3 + j/3].add(board[i][j])) return false;
                }
            }
        }
        return true;
    }
}
赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

Related Issues not found

Please contact @Ark-xkz to initialize the comment

Error: Comments Not Initialized
Styling with Markdown is supported
Powered by Gitment