第九届蓝桥杯大赛个人赛决赛（软件类）真题Java

更新中..........

同一年的题解：https://www.cnblogs.com/dgwblog/p/10111903.html

01 结果填空（满分11分）

标题：年龄问题

s夫人一向很神秘。这会儿有人问起她的年龄，她想了想说：

"20年前，我丈夫的年龄刚好是我的2倍，而现在他的年龄刚好是我的1.5倍"。

你能算出s夫人现在的年龄吗？

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

解答：这道题实际上估算以下就可以得出答案，不放心可以放到EXCEl中看看。
夫人为：40岁

02 结果填空（满分35分）

标题：最大乘积

把 1~9 这9个数字分成两组，中间插入乘号，

有的时候，它们的乘积也只包含1~9这9个数字，而且每个数字只出现1次。

比如：

984672 * 351 = 345619872

98751 * 3462 = 341875962

9 * 87146325 = 784316925

...

符合这种规律的算式还有很多，请你计算在所有这些算式中，乘积最大是多少？

注意：需要提交的是一个整数，表示那个最大的积，不要填写任何多余的内容。

（只提交乘积，不要提交整个算式）

code:

package the.ninth;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Random;

public class Solution1 {

    private static int[] data = new int[101];

    private static boolean[] vis = new boolean[101];

    private static HashSet<Integer> sets=new HashSet<>();

    static BigInteger xx=new BigInteger("345619872");

    static Random random = new Random();

    public static void main(String[] args) {

        for (int i = 1; i <= 9; i++) {

            sets.add(i);

        }

        //System.out.println(987654321);

        dfs(1,1);

        System.out.println(xx);

    }

    //9 * 87146325 = 784316925 815497632

    static void dfs(int index,int u) {

        if(index==10) {

            ArrayList<Integer> list = new ArrayList<>();

            for (int i = 1; i <=9; i++) {

                list.add(data[i]);

            }

            StringBuffer buff1 = new StringBuffer();

            for (int i =u++; i < list.size(); i++) {

                buff1.append(list.remove(i));

            }

            BigInteger a = new BigInteger(buff1.toString());

            StringBuffer buff2 = new StringBuffer();

            for (int i = 0; i < list.size(); i++) {

                buff2.append(list.get(i));

            }

            BigInteger b = new BigInteger(buff2.toString());

            BigInteger multiply = a.multiply(b);

            char[] cs = multiply.toString().toCharArray();

            for (int i = 0; i < cs.length; i++) {

                for (int j = i+1; j < cs.length; j++) {

                    if(cs[i]=='0'||cs[j]=='0')return;

                    if(cs[i]==cs[j]) {

                        return;

                    }

                }

            }

            xx = multiply.max(xx);

            return;

        }

        for (int i = 1; i <=9; i++) {

            if(vis[i]==false) {

                data[index]=i;

                vis[i]=true;

                dfs(index+1,u);

                vis[i]=false;

            }

        }

        return;

    }

}

03 代码填空（满分27分）

标题：全排列

对于某个串，比如：“1234”，求它的所有全排列。

并且要求这些全排列一定要按照字母的升序排列。

对于“1234”，应该输出(一共4!=24行)：

1234

1243

1324

1342

1423

1432

2134

2143

2314

2341

2413

2431

3124

3142

3214

3241

3412

3421

4123

4132

4213

4231

4312

4321

下面是实现程序，请仔细分析程序逻辑，并填写划线部分缺少的代码。

#include <stdio.h>

#include <string.h>

//轮换前n个，再递归处理

void permu(char* data, int cur)

