美文网首页蓝桥杯动态规划
2015年第6届蓝桥杯Java B组省赛试题解析

2015年第6届蓝桥杯Java B组省赛试题解析

作者: 疯狂的冰块 | 来源:发表于2018-03-23 15:13 被阅读31次

    1、三角形面积

    如图1所示。图中的所有小方格面积都是1。
    那么,图中的三角形面积应该是多少呢?
    请填写三角形的面积。不要填写任何多余内容或说明性文字。

    image.png
    计算方法:
    8 * 8 - (8 * 2 / 2 + 6 * 4 / 2 + 8 * 4 / 2)= 64 - (8+ 12 + 16) =64-36=28
    

    2、立方变自身

    观察下面的现象,某个数字的立方,按位累加仍然等于自身。
    1^3 = 1
    8^3 = 512 5+1+2=8
    17^3 = 4913 4+9+1+3=17
    ...
    请你计算包括1,8,17在内,符合这个性质的正整数一共有多少个?
    请填写该数字,不要填写任何多余的内容或说明性的文字。

    public class CubeEqual {
        public static void main(String[] args) {
    
            int count = 0;
            for (int i = 1; i < 100; i++) {
                int s = i * i * i;
                if (i == fun(s)) {
                    System.out.println("i = " + i);
                    System.out.println("s = " + s);
                    System.out.println("fun(s) = " + fun(s));
                    count++;
                }
            }
            System.out.println("count = " + count);
        }
    
        static int fun(int a) {
            if (a < 10) {
                return a;
            }
            return fun(a / 10) + a % 10;
        }
    }
    
    答案:6
    

    3、三羊献瑞

    观察下面的加法算式


    image.png

    其中,相同的汉字代表相同的数字,不同的汉字代表不同的数字。
    请你填写“三羊献瑞”所代表的4位数字(答案唯一),不要填写任何多余内容。

    容易推测得到:
    三 => 1
    羊 => 0
    祥 => 9
    
    羊等于0,各个汉字不同,所以:生=瑞+1;
    
    由于 
    生+献=瑞 即: 瑞+1 +献=瑞 => 献等于8,或9,但是已经有祥等于9了,所献等于8.
    
    辉和瑞相加一定大与等于10,由以上推出的数字可得:
    
    辉,瑞 在[5,7 ] , [6, 7]两种可能之中。
    大约四种情况:代入等式去试一下,就能得出答案。
    
    答案:1085
    

    4、循环节长度

    两个整数做除法,有时会产生循环小数,其循环部分称为:循环节。
    比如,11/13=6=>0.846153846153..... 其循环节为[846153] 共有6位。
    下面的方法,可以求出循环节的长度。

    请仔细阅读代码,并填写划线部分缺少的代码。

    public static int f(int n, int m)
    {
        n = n % m;  
        Vector v = new Vector();
        
        for(;;)
        {
            v.add(n);
            n *= 10;
            n = n % m;
            if(n==0) return 0;
            if(v.indexOf(n)>=0)  _________________________________ ;  //填空
        }
    }
    

    注意,只能填写缺少的部分,不要重复抄写已有代码。不要填写任何多余的文字。

    答案: return v.size()-v.index(n)
    

    这一题非常容易漏掉v.index(n); 主要的原因是,比如20/7,和200/7 的循环节其实是一样的,但是v.size()是不一样的。

    5、 九数组分数

    1,2,3…9 这九个数字组成一个分数,其值恰好为1/3,如何组法?

    下面的程序实现了该功能,请填写划线部分缺失的代码。

    public class A
    {
        public static void test(int[] x)
        {
            int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
            int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]*10 + x[8];     
            if(a*3==b) System.out.println(a + " " + b);
        }
    
        public static void f(int[] x, int k)
        {
            if(k>=x.length){
                test(x);
                return;
            }
    
            for(int i=k; i<x.length; i++){
                {int t=x[k]; x[k]=x[i]; x[i]=t;}
                f(x,k+1);
                _______________________________________       // 填空
            }
        }
    
        public static void main(String[] args)
        {
            int[] x = {1,2,3,4,5,6,7,8,9};      
            f(x,0);
        }
    }
    

    咋一看,这一题好像很难,但是其实如果熟悉排列的写法,这题很简单。我们来看一下对一组数字进行排列的示例代码:

    /**
     * 该类主要用户打印排列
     *
     * @author yunqing_shui@163.com
     */
    public class Main {
        public static int count = 0;
    
        public static void main(String[] args) {
            int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
            per(a, 0, 4);
            System.out.println(count);
        }
    
        public static void swapTwoNumber(int a[], int i, int j) {
            if (i != j) {
                a[i] ^= a[j];
                a[j] ^= a[i];
                a[i] ^= a[j];
            }
        }
    
        /**
         * @param a
         * @param index 数组的起始位置
         * @param len   要排列的长度
         */
        public static void per(int a[], int index, int len) {
            if (index == len) {
                print(a, len);
            }
            for (int i = index; i < len; i++) {
                // 交换两个数
                swapTwoNumber(a, index, i);
                per(a, index + 1, len);
                // 交换两个数
                swapTwoNumber(a, index, i);
            }
        }
    
        public static void print(int a[], int len) {
            for (int i = 0; i < len; i++) {
                System.out.print(a[i]);
            }
            count++;
            System.out.println();
        }
    }
    

    该题的题目意思很简单,由函数test(int[] x)得出,取出4个作为分子,取出五个作为分母。然后验证是否等于三分之一,所以本质上就是对9个数字作排列,前4个作为分子,后5个作为分母。那么分析到这里。就很简单了。我们对比以下排列的核心代码

       for (int i = index; i < len; i++) {
                // 交换两个数
                swapTwoNumber(a, index, i);
                per(a, index + 1, len);
                // 交换两个数
                swapTwoNumber(a, index, i);
            }
    
      for(int i=k; i<x.length; i++){
                {int t=x[k]; x[k]=x[i]; x[i]=t;}
                f(x,k+1);
                _______________________________________       // 填空
            }
    

    就能得出横线部分就是交换数组中的两个数。

    答案:{int t=x[k]; x[k]=x[i]; x[i]=t;}
    

    6、加法变乘法

    我们都知道:1+2+3+ … + 49 = 1225
    现在要求你把其中两个不相邻的加号变成乘号,使得结果为2015

    比如:
    1+2+3+…+10 * 11+12+…+27*28+29+…+49 = 2015
    就是符合要求的答案。

    请你寻找另外一个可能的答案,并把位置靠前的那个乘号左边的数字提交(对于示例,就是提交10)。

    注意:需要你提交的是一个整数,不要填写任何多余的内容。

    这一题没有什么技术含量,暴力破解就行。

    /**
     *
     * @author yunqing_shui@163.com
     */
    public class Main6 {
    
        public static void main(String[] args) {
            int a[] = new int[49];
            for (int i = 0; i < 49; i++) {
                a[i] = i+1;
            }
    
            int b[] = new int[47];
    
            for (int x = 0; x < 46; x++) {
                for (int y = x + 2; y <= 48; y++) {
    
                    for (int i = 0, j = 0; i < 47 && j < 49; i++, j++) {
                        if (i == x || i == y) {
                            int s = a[j] * a[j + 1];
                            b[i] = s;
                            j++;
                        } else {
                            b[i] = a[j];
                        }
                    }
    
                    if (sum(b) == 2015) {
                        System.out.println("x = " + (x+1));
                        System.out.println("y = " + (y+2));
                        System.out.println("Arrays.toString(a) = " + Arrays.toString(a));
                        System.out.println("Arrays.toString(b) = " + Arrays.toString(b));
                    }
                }
            }
    
            System.out.println("sum = " + sum(b));
        }
    
        public static int sum(int a[]) {
            int s = 0;
            for (int i = 0; i < a.length; i++) {
                s += a[i];
            }
            return s;
        }
    }
    
    
    答案:16
    

    7、牌型种数

    小明被劫持到X赌城,被迫与其他3人玩牌。
    一副扑克牌(去掉大小王牌,共52张),均匀发给4个人,每个人13张。
    这时,小明脑子里突然冒出一个问题:
    如果不考虑花色,只考虑点数,也不考虑自己得到的牌的先后顺序,自己手里能拿到的初始牌型组合一共有多少种呢?

    请填写该整数,不要填写任何多余的内容或说明文字。

    在网上发现了dfs的方法,非常简洁

    public class Seven3 {
    
        public static int ans = 0;
    
        static void dfs(int type, int sum) {
            if (sum > 13) return;
            if (type == 13) {
                if (sum == 13) ans++;
                return;
            }
            for (int i = 0; i < 5; i++) {
                dfs(type + 1, sum + i);
            }
        }
    
        public static void main(String[] args) {
            dfs(0, 0);
            System.out.println("ans = " + ans);
        }
    }
    

    2、线性规划的解法

    在网上看到有大神用线性规划来求解问题,佩服不已,代码简洁高效,贴出代码以供观摩。

    public class Seven {
    
        public static void main(String[] args) {
            int[][] dp = new int[14][14];
            dp[0][0] = 1;
            for (int i = 1; i < 14; i++)
                for (int j = 0; j < 14; j++)
                    for (int k = 0; k < 5; k++)
                        if (j + k <= 13)
                            dp[i][j + k] += dp[i - 1][j];
            System.out.println(dp[13][13]);
        }
    }
    

    还有另外一种写法:

    public class Seven2 {
    
        public static void main(String[] args) {
            int dp[][] = new int[14][14];
            dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = dp[1][4] = 1;
    
            for (int i = 2; i <= 13; i++) {
                for (int j = 0; j <= 13; j++) {
                    if (j - 4 >= 0) dp[i][j] += dp[i-1][j-4];
                    if (j - 3 >= 0) dp[i][j] += dp[i-1][j-3];
                    if (j - 2 >= 0) dp[i][j] += dp[i-1][j-2];
                    if (j - 1 >= 0) dp[i][j] += dp[i-1][j-1];
                    dp[i][j] += dp[i-1][j];
                }
            }
            System.out.println(dp[13][13]);
        }
    }
    

    主要的思路是

    假设牌是从1到13按顺序取的,dp[i][j]表示取到牌数为i的牌,j表示目前一共取了多少张牌。
    比如d[3][4] , 则i=3, j = 4 , 表示从A,2,3三种(i=3)牌中(每种4张,红桃、方块、黑桃、梅花)取出4(j=4)张 。
    我们最重要的是确认递归方程:从第一张牌开始,每种牌都有5种可能:
    1、这种牌取0个
    2、这种牌取1个
    3、这种牌取2个
    4、这种牌取3个
    5、这种牌取4个

    首先我们需要推导出状态转换方程。

    决策过程如下图:

    决策过程

    由上图我们看出:

      dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = dp[1][4] = 1;
    

    dp[2][0] = dp[1][0] =1 ;

    image.png

    由上图我们得到:
    dp[2][1] = dp[1][0] +dp[1][1] ;

    image.png

    同样的对于dp[2][2]
    dp[2][2] = dp[1][0] +dp[1][1]+dp[1][2] ;

    image.png

    dp[2][3] = dp[1][0] +dp[1][1]+dp[1][2]+d[1][3] ;

    类似的:

    dp[2][4] = dp[1][0] + dp[1][1] + dp[1][2] + dp[1][3] + d[1][4] ;
    dp[2][5] = dp[1][1] + dp[1][2] + dp[1][3] + dp[1][4] + d[1][5] ;
    说明:dp[1][5]为不可能事件,所以为0. dp[1][5]就是一种牌里取出5个的意思。

    由此我们归纳得出状态转移方程如下(没有加限制条件):


    状态转移方程

    得出转移方程,我们就知道如何决策了。d[13][13]即13种牌,取出13张的总数。

    回头看一看代码,基本明白了作者的思路:

    public class Seven2 {
    
        public static void main(String[] args) {
            int dp[][] = new int[14][14];
            dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = dp[1][4] = 1;
    
            for (int i = 2; i <= 13; i++) {
                for (int j = 0; j <= 13; j++) {
                    if (j - 4 >= 0) dp[i][j] += dp[i-1][j-4];
                    if (j - 3 >= 0) dp[i][j] += dp[i-1][j-3];
                    if (j - 2 >= 0) dp[i][j] += dp[i-1][j-2];
                    if (j - 1 >= 0) dp[i][j] += dp[i-1][j-1];
                    dp[i][j] += dp[i-1][j];
                }
            }
            System.out.println(dp[13][13]);
        }
    }
    

    第三种解法

    以下是我的方法,思路是先求牌的个数,如单张的有多少个,对子有多少个,三个的有多少个,四个的有多少个,0个的有多少个。
    然后求排列,比较繁琐一些,但是也能解决问题。

    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author yunqing_shui@163.com
     */
    public class Main7 {
        public static int S = 0;
    
        public static void main(String[] args) {
    
    
            ArrayList<Integer> list0 = new ArrayList<>();
            for (int i = 0; i < 4; i++) {
                ArrayList<Integer> list1 = new ArrayList<>(list0);
                for (int j = 0; j < 5; j++) {
                    ArrayList<Integer> list2 = new ArrayList<>(list1);
                    for (int k = 0; k < 7; k++) {
                        ArrayList<Integer> list3 = new ArrayList<>(list2);
                        for (int l = 0; l < 14; l++) {
                            sumList(list3);
                            list3.add(1);
                        }
                        list2.add(2);
                    }
                    list1.add(3);
                }
                list0.add(4);
            }
            System.out.println("S = " + S);
    
        }
    
        public static void sumList(List<Integer> list) {
            int sum = 0;
            for (int i : list) {
                sum += i;
            }
            int a4 = 0;
            int a3 = 0;
            int a2 = 0;
            int a1 = 0;
            if (sum == 13) {
                for (int it : list) {
                    if (it == 1) {
                        a1++;
                    } else if (it == 2) {
                        a2++;
                    } else if (it == 3) {
                        a3++;
                    } else if (it == 4) {
                        a4++;
                    }
                }
                int number = getCNM(13, a1) * getCNM(13 - a1, a2) * getCNM(13 - a1 - a2, a3) * getCNM(13 - a1 - a2 - a3, a4);
                S += number;
            }
    
        }
    
        public static int getANM(int a, int b) {
            int s = 1;
            for (int i = a; i > Math.max(b, a - b); i--) {
                s *= i;
            }
            return s;
        }
    
        public static int getCNM(int a, int b) {
            return getANM(a, b) / getN(Math.min(b, a - b));
        }
    
        public static int getN(int a) {
            if (a == 1 || a == 0) {
                return 1;
            }
            return a * getN(a - 1);
        }
    }
    
    

    相关文章

      网友评论

      本文标题:2015年第6届蓝桥杯Java B组省赛试题解析

      本文链接:https://www.haomeiwen.com/subject/rbqxcftx.html