1.最大波动
问题描述
小明正在利用股票的波动程度来研究股票。小明拿到了一只股票每天收盘时的价格，他想知道，这只股票连续几天的最大波动值是多少，即在这几天中某天收盘价格与前一天收盘价格之差的绝对值最大是多少。
输入格式
输入的第一行包含了一个整数n，表示小明拿到的收盘价格的连续天数。
第二行包含n个正整数，依次表示每天的收盘价格。输出格式
输出一个整数，表示这只股票这n天中的最大波动值。
样例输入
6
2 5 5 7 3 5样例输出
4
样例说明
第四天和第五天之间的波动最大，波动值为|3-7|=4。
评测用例规模与约定
对于所有评测用例，2 ≤ n ≤ 1000。股票每一天的价格为1到10000之间的整数。
思路
前几年的第一题通常比较简单，这道题用的解法是错位求出当天和前一天的收盘价格差值，并存入数组中。再对数组调方法进行排序输出最大值即可。
Java代码
import java.util.*;
public class Main2016091 {
public static void main(String [] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int [] a = new int [n];
for(int i=0;i<n;i++) {
a[i] = scan.nextInt();
}
int [] de = new int [n-1];
for(int i=0;i<n-1;i++) {
de[i] = Math.abs(a[i]-a[i+1]);
}
Arrays.sort(de);
System.out.print(de[n-2]);
}
}2.火车购票（90分）
问题描述
请实现一个铁路购票系统的简单座位分配算法，来处理一节车厢的座位分配。
假设一节车厢有20排、每一排5个座位。为方便起见，我们用1到100来给所有的座位编号，第一排是1到5号，第二排是6到10号，依次类推，第20排是96到100号。
购票时，一个人可能购一张或多张票，最多不超过5张。如果这几张票可以安排在同一排编号相邻的座位，则应该安排在编号最小的相邻座位。否则应该安排在编号最小的几个空座位中（不考虑是否相邻）。
假设初始时车票全部未被购买，现在给了一些购票指令，请你处理这些指令。输入格式
输入的第一行包含一个整数n，表示购票指令的数量。
第二行包含n个整数，每个整数p在1到5之间，表示要购入的票数，相邻的两个数之间使用一个空格分隔。输出格式
输出n行，每行对应一条指令的处理结果。
对于购票指令p，输出p张车票的编号，按从小到大排序。样例输入
4
2 5 4 2样例输出
1 2
6 7 8 9 10
11 12 13 14
3 4样例说明
1) 购2张票，得到座位1、2。
2) 购5张票，得到座位6至10。
3) 购4张票，得到座位11至14。
4) 购2张票，得到座位3、4。评测用例规模与约定
对于所有评测用例，1 ≤ n ≤ 100，所有购票数量之和不超过100。
思路
在第一题非常简单的情况下，第二道题会比较麻烦。这道题用的解法是。
定义一个二维数组，来存储100个座位。并且在每一排的数据中，再加两个数据，第六位存储空位的起始下标，第七位存储空位数量。
因为要输出位置号，所以用1~100给每个座位编码，并且初始空位数都是5个。定义一个方法，来控制每一排座位空位的起始下标的更新。
定义一个标志量flag，判断是否所剩的座位可以安排为连续的。如果可以连续安排座位，就从每排的空位数和空位下标进行匹配，安排座位并输出座位号。如果不可以连续安排座位，那就从第一排开始有空位就安排，并输出座位号。
Java代码
import java.util.*;
public class Main2016092 {
public static void main(String [] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int [] a = new int [n];
for(int i=0;i<n;i++) {
a[i] = scan.nextInt();
}
int [][] site = new int [20][7];//第六位存起始空位 第七位存空位数
int count = 1;
for(int i=0;i<20;i++) {
for(int j=0;j<5;j++) {
site[i][j] = count;
count++;
}
site[i][6] = 5;
}
setIndex(site);
boolean flag = true;
for(int i=0;i<n;i++) {
for(int j=0;j<20;j++) {
if(a[i]<=site[j][6]) {
site[j][6]-=a[i];
for(int k=site[j][5];k<(site[j][5]+a[i]);k++) {
System.out.print(site[j][k]+" ");
site[j][k] = -1;
}
flag = false;
site[j][5]+=a[i];
break;
}
}
int temp = a[i];
while(flag) {
for(int j=0;j<20;j++){
for(int k=site[j][5];k<5;k++) {
System.out.print(site[j][k]+" ");
site[j][k] = -1;
site[j][5]+=1;
site[j][6]-=1;
temp--;
}
if(temp==0)
flag = false;
break;
}
}
System.out.println();
}
}
public static void setIndex(int [][] site) {
for(int i=0;i<20;i++) {
for(int j=0;j<5;j++) {
if(site[i][j]==-1) {
site[i][5] = j;
}
}
}
}
}3.炉石传说（70分）
问题描述
《炉石传说：魔兽英雄传》（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% 的评测用例不会出现随从死亡的情况。
思路
这道题的解题思路是。不管是英雄还是随从，都拥有攻击力和生命值两个属性（英雄的攻击力为0）。因此首先定义了一个英雄类，具有攻击力和生命值两个属性。并将所有英雄存储在map中，由于随从都有从1-7的位置，首先放置英雄到0号位。其余的位置存储不同的随从。
由于每个回合的操作除了“end”命令之外，有两种主要操作：summon放置随从以及attack攻击操作。因此分别定义summon、attack方法实现操作。
另外定义了一个endnum是为了区别先手还是后手，先手的话，endnum为单数，后手为双数。
summon方法中主要实现，判断要放置随从的位置是否有随从，没有的话直接放置，有的话，所有指定位置及之后的随从全都向右移动一个位置，再放置要加入的随从。
attack方法主要实现，减去相应的生命值之后判断随从或英雄是否已经死亡，若英雄死亡，游戏结束。若随从死亡，则死亡的一方需要将该随从及之后的随从往左移动一个位置。
Java代码
package ccfWork;
import java.util.*;
class Hero{
int att;
int hea;
public Hero(int att,int hea) {
this.att = att;
this.hea = hea;
}
}
public class Main2016093 {
public static void main(String [] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
String [] ops = new String [n];
int endnum = 1;
HashMap<Integer,Hero> mapa = new HashMap<>();
Hero hero1 = new Hero(0,30);
mapa.put(0, hero1);
Hero hero2 = new Hero(0,30);
HashMap<Integer,Hero> mapb = new HashMap<>();
mapb.put(0, hero2);
scan.nextLine();
for(int i=0;i<n;i++) {
ops[i] = scan.nextLine();
if(ops[i].startsWith("summon")) {
String [] temp = ops[i].split(" ");
if(endnum%2!=0) {
summon(Integer.parseInt(temp[1]),Integer.parseInt(temp[2]),Integer.parseInt(temp[3]),mapa);
}else {
summon(Integer.parseInt(temp[1]),Integer.parseInt(temp[2]),Integer.parseInt(temp[3]),mapb);
}
}else if(ops[i].startsWith("attack")) {
String [] temp = ops[i].split(" ");
if(endnum%2!=0) {//end为单数 即为先手回合
attack(Integer.parseInt(temp[1]),Integer.parseInt(temp[2]),mapa,mapb);
}else {
attack(Integer.parseInt(temp[2]),Integer.parseInt(temp[1]),mapa,mapb);
}
}else if(ops[i].startsWith("end")){
endnum++;
}
}
int res = 0;
if(mapa.get(0).hea<=0) {
res = -1;
}else if(mapb.get(0).hea<=0){
res = 1;
}
System.out.println(res);
System.out.println(mapa.get(0).hea);
System.out.print((mapa.size()-1)+" ");
for(int i=1;i<mapa.size();i++) {
System.out.print(mapa.get(i).hea+" ");
}
System.out.println();
System.out.println(mapb.get(0).hea);
System.out.print((mapb.size()-1)+" ");
for(int i=1;i<mapb.size();i++) {
System.out.print(mapb.get(i).hea+" ");
}
System.out.println();
}
public static void summon(int p,int att,int hea,HashMap<Integer,Hero> mapa) {
if(mapa.get(p)!=null) {
mapa.put(mapa.size(), mapa.get(mapa.size()-1));
for(int i=mapa.size();i>p;i--) {
mapa.replace(i, mapa.get(i-1));
}
Hero hero = new Hero(att,hea);
mapa.replace(p, hero);
}else {
Hero hero = new Hero(att,hea);
mapa.put(p, hero);
}
}
public static void attack(int at,int de,HashMap<Integer,Hero> mapa,HashMap<Integer,Hero> mapb) {
mapa.get(at).hea = mapa.get(at).hea-mapb.get(de).att;
mapb.get(de).hea = mapb.get(de).hea-mapa.get(at).att;
if(mapa.get(at).hea<=0) {
for(int i=at;i<mapa.size()-1;i++) {
mapa.replace(i, mapa.get(i+1));
}
mapa.remove(mapa.size()-1);
}
if(mapb.get(de).hea<=0) {
for(int i=de;i<mapb.size()-1;i++) {
mapb.replace(i, mapb.get(i+1));
}
mapb.remove(mapb.size()-1);
}
}
}