【蓝桥杯】Java_B组2016年省赛真题

于 2022-03-18 22:19:50 发布
阅读量144 收藏 1
点赞数
分类专栏： 蓝桥杯 文章标签： java 算法 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48434658/article/details/123585877
版权

Java_B组2016年省赛真题

01 煤球数目

有一堆煤球，堆成三角棱锥形。具体：

第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
…
如果一共有100层，共有多少个煤球？

请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

  • 答案：171700

  • 观察规律：

    第一层摆放数量为1，后续第n层摆放数量为 f(n)，f(n) = f(n - 1) + n；

    或者第n层摆放数目用公式计算为 f(n) = n * (n + 1) / 2；

    每层累加即可得到结果。

public class B_01煤球数目 {
	public static void main(String[] args) {
		int pre = 1;
		int sum = 1;
		int n = 2;
		while(n <= 100) {
			sum += pre + n;
			pre += n++;
		}
		System.out.println(sum);
	}
}

 

02 生日蜡烛

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。

现在算起来，他一共吹熄了236根蜡烛。

请问，他从多少岁开始过生日party的？

请填写他开始过生日party的年龄数。

注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

  • 答案：26

  • 观察规律：

    • 假设从 a 岁开始：a, a + 1, a + 2, a + 3, … , a + k；

      累加和等于236;

      尝试找出a或k。

    • 注意累加和公式：(1 + k) * a + (1 + k) * k / 2 中有个÷2操作，直接使用代码会是向下取整的，所以会出错。

public class B_02生日蜡烛 {
	public static void main(String[] args) {
		l1: for(int a = 1; a < 50; a++) {	// 举办的初始年龄
			for(int k = 1;; k++) {	// 举办了多少年
				
				// 计算累加和
				int temp = k, sum = a * (1 + k);	
				while(temp > 0){
					sum += temp--;
				}
				
				// 是否符合条件
				if(sum == 236) {
					System.out.println(a);
					break;
				}else if(sum > 236)
					continue l1;
			}
		}
	}
}

 

03 凑算式

在这里插入图片描述

这个算式中AI代表19的数字，不同的字母代表 不同的数字。

比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？

注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

  • 答案：29

  • 参考之前 “带分数” 的做法，对 1-9 的数组全排列，再进行 check 看是否符合条件。

  • 注意点：

    分数部分需要进行通分，对通分后的分数要能整除；

    如果不通分，B/C和DEF/GHI可以是小数相加后为整，难写。

public class B_03凑算式 {
	static int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	static int ans;

	public static void main(String[] args) {
		f(arr, 0);
		System.out.println(ans);
	}

	private static void f(int[] arr, int k) {
		if (k == arr.length) {
			if (check()) {
				ans++;
			}
		}

		for (int i = k; i < arr.length; i++) {
			int temp = arr[i];
			arr[i] = arr[k];
			arr[k] = temp;

			f(arr, k + 1);

			temp = arr[i];
			arr[i] = arr[k];
			arr[k] = temp;
		}
	}

	private static boolean check() {
		int A = arr[0];
		int B = arr[1];
		int C = arr[2];
		int DEF = arr[3] * 100 + arr[4] * 10 + arr[5];
		int GHI = arr[6] * 100 + arr[7] * 10 + arr[8];

		if (A + (B * GHI + C * DEF) / (C * GHI) == 10 && (B * GHI + C * DEF) % (C * GHI) == 0)
			return true;
		return false;
	}
}

 

04 分小组

9名运动员参加比赛，需要分3组进行预赛。有哪些分组的方案呢？

我们标记运动员为 A,B,C,… I

下面的程序列出了所有的分组方法。

该程序的正常输出为：
ABC DEF GHI
ABC DEG FHI
ABC DEH FGI
ABC DEI FGH
ABC DFG EHI
ABC DFH EGI
ABC DFI EGH
ABC DGH EFI
ABC DGI EFH
ABC DHI EFG
ABC EFG DHI
ABC EFH DGI
ABC EFI DGH
ABC EGH DFI
ABC EGI DFH
ABC EHI DFG
ABC FGH DEI
ABC FGI DEH
ABC FHI DEG
ABC GHI DEF
ABD CEF GHI
ABD CEG FHI
ABD CEH FGI
ABD CEI FGH
ABD CFG EHI
ABD CFH EGI
ABD CFI EGH
ABD CGH EFI
ABD CGI EFH
ABD CHI EFG
ABD EFG CHI
… (以下省略，总共560行)。

