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

}