第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
125
import java.util.Scanner;
public class Main {
public static void main(String[] args){
System.out.println(run(2000));
System.out.println(31+29+31+30+4);
}
private static boolean run(int year){
if((year%4==0 &&year%100!=0 )||(year%400==0)){
return true;
}
return false;
}
}
方格计数
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
注意：需要提交的是一个整数，不要填写任何多余内容。
3137548
import java.util.Scanner;
public class Main {
public static void main(String[] args){
int count=0;
double radis=1000*1000;
for(int i=0;i<1000;i++){
for(int j=0;j<1000;j++){
double x=i+1;
double y=j+1;
if(x*x+y*y<=radis){
count++;
}
}
}
System.out.println(count*4);
}
}
复数幂
设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
由于123456次幂实在太大，所以采用Java中的BigInteger存储数据
而且从控制台中无法输出，所以在这里把结果输出到了一个txt文件中。
此题参考来自：复数幂
import java.io.*;
import java.math.BigInteger;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
PrintStream ps=new PrintStream(new FileOutputStream("work.txt"));
System.setOut(ps); //文件输出
int n=123456;
BigInteger a=new BigInteger("2");
BigInteger b=new BigInteger("3");
BigInteger a1=new BigInteger("2");
BigInteger b1=new BigInteger("3");
for(int i=1;i<n;i++) {
BigInteger ta=a;
a=a.multiply(a1).subtract(b.multiply(b1));//a=a*a1-b*b1;
b=ta.multiply(b1).add(b.multiply(a1));//b=a*b1+b*a1
}
System.out.println(a+(b.compareTo(BigInteger.ZERO)>0?"+":"")+b+"i");
}
}
测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
19
解题思路
看这个大佬的思路吧
import java.util.*;
public class Main {
public static void main(String[] args) {
int n,m;
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
m=sc.nextInt();
int[][] dp=new int[n+5][m+5];
//dp[i][j]表示还有i层未测，j个手机没碎
for(int i=1;i<=n;i++)
{
dp[i][1]=i;//只有一个手机还有i层没测最坏的情况下需要i次
}
for(int i=2;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
dp[j][i]=dp[j-1][i]+1;//还有j层，i个手机，推一下，相当于j-1层i个手机，多测一次
for(int k=2;k<=j;k++)
{
dp[j][i]=Math.min(dp[j][i],Math.max(dp[k-1][i-1], dp[j-k][i])+1);
//在第k层摔坏了 dp[k-1][i-1] (下面k-1层，用i-1个手机去测试）
//在第k层没坏 dp[j-k][i] (上面的j-k层，用i个手机去测）
}
}
}
System.out.println(dp[n][m]);
}
}
快速排序
以下代码可以从数组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));
}
}
注意：只提交划线部分缺少的代码，不要抄写任何已经存在的代码或符号。
a,i+1,r,k-i+l-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; //随机输入一个0-6的数
int x = a[p]; //x为数组中随机的一个数
int tmp = a[p]; a[p] = a[r]; a[r] = tmp;//随机数和最后一个数交换数值
int i = l, j = r; //i为0，j为5，两个边界
while(i < j) { //当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,k-i+l-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));
}
}
递增三元组
给定三个整数数组
A = [A1, A2, … AN],
B = [B1, B2, … BN],
C = [C1, C2, … CN]，
请你统计有多少个三元组(i, j, k) 满足：
- 1 <= i, j, k <= N
- 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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String args[]) throws IOException {
BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
int n=Integer.parseInt(bf.readLine());
int []a=new int[n+1];
int []b=new int[n+1];
int []c=new int[n+1];
int count=0;
String []input1=bf.readLine().split(" ");
for(int i=1;i<=n;i++){
a[i]=Integer.parseInt(input1[i-1]);
}
String []input2=bf.readLine().split(" ");
for(int i=1;i<=n;i++){
b[i]=Integer.parseInt(input2[i-1]);
}
String []input3=bf.readLine().split(" ");
for(int i=1;i<=n;i++){
c[i]=Integer.parseInt(input3[i-1]);
}
Arrays.sort(a);
Arrays.sort(b);
Arrays.sort(c);
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(a[i]>=b[j])
continue;
for(int k=1;k<=n;k++){
if(a[i]>=c[k] || b[j]>=c[k])
continue;
if((a[i]<b[j])&&(a[i]<c[k])&&(b[j]<c[k])){
count++;
}
}
}
}
System.out.println(count);
}
}
螺旋折线
如图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 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
long X = in.nextLong();
long Y = in.nextLong();
// 判断所在点所在的正方形
long n = Math.max(Math.abs(X) , Math.abs(Y));
// 1. 之前正方形的长度和
long Sn = 4*(n-1)*n;
// 2. 计算点(-n, -n) 到点(X, Y)的距离, 考虑清楚情况
long sum = 0;
long px = -n, py = -n;
long d1 = X-px, d2 = Y-py;
if (Y > X) {
sum += (d1+d2);
} else {
sum += (8*n-d1-d2);
}
System.out.println(sum + Sn);
}
}
自己暴力破解的
import java.util.Scanner;
public class Main{
static long result=0;
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
int y=sc.nextInt();
System.out.println(dis(x,y));
}
private static long dis(int x,int y){
int n_x=0,n_y=0;
long count=1,ter_count;
while(1>0){
ter_count=count;
while(ter_count>0){
n_x-=1;
result++;
if(n_x==x && n_y==y){
return result;
}
ter_count--;
}
ter_count=count;
while(ter_count>0){
n_y+=1;
result++;
if(n_x==x && n_y==y){
return result;
}
ter_count--;
}
ter_count=count;
while(ter_count+1>0){
n_x+=1;
result++;
if(n_x==x && n_y==y){
return result;
}
ter_count--;
}
ter_count=count;
while(ter_count+1>0){
n_y-=1;
result++;
if(n_x==x && n_y==y){
return result;
}
ter_count--;
}
count+=2;
}
}
}
日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main{
static long result=0;
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int d=sc.nextInt();
int k=sc.nextInt();
int []tiezi=new int[100001];
ArrayList []list=new ArrayList[100001];
for(int i=0;i<100001;i++){
list[i]=new ArrayList();
}
for(int i=0;i<n;i++){
int ts=sc.nextInt();
int id=sc.nextInt();
list[id].add(ts);
}
for(int i=0;i<100001;i++){
if(list[i].size()<k)
continue;
Collections.sort(list[i]);
for(int j=0;j<list[i].size()-k+1;j++){
int start=(Integer) list[i].get(j);
int count=1;
for(int z=j+1;z<list[i].size();z++){
if((Integer)list[i].get(z)-start<d){ //在这个时间内有多少个赞
count++;
}
}
if(count>=k){
System.out.println(i);
break;
}
}
}
}
}
全球变暖
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：
…
.##…
.##…
…##.
…####.
…###.
…
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
…
…
…
…
…#…
…
…
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
…
.##…
.##…
…##.
…####.
…###.
…
【输出样例】
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main{
static class Node{
int x;
int y;
Node(int x,int y){
this.x=x;
this.y=y;
}
}
static int n;
static char [][]copy;
static char [][]arr;
static int [][]book;
static int [][]fin;
static int [][]dpxy= {{0,1},{1,0},{0,-1},{-1,0}};
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
sc.nextLine();
arr=new char[n][n];
book=new int[n][n];
fin=new int[n][n];
copy=new char[n][n];
for(int i=0;i<n;i++){
String input=sc.nextLine();
for(int j=0;j<n;j++){
arr[i][j]=input.charAt(j);
}
}
int num=panduan();
BFS(0,0);
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(fin[i][j]==-1){
arr[i][j]='.';
}
}
}
int n_num=panduan();
System.out.println(num-n_num);
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++){
// System.out.print(arr[i][j]);
// }
// System.out.println();
// }
}
public static void BFS(int x,int y) {
Queue<Node> que=new LinkedList<Node>();
book[x][y]=1;
que.add(new Node(x,y));
while(!que.isEmpty()) { //当队列为空时就代表走完
Node now_node=que.remove(); //取出队列中一个坐标来走下一步
if(arr[now_node.x][now_node.y]=='#'){
boolean safe=true;
for(int i=0;i<4;i++){
int new_x=now_node.x+dpxy[i][0];
int new_y=now_node.y+dpxy[i][1];
if(new_x>=0 &&new_x<n &&new_y>=0 &&new_y<n){
if(arr[new_x][new_y]=='.'){
safe=false;
break;
}
}
}
if(safe==false){
fin[now_node.x][now_node.y]=-1;
}
}
for(int i=0;i<4;i++) {
int new_x=now_node.x+dpxy[i][0];
int new_y=now_node.y+dpxy[i][1];
if(new_x>=0 && new_x<n && new_y>=0 && new_y<n && book[new_x][new_y]==0) {
book[new_x][new_y]=1; //标记走过
que.add(new Node(new_x,new_y));
}
}
}
}
public static int panduan(){
int count=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
copy[i][j]=arr[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(copy[i][j]=='#'){
DFS(i,j);
count++;
}
}
}
return count;
}
public static void DFS(int x,int y){
for(int i=0;i<4;i++) {
int new_x=x+dpxy[i][0];
int new_y=y+dpxy[i][1];
if(new_x>=0 && new_x<n && new_y>=0 && new_y<n && copy[new_x][new_y]=='#') {
copy[new_x][new_y]='.'; //标记走过
DFS(new_x,new_y);
}
}
}
}
堆的计数
我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。
假设N个节点的权值分别是1~N，你能求出一共有多少种不同的小根堆吗？
例如对于N=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，否则按无效代码处理。
