package acmcode;


/**
 * @author Leon.Chen
 *
 */
public class IntervalTree {


    /**
     * 红
     */
    private static final String RED = "red";

    /**
     * 黑
     */
    private static final String BLACK = "black";

    /**
     * 根节点
     */
    private RBNode root;

    /**
     * 左旋转
     * 
     * @param x
     */
    private void leftRotate(RBNode x) {
        RBNode y = x.right;
        x.right = y.left;
        y.left.parent = x;
        x.setMinPointAndMaxPoint();
        y.parent = x.parent;
        if (x.parent == null) {
            root = y;
        } else {
            if (x == x.parent.left) {
                x.parent.left = y;
            } else {
                x.parent.right = y;
            }
        }
        y.left = x;
        x.parent = y;
        y.setMinPointAndMaxPoint();
    }

    /**
     * 右旋转
     * 
     * @param y
     */
    private void rightRotate(RBNode y) {
        RBNode x = y.left;
        y.left = x.right;
        x.right.parent = y;
        y.setMinPointAndMaxPoint();
        x.parent = y.parent;
        if (y.parent == null) {
            root = x;
        } else {
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }
        x.right = y;
        y.parent = x;
        x.setMinPointAndMaxPoint();
    }

    /**
     * 红黑树插入方法
     * 
     * @param z
     */
    public void RBInsert(RBNode z) {
        if (root == null) {
            root = z;
            root.color = BLACK;
            root.setMinPointAndMaxPoint(z);
        } else {
            RBNode x = root;
            RBNode y = null;
            while (isNotNilNode(x)) {
                y = x;
                x.setMinPointAndMaxPoint(z);
                if (z.value.compareTo(x.value) < 0) {
                    x = x.left;
                } else {
                    x = x.right;
                }
            }
            if (z.value.compareTo(y.value) < 0) {
                y.left = z;
            } else {
                y.right = z;
            }
            z.color = RED;
            z.setMinPointAndMaxPoint(z);
            z.parent = y;
        }
        z.left = new RBNode(BLACK);
        z.right = new RBNode(BLACK);
        RBInsertFixUp(z);
    }

    /**
     * 解决插入冲突
     * 
     * @param z
     */
    private void RBInsertFixUp(RBNode z) {
        while (z.parent != null && z.parent.color.equals(RED)) {
            if (z.parent == z.parent.parent.left) {
                RBNode y = z.parent.parent.right;
                if (y.color.equals(RED)) {
                    z.parent.color = BLACK;
                    y.color = BLACK;
                    z.parent.parent.color = RED;
                    z = z.parent.parent;
                } else if (z == z.parent.right) {
                    z = z.parent;
                    leftRotate(z);
                } else if (z == z.parent.left) {
                    z.parent.color = BLACK;
                    z.parent.parent.color = RED;
                    rightRotate(z.parent.parent);
                }
            } else {
                RBNode y = z.parent.parent.left;
                if (y.color.equals(RED)) {
                    z.parent.color = BLACK;
                    y.color = BLACK;
                    z.parent.parent.color = RED;
                    z = z.parent.parent;
                } else if (z == z.parent.left) {
                    z = z.parent;
                    rightRotate(z);
                } else if (z == z.parent.right) {
                    z.parent.color = BLACK;
                    z.parent.parent.color = RED;
                    leftRotate(z.parent.parent);
                }
            }
        }
        root.color = BLACK;
    }

    /**
     * @param deleteNode
     */
    public void RBDelete(RBNode deleteNode) {
        RBNode y = null;
        RBNode z = serach(deleteNode.value);
        if (isNilNode(z.left) || isNilNode(z.right)) {
            y = z;
        } else {
            y = treeSuccessor(z);
        }
        RBNode x = null;
        if (isNotNilNode(y.left)) {
            x = y.left;
        } else {
            x = y.right;
        }
        x.parent = y.parent;
        if (isNilNode(y.parent)) {
            root = x;
        } else {
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }
        if (y != z) {
            z.value = y.value;
        }
        if (y.color.equals(BLACK)) {
            RBDeleteFixUp(x);
        }
    }

    /**
     * @param x
     */
    private void RBDeleteFixUp(RBNode x) {
        // 解决黑黑冲突,完善中
        while (x != root && x.color.equals(BLACK)) {
            if (x == x.parent.left) {
                RBNode w = x.parent.right;
                if (w.color.equals(RED)) {
                    w.color = BLACK;
                    x.parent.color = RED;
                    leftRotate(x.parent);
                    w = x.parent.right;
                } else if (w.left.color.equals(BLACK) && w.right.color.equals(BLACK)) {
                    w.color = RED;
                    x = x.parent;
                } else if (w.right.color.equals(BLACK)) {
                    w.left.color = BLACK;
                    w.color = RED;
                    rightRotate(w);
                    w = x.parent.right;
                } else if (w.left.color.equals(BLACK)) {
                    w.color = x.parent.color;
                    x.parent.color = BLACK;
                    w.right.color = BLACK;
                    leftRotate(x.parent);
                    x = root;
                }
            } else {
                RBNode w = x.parent.left;
                if (w.color.equals(RED)) {
                    w.color = BLACK;
                    x.parent.color = RED;
                    rightRotate(x.parent);
                    w = x.parent.left;
                } else if (w.left.color.equals(BLACK) && w.right.color.equals(BLACK)) {
                    w.color = RED;
                    x = x.parent;
                } else if (w.left.color.equals(BLACK)) {
                    w.right.color = BLACK;
                    w.color = RED;
                    leftRotate(w);
                    w = x.parent.left;
                } else if (w.right.color.equals(BLACK)) {
                    w.color = x.parent.color;
                    x.parent.color = BLACK;
                    w.left.color = BLACK;
                    rightRotate(x.parent);
                    x = root;
                }
            }
        }
        x.color = BLACK;
    }

    /**
     * 找后继
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treeSuccessor(RBNode node) {
        if (node.right != null) {
            return treeMiniMum(node.right);
        }
        RBNode currentNode = getParentNode(node);
        while (currentNode != null && node == currentNode.right) {
            node = currentNode;
            currentNode = getParentNode(node);
        }
        return currentNode;
    }

    /**
     * 找前驱
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treePrecursor(RBNode node) {
        if (node.left != null) {
            return treeMaxiMum(node.left);
        }
        RBNode currentNode = getParentNode(node);
        while (currentNode != null && node == currentNode.left) {
            node = currentNode;
            currentNode = getParentNode(node);
        }
        return currentNode;
    }

    /**
     * 最大节点
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treeMaxiMum(RBNode node) {
        while (isNotNilNode(node.right)) {
            node = node.right;
        }
        return node;
    }

    /**
     * 最小节点
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treeMiniMum(RBNode node) {
        while (isNotNilNode(node.left)) {
            node = node.left;
        }
        return node;
    }

    /**
     * 找节点的父节点
     * 
     * @param node
     * @return TreeNode
     */
    public RBNode getParentNode(RBNode node) {
        RBNode current = root;
        RBNode trailCurrent = null;
        while (isNotNilNode(current)) {
            if (current.value.compareTo(node.value) == 0) {
                break;
            }
            trailCurrent = current;
            if (node.value.compareTo(current.value) < 0) {
                current = current.left;
            } else {
                current = current.right;
            }
        }
        return trailCurrent;
    }

    /**
     * 搜索
     * 
     * @param value
     * @return TreeNode
     */
    public RBNode serach(RBValue value) {
        return treeSerach(root, value);
    }

    /**
     * 搜索
     * 
     * @param node
     * @param value
     * @return TreeNode
     */
    public RBNode treeSerach(RBNode node, RBValue value) {
        if (isNotNilNode(node) && node.value.compareTo(value) == 0) {
            return node;
        }
        if (value.compareTo(node.value) < 0) {
            return treeSerach(node.left, value);
        } else {
            return treeSerach(node.right, value);
        }
    }

    /**
     * 中序遍历
     * 
     * @param node
     */
    public void inOrder(RBNode node) {
        if (isNotNilNode(node)) {
            inOrder(node.left);
            System.out.println(node.value+","+node.color);
            inOrder(node.right);
        }
    }
    
    /**
     * 先序遍历
     * 
     * @param node
     */
    public void perOrder(RBNode node) {
        if (isNotNilNode(node)) {
            System.out.println(node.value+","+node.color);
            perOrder(node.left);
            perOrder(node.right);
        }
    }

    /**
     * @param node
     * @return 是否为NIL[T]节点
     */
    private boolean isNotNilNode(RBNode node) {
        return node != null && node.value != null;
    }

    /**
     * @param node
     * @return 是否为NIL[T]节点
     */
    private boolean isNilNode(RBNode node) {
        return !isNotNilNode(node);
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        IntervalTree tree = new IntervalTree();
        tree.RBInsert(new RBNode(new RBValue(0,3)));
        tree.RBInsert(new RBNode(new RBValue(5,8)));
        tree.RBInsert(new RBNode(new RBValue(6,10)));
        tree.RBInsert(new RBNode(new RBValue(8,9)));
        tree.RBInsert(new RBNode(new RBValue(15,23)));
        tree.RBInsert(new RBNode(new RBValue(16,21)));
        tree.RBInsert(new RBNode(new RBValue(17,19)));
        tree.RBInsert(new RBNode(new RBValue(19,20)));
        tree.RBInsert(new RBNode(new RBValue(25,30)));
        tree.RBInsert(new RBNode(new RBValue(26,26)));
        System.out.println("=================");
        System.out.println("root = "+tree.root.value);
        System.out.println("=================");
        tree.inOrder(tree.root);
        System.out.println("=================");
        tree.perOrder(tree.root);
    }

}

