CCF——炉石传说

最新推荐文章于 2023-02-24 21:34:59 发布
最新推荐文章于 2023-02-24 21:34:59 发布
阅读量710 收藏 1
点赞数
分类专栏： 八股编程 文章标签： 炉石传说 CCF CSP认证 Java ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_bian/article/details/78004875
版权
问题描述
试题编号： 201609-3
试题名称： 炉石传说
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　《炉石传说：魔兽英雄传》（Hearthstone: Heroes of Warcraft，简称炉石传说）是暴雪娱乐开发的一款集换式卡牌游戏（如下图所示）。游戏在一个战斗棋盘上进行，由两名玩家轮流进行操作，本题所使用的炉石传说游戏的简化规则如下：

　　* 玩家会控制一些 角色，每个角色有自己的 生命值和 攻击力。当生命值小于等于 0 时，该角色 死亡。角色分为 英雄和 随从。
　　* 玩家各控制一个英雄，游戏开始时，英雄的生命值为 30，攻击力为 0。当英雄死亡时，游戏结束，英雄未死亡的一方获胜。
　　* 玩家可在游戏过程中召唤随从。棋盘上每方都有 7 个可用于放置随从的空位，从左到右一字排开，被称为 战场。当随从死亡时，它将被从战场上移除。
　　* 游戏开始后，两位玩家轮流进行操作，每个玩家的连续一组操作称为一个 回合。
　　* 每个回合中，当前玩家可进行零个或者多个以下操作：
　　1)  召唤随从：玩家召唤一个随从进入战场，随从具有指定的生命值和攻击力。
　　2)  随从攻击：玩家控制自己的某个随从攻击对手的英雄或者某个随从。
　　3)  结束回合：玩家声明自己的当前回合结束，游戏将进入对手的回合。该操作一定是一个回合的最后一个操作。
　　* 当随从攻击时，攻击方和被攻击方会同时对彼此造成等同于自己攻击力的 伤害。受到伤害的角色的生命值将会减少，数值等同于受到的伤害。例如，随从  X 的生命值为  HX、攻击力为  AX，随从  Y 的生命值为  HY、攻击力为  AY，如果随从  X 攻击随从  Y，则攻击发生后随从  X 的生命值变为  HX -  AY，随从  Y 的生命值变为  HY -  AX。攻击发生后，角色的生命值可以为负数。
　　本题将给出一个游戏的过程，要求编写程序模拟该游戏过程并输出最后的局面。
输入格式
　　输入第一行是一个整数  n，表示操作的个数。接下来  n 行，每行描述一个操作，格式如下：
　　<action> <arg1> <arg2> ...
　　其中<action>表示操作类型，是一个字符串，共有 3 种：summon表示召唤随从，attack表示随从攻击，end表示结束回合。这 3 种操作的具体格式如下：
　　* summon <position> <attack> <health>：当前玩家在位置<position>召唤一个生命值为<health>、攻击力为<attack>的随从。其中<position>是一个 1 到 7 的整数，表示召唤的随从出现在战场上的位置，原来该位置及右边的随从都将顺次向右移动一位。
　　* attack <attacker> <defender>：当前玩家的角色<attacker>攻击对方的角色 <defender>。<attacker>是 1 到 7 的整数，表示发起攻击的本方随从编号，<defender>是 0 到 7 的整数，表示被攻击的对方角色，0 表示攻击对方英雄，1 到 7 表示攻击对方随从的编号。
　　* end：当前玩家结束本回合。
　　注意：随从的编号会随着游戏的进程发生变化，当召唤一个随从时，玩家指定召唤该随从放入战场的位置，此时，原来该位置及右边的所有随从编号都会增加 1。而当一个随从死亡时，它右边的所有随从编号都会减少 1。任意时刻，战场上的随从总是从1开始连续编号。
输出格式
　　输出共 5 行。
　　第 1 行包含一个整数，表示这  n 次操作后（以下称为  T 时刻）游戏的胜负结果，1 表示先手玩家获胜，-1 表示后手玩家获胜，0 表示游戏尚未结束，还没有人获胜。
　　第 2 行包含一个整数，表示  T 时刻先手玩家的英雄的生命值。
　　第 3 行包含若干个整数，第一个整数  p 表示  T 时刻先手玩家在战场上存活的随从个数，之后  p 个整数，分别表示这些随从在  T 时刻的生命值（按照从左往右的顺序）。
　　第 4 行和第 5 行与第 2 行和第 3 行类似，只是将玩家从先手玩家换为后手玩家。
样例输入
8
summon 1 3 6
summon 2 4 2
end
summon 1 4 5
summon 1 2 1
attack 1 2
end
attack 1 1
样例输出
0
30
1 2
30
1 2
样例说明
　　按照样例输入从第 2 行开始逐行的解释如下：
　　1. 先手玩家在位置 1 召唤一个生命值为 6、攻击力为 3 的随从 A，是本方战场上唯一的随从。
　　2. 先手玩家在位置 2 召唤一个生命值为 2、攻击力为 4 的随从 B，出现在随从 A 的右边。
　　3. 先手玩家回合结束。
　　4. 后手玩家在位置 1 召唤一个生命值为 5、攻击力为 4 的随从 C，是本方战场上唯一的随从。
　　5. 后手玩家在位置 1 召唤一个生命值为 1、攻击力为 2 的随从 D，出现在随从 C 的左边。
　　6. 随从 D 攻击随从 B，双方均死亡。
　　7. 后手玩家回合结束。
　　8. 随从 A 攻击随从 C，双方的生命值都降低至 2。
评测用例规模与约定
　　* 操作的个数0 ≤  n ≤ 1000。
　　* 随从的初始生命值为 1 到 100 的整数，攻击力为 0 到 100 的整数。
　　* 保证所有操作均合法，包括但不限于：
　　1) 召唤随从的位置一定是合法的，即如果当前本方战场上有  m 个随从，则召唤随从的位置一定在 1 到  m + 1 之间，其中 1 表示战场最左边的位置， m + 1 表示战场最右边的位置。
　　2) 当本方战场有 7 个随从时，不会再召唤新的随从。
　　3) 发起攻击和被攻击的角色一定存在，发起攻击的角色攻击力大于 0。
　　4) 一方英雄如果死亡，就不再会有后续操作。
　　* 数据约定：
　　前 20% 的评测用例召唤随从的位置都是战场的最右边。
　　前 40% 的评测用例没有 attack 操作。
　　前 60% 的评测用例不会出现随从死亡的情况。

