1：第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？

注意：需要提交的是一个整数，不要填写任何多余内容。

用excel算，答案125.

2.标题：方格计数

如图p1.png所示，在二维平面上有无数个1x1的小方格。

我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？

注意：需要提交的是一个整数，不要填写任何多余内容。

  1. public class Main {
  2.  
  3. 	public static void main(String[] args) {
  4. 		int R=1000;
  5. 		int a=1000,b=0,tb=b,count=0;
  6. 		for(a=1000;a>=0;a--) {
  7. 			while(a*a+b*b<=R*R)b++;
  8. 			b--;
  9. 			count+=a*(b-tb);
  10. 			tb=b;
  11. 		}
  12. 		System.out.println(count*4);    //答案 3137548
  13. 	}
  14. }

　　

3.标题：复数幂

设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 "实部±虚部i" 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。

 BigInteger 的使用了

注意点：

1.直接在控制台输出的话，因为太大了，不会显示完整数字结果，结果如图，其实，粘贴到记事本就可以看到完整的。

2.或者直接用FileWrite()写入文本。

  1. import java.io.FileWriter;
  2. import java.io.IOException;
  3. import java.math.BigInteger;
  4. import java.util.Scanner;
  5.  
  6. public class Main {
  7. 	public static Scanner cin = new Scanner(System.in);
  8. 	public static void main(String[] args) throws IOException {
  9. //		求 (2+3i)^123456 等于多少？
  10.  
  11. 		//存答案
  12. 		BigInteger a = new BigInteger("2");
  13. 		BigInteger b = new BigInteger("3");
  14. 		//乘数
  15. 		BigInteger c = new BigInteger("2");
  16. 		BigInteger d = new BigInteger("3");
  17.  
  18. 		//注意我是从第二个开始的：
  19. 		for(int i = 1; i < 123456; i++) {
  20. 			BigInteger x = a.multiply(c).subtract(b.multiply(d));
  21. 			BigInteger y = a.multiply(d).add(b.multiply(c));
  22. 			a = x;
  23. 			b = y;
  24. 		}
  25. //		System.out.println(a + "+" + d + "i");
  26.  
  27. 		//写文件
  28. 		FileWriter file = new FileWriter("ans.txt");
  29. 		//需要判断虚部的正负号，如果是负的就不需要"+"
  30. 		if(b.compareTo(new BigInteger("0")) < 0) {
  31. 			System.out.println("b < 0");
  32. 			file.write(a + "" + d + "i");
  33. 		}
  34. 		else if (b.compareTo(new BigInteger("0")) > 0){
  35. 			System.out.println("b > 0");
  36. 			file.write(a + "+" + d + "i");
  37. 		}
  38. 		else {
  39. 			System.out.println("b = 0");
  40. 			file.write(a + "");
  41. 		}
  42. 		file.close();
  43.  
  44. 	}
  45.  
  46. }

　　

4.标题：测试次数

x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。

分案一：数学推导：

https://blog.csdn.net/nka_kun/article/details/79789511

注：

　　

方案二：网上说：这道题其实是需要用动态规划或者记忆化搜索去解的，dp[x][y]表示当前还剩x楼不确定，还有y部手机没爆。

尚未看懂！！！！！！！！！！

  1. #include<stdio.h>
  2. #define Max(a,b) (a>b?a:b)
  3. #define Min(a,b) (a<b?a:b)
  4. int dp[1005][50];
  5. int main(int argc, char* argv[])
  6. {
  7. 	int n,m;
  8. 	scanf("%d%d",&n,&m);
  9. 	for (int i=1;i<=n;i++)
  10.     {
  11.         dp[i][1]=i;
  12.     }
  13.     for (int cnt=2;cnt<=m;cnt++)
  14.     {
  15.         for (int ind=1;ind<=n;ind++)
  16.         {
  17.             dp[ind][cnt]=1+dp[ind-1][cnt];
  18.             for (int k=2;k<=ind;k++)
  19.                 dp[ind][cnt]=Min(dp[ind][cnt],1+Max(dp[k-1][cnt-1],dp[ind-k][cnt]));
  20.         }
  21.     }
  22.     printf("%d\n",dp[n][m]);
  23. 	return 0;
  24. }

　　

