2014年 蓝桥杯决赛(Java)

Posted piaocoder

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2014年 蓝桥杯决赛(Java)相关的知识,希望对你有一定的参考价值。

国王的遗产

 

     X国是个小国。国王K有6个儿子。在临终前,K国王立下遗嘱:国王的一批牛作为遗产要分给他的6个儿子。

    其中,大儿子分1/4,二儿子1/5,三儿子1/6,....

    直到小儿子分1/9。

    牛是活的,不能把一头牛切开分。

    最后还剩下11头牛,分给管家。

    请计算国王这批遗产中一共有多少头牛。

    这是一个整数,请通过浏览器提交答案,不要填写任何多余的内容(比如说明性的文字)

 

2520

 

public class Main{
    public static void main(String[] args) {  
        int sum = 4*5*6*7*8*9;
        int x = sum/4+sum/5+sum/6+sum/7+sum/8+sum/9;
        System.out.println(11*sum/(sum-x));
    }
}

 

六角幻方(搜索)

    把 1 2 3 ... 19 共19个整数排列成六角形状,如下:

    * * *

   * * * *

  * * * * *

   * * * *

    * * *

    要求每个直线上的数字之和必须相等。共有15条直线哦!

    再给点线索吧!我们预先填好了2个数字,第一行的头两个数字是:15 13,参见下图,黄色一行为所求。

 

 

    请你填写出中间一行的5个数字。数字间用空格分开。

   这是一行用空格分开的整数,请通过浏览器提交答案,不要填写任何多余的内容(比如说明性的文字等)

 

9 6 5 2 16

 

public class Main{
	static int[] table = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};  
    
    public static void main(String[] args){  
        int arr[] = new int[16];  
        boolean[] vis = new boolean[20];  
        vis[15] = vis[13] = vis[10] = true;  
        dfs(arr,0,vis);  
    }  
      
    static void dfs(int[] arr,int step, boolean[] vis){  
        if(step == 4){  
            if(arr[0]+arr[1]+arr[2]+arr[3] != 38)  
                return ;  
        }else if(step == 5){  
            if(15+arr[0]+arr[4] != 38)  
                return ;  
        }else if(step == 9){  
            if(arr[4]+arr[5]+arr[6]+arr[7]+arr[8] != 38 ||   
                    10+arr[3]+arr[8] != 38)  
                return ;  
        }else if(step == 10){  
            if(13+arr[1]+arr[5]+arr[9] != 38)  
                return ;  
        }else if(step == 13){  
            if(arr[9]+arr[10]+arr[11]+arr[12] != 38 ||  
                    13+arr[2]+arr[7]+arr[12] != 38)  
                return ;  
        }else if(step == 14){  
            if(10+arr[2]+arr[6]+arr[10]+arr[13] != 38 ||  
                    arr[4]+arr[9]+arr[13] != 38)  
                return ;  
        }  
        else if(step == 15){  
            if(arr[0]+arr[5]+arr[10]+arr[14] != 38 ||  
                    arr[3]+arr[7]+arr[11]+arr[14] != 38)  
                return ;  
        }  
        else if(step == 16){  
            if(arr[13]+arr[14]+arr[15] != 38 ||  
                    15+arr[1]+arr[6]+arr[11]+arr[15] != 38 ||  
                    arr[8]+arr[12]+arr[15] != 38)  
                return ;  
            print(arr);  
        }  
        for(int i = 0; i < table.length; ++i){  
            if(vis[table[i]] == false){  
                vis[table[i]] = true;  
                arr[step] = table[i];  
                dfs(arr,step+1,vis);  
                vis[table[i]] = false;  
            }  
        }  
    }  
      
    static void print(int[] arr){  
        for(int i = 0; i < arr.length; ++i){  
            System.out.print(arr[i]+" ");  
        }  
        System.out.println();  
    }
}  

 

 

格子放鸡蛋

     X星球的母鸡很聪明。它们把蛋直接下在一个 N * N 的格子中,每个格子只能容纳一枚鸡蛋。它们有个习惯,要求:每行,每列,以及每个斜线上都不能有超过2个鸡蛋。如果要满足这些要求,母鸡最多能下多少蛋呢,有多少种摆放方法呢?

    下面的程序解决了这个问题,请仔细分析程序逻辑,推断划线处缺少的代码。

 