public class A
{
 public static String remain(int[] a)
 {
     String s = "";
     for(int i=0; i<a.length; i++){
         if(a[i] == 0) s += (char)(i+'A');
     }    
	return s;
}

public static void f(String s, int[] a)
 {
     for(int i=0; i<a.length; i++){
         if(a[i]==1) continue;
         a[i] = 1;
         for(int j=i+1; j<a.length; j++){
             if(a[j]==1) continue;
             a[j]=1;
             for(int k=j+1; k<a.length; k++){
                 if(a[k]==1) continue;
                 a[k]=1;
                 System.out.println(__________________________________);  //填空位置
                 a[k]=0;
             }
             a[j]=0;
         }
         a[i] = 0;
     }
 }

 public static void main(String[] args)
 {
     int[] a = new int[9];        
     a[0] = 1;

     for(int b=1; b<a.length; b++){
         a[b] = 1;
         for(int c=b+1; c<a.length; c++){
             a[c] = 1;
             String s = "A" + (char)(b+'A') + (char)(c+'A');
             f(s,a);
             a[c] = 0;
         }
         a[b] = 0;
     }
 }
}

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。

  • 答案

    System.out.println(s + (char) (i + 'A') + (char) (j + 'A') + (char) (k + 'A') + remain(a)); // 填空位置

 

05 抽签

X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
…

那么最终派往W星的观察团会有多少种国别的不同组合呢？

下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
…
(以下省略，总共101行)

public class A
{
 public static void f(int[] a, int k, int n, String s)
 {
     if(k==a.length){ 
         if(n==0) System.out.println(s);
         return;
     }
		String s2 = s;
     for(int i=0; i<=a[k]; i++){
         _____________________________;   //填空位置
         s2 += (char)(k+'A');
     }
 }

 public static void main(String[] args)
 {
     int[] a = {4,2,2,1,1,3};

     f(a,0,5,"");
 }
}

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。

  • 答案：

    f(a, k + 1, n - i, s2);   //填空位置

 

06 方格填数

如下的10个格子
在这里插入图片描述
填入0~9的数字。
要求：连续的两个数字不能相邻。（左右、上下、对角都算相邻）

一共有多少种可能的填数方案？

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

  • 答案：1580

  • 方法一：全排列+check()

    import static java.lang.Math.abs;

public class B_06方格填数 {
	static int[] arr = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	static int ans = 0;

	public static void main(String[] args) {
		f(0);
		System.out.println(ans);
	}

	private static void f(int k) {
		if (k == arr.length) {
			if (check()) {
				ans++;
				return;
			}
		}

		for (int i = k; i < arr.length; i++) {
			int t = arr[i];
			arr[i] = arr[k];
			arr[k] = t;

			f(k + 1);

			t = arr[i];
			arr[i] = arr[k];
			arr[k] = t;
		}
	}

	private static boolean check() {
		// 导入Math包使用绝对值:import static java.lang.Math.*;要加上static
		if (abs(arr[0] - arr[1]) == 1 || abs(arr[0] - arr[3]) == 1 || abs(arr[0] - arr[4]) == 1
				|| abs(arr[0] - arr[5]) == 1 || abs(arr[1] - arr[2]) == 1 || abs(arr[1] - arr[4]) == 1
				|| abs(arr[1] - arr[5]) == 1 || abs(arr[1] - arr[6]) == 1 || abs(arr[2] - arr[5]) == 1
				|| abs(arr[2] - arr[6]) == 1 || abs(arr[3] - arr[4]) == 1 || abs(arr[3] - arr[7]) == 1
				|| abs(arr[3] - arr[8]) == 1 || abs(arr[4] - arr[5]) == 1 || abs(arr[4] - arr[7]) == 1
				|| abs(arr[4] - arr[8]) == 1 || abs(arr[4] - arr[9]) == 1 || abs(arr[5] - arr[6]) == 1
				|| abs(arr[5] - arr[8]) == 1 || abs(arr[5] - arr[9]) == 1 || abs(arr[6] - arr[9]) == 1
				|| abs(arr[7] - arr[8]) == 1 || abs(arr[8] - arr[9]) == 1) {
			return false;
		}
		return true;
	}
}

  • 方法二：

    原是一个3×4的的矩阵，增加一圈外围变为5×6，方便用双层循环检测每一个数（以这个数为中心，3×3范围内是否符合要求），不会导致越界。

    import static java.lang.Math.abs;