第五题：

标题：快速排序
以下代码可以从数组a[]中找出第k小的元素。  
它使用了类似快速排序中的分治算法，期望时间复杂度是O(N)的。

请仔细阅读分析源码，填写划线部分缺失的内容。

  1. import java.util.Random;
  2. public class Main{
  3. 	public static int quickSelect(int a[], int l, int r, int k) {
  4. 		Random rand = new Random();
  5. 		int p = rand.nextInt(r - l + 1) + l;
  6. 		int x = a[p];
  7. 		int tmp = a[p]; a[p] = a[r]; a[r] = tmp;
  8. 		int i = l, j = r;
  9. 		while(i < j) {
  10.                 	while(i < j && a[i] < x) i++;
  11.                 	if(i < j) {
  12.                         	a[j] = a[i];
  13.                         	j--;
  14.                 	}
  15.                 	while(i < j && a[j] > x) j--;
  16.                 	if(i < j) {
  17.                         	a[i] = a[j];
  18.                         	i++;
  19.                 	}
  20.         	}
  21.         	a[i] = x;
  22.         	p = i;
  23.         	if(i - l + 1 == k) return a[i];
  24.         	if(i - l + 1 < k) return quickSelect( _________________________________ ); //填空
  25.         	else return quickSelect(a, l, i - 1, k);
  26. 	}
  27. 	public static void main(String args[]) {
  28. 		int [] a = {1, 4, 2, 8, 5, 7};
  29. 		System.out.println(quickSelect(a, 0, 5, 4));
  30. 	}
  31. }
  32.  
  33. 注意：只提交划线部分缺少的代码，不要抄写任何已经存在的代码或符号。

　　

我当时的答案是：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

思路： https://blog.csdn.net/yinxiaobao97/article/details/79929549

  1. import java.util.Arrays;
  2. import java.util.Comparator;
  3. import java.util.Scanner;
  4.  
  5. public class Main{
  6. 	public static void main(String args[] ) {
  7. 		int n;
  8. 		Scanner cin = new Scanner(System.in);
  9. 		n = cin.nextInt();
  10. 		Integer[] a = new Integer[n];
  11. 		Integer[] b = new Integer[n];
  12. 		Integer[] c = new Integer[n];
  13.  
  14. 		for(int i = 0; i < n; i++) {
  15. 			a[i] = cin.nextInt();
  16. 		}
  17. 		for(int i = 0; i < n; i++) {
  18. 			b[i] = cin.nextInt();
  19. 		}
  20. 		for(int i = 0; i < n; i++) {
  21. 			c[i] = cin.nextInt();
  22. 		}
  23. 		Comparator<Integer> cmp = new MyComparator();
  24. 		Arrays.sort(a, cmp);
  25. 		Arrays.sort(b, cmp);
  26. 		Arrays.sort(c, cmp);
  27.  
  28. 		int[] bc = new int[n]; //存放bj > ck 的个数
  29. 		long[] he = new long[n]; //存放bc的加和
  30. 		long ans = 0;
  31. 		int i, j;
  32. 		for(i = 0; i < n; i++) {
  33. 			for(j = 0; j < n; j++) {
  34. 				if(b[i] >= c[j]) {
  35. 					break;
  36. 				}
  37. 			}
  38. 			bc[i] = j;
  39. 			if(i == 0) {
  40. 				he[i] = j;
  41. 			}
  42. 			else {
  43. 				he[i] = he[i-1] + j;
  44. 			}
  45. //			System.out.print(bc[i] + ",");
  46. 		}
  47. 		for(i = 0; i < n; i++) {
  48. 			for(j = 0; j < n; j++) {
  49. 				if(a[i] >= b[j]) {
  50. 					break;
  51. 				}
  52. 			}
  53. 			if(j > 0)
  54. 				ans += he[j-1];
  55. 		}
  56. 		System.out.println(ans);
  57. 	}
  58. }
  59. class MyComparator implements Comparator<Integer>{
  60. 	@Override
  61. 	public int compare(Integer o1, Integer o2) {
  62. 		return o2 - o1;
  63. 	}
  64. }
  65. 	/*
  66. 3
  67. 1 1 1
  68. 2 1 2
  69. 3 2 3
  70. 12
  71. -------
  72. 3
  73. 1 1 1
  74. 2 2 2
  75. 3 3 3
  76. 27
  77. 	 */

　　