public class A
{
       static int max = 0;
       static int T = 0;
       static final int N = 6;
             
       // 只能在(r,c) 以及其右,其下放置
       static void f(int[][] da, int r, int c)
       {    
              if(r>=N){
                     int n = count(da);
                     if(n>max) {
                            max= n;
                            T= 0;
                     }
                     if(n==max) T++;
                     return;
              }
             
              //计算一下步放哪
              int r_next = r;
              int c_next = c +1;
              if(c_next>=N){
                     c_next = 0;
                     r_next++;
              }
             
              if(____________________){  // 填空位置
                     da[r][c] = 1;
                     f(da, r_next, c_next);
              }
             
              da[r][c] = 0;
              f(da, r_next,c_next);
       }
      
       static int count(int[][] da)
       {
              int n = 0;
             
              for(int i=0;i<da.length; i++)
              for(int j=0;j<da[i].length; j++)
                     if(da[i][j]==1) n++;
                    
              return n;
       }
      
       static int spy(int[][] da, int r, int c)
       {
              int m=0;
             
              // 该行
              int n=0;
              for(int i=0;i<N; i++) if(da[r][i]==1) n++;
              if(n>m) m = n;
 
              //该列
              n=0;
              for(int i=0;i<N; i++) if(da[i][c]==1) n++;
              if(n>m) m = n;
             
              //右斜线
              n=0;
              for(int i=0;i<N; i++){
                     if(r-i<0 || c-i<0) break;
                     if(da[r-i][c-i]==1) n++;
              }
              for(int i=1;i<N; i++){
                     if(r+i>=N || c+i>=N) break;
                     if(da[r+i][c+i]==1) n++;
              }
              if(n>m) m = n;
             
              //左斜线
              n=0;
              for(int i=0;i<N; i++){
                     if(r-i<0 || c+i>=N) break;
                     if(da[r-i][c+i]==1) n++;
              }
              for(int i=1;i<N; i++){
                     if(r+i>=N || c-i<0) break;
                     if(da[r+i][c-i]==1) n++;
              }
              if(n > m) m =n;
             
              return m;
       }
      
       public static void main(String[] args)
       {
              int[][] da = newint[N][N];
             
              f(da, 0, 0);
             
              System.out.println(max);
              System.out.println(T);
       }
}

 

 

 

注意:通过浏览器提交答案。只填写缺少的内容,不要填写任何多余的内容(例如:说明性文字或已有符号)。

 

spy(da,r,c) <= 2

 

排列序数

   如果用a b c d这4个字母组成一个串,有4!=24种,如果把它们排个序,每个串都对应一个序号:

  abcd  0

  abdc  1

  acbd  2

  acdb  3

  adbc  4

  adcb  5

  bacd  6

  badc  7

  bcad  8

  bcda  9

  bdac 10

  bdca 11

  cabd 12

  cadb 13

  cbad 14

  cbda 15

  cdab 16

  cdba 17

  ...

    现在有不多于10个两两不同的小写字母,给出它们组成的串,你能求出该串在所有排列中的序号吗?

【输入格式】

一行,一个串。

【输出格式】

一行,一个整数,表示该串在其字母所有排列生成的串中的序号。注意:最小的序号是0。

例如:

输入:

bdca

程序应该输出:

11

再例如:

输入:

cedab

程序应该输出:

70

资源约定:

峰值内存消耗(含虚拟机) < 256M

CPU消耗 < 1000ms

请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。

注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意:主类的名字必须是:Main,否则按无效代码处理。

 

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

public class Main{
	static String str;
	static char[] arr,target;
	static int count;
	public static void main(String[] args){
		Scanner sca = new Scanner(System.in);
		str = sca.nextLine();
		arr = str.toCharArray();
		Arrays.sort(arr);
		boolean[] vis = new boolean[20];
		target = new char[arr.length];
		dfs(0,vis);
	}