public class B_06方格填数 {
	static int[][] a = new int[5][6];
	static int vis[] = new int[10]; // 标记
	static int ans;

	public static void main(String[] args) {
		init();
		f(1, 2); // 5×6数组中,第一个填入数在(1, 2)
		System.out.println(ans);
	}

	// 初始化数组,填入-10
	private static void init() {
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[0].length; j++) {
				a[i][j] = -10;
			}
		}
	}

	private static void f(int x, int y) {
		if (x == 3 && y == 4) {
			ans++;
			return;
		}

		for (int i = 0; i < 10; i++) { // 0~9填入一个
			if (vis[i] == 0) { // 数字i没有被填入
				a[x][y] = i; // 填入数字i
				if (!check(x, y)) { // 不符合要求,恢复
					a[x][y] = -10;
					continue;
				}
				vis[i] = 1; // 若符合要求,标记已访问
				if (y == 4)
					f(x + 1, 1); // 到达边界,换行
				else
					f(x, y + 1); // 向右填入

				// 回溯
				vis[i] = 0;
				a[x][y] = -10;
			}
		}
	}

	// 检查以(x,y)为中心的3*3范围
	private static boolean check(int x, int y) {
		for (int i = x - 1; i <= x + 1; i++) {
			for (int j = y - 1; j <= y + 1; j++) {
				if (abs(a[i][j] - a[x][y]) == 1)
					return false;
			}
		}
		return true;
	}
}

 

07 减邮票

如【图1】, 有12张连在一起的12生肖的邮票。

现在你要从中剪下5张来，要求必须是连着的。（仅仅连接一个角不算相连）

比如，【图2】，【图3】中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

请填写表示方案数目的整数。

注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

在这里插入图片描述
 
在这里插入图片描述
 
在这里插入图片描述

  • 答案：116

  • 思考：使用dfs是不行的，dfs不能解决T字型连通方案；

  • 方法：

    枚举可能的5张牌的组合，再检查是否是符合要求的连通块；

    public class B_07减邮票 {
	static int a[] = { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 }; // 每个排列代表着12选5的一个方案
	static int ans;
	static boolean[] vis = new boolean[a.length]; // 标记已访问的数

	public static void main(String[] args) {
		int path[] = new int[a.length]; // 存储路径
		f(0, path);
		System.out.println(ans);
	}

	private static void f(int k, int[] path) {
		if (k == a.length) {
			if (check(path)) {
				ans++;
			}
		}

		// 采用抓取法
		for (int i = 0; i < a.length; i++) {
			// 抓取到的数和上一个数相同,且上一个数还没被使用
			if (i > 0 && a[i] == a[i - 1] && !vis[i - 1])
				continue;
			if (!vis[i]) { // 抓取到的数未被使用过
				vis[i] = true; // 标记已访问
				path[k] = a[i];
				f(k + 1, path);
				vis[i] = false; // 回溯
			}
		}
	}

	private static boolean check(int[] path) {
		int[][] g = new int[3][4];

		// 将path的排列映射到二维数组上
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 4; j++) {
				if (path[i * 4 + j] == 1)
					g[i][j] = 1;
				else
					g[i][j] = 0;
			}
		}

		// 检查路径是否符合要求
		int cnt = 0; // 连通块个数
		// g中有5个格子被标记为1,用dfs检查连通性,按照题意只有一个连通块
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 4; j++) {
				if (g[i][j] == 1) {
					dfs(g, i, j);
					cnt++;
				}
			}
		}

		return cnt == 1;
	}

	private static void dfs(int[][] g, int i, int j) {
		g[i][j] = 0; // 检查时,走过的格子置为0
		if (i - 1 >= 0 && g[i - 1][j] == 1)
			dfs(g, i - 1, j);
		if (i + 1 <= 2 && g[i + 1][j] == 1)
			dfs(g, i + 1, j);
		if (j - 1 >= 0 && g[i][j - 1] == 1)
			dfs(g, i, j - 1);
		if (j + 1 <= 3 && g[i][j + 1] == 1)
			dfs(g, i, j + 1);
	}
}

 

