LintCode算法题解——判断数独是否合法、平面列表、克隆二叉树、序列排号

判断数独是否合法

请判定一个数独是否有效。

该数独可能只填充了部分数字，其中缺少的数字用 . 表示。

注意事项

一个合法的数独（仅部分填充）并不一定是可解的。我们仅需使填充的空格有效即可。

样例

算法

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;
}

}