package acmcode;

/**
 * @author Leon.Chen
 *
 */
public class RBNode {

    /**
     * 
     */
    public RBNode parent;

    /**
     * 
     */
    public RBNode left;

    /**
     * 
     */
    public RBNode right;

    /**
     * 
     */
    public RBValue value;

    /**
     * 
     */
    public String color;

    /**
     * @param color
     */
    public RBNode(String color) {
        this.color = color;
    }

    /**
     * 
     */
    public RBNode() {

    }

    /**
     * @param value
     */
    public RBNode(RBValue value) {
        this.value = value;
    }
    
    /**
     * @param node
     */
    public void setMinPointAndMaxPoint(RBNode node) {
        if(node.value.startPoint<this.value.minPoint) {
            this.value.minPoint = node.value.startPoint;
        }
        if(node.value.endPoint>this.value.maxPoint) {
            this.value.maxPoint = node.value.endPoint;
        }
    }
    
    /**
     * 
     */
    public void setMinPointAndMaxPoint() {
        int min = 0;
        int max = 0;
        if (this.left.value == null && this.right.value == null) {
            min = this.value.startPoint;
            max = this.value.endPoint;
        } else {
            min = getMin();
            max = getMax();
        }
        this.value.minPoint = min;
        this.value.maxPoint = max;
    }
    
    /**
     * @return min
     */
    private int getMin() {
        RBNode left = this.left;
        RBNode right = this.right;
        int temp = getMin(left,right);
        if(this.value.startPoint > temp) {
            return temp;
        }
        return this.value.startPoint;
    }
    
    /**
     * @return max
     */
    private int getMax() {
        RBNode left = this.left;
        RBNode right = this.right;
        int temp = getMax(left,right);
        if(this.value.endPoint >temp) {
            return this.value.endPoint;
        }
        return temp;
    }
    
    /**
     * @param node1
     * @param node2
     * @return min
     */
    private int getMin(RBNode node1, RBNode node2) {
        if (node1.value == null && node2.value == null) {
            return 2147483647;
        }
        if (node1.value == null) {
            return node2.value.minPoint;
        }
        if (node2.value == null) {
            return node1.value.minPoint;
        }
        return (node1.value.minPoint < node2.value.minPoint ? node1.value.minPoint : node2.value.minPoint);
    }
    
    /**
     * @param node1
     * @param node2
     * @return max
     */
    private int getMax(RBNode node1, RBNode node2) {
        if (node1.value == null && node2.value == null) {
            return 0;
        }
        if (node1.value == null) {
            return node2.value.maxPoint;
        }
        if (node2.value == null) {
            return node1.value.maxPoint;
        }
        return (node1.value.maxPoint < node2.value.maxPoint ? node2.value.maxPoint : node1.value.maxPoint);
    }
}

package acmcode;

/**
 * @author Leon.Chen
 *
 */
public class RBValue {

    /**
     * 
     */
    public int startPoint;

    /**
     * 
     */
    public int endPoint;

    /**
     * 初始化minPoint为无穷大
     */
    public int minPoint = 2147483647;

    /**
     * 
     */
    public int maxPoint;

    /**
     * @param startPoint
     * @param endPoint
     */
    public RBValue(int startPoint, int endPoint) {
        this.startPoint = startPoint;
        this.endPoint = endPoint;
    }

    /**
     * @param otherValue
     * @return 比较结果
     */
    public int compareTo(RBValue otherValue) {
        int thisVal = this.startPoint;
        int anotherVal = otherValue.startPoint;
        return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));
    }

    public String toString() {
        return "[" + startPoint + "," + endPoint + "]" + " , [" + minPoint + "," + maxPoint + "]";
    }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package acmcode;

/**
 * Red-Black Tree
 * 
 * @author Leon.Chen
 */
public class RBTree {

    /**
     * 红
     */
    private static final String RED = "red";

    /**
     * 黑
     */
    private static final String BLACK = "black";

    /**
     * 根节点
     */
    private RBNode root;

    /**
     * 左旋转
     * 
     * @param x
     */
    private void leftRotate(RBNode x) {
        RBNode y = x.right;
        x.right = y.left;
        y.left.parent = x;
        y.parent = x.parent;
        if (x.parent == null) {
            root = y;
        } else {
            if (x == x.parent.left) {
                x.parent.left = y;
            } else {
                x.parent.right = y;
            }
        }
        y.left = x;
        x.parent = y;
    }

    /**
     * 右旋转
     * 
     * @param y
     */
    private void rightRotate(RBNode y) {
        RBNode x = y.left;
        y.left = x.right;
        x.right.parent = y;
        x.parent = y.parent;
        if (y.parent == null) {
            root = x;
        } else {
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }
        x.right = y;
        y.parent = x;
    }

    /**
     * 红黑树插入方法
     * 
     * @param z
     */
    public void RBInsert(RBNode z) {
        if (root == null) {
            root = z;
            root.color = BLACK;
        } else {
            RBNode x = root;
            RBNode y = null;
            while (isNotNilNode(x)) {
                y = x;
                if (z.value.compareTo(x.value) < 0) {
                    x = x.left;
                } else {
                    x = x.right;
                }
            }
            if (z.value.compareTo(y.value) < 0) {
                y.left = z;
            } else {
                y.right = z;
            }
            z.color = RED;
            z.parent = y;
        }
        z.left = new RBNode(BLACK);
        z.right = new RBNode(BLACK);
        RBInsertFixUp(z);
    }

    /**
     * 解决插入冲突
     * 
     * @param z
     */
    private void RBInsertFixUp(RBNode z) {
        while (z.parent != null && z.parent.color.equals(RED)) {
            if (z.parent == z.parent.parent.left) {
                RBNode y = z.parent.parent.right;
                if (y.color.equals(RED)) {
                    z.parent.color = BLACK;
                    y.color = BLACK;
                    z.parent.parent.color = RED;
                    z = z.parent.parent;
                } else if (z == z.parent.right) {
                    z = z.parent;
                    leftRotate(z);
                } else if (z == z.parent.left) {
                    z.parent.color = BLACK;
                    z.parent.parent.color = RED;
                    rightRotate(z.parent.parent);
                }
            } else {
                RBNode y = z.parent.parent.left;
                if (y.color.equals(RED)) {
                    z.parent.color = BLACK;
                    y.color = BLACK;
                    z.parent.parent.color = RED;
                    z = z.parent.parent;
                } else if (z == z.parent.left) {
                    z = z.parent;
                    rightRotate(z);
                } else if (z == z.parent.right) {
                    z.parent.color = BLACK;
                    z.parent.parent.color = RED;
                    leftRotate(z.parent.parent);
                }
            }
        }
        root.color = BLACK;
    }

    /**
     * @param deleteNode
     */
    public void RBDelete(RBNode deleteNode) {
        RBNode y = null;
        RBNode z = serach(deleteNode.value);
        if (isNilNode(z.left) || isNilNode(z.right)) {
            y = z;
        } else {
            y = treeSuccessor(z);
        }
        RBNode x = null;
        if (isNotNilNode(y.left)) {
            x = y.left;
        } else {
            x = y.right;
        }
        x.parent = y.parent;
        if (isNilNode(y.parent)) {
            root = x;
        } else {
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }
        if (y != z) {
            z.value = y.value;
        }
        if (y.color.equals(BLACK)) {
            RBDeleteFixUp(x);
        }
    }

    /**
     * @param x
     */
    private void RBDeleteFixUp(RBNode x) {
        System.out.println("===="+x.value);
        // 解决黑黑冲突,完善中
        while (x != root && x.color.equals(BLACK)) {
            if (x == x.parent.left) {
                RBNode w = x.parent.right;
                if (w.color.equals(RED)) {
                    w.color = BLACK;
                    x.parent.color = RED;
                    leftRotate(x.parent);
                    w = x.parent.right;
                } else if (w.left.color.equals(BLACK) && w.right.color.equals(BLACK)) {
                    w.color = RED;
                    x = x.parent;
                } else if (w.right.color.equals(BLACK)) {
                    w.left.color = BLACK;
                    w.color = RED;
                    rightRotate(w);
                    w = x.parent.right;
                } else if (w.left.color.equals(BLACK)) {
                    w.color = x.parent.color;
                    x.parent.color = BLACK;
                    w.right.color = BLACK;
                    leftRotate(x.parent);
                    x = root;
                }
            } else {
                RBNode w = x.parent.left;
                if (w.color.equals(RED)) {
                    w.color = BLACK;
                    x.parent.color = RED;
                    rightRotate(x.parent);
                    w = x.parent.left;
                } else if (w.left.color.equals(BLACK) && w.right.color.equals(BLACK)) {
                    w.color = RED;
                    x = x.parent;
                } else if (w.left.color.equals(BLACK)) {
                    w.right.color = BLACK;
                    w.color = RED;
                    leftRotate(w);
                    w = x.parent.left;
                } else if (w.right.color.equals(BLACK)) {
                    w.color = x.parent.color;
                    x.parent.color = BLACK;
                    w.left.color = BLACK;
                    rightRotate(x.parent);
                    x = root;
                }
            }
        }
        x.color = BLACK;
    }

