USACO 1.3.4 Prime Cryptarithm 牛式 JAVA实现

也许我要从CSDN转移到这里来了。

 

这道题可以很自然地想到，得到用到的数字后，把这些数字对每一个的位置的情况进行遍历，两个月前我用C++做题时打算这么做过，后来因为严重超时而放弃；另一种方式就巧妙多了：既然数字的位数已经指定了, 可以遍历三位数与二位数的组合，再从中选择符合条件的。

总得来说是第一个for循环遍历所有三位数，判断这个三位数是不是由可用数字组成的；如果是，那么进入第二个for循环遍历二位数，判断二位数的是否由可用数字组成；接着判断三位数和二位数的个位的乘积，三位数和二位数十位的乘积，总的乘积。注意每个乘积都有位数要求，所以不妨增加个大小限制，相当于进行了剪枝。

 

针对JAVA的特性，我觉得最方便的是判断三位数每个位置上的数字是不是可用的数字，在这里可以把包装器类的Integer转化成字串，再通过toString以及charAt获取指定位置上的数字。至于具体的判断方式，我的做法是用一个标记数组，如果9是可用的，那么num[9]就是true。

 

package primeCrypt;

import java.util.Arrays;
import java.util.Scanner;

//输入数据
//    输入第一个数字
//    输入接下来的可用数字
//    运用标记
//        数字标记数组
//
//遍历所有三位数
//    遍历所有二位数
//    检查第一个步骤积
//    检查第二个步骤积
//    检查最终的结果 四位


public class Main {
    static int n;
    static boolean[] numbers= new boolean[10];
    public static void main(String[] args) {
        Scanner console= new Scanner(System.in);
        n= console.nextInt();
        
        for(int i=0; i<10; i++) {//初始化
            numbers[i]= false;
        }
        
        int num;
        for(int i=0;i<n; i++) {//设置有效数字
            num= console.nextInt();
            numbers[num]= true;
        }
        
        int countN= 0;
        for(Integer i=100; i<=999; i++) {
            boolean signOk1= true;
            //讨论三位数可行性
            for(int s=0; s<=2; s++) {
                if(numbers[i.toString().charAt(s)-'0']==false) {
                    signOk1= false;break;
                    }
                }
            if(signOk1== false) continue;//不可行提前终止
            
            //讨论二位数可行性
            for(Integer j=10; j<=99; j++) {
                boolean signOk2= true;
                for(int s=0; s<=1; s++) {
                    if(numbers[j.toString().charAt(s)-'0']==false) {
                        signOk2= false;break;
                    }
                }
                if(signOk2== false) continue;//不可行提前终止        
                
            //讨论第一个积的可行性
                boolean signOk3= true;
                Integer prdt1= i* (j.toString().charAt(1)-'0');
                if(prdt1>999) continue;
                for(int s=0; s<=2; s++) {
                    if(numbers[prdt1.toString().charAt(s)-'0']==false) {
                        signOk3= false;
                    }
                }
                if(signOk3== false)continue;
                
            //讨论第二个积的可行性
                boolean signOk4= true;
                Integer prdt2= i* (j.toString().charAt(0)-'0');
                if(prdt2>999) continue;
                for(int s=0; s<=2; s++) {
                    if(numbers[prdt2.toString().charAt(s)-'0']==false) {
                        signOk4= false;
                    }
                }
                if(signOk4== false)continue;
                
                //讨论第三个积的可行性
                boolean signOk5= true;
                Integer prdt3= i* j;
                if(prdt3>9999) continue;
                for(int s=0; s<=2; s++) {
                    if(numbers[prdt3.toString().charAt(s)-'0']==false) {
                        signOk5= false;
                    }
                }
                
                if(signOk5== true) countN++;
            }
        }
        System.out.println(countN);
    }
}