java实现第九届蓝桥杯三角形面积
三角形面积
小明最近在玩一款游戏。对游戏中的防御力很感兴趣。
我们认为直接影响防御的参数为“防御性能”，记作d，而面板上有两个防御值A和B，与d成对数关系，A=2^d，B=3^d（注意任何时候上式都成立）。
在游戏过程中，可能有一些道具把防御值A增加一个值，有另一些道具把防御值B增加一个值。
现在小明身上有n1个道具增加A的值和n2个道具增加B的值，增加量已知。
现在已知第i次使用的道具是增加A还是增加B的值，但具体使用那个道具是不确定的，请找到一个字典序最小的使用道具的方式，使得最终的防御性能最大。
初始时防御性能为0，即d=0，所以A=B=1。
【输入格式】
输入的第一行包含两个数n1,n2，空格分隔。
第二行n1个数，表示增加A值的那些道具的增加量。
第三行n2个数，表示增加B值的那些道具的增加量。
第四行一个长度为n1+n2的字符串，由0和1组成，表示道具的使用顺序。0表示使用增加A值的道具，1表示使用增加B值的道具。输入数据保证恰好有n1个0，n2个1。
【输出格式】
对于每组数据，输出n1+n2+1行，前n1+n2行按顺序输出道具的使用情况，若使用增加A值的道具，输出Ax，x为道具在该类道具中的编号（从1开始）。若使用增加B值的道具则输出Bx。最后一行输出一个大写字母E。
【样例输入1】
1 2
4
2 8
101
【样例输出1】
B2
A1
B1
E
【样例输入2】
3 0
7 11 13
000
【样例输出2】
A1
A2
A3
E
【样例说明】
对于第一组测试数据，操作过程如下：
操作 d A B
初始 0 1 1
B2 2 4 9
A1 3 8 27
B1 log3(29) 2^(log3(29)) 29
可以证明，这个值是最大的。
对于第二组测试数据，可见无论用什么顺序，A最后总为32，即d总为5，B总为243。
【数据规模】
对于20%的数据，字符串长度<=10000；
对于70%的数据，字符串长度<=200000；
对于100%的数据，字符串长度<=2000000，输入的每个增加值不超过2^30。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class MainB {
public static InputReader in = new InputReader(new BufferedInputStream(System.in));
public static PrintWriter out = new PrintWriter(System.out);
public static int n1, n2, d, a, b, len, ka, kb, k;
public static String s;
public static A[] ai = new A[2000010];
public static B[] bi = new B[2000010];
public static int[] order;
public static void main(String[] args) {
d = 0;
a = 1;
b = 1;
n1 = in.nextInt();
n2 = in.nextInt();
if (n1 == 0) s = in.nextLine();//吸取空行
for (int i = 1; i <= n1; i++) {
ai[i] = new A();
ai[i].id = i;
ai[i].value = in.nextInt();
}
if (n2 == 0) s = in.nextLine();
for (int i = 1; i <= n2; i++) {
bi[i] = new B();
bi[i].id = i;
bi[i].value = in.nextInt();
}
s = in.nextLine();
Arrays.sort(ai, 1, n1+1);
Arrays.sort(bi, 1, n2+1);
len = s.length();
ka = 1;
kb = 1;
for (int i = 0; i < len; i++) {
if (s.charAt(i) == '0') {
if (s.charAt(i) == '1') {
out.println("A" + ai[ka++].id);
out.flush();
} else {//出现连续的0
order = new int[len-i+5];
k = 0;
order[k++] = ai[ka++].id;//将这一段连续的'0'对应的id存在一个数组里
int j = i + 1;
for (j = i+1; j < len; j++) {
if (s.charAt(j) != '0') break;
order[k++] = ai[ka++].id;
}
Arrays.sort(order, 0, k);//按id从小到大排(即字典序从小到大)
i = j - 1;//调整i，使i下一次循环是从后面第一个'1'处开始
for (j = 0; j < k; j++) {
out.println("A" + order[j]);
out.flush();
}
}
} else {
if (s.charAt(i) == '0') {
out.println("B" + bi[kb++].id);
out.flush();
} else {//出现连续的1
order = new int[len-i+5];
k = 0;
order[k++] = bi[kb++].id;//将这一段连续的'1'对应的id存在一个数组里
int j = i + 1;
for (j = i+1; j < len; j++) {
if (s.charAt(j) != '1') break;
order[k++] = bi[kb++].id;
}
Arrays.sort(order, 0, k);//按id从小到大排(即字典序从小到大)
i = j - 1;//调整i，使i下一次循环是从后面第一个'0'处开始
for (j = 0; j < k; j++) {
out.println("B" + order[j]);
out.flush();
}
}
}
}
out.println("E");
out.flush();
out.close();
}
static class A implements Comparable<A>{
int id, value;
@Override
public int compareTo(A o) {
if (o.value - this.value != 0) {
return o.value - this.value;
} else {
return this.id - o.id;
}
}
}
static class B implements Comparable<B>{
int id, value;
@Override
public int compareTo(B o) {
if (o.value - this.value != 0) {
return o.value - this.value;
} else {
return this.id - o.id;
}
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
String str = null;
try {
str = reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public Double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
}
}
