1：第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
用excel算，答案125.
2.标题：方格计数
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
注意：需要提交的是一个整数，不要填写任何多余内容。
public class Main {
public static void main(String[] args) {
int R=1000;
int a=1000,b=0,tb=b,count=0;
for(a=1000;a>=0;a--) {
while(a*a+b*b<=R*R)b++;
b--;
count+=a*(b-tb);
tb=b;
}
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
注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。
注意点：
1.直接在控制台输出的话，因为太大了，不会显示完整数字结果，结果如图
，其实，粘贴到记事本就可以看到完整的。
2.或者直接用FileWrite()写入文本。
import java.io.FileWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static Scanner cin = new Scanner(System.in);
public static void main(String[] args) throws IOException {
//求 (2+3i)^123456 等于多少？
//存答案
BigInteger a = new BigInteger("2");
BigInteger b = new BigInteger("3");
//乘数
BigInteger c = new BigInteger("2");
BigInteger d = new BigInteger("3");
//注意我是从第二个开始的：
for(int i = 1; i < 123456; i++) {
BigInteger x = a.multiply(c).subtract(b.multiply(d));
BigInteger y = a.multiply(d).add(b.multiply(c));
a = x;
b = y;
}
//System.out.println(a + "+" + d + "i");
//写文件
FileWriter file = new FileWriter("ans.txt");
//需要判断虚部的正负号，如果是负的就不需要"+"
if(b.compareTo(new BigInteger("0")) < 0) {
System.out.println("b < 0");
file.write(a + "" + d + "i");
}
else if (b.compareTo(new BigInteger("0")) > 0){
System.out.println("b > 0");
file.write(a + "+" + d + "i");
}
else {
System.out.println("b = 0");
file.write(a + "");
}
file.close();
}
}
4.标题：测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
分案一：数学推导：
注：
方案二：网上说：这道题其实是需要用动态规划或者记忆化搜索去解的，dp[x][y]表示当前还剩x楼不确定，还有y部手机没爆。
尚未看懂！！！！！！！！！！
#include
#define Max(a,b) (a>b?a:b)
#define Min(a,b) (a
int dp[1005][50];
int main(int argc, char* argv[])
{
int n,m;
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
{
dp[i][1]=i;
}
for (int cnt=2;cnt<=m;cnt++)
{
for (int ind=1;ind<=n;ind++)
{
dp[ind][cnt]=1+dp[ind-1][cnt];
for (int k=2;k<=ind;k++)
dp[ind][cnt]=Min(dp[ind][cnt],1+Max(dp[k-1][cnt-1],dp[ind-k][cnt]));
}
}
printf("%d\n",dp[n][m]);
return 0;
}
第五题：
标题：快速排序
以下代码可以从数组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 ， 当时跑了下，结果正确就没管了，实际上如果我多测计组就会发现是错的。
答案应该是： a, i + 1, r, k - i + l - 1；
对于那个传过去的 第几大问题，不能直接以为 k - i 就行了，因为 k 是新的，新对于一截数组的元素个数的第几大，
然而 那个下标 i 依然是整个数组的 i，所以 k 有种情况会小于 i ，故应该在数组中找到真实的 第几大，再去减掉 i, 故因为是 k + l - i + 1
-----------------------------------编程题-------------------------------------------
第六题
给定三个整数数组 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
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main{
public static void main(String args[] ) {
int n;
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
Integer[] a = new Integer[n];
Integer[] b = new Integer[n];
Integer[] c = new Integer[n];
for(int i = 0; i < n; i++) {
a[i] = cin.nextInt();
}
for(int i = 0; i < n; i++) {
b[i] = cin.nextInt();
}
for(int i = 0; i < n; i++) {
c[i] = cin.nextInt();
}
Comparator cmp = new MyComparator();
Arrays.sort(a, cmp);
Arrays.sort(b, cmp);
Arrays.sort(c, cmp);
int[] bc = new int[n]; //存放bj > ck 的个数
long[] he = new long[n]; //存放bc的加和
long ans = 0;
int i, j;
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
if(b[i] >= c[j]) {
break;
}
}
bc[i] = j;
if(i == 0) {
he[i] = j;
}
else {
he[i] = he[i-1] + j;
}
//System.out.print(bc[i] + ",");
}
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++) {
if(a[i] >= b[j]) {
break;
}
}
if(j > 0)
ans += he[j-1];
}
System.out.println(ans);
}
}
class MyComparator implements Comparator{
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
}
/*
3
1 1 1
2 1 2
3 2 3
12
-------
3
1 1 1
2 2 2
3 3 3
27
*/
第七题
标题：螺旋折线
如图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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
---------------------
思路：记得我去年是分象限讨论的，找了每个对角线的点为基准，然后讨论，细心点也好搞出来，但是比较复杂。今年重新看下，发现有了新思路
(刚刚看到有网上有图，直接搞过来吧，自己懒得画了)：
就是弄成完整的正方形，这样子就好搞多了，也就是说你可以总结出一个公式了：
以(-n, -n)为基准，所以就是最外圈 + 内圈和了。
内圈是： 1*8 + 2 * 8 + 3 * 8 + 。。。+ ( max(abs(x), abs(y) ) - 1) * 8
外圈就是：
if y < x : max(abs(x), abs(y) ) * 8 - ( abs(x - max(abs(x), abs(y) ) + abs(y - max(abs(x), abs(y) ) )
else : abs(x - max(abs(x), abs(y) ) + abs(y - max(abs(x), abs(y) )
总数量就是 ： 内圈加外圈之和了。
第八题：日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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，否则按无效代码处理。
暴力：先按时间排序，然后两重for判断，用了hashmap统计，set去重统计id
后面的代码用了尺取法。
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
public class Main{
public static void main(String args[] ) {
int n, d, k;
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
d = cin.nextInt();
k = cin.nextInt();
zan[] a = new zan[n ];
for(int i = 0; i < n; i++) {
a[i] = new zan(cin.nextInt(), cin.nextInt());
}
Arrays.sort(a, new Comparator() {
public int compare(zan x, zan y) {
return x.ts - y.ts;
}
});
//for(zan i : a) {
//System.out.println(i.ts);
//}
//用hashmap统计每个时段内每个内容的点赞次数
HashMap map = new HashMap<>();
HashSet set = new HashSet<>();
for(int i = a[0].ts; i <= a[n-1].ts; i++) {
for(int j = 0; j < n; j++) {
if(a[j].ts >= i && a[j].ts < i + d) {
if(map.containsKey(a[j].id)) {
int tm = map.get(a[j].id) + 1;
if(tm >= k && !set.contains(a[j].id)) {
set.add(a[j].id);
//set.
}
map.put(a[j].id, tm);
}
else {
map.put(a[j].id, 1);
}
}
}
//System.out.println(map.values());
map.clear();
}
//System.out.println(set.size() + ": " + set.toString());
//取出所有的set内容，存入ans中
Iterator it = set.iterator();
int[] ans = new int[set.size()];
int ct = 0;
while(it.hasNext()) {
ans[ct++] = it.next();
//System.out.print(it.next() + " ");
}
Arrays.sort(ans);
for(int i = 0; i < ct; i++) {
System.out.print(ans[i] + " ");
}
}
}
class zan{
public int ts;
public int id;
zan(int t, int i){
this.ts = t;
this.id = i;
}
}
/*
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
public class Main{
public static int n, d, k;
public static List[] list = new ArrayList[100005];
public static void main(String args[] ) {
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
d = cin.nextInt();
k = cin.nextInt();
int Ids = 100005;
for(int i = 0; i < Ids; i++) {
list[i] = new ArrayList();
}
HashSet set = new HashSet<>();
for(int i = 0; i < n; i++) {
int id, ts;
ts = cin.nextInt();
id = cin.nextInt();
list[id].add(ts);
set.add(id);
}
int cnt = 0, ids = set.size();
int[] ans = new int[ids];
Object[] yid = new Object[ids];
//将集合里面的数据取出来
yid = set.toArray();
for(int i = 0; i < ids; i++) {
if(judge((int) yid[i])) {
ans[cnt++] = (int)yid[i];
//System.out.println(yid[i] + "-----");
}
}
for(int i = 0; i < cnt; i++) {
System.out.print(yid[i] + " ");
}
}
public static boolean judge(int id) {
int l = 0, r = 0;
int len = list[id].size();
int sum = 0;
if(len < k) {
return false;
}
//对链表排序
Collections.sort(list[id]);
//尺取法
while(l <= r && r < len) {
if(r - l + 1 >= k) {
if(list[id].get(r) - list[id].get(l) < d) {
return true;
}
else {
l++;
}
}
r++;
}
return false;
}
}
/*
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
*/
第九题 全球变暖
你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
.......
.##....
.##....
....##.
..####.
...###.
.......
【输出样例】
1
资源约定：
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
思路：
把'.'当做0，把'#'当做-1(化作整数方便标记连通分量)
1.dfs一次，并在dfs的过程中标连通分量(每个岛给一个编号p，p从1开始)
2.在1的过程中，把会被淹没的陆地(如果周围存在海)给予特殊编号-2
3.最后统计非特殊编号个数cnt, 答案就是p-cnt;
注意数据的输入，java 我输入还不是很熟啊！！！
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
public class Main{
public static int[][] map;
public static int[][] visit;
public static int dx[] = {1, -1, 0, 0};
public static int dy[] = {0, 0, 1, -1};
public static int n;
public static void main(String args[] ) {
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
//cin.nextLine(); //读掉回车
map = new int[n][n];
visit = new int[n][n];
for(int i = 0; i < n; i++) {
String temp = cin.next();
//System.out.println("---" + temp + "----");
for(int j = 0; j < n; j++) {
if(temp.charAt(j) == '.') {
map[i][j] = -1; //水
}
else {
map[i][j] = 0; //土地
}
visit[i][j] = 0;
}
}
int cnt = 0; //原来总的岛屿数量
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if(map[i][j] == 0) {
cnt++;
dfs(i, j, cnt);
}
}
}
int ans = 0;
HashSet set = new HashSet<>();
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if(map[i][j] > 0) {
set.add(map[i][j]);
}
}
}
System.out.println(cnt - set.size());
System.out.println(set.toString());
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
System.out.print(map[i][j]);
}
System.out.println();
}
}
public static void dfs(int x, int y, int bh) {
//System.out.println("x + y" + x + " " + y);
map[x][y] = bh;
visit[x][y] = 1;
int flag = 0;
for(int i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if(xx >= 0 && xx < n &&
yy >= 0 && yy < n && visit[xx][yy] == 0) {
if(map[xx][yy] == -1) { //周边有一个是水，则淹没
map[x][y] = -2; //特殊标记，表示已经淹没的，但不能和水一样，否则会导致他相邻的误判
}
else if(map[xx][yy] == 0){
dfs(xx, yy, bh);
}
}
}
}
}
/*
样例1：
7
.......
.##....
.##....
....##.
..####.
...###.
.......
1
样例2：
7
.......
.##....
.####..
....##.
..####.
...###.
.......
0
*/
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.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
public class Main{
public static int[] visit = new int[100005];
public static int n;
public static int ans = 0;
public static int[] tree = new int[100005];
public static void main(String args[] ) {
Scanner cin = new Scanner(System.in);
n = cin.nextInt(); // 树上节点总数
find(1);
System.out.println(ans);
}
public static void find(int x) {
if(x == n + 1) {
for(int i = 1; i <= n; i++) {
System.out.print(tree[i] + " ");
}
System.out.println();
ans = (ans + 1) % 1000000009;
}
int st = x / 2;
for(int i = tree[st] + 1; i <= n; i++) {
if(visit[i] == 0) {
visit[i] = 1;
tree[x] = i;
find(x+1);
visit[i] = 0;
tree[x] = 0;
}
}
}
}
扫一扫
1589
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