第七题

标题：螺旋折线

如图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

后面的代码用了尺取法。

  1. import java.util.Arrays;
  2. import java.util.Comparator;
  3. import java.util.HashMap;
  4. import java.util.HashSet;
  5. import java.util.Iterator;
  6. import java.util.Scanner;
  7.  
  8. public class Main{
  9. 	public static void main(String args[] ) {
  10. 		int n, d, k;
  11. 		Scanner cin = new Scanner(System.in);
  12. 		n = cin.nextInt();
  13. 		d = cin.nextInt();
  14. 		k = cin.nextInt();
  15. 		zan[] a = new zan[n ];
  16. 		for(int i = 0; i < n; i++) {
  17. 			a[i] = new zan(cin.nextInt(), cin.nextInt());
  18. 		}
  19. 		Arrays.sort(a, new Comparator<zan>() {
  20. 			public int compare(zan x, zan y) {
  21. 				return x.ts - y.ts;
  22. 			}
  23. 		});
  24. //		for(zan i : a) {
  25. //			System.out.println(i.ts);
  26. //		}
  27. 		//用hashmap统计每个时段内每个内容的点赞次数
  28. 		HashMap<Integer, Integer> map = new HashMap<>();
  29. 		HashSet<Integer> set = new HashSet<>();
  30. 		for(int i = a[0].ts; i <= a[n-1].ts; i++) {
  31. 			for(int j = 0; j < n; j++) {
  32. 				if(a[j].ts >= i && a[j].ts < i + d) {
  33. 					if(map.containsKey(a[j].id)) {
  34. 						int tm = map.get(a[j].id) + 1;
  35. 						if(tm >= k && !set.contains(a[j].id)) {
  36. 							set.add(a[j].id);
  37. //							set.
  38. 						}
  39. 						map.put(a[j].id, tm);
  40. 					}
  41. 					else {
  42. 						map.put(a[j].id, 1);
  43. 					}
  44. 				}
  45. 			}
  46. //			System.out.println(map.values());
  47. 			map.clear();
  48. 		}
  49. //		System.out.println(set.size() + ": " + set.toString());
  50. 		//取出所有的set内容，存入ans中
  51. 		Iterator<Integer> it = set.iterator();
  52. 		int[] ans = new int[set.size()];
  53. 		int ct = 0;
  54. 		while(it.hasNext()) {
  55. 			ans[ct++] = it.next();
  56. //			System.out.print(it.next() + " ");
  57. 		}
  58. 		Arrays.sort(ans);
  59. 		for(int i = 0; i < ct; i++) {
  60. 			System.out.print(ans[i] + " ");
  61. 		}
  62. 	}
  63. }
  64. class zan{
  65. 	public int ts;
  66. 	public int id;
  67. 	zan(int t, int i){
  68. 		this.ts = t;
  69. 		this.id = i;
  70. 	}
  71. }
  72.  
  73. 	/*
  74.  7 10 2
  75. 0 1
  76. 0 10
  77. 10 10
  78. 10 1
  79. 9 1
  80. 100 3
  81. 100 3
  82. 	 */

　　

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Collections;
  4. import java.util.HashSet;
  5. import java.util.List;
  6. import java.util.Scanner;
  7.  
  8. public class Main{
  9. 	public static int n, d, k;
  10. 	public static List<Integer>[] list = new ArrayList[100005];
  11. 	public static void main(String args[] ) {
  12. 		Scanner cin = new Scanner(System.in);
  13. 		n = cin.nextInt();
  14. 		d = cin.nextInt();
  15. 		k = cin.nextInt();
  16. 		int Ids = 100005;
  17.  
  18. 		for(int i = 0; i < Ids; i++) {
  19. 			list[i] = new ArrayList<Integer>();
  20. 		}
  21. 		HashSet<Integer> set = new HashSet<>();
  22. 		for(int i = 0; i < n; i++) {
  23. 			int id, ts;
  24. 			ts = cin.nextInt();
  25. 			id = cin.nextInt();
  26. 			list[id].add(ts);
  27. 			set.add(id);
  28. 		}
  29. 		int cnt = 0, ids = set.size();
  30. 		int[] ans = new int[ids];
  31. 		Object[] yid = new Object[ids];
  32. 		//将集合里面的数据取出来
  33. 		yid = set.toArray();
  34. 		for(int i = 0; i < ids; i++) {
  35. 			if(judge((int) yid[i])) {
  36. 				ans[cnt++] = (int)yid[i];
  37. //				System.out.println(yid[i] + "-----");
  38. 			}
  39. 		}
  40. 		for(int i = 0; i < cnt; i++) {
  41. 			System.out.print(yid[i] + " ");
  42. 		}
  43. 	}
  44. 	public static boolean judge(int id) {
  45. 		int l = 0, r = 0;
  46. 		int len = list[id].size();
  47. 		int sum = 0;
  48. 		if(len < k) {
  49. 			return false;
  50. 		}
  51. 		//对链表排序
  52. 		Collections.sort(list[id]);
  53. 		//尺取法
  54. 		while(l <= r && r < len) {
  55. 			if(r - l + 1 >= k) {
  56. 				if(list[id].get(r) - list[id].get(l) < d) {
  57. 					return true;
  58. 				}
  59. 				else {
  60. 					l++;
  61. 				}
  62. 			}
  63. 			r++;
  64. 		}
  65. 		return false;
  66. 	}
  67. }
  68. 	/*
  69.  7 10 2
  70. 0 1
  71. 0 10
  72. 10 10
  73. 10 1
  74. 9 1
  75. 100 3
  76. 100 3
  77. 	 */

　　