    /**
     * 找后继
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treeSuccessor(RBNode node) {
        if (node.right != null) {
            return treeMiniMum(node.right);
        }
        RBNode currentNode = getParentNode(node);
        while (currentNode != null && node == currentNode.right) {
            node = currentNode;
            currentNode = getParentNode(node);
        }
        return currentNode;
    }

    /**
     * 找前驱
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treePrecursor(RBNode node) {
        if (node.left != null) {
            return treeMaxiMum(node.left);
        }
        RBNode currentNode = getParentNode(node);
        while (currentNode != null && node == currentNode.left) {
            node = currentNode;
            currentNode = getParentNode(node);
        }
        return currentNode;
    }

    /**
     * 最大节点
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treeMaxiMum(RBNode node) {
        while (isNotNilNode(node.right)) {
            node = node.right;
        }
        return node;
    }

    /**
     * 最小节点
     * 
     * @param node
     * @return RBNode
     */
    public RBNode treeMiniMum(RBNode node) {
        while (isNotNilNode(node.left)) {
            node = node.left;
        }
        return node;
    }

    /**
     * 找节点的父节点
     * 
     * @param node
     * @return TreeNode
     */
    public RBNode getParentNode(RBNode node) {
        RBNode current = root;
        RBNode trailCurrent = null;
        while (isNotNilNode(current)) {
            if (current.value.compareTo(node.value) == 0) {
                break;
            }
            trailCurrent = current;
            if (node.value.compareTo(current.value) < 0) {
                current = current.left;
            } else {
                current = current.right;
            }
        }
        return trailCurrent;
    }

    /**
     * 搜索
     * 
     * @param value
     * @return TreeNode
     */
    public RBNode serach(RBValue value) {
        return treeSerach(root, value);
    }

    /**
     * 搜索
     * 
     * @param node
     * @param value
     * @return TreeNode
     */
    public RBNode treeSerach(RBNode node, RBValue value) {
        if (isNotNilNode(node) && node.value.compareTo(value) == 0) {
            return node;
        }
        if (value.compareTo(node.value) < 0) {
            return treeSerach(node.left, value);
        } else {
            return treeSerach(node.right, value);
        }
    }

    /**
     * 中序遍历
     * 
     * @param node
     */
    public void inOrder(RBNode node) {
        if (isNotNilNode(node)) {
            inOrder(node.left);
            System.out.println(node.value+","+node.color);
            inOrder(node.right);
        }
    }
    
    /**
     * 先序遍历
     * 
     * @param node
     */
    public void perOrder(RBNode node) {
        if (isNotNilNode(node)) {
            System.out.println(node.value+","+node.color);
            perOrder(node.left);
            perOrder(node.right);
        }
    }

    /**
     * @param node
     * @return 是否为NIL[T]节点
     */
    private boolean isNotNilNode(RBNode node) {
        return node != null && node.value != null;
    }

    /**
     * @param node
     * @return 是否为NIL[T]节点
     */
    private boolean isNilNode(RBNode node) {
        return !isNotNilNode(node);
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        RBTree tree = new RBTree();
        
        
        tree.RBInsert(new RBNode(new RBValue(3)));
        tree.RBInsert(new RBNode(new RBValue(4)));
        tree.RBInsert(new RBNode(new RBValue(12)));
        tree.RBInsert(new RBNode(new RBValue(13)));
        tree.RBInsert(new RBNode(new RBValue(11)));
        tree.RBInsert(new RBNode(new RBValue(15)));
        tree.RBDelete(new RBNode(new RBValue(12)));
        System.out.println("=================");
        System.out.println("root = "+tree.root.value);
        System.out.println("=================");
        tree.inOrder(tree.root);
        System.out.println("=================");
        tree.perOrder(tree.root);
    }

}

package acmcode;

/**
 * @author Leon.Chen
 *
 */
public class RBNode {

    public RBNode parent;

    public RBNode left;

    public RBNode right;

    public RBValue value;

    public String color;

    public RBNode(String color) {
        this.color = color;
    }

    public RBNode() {

    }

    public RBNode(RBValue value) {
        this.value = value;
    }

}

package acmcode;

public class RBValue {

    public int value;

    public RBValue(int value) {
        this.value = value;
    }

    public int compareTo(RBValue otherValue) {
        int thisVal = this.value;
        int anotherVal = otherValue.value;
        return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));
    }

    public String toString() {
        return new Integer(value).toString();
    }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

给定一个字符串
example:"4-(4-3*5+(2*4)+100)/10";
要求输出结果"-5.70";结果四舍五入，保留两位小数

	public BigDecimal calculateString(String str) {
		char[] strs = str.toCharArray();
		Stack<String> stack = new Stack<String>();

		for (int i = 0; i < strs.length; i++) {
			String stackStr = String.valueOf(strs[i]);
			stack.push(stackStr);
			if (")".equals(stack.top())) {
				String subStr = null;
				while (!"(".equals(stack.top())) {
					stack.pop();
					if (!"(".equals(stack.top())) {
						subStr = addEnd(subStr, stack.top());
					}
				}
				String pushStr = CalculateReversePolishExpression(subStr);
				stack.pop();
				stack.push(pushStr);
			}

		}
		String resultStr = null;
		while (stack.count != 0) {
			resultStr = CalculateReversePolishExpression(stack.toString());
		}
		BigDecimal result = null;
		if (resultStr != null) {
			result = new BigDecimal(resultStr);
		} else {
			result = BigDecimal.ZERO;
		}
		return result.setScale(2, BigDecimal.ROUND_HALF_UP);
	}

String pushStr = CalculateReversePolishExpression(subStr);

package graph;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 
 * 应用：逆波兰表达式
 * 
 * @author Leon.Chen
 * 
 */
public class CalculateString {

	public BigDecimal calculateString(String str) {
		char[] strs = str.toCharArray();
		Stack<String> stack = new Stack<String>();

		for (int i = 0; i < strs.length; i++) {
			String stackStr = String.valueOf(strs[i]);
			stack.push(stackStr);
			if (")".equals(stack.top())) {
				String subStr = null;
				while (!"(".equals(stack.top())) {
					stack.pop();
					if (!"(".equals(stack.top())) {
						subStr = addEnd(subStr, stack.top());
					}
				}
				String pushStr = CalculateReversePolishExpression(subStr);
				stack.pop();
				stack.push(pushStr);
			}

		}
		String resultStr = null;
		while (stack.count != 0) {
			resultStr = CalculateReversePolishExpression(stack.toString());
		}
		BigDecimal result = null;
		if (resultStr != null) {
			result = new BigDecimal(resultStr);
		} else {
			result = BigDecimal.ZERO;
		}
		return result.setScale(2, BigDecimal.ROUND_HALF_UP);
	}

	public String[] matcher(String regex, String str) {
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		List<String> list = new ArrayList<String>();
		while (matcher.find()) {
			list.add(matcher.group());
		}
		String[] result = new String[list.size()];
		return list.toArray(result);
	}

	public List<String> createReversePolishExpression(String subStr) {
		String regex = "\\d+\\.{0,1}\\d*";
		String[] numbers = matcher(regex, subStr);
		String changeStr = subStr.replaceAll(regex, "0").replaceAll("\\-\\-0",
				"-1").replaceAll("\\+\\-0", "+1").replaceAll("\\*\\-0", "*1")
				.replaceAll("\\/\\-0", "/1");
		char[] chars = changeStr.toCharArray();
		int index = 0;
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < chars.length; i++) {
			String str = String.valueOf(chars[i]);
			if ("0".equals(str)) {
				list.add(numbers[index++]);
			} else if ("1".equals(str)) {
				list.add("-" + numbers[index++]);
			} else {
				list.add(str);
			}
		}
		List<String> suffix = new ArrayList<String>();
		Stack<String> operator = new Stack<String>();
		for (int i = 0; i < list.size(); i++) {
			if (!isOperatorType(list.get(i))) {
				suffix.add(list.get(i));
			} else {
				if (operator.count == 0) {
					operator.push(list.get(i));
				} else {
					while (operator.count != 0&&compare(operator.top(), list.get(i)) >= 0) {
						String top = operator.top();
						operator.pop();
						suffix.add(top);
					} 
					operator.push(list.get(i));

				}
			}
		}

		while (operator.count != 0) {
			suffix.add(operator.top());
			operator.pop();
		}
		return suffix;
	}

	public String CalculateReversePolishExpression(String subStr) {
		List<String> suffix = createReversePolishExpression(subStr);
		Stack<Double> stack = new Stack<Double>();
		for (int i = 0; i < suffix.size(); i++) {
			if (!isOperatorType(suffix.get(i))) {
				stack.push(Double.valueOf(suffix.get(i)));
			} else {
				Double current = stack.top();
				stack.pop();
				Double previous = null;
				if (stack.count != 0) {
					previous = stack.top();
					stack.pop();
				} else {
					previous = new Double(0);
				}
				Double result = calculate(suffix.get(i), previous, current);
				stack.push(result);
			}
		}
		return stack.top().toString();
	}

	public String addEnd(String str, String a) {
		StringBuffer buf = new StringBuffer();
		buf.append(a);
		if (str != null) {
			buf.append(str);
		}
		return buf.toString();
	}

	public boolean isOperatorType(String str) {
		if (str.equals("+") || str.equals("-") || str.equals("*")
				|| str.equals("/")) {
			return true;
		}
		return false;
	}

	public int compare(String op1, String op2) {
		Integer iop1 = getOperator(op1);
		Integer iop2 = getOperator(op2);
		return iop1.compareTo(iop2);
	}

	public Integer getOperator(String op) {
		if ("+".equals(op) || "-".equals(op)) {
			return new Integer(0);
		}
		if ("*".equals(op) || "/".equals(op)) {
			return new Integer(1);
		}
		return null;
	}

	public Double calculate(String op, Double previous, Double current) {
		if ("+".equals(op)) {
			return previous + current;
		}
		if ("-".equals(op)) {
			return previous - current;
		}
		if ("*".equals(op)) {
			return previous * current;
		}
		if ("/".equals(op)) {
			return previous / current;
		}
		return null;
	}

	public static void main(String[] args) {
		String[] strs = new String[]{"(5+6)*7","(-1)/(-3)","1/(-3)","-1/7","7+(3*5)-(8+20/2)","4-(4-3*5+(2*4)+100)/10"};
		for(int i=0;i<strs.length;i++){
			BigDecimal result = new CalculateString().calculateString(strs[i]);
			System.out.println(result.toString());
		}
		
	}

}

