蓝桥杯Java——算法训练（ALGO986-996）

原创已于 2022-02-09 17:53:16 修改 · 1.6k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#蓝桥杯 #java #算法 #eclipse #经验分享

于 2022-02-08 17:44:23 首次发布

蓝桥杯-Java 专栏收录该内容

37 篇文章

订阅专栏

这篇博客涵盖了多种算法问题，包括车的放置（搜索）、24点游戏（搜索）、最大分解（贪心）、RP大冒险（随机过程）、士兵杀敌（动态规划）、Sticks问题（搜索）、逗志芃的危机（贪心）、强力党逗志芃（动态规划）、藏匿的刺客（贪心）等。这些问题涉及到了不同的算法思想，如深度优先搜索、贪心策略、动态规划等，展现了算法在解决数学和游戏问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.车的放置（搜索）

问题描述

　　在一个n*n的棋盘中，每个格子中至多放置一个车，且要保证任何两个车都不能相互攻击，有多少中放法(车与车之间是没有差别的)

输入格式

　　包含一个正整数n

输出格式

　　一个整数，表示放置车的方法数

样例输入

2

样例输出

7

数据规模和约定

n<=8

　　【样例解释】一个车都不放为1种，放置一个车有4种，放置2个车有2种。

import java.io.*;
public class Main {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		Temp996b temp = new Temp996b(n);
		temp.dfs(1);//从第一行开始摆放
		System.out.println(temp.ans);
	}
}
class Temp996b{
	int n;
	int ans = 1;
	boolean visited[] = new boolean[9];//表示第几列是否摆放
	
	public Temp996b(int n) {
		this.n = n;
	}
	
	public void dfs(int step) {//表示棋子应放到第temp行
		if(step > n) {//递归出口：当前摆放行数超出棋盘总行数
			return;
		}
		for(int i = 1; i <= n; i++) {
			if(!visited[i]) {//step行的第i列为空
				visited[i] = true;//已放置
				ans++;
				dfs(step + 1);//递归至下一行摆放
				visited[i] = false;//回溯：将step行重置
			}
		}
		dfs(step + 1);//有空行情况，将step行跳过（不摆放）
	}
}

2.24点（搜索）

问题描述

24点游戏是一个非常有意思的游戏，很流行，玩法很简单：给你4张牌，每张牌上有数字（其中A代表1，J代表11，Q代表12，K代表13），你可以利用数学中的加、减、乘、除以及括号想办法得到24，例如：

((A*K)-J)*Q等价于((1*13)-11)*12=24

　　加减乘不用多说了，但除法必须满足能整除才能除！这样有一些是得不到24点的，所以这里只要求求出不超过24的最大值。

输入格式

　　输入第一行N(1<=N<=5)表示有N组测试数据。每组测试数据输入4行，每行一个整数(1到13)表示牌值。

输出格式

　　每组测试数据输出一个整数，表示所能得到的最大的不超过24的值。

样例输入

3

3

3

3

3

1

1

1

1

12

5

13

1

样例输出

24

4

21

3.最大分解（贪心）

问题描述

　　给出一个正整数n，求一个和最大的序列a0，a1，a2，……，ap，满足n=a0>a1>a2>……>ap且ai+1是ai的约数，输出a1+a2+……+ap的最大值

输入格式

　　输入仅一行，包含一个正整数n

输出格式

　　一个正整数，表示最大的序列和，即a1+a2+……+ap的最大值

样例输入

10

样例输出

6

数据规模和约定

1<n<=10^6

样例说明

p=2

a0=10，a1=5，a2=1，6=5+1

import java.util.HashSet;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        HashSet<Integer> hashSet=new HashSet<>();
        int result=0;//结果
        hashSet =dfs(n,hashSet);
        //遍历相加
        for (Integer arrayList:hashSet){
            result+=arrayList;
        }
        System.out.println(result);
    }
    public static HashSet<Integer> dfs(int n, HashSet<Integer> hashSet) {
        for (int i=n-1;i>0;i--){//找最大值，先从大的往小的找
            if (n%i==0){//最大的约数a(i+1)是ai的约数 {a(i+1)就是i，ai就是n，递归一次a(i+1)就是n，a(i+2)就是i}，期间就是n=i
                n=i;//更新n的值
                hashSet.add(n);//我不行，只能这样去除重复值
                dfs(n,hashSet);
            }
        }
        return hashSet;
    }
}