08 四方平和

四平方和定理，又称为拉格朗日定理：

每个正整数都可以表示为至多4个正整数的平方和。

如果把0包括进去，就正好可以表示为4个数的平方和。

比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）

对于一个给定的正整数，可能存在多种平方和的表示法。

要求你对4个数排序：0 <= a <= b <= c <= d

并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法

程序输入为一个正整数N (N<5000000)

要求输出4个非负整数，按从小到大排序，中间用空格分开

例：

输入：
5
输出：
0 0 1 2

输入：
12
输出：
0 2 2 2

输入：
773535
输出：
1 1 267 838

资源约定：

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

CPU消耗 < 3000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

  • 方法一：暴力枚举（得部分分，会超时）10 12

    for a : 0 ~ a*a ≤ N/4

    ​ for b : 0 ~ b*b ≤ N/3

    ​ for c : 0 ~ c*c ≤ N/2

    ​ for d : 0 ~ d*d ≤ N

    若最后一层改为 N - a 2 - b 2 - c 2 = D，检验是 D 是否能开放，即是否可为d 2，可以减少一层时间，10 9，但是仍然会超时。

  • 方法二：枚举改进：减少枚举变量+使用缓存，空间换时间

    枚举a，b，用 N - a 2 - b 2 = x，查x是否为 c 2 + d 2 两个数的平方和。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class B_08四平方和 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();

		Map<Integer, Integer> map = new HashMap<Integer, Integer>();

		// 缓存x = c*c+d*d
		for (int c = 0; c * c <= N / 2; c++) {
			for (int d = c; c * c + d * d <= N; d++) {
				int x = c * c + d * d;
				if (map.get(x) == null)
					map.put(x, c);
			}
		}

		// 枚举a*a+b*b,查看缓存的x中是否含有N-a*a-b*b的值
		for (int a = 0; a * a <= N / 4; a++) {
			for (int b = a; a * a + b * b <= N / 3; b++) {
				if (map.get(N - a * a - b * b) != null) {
					int c = map.get(N - a * a - b * b);
					int d = (int) Math.sqrt(N - a * a - b * b - c * c);
					System.out.println(a + " " + b + " " + c + " " + d);
					return;
				}
			}
		}
	}
}

 

09 取球博弈

两个人玩取球的游戏。
一共有N个球，每人轮流取球，每次可取集合{n1,n2,n3}中的任何一个数目。
如果无法继续取球，则游戏结束。
此时，持有 奇数个球的一方获胜。
如果 两人都是奇数，则为平局。

假设双方都采用最聪明的取法，
第一个取球的人一定能赢吗？
试编程解决这个问题。

输入格式：
第一行3个正整数n1 n2 n3，空格分开，表示每次可取的数目 (0<n1,n2,n3<100)
第二行5个正整数x1 x2 … x5，空格分开，表示5局的初始球数(0<xi<1000)

输出格式：
一行5个字符，空格分开。分别表示每局先取球的人能否获胜。
能获胜则输出+，
次之，如有办法逼平对手，输出0，
无论如何都会输，则输出-

输入：
1 2 3
1 2 3 4 5

输出：

+ 0 + 0 -

输入：
1 4 5
10 11 12 13 15

输出：
0 - 0 + +

输入：
2 3 5
7 8 9 10 11

输出：

+ 0 0 0 0

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

  • 方法：dfs枚举（博弈问题）

    • 博弈过程你来我往，主体视角是在变换的：

      第一层（轮）：“我” ----> 第二层：对手 ----> 第三层：“我” ----> …

    • 每一轮可以面对三种选择 {n1,n2,n3}，剩下 N-ni （≥0）个继续抓取；

      f(restBalls, currentPlayer, enermy)

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

