2018年第九屆藍橋杯省賽試題及詳解（Java本科B組）
藍橋杯歷年真題題目及題解目錄彙總
- 結果填空 (滿分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;
}
}
相關文章
- 2018年第九屆藍橋杯省賽試題及詳解（Java本科A組）Java
- 2013年第四屆藍橋杯省賽試題及詳解（Java本科C組）Java
- 2014年第五屆藍橋杯省賽試題及詳解（Java本科C組）Java
- 第九屆藍橋杯軟體類省賽 Java B組 題目及解析Java
- 第九屆藍橋杯B組省賽———乘積最大
- 2018第九屆藍橋杯省賽C++B組【第四題：測試次數】C++
- 藍橋杯第五屆省賽題目及題解
- 第六屆藍橋杯省賽CC++B組C++
- 2017省賽藍橋杯B組
- 2018藍橋杯省賽B組
- 第九屆藍橋杯省賽C++A組 倍數問題（dfs）C++
- 藍橋杯__省賽__第九屆__C/C++__大學A組C++
- 2016年省賽第七屆藍橋杯B組C/C++第九題解 交換瓶子C++
- 2015年藍橋杯六屆省賽大學B組真題
- 藍橋杯歷年（省賽）試題彙總及試題詳解
- 第十五屆藍橋杯軟體賽省賽C/C++B 組題解C++
- 試題B：小球反彈（第十五屆藍橋杯省賽B組c/c++組）C++
- 第十三屆藍橋杯省賽A組
- 第九屆藍橋杯大賽個人賽決賽（軟體類本科B組）做題筆記 mit zwei Antworten筆記MIT
- 第十三屆藍橋杯省賽C/C++ B組C++
- 第十四屆藍橋杯省賽C++ B組（個人經歷 + 題解）C++
- 2017第八屆藍橋杯C/C++ B組省賽第二題 秒解C++
- 藍橋杯省賽真題2015年第六屆Java本科B組第01題——三角形面積Java
- 【藍橋杯考前突擊】第十屆藍橋杯省賽C/C++大學B組 試題 D 數的分解C++
- 第14屆藍橋杯B組國賽
- 2019年省賽第十屆藍橋杯B組C/C++試題H解 等差數列C++
- 第十五屆藍橋杯C++B組省賽總結C++
- 第十屆藍橋杯省賽C++B組 等差數列C++
- 【題解】爬山 藍橋杯2024省B
- 第十屆藍橋杯C++國賽B組部分題解(假題解)C++
- 藍橋杯省賽真題2013題解
- 2020藍橋杯省賽B組C++(第二場)真題C++
- 2013第四屆藍橋杯省賽C++B組【第六題：三部排序】C++排序
- 藍橋杯__省賽__第七屆__C/C++__大學A組C++
- 藍橋杯__省賽__第八屆__C/C++__大學A組C++
- 2015年省賽第六屆藍橋杯B組C/C++第五題解 九陣列分數C++陣列
- 第十一屆藍橋杯省賽CC++組第二場比賽C++
- 2013第四屆藍橋杯省賽C++A組【第一題：高斯日記】C++