package graph;

public class Stack<T> {
	public StackNode<T> stackTop;
	public int count;
	public void push(T info) {
		StackNode<T> node = new StackNode<T>();
		node.info = info;
		node.link = stackTop;
		stackTop = node;
		count++;
	} 
	
	public void pop() {
		if(stackTop == null) {
			System.out.println("null stack");
		} else {
			stackTop = stackTop.link;
			count--;
		}

	}
	
	public boolean isEmpty() {
		return count == 0;
	}
	
	public T top() {
		if(stackTop == null) {
			return null;
		}
		return stackTop.info;
	}
	
	public String toString(){
		Stack<T> other = new Stack<T>();
		while(count != 0){
			T top = top();
			pop();
			other.push(top);
		}
		StringBuffer buf = new StringBuffer();
		while(other.count !=0){
			buf.append(other.top());
			other.pop();
		}
		return buf.toString();
	}

}

package graph;

public class StackNode<T> {
	public StackNode<T> link;
	public T info;
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

 /**
 * 
 * 时间限制(普通/Java):6000MS/20000MS 运行内存限制:65536KByte
 * 总提交:131 测试通过:32
 * 描述
 * 在一个0,1方阵中找出其中最大的全0子矩阵，所谓最大是指O的个数最多
 * 输入
 * 单组数据第一行为整数N，其中1<=N<=2000，为方阵的大小，紧接着N行每行均有N个0或1，相邻两数间严格用一个空格隔开
 * 输出
 * 输出仅一行包含一个整数表示要求的最大的全零子矩阵中零的个数
 * 样例输入
 * 5
 * 0 1 0 1 0
 * 0 0 0 0 0
 * 0 0 0 0 1
 * 1 0 0 0 0
 * 0 1 0 0 0
 * 样例输出
 * 9
 */

package graph;
/**
 * 
 * 时间限制(普通/Java):6000MS/20000MS 运行内存限制:65536KByte
 * 总提交:131 测试通过:32
 * 描述
 * 在一个0,1方阵中找出其中最大的全0子矩阵，所谓最大是指O的个数最多
 * 输入
 * 单组数据第一行为整数N，其中1<=N<=2000，为方阵的大小，紧接着N行每行均有N个0或1，相邻两数间严格用一个空格隔开
 * 输出
 * 输出仅一行包含一个整数表示要求的最大的全零子矩阵中零的个数
 * 样例输入
 * 5
 * 0 1 0 1 0
 * 0 0 0 0 0
 * 0 0 0 0 1
 * 1 0 0 0 0
 * 0 1 0 0 0
 * 样例输出
 * 9
 * 
 * @author Leon.Chen
 *
 */
public class AllZeroMatrix {
	/**
	 * 输入矩阵
	 */
	public int[][] matrix;
	/**
	 * 矩阵最大行
	 */
	public int maxRow;
	/**
	 * 矩阵最大列
	 */
	public int maxColumn;
	/**
	 * 被乘数
	 */
	public int multiplicand;
	/**
	 * 最大全零矩阵
	 */
	public int totalCount;

	/**
	 * 每个点向下，向右扩张矩形，取最大的矩形
	 * 
	 * @param row
	 * @param column
	 */
	public void spread(int row, int column) {
		int rowStart = row;
		int rowEnd = row;
		while (rowEnd < maxRow) {
			if (matrix[rowEnd][column] == 0) {
				rowEnd++;
			} else {
				break;
			}
		}
		this.multiplicand = 0;
		spreadMatrixRight(rowStart, rowEnd, column);
		int count = (rowEnd - rowStart) * multiplicand;
		if (totalCount < count) {
			totalCount = count;
		}
		int columnStart = column;
		int columnEnd = column;
		while (columnEnd < maxColumn) {
			if (matrix[row][columnEnd] == 0) {
				columnEnd++;
			} else {
				break;
			}
		}
		this.multiplicand = 0;
		spreadMatrixbelow(columnStart, columnEnd, row);
		count = (columnEnd - columnStart) * multiplicand;
		if (totalCount < count) {
			totalCount = count;
		}
	}

	/**
	 * 矩阵的向右扩张
	 * 
	 * @param start
	 * @param end
	 * @param column
	 */

	public void spreadMatrixRight(int start, int end, int column) {
		boolean flg = true;
		for (int i = start; i < end; i++) {
			if (matrix[i][column] == 1) {
				flg = false;
				break;
			}
		}
		if (flg) {
			multiplicand++;
			int nextColumn = column;
			nextColumn++;
			if (nextColumn < maxColumn) {
				spreadMatrixRight(start, end, nextColumn);
			}
		}
	}

	/**
	 * 矩阵的向下扩张
	 * 
	 * @param start
	 * @param end
	 * @param row
	 */
	public void spreadMatrixbelow(int start, int end, int row) {
		boolean flg = true;
		for (int i = start; i < end; i++) {
			if (matrix[row][i] == 1) {
				flg = false;
				break;
			}
		}
		if (flg) {
			multiplicand++;
			int nextRow = row;
			nextRow++;
			if (nextRow < maxRow) {
				spreadMatrixbelow(start, end, nextRow);
			}
		}
	}

	/**
	 * 得到最大全零矩阵的大小
	 * 
	 * @param printMatrix
	 */
	public void getAllZeroMatrix(int[][] printMatrix) {
		matrix = printMatrix;
		maxRow = matrix.length;
		maxColumn = matrix[0].length;
		for (int i = 0; i < maxRow; i++) {
			for (int j = 0; j < maxColumn; j++) {
				int count = (maxRow - i) * (maxColumn - j);
				if (count <= totalCount) {
					continue;
				}
				if (matrix[i][j] != 1) {
					spread(i, j);
				}
			}
		}
		System.out.println(totalCount);
	}
	