public class B_09取球博弈 {
	static int[] n;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = new int[3];
		for (int i = 0; i < 3; i++) {
			n[i] = sc.nextInt();
		}
		Arrays.sort(n); // 能取球数排个序
		for (int i = 0; i < 5; i++) {
			int num = sc.nextInt();
			char res = f(num, 0, 0);
			System.out.print(res + " ");
		}

	}

	private static char f(int num, int me, int you) {
		// 结束条件
		if (num < n[0]) { // n前面进行排序的原因:若能取的最小个数＞剩下的球数,游戏结束
			if ((me & 1) == 1 && (you & 1) == 0)
				return '+';
			else if ((me & 1) == 0 && (you & 1) == 1)
				return '-';
			else
				return '0';
		}

		boolean ping = false; // 判断是否有平局
		for (int i = 0; i < 3; i++) {
			if (num >= n[i]) {
				char res = f(num - n[i], you, me + n[i]);
				if (res == '-') // 若对方输了
					return '+'; // 则我方获胜
				if (res == '0')
					ping = true;
			}
		}
		// 到此，说明不存在对手输的情况
		// 优先判断是否有平的情况
		if (ping)
			return '0';
		else
			return '-';
	}
}

  • 改进：中间的取法是无所谓的，所以会出现重复导致浪费时间

    • 我方持有的数目–>我方数目的奇偶性

      对手持有的数目–>对方数目的奇偶性

      保存双方奇偶性即可。

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

public class B_09取球博弈 {
	static int[] n;
	static char[][][] cache = new char[1000][2][2];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = new int[3];
		for (int i = 0; i < 3; i++) {
			n[i] = sc.nextInt();
		}
		Arrays.sort(n); // 能取球数排个序
		for (int i = 0; i < 5; i++) {
			int num = sc.nextInt();
			char res = f(num, 0, 0);
			System.out.print(res + " ");
		}

	}

	private static char f(int num, int me, int you) {
		// 结束条件
		if (num < n[0]) { // n前面进行排序的原因:若能取的最小个数＞剩下的球数,游戏结束
			if ((me & 1) == 1 && (you & 1) == 0)
				return '+';
			else if ((me & 1) == 0 && (you & 1) == 1)
				return '-';
			else
				return '0';
		}

		// 查看缓存,若已存在于缓存中,直接返回
		if (cache[num][me][you] != '\0')
			return cache[num][me][you];

		boolean ping = false; // 判断是否有平局
		for (int i = 0; i < 3; i++) {
			if (num >= n[i]) {
				char res = f(num - n[i], you, (n[i] & 1) == 0 ? me : (1 - me));
				if (res == '-') { // 若对方输了
					cache[num][me][you] = '+';
					return '+'; // 则我方获胜
				}
				if (res == '0')
					ping = true;
			}
		}
		// 到此，说明不存在对手输的情况
		// 优先判断是否有平的情况
		if (ping) {
			cache[num][me][you] = '0';
			return '0';
		} else {
			cache[num][me][you] = '-';
			return '-';
		}
	}
}

 

10 压缩变换

小明最近在研究压缩算法。
他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。
然而，要使数值很小是一个挑战。

最近，小明需要压缩一些正整数的序列，这些序列的特点是，后面出现的数字很大可能是刚出现过不久的数字。对于这种特殊的序列，小明准备对序列做一个变换来减小数字的值。

变换的过程如下：
从左到右枚举序列，每枚举到一个数字，如果这个数字没有出现过，刚将数字变换成它的相反数，如果数字出现过，则看它在原序列中最后的一次出现后面（且在当前数前面）出现了几种数字，用这个种类数替换原来的数字。

比如，序列(a1, a2, a3, a4, a5)=(1, 2, 2, 1, 2)在变换过程为：
a1: 1未出现过，所以a1变为-1；
a2: 2未出现过，所以a2变为-2；
a3: 2出现过，最后一次为原序列的a2，在a2后、a3前有0种数字，所以a3变为0；
a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字，所以a4变为1；
a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。
现在，给出原序列，请问，按这种变换规则变换后的序列是什么。

输入格式：
输入第一行包含一个整数n，表示序列的长度。
第二行包含n个正整数，表示输入序列。

输出格式：
输出一行，包含n个数，表示变换后的序列。

输入：
5
1 2 2 1 2

输出：
-1 -2 0 1 1

输入：
12
1 1 2 3 2 3 1 2 2 2 3 1

输出：
-1 0 -2 -3 1 1 2 2 0 0 2 2