第九题 全球变暖
你有一张某海域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 我输入还不是很熟啊！！！

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Collections;
  4. import java.util.HashSet;
  5. import java.util.List;
  6. import java.util.Scanner;
  7.  
  8. public class Main{
  9. 	public static int[][] map;
  10. 	public static int[][] visit;
  11. 	public static int dx[] = {1, -1, 0, 0};
  12. 	public static int dy[] = {0, 0, 1, -1};
  13. 	public static int n;
  14.  
  15. 	public static void main(String args[] ) {
  16. 		Scanner cin = new Scanner(System.in);
  17. 		n = cin.nextInt();
  18. //		cin.nextLine();  //读掉回车
  19. 		map = new int[n][n];
  20. 		visit = new int[n][n];
  21. 		for(int i = 0; i < n; i++) {
  22. 			String temp = cin.next();
  23. //			System.out.println("---" + temp + "----");
  24. 			for(int j = 0; j < n; j++) {
  25. 				if(temp.charAt(j) == '.') {
  26. 					map[i][j] = -1; //水
  27. 				}
  28. 				else {
  29. 					map[i][j] = 0;  //土地
  30. 				}
  31. 				visit[i][j] = 0;
  32. 			}
  33. 		}
  34. 		int cnt = 0; //原来总的岛屿数量
  35. 		for(int i = 0; i < n; i++) {
  36. 			for(int j = 0; j < n; j++) {
  37. 				if(map[i][j] == 0) {
  38. 					cnt++;
  39. 					dfs(i, j, cnt);
  40. 				}
  41. 			}
  42. 		}
  43. 		int ans = 0;
  44. 		HashSet<Integer> set = new HashSet<>();
  45. 		for(int i = 0; i < n; i++) {
  46. 			for(int j = 0; j < n; j++) {
  47. 				if(map[i][j] > 0) {
  48. 					set.add(map[i][j]);
  49. 				}
  50. 			}
  51. 		}
  52. 		System.out.println(cnt - set.size());
  53. 		System.out.println(set.toString());
  54. 		for(int i = 0; i < n; i++) {
  55. 			for(int j = 0; j < n; j++) {
  56. 				System.out.print(map[i][j]);
  57. 			}
  58. 			System.out.println();
  59. 		}
  60. 	}
  61.  
  62. 	public static void dfs(int x, int y, int bh) {
  63. //		System.out.println("x + y" + x + " " + y);
  64. 		map[x][y] = bh;
  65. 		visit[x][y] = 1;
  66. 		int flag = 0;
  67. 		for(int i = 0; i < 4; i++) {
  68. 			int xx = x + dx[i];
  69. 			int yy = y + dy[i];
  70. 			if(xx >= 0 && xx < n &&
  71. 					yy >= 0 && yy < n && visit[xx][yy] == 0) {
  72. 				if(map[xx][yy] == -1) { //周边有一个是水，则淹没
  73. 					map[x][y] = -2; //特殊标记，表示已经淹没的，但不能和水一样，否则会导致他相邻的误判
  74. 				}
  75. 				else if(map[xx][yy] == 0){
  76. 					dfs(xx, yy, bh);
  77. 				}
  78. 			}
  79. 		}
  80. 	}
  81.  
  82. }
  83. 	/*
  84.  
  85. 样例1：
  86. 7
  87. .......
  88. .##....
  89. .##....
  90. ....##.
  91. ..####.
  92. ...###.
  93. .......
  94.  
  95. 1
  96.  
  97. 样例2：
  98. 7
  99. .......
  100. .##....
  101. .####..
  102. ....##.
  103. ..####.
  104. ...###.
  105. .......
  106.  
  107. 0
  108. 	 */

　　

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，否则按无效代码处理。

