1-9自然数，可以组成3个3位数（数字不能重复使用），要求这三个三位数满足1:2:3,

Question

1-9自然数，可以组成3个3位数（数字不能重复使用），要求这三个三位数满足1:2:3,
写出实现逻辑和程序。
求代码！

Answer 1

这个有点意思
[code="java"] private static TreeSet set = new TreeSet();
/**
* @param args
*/
public static void main(String[] args) throws Exception {

    int[] data = new int[]{1,2,3,4,5,6,7,8,9};
    int[] used = new int[3];
    for (int i=0; i<used.length; i++){
        // 用 -1 来表示未使用
        used[i] = -1;
    }
    // 计算排列数
    calcPermutation(data, used, 0, 3);
    // 
    int second = 0;
    int third = 0;
    for (Integer first : set){
        second = first * 2;
        third = first * 3;
        if (set.contains(second) && set.contains(third)){
            // 检查是否有重复数字
            if (isUnique(first, second, third)){
                System.out.println(first + ", " + second + ", " + third);
            }
        }
    }

}
/**
 * 计算排列数
 * @param data 原始数组
 * @param used 存储一组解的下标
 * @param level 当前层次 [0, deep]
 * @param deep 排列深度 [level, min(used.length, data.length)]
 */
public static void calcPermutation(int[] data, int[] used,
        int level, int deep){
    if (level == deep){
        // 完成一组解
        output(data, used);
        return;
    }
    // 计算当前层的下一个可用值
    int next = getNext(used, level, data.length);
    while (next != -1){
        // 为当前层赋值
        used[level] = next;
        // 处理下一层
        calcPermutation(data, used, level + 1, deep);
        // 回溯时将下一层还原
        if (level + 1 < used.length){
            used[level + 1] = -1;
        }
        next = getNext(used, level, data.length);
    }
}
/**
 * 获取下一个未使用的值
 * @param used 存储一组解的下标
 * @param level 当前层次 [0, used.length)
 * @param length 
 * @return
 */
private static int getNext(int[] used, int level, int length) {
    int result = -1;
    for (int i=used[level] + 1; i<length; i++){
        // 标记当前下标是否已经使用过
        boolean available = true;
        for (int j=0; j<=level; j++){
            if (i == used[j]){
                available = false;
                break;
            }
        }
        if (available){
            result = i;
            break;
        }
    }
    return result;
}
/**
 * 输出一组解
 * @param data
 * @param used
 */
private static void output(int[] data, int[] used) {
    int result = 0;
    for (byte i=0; i<used.length; i++){
        result = result * 10 + data[used[i]];
    }
    set.add(result);
}
/**
 * 判断数字是否唯一
 * @param args
 * @return
 */
private static boolean isUnique(int... args){
    Set<Integer> tmp = new HashSet<Integer>();
    for (int arg : args){
        int first = arg / 100;
        arg = arg%100;
        int second = arg / 10;
        int third = arg%10;
        if (tmp.contains(first) || tmp.contains(second) 
                || tmp.contains(third)){
            return false;
        }
        tmp.add(first);
        tmp.add(second);
        tmp.add(third);
    }
    return true;
}[/code]

// 输出
[code="html"]192, 384, 576
219, 438, 657
273, 546, 819
327, 654, 981[/code]