数据规模与约定
对于30%的数据，n<=1000；
对于50%的数据，n<=30000；
对于100%的数据，1 <=n<=100000，1<=ai<=10^9

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

  • 方法：暴力法（30分）

    扫描数组，用一个hashMap存储数值及其下标，没扫描一个数，在hashMap中查看是否已存在；

    若不存在，则在数组中将其替换为相反数；

    若存在，获取其在map中存储的下标（为访问的最后的一次出现的位置），再次扫描该位置到当前位置有多少种数，进行替换；

    import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class B_10压缩变换 {
	static int[] arr;
	static int[] ans;
	static Map<Integer, Integer> map = new HashMap<Integer, Integer>();

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		arr = new int[n];
		ans = new int[n];
		for (int i = 0; i < n; i++) {
			int num = sc.nextInt();
			arr[i] = num;
			if (map.get(num) == null) { // 若当前的num未出现过
				ans[i] = -num;
			} else { // 如果出现过
				Set<Integer> set = new HashSet<>();
				for (int j = map.get(num) + 1; j < i; j++) {
					set.add(arr[j]);
				}
				ans[i] = set.size();
			}
			map.put(num, i);
		}

		for (int i = 0; i < n; i++) {
			System.out.print(ans[i] + " ");
		}
	}
}

  • 优化：前缀和 —> 线段树

    import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class B_10压缩变换2 {
	static Map<Integer, Integer> lastIndex = new HashMap<Integer, Integer>(); // 数字与下标的映射
	static int[] a;// 记录原始数据
	static int[] ans;// 记录答案
	static int[] b;// 这是一个01序列，某一个位置p上的数字为1，代表着a[p]这个数字最后出现的位置是p，而a[p]曾经出现过的位置上都是0
	private static int n;
	private static SegTree root;

	public static void main(String[] args) {
		// 输入、初始化
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		a = new int[n]; // 原始数组
		ans = new int[n]; // 答案
		b = new int[n]; // 01数组,标记重复出现的数;最后出现的重复数为1,其他为0
		root = buildSegTree(0, n - 1);

		for (int i = 0; i < n; i++) {
			int num = sc.nextInt();
			a[i] = num;
			Integer preIndex = lastIndex.get(num);
			if (preIndex == null) { // 未出现过
				ans[i] = -num;
				b[i] = 1;
				update(root, i, 1);
			} else {
				// 统计p_num和i之间有多少不同的数字
				ans[i] = query(root, preIndex + 1, i - 1); // 统计两个位置之间的1的个数==>求区间和
				b[preIndex] = 0;
				b[i] = 1;
				update(root, preIndex, -1);
				update(root, i, 1);
			}
			lastIndex.put(num, i);
		}
		for (int i = 0; i < n; i++) {
			System.out.print(ans[i] + " ");
		}
	}

	// 求区间和
	private static int query(SegTree tree, int x, int y) {
		int l = tree.l;
		int r = tree.r;
		if (x <= l && y >= r)
			return tree.sum;
		int mid = (l + r) / 2;
		int ans = 0;
		if (x <= mid)
			ans += query(tree.lson, x, y);
		if (y > mid)
			ans += query(tree.rson, x, y);
		return ans;
	}

	// 更新根节点sum
	private static void update(SegTree tree, int p, int i) {
		if (tree == null)
			return;

		tree.sum += i;
		int l = tree.l;
		int r = tree.r;
		int mid = (l + r) >> 1;
		if (p <= mid) {
			update(tree.lson, p, i);
		} else {
			update(tree.rson, p, i);
		}
	}

	// 构建线段树
	private static SegTree buildSegTree(int l, int r) {
		SegTree segTree = new SegTree(l, r);
		if (l == r) {
			segTree.sum = b[l];
			return segTree;
		}

		int mid = (l + r) / 2;
		SegTree lson = buildSegTree(l, mid);
		SegTree rson = buildSegTree(mid + 1, r);
		segTree.lson = lson;
		segTree.rson = rson;
		segTree.sum = lson.sum + rson.sum;
		return segTree;
	}

	static class SegTree {
		int l, r; // 所以区间
		int sum; // 区间和

		SegTree lson; // 左子树
		SegTree rson; // 右子树

		public SegTree(int l, int r) {
			this.l = l;
			this.r = r;
		}
	}
}

 