纯暴力深搜代码：

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Collections;
  4. import java.util.HashSet;
  5. import java.util.List;
  6. import java.util.Scanner;
  7.  
  8. public class Main{
  9. 	public static int[] visit = new int[100005];
  10. 	public static int n;
  11. 	public static int ans = 0;
  12. 	public static int[] tree = new int[100005];
  13.  
  14. 	public static void main(String args[] ) {
  15. 		Scanner cin = new Scanner(System.in);
  16. 		n = cin.nextInt(); // 树上节点总数
  17. 		find(1);
  18.  
  19. 		System.out.println(ans);
  20. 	}
  21. 	public static void find(int x) {
  22. 		if(x == n + 1) {
  23. 			for(int i = 1; i <= n; i++) {
  24. 				System.out.print(tree[i] + " ");
  25. 			}
  26. 			System.out.println();
  27. 			ans = (ans + 1) % 1000000009;
  28. 		}
  29. 		int st = x / 2;
  30. 		for(int i = tree[st] + 1; i <= n; i++) {
  31. 			if(visit[i] == 0) {
  32. 				visit[i] = 1;
  33. 				tree[x] = i;
  34. 				find(x+1);
  35. 				visit[i] = 0;
  36. 				tree[x] = 0;
  37. 			}
  38. 		}
  39. 	}
  40.  
  41. }

　　

