9 练功
题目
【问题描述】
小明每天都要练功，练功中的重要一项是梅花桩。
小明练功的梅花桩排列成 n 行 m 列，相邻两行的距离为 1，相邻两列的距离也为 1。
小明站在第 1 行第 1 列上，他要走到第 n 行第 m 列上。小明已经练了一段时间，他现在可以一步移动不超过 d 的距离（直线距离）。
小明想知道，在不掉下梅花桩的情况下，自己最少要多少步可以移动到目标。
【输入格式】
输入的第一行包含两个整数 n, m，分别表示梅花桩的行数和列数。
第二行包含一个实数 d（最多包含一位小数），表示小明一步可以移动的距离。
【输出格式】
输出一个整数，表示小明最少多少步可以到达目标。
【样例输入】
3 4
1.5
【样例输出】
3
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20，1 <= d <= 20。
对于 60% 的评测用例，2 <= n, m <= 100，1 <= d <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= d <= 100。
解析
走方格的问题到某一个终点求最少的步数，采用bfs遍历（广度优先遍历）。
本题中以当前点为圆心，d为半径的圆内的桩，都是一步可达的点。由于要往右下角，故只考虑右下四分之一圆内的桩，将这些点加入bfs队列中，不加所有的点，而是加比较靠近圆边缘的点。如下图所示。bfs遍历像水波波纹一样扩散。
代码如下：
package com.lanqiao.mike;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Meihuazhuang {
static class Point{
int x,y,step;
public Point(int x,int y,int step){
this.x=x;
this.y=y;
this.step=step;
}
}
static int[][] vis;
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
double d=sc.nextDouble();
// long start=System.currentTimeMillis();
vis=new int[n][m];
Queue<Point> q=new LinkedList<>();
q.add(new Point(0, 0, 0));
out:
while(!q.isEmpty()){
Point top=q.poll();
int top_x=top.x;
int top_y=top.y;
int step=top.step;
//在右下边四分之一圆内搜索一步到达的点，加入队列
//注意题目是(1,1)->(n,m)
//但程序是(0,0)->(n-1,m-1)
int delta_y=(int) d;//y方向的增量（整数）
for(int delta_x=0;delta_x<n-top_x;delta_x++){//x方向的增量（整数）
//当弹出的是Point(0,0,0),delta_x=0,1,2,...,n-1,对于每一个delta_x
//求出最大的delta_y
if (delta_x>d) {
break;
}
//计算出可能的最大值delta_y
while(delta_x*delta_x+delta_y*delta_y>d*d&&delta_y>=0){
//delta_y最大可为d,逐渐缩小直到进入圆内
delta_y--;
}
//构造新的点
int nx=top_x+delta_x;//前面for循环的判断条件保证top_x+delta_x<n
int ny=top_y+delta_y;
if (ny>=m) {
ny=m-1;
}
if (vis[nx][ny]==0) {
if (nx==n-1&&ny==m-1) {
System.out.println(step+1);
break out;//中断while循环，bfs遍历就像水中的波纹朝外面扩散
}
vis[nx][ny]=1;
q.add(new Point(nx, ny, step+1));
}
}
}
// System.out.println("dure:"+(System.currentTimeMillis()-start)/1000);
}
}
测试用例：
1000 1000
100
15
3 4
1.5
3
总结：走方格到某一个点的问题用bfs（广度优先遍历），全排列组合问题用dfs（深度优先遍历）
10 积木
题目
【问题描述】
小明用积木搭了一个城堡。
为了方便，小明在搭的时候用的是一样大小的正方体积本，搭在了一个 n 行 m 列的方格图上，每个积木正好占据方格图的一个小方格。
当然，小明的城堡并不是平面的，而是立体的。小明可以将积木垒在别的积木上面。当一个方格上的积木垒得比较高时，就是一个高塔，当一个方格上没有积木时，就是一块平地。
小明的城堡可以用每个方格上垒的积木层数来表示。例如，下面就表示一个城堡。
9 3 3 1
3 3 3 0
0 0 0 0
这个城堡南面和东面都有空地，西北面有一个大房子，在西北角还有一个高塔，东北角有一个车库。
现在，格格巫要来破坏小明的城堡，他施了魔法水淹小明的城堡。
如果水的高度为1，则紧贴地面的那些积木要被水淹，在上面的例子中，有7块积木要被水淹。
如果水的高度为2，则更多积木要被水淹，在上面的例子中，有13块积木要被水淹。
给定小明的城堡图，请问，水的高度依次为1, 2, 3, …, H 时，有多少块积木要被水淹。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行，每行 m 个整数，表示小明的城堡中每个位置积木的层数。
接下来包含一个整数 H，表示水高度的上限。
【输出格式】
输出 H 行，每行一个整数。第 i 的整数表示水的高度为 i 时被水淹的积木数量。
【样例输入】
3 4
9 3 3 1
3 3 3 0
0 0 0 0
10
【样例输出】
7
13
19
20
21
22
23
24
25
25
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n, m <= 100，1 <= H <= 100，积木层数不超过100；
对于 70% 的评测用例，1 <= n, m <= 1000，1 <= H <= 1000，积木层数不超过1000；
对于所有评测用例，1 <= n, m <= 1000，1 <= H <= 100000，积木层数不超过1000000000。
解析：这是一个排序计数的问题。
代码1：如下
package com.lanqiao.mike;
import java.util.Scanner;
public class JiMu {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
int[][] arr=new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
arr[i][j]=scanner.nextInt();
}
}
int H=scanner.nextInt();
int[] sum=new int[H];
int[] ans=new int[H];
int an=0;
for (int k = 0; k < H; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j]>=k+1) {
sum[k]++;
}
}
}
an+=sum[k];
ans[k]=an;
}
for (int i = 0; i < H; i++) {
System.out.println(ans[i]);
}
}
}
测试用例如下：
3 4
9 3 3 1
3 3 3 0
0 0 0 0
10
7
13
19
20
21
22
23
24
25
25
代码评价：其中有一个三重循环，若n=1000,m=1000,H=100000，则时间复杂度为1011>>108 （此为计算机本身的计算效率），算法效率低。
代码2如下：
package com.lanqiao.mike;
import java.util.Arrays;
import java.util.Scanner;
public class JiMu2 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
int len=n*m;
int[] a=new int[len];//用一维数组存储积木的层数
int a_index=0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[a_index++]=scanner.nextInt();
}
}
int H=scanner.nextInt();
Arrays.sort(a);//默认从小到大排序,这步排序很关键
// System.out.println(Arrays.toString(a));
int pos=0;
long last=0;
for (int i = 1; i <=H; i++) {//水的高度为1,2,...,H
while(pos<len&&a[pos]<i){
pos++;
}
//循环结束后得到第一个a[pos]>=i
last=len-pos+last;//巧妙，通过排序，避免累加1的情况，直接一步到位
System.out.println(last);
}
}
}
测试用例如下：
3 4
9 3 3 1
3 3 3 0
0 0 0 0
10
7
13
19
20
21
22
23
24
25
25
代码评价：方格上的积木层数用一维数组存储，再加以排序，再在后面for-while循环里确定大于等于水的高度的索引位置pos，len-pos直接算出被淹没的积木数，这里是优化算法的关键，其时间复杂度为O(106) ，因为pos一直往前加1，直至a数组遍历完。此后被淹没的积木数总是不变。这里的算法效率比上一个程序的三重循环累加1的效率高多啦。
————————————————
版权声明：本文为CSDN博主「小9」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhengwei223/article/details/106166588
扫一扫
1929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