这道题不像别的题目那样所选的算法不同复杂度不同。这道题目没有什么可以优化的，就是一条指令一条指令地执行。所以这道题目的关键是细心，要注意留心一些细节，我在刚开始做的时候就忽略了一些细节，导致拿不到全分，比如我在第一次提交的时候，没有考虑随从的生命值和攻击值是多位数的情况，结果导致只得了70分，更改之后才得到全分。
这道题的Java代码实现如下： 
import java.util.*;
public class Main {

	public static int player = 0;
	public static int[][] life = new int[2][8];
	public static int[][] hurt = new int[2][8];
	public static int result = 0;
	
	public static void main(String[] args) {
		
		Scanner in = new Scanner(System.in);
		int num = in.nextInt();
		String astr = in.nextLine();//消除回车的影响
		String[] commends = new String[num];
		for(int i = 0;i<num;i++){
			commends[i] = in.nextLine();
		}
		
		for(int i = 0;i<8;i++){
			life[0][i] = 0;
			life[1][i] = 0;
			hurt[0][i] = 0;
			hurt[1][i] = 0;
		}		
		life[0][0] = 30;
		life[1][0] = 30;
		
		for(int i = 0;i<num;i++){
			action(commends[i]);
			//System.out.println("第"+i+"条指令执行后的结果为：");
			//printSituation();
			if(result!=0){
				printResult();
				System.exit(0);
			}
			
		}
		//printSituation();
		printResult();
		
	}
	