小易I
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2016年蓝桥杯省赛B组Java真题
小李的博客
09-19 729
1. 煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 2. 生日蜡烛 某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一共吹熄了236根蜡烛。 请问，他从多少岁开始过生日party的？ 请填写他开始过生日party的年
蓝桥杯第七 java决赛_第七届（16年）蓝桥杯java B组决赛真题
weixin_35764712的博客
02-13 137
1、愤怒小鸟(填空)X星球愤怒的小鸟喜欢撞火车！一根平直的铁轨上两火车间相距 1000 米两火车 (不妨称A和B) 以时速 10米/秒 相对行驶。愤怒的小鸟从A车出发，时速50米/秒，撞向B车，然后返回去撞A车，再返回去撞B车，如此往复....两火车在相距1米处停车。问：这期间愤怒的小鸟撞 B 车多少次？注意：需要提交的是一个整数(表示撞B车的次数)，不要填写任何其它内容。1 public cl...
2016年第七届蓝桥杯真题解析JavaB组
qq_44844588的博客
10-04 2265
A：煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 数列求和，直接暴力； import java.util.Scanner; public class 煤球数目 { public static void main(String[] args) {
2016第七届蓝桥杯省赛JAVA B组真题解析（带源码及解析）
王跃坤的博客
03-18 8237
目录：A：煤球数目（难度：★）.分析：AC代码：B：生日蜡烛（难度：★）.分析：AC代码：C：凑算式（难度：★★）.分析：AC代码：D：分小组（难度：★★★）.分析：AC代码：E：抽签（难度：★★）.分析：AC代码：F：方格填数（难度：★★★★）.分析：AC代码：G：剪邮票（难度：★★★★★）.分析：AC代码：H：四平方和（难度：★★★）.分析：AC代码：I 取球博弈（难度：★★★★★）.分析：A...
2016年第七届蓝桥杯国赛试题及详解（Java本科B组）
zmjのblog
05-19 894
1. 愤怒小鸟 愤怒小鸟 X星球愤怒的小鸟喜欢撞火车！ 一根平直的铁轨上两火车间相距 1000 米 两火车 （不妨称A和B） 以时速 10米/秒 相对行驶。 愤怒的小鸟从A车出发，时速50米/秒，撞向B车， 然后返回去撞A车，再返回去撞B车，如此往复… 两火车在相距1米处停车。 问：这期间愤怒的小鸟撞 B 车多少次？ 注意：需要提交的是一个整数（表示撞B车的次数），不要填写任何其它内容。 解析： ...
2018年第九届蓝桥杯省赛 Java A 组真题
Code-CHAN的博客
04-07 186
2018年第九届蓝桥杯省赛 Java A 组真题 第一题 import java.util.Calendar; public class Q1 { public static void main(String[] args) { Calendar cal = Calendar.getInstance(); cal.set(Calendar.YEAR, 2000); // 月份从 0 开始 cal.set(Calendar.MONTH, 0); cal.set(Calendar.
2024年 第15届蓝桥杯 EDA组 省赛 真题
最新发布
05-04
在2024年的第15届蓝桥杯竞赛中，EDA组省赛主要考察参赛者的EDA技术应用能力，可能包括以下几个方面的知识点： 1. **电路设计基础**：了解基本的电路理论，如电阻、电容、电感等元器件的工作原理，以及电路分析中的...
2018年省赛第九届蓝桥杯真题Java B组
04-01
【标题】"2018年省赛第九届蓝桥杯真题Java B组"是针对一项编程竞赛的真题集，主要针对Java语言的B组参赛者。蓝桥杯是一项国内知名的编程竞赛，旨在检验学生的算法设计和编程能力，尤其在解决实际问题上的应用。该...
第14届蓝桥杯Python省赛真题-大学B组
12-28
第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛...
蓝桥杯2016省赛B组真题.zip
07-21
"蓝桥杯2016省赛B组真题.zip"是一个包含2016年蓝桥杯省赛B组算法竞赛真题的压缩文件。蓝桥杯是一项在中国极具影响力的编程竞赛，旨在提升大学生和青少年的算法设计与编程能力。这个压缩包很可能是为了帮助参赛者或对...
蓝桥杯第十三届嵌入式省赛真题及答案
04-10
《蓝桥杯第十三届嵌入式省赛真题及答案》是针对国内一项重要的嵌入式技术竞赛——蓝桥杯的实战题目与解答集锦。蓝桥杯比赛旨在提升大学生和程序员在嵌入式系统设计与开发领域的技能，每年吸引众多参赛者参与。STM32...
2016第七届蓝桥杯 B组 C/C++ 真题及题解
GUOQU_WEILAI的博客
03-25 404
1. 煤球数目有一堆煤球，堆成三角棱锥形。具体：第一层放1个，第二层3个（排列成三角形），第三层6个（排列成三角形），第四层10个（排列成三角形），....如果一共有100层，共有多少个煤球？请填表示煤球总数目的数字。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。分析：递推，第i层煤球数为arr[i] = arr[i-1] + i;           计算出每一层的数量然后全...
蓝桥杯试题：凑算式(C/C++)
m0_54185237的博客
03-10 1317
问题描述： 这个算式中A~I代表1-9的数字，不同的字母代表不同的数字。 比如： 6+8/3+952/714 就是一种解法， 5+3/1+972/486 是另一种解法。 这个算式一共有多少种解法？ 注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字 问题分析： 可以使用全排列的方法进行填空，直到找出符合条件的等式为止。 #include<bits/stdc++.h> using namespace std; int p[]={1,2,3,4,5,6,7,8,9};
20200310之凑算式 （填空 全排列）
weixin_45351699的博客
03-10 201
这个算式中A-I代表1-9的数字，不同的字母代表不同的数字。 比如： 6+8/3+952/714就是一种解法， 5+3/1+972/486是另一种解法。 这个算式一共有多少种解法？ 注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。 这题万万万没想到是double！！根据之前学过的“算式900”，这样算数的题我们都可以用全排列来实现，比暴力等方法易懂且简洁。 但！！！ 本来还质疑第一...
蓝桥杯 凑数字(全排列)
weixin_34204722的博客
03-17 173
凑算式 这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。 比如：6+8/3+952/714 就是一种解法，5+3/1+972/486 是另一种解法。 这个算式一共有多少种解法？ 注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。 思路：枚举1-9的全排列，判断是否符合条件即可。 易错点： 这9个数如果定义为int，那么做除法的时候会丢掉结果的...
蓝桥杯-----凑算式（第7届蓝桥杯省赛 题3）
小蜗牛的博客
02-14 306
一、问题                           这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。 比如： 6+8/3+952/714 就是一种解法，            5+3/1+972/486 是另一种解法。 这个算式一共有多少种解法？ 注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。 二、代码 public class CouSuanShi...
蓝桥杯2016年省赛[第七届]-JavaB组赛题解析（上）
ATFWUS的博客
01-23 3448
蓝桥杯2016年省赛[第七届]-JavaB组赛题解析上半部分 主要是1-7题（所有的填空题）比较好的题目是 剪邮票，使用全排列+DFS连通性检查的方法。
2016年第七届蓝桥杯C/C++B组省赛题目解析
夏日 の blog
04-13 488
1.煤球数目 有一堆煤球，堆成三角棱锥形。具体：第一层放1个，第二层3个（排列成三角形），第三层6个（排列成三角形），第四层10个（排列成三角形），…如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 思路：分别是1、3、6、10…，其实就是找规律，可以看出来每次+2、+3、+4…即An=An-1+n ❗注意让求得是煤球的总数，而不是第100层煤球的数量，千万要注意 #include <iostream> usi
2016年 第7届 蓝桥杯 Java B组 省赛解析及总结
upward
08-21 2450
01 煤球数目 找规律 简单计算 02 生日蜡烛 枚举: 1两个年龄 2过生日的次数，等差数列求和的公式 03 凑算式 全排列+check 04 分小组 逻辑 05 抽签递归，搞清楚参数的含义和参数的变化方向 06 方格填数 全排列+check 07**** 剪邮票 全排列(带重复元素的全排列，要用套路全排套路1) +标注(二维数组上标注01) +dfs求连通块数目 08 四平方和 枚举优化(hash缓存) 09*** 取球博弈 典型的博弈框架(带平局) 10****压缩变换 hash查找+标注+区间树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值