吸血鬼数求解的思考

  求解吸血鬼数，这是第四章末尾的一道练习题，本来我是没在意的，结果我忘了vampire的写法……这一做问题还不少，尤其算法对程序效率的影响，我是第一次如此直观的感受到，下面贴三段代码，分别是官方答案，我的解法，网络上的另一种解法（括号中的方法名称，是我根据方法特点粗浅概括的）：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 找出全部4位吸血鬼数
 * @author pc
 *
 */
public class VampireNumberTest {
    public static void main(String[] args) {
        long s1 = System.nanoTime();  
        test1(); 
        long e1 = System.nanoTime();  
        System.out.println("=======test1 :" + (d1 - e1));      
        long s2 = System.nanoTime();  
        test2(); 
        long e2 = System.nanoTime();  
        System.out.println("=======test2 :" + (d2 - e2));

        long s3 = System.nanoTime();  
        method3();  
        long e3 = System.nanoTime();  
        System.out.println("=======method3 :" + (d3 - e3));
    }

    /**
     * 官方答案(双数组循环比较法)
     */
    private static void method3() { // 官方参考答案  

        int[] startDigit = new int[4];  
        int[] productDigit = new int[4];  
        int c =0;   //循环主体执行次数
        for (int num1 = 10; num1 <= 99; num1++)  
            for (int num2 = num1; num2 <= 99; num2++) {  
                if ((num1 * num2) % 9 != (num1 + num2) % 9)  //移项 即为 (num1*num2-num1-num2)%9 != 0
                    continue;  
                c++;
                int product = num1 * num2;  
                startDigit[0] = num1 / 10;  
                startDigit[1] = num1 % 10;  
                startDigit[2] = num2 / 10;  
                startDigit[3] = num2 % 10;  
                productDigit[0] = product / 1000;  
                productDigit[1] = (product % 1000) / 100;  
                productDigit[2] = product % 1000 % 100 / 10;  
                productDigit[3] = product % 1000 % 100 % 10;  
                int count = 0;    //数字相等次数(更改次数)
                for (int x = 0; x < 4; x++)  
                    for (int y = 0; y < 4; y++) {  
                        if (productDigit[x] == startDigit[y]) {  
                            count++;  
                            productDigit[x] = -1;   //  -1, -2均无实际意义，只作为更改标记 ，以避免重复比较
                            startDigit[y] = -2;       
                            if (count == 4)  
                              System.out.println(num1 + " * " + num2 + " : "  + product);  
                        }  
                    }  

            }
        System.out.println("循环主体执行次数 ："+c);
    }  

    /**
     * 我的实践(集合删数法)
     */
    private static void test1() {   
        int[] multiplierNums = new int[4];   //封装组成两个两位数的4个数字
         List<Integer> productNums = new ArrayList<>();  //封装乘积千、百、十、个各位
        int c = 0;  //循环主体执行次数
        for(int j = 10; j<100;j++) {
            for(int k = j ; k<100 ; k++) {    // 令 k = j 可以去重，约消减三分之一的运行时间开销
                int product = j*k;  //计算乘积
                if( product>1000 && product<10000 && product%100 != 0 && (j * k - j - k) % 9 == 0 ) { //乘积筛选
                    c++;
                    /*初始化乘子数组*/
                    multiplierNums[0] =  j/10;
                    multiplierNums[1] =  j%10;
                    multiplierNums[2] =  k/10;
                    multiplierNums[3] = k%10;
                    /*初始化乘积数字集合*/
                    int productClone = product;
                    for (int i = 0 ; i <4;i++) {
                        productNums.add(productClone%10);
                        productClone/=10;
                    }
                    /*遍历乘子数组，如果乘积各位数字中包含两个乘子的组成数字，则将该数字从乘积各位数字集合中删除 (遍历数组，更改集合，规避并发修改异常)*/
                    for (Integer i : multiplierNums) {
                        if(productNums.contains(i)) {  
                            productNums.remove(i);
                        }
                    }
                    /*如果集合为空(删除执行了四次，即满足吸血鬼数的条件)*/
                    if(productNums.isEmpty()) {  
                        System.out.println(j + "*" + k + "=" + product);
                    }else {
                        productNums.clear();  //清空集合以不干扰下次流程
                    }
                }
            }
        }
         System.out.println("循环主体执行次数 ："+c);
    }