	public static void action(String str){
		//System.out.println("当前处理的指令："+str);
		
		if(str.equals("end")){
			player = 1-player;
			return;
		}
		else if(str.length()>3){
		
			if(str.substring(0, 6).equals("summon")){
				int position = (int)str.charAt(7)-48;
				int attack = 0;
				int health = 0;
				int index = 9;
				while(index<str.length() && (int)str.charAt(index)-48<10 && (int)str.charAt(index)-48>=0){
					attack = attack*10+(int)str.charAt(index)-48;
					index++;
				}
				index++;
				while(index<str.length() && (int)str.charAt(index)-48<10 && (int)str.charAt(index)-48>=0){
					health = health*10+(int)str.charAt(index)-48;
					index++;
				}
				
				if(life[player][position]<=0){
					int now = position;
					while(life[player][now]<=0 && now>0){
						now--;
					}
					life[player][now+1] = health;
					hurt[player][now+1] = attack;
				}
				else{
					int last = position;
					while(life[player][last]>0){
						last++;
					}
					for(int i = last-1;i>=position;i--){
						life[player][i+1] = life[player][i];
						hurt[player][i+1] = hurt[player][i];
					}
					life[player][position] = health;
					hurt[player][position] = attack;
				}
				return;
			}
			else if(str.substring(0, 6).equals("attack")){
				int attacker = (int)str.charAt(7)-48;
				int defender = (int)str.charAt(9)-48;
				//System.out.println(player+"号玩家的"+attacker+"攻击"+defender);
				life[player][attacker] -= hurt[1-player][defender];
				life[1-player][defender] -= hurt[player][attacker];
				//printSituation();
				if(gameover()){
					return;
				}
				if(life[player][attacker]<=0 && attacker<7){
					if(life[player][attacker+1]>0){
						int now = attacker+1;
						while(now<8 && life[player][now]>0){
							life[player][now-1] = life[player][now];
							hurt[player][now-1] = hurt[player][now];
							now++;
						}
						life[player][now-1] = 0;
						hurt[player][now-1] = 0;
					}
				}
				if(life[player][attacker]<=0 && attacker<7){
					life[player][attacker] = 0;
					hurt[player][attacker] = 0;
				}
				if(life[1-player][defender]<=0 && defender<7){
					if(life[1-player][defender+1]>0){
						int now = defender+1;
						while(now<8 && life[1-player][now]>0){
							life[1-player][now-1] = life[1-player][now];
							hurt[1-player][now-1] = hurt[1-player][now];
							now++;
						}
						life[1-player][now-1] = 0;
						hurt[1-player][now-1] = 0;
					}
				}				
				
			}
			return;
		}
	}
	
	public static boolean gameover(){
		if(life[0][0]<=0){
			result = -1;
			return true;
		}else if(life[1][0]<=0){
			result = 1;
			return true;
		}
		return false;
	}
	
	public static void printResult(){		
		
		System.out.println(result);
		System.out.println(life[0][0]);
		int num = 0;
		for(int i = 1;i<8;i++){
			if(life[0][i]<=0)
				break;
			num++;
		}
		System.out.print(num);
		for(int i = 1;i<=num;i++){
			System.out.print(" "+life[0][i]);
		}
		System.out.println();
		
		System.out.println(life[1][0]);
		num = 0;
		for(int i = 1;i<8;i++){
			if(life[1][i]<=0)
				break;
			num++;
		}
		System.out.print(num);
		for(int i = 1;i<=num;i++){
			System.out.print(" "+life[1][i]);
		}
		System.out.println();
	}
	
	/**
	 * 打印当前的情况
	 */
	public static void printSituation(){
		System.out.println("============================");
		System.out.println("--------------");
		System.out.println("先手生命值：");
		for(int i = 0;i<8;i++){
			System.out.print(life[0][i]+" ");
		}
		System.out.println();
		System.out.println("先手攻击值：");
		for(int i = 0;i<8;i++){
			System.out.print(hurt[0][i]+" ");
		}
		System.out.println();
		System.out.println("后手生命值：");
		for(int i = 0;i<8;i++){
			System.out.print(life[1][i]+" ");
		}
		System.out.println();
		System.out.println("后手攻击值：");
		for(int i = 0;i<8;i++){
			System.out.print(hurt[1][i]+" ");
		}
		System.out.println();
		System.out.println("--------------");
		System.out.println("============================");
	}

}
eclipse中的运行截图如下：

