2005年问题一
题目描述
12翻一下是21,34翻一下是43,12+34是46,46翻一下是64,现在又任意两个正整数,问他们两个数反转的和是否等于两个数的和的反转。
输入描述:
每行两个正整数a和b(0<a,b<=10000)。
输出描述:
如果满足题目的要求输出a+b的值,否则输出NO。
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] parts = br.readLine().split(" ");
StringBuilder a = new StringBuilder(parts[0]);
StringBuilder b = new StringBuilder(parts[1]);
a.reverse();
b.reverse();
int sum1 = Integer.parseInt(a.reverse().toString()) + Integer.parseInt(b.reverse().toString());
int sum2 = Integer.parseInt(parts[0]) + Integer.parseInt(parts[1]);
if(sum1 == sum2) System.out.println(sum1);
else System.out.println("NO");
} catch(IOException e) {
e.printStackTrace();
}
}
}
问题二
题目描述
给你一串路径,譬如: a\b\c a\d\e b\cst d\ 你把这些路径中蕴含的目录结构给画出来,子目录直接列在父目录下面,并比父目录向右缩一格,就像这样: a b c d e b cst d 同一级的需要按字母顺序排列,不能乱。
输入描述:
每行有一个字串表示一个路径,长度小于50。
输出描述:
输出目录结构。
示例:
a\b\c
a\d\e
b\cst
d\
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
ArrayList<String> list = new ArrayList<>();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str = br.readLine()) != null) {
if(str.contentEquals("")) break;
list.add(str);
}
Collections.sort(list);
String[] parts1 = list.get(0).split("\\\\");
for(int i = 0; i < parts1.length; i++) {
StringBuilder s = new StringBuilder();
for(int j = 0; j < i; j++) {
s.append(" ");
}
s.append(parts1[i]);
System.out.println(s);
}
for(int k = 1; k < list.size(); k++) {
boolean mark = true;
String[] parts2 = list.get(k).split("\\\\");
for(int i = 0; i < parts2.length; i++) {
if(mark && i < parts1.length && parts2[i].contentEquals(parts1[i])) continue;
else mark = false;
StringBuilder s = new StringBuilder();
for(int j = 0; j < i; j++) s.append(" ");
s.append(parts2[i]);
System.out.println(s);
}
parts1 = Arrays.copyOf(parts2, parts2.length);
}
} catch(IOException e) {
e.printStackTrace();
}
}
}
问题三
题目描述
有一个6*6的棋盘,每个棋盘上都有一个数值,现在又一个起始位置和终止位置,请找出一个从起始位置到终止位置代价最小的路径: 1、只能沿上下左右四个方向移动 2、总代价是没走一步的代价之和 3、每步(从a,b到c,d)的代价是c,d上的值与其在a,b上的状态的乘积 4、初始状态为1 每走一步,状态按如下公式变化:(走这步的代价%4)+1。
输入描述:
每组数据一开始为6*6的矩阵,矩阵的值为大于等于1小于等于10的值,然后四个整数表示起始坐标和终止坐标。
输出描述:
输出最小代价。
示例1
输入
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
0 0 5 5
输出
23
import java.util.*;
import java.io.*;
public class Main {
static int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
static int[][] nums = new int[6][6];
static int startX;
static int startY;
static int endX;
static int endY;
static int res = Integer.MAX_VALUE;
static boolean[][] visited = new boolean[6][6];
public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
for(int i = 0; i < 6; i++) {
String[] parts = br.readLine().split(" ");
for(int j = 0; j < 6; j++) {
nums[i][j] = Integer.parseInt(parts[j]);
}
}
String[] parts = br.readLine().split(" ");
startX = Integer.parseInt(parts[0]);
startY = Integer.parseInt(parts[1]);
endX = Integer.parseInt(parts[2]);
endY = Integer.parseInt(parts[3]);
dfs(startX, startY, 0, 1);
System.out.println(res);
} catch(IOException e) {
e.printStackTrace();
}
}
public static void dfs(int x, int y, int count, int state) {
if(x == endX && y == endY) {
if(count < res) res = count;
return;
}
if(count >= res) return;
visited[x][y] = true;
for(int i = 0; i < 4; i++) {
int nx = x + directions[i][0];
int ny = y + directions[i][1];
if(inArea(nx, ny) && !visited[nx][ny]) {
int cur_val = state*nums[nx][ny];
dfs(nx, ny, count+cur_val, cur_val%4+1);
}
}
visited[x][y] = false;
}
public static boolean inArea(int x, int y) {
if(x < 0 || y < 0 || x >= 6 || y >= 6) return false;
return true;
}
}