    /**
     * 其他答案(双数组排序比较法)
     */
    private static void test2() {   
        int c = 0;   //循环主体执行次数
        for (int i = 10; i <= 99; i++) {
            //for (int j = i + 1 ; j <= 99; j++) {  //原程序 +1 以排除平方数，但许多平方数是能够满足“余9”算法的，所以需要涵盖并进行进一步校验
            for (int j = i  ; j <= 99; j++) {  
                 // 计算出所有两位数的积
                 int sum = i * j;
                // if (sum <= 9999 && sum >= 1000) {   //原程序  
                 if( sum>1000 && sum<10000 && sum%100 != 0 && (i*j - i - j) % 9 == 0 ) {   //用算法改进
                     c++;
                      String[] t1 = (sum + "").split("");
                      // 对数组t1进行升序排列
                      Arrays.sort(t1);
                      // 这个地方，把i和j都当String型的字符串加起来组成一个四位数
                      String[] t2 = ("" + i + j).split("");
                      // 对t2进行升序排列
                      Arrays.sort(t2);
                      //下面判断是通过两个已经排好序的数组相比较，当完全相同时执行
                      if (Arrays.equals(t1, t2)) {
                          System.out.println(i + "*" + j + "=" + i * j);
                      }
                 }
            }
        }
        System.out.println("循环主体执行次数 ："+c);
    }

}

  必须要对程序中所用到的算法进行解释，我概括为“余9”算法，也不知是哪位前辈高人想出的这种定律…
  吸血鬼数：位数为偶数，由一对数字相乘而得，且这对数字各包含乘积一半位数的数字，数字可任意排序，不允许以两个零结尾，如：
1260 = 21 * 60；
1827 = 21 * 87；
2187 = 27 * 81；

  现假设乘积 product 为 1000a + 100b + 10c + d (即abcd分别为千百十个位数字)，由吸血鬼数的特点，两个乘子可以为 x=10a+b，y=10c+d。（如不理解请一定停下，回头再看吸血鬼数定义和举例。另外注意：我说的是“可以为”，并不是“一定为”，这只是一种组合方式，如果你想用x=10a+c, y=10b+d等等亦可，结论是一致的。）那么有：product - x - y =990a + 99b = 9(110a + 11b) , 之所以这样提取公因式，是为了强调 ， 这个差是9的倍数！ ，其他排列组合的情况相同，该差都是9的倍数。至此，算法解释完毕。就这么一个小规律，放在主流程的外面，拦截了相当大一部分的不必要校验，消减了三分之二的时间开销，极大提升了程序效率！其他细节的解释说明，已在程序中注释清楚。
  关于程序执行效率的问题，官方双数组进行循环比较的效率是最高的（500000-700000），我的做法由于使用了List集合（底层是数组），所以效率较差，耗时约是官方的3-5倍（2100000-2500000），当然，程序中是以毫微秒（纳秒）为单位，所以实际上还好，我还是习惯用集合的一系列方法，而不是循环嵌套来比较数组元素，这就牺牲了一定的效率，最后一种方法，虽然耗时更长些（约是官方答案的20余倍），但也不失为一种清晰简单的好思路，相比心疼机器，我觉得还是心疼程序员的脑细胞更实在些…..
  另外官方的筛选条件中没有涵盖四位数的判断（10*10=100, 99*99=9801所有乘积满足上限，但部分数不满足下限），以及两个0结尾的拦截，致使一些不必要的数字能够执行主流程，我已在我的程序入口加以拦截，从流程执行次数可以看出是有效的。
  以上。