4.RP大冒险（RP）

问题描述

　　请尽情使用各种各样的函数来测试你的RP吧~~~

输入格式

　　一个数N表示测点编号。

输出格式

　　一个0~9的数。

样例输入

0

样例输出

X
{当且仅当输出仅有一个数X且X为0~9的数时你的得分不为零，此时你的得分为系统根据你的输出而计算出的你本次的RP。}

数据规模和约定

　　测点编号为1~10，且stdans随机。
　　究竟使用怎样的函数才能获得较高的RP呢？指数函数？幂函数？斐波那契数？圆周曲线的导数函数？好想尝试一下哦~

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		if(n > 10)
			n %= 10;
		System.out.println((int)(Math.pow(n,Math.random())));
	}
}

5.士兵杀敌（二）

问题描述

　　南将军手下有N个士兵，分别编号1到N，这些士兵的杀敌数都是已知的。

　　小工是南将军手下的军师，南将军经常想知道第m号到第n号士兵的总杀敌数，请你帮助小工来回答南将军吧。

　　南将军的某次询问之后士兵i可能又杀敌q人，之后南将军再询问的时候，需要考虑到新增的杀敌数。

输入格式

　　多组测试数据，以EOF结尾；

　　每组第一行是两个整数N,M，其中N表示士兵的个数(1<N<1000000)，M表示指令的条数。(1<M<100000)

　　随后的一行是N个整数，ai表示第i号士兵杀敌数目。(0<=ai<=100)

　　随后的M行每行是一条指令，这条指令包含了一个字符串和两个整数，首先是一个字符串，如果是字符串QUERY则表示南将军进行了查询操

　　作，后面的两个整数m,n，表示查询的起始与终止士兵编号；如果是字符串ADD则后面跟的两个整数I,A(1<=I<=N,1<=A<=100),表示第I个士兵新增杀敌数为A.

输出格式

　　对于每次查询，输出一个整数R表示第m号士兵到第n号士兵的总杀敌数，每组输出占一行

样例输入

5 6

1 2 3 4 5

QUERY 1 3

ADD 1 2

QUERY 1 3

ADD 2 3

QUERY 1 2

QUERY 1 5

样例输出

6

8

8

20

6.Sticks（搜索）

问题描述

George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many sticks he had originally and how long they were originally. Please help him and design a program which computes the smallest possible original length of those sticks. All lengths expressed in units are integers greater than zero.

乔治拿了相同长度的木棍，随机切开，直到所有零件的长度最大为50个单位。现在，他想将木棍恢复到原始状态，但是他忘记了原来拥有多少木棍以及它们原本有多长时间。请帮助他，设计一个程序，计算出那些棍子的最小可能的原始长度。所有以单位表示的长度都是大于零的整数。

输入格式

The input contains blocks of 2 lines. The first line contains the number of sticks parts after cutting, there are at most 64 sticks. The second line contains the lengths of those parts separated by the space. The last line of the file contains zero.

输入包含2行的块。第一行包含切割后的木棍零件数，最多为64根木棍。第二行包含被空格隔开的那些部分的长度。文件的最后一行包含零。

输出格式

The output should contains the smallest possible length of original sticks, one per line.

输出应包含最小长度的原始摇杆，每行一根。

样例输入

9

5 2 1 5 2 1 5 2 1

4

1 2 3 4

0

样例输出

5

6

7.测试

Description

Two positive integers are said to be relatively prime to each other if the Great Common Divisor (GCD) is 1. For instance, 1, 3, 5, 7, 9...are all relatively prime to 2006.

Now your job is easy: for the given integer m, find the K-th element which is relatively prime to m when these elements are sorted in ascending order.

Input

The input contains multiple test cases. For each test case, it contains two integers m (1 <= m <= 1000000), K (1 <= K <= 100000000).

Output

Output the K-th element in a single line.

Sample Input

2006 1

2006 2

2006 3

Sample Output

1

3

5

8.逗志芃的危机（贪心）

问题描述

　　逗志芃又一次面临了危机。逗志芃的妹子是个聪明绝顶的人，相比之下逗志芃就很菜了。现在她妹子要和他玩一个游戏，这个游戏是这样的：一共有n个数（n是偶数）写成一行，然后两个人轮流取数，每次只能从最前面或者最后面取走一个数，全部取完则游戏结束，之后每个人取走的数的和就是每个人的得分。由于逗志芃妹子很厉害，但他又不想输，所以只能找到你了，你要告诉他最多可以得到多少分。（注意，妹子智商是maxlongint所以是不会犯错的，每次的策略必然最优，而且逗志芃是先手）