提交截图如下：

麦克斯韦的妖精
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ccf历年题目 炉石传说个人简单解法，基础容器运用
06-05
ccf历年题目 炉石传说个人简单解法，基础容器运用。ccf历年题目 炉石传说个人简单解法，基础容器运用。ccf历年题目 炉石传说个人简单解法，基础容器运用。ccf历年题目 炉石传说个人简单解法，基础容器运用。ccf历年...
ccf 炉石传说
白黑菜的博客
09-15 727
201609-3 试题名称： 炉石传说 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　《炉石传说：魔兽英雄传》（Hearthstone: Heroes of Warcraft，简称炉石传说）是暴雪娱乐开发的一款集换式卡牌游戏（如下图所示）。游戏在一个战斗棋盘上进行，由两名玩家轮流进行操作，本题所使用的炉石传说游戏的
炉石传说酒馆战棋（python版)
Pinstein的博客
05-11 3132
详细解释内容请见代码注释XD import numpy as np #随从的定义 #随从的星数，攻击力，防御力，属性，圣盾，亡语，嘲讽，在场buff，因其他随从状态变化而造成的效果 class minions(): def __init__(self, name, star, ATK, DEF, attribute, DivineShield, Deathrattle, Taunt, onboard, feedback): self.name =
二进制枚举：islands打炉石传说
qq_42748585的博客
07-30 211
二进制枚举：islands打炉石传说 问题描述 islands 最近在完一款游戏“炉石传说”，又名“魔兽英雄传”。炉石传说是一款卡牌类对战的游戏。游戏是两人对战，总的来说，里面的卡牌分成两类，一类是法术牌，另一类是随从牌（所谓随从就是怪物）。 为了简化问题，现在假设随从牌的作用是召唤一个具有一定攻击力的怪物，法术牌的作用是给某个随从增加一定攻击力。随从牌和法术牌的使用都需要消耗一定的法力值。现在...
201609-3 炉石传说
cxw789的博客
09-02 133
201609-3 炉石传说 题意描述 本题要求我们去模拟一款游戏的运行，游戏分为双方 轮流操作 操作共有三种形式 summon attack end 输入输出格式 输入 n 接下来是 n 个操作 每个操作由字符串区分 后面是操作对应的参数 操作过后 先输出胜负情况 之后输出双方英雄及随从的血量 数据规模 n <= 1e3 算法设计 既然是模拟题 那就要寻找数据表示 读题可知 无论是英雄 还是 随从 均有攻击力 血量 故考虑用 unordered_map<gg,vector<array&lt
CCF 201609-3 炉石传说 解题报告 模拟
xiaoli_nu的博客
10-15 2970
题目： 问题描述 试题编号： 201612-3 试题名称： 炉石传说 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　《炉石传说：魔兽英雄传》（Hearthstone: Heroes of Warcraft，简称炉石传说）是暴雪娱乐开发的一款集换式卡牌
ccf.rar_ccf试题
09-20
【标题】"ccf.rar_ccf试题" 涉及的是中国计算机学会（CCF）组织的编程竞赛题目，特别是17年9月和12月的第二题。这类题目通常涵盖算法、数据结构和编程技巧等多个方面，旨在检验参赛者的计算机科学基础和问题解决能力...
ccf认证
03-25
【CCF认证】是中国计算机学会（CCF）举办的一项针对计算机技术能力的认证考试，旨在检验和提升参与者的编程技能，特别是Python编程语言的应用能力。这个压缩包包含了2013年至2019年CCF认证考试中Python部分的满分源...
历年题_CCF题解_
10-04
《历年CCF题解解析》 CCF，全称是中国计算机学会（China Computer Federation），它在计算机领域中扮演着重要角色，特别是在组织和推动计算机科学竞赛方面。每年，CCF都会举办一系列的竞赛，如NOI（全国青少年信息...
CCF CSP认证资料
08-03
字符串处理上：lcs(最长公共子序列)，kmp（字符串匹配算法），复杂题设计思维+注释，类的设置，数据封装，多重嵌套解法。 图论算法上（目前出现过的）：设置高效的邻接表，dfs是基础，bfs（最优/短问题且各边权值为1...
CCF 201609-3炉石传说 （100分）
Henimal00的博客
08-23 279
（1）题目描述 （2）算法思想 题目看起来很长，但是只要玩过游戏阅读起来很容易理解，充分理解后按照要求模拟即可没有什么难度。 需要注意的一点就是从者的位置，可以选用vector容器存储，方便召唤时的插入以及死亡时的删除。 （3）代码实现 #include<vector> #include<iostream> using namespace std; struct servant { int HP; int ATK; }; struct player { int HeroH
CSU1646: HearthStone(DP)
ACM！荣耀之路！
05-31 1261
Description Henry十分钟爱炉石传说(Heart Stone)这款有趣的桌面卡牌游戏。 我们简化的游戏规则如下： 游戏由两人对战，出牌并尽量对对方造成最大的伤害，一共进行 r轮。 前10轮，第i轮你有i个法力水晶；之后每轮都有10个法力水晶。前一轮未使用的法力水晶不能累积到下一轮。有两种卡牌，随从卡 “达拉然法师” 和 法术卡  “刺骨”。
CCF 炉石传说 满分代码（详细注释） + 解题思路 （结构体模拟） 201609-3
最新发布
一只可爱的小猴子的博客
02-24 358
attack操作，将双方生命减去对方的攻击值，如果死了并且不是英雄的话，将后面的随从往前移动一位。sommon操作，将pos位置后面的人右移，然后将新随从插入到pos位置。p[0,0]存储先手英雄，p[0,1~7]存储先手的随从。p[1,0]存储先手英雄，p[1,1~7]存储先手的随从。读入n个操作，执行这n个操作，最后输出所有人员的生命信息。如果是end操作，交换双方操作对象（r =!用一个结构体二维数组存储所有人员信息。将每个人用结构体存储生命和攻击力。
CCF-炉石传说
wwwa1231的博客
11-30 1154
这题原本想的比较复杂，因为每次召唤随从或随从死亡时都要对右边的随从编号进行变动，然后构建了链表的数据结构，但是越写越复杂，所以马上放弃这个思路。 其实只要构建一个结构体，结构体保存随从的health和attack，以及一个flag表示随从是否死亡。构建两个size为8的数组，用以保存随从即可。 #include #include #include using namespace std;
ccf 炉石传说
chaomaer的博客
09-14 386
import java.util.ArrayList; import java.util.Scanner;/** * date:9/11/17 * author:chaomaer **/ public class Main { public ArrayList<Role> roleArrayList = new ArrayList<>(); public int turn =
csp ccf 201609-3 第三题炉石传说java 100
outsider
03-09 516
整个题目还是挺简单的，以下是java代码！可以直接提交import java.util.HashMap; import java.util.Map; import java.util.Scanner; //题目炉石传说 public class Main{ public static void main(String[] args) throws Exception { Scanner s...
CCF 201612-1 中间数 JAVA实现
oxygen_czp的博客
12-20 2017
试题编号： 201612-1 试题名称： 中间数 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　在一个整数序列a1, a2, …, an中，如果存在某个数，大于它的整数数量等于小于它的整数数量，则称其为中间数。在一个序列中，可能存在多个下标不相同的中间数，这些中间数的值是相同的。
CCF CSP 炉石传说 JAVA 201609-3 100分
董公子的博客
10-19 959
这个题麻烦在角色的信息不好处理 想想其实也好处理，只需要封装一个角色类，将生命值和攻击力封装起来就好了 还有一点是随从进场位置，如果出现在左边要使右面所有随从position+1 其实也好处理，正好！用Link接口实现的有add(index,element)方法，数据在列表中的位置可以完美的表示不同随从的position 更完美的是：“任意时刻，战场上的随从总是从1开始连续编号。” 简直
CCF历年编程题解决方案
CCF历年真题解析 CCF（China Collegiate Computing）是一项全国性的大学生计算机编程竞赛，旨在提高大学生编程能力和创新能力。以下是对CCF历年真题的解析： 一、统计最大值、中位数和最小值 在这个题目中，要求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值