目录
1.第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？注意：需要提交的是一个整数，不要填写任何多余内容。
解法一：直接计算
2000年是闰年，2月有29天
1月：31天，2月：29天，3月：31天，4月：30天，5月：4天
31+29+31+30+4=125
解法二：Excel
124是相差天数，第几天要再加1
答案：125
2.方格计数
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
注意：需要提交的是一个整数，不要填写任何多余内容。
public class Main{
public static void main(String[] args) {
int r=1000;
int count = 0;
for (int i=1;i<=r;i++){
for (int k=1;k<=r;k++){
if ((i*i+k*k)<=r*r){
count++;
}
}
}
System.out.println(count*4);
}
}答案：3137548
3.复数幂
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 “实部±虚部i” 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。
(a+bi)(c+di)=(ac-bd)+(ad+bc)i
import java.math.BigInteger;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
Scanner sc = new Scanner(System.in);
PrintStream ps=new PrintStream(new FileOutputStream("E:/file.txt"));
System.setOut(ps);
BigInteger real = BigInteger.valueOf(2); //实部
BigInteger xu = BigInteger.valueOf(3); //虚部
BigInteger sumreal = BigInteger.valueOf(2); //最后的总和的实部存储在这
BigInteger sumxu = BigInteger.valueOf(3); //最后总和的虚部存储在这
for(long i=0;i<123455;i++) {
BigInteger tmpreal = sumreal; //临时变量用于计算虚部的变化
BigInteger tmpxu = sumxu;
sumreal=sumreal.multiply(real); //计算实部的变化
sumxu=sumxu.multiply(xu);
sumreal = sumreal.subtract(sumxu);
tmpreal=tmpreal.multiply(xu); //计算虚部变化
tmpxu=tmpxu.multiply(real);
tmpreal=tmpreal.add(tmpxu);
sumxu=tmpreal;
}
System.out.println(sumreal.toString()); //输出实数部分
System.out.println(sumxu.toString()); //输出虚数部分
}
}4.测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
import java.util.Scanner;
public class Main {
private static int maxn = 1005;
private static int[][] dp = new int[maxn][10];
private static int inf = 0x3f3f3f3f;
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
int m = cin.nextInt();
for(int i = 0; i <= n; ++i) {
for(int j = 0; j <= m; ++j) {
dp[i][j] = inf;
}
}
System.out.println(work(n, m));
}
private static int work(int n, int m) {
if(dp[n][m] != inf) {
return dp[n][m];
}
if(n == 0) {
return dp[n][m] = 0;
}
if(m == 1) {
return dp[n][m] = n;
}
for(int i = 1; i <= n; ++i) {
dp[n][m] = Math.min(dp[n][m], 1 + Math.max(work(i-1, m-1), work(n-i, m)));
}
return dp[n][m];
}
}答案：19
5.快速排序
以下代码可以从数组a[]中找出第k小的元素。
它使用了类似快速排序中的分治算法，期望时间复杂度是O(N)的。
请仔细阅读分析源码，填写划线部分缺失的内容。
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(___________________); // 填空
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));
}
}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)// (1)说明到底了
return a[i];
if (i - l + 1 < k)
return quickSelect(a, i + 1, r, k - i + l - 1); // 填空
// qsort(a, i + 1, right);
// (3)先试试k，
// (4)再考虑：k要移动到等于（i - l + 1），试试k-(i - l + 1)
else
// i - l + 1 > k
return quickSelect(a, l, i - 1, k);// (2)qsort(a, left, 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));
// int [] a = {1, 4, 2, 8, 5, 7, 23, 58, 16, 27, 55, 13, 26, 24, 12, 2};
// System.out.println(quickSelect(a, 0, a.length-1, 6));
}
}答案：a, i + 1, r, k - i + l - 1
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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] A = new int[n];
int[] B = new int[n];
int[] C = new int[n];
for (int i = 0; i < n; i++)
A[i] = sc.nextInt();
for (int i = 0; i < n; i++)
B[i] = sc.nextInt();
for (int i = 0; i < n; i++)
C[i] = sc.nextInt();
Arrays.sort(A);
Arrays.sort(B);
Arrays.sort(C);
int[] l = new int[n];
int[] r = new int[n];
long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (B[j] > A[i]) {
l[i] = n - j;
break;
}
}
if (l[i] != 0)
for (int j = 0; j < n; j++) {
if (C[j] > B[i]) {
r[i] = n - j;
sum += l[i] * r[i];
break;
}
}
}
System.out.println(sum);
}
}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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.util.Scanner;
public class Main {
static int x, y;
static int df = 0;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
x = in.nextInt();
y = in.nextInt();
if (x > 0 && y >= 0) {
int dx = Math.max(x, y);
int dy = dx;
df = (dx + dy) * (dx + dy);
if (x < dx) {
df -= (dx - x);
}
if (y < dy) {
df += (dy - y);
}
} else if (x >= 0 && y < 0) {
int dx = Math.max(Math.abs(x), Math.abs(y));
int dy = -dx;
df = (dx + Math.abs(dy)) * (dx + Math.abs(dy) + 1);
if (x < dx) {
df += (dx - x);
}
if (y > dy) {
df -= (y - dy);
}
} else if (x < 0 && y <= 0) {
int dx = -Math.max(Math.abs(x), Math.abs(y));
int dy = dx + 1;
df = (Math.abs(dx) + Math.abs(dy)) * (Math.abs(dx) + Math.abs(dy));
if (x > dx) {
df -= (x - dx);
}
if (y > dy) {
df += (y - dy);
}
} else if (x <= 0 && y > 0) {
int dx = -Math.max(Math.abs(x), Math.abs(y));
int dy = -dx;
df = (Math.abs(dx) + Math.abs(dy)) * (Math.abs(dx) + Math.abs(dy) - 1);
if (x > dx) {
df += (x - dx);
}
if (y < dy) {
df -= (y - dy);
}
}
System.out.println(df);
}
}8.日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：
ts id
表示在ts时刻编号id的帖子收到一个"赞"。
现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String args[]) {
int n, d, k; // 输入的N行每行一条日志，包含两个整数ts 和id。
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
d = sc.nextInt();
k = sc.nextInt();
ClickHot arr[] = new ClickHot[n];
for (int i = 0; i < n; i++) {
int time = sc.nextInt();
int id = sc.nextInt();
arr[i] = new ClickHot(time, id); // 存放每组数字
}
Arrays.sort(arr); // 对其进行排序
int parentId = arr[0].id; // 先拿到第一个id
boolean flag =false; // 设置一个标志
for (int i = 0; i < n; i++) {
// 我当前得id如果有k个赞得话，就是热帖
// 当前位置和以后的k个位置上都是此id，就有k个赞
// 并且时间差小于d，并且没有被输出过
if (i + k - 1 < n && arr[i + k - 1].id == parentId && arr[i + k - 1].ts - arr[i].ts < d && !flag )
{
System.out.println(parentId); // 输出这个id 因为题目中只要求输出在同一个时间段有两个赞即可
flag = true;// 这步设置变量，当后面来相同的，但是我不需要输出了，因为两个已经够了
} else if (arr[i].id != parentId) // 这步是如果我不相同id值，那么我就把这个当前的id用我现在i数组中对应的id取代
{
parentId = arr[i].id; // 把先前的id替换
flag = false; // 重新设置标志
i = i - 1; // 因为我把上面一个设置了，此时我需要向上减一，然后再做比较，这样相当于我开始时候i不做变换没我把该取代的值取代掉
}
}
}
}
class ClickHot implements Comparable<ClickHot> // 创建一个ClickHot类留存放两个每次的两个数字 一个是
// ts 是td
{
int ts, id;
ClickHot(int ts, int id) // 两个变量
{
this.ts = ts;
this.id = id;
}
@Override
public int compareTo(ClickHot o) {
if (id == o.id) // 先对id做比较其次id相同对ts做比较
return ts - o.ts;
else
return id - o.id;
}
}9.全球变暖
你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
.......
.##....
.##....
....##.
..####.
...###.
.......
【输出样例】
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.util.Scanner;
public class Main{
static int n;
static int m;
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
n=in.nextInt();
int count1=0; //、原始岛屿总数
char[][] a=new char[n][]; //a统计原始岛屿数目
char[][] b=new char[n][];
char[][] c=new char[n][];
for(int i=0;i<n;i++) {
a[i]=in.next().toCharArray();
}
for(int i=0;i<n;i++) {
b[i]=a[i];
}
for(int i=0;i<n;i++) {
c[i]=a[i];
}
m=a[0].length;
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
if(a[i][j]=='#') {
dfs(a,i,j);
count1++;
}
}
}
//System.out.println(count1); //、计算出原始岛屿总数，然后求淹没后的岛屿数，进行相减
char temp;
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
if(i!=0&&i!=n-1&&j!=0&&j!=m-1) { //、先保证不在第一行，第一列，最后一行，最后一列
temp=c[i][j];
if(temp=='#') {
if(a[i-1][j]!=temp||a[i][j-1]!=temp||a[i+1][j]!=temp||a[i][j+1]!=temp) {
b[i][j]='.';
}
}
}else { //、在这些位置直接淹没
b[i][j]='.';
}
}
}
int count2=0;
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
if(b[i][j]=='#') {
dfs2(b,i,j);
count2++;
}
}
}
System.out.println("count2 "+count2);
System.out.println(count1-count2);
}
public static void dfs2(char[][] arr,int x,int y) {
arr[x][y]='.';
//、向左
if(y>0&&arr[x][y-1]=='#') dfs(arr,x,y-1);
//、向右
if(y<m&&arr[x][y+1]=='#') dfs(arr,x,y+1);
//、向上
if(x>0&&arr[x-1][y]=='#') dfs(arr,x-1,y);
//、向下
if(x<n&&arr[x+1][y]=='#') dfs(arr,x+1,y);
}
public static void dfs(char[][] arr,int x,int y) {
arr[x][y]='.';
for(int i=-1;i<2;i++) {
for(int j=-1;j<2;j++) {
if(i+x>=0&&i+x<n&&j+y>=0&&j+y<m) {
if(i==0&&j==0)continue;
if(arr[i+x][j+y]=='#') {
dfs(arr,i+x,j+y);
}
}
}
}
}
}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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
f = new long[n + 5];
inv = new long[n + 5];
s = new int[n + 5];
dp = new long[n + 5];
f[0] = 1;
for (int i = 1; i < n + 5; i++) {
f[i] = f[i - 1] * i % mod;
inv[i] = mpow(f[i], mod - 2);
}
for (int i = n; i >= 1; i--)
// 类似堆的找孩子
s[i] = 1 + (2 * i <= n ? s[2 * i] : 0)
+ (2 * i + 1 <= n ? s[2 * i + 1] : 0);// c[i]<=n所以不用取余
for (int i = 1; i < n + 5; i++)
dp[i] = 1;
for (int i = n; i >= 1; i--)
if (2 * i + 1 <= n)
dp[i] = dp[2 * i] * dp[2 * i + 1] % mod
* C(s[i] - 1, s[i * 2 + 1]) % mod;// C(s[i]-1,s[i*2+1])和C(s[i]-1,s[i*2])都一样,组合对称
System.out.println(dp[1]);
}
static int n;
static long mod = 1000000009;
static long[] f;
static long[] inv;
static int[] s;// 记录该点的孩子节点+自身的总数
static long[] dp;
static long C(int n, int m) {
return f[n] * inv[m] % mod * inv[n - m] % mod;
}
static long mpow(long a, long n) {// 快速幂
if (n == 0 || a == 1)
return 1;
long ans = 1;
while (n != 0) {
if (n % 2 == 1)
ans = a * ans % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
}
5760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
