Judging whether Sudoku is legal
Please determine if a Sudoku is valid.
The Sudoku may only be populated with partial numbers, where missing numbers are used. Said. Precautions
A valid Sudoku (partial padding only) is not necessarily solvable. We just need to make the padding space valid. Sample Example algorithm
public class Solution {/* * @param board:the Board * @return: Whether the Sudoku is valid */publ
IC Boolean Isvalidsudoku (char[][] board) {//write your code here boolean[] index = new boolean[9];
for (int j = 0; j<9; j + +) {Arrays.fill (index, false);
for (int i = 0; i<9; i++) {if (!checksudoku (index, Board[j][i]) return false;
}} for (int i = 0; i<9; i++) {Arrays.fill (index, false);
for (int j = 0; j<9; j + +) {if (!checksudoku (index, BOARD[I][J])) return false; }} for (int i=0, i<9; i=i+3) {for (int j = 0; j<9; j=j+3) {Arrays
. Fill (index, false); for (int k = 0; k<9; k++) {if (!checksudoku (index, board[i+k/3][j+k%3])) Retu
RN false; }
}
} return true;
} public boolean Checksudoku (boolean[] index, char num) {if (num = = '. ')
return true;
int _num = num-' 0 '; if (num>9| | num<0| |
Index[_num-1]) return false;
Index[_num-1] = true;
return true;
}
}
Flat List
Given a list, each feature in the list is either a list or an integer. Turn it into a simple list that contains only integers. Sample Example
Given [1,2,[1,2]], return [1,2,1,2].
Given [4,[3,[2,[1]]], return [4,3,2,1]. algorithm
Use recursion
/** *//This is the interface, allows for creating nested lists. *//should not implement it, or speculate on its implementation * public interface Nestedinteger {* *//@
Return true if this nestedinteger holds a single integer, *//rather than a nested list.
* Public boolean isinteger (); * *//@return The single integer which this nestedinteger holds, *//if it holds a single integer *//Ret
Urn NULL if this nestedinteger holds a nested list * public Integer getinteger (); * *//@return The nested list that this nestedinteger holds, *//if it holds a nested list *//Return Nu
ll if this nestedinteger holds a single integer * Public list<nestedinteger> getList (); * */public class Solution {//@param nestedlist a list of Nestedinteger//@return A list of integer pub Lic list<integer> Flatten (list<nestedinteger> nestedlist) {//Write your code here LIST<integer> list = new arraylist<integer> ();
for (Nestedinteger ele:nestedlist) {if (Ele.isinteger ()) List.add (Ele.getinteger ());
else List.addall (Flatten (Ele.getlist ()));
} return list;
}
}
Cloning binary Tree
Deep copy a binary tree.
Given a binary tree, return a sample of his clones
Given a two-pronged tree
1
/ \
2 3
/\
4 5
=
1
/ \
2 3
/\
4 5
algorithm
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* Public TreeNode left and right;
* Public TreeNode (int val) {
* this.val = val;
* this.left = This.right = null;
* }
*} * * Public
class Solution {
/**
* @param root:the root of binary tree
* @return Root of new Tree
* * Public
TreeNode clonetree (TreeNode root) {
//Write Your code here
if (root==null)
return null;
TreeNode _root = new TreeNode (root.val);
if (root.left!=null)
_root.left = Clonetree (root.left);
if (root.right!=null)
_root.right = Clonetree (root.right);
return _root;
}
}
ordinal arrangement
Arrange serial numbers
Gives an arrangement that does not contain a repeating number, which is the number of all the permutations of these numbers sorted by dictionary order. Where the numbering starts from 1. Sample Example
For example, the permutation [1,2,4] is the 1th permutation. algorithm
Forgive me for not understanding the meaning of the topic at first.
For a number 321, the three-digit permutation has 3. Species, knowing the first number, arranged with 2. Species, knowing the second number, arranged with 1. Know the third number, arranged with 0. ;
The number of the first bit less than the first digit is x, the second bit is less than the second digit has Y, the third position is 0, so the result of the last permutation is index = x*2!+y*1!.
public class Solution {
/* * @param a:an array of integers
* @return: A Long Integer */public
long p Ermutationindex (int[] A) {
//write your code here
long index = 0;
Long _middle = 0;
Long middle = 1;
Long num = 0;
for (int i=0;i<a.length;i++) {for
(int m=a.length-i-1;m>0;m--)
middle = middle*m;
for (int j=i+1;j<a.length;j++) {
if (A[i]>a[j])
num=num+1;
}
index = index + num*middle;
num = 0;
middle = 1;
_middle = 0;
}
return index+1;
}
}