{

int i,j;

if(data[cur]=='\0'){

printf("%s\n", data);

return;

}

for(i=cur; data; i++){

char tmp = data;

for(j=i-1; j>=cur; j--) data[j+1] = data[j];

data[cur] = tmp;

permu(data, cur+1);

tmp = data[cur];

___________________________________ ; //填空

data = tmp;

}

int main()

{

char a[] = "1234";

permu(a,0);

return 0;

}

注意：只需要填写划线部分缺少的内容，不要抄写已有的代码或符号。

#include <stdio.h>

#include <string.h>

//轮换前n个，再递归处理

void permu(char* data, int cur) {

    int i,j;

    if(data[cur]=='\0') {

        printf("%s\n", data);

        return;

    }

    for(i=cur; i<; i++) {

        char tmp = data[i];

        for(j=i-; j>=cur; j--)

            data[j+] = data[j];

        data[cur] = tmp;

        permu(data, cur+);

        tmp = data[cur];

        data[cur]= data[cur+];  //填空

        data[cur] = tmp;

    }

}

int main() {

    char a[] = "";

    permu(a,);

    return ;

}

04 程序设计（满分45分）

标题：约瑟夫环

n 个人的编号是 1~n，如果他们依编号按顺时针排成一个圆圈，从编号是1的人开始顺时针报数。

（报数是从1报起）当报到 k 的时候，这个人就退出游戏圈。下一个人重新从1开始报数。

求最后剩下的人的编号。这就是著名的约瑟夫环问题。

本题目就是已知 n，k 的情况下，求最后剩下的人的编号。

题目的输入是一行，2个空格分开的整数n, k

要求输出一个整数，表示最后剩下的人的编号。

约定：0 < n,k < 1百万

例如输入：

10 3

程序应该输出：

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

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

注意：main函数需要返回0;

只使用ANSI C/ANSI C++ 标准;

不要调用依赖于编译环境或操作系统的特殊函数。

所有依赖的函数必须明确地在源文件中 #include <xxx>

不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

public static void main(String[] args) {

        int a=41;

        int b=3;

        LinkedList<Integer> list = new LinkedList<>();

        for (int i = 0; i < a; i++) {

            list.add(i+1);

        }

        while (list.size()>1){

            for (int i = 0; i < b-1; i++) {

                list.add(list.remove());

            }

            System.out.print("->"+list.getFirst());

            list.remove();//remve head

        }

        System.out.println(list.getFirst());

    }

05 程序设计（满分77分）

标题：交换次数

IT产业人才需求节节攀升。业内巨头百度、阿里巴巴、腾讯（简称BAT）在某海滩进行招聘活动。

招聘部门一字排开。由于是自由抢占席位，三大公司的席位随机交错在一起，形如：

ABABTATT，这使得应聘者十分别扭。

于是，管理部门要求招聘方进行必要的交换位置，使得每个集团的席位都挨在一起。即最后形如：

BBAAATTT 这样的形状，当然，也可能是：

AAABBTTT 等。

现在，假设每次只能交换2个席位，并且知道现在的席位分布，

你的任务是计算：要使每个集团的招聘席位都挨在一起需要至少进行多少次交换动作。

输入是一行n个字符（只含有字母B、A或T），表示现在的席位分布。

输出是一个整数，表示至少交换次数。

比如，输入：

TABTABBTTTT

程序应该输出：

再比如，输入：

TTAAABB

程序应该输出：

我们约定，输入字符串的长度n 不大于10万

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

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

注意：main函数需要返回0;

只使用ANSI C/ANSI C++ 标准;

不要调用依赖于编译环境或操作系统的特殊函数。

所有依赖的函数必须明确地在源文件中 #include <xxx>

不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

06 程序设计（满分105分）

不清楚是否正确，给了几个数据正常：

public class B {

    private static int MINX = 0;

    private static int x = 0;

    private static int y = 0;

    static boolean flag = false;

    //TABTABBTTTT

    public static void main(String[] args) {

        String str = "TTAAABB";//TABTABBTTTT

        char[] arr = str.toCharArray();

        char s = 0;

        int sx = 0;

        char e = 0;

        int ex = 0;

        boolean flag2=true;

        for (int i = 0; i < arr.length-1; i++) {

            if(arr[i]==arr[i+1]) {

                y++;

                flag2=false;

            }

            if(arr[i]!=arr[i+1]&&flag2==false) {

                y--;

            }

        }

        if(y==1) {

            System.out.println(((arr.length-1)/2));

            return;

        }

        for (int i = 0; i < arr.length - 1; i++) {

            if (arr[i] == arr[i + 1] && flag == false) {

                flag = true;

                s = arr[i];

                sx = i;

            } else {

                e = arr[i];

                ex = i;

            }

        }

        //System.out.println(s + " " + e);

        //System.out.println(sx + " " + ex);

        /*// inline

        for (int i = sx; i < ex-1; i++) {

            if(arr[i]!=arr[i+1]) {

                x++;

            }

        }*/

        for (int i = 0; i < sx; i++) {

            if (arr[i] == arr[sx]) {

                char temp = arr[sx - 1];

                //System.out.println(arr[sx - 1]);

                arr[sx - 1] = arr[i];

                arr[i] = temp;

                sx--;

                x++;

            }

        }

        for (int i = 0; i < sx; i++) {

            if (arr[i] == e) {

                x++;

            }

        }

        System.out.println(x);

    }

｝

标题：迷宫与陷阱

小明在玩一款迷宫游戏，在游戏中他要控制自己的角色离开一间由NxN个格子组成的2D迷宫。

小明的起始位置在左上角，他需要到达右下角的格子才能离开迷宫。

每一步，他可以移动到上下左右相邻的格子中（前提是目标格子可以经过）。

迷宫中有些格子小明可以经过，我们用'.'表示；

有些格子是墙壁，小明不能经过，我们用'#'表示。

此外，有些格子上有陷阱，我们用'X'表示。除非小明处于无敌状态，否则不能经过。

有些格子上有无敌道具，我们用'%'表示。

当小明第一次到达该格子时，自动获得无敌状态，无敌状态会持续K步。

之后如果再次到达该格子不会获得无敌状态了。

处于无敌状态时，可以经过有陷阱的格子，但是不会拆除/毁坏陷阱，即陷阱仍会阻止没有无敌状态的角色经过。

给定迷宫，请你计算小明最少经过几步可以离开迷宫

输入

----

第一行包含两个整数N和K。 (1 <= N <= 1000 1 <= K <= 10)

以下N行包含一个NxN的矩阵。

矩阵保证左上角和右下角是'.'。

输出

----

一个整数表示答案。如果小明不能离开迷宫，输出-1。

【样例输入1】

5 3

...XX

##%#.

...#.

.###.

.....

【样例输出1】

【样例输入2】

5 1

...XX

##%#.

...#.

.###.

.....

【样例输出2】

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 3000ms

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

注意：main函数需要返回0;

只使用ANSI C/ANSI C++ 标准;

不要调用依赖于编译环境或操作系统的特殊函数。

所有依赖的函数必须明确地在源文件中 #include <xxx>

不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

code：

package the.ninth;

import java.util.LinkedList;

import java.util.Scanner;

public class E {

    private final static int MAXN = 1006;

    private static char[][] maps = new char[MAXN][MAXN];

    private static int [][][] dp=new int[MAXN][MAXN][10];

    private static int[] x = { 0, 0, 1, -1 };

    private static int[] y = { 1, -1, 0, 0 };

    private static int K = 0;

    private static int n = 0;

    public static void main(String[] args) {

        for (int i = 0; i < MAXN; i++) {

            for (int j = 0; j < MAXN; j++) {

                for (int k = 0; k < 10; k++) {

                    dp[i][j][k]=100000;

                }

            }

        }

        Scanner input = new Scanner(System.in);

        n = input.nextInt();

        K = input.nextInt();

        for (int i = 0; i < n; i++) {

            maps[i] = input.next().toCharArray();

        }

        class Nodex  {

            int x;

            int y;

            int k;

            public Nodex() {

            }

            public Nodex(int x, int y,int k) {

                this.x = x;

                this.y = y;

                this.k = k;

            }

        }

        LinkedList<Nodex> queue = new LinkedList<>();

        Nodex head = new Nodex(0, 0, 0);

        dp[0][0][0]=0;

        queue.add(head);

        while (!queue.isEmpty()) {

            Nodex cur = queue.poll();

            for (int i = 0; i < 4; i++) {

                int newx = cur.x + x[i];

                int newy = cur.y + y[i];

                Nodex node=new Nodex();

                node.x=newx;

                node.y=newy;

                node.k = cur.k>0? cur.k - 1 : 0;

                if(newx<0||newx>=n||newy<0||newy>=n)continue;

                if(maps[newx][newy]=='#') continue;

                if(maps[newx][newy]=='%') node.k = K-1;

                else if(maps[newx][newy] == 'X' && cur.k<=0)continue;

                if (dp[newx][newy][node.k] > dp[cur.x][cur.y][cur.k] + 1) {

                    dp[newx][newy][node.k] = dp[cur.x][cur.y][cur.k] + 1;

                    queue.push(node);

                }

                if (maps[cur.x][cur.y] == '%') maps[cur.x][cur.y] = '.';

            }

        }

        int ans = Integer.MAX_VALUE;

        for (int i = 0; i < K; i++) ans = Math.min(ans, dp[n-1][n-1][i]);

        if (ans == Integer.MAX_VALUE) System.out.println("-1");

        else System.out.println(ans);

    }

}