蓝桥杯历年真题题目及题解目录汇总
- 结果填空 (满分5分)
- 结果填空 (满分7分)
- 结果填空 (满分13分)
- 结果填空 (满分17分)
- 代码填空 (满分9分)
- 程序设计(满分11分)
- 程序设计(满分19分)
- 程序设计(满分21分)
- 程序设计(满分23分)
- 程序设计(满分25分)
1、标题:第几天
2000年的1月1日,是那一年的第1天。
那么,2000年的5月4日,是那一年的第几天?
注意:需要提交的是一个整数,不要填写任何多余内容。
打开电脑日历数:125
2、标题:方格计数
如图p1.png所示,在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗?
注意:需要提交的是一个整数,不要填写任何多余内容。
根据圆的对此性,我们其实只要对1/4的正半轴圆进行暴力枚举每个方格,这里我们可以转换下关注点,用右上角的点代表一个方格,因为它是最远点,距离公式,答案:3137548,做法其实还有很多,不过填空题这样最快最稳
public class _02方格计数1 {
public static void main(String[] args) {
int d=1000,ans=0;
for(int i=1;i<=d;i++)
for(int j=1;j<=d;j++)
if(i*i+j*j<=d*d)
ans++;
System.out.println(ans*4);
}
}
3、标题:复数幂
设i为虚数单位。对于任意正整数n,(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少? 即(2+3i)的123456次幂,这个数字很大,要求精确表示。
答案写成 "实部±虚部i" 的形式,实部和虚部都是整数(不能用科学计数法表示),中间任何地方都不加空格,实部为正时前面不加正号。(2+3i)^2 写成: -5+12i,
(2+3i)^5 的写成: 122-597i
注意:需要提交的是一个很庞大的复数,不要填写任何多余内容。
答案太长了贴不了,因为a和b都是负数所以不用加+号,ctrl+A复制到记事本或者输出到文件里
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.math.BigInteger;
public class _03_复数幂 {
public static void main(String[] args) throws FileNotFoundException {
BigInteger c = BigInteger.valueOf(2);
BigInteger d = BigInteger.valueOf(3);
BigInteger a = BigInteger.valueOf(2);
BigInteger b = BigInteger.valueOf(3);
//(a+bi)*(c+di) = (a*c - b*d) + (a*d + b*c)i
for(int i=1;i<123456;i++) {
BigInteger A = a.multiply(c).subtract(b.multiply(d));
BigInteger B = a.multiply(d).add(b.multiply(c));
a=A;//如果不设置临时变量,后面b的值会出错
b=B;
}
PrintStream out = System.out;
PrintStream ps = new PrintStream(new File("ans.txt"));//默认在项目的路径
System.setOut(ps);//输出在ans.txt里
System.out.println(a.toString()+b.toString()+"i");
System.setOut(out);//注释了下面就不会输入到控制台里
System.out.println(a.toString()+b.toString()+"i");
}
}
4、标题:测试次数
x星球的居民脾气不太好,但好在他们生气的时候唯一的异常举动是:摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试,并且评定出一个耐摔指数来,之后才允许上市流通。
x星球有很多高耸入云的高塔,刚好可以用来做耐摔测试。塔的每一层高度都是一样的,与地球上稍有不同的是,他们的第一层不是地面,而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏,但第8层摔坏了,则手机耐摔指数=7。
特别地,如果手机从第1层扔下去就坏了,则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏,则耐摔指数=n
为了减少测试次数,从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层,如果我们总是采用最佳策略,在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢?
请填写这个最多测试次数。
注意:需要填写的是一个整数,不要填写任何多余内容。
答案:19,leetcode原题887. 鸡蛋掉落
dp,个人熟悉记忆搜索多些,贴个记忆搜索代码,复杂度都差不多,况且还是填空
public class _04_测试次数 {
public static void main(String[] args) {
for(int i=0;i<10;i++)
for(int j=0;j<10000;j++)
memo[i][j] = 99999999;//找最小,初始化INF
System.out.println(f(3,1000));
}
static int[][] memo = new int[10][10005];
static int f(int n,int m) {
if(n==1)
return m;
if(m==1 || m==2)
return 1;
if(memo[n][m]!=99999999)
return memo[n][m];
for(int i=1;i<=m;i++) {
memo[n][m] = Math.min(memo[n][m], 1+Math.max(f(n,m-i),f(n-1,i)));
}
return memo[n][m];
}
}
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));
}
}
注意:只提交划线部分缺少的代码,不要抄写任何已经存在的代码或符号。
答案:quickSelect(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,否则按无效代码处理。
10W的数据规模,3个for的暴力解法O(n^3)肯定超时,不过拿60%已经挺不错了,优化下,最后一层for改为二分,这样的复杂度O(n^2logn)还是太高,可以再优化一次,把A和B,B和C分开统计,现在在B中二分查找比A[i]大的个数,同理在C中二分查找比B[i]大的个数,最后所有的这2个数相乘的累加就是ans,复杂度O(nlogn)
import java.util.Arrays;
import java.util.Scanner;
public class _06递增三元组 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.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] = in.nextInt();
for(int i=0;i<n;i++)
B[i] = in.nextInt();
for(int i=0;i<n;i++)
C[i] = in.nextInt();
Arrays.sort(A);
Arrays.sort(B);
Arrays.sort(C);
int ans=0;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++)
if(A[i]<B[j]) {
int l=0,r=n-1;
while(l<=r){
int m = (l+r)/2;
if(C[m]>B[j]) r= m-1;
else l = m +1;
}
// System.out.println(i+" "+j+" "+l);
ans+=n-l;
}
// System.out.println();
}
System.out.println(ans);
}
}
O(nlogn)代码,花里胡哨的,想拿满分不容易,别忘了用long,其实这题分值那么小暴力应该能拿80%以上把,数据规模可能是虚的吧,优化浪费的时间有点多
可以测下10W的最坏情况1,2,3有没溢出,提醒粗心的自己org
//第六题:
//
//标题:递增三元组
//给定三个整数数组
//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
//请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。
import java.util.Arrays;
import java.util.Scanner;
public class _06递增三元组2 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.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] = 1;
for(int i=0;i<n;i++)
B[i] = 2;
for(int i=0;i<n;i++)
C[i] = 3;
Arrays.sort(A);
Arrays.sort(B);
Arrays.sort(C);
int[] v = new int[n];//代表在B里面比A[i]大的元素个数
int[] w = new int[n];//同上
// int[] p = new int[n];//索引指针数组,i->j->k,但其实n-v[i]就可以找到B里面那个刚好比A[i]大的下标
long ans=0;
for(int i=0;i<n;i++) {
int l=0,r=n-1;
while(l<=r){
int mid = l + (r-l)/2;
if(B[mid]>A[i])
r= mid-1;
else
l = mid +1;
}
v[i] = n-l;
// p[i] = l;
}
for(int i=0;i<n;i++) {
int l=0,r=n-1;
while(l<=r){
int mid = l + (r-l)/2;
if(C[mid]>B[i])
r= mid-1;
else
l = mid +1;//11+11+3+1
}
w[i] = n-l;
}
for(int i=0;i<n;i++) {
System.out.println(v[i]+" "+w[n-v[i]]);
ans+=v[i]*w[n-v[i]];
}
System.out.println(ans);
}
}
//4
//1 1 2 3
//2 2 3 4
//3 3 4 6 ans:37
//3
//1 2 3
//2 3 4
//2 2 6 ans:6
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,否则按无效代码处理。
数据规模10^9,应该要推出一条O(1)的数学公式才能AC,对于完全没有头绪的可以模拟螺旋轨迹拿30%也挺不错的
import java.util.Scanner;
public class G {
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);
}
}
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,否则按无效代码处理。
双指针+Map+HashSet,模拟点赞过程排重O(n),但排序要O(nlogn),所以总的复杂度为O(nlogn)
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
//标题:日志统计
//小明维护着一个程序员论坛。现在他收集了一份"点赞"日志,日志共有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
//请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。
public class 日志统计 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int d = in.nextInt();
int k = in.nextInt();
ArrayList<Node> list = new ArrayList<>();//曾经为热帖
HashSet<Integer> set = new HashSet<>();//排重
HashMap<Integer, Integer> map = new HashMap<>();//为什么用map,因为其实10W个id并没有全用上
for(int i=0;i<n;i++) {
int a = in.nextInt();
int b = in.nextInt();
map.put(b, 0);
list.add(new Node(a,b));
}
Collections.sort(list);
int min=list.get(0).t,max = list.get(0).t,i=0,j=0;
while(j<n) {//双指针
Node u = list.get(j);
max = u.t;
map.put(u.id, map.get(u.id)+1);
while(max-min>=10){
Node v = list.get(i);
map.put(v.id, map.get(v.id)-1);
i++;
min = list.get(i).t;
}
if(map.get(u.id)>=k)
set.add(u.id);
j++;
}
ArrayList<Integer> ans = new ArrayList<>();
for(int x:set)
ans.add(x);
Collections.sort(ans);
for(int x:ans)
System.out.println(x);
}
static class Node implements Comparable<Node>{
int t,id;
public Node(int t,int id) {
this.t= t;
this.id = id;
}
@Override
public int compareTo(Node o) {
return this.t - o.t;
}
}
}
9、标题:全球变暖
你有一张某海域NxN像素的照片,"."表示海洋、"#"表示陆地,如下所示:
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升,科学家预测未来几十年,岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋),它就会被淹没。
例如上图中的海域未来会变成如下样子:
.......
.......
.......
.......
....#..
.......
.......
请你计算:依照科学家的预测,照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
.......
.##....
.##....
....##.
..####.
...###.
.......
【输出样例】
1
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
简单的求联通块题,先预处理,把有连接海洋的小岛用区别于其他字母的东东替换,接着就是dfs+联通块
//第九题
//
//标题:全球变暖
//
//你有一张某海域NxN像素的照片,"."表示海洋、"#"表示陆地,如下所示:
//.......
//.##....
//.##....
//....##.
//..####.
//...###.
//.......
//其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
//由于全球变暖导致了海面上升,科学家预测未来几十年,岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋),它就会被淹没。
//例如上图中的海域未来会变成如下样子:
//.......
//.......
//.......
//.......
//....#..
//.......
//.......
//请你计算:依照科学家的预测,照片中有多少岛屿会被完全淹没。
//【输入格式】
//
//第一行包含一个整数N。 (1 <= N <= 1000)
//
//以下N行N列代表一张海域照片。
//
//照片保证第1行、第1列、第N行、第N列的像素都是海洋。
//【输出格式】
//一个整数表示答案。
//【输入样例】
//7
//.......
//.##....
//.##....
//....##.
//..####.
//...###.
//.......
//【输出样例】
//1
//资源约定:
//峰值内存消耗(含虚拟机) < 256M
//CPU消耗 < 1000ms
//请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。
import java.util.Scanner;
public class _09全球变暖_ {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
ch = new char[n][n];
vis = new int[n][n];
for(int i=0;i<n;i++)
ch[i] = in.next().toCharArray();
for(int i=0;i<n;i++)
for(int j=0;j<n;j++) {
vis[i][j] = 0;
if(ch[i][j]=='#' && is(i,j))
ch[i][j] = '*';
}
int ans=0;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
if(ch[i][j]=='#' && vis[i][j]==0)
dfs(i,j,++ans);
for(int i=0;i<n;i++) {//检查
for(int j=0;j<n;j++)
System.out.print(ch[i][j]);
System.out.println();
}
System.out.println(ans);
}
static int n;
static char[][] ch;
static int[][] vis;
static int[] dx = new int[] {1,0,-1,0};
static int[] dy = new int[] {0,1,0,-1};
static boolean is(int x,int y) {
for(int i=0;i<4;i++)
if(x+dx[i]>=0 && x+dx[i]<n && y+dy[i]>=0 && y+dy[i]<n && ch[x+dx[i]][y+dy[i]]=='.')
return true;
return false;
}
static void dfs(int x,int y,int t) {
vis[x][y] = t;
for(int i=0;i<4;i++)
if(x+dx[i]>=0 && x+dx[i]<n && y+dy[i]>=0 && y+dy[i]<n && ch[x+dx[i]][y+dy[i]]=='#' && vis[x+dx[i]][y+dy[i]]==0)
dfs(x+dx[i],y+dy[i],t);
}
}
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,否则按无效代码处理。
这题先来个阶乘逆元求组合数复杂度O(nlogn),不过最快的还是Lucas定理,动态规划复杂度O(n),所以整体复杂度O(nlogn),10W的数据规模可行
阶乘逆元模板
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];
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);
}
}
static int n;
static long mod = 1000000009;
static long[] f;
static long[] inv;
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;
}
AC代码,矩阵幂_快速幂_矩阵乘法_模板
import java.util.Scanner;
public class _10_堆的计数1 {
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;
}
}