	private static void dfs(int step, boolean[] vis) {
		// TODO Auto-generated method stub
		if(step == target.length){
			if(str.equals(String.valueOf(target))){
				System.out.println(count);
			}
			++count;
			return ;
		}
		
		for(int i = 0; i < target.length; ++i){
			if(!vis[i]){
				vis[i] = true;
				target[step] = arr[i];
				dfs(step+1,vis);
				vis[i] = false;
			}
		}
	}
}

 

 

 

幂一矩阵

    天才少年的邻居 atm 最近学习了线性代数相关的理论,他对“矩阵”这个概念特别感兴趣。矩阵中有个概念叫做幂零矩阵。对于一个方阵 M ,如果存在一个正整数 k 满足 M^k = 0 ,那么 M 就是一个幂零矩阵。(^ 表示乘方)

    atm 不满足幂零矩阵,他自己设想了一个幂一矩阵:对于一个方阵 M ,如果存在一个正整数 k 满足 M^k = I ,其中 I 是单位矩阵,那么 M 就是一个幂一矩阵。

    atm 特别钟情于这样一种方阵:每行每列有且仅有一个 1 。经过 atm 不断实验,他发现这种矩阵都是幂一矩阵。

    现在,他的问题是,给定一个满足以上条件的方阵,他想求最小的 k 是多少。

【输入格式】

第一行一个正整数 n ,表示矩阵大小是 n * n。

接下来 n 行,每行两个正整数 i j 表示方阵的第 i 行第 j 列为 1。

1 <= i, j <= n 。

行号,列号都从1开始。

【输出格式】

一行。一个正整数,即题目中所说最小的 k 。

【样例输入】

5

3 1

1 2

4 4

2 3

5 5

【样例输出】

3

【数据范围】

对于 30% 的数据满足 n <=10

对于 60% 的数据答案不超过 10^18

对于 100% 的数据满足 n <=10000

资源约定:

峰值内存消耗(含虚拟机) < 256M

CPU消耗 < 1000ms

请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。

注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意:主类的名字必须是:Main,否则按无效代码处理。

解题思路:

首先求出每一行的1的位置经过多少次会等于它的行数,然后求出这些值的最小公倍数即可。

 

import java.math.BigInteger;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class Main{
	 
	public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        Scanner sca = new Scanner(System.in);  
        int n = sca.nextInt();  
        int[] row = new int[n + 1];  
        int[] pos = new int [n + 1]; 
        int count [] = new int [n + 1];  
        HashSet<Integer> hashset = new HashSet<Integer>();  
        for(int i = 0; i < n; ++i){  
            int x = sca.nextInt();  
            int y = sca.nextInt();  
            pos[x] = y;  
            row[x] = y;  
        }   
        for(int i = 1; i <= n; ++i) {  
            hashset.add(cal(row, pos, i));  
        }  
        Iterator<Integer> iter = hashset.iterator();  
        BigInteger sum = new BigInteger(iter.next()+"");  
        while(iter.hasNext()){  
            BigInteger next = new BigInteger(iter.next()+"");
            BigInteger gcd = GCD(sum,next);
            sum = sum.divide(gcd).multiply(next);
        }  
        System.out.println(sum); 
    }  

	private static BigInteger GCD(BigInteger sum, BigInteger next) {
		// TODO Auto-generated method stub
		if(next.equals(BigInteger.ZERO))
			return sum;
		else
			return GCD(next,sum.mod(next));
	}

	private static int cal(int[] row, int[] pos, int i) {
		// TODO Auto-generated method stub
		int tmp = 1;  
        while(true){  
            row[i] = pos[row[i]];  
            tmp++;  
            if(row[i] == i)  
                break;  
        }  
        if(tmp == 2)  
            return 1;  
        return tmp;  
    }
}  

 

