判断数独是否合法
请判定一个数独是否有效。
该数独可能只填充了部分数字，其中缺少的数字用 . 表示。
注意事项
一个合法的数独（仅部分填充）并不一定是可解的。我们仅需使填充的空格有效即可。
样例
算法
public class Solution {
/*
* @param board: the board
* @return: whether the Sudoku is valid
*/
public 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]))
return 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;
}
}
平面列表
给定一个列表，该列表中的每个要素要么是个列表，要么是整数。将其变成一个只包含整数的简单列表。
样例
给定 [1,2,[1,2]]，返回 [1,2,1,2]。
给定 [4,[3,[2,[1]]]]，返回 [4,3,2,1]。
算法
使用递归
/**
* // This is the interface that allows for creating nested lists.
* // You should not implement it, or speculate about 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 that this NestedInteger holds,
* // if it holds a single integer
* // Return 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 null 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
public 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;
}
}
克隆二叉树
深度复制一个二叉树。
给定一个二叉树，返回一个他的 克隆品
样例
给定一颗二叉树
1
/ \
2 3
/ \
4 5
=>
1
/ \
2 3
/ \
4 5
算法
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, 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;
}
}
序号排列
排列序号
给出一个不含重复数字的排列，求这些数字的所有排列按字典序排序后该排列的编号。其中，编号从1开始。
样例
例如，排列[1,2,4]是第1个排列。
算法
原谅我一开始题目意思都没有理解。
对于一个数321，三个数的排列有3！种，知道第一个数，排列有2！种，知道第二个数，排列有1！知道第三个数，排列有0！；
第一位后小于第一位的数为x，第二位后小于第二位的数有y，第三位后为0，所以最后排列序号的结果为index = x*2!+y*1!。
public class Solution {
/*
* @param A: An array of integers
* @return: A long integer
*/
public long permutationIndex(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;
}
}