36-2018 蓝桥杯Java B组试题及答案的更多相关文章

  1. 蓝桥杯java历年真题及答案整理1~20.md

    蓝桥杯java历年真题及答案整理(闭关一个月,呕心沥血整理出来的) 1 算法是这样的,如果给定N个不同字符,将这N个字符全排列,最终的结果将会是N!种.如:给定 A.B.C三个不同的字符,则结果为:A ...

  2. 第八届蓝桥杯java b组第六题

    标题:最大公共子串 最大公共子串长度问题就是:求两个串的所有子串中能够匹配上的最大长度是多少. 比如:"abcdkkk" 和 "baabcdadabc",可以找 ...

  3. 2012年第三届蓝桥杯Java本科组省赛试题解析

    题目地址:https://wenku.baidu.com/view/326f7b4be518964bcf847c96.html?rec_flag=default    => 百度文档 题目及解析 ...

  4. 2018年蓝桥杯java b组第八题

    标题:日志统计 小明维护着一个程序员论坛.现在他收集了一份"点赞"日志,日志共有N行.其中每一行的格式是: ts id 表示在ts时刻编号id的帖子收到一个"赞" ...

  5. 2018年蓝桥杯java b组第七题

    标题:螺旋折线 如图p1.pgn所示的螺旋折线经过平面上所有整点恰好一次. 对于整点(X, Y),我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度. 例如dis(0, ...

  6. 2018年蓝桥杯java b组第六题

    标题:递增三元组 给定三个整数数组A = [A1, A2, ... AN], B = [B1, B2, ... BN], C = [C1, C2, ... CN],请你统计有多少个三元组(i, j, ...

  7. 2018年蓝桥杯java b组第五题

    标题:快速排序 以下代码可以从数组a[]中找出第k小的元素. 它使用了类似快速排序中的分治算法,期望时间复杂度是O(N)的. 请仔细阅读分析源码,填写划线部分缺失的内容. 我在使用(a, l, r, ...

  8. 2018年蓝桥杯java b组第四题

    标题:测试次数 x星球的居民脾气不太好,但好在他们生气的时候唯一的异常举动是:摔手机.各大厂商也就纷纷推出各种耐摔型手机.x星球的质监局规定了手机必须经过耐摔测试,并且评定出一个耐摔指数来,之后才允许 ...

  9. 2018年蓝桥杯java b组第三题

    标题:复数幂 设i为虚数单位.对于任意正整数n,(2+3i)^n 的实部和虚部都是整数.求 (2+3i)^123456 等于多少? 即(2+3i)的123456次幂,这个数字很大,要求精确表示. 答案 ...

随机推荐

  1. JAVA_连接池、DataSource、JNDI

    1.连接池    Connection的取得和开放是代价比较高的处理,解决这个问题的方法是连接池.    连接池就是事先取得一定数量的Connection,程序执行处理的时候不是新建Connectio ...

  2. centos7下找不到iptables文件

    最近在centos7下,搭建ftp服务,按照步骤一步一步来,发现 etc/sysconfig/iptables这个文件并不存在,然后去找解决方案, 原文地址:http://blog.csdn.net/ ...

  3. RabbitMQ.Net 应用(2)

    //生产者 using RabbitMQ.Client; using System; using System.Collections.Generic; using System.Linq; usin ...

  4. [jPlayer]一分钟部署jPlayer

    ---------------------------------------------------------------------------------------------------- ...

  5. 删除node_modules文件夹

    老版本的npm对有node_modules文件夹太长的问题,新版本就没有这个问题.2.7? npm install rimraf -g rimraf node_modules

  6. android有关生命周期探讨

    android生命周期直接贴一个经典图: 1.activity生命周期三段式,(开三步,跑,关三步,这三步都是回掉函数哦) 开 onCreate->onStart->onResume 跑 ...

  7. SAP RFC函数

    RFC 接口 RFC是对一个函数模块的调用,但是调用者的系统与被调函数所在的系统是不一样的. RFC也可以在系统内被调用,但是通常调用和被调用是在不同的系统中的. 在sap系统中,远程调用的能力是有R ...

  8. jquery val() text() html()的区别

    value()主要用在表单元素上,如果其他的元素获取value是通过attract()的方法,text()是获取元素的纯文本,如果text(“content”)就会更改元素的文本内容:html()获取 ...

  9. 用python来分割图片

    程序思路: 此次程序主要是利用PIL(Python Image Libraty)这库,来进行图片的处理.PIL是一个功能非常强大的python图像处理标准库,但由于PIL只支持python2.7.如今 ...

  10. 初识Elasticsearch，bulk 操作的遇到的那些事

    bulk api可以在单个请求中一次执行多个文档的 create . index . update 或 delete 操作 批量操作的行为(action)必须是以下几种: 行为 解释 create 当 ...