1. 程式人生 > >CCF201609 爐石傳說(JAVA)

CCF201609 爐石傳說(JAVA)

描述:

問題描述

  《爐石傳說:魔獸英雄傳》(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% 的評測用例不會出現隨從死亡的情況。

 

package hearthStone;

import java.util.Scanner;
import java.util.Vector;

public class Main {
	static Vector<Role> player1 = new Vector<>();// 先手玩家
	static Vector<Role> player2 = new Vector<>();// 後手玩家
	static Vector<Role> player;// 當前回合玩家
	static Vector<Role> oppo;// 當前回合對手玩家

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();// 運算元
		String operation;// 操作語句
		Role hero1 = new Role(0, 30);// 建立先手玩家的英雄0攻30血
		Role hero2 = new Role(0, 30);// 建立後手玩家的英雄
		player1.add(hero1);// 0下標位置儲存該玩家英雄
		player2.add(hero2);
		sc.nextLine();
		boolean flag = true;// 回合標記:先手玩家回合值為:true,後手玩家回合值為:false
		for (int i = 0; i < n; i++) {
			player = round(flag);// 判斷當前回合玩家
			operation = sc.nextLine();// 獲取操作指令
			String[] values = operation.split(" ");
			switch (values[0]) {
			case "summon":
				int pos = Integer.valueOf(values[1]);// 獲取位置
				int atk = Integer.valueOf(values[2]);// 獲取攻擊力
				int health = Integer.valueOf(values[3]);// 獲取生命值
				Role servant = new Role(atk, health);// 建立隨從,初始化攻擊力與生命值
				player.add(pos, servant);// 將該隨從置入戰場
				break;
			case "attack":
				int attacker = Integer.valueOf(values[1]);// 攻擊者序號
				int defender = Integer.valueOf(values[2]);// 防禦者序號
				oppo = round(!flag);
				oppo.get(defender).setHealth(
						oppo.get(defender).health - player.get(attacker).atk);
				// 攻擊者對防禦者生命值造成攻擊力值的傷害
				player.get(attacker).setHealth(
						player.get(attacker).health - oppo.get(defender).atk);
				// 攻擊者生命值受到防禦者攻擊力值的傷害
				if (player.get(attacker).health <= 0)// 隨從生命值小於0則移除
					player.remove(attacker);
				if (defender != 0 && oppo.get(defender).health <= 0)
					oppo.remove(defender);
				break;
			case "end":
				flag = !flag;//切換玩家回合
				break;
			}
		}
		// 輸出
		int winner = 0;
		String str;
		if (player1.get(0).health <= 0)// 判斷當前勝負
			winner = -1;
		if (player2.get(0).health <= 0)
			winner = 1;
		System.out.println(winner);
		System.out.println(player1.get(0).health);
		str = String.valueOf(player1.size() - 1);
		for (int i = 1; i < player1.size(); i++) {
			str += " " + player1.get(i).health;
		}
		System.out.println(str);
		System.out.println(player2.get(0).health);
		str = String.valueOf(player2.size() - 1);
		for (int i = 1; i < player2.size(); i++) {
			str += " " + player2.get(i).health;
		}
		System.out.println(str);

	}

	public static Vector<Role> round(boolean flag) {
		if (flag)// 判斷當前屬於哪位玩家的回合
			return player1;
		else
			return player2;
	}
}

class Role// 角色
{
	int atk;
	int health;

	public Role(int atk, int health) {
		this.atk = atk;
		this.health = health;
	}

	public int getAtk() {
		return atk;
	}

	public void setAtk(int atk) {
		this.atk = atk;
	}

	public int getHealth() {
		return health;
	}

	public void setHealth(int health) {
		this.health = health;
	}
}