题解为博主准备决赛过程中顺手写的，思路可能写得不是很详细，若有思路或代码看不懂或其它问题可以评论区或私信询问。
A 三角形面积
已知三角形三个顶点在直角坐标系下的坐标分别为：
(2.3, 2.5)
(6.4, 3.1)
(5.1, 7.2)
求该三角形的面积。
注意，要提交的是一个小数形式表示的浮点数。
要求精确到小数后3位，如不足3位，需要补零。（5分）
解析：已知三点坐标求三角形面积：
方法一： S=(p(p-a)(p-b)(p-c)^1/2海伦公式
方法二： S=1/2*(x1y2-x2y1+x2y3-x3y2+x3y1-x1y3) 即：S=1/2*IaXbI (a和b是三角形的任意两边，X表示叉乘)
public class 三角形面积 {
public static void main(String[] args) {
double x1=2.3,y1=2.5;
double x2=6.4,y2=3.1;
double x3=5.1,y3=7.2;
System.out.printf("%.3f",(x1*y2-x2*y1+x2*y3-x3*y2+x3*y1-x1*y3)/2);
}
}
B 最大乘积
把 1~9 这9个数字分成两组，中间插入乘号，
有的时候，它们的乘积也只包含1~9这9个数字，而且每个数字只出现1次。
比如：
984672 * 351 = 345619872
98751 * 3462 = 341875962
9 * 87146325 = 784316925
…
符合这种规律的算式还有很多，请你计算在所有这些算式中，乘积最大是多少？
注意，需要提交的是一个整数，表示那个最大的积，不要填写任何多余的内容。
（只提交乘积，不要提交整个算式）
解析：把9个数字全排列，在中间插入乘号求值即可，复杂度9!*8不是很大
public class 最大乘积 {
static long max = 0;
static String num = "123456789";
public static void main(String[] args) {
dfs(0);
System.out.println(max);
}
private static void dfs(int index) {
for(int i=1;i<=8;i++) {
String num1 = num.substring(0,i);
String num2 = num.substring(i,9);
long x1 = Long.parseLong(num1);
long x2 = Long.parseLong(num2);
long now = x1*x2;
if(now>max) max = now;
}
for(int i=index+1;i<=8;i++) {
swap(index,i);
dfs(index+1);
swap(index,i);
}
}
private static void swap(int index, int i) {
char[] temp = num.toCharArray();
char tc1 = temp[index];
temp[index] = temp[i];
temp[i] = tc1;
num = "";
for(int j=0;j<9;j++) num+=temp[j];
}
}
C 全排列
对于某个串，比如：“1234”，求它的所有全排列。
并且要求这些全排列一定要按照字母的升序排列。
对于“1234”，应该输出(一共4!=24行)：
1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321
下面是实现程序，请仔细分析程序逻辑，并填写划线部分缺少的代码。
import java.util.*;
public class A
{
static void permu(char[] data, int cur){
if(cur==data.length-1){
System.out.println(new String(data));
return;
}
for(int i=cur; i<data.length; i++){
char tmp = data[i];
for(int j=i-1; j>=cur; j--) data[j+1] = data[j];
data[cur] = tmp;
permu(data, cur+1);
tmp = data[cur];
__________________________________________ ;
data[i] = tmp;
}
}
static void permu(String x){
permu(x.toCharArray(),0);
}
public static void main(String[] args){
permu("1234");
}
}
请注意：只需要填写划线部分缺少的内容，不要抄写已有的代码或符号。
解析：这个结构一看就是回溯的过程，也不需要看懂代码讲的是啥，填和递归前的效果相反的代码就行了。
for(int j = cur; j <= i-1; j++) data[j] = data[j + 1];
D 整理玩具
小明有一套玩具，一共包含NxM个部件。这些部件摆放在一个包含NxM个小格子的玩具盒中，每个小格子中恰好摆放一个部件。
每一个部件上标记有一个0~9的整数，有可能有多个部件标记相同的整数。
小明对玩具的摆放有特殊的要求：标记相同整数的部件必须摆在一起，组成一个矩形形状。
如以下摆放是满足要求的：
00022
00033
44444
12244
12244
12233
01234
56789
以下摆放不满足要求：
11122
11122
33311
111111
122221
122221
111111
11122
11113
33333
给出一种摆放方式，请你判断是否符合小明的要求。
输入：
输入包含多组数据。
第一行包含一个整数T，代表数据组数。 (1 <= T <= 10)
以下包含T组数据。
每组数据第一行包含两个整数N和M。 (1 <= N, M <= 10)
以下包含N行M列的矩阵，代表摆放方式。
输出：
对于每组数据，输出YES或者NO代表是否符合小明的要求。
【样例输入】
3
3 5
00022
00033
44444
3 5
11122
11122
33311
2 5
01234
56789
【样例输出】
YES
NO
YES
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
解析：
两个限制条件：
1 相同数字要联通
2 每一块都要摆成矩形
对于1：在遍历过程中用一个数组记录当前数字有没有被遍历过，如果重复遍历输出NO。
对于2：用变量tx bx ly ry 分别表示当前遍历中的数字的最上边界，最下边界，最左边界，最右边界，当前数字遍历完后在原矩阵中检查这个最大矩形区间内是否有其它数字，如果存在其它数字则输出NO。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.xml.transform.Templates;
public class 整理玩具 {
static int N;
static int M;
static int[] visitedNum;
static int[][] map;
static int[][] visited;
static int tx,bx,ly,ry;
static int now;//当前正在遍历的数字
static boolean flag;//当前是否符合要求
static int[][] dir = new int[][] {{1,0},{-1,0},{0,1},{0,-1}};//遍历方向
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(in.readLine());
while(T-->0) {
String[] tl = in.readLine().split(" ");
N = Integer.parseInt(tl[0]);
M = Integer.parseInt(tl[1]);
visitedNum = new int[10];
map = new int[N][M];
visited = new int[N][M];
flag = true;
for(int i=0;i<N;i++) {
String line = in.readLine();
for(int j=0;j<M;j++) {
map[i][j] = line.charAt(j)-'0';
}
}
for(int i=0;i<N;i++) {
if(!flag) break;
for(int j=0;j<M;j++) {
int t = map[i][j];
if(visited[i][j]==0) {
if(visitedNum[t]==1) {
flag = false;
break;
}
visited[i][j] = 1;
visitedNum[t] = 1;
now = t;
tx = N;bx = 0;ly = M;ry = 0;
dfs(i,j);
for(int x=tx;x<=bx;x++) {
if(!flag) break;
for(int y=ly;y<=ry;y++) {
if(map[x][y]!=now) {
flag=false;
break;
}
}
}
}
}
}
if(flag) System.out.println("YES");
else System.out.println("NO");
}
}
private static void dfs(int x, int y) {
for(int d=0;d<4;d++) {
int nx = x+dir[d][0];
int ny = y+dir[d][1];
if(nx>=0&&nx<N&&ny>=0&&ny<M&&visited[nx][ny]==0&&map[nx][ny]==now) {
tx = Math.min(nx,tx);
bx = Math.max(nx,bx);
ly = Math.min(ny,ly);
ry = Math.max(ny,ry);
visited[nx][ny] = 1;
dfs(nx, ny);
}
}
}
}
E 版本分支
小明负责维护公司一个奇怪的项目。这个项目的代码一直在不断分支(branch)但是从未发生过合并(merge)。
现在这个项目的代码一共有N个版本，编号1~N，其中1号版本是最初的版本。
除了1号版本之外，其他版本的代码都恰好有一个直接的父版本；即这N个版本形成了一棵以1为根的树形结构。
如下图就是一个可能的版本树：
1
/
2 3
| /
5 4 6
现在小明需要经常检查版本x是不是版本y的祖先版本。你能帮助小明吗？
输入：
第一行包含两个整数N和Q，代表版本总数和查询总数。
以下N-1行，每行包含2个整数u和v，代表版本u是版本v的直接父版本。
再之后Q行，每行包含2个整数x和y，代表询问版本x是不是版本y的祖先版本。
对于30%的数据，1 <= N <= 1000 1 <= Q <= 1000
对于100%的数据，1 <= N <= 100000 1 <= Q <= 100000
输出：
对于每个询问，输出YES或NO代表x是否是y的祖先。
【样例输入】
6 5
1 2
1 3
2 5
3 6
3 4
1 1
1 4
2 6
5 2
6 4
【样例输出】
YES
YES
NO
NO
NO
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
解析：1 <= N <= 100000 1 <= Q <= 100000 ，不用多想，查询操作必须是O(1)，只需要通过一个二维数组记录对于每一个节点，其它节点是不是它的祖先即可。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
public class 版本分支 {
static int p[][];
static int f[];
static int N;
static int Q;
public static void main(String[] args) throws IOException {
StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
in.nextToken();
N=(int) in.nval;
in.nextToken();
Q=(int) in.nval;
p = new int[N+1][N+1];
f = new int[N+1];
for(int i=0;i<N-1;i++) {
in.nextToken();
int u = (int)in.nval;
in.nextToken();
int v = (int)in.nval;
f[v]=u;
}
for(int i=1;i<=N;i++) {
int now = i;
p[i][1]=1;
while(f[now]!=0) {
p[i][f[now]]=1;
now = f[now];
}
}
for(int i=0;i<Q;i++) {
in.nextToken();
int x = (int)in.nval;
in.nextToken();
int y = (int)in.nval;
if(p[y][x]==1)System.out.println("YES");
else System.out.println("NO");
}
}
}
F 防御力
小明最近在玩一款游戏。对游戏中的防御力很感兴趣。
我们认为直接影响防御的参数为“防御性能”，记作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，否则按无效代码处理。
解析：这是道数学题。比赛时证明最优结论不太现实，而且我也不喜欢动脑子，可以半猜半证知，对于所有的情况，最优情况很大概率在：
（1）A递增使用，B递减使用；
（2）A递增使用，B递增使用；
（3）A递减使用，B递减使用；
（4）A递减使用，B递增使用
四种情况中的一种，因为这个数据规模注定了无法求出所有的情况，那么答案一定满足一定的规律，这四种是最有可能的情况，只要全求出来选择d最大中字典序最小的那个就行。O（n）的效率可以过所有样例。
通过java api对A，B进行sort，然后四次遍历求出四种情况下的d，取最大值最小字典序的那个进行输出。由于这个思路的代码实现很简单，而目前我还无法证明最优解的正确性，所以代码的实现就先不贴了。
2759
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