供水设施

    X星球的居民点很多。Pear决定修建一个浩大的水利工程,以解决他管辖的N个居民点的供水问题。现在一共有N个水塔,同时也有N个居民点,居民点在北侧从1号到N号自西向东排成一排;水塔在南侧也从1号到N号自西向东排成一排。

    N条单向输水线(有水泵动力),将水从南侧的水塔引到北侧对应的居民点。

    我们不妨将居民点和水塔都看做平面上的点,居民点坐标为(1,K)~(N,K),水塔为(1,0)~(N,0)。

    除了N条纵向输水线以外,还有M条单向的横向输水线,连接(Xi,Yi)和(Xi,(Yi)+1)或者(Xi,Yi)和(Xi,(Yi)-1)。前者被称为向右的水路,而后者是向左的。不会有两条水路重叠,即便它们方向不同。

    布局的示意图如:

    显然,每个水塔的水都可以到达若干个居民点(而不仅仅是对应的那个)。例如上图中,4号水塔可以到达3、4、5、6四个居民点。

    现在Pear决定在此基础上,再修建一条横向单项输水线。为了方便考虑,Pear认为这条水路应当是自左向右的,也就是连接了一个点和它右侧的点(例如上图中连接5和6两个纵线的横向水路)。

    Pear的目标是,修建了这条水路之后,能有尽可能多对水塔和居民点之间能到达。换句话说,设修建之后第i个水塔能到达Ai个点,你要最大化A1+A2+...+An。

    根据定义,这条路必须和X轴平行,但Y坐标不一定要是整数。注意:虽然输入中没有重叠的水路,但是你的方案可以将新修的输水线路与已有的水路重叠。

【输入数据】

    输入第一行包含三个正整数N,M,K,含义如题面所述:N是纵向线数,M横向线数,K是居民点纵坐标。

    接下来M行,每行三个整数。前两个正整数Xi Yi表示水路的起点坐标;

    1<=Xi<=N,0<Yi<K。

    接下来一个数0或者1,如果是0表示这条水路向左,否则向右。

    保证水路都是合法的,也就是不会流向没有定义的地方。

【输出数据】

输出一行。是一个正整数,即:题目中要求的最大化的A1+A2+...+An。

【输入样例1】

4 3 2

1 1 1

3 1 0

3 1 1

【输出样例1】

11

【输入样例2】

7 9 4

2 3 0

7 2 0

6 3 1

6 1 0

2 1 1

3 3 1

5 2 0

2 2 1

7 1 0

【输出样例2】

21

【数据范围】

对于20%的数据,N,K<=20,M<=100

对于40%的数据,N,K<=100,M<=1000

对于60%的数据,N,K<=1000,M<=100000

对于100%的数据,N,K<=50000,M<=100000

资源约定:

峰值内存消耗(含虚拟机) < 256M

CPU消耗 < 5000ms

请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。

注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意:主类的名字必须是:Main,否则按无效代码处理。

官方题解:

首先不难发现:修建水渠的肯定是 y 坐标整点。因此对于 20%的数据,暴力枚举哪一 个位置修建水渠即可。接下来我们需要观察

出,这是一个平面图,因而每个点能到达的居 民点一定是连续的一段(因为有南北向水渠所以这一点比较显然)。接下来,如果把 

N 个水塔能到达的居民点区间都求出来,则区间是单调不降的。这同样取决于平面图的性质。 由于没有(双向)重边,所以图肯定

是一个拓扑图。要想得到每个水塔能到达哪些居 民点,只要把拓扑图构出来,并按拓扑序进行 dp(得到每个点能到达的最左最右

点即可)。 接下来枚举那条添加的边。这条边肯定是加在某个“关键点”向右的——所谓关键点就是 所有居民点、路的端点、水塔。

枚举它一共有 O(M+N)种情况。这条路必然把原来的一个点 向右的距离扩展了一段。接下来,假设这个点能由[l,r]这一段居民点到达

(这里易知也 是连续的,可以在反图上 dp 求出),那么就相当于这些区间的右端点都和某个数取 max。 因为右端点有序,所以很

容易维护。其它之前提到的操作都可以用 stl 解决。 整个算法复杂度为 O(NlogN)。用 O(N^2)等较劣的算法直接实现可得 60 分或 

40 分。 

以上是关于2014年 蓝桥杯决赛(Java)的主要内容,如果未能解决你的问题,请参考以下文章

第四届(13年)蓝桥杯java B组决赛真题

第七届(16年)蓝桥杯java B组决赛真题

蓝桥杯第五届决赛B组

2016年 蓝桥杯决赛体验

2014蓝桥杯决赛解题报告

2022年6月第十三届蓝桥杯大赛软件赛全国决赛C++A组题解