	public static void main(String[] args) {
		int[][] printMatrix = new int[][]{
				{0,1,0,1,0},
				{0,0,0,0,0},
				{0,0,0,0,1},
				{1,0,0,0,0},
				{0,1,0,0,0},
		};
		long start = System.currentTimeMillis();
		new AllZeroMatrix().getAllZeroMatrix(printMatrix);
		long end = System.currentTimeMillis();
		System.out.println((end-start)+"ms");
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package graph;      
     
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;      
     
/**      
 * 决策树的ID3算法      
 * 参照实现http://www.blog.edu.cn/user2/huangbo929/archives/2006/1533249.shtml    
 * @author Leon.Chen      
 */     
public class DTree {      
          
    /**    
     * root    
     */     
    TreeNode root;      
          
    /**    
     * 可见性数组    
     */     
    private static boolean[] visable;      
          
    private Object[] array;  
    
    private int index;
     
    /**    
     * @param args    
     */     
    @SuppressWarnings("boxing")      
    public static void main(String[] args) {      
        //初始数据      
        Object[] array = new Object[] {       
                        new String[]{ "Sunny"    ,"Hot"   ,"High"    ,"Weak"    ,"No" },      
                        new String[]{ "Sunny"    ,"Hot"   ,"High"    ,"Strong"  ,"No" },      
                        new String[]{ "Overcast" ,"Hot"   ,"High"    ,"Weak"    ,"Yes"},      
                        new String[]{ "Rain"     ,"Mild"  ,"High"    ,"Weak"    ,"Yes"},      
                        new String[]{ "Rain"     ,"Cool"  ,"Normal"  ,"Weak"    ,"Yes"},      
                        new String[]{ "Rain"     ,"Cool"  ,"Normal"  ,"Strong"  ,"No" },      
                        new String[]{ "Overcast" ,"Cool"  ,"Normal"  ,"Strong"  ,"Yes"},      
                        new String[]{ "Sunny"    ,"Mild"  ,"High"    ,"Weak"    ,"No" },      
                        new String[]{ "Sunny"    ,"Cool"  ,"Normal"  ,"Weak"    ,"Yes"},      
                        new String[]{ "Rain"     ,"Mild"  ,"Normal"  ,"Weak"    ,"Yes"},      
                        new String[]{ "Sunny"    ,"Mild"  ,"Normal"  ,"Strong"  ,"Yes"},      
                        new String[]{ "Overcast" ,"Mild"  ,"High"    ,"Strong"  ,"Yes"},      
                        new String[]{ "Overcast" ,"Hot"   ,"Normal"  ,"Weak"    ,"Yes"},      
                        new String[]{ "Rain"     ,"Mild"  ,"High"    ,"Strong"  ,"No" },      
                        };      
              
        DTree tree = new DTree();       
        tree.create(array,4);
    } 
    
    public void create(Object[] array,int index){
    	this.array = array;
    	init(array,index);
    	createDTree(array);
    	printDTree(root);
    }
       
    public Object[] getMaxGain(Object[] array){   
        Object[] result = new Object[2];   
        double gain = 0;   
        int index = 0;
        
        for(int i=0;i<visable.length;i++){   
            if(!visable[i]){   
                double value = gain(array,i);   
                if(gain < value){   
                    gain = value;   
                    index = i;   
                }   
            }   
        }   
        result[0] = gain;   
        result[1] = index;   
        visable[index] = true;   
        return result;   
    }   
       
    public void createDTree(Object[] array) {   
        Object[] maxgain = getMaxGain(array);   
        if (root == null) {   
            root = new TreeNode();   
            root.parent = null;   
            root.parentArrtibute = null;   
            root.arrtibutes = getArrtibutes(((Integer) maxgain[1]).intValue());   
            root.nodeName = getNodeName(((Integer) maxgain[1]).intValue());  
            root.childNodes = new TreeNode[root.arrtibutes.length];
            insertTree(array,root);
        }
    }   
       
    public void insertTree(Object[] array,TreeNode parentNode){
    	String[] arrtibutes = parentNode.arrtibutes;
    	for(int i=0;i<arrtibutes.length;i++){
    		Object[] pickArray = pickUpAndCreateArray(array,arrtibutes[i],getNodeIndex(parentNode.nodeName));
    		Object[] info = getMaxGain(pickArray);
    		double gain = ((Double)info[0]).doubleValue();
    		if(gain != 0){
    			int index = ((Integer) info[1]).intValue();
    			System.out.println("gain = "+gain+" ,node name = "+getNodeName(index));
        		TreeNode currentNode = new TreeNode();
        		currentNode.parent = parentNode;
        		currentNode.parentArrtibute = arrtibutes[i];
        		currentNode.arrtibutes = getArrtibutes(index);
        		currentNode.nodeName = getNodeName(index);
        		currentNode.childNodes = new TreeNode[currentNode.arrtibutes.length];
        		parentNode.childNodes[i] = currentNode;
        		insertTree(pickArray,currentNode);
    		}else {
    			TreeNode leafNode = new TreeNode();
    			leafNode.parent = parentNode;
    			leafNode.parentArrtibute = arrtibutes[i];
    			leafNode.arrtibutes = new String[0];
    			leafNode.nodeName = getLeafNodeName(pickArray);
    			leafNode.childNodes = new TreeNode[0];
    			parentNode.childNodes[i] = leafNode;
    		}
    	}

    }
    
    public void printDTree(TreeNode node){
    	System.out.println(node.nodeName);

    	TreeNode[] childs = node.childNodes;
    	for(int i=0;i<childs.length;i++){
    		if(childs[i]!=null){
    			System.out.println(childs[i].parentArrtibute);
    			printDTree(childs[i]);
    		}
    	}
    }
  
    /**      
     * @param dataArray 原始数组 D     
     * @param criterion 标准值      
     * @return double      
     */     
    public void init(Object[] dataArray,int index) {
    	this.index = index;
        //数据初始化   
        visable = new boolean[((String[])dataArray[0]).length];      
        for(int i=0;i<visable.length;i++) {    
            if(i == index){   
                visable[i] = true;    
            }else {   
                visable[i] = false;    
            }   
        }   
    }   
    
    public Object[] pickUpAndCreateArray(Object[] array,String arrtibute,int index){
    	List<String[]> list = new ArrayList<String[]>();
    	for(int i=0;i<array.length;i++){
    		String[] strs = (String[])array[i];
    		if(strs[index].equals(arrtibute)){
    			list.add(strs);
    		}
    	}
    	return list.toArray();
    }
  
    /**    
     * Entropy(S)    
     * @param array    
     * @return double     
     */     
    public double gain(Object[] array,int index) {      
        String[] playBalls = getArrtibutes(this.index);   
        int[] counts = new int[playBalls.length];      
        for(int i=0;i<counts.length;i++) {   
            counts[i] = 0;      
        }   
        for(int i=0;i<array.length;i++) {   
            String[] strs = (String[])array[i];   
            for(int j=0;j<playBalls.length;j++) {   
                if(strs[this.index].equals(playBalls[j])) {   
                    counts[j]++;   
                }   
            }   
        }   
        /**  
         * Entropy(S) = S -p(I) log2 p(I)  
         */  
        double entropyS = 0;   
        for(int i=0;i<counts.length;i++) {      
            entropyS += DTreeUtil.sigma(counts[i],array.length);      
        }   
        String[] arrtibutes = getArrtibutes(index);   
        /**  
         * total ((|Sv| / |S|) * Entropy(Sv))   
         */  
        double sv_total = 0;   
        for(int i=0;i<arrtibutes.length;i++){   
            sv_total += entropySv(array, index,arrtibutes[i],array.length);   
        }   
        return entropyS-sv_total;   
    }   
       
    /**  
     * ((|Sv| / |S|) * Entropy(Sv))  
     * @param array  
     * @param index  
     * @param arrtibute  
     * @param allTotal  
     * @return  
     */  
    public double entropySv(Object[] array,int index,String arrtibute,int allTotal) {   
        String[] playBalls = getArrtibutes(this.index);   
        int[] counts = new int[playBalls.length];   
        for(int i=0;i<counts.length;i++) {   
            counts[i] = 0;      
        }   
  
        for (int i = 0; i < array.length; i++) {   
            String[] strs = (String[]) array[i];   
            if (strs[index].equals(arrtibute)) {   
                for (int k = 0; k < playBalls.length; k++) {   
                    if (strs[this.index].equals(playBalls[k])) {   
                        counts[k]++;   
                    }   
                }   
            }   
        }   
  
        int total = 0;   
        double entropySv = 0;    
        for(int i=0;i<counts.length;i++){   
            total += counts[i];   
        }   
        for(int i=0;i<counts.length;i++){   
            entropySv += DTreeUtil.sigma(counts[i],total);    
        }    
        return DTreeUtil.getPi(total, allTotal)*entropySv;   
    }   
          
    @SuppressWarnings("unchecked")   
    public String[] getArrtibutes(int index) {      
        TreeSet<String> set = new TreeSet<String>(new SequenceComparator());      
        for (int i = 0; i < array.length; i++) {      
            String[] strs = (String[]) array[i];      
            set.add(strs[index]);      
        }      
        String[] result = new String[set.size()];      
        return set.toArray(result);      
    }   
          
    public String getNodeName(int index) {    
    	String[] strs = new String[]{"Outlook","Temperature","Humidity","Wind","Play ball"};
    	for(int i=0;i<strs.length;i++){
    		if(i == index){
    			return strs[i];
    		}
    	}
    	return null;    
    }
    
    public String getLeafNodeName(Object[] array){
    	if(array!=null && array.length>0){
    		String[] strs = (String[])array[0];
    		return strs[index];
    	}
    	return null;		
    }
    
    public int getNodeIndex(String name) {  
    	String[] strs = new String[]{"Outlook","Temperature","Humidity","Wind","Play ball"};
    	for(int i=0;i<strs.length;i++){
    		if(name.equals(strs[i])){
    			return i;
    		}
    	}
        return -1;    
    } 
}      

package graph;      
     
/**    
 * @author B.Chen    
 */     
public class TreeNode {      
     
    /**    
     * 父    
     */     
    TreeNode parent;    
     
    /**    
     * 指向父的哪个属性    
     */     
    String parentArrtibute;      
     
    /**    
     * 节点名    
     */     
    String nodeName;      
     
    /**    
     * 属性数组    
     */     
    String[] arrtibutes;    
    
    /**
     * 节点数组
     */
    TreeNode[] childNodes;

}      

package graph;   
  
public class DTreeUtil {   
  
    /**  
     * 属性值熵的计算 Info(T)=(i=1...k)pi*log（2）pi  
     *   
     * @param x  
     * @param total  
     * @return double  
     */  
    public static double sigma(int x, int total) {
    	if(x == 0){
    		return 0;
    	}
        double x_pi = getPi(x, total);   
        return -(x_pi * logYBase2(x_pi));   
    }   
  
    /**  
     * log2y  
     *   
     * @param y  
     * @return double  
     */  
    public static double logYBase2(double y) {   
        return Math.log(y) / Math.log(2);   
    }   
  
    /**  
     * pi是当前这个属性出现的概率（=出现次数/总数）  
     *   
     * @param x  
     * @param total  
     * @return double  
     */  
    public static double getPi(int x, int total) {   
        return x * Double.parseDouble("1.0") / total;   
    }  

}   

package graph;

import java.util.Comparator;

public class SequenceComparator implements Comparator {

    public int compare(Object o1, Object o2) throws ClassCastException {
        String str1 = (String) o1;
        String str2 = (String) o2;
        return str1.compareTo(str2);
    }

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

/**
 * @author B.Chen
 */
function store2xml(store, xml){
 store.load();
 var array = new Array();
 var old_nodes = xml.documentElement.childNodes;
 var old_firstNodes = old_nodes[0];
 var attributes = old_firstNodes.attributes;
 for(var i=0;i<attributes.length;i++) {
  array[i] = attributes[i].name;
 }
 
 var xmlDoc = createXmlDoc(store);
 var new_nodes = xmlDoc.documentElement.childNodes;
 for(var i=0;i<store.getCount();i++) {
  var record = store.getAt(i);
  for(var j=0;j<array.length;j++) {
   new_nodes[i].setAttribute(array[j],record.get(array[j]));
  }
 }
 return xmlDoc;
}

function createXmlDoc(store){
    var xmlDoc = new ActiveXObject("Microsoft.XMLDOM")
    var xmlString = "";
    var root = "<data>";
    var end_root = "</data>";
    var child = "<row>"
    var end_child = "</row>";
    var tab = "\t";
    var nextLine = "\n";
    xmlString += root + nextLine;
    for (var i = 0; i < store.getCount(); i++) {
        xmlString += tab + child + nextLine;
        xmlString += tab + end_child + nextLine;
    }
    xmlString += end_root;
    xmlDoc.loadXML(xmlString)
 return xmlDoc;
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package tree;   
  
public class TreeNode {   
    TreeNode llink;   
    TreeNode rlink;   
    int info;   
}  
package tree;   
  
public class Tree {   
  
    TreeNode root;   
  
    public Tree() {   
    }   
  
    public boolean isEmpty() {   
        return root == null;   
    }   
  
    // 插入   
    public void insertBinaryTree(int info) {   
        TreeNode node = new TreeNode();   
        node.info = info;   
        if (root == null) {   
            root = node;   
        } else {   
            TreeNode currentNode = root;   
            TreeNode parent;   
            while (currentNode != null) {   
                parent = currentNode;   
                if (info > currentNode.info) {   
                    currentNode = currentNode.rlink;   
                    if (currentNode == null) {   
                        parent.rlink = node;   
                    }   
                } else if (info < currentNode.info) {   
                    currentNode = currentNode.llink;   
                    if (currentNode == null) {   
                        parent.llink = node;   
                    }   
                }   
            }   
        }   
    }   
  
    // 删除   
    public void treeDelete(int info) {   
        TreeNode tNode = serach(info);   
        TreeNode deleteNode = new TreeNode();   
        TreeNode dNodeChild = new TreeNode();   
        if (tNode == null) {   
            System.out.println("node is not exists");   
        } else if (tNode.llink == null || tNode.rlink == null) {   
            deleteNode = tNode;   
        } else {   
            deleteNode = treeSuccessor(tNode);   
        }   
        if (deleteNode.llink != null) {   
            dNodeChild = deleteNode.llink;   
        } else {   
            dNodeChild = deleteNode.rlink;   
        }   
        if (getFatherNode(deleteNode) == null) {   
            root = dNodeChild;   
        } else {   
            if (deleteNode == getFatherNode(deleteNode).llink) {   
                getFatherNode(deleteNode).llink = dNodeChild;   
            } else {   
                getFatherNode(deleteNode).rlink = dNodeChild;   
            }   
        }   
        if (deleteNode != tNode) {   
            tNode.info = deleteNode.info;   
        }   
    }   
  
    // 搜索   
    public TreeNode serach(int info) {   
        return treeSerach(root, info);   
    }   
  
    // 搜索   
    public TreeNode treeSerach(TreeNode tNode, int info) {   
        if (tNode == null || tNode.info == info) {   
            return tNode;   
        }   
        if (info < tNode.info) {   
            return treeSerach(tNode.llink, info);   
        } else {   
            return treeSerach(tNode.rlink, info);   
        }   
    }   
  
    // 最大节点   
    public TreeNode treeMaxiMum(TreeNode tNode) {   
        while (tNode.rlink != null) {   
            tNode = tNode.rlink;   
        }   
        return tNode;   
    }   
  
    // 最小节点   
    public TreeNode treeMiniMun(TreeNode tNode) {   
        while (tNode.llink != null) {   
            tNode = tNode.llink;   
        }   
        return tNode;   
    }   
  
    // 找后继   
    public TreeNode treeSuccessor(TreeNode tNode) {   
        if (tNode.rlink != null) {   
            return treeMiniMun(tNode.rlink);   
        }   
        TreeNode currentNode = getFatherNode(tNode);   
        while (currentNode != null && tNode == currentNode.rlink) {   
            tNode = currentNode;   
            currentNode = getFatherNode(tNode);   
        }   
        return currentNode;   
    }   
  
    // 找前驱   
    public TreeNode treePrecursor(TreeNode tNode) {   
        if (tNode.llink != null) {   
            return treeMaxiMum(tNode.llink);   
        }   
        TreeNode currentNode = getFatherNode(tNode);   
        while (currentNode != null && tNode == currentNode.llink) {   
            tNode = currentNode;   
            currentNode = getFatherNode(tNode);   
        }   
        return currentNode;   
    }   
  
    // 找节点的父节点   
    public TreeNode getFatherNode(TreeNode tNode) {   
        TreeNode current = root;   
        TreeNode trailCurrent = null;   
        while (current != null) {   
            if (current.info == tNode.info) {   
                break;   
            }   
            trailCurrent = current;   
            if (tNode.info < current.info) {   
                current = current.llink;   
            } else {   
                current = current.rlink;   
            }   
        }   
        return trailCurrent;   
    }   
  
    // 中序遍历   
    public void inOrder(TreeNode tNode) {   
        if (tNode != null) {   
            inOrder(tNode.llink);   
            System.out.print(tNode.info + " ");   
            inOrder(tNode.rlink);   
        }   
    }   
  
    // 打印树   
    public void printTree() {   
        System.out.println("inOrder");   
        inOrder(root);   
        System.out.println();   
        System.out.println("preOrder");   
        preOrder(root);   
        System.out.println();   
        System.out.println("postOrder");   
        postOrder(root);   
        System.out.println();   
    }   
  
    // 前序遍历   
    public void preOrder(TreeNode tNode) {   
        if (tNode != null) {   
            System.out.print(tNode.info + " ");   
            preOrder(tNode.llink);   
            preOrder(tNode.rlink);   
        }   
    }   
  
    // 后序遍历   
    public void postOrder(TreeNode tNode) {   
        if (tNode != null) {   
            postOrder(tNode.llink);   
            postOrder(tNode.rlink);   
            System.out.print(tNode.info + " ");   
        }   
    }   
  
    public static void main(String[] args) {   
        Tree tree = new Tree();   
        System.out.println("insert tree start");   
        tree.insertBinaryTree(15);   
        tree.insertBinaryTree(5);   
        tree.insertBinaryTree(16);   
        tree.insertBinaryTree(3);   
        tree.insertBinaryTree(12);   
        tree.insertBinaryTree(20);   
        tree.insertBinaryTree(10);   
        tree.insertBinaryTree(13);   
        tree.insertBinaryTree(18);   
        tree.insertBinaryTree(23);   
        tree.insertBinaryTree(6);   
        tree.insertBinaryTree(7);   
        System.out.println("insert tree end");   
        System.out.println("print tree start");   
        tree.treeDelete(15);   
        tree.printTree();   
        System.out.println("print tree end");   
  
    }   
}     

package tree;   
  
/**  
 * @author B.Chen  
 */  
public class HuffmanTree {   
  
    /**  
     * 根节点  
     */  
    public TreeNode root;   
  
    /**  
     * 数组下表  
     */  
    public int nodeSize;   
  
    /**  
     * 长度  
     */  
    public int length;   
  
    /**  
     * 哈夫曼节点数组  
     */  
    public TreeNode[] nodeList;   
       
    /**  
     * 访问控制  
     */  
    public boolean[] visited;   
  
    /**  
     * @param length  
     */  
    public HuffmanTree(int length) {   
        this.length = length;   
        nodeList = new TreeNode[2 * length-1];   
        visited = new boolean[2*length-1];   
    }   
  
    /**  
     * @param info  
     */  
    public void addNode(int info) {   
        TreeNode tNode = new TreeNode();   
        tNode.info = info;   
        if (nodeSize < length) {   
            nodeList[nodeSize++] = tNode;   
        } else {   
            System.out.println("out of size");   
        }   
    }   
       
    /**  
     * 构造哈夫曼树  
     */  
    public void createHuffmanTree() {   
        int j = length;   
        while (nodeList[2*length -2] == null) {   
            TreeNode lNode = getMiniMumNode();   
            TreeNode rNode = getMiniMumNode();   
            TreeNode tNode = new TreeNode();   
            System.out.println(lNode.info + " " + rNode.info);   
            tNode.llink = lNode;   
            tNode.rlink = rNode;   
            tNode.info = lNode.info + rNode.info;   
            nodeList[j++] = tNode;   
        }   
        root = nodeList[2 * length - 2];   
    }   
       
    /**  
     * @return TreeNode  
     */  
    public TreeNode getMiniMumNode() {   
        TreeNode tNode = null;   
        int size = 0;   
        for(int i=0;i<2*length-1;i++) {   
            if(!visited[i] && nodeList[i] != null) {   
                tNode = nodeList[i];   
                size = i;   
                for(int j=0;j<2*length-1;j++) {   
                    if(!visited[j] && nodeList[j] != null) {   
                        if(tNode.info > nodeList[j].info) {   
                            tNode = nodeList[j];   
                            size = j;   
                        }   
                    }   
                }   
            }   
        }   
        visited[size] = true;   
        return tNode;   
    }   
       
    /**  
     * 中序遍历  
     *   
     * @param tNode  
     */  
    public void inOrder(TreeNode tNode) {   
        if (tNode != null) {   
            inOrder(tNode.llink);   
            System.out.print(tNode.info + " ");   
            inOrder(tNode.rlink);   
        }   
    }   
       
    /**  
     * 打印  
     */  
    public void printHuffmanTree() {   
        System.out.println("inOrder");   
        inOrder(root);   
    }   
       
    /**  
     * @param args  
     */  
    public static void main(String[] args) {   
        HuffmanTree hTree = new HuffmanTree(6);   
        hTree.addNode(4);   
        hTree.addNode(4);   
        hTree.addNode(4);   
        hTree.addNode(4);   
        hTree.addNode(5);   
        hTree.addNode(6);   
        hTree.createHuffmanTree();   
        hTree.printHuffmanTree();   
    }   
}  

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package graph;   
  
/**  
 * @author B.Chen  
 */  
public class LCS {   
  
    /**  
     * @param a  
     * @param b  
     * @return lcs string  
     */  
    public String lcs(String a, String b) {   
        if (a.length() == 0 || b.length() == 0) {   
            return "";   
        }   
        int[][] matrix = new int[a.length() + 1][b.length() + 1];   
        for (int i = 0; i < a.length() + 1; i++) {   
            matrix[i][0] = 0;   
        }   
        for (int i = 0; i < b.length() + 1; i++) {   
            matrix[0][i] = 0;   
        }   
        String[] arrayA = a.split("");   
        String[] arrayB = b.split("");   
        int maxloop = 0;   
        int position = 0;   
        for (int i = 1; i < a.length() + 1; i++) {   
            for (int j = 1; j < b.length() + 1; j++) {   
                if (arrayA[i - 1].equals(arrayB[j - 1])) {   
                    matrix[i][j] = matrix[i - 1][j - 1] + 1;   
                    if (matrix[i][j] > maxloop) {   
                        maxloop = matrix[i][j];   
                        position = i;   
                    }   
                } else {   
                    matrix[i][j] = 0;   
                }   
            }   
        }   
        StringBuffer result = new StringBuffer();   
        if (maxloop == 0) {   
            return "";   
        }   
        for (int i = position - maxloop; i < position; i++) {   
            result.append(arrayA[i]);   
        }   
        return result.toString();   
    }   
  
    /**  
     * @param a  
     * @param b  
     * @return int lcs length  
     */  
    public int maxLength(String a, String b) {   
        String length = lcs(a, b);   
        return length.length();   
    }   
  
}  

package graph;   
  
public class GraphNode {   
    public GraphNode link;   
    public int info;   
}  
package graph;   
  
public class GraphList {   
  
    public GraphNode first;   
    public GraphNode last;   
    public boolean visitable;   
    public int getAjd(int[] ajd) {   
        GraphNode current = first;   
        int length = 0;   
        while(current != null) {   
            ajd[length++] = current.info;   
            current = current.link;   
        }   
        return length;   
    }   
    public void addNode(int v) {   
        GraphNode node = new GraphNode();   
        node.info = v;   
        if(first == null) {   
            first = node;   
            last = node;   
        } else {   
            last.link = node;   
            last = node;   
        }   
    }   
}  
package graph;   
  
/**  
 * @author B.Chen  
 *  
 */  
public class Graph {   
  
    /**  
     * 节点数  
     */  
    private int length;   
  
    /**  
     * 链表  
     */  
    private GraphList[] list;   
  
    /**  
     * 权集  
     */  
    private int[][] weight;   
       
    /**  
     * 轻边集  
     */  
    private int[][] lightSide;   
       
    /**  
     * 等价类  
     */  
    private int[] replaceValue;   
  
    /**  
     * @param length  
     */  
    public Graph(int length) {   
        this.length = length;   
        list = new GraphList[length];   
        weight = new int[length][length];   
        lightSide = new int[length][length];   
        replaceValue = new int[length];   
        for(int i=0;i<length;i++) {   
            replaceValue[i] = i;   
            for(int j=0;j<length;j++) {   
                weight[i][j] = 9999;   
            }   
        }   
    }   
  
    /**  
     * @param v  
     */  
    public void dfs(int v) {   
        int[] ajd = new int[length];   
        int ajdlength = list[v].getAjd(ajd);   
        list[v].visitable = true;   
        System.out.print(v + " ");   
        for (int i = 0; i < ajdlength; i++) {   
            int w = ajd[i];   
            if (!list[w].visitable) {   
                dfs(w);   
            }   
        }   
    }   
  
    /**  
     * 深度优先遍历     
     */  
    public void dfsTravel() {   
        for (int i = 0; i < length; i++) {   
            list[i].visitable = false;   
        }   
        for (int i = 0; i < length; i++) {   
            if (!list[i].visitable) {   
                dfs(i);   
            }   
        }   
    }   
  
    /**  
     * 广度优先遍历   
     */  
    public void bfsTravel() {   
        for (int i = 0; i < length; i++) {   
            list[i].visitable = false;   
        }   
        bfs();   
    }   
  
    /**  
     * bfs  
     */  
    private void bfs() {   
        Queue queue = new Queue();   
        for (int index = 0; index < length; index++) {   
            if (!list[index].visitable) {   
                queue.addQueue(index);   
                list[index].visitable = true;   
                System.out.print(index + " ");   
                while (!queue.isEmpty()) {   
                    int temp = queue.front();   
                    queue.deleteQueue();   
                    int[] adj = new int[length];   
                    int ajdlength = list[temp].getAjd(adj);   
                    for (int i = 0; i < ajdlength; i++) {   
                        int w = adj[i];   
                        if (!list[w].visitable) {   
                            System.out.print(w + " ");   
                            queue.addQueue(w);   
                            list[w].visitable = true;   
                        }   
                    }   
                }   
            }   
  
        }   
    }   
  
    /**  
     * 长度     
     */  
    public void length() {   
        System.out.println(length);   
    }   
  
    /**  
     * @return boolean  
     */  
    public boolean isEmpty() {   
        return length == 0;   
    }   
  
    /**  
     * @param info  
     */  
    public void addGraph(int info) {   
        for (int i = 0; i < length; i++) {   
            if (list[i] == null) {   
                GraphList g = new GraphList();   
                g.addNode(info);   
                list[i] = g;   
                break;   
            }   
        }   
    }   
  
    /**  
     * 添加有向图的一条边  
     * @param vfrom  
     * @param vto  
     * @param value 权  
     */  
    public void addSide(int vfrom, int vto, int value) {   
        list[vfrom].addNode(vto);   
        weight[vfrom][vto] = value;   
    }   
  
    /**  
     * 添加无向图的一条边  
     * @param vfrom  
     * @param vto  
     * @param value  
     */  
    public void addDoubleSide(int vfrom, int vto, int value) {   
        list[vfrom].addNode(vto);   
        list[vto].addNode(vfrom);   
        weight[vfrom][vto] = value;   
        weight[vto][vfrom] = value;   
    }   
  
    /**  
     * 打印图     
     */  
    public void print() {   
        for (int i = 0; i < length; i++) {   
            GraphNode current = list[i].first;   
            while (current != null) {   
                System.out.print(current.info + " ");   
                current = current.link;   
            }   
            System.out.println();   
        }   
    }   
  
    /**  
     * Dijkstra  
     *   
     * @param v  
     * @return int[]  
     */  
    public int[] shortPath(int v) {   
        int[] shortPath = new int[length];   
        boolean[] weightFound = new boolean[length];   
        for (int i = 0; i < length; i++) {   
            // 趋近无穷   
            shortPath[i] = 9999;   
            weightFound[i] = false;   
        }   
        shortPath[v] = 0;   
        weightFound[v] = true;   
        Queue queue = new Queue();   
        queue.addQueue(v);   
        while (!queue.isEmpty()) {   
            int temp = queue.front();   
            queue.deleteQueue();   
            int[] ajd = new int[length];   
            int ajdlength = list[temp].getAjd(ajd);   
            for (int i = 0; i < ajdlength; i++) {   
                int w = ajd[i];   
                if (!weightFound[w]) {   
                    if (shortPath[w] > shortPath[temp] + weight[temp][w]) {   
                        shortPath[w] = shortPath[temp] + weight[temp][w];   
                    }   
                }   
            }   
            int minWeightNode = 0;   
            for (int i = 0; i < length; i++) {   
                if (!weightFound[i]) {   
                    minWeightNode = i;   
                    for (int j = 0; j < length; j++) {   
                        if (!weightFound[j]) {   
                            if (shortPath[j] < shortPath[minWeightNode]) {   
                                minWeightNode = j;   
                            }   
                        }   
                    }   
                    break;   
                }   
            }   
            if (!weightFound[minWeightNode]) {   
                weightFound[minWeightNode] = true;   
                queue.addQueue(minWeightNode);   
            }   
        }   
        return shortPath;   
    }   
       
    /**  
     * 普里姆最小生成树  
     *   
     * @param v  
     */  
    public void primMST(int v) {   
        boolean[] visited = new boolean[length];   
        for (int i = 0; i < length; i++) {   
            visited[i] = false;   
            for (int j = 0; j < length; j++) {   
                lightSide[i][j] = 9999;   
            }   
        }   
        visited[v] = true;   
        Queue queue = new Queue();   
        queue.addQueue(v);   
        while (!queue.isEmpty()) {   
            int temp = queue.front();   
            queue.deleteQueue();   
            int[] ajd = new int[length];   
            int ajdlength = list[temp].getAjd(ajd);   
            for (int i = 0; i < ajdlength; i++) {   
                int w = ajd[i];   
                lightSide[temp][w] = weight[temp][w];   
            }   
            // 找到最小边   
            int minSide = 0;   
            int vfrom =0;   
            int vto = 0;   
            for (int i = 0; i < length; i++) {   
                for (int j = 0; j < length; j++) {   
                    if (visited[i] && visited[j]) {   
                        continue;   
                    }   
                    minSide = lightSide[i][j];   
                    vfrom = i;   
                    vto = j;   
                    for (int k = 0; k < length; k++) {   
                        for (int l = 0; l < length; l++) {   
                            if (visited[k] && visited[l]) {   
                                continue;   
                            }   
                            if (lightSide[k][l] < minSide) {   
                                minSide = lightSide[k][l];   
                                vfrom = k;   
                                vto = l;   
                            }   
                        }   
                    }   
                    break;   
                }   
            }   
            //将最小边的节点vto设为true，并输出vto   
            if (!visited[vto]) {   
                visited[vto] = true;   
                System.out.print(vfrom+"==>" + vto+", ");   
                queue.addQueue(vto);   
            }   
        }   
    }   
       
    /**  
     * 克鲁斯卡尔最小生成树  
     */  
    public void kruskalMST() {   
        int m = 0;   
        while (m < length - 1) {   
            // 找到最小边   
            int minSide = 0;   
            int vfrom = 0;   
            int vto = 0;   
            for (int i = 0; i < length; i++) {   
                for (int j = 0; j < length; j++) {   
                    if (replaceValue[i] == replaceValue[j]) {   
                        continue;   
                    }   
                    minSide = weight[i][j];   
                    vfrom = i;   
                    vto = j;   
                    for (int k = 0; k < length; k++) {   
                        for (int l = 0; l < length; l++) {   
                            if (replaceValue[k] == replaceValue[l]) {   
                                continue;   
                            }   
                            if (weight[k][l] < minSide) {   
                                minSide = weight[k][l];   
                                vfrom = k;   
                                vto = l;   
                            }   
                        }   
                    }   
                    break;   
                }   
            }   
            if (replaceValue[vfrom] != replaceValue[vto]) {   
                System.out.print(vfrom + "==>" + vto + ", ");   
                for (int i = 0; i < length; i++) {   
                    if (replaceValue[i] == replaceValue[vfrom]) {   
                        replaceValue[i] = replaceValue[vto];   
                    }   
                }   
                m++;   
            }   
        }   
    }   
  
    /**    
     * @param args    
     */  
    public static void main(String[] args) {   
        Graph graph = new Graph(6);   
        System.out.println("create graph start");   
        for (int i = 0; i < 6; i++) {   
            graph.addGraph(i);   
        }   
        graph.addDoubleSide(0, 1, 1);   
        graph.addDoubleSide(0, 2, 8);   
        graph.addDoubleSide(0, 3, 7);   
        graph.addDoubleSide(1, 2, 5);   
        graph.addDoubleSide(1, 4, 5);   
        graph.addDoubleSide(1, 5, 4);   
        graph.addDoubleSide(1, 3, 10);   
        graph.addDoubleSide(2, 4, 3);   
        graph.addDoubleSide(4, 5, 6);   
        graph.addDoubleSide(5, 3, 2);   
        graph.print();   
        System.out.println("create graph end");   
        graph.kruskalMST();   
    }   
}  

/**  
 * 佛洛伊德最短路径  
 *   
 * @param v  
 * @return int[]  
 */  
public int[] floydShortPath(int v) {   
    // 初始化矩阵   
    int[][] spath = new int[length][length];   
    for (int i = 0; i < length; i++) {   
        for (int j = 0; j < length; j++) {   
            if (i == j) {   
                spath[i][j] = 0;   
            } else {   
                spath[i][j] = weight[i][j];   
            }   
        }   
    }   
    for (int i = 0; i < length; i++) {   
        for (int j = 0; j < length; j++) {   
            for (int k = 0; k < length; k++) {   
                if (spath[i][j] + spath[k][i] < spath[j][k]) {   
                    spath[j][k] = spath[i][j] + spath[k][i];   
                }   
            }   
        }   
    }   
    int[] resultArray = new int[length];   
    for (int i = 0; i < length; i++) {   
        resultArray[i] = spath[v][i];   
    }   
    return resultArray;   
  
}  

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package convex;   
  
public class Point {   
  
    public int x, y;   
  
    public Point(int x, int y) {   
        if (x > 7 || y > 7) {   
            throw new RuntimeException("out of matrix");   
        }   
        this.x = x;   
        this.y = y;   
    }   
  
    public String toString() {   
        return "x=" + x + ",y=" + y;   
    }   
  
}   

package convex;         
     
import java.io.BufferedReader;      
import java.io.IOException;      
import java.io.InputStreamReader;      
import java.util.StringTokenizer;      
     
import convex.Point;         
        
public class Algo {         
     
    private boolean[][] flg = new boolean[8][8];      
     
    private int[][] shortPath = new int[8][8];      
          
    //最短距离矩阵      
    public int[][] distanceSq(Point p1) {      
        djkst(p1);      
        return shortPath;      
    }      
     
    //BFS       
    private void djkst(Point p1) {      
        Point[] queue = new Point[64];      
        flg[p1.x][p1.y] = true;      
        queue[0] = p1;      
        int j=0;      
        int queueSize = 1;      
        while (j < queue.length) {      
                Point temp = queue[j];      
                Point[] list = getList(temp);      
                for(int i=0;i < list.length;i++) {      
                    if(list[i] != null) {      
                        Point w = list[i];      
                        if (!flg[w.x][w.y]) {      
                            shortPath[w.x][w.y] = shortPath[temp.x][temp.y] + 1;                                  
                            queue[queueSize++] = w;      
                            flg[w.x][w.y] = true;      
                        }      
                    }      
                }      
            j++;      
        }      
    }      
     
    //可行步数集         
    private static Point[] getList(Point point) {      
        Point[] list = new Point[8];      
        int length = 0;      
        if (point.x + 2 <= 7 && point.y + 1 <= 7) {      
            list[length++] = new Point(point.x + 2, point.y + 1);      
        }      
        if (point.x - 2 >= 0 && point.y - 1 >= 0) {      
            list[length++] = new Point(point.x - 2, point.y - 1);      
        }      
        if (point.x + 1 <= 7 && point.y + 2 <= 7) {      
            list[length++] = new Point(point.x + 1, point.y + 2);      
        }      
        if (point.x - 1 >= 0 && point.y - 2 >= 0) {      
            list[length++] = new Point(point.x - 1, point.y - 2);      
        }      
        if (point.x + 2 <= 7 && point.y - 1 >= 0) {      
            list[length++] = new Point(point.x + 2, point.y - 1);      
        }      
        if (point.x - 2 >= 0 && point.y + 1 <= 7) {      
            list[length++] = new Point(point.x - 2, point.y + 1);      
        }      
        if (point.x + 1 <= 7 && point.y - 2 >= 0) {      
            list[length++] = new Point(point.x + 1, point.y - 2);      
        }      
        if (point.x - 1 >= 0 && point.y + 2 <= 7) {      
            list[length++] = new Point(point.x - 1, point.y + 2);      
        }      
        return list;      
    }      
          
    public static int[] method(Point[] points, int i,int j,Object[] pointList) {         
        int maxDay = 0;         
        int distance = 0;      
        for(int k=0;k<pointList.length;k++) {      
            int day = ((int[][])pointList[k])[i][j];      
            distance += day;      
            if(maxDay<day) {      
                maxDay = day;      
            }      
        }      
        return new int[]{maxDay,distance};         
    }      
        
    public static void main(String[] args) throws IOException {      
        //数据输入      
        //数据输入格式：第一个数字是骑士n，第2，3个数字是第一个骑士的坐标，依次类推。      
        //每个数字之间以空格区分      
        BufferedReader stdin =       
            new BufferedReader(      
                new InputStreamReader(System.in));      
     
        String line = stdin.readLine();      
        StringTokenizer st = new StringTokenizer(line);      
        int pointLength = Integer.parseInt(st.nextToken());      
        Point[] points = new Point[pointLength];      
        for(int i=0;i<points.length;i++) {      
            int x = Integer.parseInt(st.nextToken());      
            int y = Integer.parseInt(st.nextToken());      
            points[i] = new Point(x,y);      
        }      
        Object[] pointList = new Object[points.length];      
        for (int j = 0; j < points.length; j++) {         
            pointList[j] = new Algo().distanceSq(points[j]);      
        }      
        int minDay = 999999999;      
        int minDistance = 999999999;        
        for(int i=0;i<7;i++) {      
            for(int j=0;j<7;j++) {      
                int[] result = Algo.method(points, i,j,pointList);         
                //找最短天数，最短天数相同，找最短距离      
                if (minDay > result[0]) {      
                    minDay = result[0];      
                    minDistance = result[1];      
                } else if(minDay == result[0]) {      
                    if(minDistance > result[1]) {      
                        minDistance = result[1];      
                    }      
                }      
            }      
        }      
        for(int i=0;i<7;i++) {      
            for(int j=0;j<7;j++) {      
                int[] result = Algo.method(points, i,j,pointList);    
                if(minDay == result[0] && minDistance == result[1]) {   
                    System.out.println(i+" " + j +" "+ minDay);   
                }   
            }   
        }    
    }      
}     

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师