今天把答案放出。
这段代码是从去年年初的邮件里扫出来的，由于手头没数据集，没有再调试一下。不过当时都是全通过的，应该没啥问题。下面来简单的说一下思想：
针对input来看，其实就是有一棵或多棵现成的树，目的就是把每个节点的左右两个分支配平。
由于子节点的配平会影响到父节点的配平，所以很自然的就想到了用递归的方法来解这个问题。
整个递归过程就是一个树的后序遍历过程。

话说这代码缩进好像有点问题- -

调整了代码缩进，加入必要注释

package PhoneInterview;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Balance {
    // 每个天秤的属性
    public boolean balanced = false;// 判断是否已经配平
    public int nodeID;// 天秤id
    public Balance[] leftChild = null;// 左子树的天秤数组
    public Balance[] rightChild = null;// 右子树的天秤数组
    public int balanceWeight = 10;// 自身重量
    public int leftWeight = 0;// 左子树总重量
    public int rightWeight = 0;// 右子树总重量
    public int adding = 0;// 为了配平，还需添加多少重量的砝码

    // 递归函数
    public static int balancing(Balance node) {
        // 判断天秤左边是否有子天秤
        if (node.leftChild != null) {
            for (int i = 0; i < node.leftChild.length; i++)
                node.leftWeight += balancing(node.leftChild[i]);
        }
        // 判断天秤右边是否有紫天秤
        if (node.rightChild != null) {
            for (int i = 0; i < node.rightChild.length; i++) {
                node.rightWeight += balancing(node.rightChild[i]);
            }
        }
        // 天秤左右子树都计算完毕，来计算当前天秤左右重量差
        node.adding = Math.abs(node.leftWeight - node.rightWeight);
        // 标记该天秤已经配平
        node.balanced = true;
        return node.balanceWeight + node.leftWeight + node.rightWeight
                + node.adding;
    }

    // 主函数
    public static void main(String[] args) {
        int N = 0;
        Balance[] Balances;
        BufferedReader br;
        try {
            // 载入数据，初始化过程，无视这个file name吧
            br = new BufferedReader(new FileReader("input00.txt"));
            // load第一行，得到天秤总数
            String string = br.readLine();
            N = Integer.parseInt(string);
            // 初始化Balances数组
            Balances = new Balance[N];
            int i = 0;
            for (int k = 0; k < N; k++) {
                Balances[k] = new Balance();
                Balances[k].nodeID = k;
            }
            /*
             * 开始一行一行的读入数据，每两行一个循环
             */
            while ((string = br.readLine()) != null) {
                // 天秤左半部分初始化
                String[] strs = string.split(" ");
                Balances[i].leftWeight = Integer.parseInt(strs[0]);
                /*
                 * 这里是根据数据格式来的 如果length超过1，那就代表除了自重的值以外 还有放置的子天秤
                 * 遂初始化子树上的数组，添加对子天平的引用，方便日后调用
                 */
                if (strs.length != 1)
                    Balances[i].leftChild = new Balance[strs.length - 1];
                for (int j = 1; j < strs.length; j++) {
                    Balances[i].leftChild[j - 1] = Balances[Integer
                            .parseInt(strs[j])];
                }
                // 天秤右半部分初始化
                string = br.readLine();
                String[] strs1 = string.split(" ");
                Balances[i].rightWeight = Integer.parseInt(strs1[0]);
                // 同理左半部分的操作
                if (strs1.length != 1)
                    Balances[i].rightChild = new Balance[strs1.length - 1];
                for (int j = 1; j < strs1.length; j++) {
                    Balances[i].rightChild[j - 1] = Balances[Integer
                            .parseInt(strs1[j])];
                }
                i++;
            }

            // 初始化完毕，开始配平
            for (i = 0; i < Balances.length; i++) {
                if (!Balances[i].balanced)
                    Balance.balancing(Balances[i]);
            }

            // 输出结果
            for (int m = 0; m < Balances.length; m++) {
                if (Balances[m].leftWeight < Balances[m].rightWeight)
                    System.out.println(m + ": " + Balances[m].adding + " 0");
                else if (Balances[m].leftWeight >= Balances[m].rightWeight)
                    System.out.println(m + ": 0 " + Balances[m].adding);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}