1. 猜灯谜
标题：猜灯谜
A 村的元宵节灯会上有一迷题：
请猜谜 * 请猜谜 = 请边赏灯边猜
小明想，一定是每个汉字代表一个数字，不同的汉字代表不同的数字。
请你用计算机按小明的思路算一下，然后提交“请猜谜”三个字所代表的整数即可。
请严格按照格式，通过浏览器提交答案。
注意：只提交一个3位的整数，不要写其它附加内容，比如：说明性的文字。
解析：写几层循环暴力过就行
package A;
public class Main {
public static void main(String[] args) {
for (int a = 1; a < 10; a++) {
for (int b = 0; b < 10; b++) {
for (int c = 0; c < 10; c++) {
for (int d = 0; d < 10; d++) {
for (int e = 0; e < 10; e++) {
for (int f = 0; f < 10; f++) {
int s = a*100 + b*10 + c;
int t = a*100000 + d*10000 + e*1000 + f*100 + d*10 + b;
if (s*s == t) {
System.out.println(s + "*" + s + "=" + t);
}
}
}
}
}
}
}
}
}
// 我的答案：897
答案是：897
2. 连续奇数和
小明看到一本书上写着：任何数字的立方都可以表示为连续奇数的和。
比如：
2^3 = 8 = 3 + 5
3^3 = 27 = 7 + 9 + 11
4^3 = 64 = 1 + 3 + ... + 15
虽然他没有想出怎么证明，但他想通过计算机进行验证。
请你帮助小明写出 111 的立方之连续奇数和表示法的起始数字。如果有多个表示方案，选择起始数字小的方案。
请严格按照要求，通过浏览器提交答案。
注意：只提交一个整数，不要写其它附加内容，比如：说明性的文字。
解析：同样也是暴力题
package B;
public class Main {
public static void main(String[] args) {
int n = 111*111*111;
// 起始数字
for (int i = 1; i <= n; i += 2) {
int sum = i;
for (int j = i + 2; j <= n; j += 2) {
sum += j;
if (sum == n) {
System.out.println("起始数字" + i + "结束数字" + j);
}
if (sum > n) break;
}
}
}
}
我的答案：371
3. 快速排序
标题：快速排序
快速排序算法是典型的分治思想的运用。它使用某个key把全部元素分成两组，其中一组的元素不大于另一组。然后对这两组再次进行递归排序。
以下代码实现了快速排序。请仔细阅读代码，填写缺少代码的部分。
static void f(int[] x, int left, int right)
{
if(left >= right) return;
int key = x[(left+right)/2];
int li = left;
int ri = right;
while(li<=ri){
while(x[ri]>key) ri--;
while(x[li]<key) li++;
if(________________){ //填空位置
int t = x[li];
x[li] = x[ri];
x[ri] = t;
li++;
ri--;
}
}
if(li < right) f(x, li, right);
if(ri > left) f(x, left, ri);
}
请分析代码逻辑，并推测划线处的代码，通过网页提交。
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！
解析：在快排交换元素的时候，应该保证左指针小于等于右指针
答案：li <= ri
4. 九宫重排
标题：九宫重排
如图1的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成图2所示的局面。
我们把图1的局面记为：12345678.
把图2的局面记为：123.46758
显然是按从上到下，从左到右的顺序记录数字，空格记为句点。
图1.
图2.
本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。
例如：
输入数据为：
12345678.
123.46758
则,程序应该输出：
3
再如：
输入：
13524678.
46758123.
则，程序输出：
22
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
解析
可以把空白格当成一个小人，然后向上下左右移动（移动后与元素交换位置），看是否能达到终态。
使用BFS，每次移动后，保存当前状态，与终态比较，是否一致，如果一致就输出步数
我们需要将走过的状态存到set中，不能重复走
代码：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.HashSet;
public class Main{
static String start, end;
static int[] move = {-3, 3, -1, 1}; // 上下左右
static HashSet<String> hs = new HashSet<String>();
static class Board {
String chess; // 棋盘状态
int pos; // 坐标
int cnt; // 步数
public Board(String chess, int pos, int cnt) {
this.chess = chess;
this.pos = pos;
this.cnt = cnt;
}
}
// 交换下标a b的两个字符
static String swap(String s, int a, int b) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (i == a) {
sb.append(s.charAt(b));
} else if (i == b) {
sb.append(s.charAt(a));
} else {
sb.append(s.charAt(i));
}
}
return sb.toString();
}
static void BFS(Board s) {
ArrayDeque<Board> q = new ArrayDeque<>();
q.offerLast(s);
hs.add(s.chess);
while(!q.isEmpty()) {
Board e = q.removeFirst();
if (e.chess.equals(end)) {
System.out.println(e.cnt);
return ;
}
for (int i = 0; i < 4; i++) {
// 在边上的时候不能左右移动
if ((e.pos == 3 || e.pos == 6) && i == 2) continue;
if ((e.pos == 2 || e.pos == 5) && i == 3) continue;
int pos = e.pos + move[i];
if (pos >= 0 && pos < 9) {
int cnt = e.cnt + 1;
// 交换位置 e.pos, pos
String chess = swap(e.chess, e.pos, pos);
if (!hs.contains(chess)) {
hs.add(chess);
Board t = new Board(chess, pos, cnt);
q.offerLast(t);
}
}
}
}
System.out.println("-1");
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
start = br.readLine();
end = br.readLine();
// 找到起点, 开始搜索
for (int i = 0; i < start.length(); i++) {
if (start.charAt(i) == '.') {
String s = start;
Board b = new Board(s, i, 0);
BFS(b);
break;
}
}
}
}
可以将棋盘状态用一个大数字表示，将.号转换为0。
这样set判重速度会更快，但代码量会增加一些
5. 格子刷油漆
比较难的dp题。告辞
6. 农场阳光
标题：农场阳光
X星球十分特殊，它的自转速度与公转速度相同，所以阳光总是以固定的角度照射。
最近，X星球为发展星际旅游业，把空间位置出租给Y国游客来晒太阳。每个租位是漂浮在空中的圆盘形彩云（圆盘与地面平行）。当然，这会遮挡住部分阳光，被遮挡的土地植物无法生长。
本题的任务是计算某个农场宜于作物生长的土地面积有多大。
输入数据的第一行包含两个整数a, b，表示某农场的长和宽分别是a和b，此时，该农场的范围是由坐标(0, 0, 0), (a, 0, 0), (a, b, 0), (0, b, 0)围成的矩形区域。
第二行包含一个实数g，表示阳光照射的角度。简单起见，我们假设阳光光线是垂直于农场的宽的，此时正好和农场的长的夹角是g度，此时，空间中的一点(x, y, z)在地面的投影点应该是(x + z * ctg(g度), y, 0)，其中ctg(g度)表示g度对应的余切值。
第三行包含一个非负整数n，表示空中租位个数。
接下来 n 行，描述每个租位。其中第i行包含4个整数xi, yi, zi, ri，表示第i个租位彩云的圆心在(xi, yi, zi)位置，圆半径为ri。
要求输出一个实数，四舍五入保留两位有效数字，表示农场里能长庄稼的土地的面积。
例如：
用户输入：
10 10
90.0
1
5 5 10 5
程序应该输出：
21.46
再例如：
用户输入：
8 8
90.0
1
4 4 10 5
程序应该输出：
1.81
样例3：
用户输入：
20 10
45.0
2
5 0 5 5
8 6 14 6
程序输出：
130.15
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
解析
这道题挺难的，很菜，只能暴力混分。首先把投影点计算出来，保存好
然后我们提高精度，暴力枚举点到每个圆心的距离，如果这个点到任何一个圆心都大于该圆对应的半径，说明这个点适合作物生长
package F;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
static class Point {
double x, y, r;
public Point(double x, double y, double r) {
this.x = x;
this.y = y;
this.r = r;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double rectLength = sc.nextDouble();
double rectWidth = sc.nextDouble();
double g = sc.nextDouble();
int n = sc.nextInt();
ArrayList<Point> list = new ArrayList<Point>();
for (int i = 0; i < n; i++) {
double x = sc.nextDouble();
double y = sc.nextDouble();
double z = sc.nextDouble();
double r = sc.nextDouble();
// 投影点
double nx = x + z/Math.tan(Math.toRadians(g));
double ny = y;
list.add(new Point(nx, ny, r));
}
int prec = 300;
int sum = 0;
for (int i = 0; i < rectLength*prec; i++) {
for (int j = 0; j < rectWidth*prec; j++) {
boolean flag = true;
// 求该点到 每个圆心的距离
for (int k = 0; k < list.size(); k++) {
Point p = list.get(k);
// (i, j) 到 点p的距离
double dis = Math.sqrt((p.x*prec - i)*(p.x*prec - i) + (p.y*prec - j)*(p.y*prec - j));
// 该点在阴影圆内
if (dis <= p.r*prec) {
flag = false;
break;
}
}
if (flag) {
sum++;
}
}
}
System.out.println(String.format("%.2f", sum*1.0 / (prec*prec)));
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
