题目标签
1 | 2 | 3 | 4 | 5 | |||||
第几天 | 方格计数 | 复数幂 | 测试次数 | 快速排序 | |||||
6 | 7 | 8 | 9 | 10 | |||||
递增三元组 | 螺旋折线 | 日记统计 | 全球变暖 | 堆的计数 |
1.第几天
标题：第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
125
package 第几天;
public class Main {
public static void main(String[] args) {
int sum = 0;
sum += 31;
sum+= 29;
sum+= 31;
sum+= 30;
sum += 4;
System.out.println(sum);
}
}
2.方格计数
标题：方格计数
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
3137548
package 方格计数;
public class Main {
public static void main(String[] args) {
int count=0;
for(int i=1;i<=1000;i++) {
for(int j=1;j<=1000;j++) {
if(i*i+j*j<=1000*1000){
count++;
}
}
}
System.out.println(count*4);
}
}
3.复数幂
标题：复数幂
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 "实部±虚部i" 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
122-597i
package 第九届B;
import java.math.BigInteger;
public class T3 {
public static void main(String[] args) {
//(a+bi)(c+di)=(ac-bd)+(bc+ad)i
BigInteger a = new BigInteger("2");
BigInteger b = new BigInteger("3");
BigInteger c = new BigInteger("2");
BigInteger d = new BigInteger("3");
BigInteger e = new BigInteger("2");
BigInteger f = new BigInteger("3");
for (int i = 1; i < 5; i++) {
e = a.multiply(c).subtract(b.multiply(d));
f = b.multiply(c).add(a.multiply(d));
a = e;
b = f;
}
System.out.print(a);
if (b == b.abs()) {
System.out.print("+");
}
System.out.print(b);
System.out.print("i");
}
}
4.测试次数
标题：测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
19
package 第九届B;
public class T4 {
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
if ((i*i*i+i)/6>1000) {
System.out.println(i);
return;
}
}
}
}
5.快速排序
标题：快速排序
以下代码可以从数组a[]中找出第k小的元素。
它使用了类似快速排序中的分治算法，期望时间复杂度是O(N)的。
请仔细阅读分析源码，填写划线部分缺失的内容。
a,i+1,r,r-k+1 最后一个参数猜的成分比较大。
import java.util.Random;
public class Main{
public static int quickSelect(int a[], int l, int r, int k) {
Random rand = new Random();
int p = rand.nextInt(r - l + 1) + l;
int x = a[p];
int tmp = a[p]; a[p] = a[r]; a[r] = tmp;
int i = l, j = r;
while(i < j) {
while(i < j && a[i] < x) i++;
if(i < j) {
a[j] = a[i];
j--;
}
while(i < j && a[j] > x) j--;
if(i < j) {
a[i] = a[j];
i++;
}
}
a[i] = x;
p = i;
if(i - l + 1 == k) return a[i];
if(i - l + 1 < k) return quickSelect(a,i+1,r,r-k+1 ); //填空
else return quickSelect(a, l, i - 1, k);
}
public static void main(String args[]) {
int [] a = {1, 4, 2, 8, 5, 7};
System.out.println(quickSelect(a, 0, 5, 4));
}
}
6.递增三元组
标题：递增三元组
给定三个整数数组
A = [A1, A2, ... AN],
B = [B1, B2, ... BN],
C = [C1, C2, ... CN]，
请你统计有多少个三元组(i, j, k) 满足：
1. 1 <= i, j, k <= N
2. Ai < Bj < Ck
【输入格式】
第一行包含一个整数N。
第二行包含N个整数A1, A2, ... AN。
第三行包含N个整数B1, B2, ... BN。
第四行包含N个整数C1, C2, ... CN。
对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000
【输出格式】
一个整数表示答案
【输入样例】
3
1 1 1
2 2 2
3 3 3
【输出样例】
27
package 递增三元组;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n =sr.nextInt();
long s = System.currentTimeMillis();
int[] A = new int[n];
int[] B = new int[n];
int[] C = new int[n];
for (int i = 0; i < n; i++) {
A[i] = sr.nextInt();
}
for (int i = 0; i < n; i++) {
B[i] = sr.nextInt();
}
for (int i = 0; i < n; i++) {
C[i] = sr.nextInt();
}
//排序数组,这样操作时就可以即时舍弃循环,减少耗时
Arrays.sort(A);
Arrays.sort(B);
Arrays.sort(C);
System.out.println(System.currentTimeMillis()-s);
int minIdex_i = 0;//从i的上次最小地方开始
int minIdex_j = 0;//从j的上次最小地方开始
long res = 0;
for (int i = 0; i < A.length; i++) {
for (int j = minIdex_i; j < B.length; j++) {
if (A[i] < B[j]) {
minIdex_i = j;
for (int k = minIdex_j; k < C.length; k++) {
if (B[j] < C[k]) {
minIdex_j = k;
res++;
}
}
minIdex_i = 0;
minIdex_j = 0;
}
}
}
System.out.println(res);
return;
}
}
7.螺旋折线
标题：螺旋折线
如图p1.pgn所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。
例如dis(0, 1)=3, dis(-2, -1)=9
给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？
【输入格式】
X和Y
对于40%的数据，-1000 <= X, Y <= 1000
对于70%的数据，-100000 <= X， Y <= 100000
对于100%的数据, -1000000000 <= X, Y <= 1000000000
【输出格式】
输出dis(X, Y)
【输入样例】
0 1
【输出样例】
3
package 螺旋折线;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
long X = sr.nextLong();
long Y = sr.nextLong();
// 判断所在点所在的正方形
long n = Math.max(Math.abs(X) , Math.abs(Y))-1;
long sum = 0;
for (int i = (int)n*2; i >= 2; i-=2) {
sum += i*4;
}
System.out.println(sum);
long nx = -n;
long ny = -n;
if (nx==X && ny == Y) {
System.out.println(sum);
return;
}
//往左挪一步
nx--;sum++;
if (nx==X && ny == Y) {
System.out.println(sum);
return;
}
//往上走边长发生变化
n+=1;
for (int i = 0; i < n; i++) {//上
ny++;sum++;
if (nx==X && ny == Y) {
System.out.println(sum);
return;
}
}
//往右走边长发生变化
n+=1;
for (int i = 0; i < n; i++) {
nx++;sum++;
if (nx==X && ny == Y) {
System.out.println(sum);
return;
}
}
for (int i = 0; i < n; i++) {
ny--;sum++;
if (nx==X && ny == Y) {
System.out.println(sum);
return;
}
}
n+=1;
//往左走边长发生变化
for (int i = 0; i < n; i++) {
nx--;sum++;
if (nx==X && ny == Y) {
System.out.println(sum);
return;
}
}
}
}
8.日记统计
现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。
具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。
给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。
【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。
对于50%的数据，1 <= K <= N <= 1000
对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000
【输出格式】
按从小到大的顺序输出热帖id。每个id一行。
【输入样例】
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
【输出样例】
1
3
package 日志统计;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int N,D,K;
N = sr.nextInt();
D = sr.nextInt();
K = sr.nextInt();
ArrayList<Integer> id = new ArrayList<Integer>();
Object [] arr = new Object[100000];
for (int i = 0; i < N; i++) {
int ts = sr.nextInt();
int td = sr.nextInt();
if (arr[ts]==null) {
arr[ts] = new ArrayList<Integer>();
}
ArrayList<Integer> l = (ArrayList<Integer>) arr[ts];
l.add(td);
arr[ts] = l;
}
ArrayList<Integer> l;
for (int i = 0; i < arr.length-D; i++) {
//时间间隔为D的区间
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int j = i; j < i+D; j++) {
if (arr[j]!=null) {
l = (ArrayList<Integer>)arr[j];
for (int k = 0; k < l.size(); k++) {
int temp = l.get(k);
if (map.containsKey(temp)) {
map.put(temp, map.get(temp)+1);
}else {
map.put(temp, 1);
}
}
for (Integer integer : map.keySet()) {
if (map.get(integer) >= K && !id.contains(integer)) {
id.add(integer);
}
}
}
}
}
System.out.println(id);
}
}
9.全球变暖
标题：全球变暖
你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
.......
.##....
.##....
....##.
..####.
...###.
.......
【输出样例】
1
package 全球变暖;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main {
static char[][] map;
static boolean[][] check;
static char count = '0';
static int[] dx = {1,-1,0,0};
static int[] dy = {0,0,-1,1};
static Queue<Integer> x = new LinkedList<Integer>();
static Queue<Integer> y = new LinkedList<Integer>();
static HashSet<Integer> set = new HashSet<Integer>();
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int m = sr.nextInt();
map = new char[m][m];
check = new boolean[m][m];
//创建地图
for (int i = 0; i < map.length; i++) {
String s = sr.next();
for (int j = 0; j < map[i].length; j++) {
char temp = s.charAt(j);
map[i][j] = temp;
}
}
//标识群岛编号
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[0].length; j++) {
if (map[i][j]=='#') {
count++;
x.add(i);
y.add(j);
map[i][j] = count;
bfs();
}
}
}
//全球变暖导致陆地淹没
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[0].length; j++) {
if (map[i][j]!='.') {
f( i, j);
}
}
}
//输出编号后陆地状态
System.out.println(count);
for (int i = 0; i < map.length; i++) {
System.out.println(Arrays.toString(map[i]));
}
//寻找没有被淹没的陆地编号
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[0].length; j++) {
if(map[i][j]!='.' && !check[i][j])
set.add((int)(map[i][j]-'0'));
}
}
//输出淹没后状态
for (int i = 0; i < check.length; i++) {
for (int j = 0; j < check[0].length; j++) {
if (!check[i][j]) {
System.out.print(map[i][j]+"\t");
}else {
System.out.print(check[i][j]+"\t");
}
}System.out.println();
}
System.out.println(set);
System.out.println(count);
}
private static void bfs() {
while (!x.isEmpty()) {
int i = x.poll();
int j = y.poll();
for (int k = 0; k < 4; k++) {
int nx = i + dx[k];
int ny = j + dy[k];
if (nx >= 0 && ny >= 0 && nx < map.length && ny < map[0].length && map[nx][ny] == '#') {
x.add(nx);
y.add(ny);
map[nx][ny] = count;
}
}
}
}
private static void f(int x, int y) {
if (x -1 >= 0 && map[x-1][y]=='.') {//上
check[x][y] = true;
}
if (x +1 < map.length && map[x+1][y]=='.') {//下
check[x][y] = true;
}
if (y - 1 >= 0 && map[x][y-1] =='.') {//左
check[x][y] = true;
}
if (y + 1 >= 0 && map[x][y+1] =='.') {//右
check[x][y] = true;
}
}
}
10.堆的计数
标题：堆的计数
我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。
假设N个节点的权值分别是1~N，你能求出一共有多少种不同的小根堆吗？
例如对于N=4有如下3种：
1
/ \
2 3
/
4
1
/ \
3 2
/
4
1
/ \
2 4
/
3
由于数量可能超过整型范围，你只需要输出结果除以1000000009的余数。
【输入格式】
一个整数N。
对于40%的数据，1 <= N <= 1000
对于70%的数据，1 <= N <= 10000
对于100%的数据，1 <= N <= 100000
【输出格式】
一个整数表示答案。
【输入样例】
4
【输出样例】
3
import java.util.Scanner;
public class Main{
private static final int MOD = 1000000009;
private static int N;
private static int[] size; //记录每个节点的size
private static long[] jie; //记录1~N的阶乘
private static long[] ni; //记录1~N的阶乘的逆元
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
size = new int[N + 1];
jie = new long[N + 1];
ni = new long[N + 1];
initSize();
initJie();
System.out.println(dp());
sc.close();
}
private static long dp() {
long[] d = new long[N + 1]; //d[i]表示的是i号节点作为根,小根堆的种数
for(int x = N; x >= 1; x--) {
if(2 * x + 1 <= N) {
d[x] = c(size[x] - 1, size[2 * x]) * d[2 * x] % MOD * d[2 * x + 1] % MOD;
}else if(2 * x <= N) {
d[x] = c(size[x] - 1, size[2 * x]) * d[2 * x] % MOD;
}else {
d[x] = 1;
}
}
return d[1];
}
private static void initJie() {
jie[0] = 1;
ni[0] = 1;
for(int i = 1; i <= N; i++) {
jie[i] = jie[i - 1] * i % MOD;
ni[i] = qpow(jie[i], MOD - 2);
}
}
private static long qpow(long a, int n) {
if(a == 0) {
return 0;
}
long ans = 1;
long x = a;
while(n > 0) {
if((n & 1) == 1) {
ans = ans * x % MOD;
}
n >>= 1;
x = x * x % MOD;
}
return ans;
}
private static void initSize() {
for(int i = N; i >= 1; i--) {
size[i] = (2 * i <= N ? size[2 * i] : 0) + (2 * i + 1 <= N ? size[2 * i + 1] : 0) + 1;
}
}
private static long c(int n, int r) {
return jie[n] * ni[r] % MOD * ni[n-r] % MOD;
}
}