输入格式

　　第一行一个数n，表示有n个数。
　　第二行就是进行游戏的n个数。

输出格式

　　一个数，最高得分

样例输入

2
10 20

样例输出

20

数据规模和约定

　　例：0<n,m<=1000,每个数不超过10000 。

9.强力党逗志芃

问题描述

　　逗志芃励志要成为强力党，所以他将身上所以的技能点都洗掉了重新学技能。现在我们可以了解到，每个技能都有一个前提技能，只有学完了前提技能才能学习当前的技能（有一个最根本的技能不需要前提技能）。学习每个技能要消耗一个技能点，然后可以获得这个技能的威力值。由于逗志芃要陪妹子，所以他希望你教他如何点技能使得威力值最大从而成为强力党。

输入格式

　　第一行两个数n，m表示有n个技能和m个技能点。第二行有n个数，第i个数表示第i个技能的威力值。
　　之后的n-1行，每行两个数x,y，表示y技能的前提技能是x，也就是说先学第x个技能才能学弟y个技能。

输出格式

　　一个数，最大的威力值。

样例输入

3 2
1 10 20
1 2
1 3

样例输出

21

数据规模和约定

　　0<n,m<=200, 技能的威力值不超过200。

10.藏匿的刺客（贪心）

问题描述

　　强大的kAc建立了强大的帝国，但人民深受其学霸及23文化的压迫，于是勇敢的鹏决心反抗。
　　kAc帝国防守森严，鹏带领着小伙伴们躲在城外的草堆叶子中，称为叶子鹏。
　　kAc帝国的派出的n个看守员都发现了这一问题，第i个人会告诉你在第li个草堆到第ri个草堆里面有人，要求你计算所有草堆中最少的人数，以商议应对。
　　“你为什么这么厉害”，得到过kAc衷心赞美的你必将全力以赴。

输入格式

　　第一行一个数字n，接下来2到n+1行，每行两个数li和ri，如题。

输出格式

　　输出一个数，表示最少人数。

样例输入

5
2 4
1 3
5 7
1 8
8 8

样例输出

3

数据规模和约定

　　30%的数据n<=10
　　70%的数据n<=100
　　100%的数据n<=1000
　　所有数字均在int表示范围内

import java.util.*;
public class Main {
    /**
     * 内部类 ——> 草堆
     * l ——> 左边界
     * r ——> 右边界
     */
    public static class Haystack {
        public int l;
        public int r;
 
        public Haystack(int l, int r) {
            this.l = l;
            this.r = r;
        }
 
        public int getR() {
            return r;
        }
    }
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //n个看守员
        int n = sc.nextInt();
        //草堆集合
        List<Haystack> haystacks = new ArrayList<>();
        int l, r;
        for (int i = 0; i < n; i++) {
            l = sc.nextInt();
            r = sc.nextInt();
            haystacks.add(new Haystack(l, r));
        }
        //按 ri 排序(升序)
        haystacks.sort(Comparator.comparing(Haystack::getR));
        //记录 n 个区间的交集
        List<Object> length = new ArrayList<>();
        int minr, k;
        while (haystacks.size() != 0) {
            Haystack haystack = haystacks.get(0);
            minr = haystack.r;
            length.add(minr);
            k = 0;
            l = haystack.l;
            while (minr >= l) {
                k += 1;
                if (k < haystacks.size()) {
                    l = haystacks.get(k).l;
                } else {
                    minr = -1;
                }
            }
            //因为要删除haystacks里面的多个值，所以会涉及到一个问题，就是当你删除掉下标为1的元素，
            //原来下标为2的元素会自动改变自己的下标为1，后面的元素依次把自己的下标值减一
            //鉴于这种情况，我们想循环删除haystacks中的多个元素的话，就必须从后往前删，这样保障了你删除了一个元素之后，
            //haystacks中元素的下标移动不会影响到那些需要删除但是还未删除到的元素
            // if (k > 0) {
            //     haystacks.subList(0, k).clear();//subList() 方法用于截取并返回动态数组中的一部分。
            // }代码等同for循环代码
            for (int i = k - 1; i >= 0; i--) {
                haystacks.remove(i);
            }
        }
        System.out.println(length.size());
    }
}