蓝桥杯 2021年省赛真题 (Java 大学B组 )
Placeholder
#A ASC
本题总分:5 分
问题描述
已知大写字母 A A A 的 A S C I I ASCII ASCII 码为 65 65 65,请问大写字母 L L L 的 A S C I I ASCII ASCII 码是多少?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
76
calcCode:
public class Test {
public static void main(String[] args) { new Test().run(); }
void run() {
// System.out.println(65 + 'L' - 'A');
System.out.println((int)'L');
}
}
麻烦签到题写的认真一点,谢谢。
#B 卡片
本题总分:5 分
问题描述
小蓝有很多数字卡片,每张卡片上都是数字
0
0
0 到
9
9
9。
小蓝准备用这些卡片来拼一些数,他想从
1
1
1 开始拼出正整数,每拼一个,就保存起来,卡片就不能用来拼其它数了。
小蓝想知道自己能从
1
1
1 拼到多少。
例如,当小蓝有
30
30
30 张卡片,其中
0
0
0 到
9
9
9 各
3
3
3 张,则小蓝可以拼出
1
1
1 到
10
10
10,但是拼
11
11
11 时卡片
1
1
1 已经只有一张了,不够拼出
11
11
11。
现在小蓝手里有
0
0
0 到
9
9
9 的卡片各
2021
2021
2021 张,共
20210
20210
20210 张,请问小蓝可以从
1
1
1 拼到多少?
提示:建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
3181
朴素解法
public class Test {
public static void main(String[] args) { new Test().run(); }
void run() { System.out.println(calc(2021)); }
int calc(int upper) {
int[] count = new int[10];
for (int n = 1, k = 1; ; k = ++n)
do
if (++count[k % 10] > upper)
return n - 1;
while ((k /= 10) > 0);
}
}
没什么好说的。
弯道超车
观察 [ 1 , 9 ] [1,9] [1,9] 这个区间中, [ 0 , 9 ] [0,9] [0,9] 的出现情况。
在 [ 1 , 9 ] [1,9] [1,9] 中, 1 1 1 至 9 9 9 各出现 1 1 1 次。
把观察的范围扩大到 [ 1 , 99 ] [1,99] [1,99],十位的 1 1 1 出现 [ 10 , 19 ] [10,19] [10,19] 共 10 10 10 次,十位的 2 2 2 出现 [ 20 , 29 ] [20,29] [20,29] 共 10 10 10 次, ⋯ \cdots ⋯ ,十位的 9 9 9 出现 [ 90 , 99 ] [90,99] [90,99] 共 10 10 10 次,低位 [ 0 , 9 ] [0,9] [0,9] 重复出现 10 10 10 次, 1 1 1 至 9 9 9 各出现 20 20 20 次, 0 0 0 出现 9 9 9 次。
将这个观察范围继续扩大,会发现 1 1 1 的使用次数总是不小于 0 0 0 、 2 2 2 至 9 9 9,也就是说统计 0 0 0 、 2 2 2 至 9 9 9 是没有意义的。
public class Test {
public static void main(String[] args) { new Test().run(); }
void run() { System.out.println(calc(20)); }
int calc(int upper) {
int count = 0;
for (int n = 1, k = 1; ; k = ++n) {
do
if (k % 10 == 1) count++;
while ((k /= 10) > 0);
if (count > upper) return n - 1;
}
}
}
#C 直线
本题总分:10 分
问题描述
在平面直角坐标系中,两点可以确定一条直线。如果有多点在一条直线上,那么这些点中任意两点确定的直线是同一条。
给定平面上
2
×
3
2 × 3
2×3 个整点
{
(
x
,
y
)
∣
0
≤
x
<
2
,
0
≤
y
<
3
,
x
∈
Z
,
y
∈
Z
}
\{(x, y)|0 ≤ x < 2, 0 ≤ y < 3, x ∈ Z, y ∈ Z\}
{(x,y)∣0≤x<2,0≤y<3,x∈Z,y∈Z},即横坐标是
0
0
0 到
1
1
1 (包含
0
0
0 和
1
1
1) 之间的整数、纵坐标是
0
0
0 到
2
2
2 (包含
0
0
0 和
2
2
2) 之间的整数的点。这些点一共确定了
11
11
11 条不同的直线。
给定平面上
20
×
21
20 × 21
20×21 个整点
{
(
x
,
y
)
∣
0
≤
x
<
20
,
0
≤
y
<
21
,
x
∈
Z
,
y
∈
Z
}
\{(x, y)|0 ≤ x < 20, 0 ≤ y < 21, x ∈ Z, y ∈ Z\}
{(x,y)∣0≤x<20,0≤y<21,x∈Z,y∈Z},即横坐标是
0
0
0 到
19
19
19 (包含
0
0
0 和
19
19
19) 之间的整数、纵坐标是
0
0
0 到
20
20
20 (包含
0
0
0 和
20
20
20) 之间的整数的点。请问这些点一共确定了多少条不同的直线。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
40257
直线方程集合
一种朴素的想法,是将所有点连接起来,去掉重复的线,然后统计。
为了方便表示,这里采用斜截式方程 y = k x + b y=kx+b y=kx+b 来表示每一条直线,其中 k k k 为直线斜率, b b b 为直线在 y y y 轴上的截距,并统一不处理斜率不存在的线,将结果加上一个 20 20 20。
注意! 这段程序的结果是不准确的。
import java.util.HashSet;
import java.util.Set;
public class Test {
public static void main(String[] args) { new Test().run(); }
int X = 20, Y = 21;
void run() {
Set<Line> set = new HashSet();
for (int x1 = 0; x1 < X; x1++)
for (int y1 = 0; y1 < Y; y1++)
for (int x2 = x1; x2 < X; x2++)
for (double y2 = 0; y2 < Y; y2++)
if (x1 != x2){
double k = (y2 - y1) / (x2 - x1);
double b = -x1 * k + y1;
set.add(new Line(k, b));
}
System.out.println(set.size() + X);
}
class Line {
double k, b;
Line(double b, double k) {
this.k = k;
this.b = b;
}
@Override
public boolean equals(Object obj) {
return k == ((Line)obj).k && b == ((Line)obj).b;
}
@Override
public int hashCode() {
return (int)k ^ (int)b;
}
}
}
分式消除误差
斜率在浮点数表示下,精度那是参差不齐,诚然可以将误差限制在一个范围内,当绝对差落入当中时,我们就将其视为值相同。
但是对于这种需要可表示的范围小的时候,我们可以定义分式来做到无误差,而不是控制精度。
import java.util.HashSet;
import java.util.Set;
public class Test {
public static void main(String[] args) { new Test().run(); }
int X = 20, Y = 21;
void run() {
Set<Line> set = new HashSet();
for (int x1 = 0; x1 < X; x1++)
for (int y1 = 0; y1 < Y; y1++)
for (int x2 = x1; x2 < X; x2++)
for (int y2 = 0; y2 < Y; y2++)
if (x1 != x2){
Fraction k = new Fraction(y2 - y1, x2 - x1);
Fraction b = new Fraction(y1 * (x2 - x1) - x1 * (y2 - y1),x2 - x1);
set.add(new Line(k, b));
}
System.out.println(set.size() + X);
}
class Fraction {
int numerator, denominator;
Fraction(int numerator, int denominator) {
int gcd = gcd(numerator, denominator);
this.denominator = denominator /gcd;
this.numerator = numerator / gcd;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
@Override
public boolean equals(Object obj) {
return this.numerator == ((Fraction)obj).numerator && this.denominator == ((Fraction)obj).denominator;
}
}
class Line {
Fraction k, b;
Line(Fraction b, Fraction k) {
this.k = k;
this.b = b;
}
@Override
public boolean equals(Object obj) {
return this.k.equals(((Line)obj).k) && this.b.equals(((Line)obj).b);
}
@Override
public int hashCode() {
return k.denominator;
}
}
}
平面几何
这是一个平面直角坐标系,原点与 ( 1 , 2 ) (1,2) (1,2) 连成一条线段。
我们将经过这两点的直线,以及这条直线经过的点与该点于横竖轴的垂线标记出来。
显然,若直线经过
(
x
1
,
y
1
)
(x_{1},y_{1})
(x1,y1)、
(
x
2
,
y
2
)
(x_{2},y_{2})
(x2,y2) 两点,那么它必然也经过
(
x
1
+
k
(
x
1
−
x
2
)
,
y
1
+
k
(
y
1
−
y
2
)
)
(x_{1} +k(x_{1} - x_{2}),y_{1} + k(y_{1} - y_{2}))
(x1+k(x1−x2),y1+k(y1−y2)),
k
∈
Z
k \in Z
k∈Z。
若在连接一条直线时,将所有直线经过的点标记起来,在下次遇到已经标记过的两点,我们便可直接跳过。
public class Test {
public static void main(String[] args) { new Test().run(); }
int X = 20, Y = 21;
void run() {
int count = 0;
boolean[][][][] marked = new boolean[X][Y][X][Y];
for (int x1 = 0; x1 < X; x1++)
for (int y1 = 0; y1 < Y; y1++) {
marked[x1][y1][x1][y1] = true;
for (int x2 = 0; x2 < X; x2++)
for (int y2 = 0; y2 < Y; y2++) {
if (marked[x1][y1][x2][y2]) continue;
int x = x1, y = y1, xOffset = x - x2, yOffset = y - y2;
while (x >= 0 && x < X && y >= 0 && y < Y) {
x += xOffset;
y += yOffset;
}
x -= xOffset;
y -= yOffset;
while (x >= 0 && x < X && y >= 0 && y < Y) {
for (int i = x - xOffset, j = y - yOffset; i >= 0 && i < X && j >= 0 && j < Y; i -= xOffset, j -= yOffset) {
marked[x][y][i][j] = marked[i][j][x][y] = true;
}
x -= xOffset;
y -= yOffset;
}
count++;
}
}
System.out.println(count);
}
}
我觉得可能会再考个差不多的,这里给大伙一个推论。
平面直角坐标系上有 n × n n × n n×n, n ≥ 2 n \ge 2 n≥2 个点 { ( x , y ) ∣ 0 ≤ x < n , 0 ≤ y < n , x ∈ Z , y ∈ Z } \{(x, y)|0 ≤ x < n, 0 ≤ y < n, x ∈ Z, y ∈ Z\} {(x,y)∣0≤x<n,0≤y<n,x∈Z,y∈Z},从原点出发可连接的不同直线为 1 ≤ x , y < n 1 \leq x,y <n 1≤x,y<n, x ≠ y x \ne y x=y 中 g c d ( x , y ) = 1 gcd(x,y) = 1 gcd(x,y)=1 的次数加 3 3 3。
感兴趣的读者可以自行证明。
同时在 1 ≤ x < y < n 1 \leq x < y < n 1≤x<y<n 时, g c d ( x , y ) = 1 gcd(x,y) = 1 gcd(x,y)=1 的出现次数恰好等于 ∑ y = 2 n − 1 φ ( y ) \displaystyle\sum_{y = 2}^{n-1}\varphi(y) y=2∑n−1φ(y),其中 φ \varphi φ 为欧拉函数。
能力有限,这里便不再继续讨论。
#D 货物摆放
本题总分:10 分
问题描述
小蓝有一个超大的仓库,可以摆放很多货物。
现在,小蓝有
n
n
n 箱货物要摆放在仓库,每箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向,每箱货物的边都必须严格平行于长、宽、高。
小蓝希望所有的货物最终摆成一个大的立方体。即在长、宽、高的方向上分别堆
L
、
W
、
H
L、W、H
L、W、H 的货物,满足
n
=
L
×
W
×
H
n = L × W × H
n=L×W×H。
给定
n
n
n,请问有多少种堆放货物的方案满足要求。
例如,当
n
=
4
n = 4
n=4 时,有以下
6
6
6 种方案:
1
×
1
×
4
1×1×4
1×1×4、
1
×
2
×
2
1×2×2
1×2×2、
1
×
4
×
1
1×4×1
1×4×1、
2
×
1
×
2
2×1×2
2×1×2、
2
×
2
×
1
2 × 2 × 1
2×2×1、
4
×
1
×
1
4 × 1 × 1
4×1×1。
请问,当
n
=
2021041820210418
n = 2021041820210418
n=2021041820210418 (注意有
16
16
16 位数字)时,总共有多少种方案?
提示:建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
2430
暴力搜索
每届必考的基本算术定理。
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) { new Test().run(); }
long n = 2021041820210418L;
void run() {
List<Integer> exps0 = new ArrayList();
ArrayDeque<Integer> exps1 = new ArrayDeque();
for (int k = 2; k <= n; k++)
if (n % k == 0) {
int e = 0;
while (n % k == 0) {
n /= k;
e++;
}
exps0.add(e);
}
System.out.println(dfs(exps0, exps1, 0));
}
int dfs(List<Integer> exps0, ArrayDeque<Integer> exps1, int cur) {
if (cur == exps0.size()) {
int comb = 1;
for (int exp : exps1)
comb *= exp + 1;
return comb;
}
int ans = 0;
for (int i = exps0.get(cur); i >= 0; i--) {
exps1.push(i);
ans += dfs(exps0, exps1, cur + 1);
exps1.pop();
}
return ans;
}
}
直接套两 for 也不是不行,但这么写出来的程序,通常到比赛结束都跑不完。
因此我们要避免无效因子的判断,
这里统计的为质因子分成三份,可能的组合个数,它与原命题等价。
没什么好讲的。
只用套两 for 是因为一个数的因子只能成对出现,
扫一下数盲。
缩放质因子
举个例子,
当 n = 9 n = 9 n=9 时,有 6 6 6 种方案: 1 × 1 × 9 1×1×9 1×1×9、 1 × 3 × 3 1×3×3 1×3×3、 1 × 9 × 1 1×9×1 1×9×1、 3 × 1 × 3 3×1×3 3×1×3、 3 × 3 × 1 3 × 3 × 1 3×3×1、 9 × 1 × 1 9 × 1 × 1 9×1×1;
当 n = 25 n = 25 n=25 时,有 6 6 6 种方案: 1 × 1 × 25 1×1×25 1×1×25、 1 × 5 × 5 1×5×5 1×5×5、 ⋯ \cdots ⋯ ;
当 n = p 2 n =p^{2^{}} n=p2 时,有 6 6 6 种方案: 1 × 1 × p 2 1×1×p^{2} 1×1×p2、 1 × p × p 1×p×p 1×p×p、 ⋯ \cdots ⋯ ;
其中 p p p 为质数。
其实上例解法当中,我们就能发现,组合的个数与其具体的值无关,它只与质因数指数挂钩。
2021041820210418 = 2 × 3 3 × 17 × 131 × 2857 × 5882353 2021041820210418 = 2 × 3^3 × 17 × 131 × 2857 × 5882353 2021041820210418=2×33×17×131×2857×5882353
如果我们找最小的几个质数来代替它们,得到的新数字 2 3 × 3 × 5 × 7 × 11 × 13 = 120120 2^3 × 3 × 5 × 7 × 11 × 13 = 120120 23×3×5×7×11×13=120120 与 2021041820210418 2021041820210418 2021041820210418 在这个命题下等价。
而 120120 120120 120120 的大小就足够我们真暴搜把它的全部因数组合找到了。
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) { new Test().run(); }
long N = 2021041820210418L;
void run() {
List<Integer> exps = new ArrayList();
for (int k = 2; k <= N; k++)
if (N % k == 0) {
int e = 0;
while (N % k == 0) {
N /= k;
e++;
}
exps.add(e);
}
exps.sort((a, b) -> (b - a));
int n = 1, p = 2, ans = 0;
for (int exp : exps) {
for (int i = 2; i * i <= p; i++)
if (p % i == 0) {
i = 1;
p++;
}
while (exp-- > 0) n *= p;
p++;
}
for (int a = 1; a <= n; a++)
if (n % a == 0)
for (int b = 1; b <= n; b++)
if (n / a % b == 0) ans++;
System.out.println(ans);
}
}
#E 路径
本题总分:15 分
问题描述
小蓝学习了最短路径之后特别高兴,他定义了一个特别的图,希望找到图中的最短路径。
小蓝的图由
2021
2021
2021 个结点组成,依次编号
1
1
1 至
2021
2021
2021。对于两个不同的结点
a
,
b
a, b
a,b,如果
a
a
a 和
b
b
b 的差的绝对值大于
21
21
21,则两个结点之间没有边相连;如果
a
a
a 和
b
b
b 的差的绝对值小于等于
21
21
21,则两个点之间有一条长度为
a
a
a 和
b
b
b 的最小公倍数的无向边相连。
例如:结点
1
1
1 和结点
23
23
23 之间没有边相连;结点
3
3
3 和结点
24
24
24 之间有一条无向边,长度为
24
24
24;结点
15
15
15 和结点
25
25
25 之间有一条无向边,长度为
75
75
75。
请计算,结点
1
1
1 和结点
2021
2021
2021 之间的最短路径长度是多少。
提示:建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
10266837
题目已经说的够清楚了,
建一个有 2021 2021 2021 个顶点 21 × 2000 + 21 ( 21 + 1 ) 2 21 × 2000 + \cfrac{21(21 + 1)}{2} 21×2000+221(21+1) 条边的无向图,跑图上的算法就完事了。
还有的细节就是整形是否会溢出,我们取 ( 1 , 2021 ] (1,2021] (1,2021] 中最大的质数 2017 2017 2017 与 202 1 2 2021^2 20212 相乘,得到的结果还是有点夸张的,虽然经过测试,可能的线路权值合至多不会超过 2 31 − 1 2^{31} - 1 231−1,但毕竟是面向竞赛,考虑甄别的时间成本,直接使用长整形更为划算。
搜索
深度优先搜索
2021 2021 2021 个顶点,绝大多数顶点都连有 2 × 21 2 × 21 2×21 条边,
别深搜了,一搜就是
compilaition completed successfully in 500ms(4 hour ago)
就,电脑跟选手对着坐牢。
记忆化搜索
深度优先搜索,在搜索最优结果时,通常需要完整的枚举全部可能的问题状态。
但在这个问题状态的集合中,所有可选方案的 “后缀” 都是相同,也就是所有可选的分支,它们都是以同一个节点结尾。
如果我们将已经搜索到的节点到目标节点间的最短路径保存下来,在再次搜索到这个 “后缀” 的分支时直接返回。
那么问题就可能在一个较短的时间内解决。
这也是所谓的记忆化搜索。
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) { new Test().run(); }
int N = 2021;
int[] weight = new int[N + 1];
List<Edge>[] graph = new List[N + 1];
boolean[] visited = new boolean[N + 1];
void run() {
for (int i = 1; i <= N; i++)
graph[i] = new ArrayList();
for (int v = 1; v < N; v++)
for (int w = v + 1; w <= min(v + 21, N); w++) {
graph[v].add(new Edge(w, lcm(v, w)));
graph[w].add(new Edge(v, lcm(v, w)));
}
visited[1] = true;
System.out.println(dfs(1));
}
int dfs(int v) {
if (v == N) return 0;
if (weight[v] != 0) return weight[v];
int min = 0x7FFFFFFF;
for (Edge edge : graph[v]) {
if (visited[edge.w]) continue;
visited[edge.w] = true;
min = min(min, dfs(edge.w) + edge.weight);
visited[edge.w] = false;
}
return weight[v] = min;
}
int min(int a, int b) { return a < b ? a : b; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
class Edge {
int w, weight;
Edge(int w, int weight) {
this.weight = weight;
this.w = w;
}
}
}
枝剪广搜
其实朴素的去搜索,不论深搜还是广搜,在竞赛里都是很冒进的行为,
影响这两个算法执行效率的因素太多。
当然要是没有其他的思路,也只能死马当活马医了。
幸运的是,只需简单的枝剪,就能在很短的时间计算出结果
import java.util.PriorityQueue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;
import java.util.List;
public class Test {
public static void main(String[] args) { new Test().run(); }
int N = 2021;
void run() {
List<Edge>[] graph = new List[N + 1];
long[] visited = new long[N + 1];
for (int i = 1; i <= N; i++)
graph[i] = new ArrayList();
for (int v = 1; v < N; v++)
for (int w = v + 1; w <= min(v + 21, N); w++) {
graph[v].add(new Edge(w, lcm(v, w)));
graph[w].add(new Edge(v, lcm(v, w)));
}
Queue<Vertex> queue = new PriorityQueue();
Arrays.fill(visited, Long.MAX_VALUE);
queue.offer(new Vertex(1, 0));
Vertex V = null;
while (queue.size() > 0) {
V = queue.poll();
if (V.v == N) break;
if (V.weight >= visited[V.v]) continue;
visited[V.v] = V.weight;
for (Edge edge : graph[V.v])
queue.offer(new Vertex(edge.w, edge.weight + V.weight));
}
System.out.println(V.weight);
}
int min(int a, int b) { return a < b ? a : b; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
class Edge {
int w, weight;
Edge(int w, int weight) {
this.weight = weight;
this.w = w;
}
}
class Vertex implements Comparable<Vertex> {
int v;
long weight;
Vertex(int v, long weight) {
this.weight = weight;
this.v = v;
}
@Override
public int compareTo(Vertex V) { return Long.compare(this.weight, V.weight); }
}
}
单源最短路径
Dijkstra
题目给出的图显然是个边加权,权重非负的无向图,跑遍 D i j k s t r a Dijkstra Dijkstra 就完事了。
import java.util.PriorityQueue;
import java.util.ArrayList;
import java.util.Queue;
import java.util.List;
public class Test {
public static void main(String[] args) { new Test().run(); }
int N = 2021;
void run() {
boolean[] marked = new boolean[N + 1];
List<Edge>[] graph = new List[N + 1];
long[] distTo = new long[N + 1];
for (int i = 1; i <= N; i++) {
graph[i] = new ArrayList();
distTo[i] = Long.MAX_VALUE;
}
for (int v = 1; v < N; v++)
for (int w = v + 1; w <= min(v + 21, N); w++) {
graph[v].add(new Edge(w, lcm(v, w)));
graph[w].add(new Edge(v, lcm(v, w)));
}
Queue<Vertex> queue = new PriorityQueue();
queue.offer(new Vertex(1, distTo[1] = 0));
while (queue.size() > 0) {
Vertex V = queue.poll();
if (marked[V.v])
continue;
marked[V.v] = true;
for (Edge edge : graph[V.v])
if (distTo[edge.w] > distTo[V.v] + edge.weight)
queue.offer(new Vertex(edge.w, distTo[edge.w] = distTo[V.v] + edge.weight));
}
System.out.println(distTo[N]);
}
int min(int a, int b) { return a < b ? a : b; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
class Edge {
int w, weight;
Edge(int w, int weight) {
this.weight = weight;
this.w = w;
}
}
class Vertex implements Comparable<Vertex> {
int v;
long dist;
Vertex(int v, long dist) {
this.dist = dist;
this.v = v;
}
@Override
public int compareTo(Vertex V) { return Long.compare(this.dist, V.dist); }
}
}
Floyd
如果是一道最短路径的结果题。
竞赛时限内能运行完 O ( n 3 ) O(n^{3}) O(n3) 的程序。
那其实无脑套 F l o y d Floyd Floyd 就行。
public class Test {
public static void main(String[] args) { new Test().run(); }
int N = 2021;
void run() {
long[][] floyd = new long[N + 1][N + 1];
for (int v = 1; v < N; v++)
for (int w = v + 1; w <= min(N, v + 21); w++)
floyd[v][w] = floyd[w][v] = lcm(v, w);
for (int k = 1; k <= N; k++)
for (int v = 1; v <= N; v++)
if (floyd[v][k] == 0) continue;
else for (int w = 1; w <= N; w++)
if (floyd[k][w] == 0) continue;
else if (floyd[v][w] == 0 || floyd[v][k] + floyd[k][w] < floyd[v][w])
floyd[v][w] = floyd[v][k] + floyd[k][w];
System.out.println(floyd[1][N]);
}
long min(int a, int b) { return a < b ? a : b; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
}
半分钟就出来了,还行。
A*
隐隐觉得能找到一些有启发性的性质。
推了一下午狗屁没推出来,就当在这开个坑把。
在这里插入代码片
#F 时间显示
时间限制: 1.0 1.0 1.0s 内存限制: 512.0 512.0 512.0MB 本题总分: 15 15 15 分
问题描述
小蓝要和朋友合作开发一个时间显示的网站。在服务器上,朋友已经获取了当前的时间,用一个整数表示,值为从
1970
1970
1970 年
1
1
1 月 1 日
00
:
00
:
00
00:00:00
00:00:00 到当前时刻经过的毫秒数。
现在,小蓝要在客户端显示出这个时间。小蓝不用显示出年月日,只需显示出时分秒即可,毫秒也不用显示,直接舍去即可。
给定一个用整数表示的时间,请将这个时间对应的时分秒输出。
输入格式
输入一行包含一个整数,表示时间。
输出格式
输出时分秒表示的当前时间,格式形如 H H HH HH: M M MM MM: S S SS SS,其中 H H HH HH 表示时,值为 0 0 0 到 23 23 23, M M MM MM 表示分,值为 0 0 0 到 59 59 59, S S SS SS 表示秒,值为 0 0 0 到 59 59 59。时、分、秒不足两位时补前导 0 0 0。
测试样例1
Input:
46800999
Output:
13:00:00
测试样例2
Input:
1618708103123
Output:
01:08:23
评测用例规模与约定
对于所有评测用例,给定的时间为不超过 1 0 18 10^{18} 1018 的正整数。
Java Win
import java.util.Scanner;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class Main {
public static void main(String[] args) { new Main().run(); }
void run() {
System.out.println(
LocalTime.MIDNIGHT.
plusSeconds(
new Scanner(System.in).nextLong() / 1000).
format(DateTimeFormatter.ISO_LOCAL_TIME)
);
}
}
不依赖 API 的实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) { new Main().run(); }
void run() {
long t = new Scanner(System.in).nextLong();
System.out.printf("%02d:%02d:%02d",
t / 3600000 % 24, t / 60000 % 60, t / 1000 % 60);
}
}
送分。
#G 最少砝码
时间限制: 1.0 1.0 1.0s 内存限制: 512.0 512.0 512.0MB 本题总分: 20 20 20 分
问题描述
你有一架天平。现在你要设计一套砝码,使得利用这些砝码可以称出任意小于等于
N
N
N 的正整数重量。
那么这套砝码最少需要包含多少个砝码?
注意砝码可以放在天平两边。
输入格式
输入包含一个正整数 N N N。
输出格式
输出一个整数代表答案。
测试样例1
Input:
7
Output:
3
Explanation:
3 个砝码重量是 1、4、6,可以称出 1 至 7 的所有重量。
1 = 1;
2 = 6 − 4 (天平一边放 6,另一边放 4);
3 = 4 − 1;
4 = 4;
5 = 6 − 1;
6 = 6;
7 = 1 + 6;
少于 3 个砝码不可能称出 1 至 7 的所有重量。
评测用例规模与约定
对于所有评测用例, 1 ≤ N ≤ 1000000000 1 ≤ N ≤ 1000000000 1≤N≤1000000000。
变种三进制
不知道怎么取标题,也算是个规律题,
这不是纯纯的恶心人吗。
一个集合中包含 n n n 个数,任取若干数可以加减出任意小于等于 N N N 的正整数。
首先要考虑怎么去满足题目要求的性质,
设第 i i i 个砝码的重量为 w i w_{i} wi,原集合 A N = { w 1 , w 2 , ⋯ , w n } A_{N} = \{w_{1},w_{2},\cdots,w_{n}\} AN={w1,w2,⋯,wn}。
要满足题意首先要有 s u m ( A ) ≥ N sum(A) \ge N sum(A)≥N,
设我们知道了 A ⌊ N / 3 ⌋ A_{\lfloor N/3 \rfloor} A⌊N/3⌋ 的方案,那么我们就能在这个方案里加入一个 2 ⌊ N / 3 ⌋ + 1 2\lfloor N/3 \rfloor + 1 2⌊N/3⌋+1,就能用 2 ⌊ N / 3 ⌋ + 1 2\lfloor N/3 \rfloor + 1 2⌊N/3⌋+1 对 A ⌊ N / 3 ⌋ A_{\lfloor N/3 \rfloor} A⌊N/3⌋ 中个若干元素做差表示出 ( ⌊ N / 3 ⌋ , 2 ⌊ N / 3 ⌋ + 1 ) (\lfloor N/3 \rfloor, 2\lfloor N/3 \rfloor + 1) (⌊N/3⌋,2⌊N/3⌋+1),对若干元素求和表示出 ( 2 ⌊ N / 3 ⌋ + 1 , N ] (2\lfloor N/3 \rfloor + 1, N] (2⌊N/3⌋+1,N],并入 A ⌊ N / 3 ⌋ A_{\lfloor N/3 \rfloor} A⌊N/3⌋ 本身能表示的范围,即能表示出任意小于等于 N N N 的正整数。
如果 A ⌊ N / 3 ⌋ A_{\lfloor N/3 \rfloor} A⌊N/3⌋ 本身是最优的,那么往里面加入 K = 2 ⌊ N / 3 ⌋ + 1 K = 2\lfloor N/3 \rfloor + 1 K=2⌊N/3⌋+1 的 A N A_N AN 也一定是最优的,因为要使得 K + s u m ( A ⌊ N / 3 ⌋ ) ≥ N K + sum(A_{\lfloor N/3 \rfloor}) \ge N K+sum(A⌊N/3⌋)≥N, K K K 必须大于等于 2 ⌊ N / 3 ⌋ + 1 2\lfloor N/3 \rfloor + 1 2⌊N/3⌋+1,而当 K > 2 ⌊ N / 3 ⌋ + 1 K > 2\lfloor N/3 \rfloor + 1 K>2⌊N/3⌋+1 时,就无法表示出 ⌊ N / 3 ⌋ + 1 \lfloor N/3 \rfloor + 1 ⌊N/3⌋+1,
当然这一切还有个前提条件,那就是 s u m ( A ⌊ N / 3 ⌋ ) = ⌊ N / 3 ⌋ sum(A_{\lfloor N/3 \rfloor}) = \lfloor N/3 \rfloor sum(A⌊N/3⌋)=⌊N/3⌋。’
不过到这里已经足够启发我们去顺推了,
因为这个问题的边界是显然的,
当 N = 1 N = 1 N=1 时, A 1 = { 1 } A_{1} = \{1\} A1={1},
我们往 A 1 A_{1} A1 中加入 2 × s u m ( A 1 ) + 1 2 × sum(A_{1}) + 1 2×sum(A1)+1,得到 A 4 A_{4} A4,即
当 N = 4 N = 4 N=4 时, A 4 = { 1 , 3 } A_{4} = \{1,3\} A4={1,3},
当 N = 13 N = 13 N=13 时, A 13 = { 1 , 3 , 9 } A_{13} = \{1,3,9\} A13={1,3,9},
⋯ ⋯ \cdots \cdots ⋯⋯
当然还存在 N N N 不在我们找到的最优规律中。
我们设 N = 5 N = 5 N=5,
因为 A 4 = { 1 , 3 } A_{4} = \{1,3\} A4={1,3} 的最优性, 2 2 2 个元素至多组成任意小于等于 4 4 4 的正整数,
因为 A 13 = { 1 , 3 , 9 } A_{13} = \{1,3,9\} A13={1,3,9} 的最优性, 3 3 3 个元素可以表示任意小于等于 13 13 13 的正整数。
即对 N = 5 N = 5 N=5 给出的答案,必须大于 2 2 2 小于等于 3 3 3。
对于给出任意 N N N 我们都可以按照这个性质求出答案。
同时在三进制下来看这个规律:
{ N } = { ( 1 ) 3 , ( 11 ) 3 , ( 11 ) 3 , ⋯ } \{N\} = \{(1)_{3},(11)_{3},(11)_{3},\cdots\} {N}={(1)3,(11)3,(11)3,⋯}
可以二分,但没有必要。
import java.util.Scanner;
public class Main {
public static void main(String[] args) { new Main().run(); }
void run() {
long N = new Scanner(System.in).nextLong(), ans = 1;
for (long pow3 = 1; pow3 < N; pow3 = pow3 * 3 + 1, ans++);
System.out.println(ans);
}
}
写的稀烂,主要这题目出的就恶心人。
#H 杨辉三角形
时间限制: 5.0 5.0 5.0s 内存限制: 512.0 512.0 512.0MB 本题总分: 20 20 20 分
下面的图形是著名的杨辉三角形:
如果我们按从上到下、从左到右的顺序把所有数排成一列,可以得到如下数列:
1
,
1
,
1
,
1
,
2
,
1
,
1
,
3
,
3
,
1
,
1
,
4
,
6
,
4
,
1
,
⋯
1, 1, 1, 1, 2, 1, 1, 3, 3, 1, 1, 4, 6, 4, 1, \cdots
1,1,1,1,2,1,1,3,3,1,1,4,6,4,1,⋯
给定一个正整数
N
N
N,请你输出数列中第一次出现
N
N
N 是在第几个数?
输入格式
输入一个整数 N N N。
输出格式
输出一个整数代表答案。
测试样例1
Input:
6
Output:
13
评测用例规模与约定
对于
20
20
20% 的评测用例,
1
≤
N
≤
10
1 ≤ N ≤ 10
1≤N≤10;
对于所有评测用例,
1
≤
N
≤
1000000000
1 ≤ N ≤ 1000000000
1≤N≤1000000000。
图片高清重置
类比单调数列
杨辉三角最外层全部是 1 1 1。
第二层则是自然数序列。
因为杨辉三角是左右对称的,因此我们可以忽略右边(左边的数字总是比右边先出现),并将数字按层分成若干序列。
由于序列都是从上置下单调递增的,我们可以在每一个这种序列上,二分查找
N
N
N 的位置,特别的,
N
=
1
N = 1
N=1 时直接输出
1
1
1。
此外,杨辉三角第 n n n 行 m 列 列 列
= C n − 1 m − 1 = ( n − 1 ) ! ( m − 1 ) ! ( n − m ) ! =C_{n-1}^{m-1} = \cfrac{(n-1)!}{(m-1)!(n - m)!} =Cn−1m−1=(m−1)!(n−m)!(n−1)!
这个数字增长的非常快 C 32 16 = 1166803110 > 1 e 9 C_{32}^{16} = 1166803110 > 1e9 C3216=1166803110>1e9。
也就至多在 14 14 14 条(除去最外两层)这样的序列中查找 N N N 的位置,因为序列的单调性不允许 N N N 的出现。
import java.util.Scanner;
public class Main {
public static void main(String[] args) { new Main().run(); }
int N;
void run() {
N = new Scanner(System.in).nextInt();
if (N == 1) System.out.println(1);
else {
long ans = (N + 1L) * N / 2 + 2;
for (int m = 2; m < 16; m++) {
int start = m * 2, end = N;
while (start <= end) {
int mid = start + end >> 1;
if (C(mid, m) == N) {
ans = min(ans, (mid + 1L) * mid / 2 + m + 1);
break;
} if (C(mid, m) > N) end = mid - 1;
else start = mid + 1;
}
}
System.out.println(ans);
}
}
long min(long a, long b) { return a < b ? a : b; }
long C(int n, int m) {
long num = 1;
for (int nm = 1; nm <= m; n--, nm++)
if ((num = num * n / nm) > N) return num;
return num;
}
}
#I 双向排序
时间限制: 5.0 5.0 5.0s 内存限制: 512.0 512.0 512.0MB 本题总分: 25 25 25 分
问题描述
给定序列
(
a
1
,
a
2
,
⋅
⋅
⋅
,
a
n
)
=
(
1
,
2
,
⋅
⋅
⋅
,
n
)
(a_{1}, a_{2}, · · · , a_{n}) = (1, 2, · · · , n)
(a1,a2,⋅⋅⋅,an)=(1,2,⋅⋅⋅,n),即
a
i
=
i
a_{i} = i
ai=i。
小蓝将对这个序列进行
m
m
m 次操作,每次可能是将
a
1
,
a
2
,
⋅
⋅
⋅
,
a
q
i
a_{1}, a_{2}, · · · , a_{q_{i}}
a1,a2,⋅⋅⋅,aqi 降序排列,或者将
a
q
i
,
a
q
i
+
1
,
⋅
⋅
⋅
,
a
n
a_{q_{i}}, a_{q_{i+1}}, · · · , a_{n}
aqi,aqi+1,⋅⋅⋅,an 升序排列。
请求出操作完成后的序列。
输入格式
输入的第一行包含两个整数
n
,
m
n, m
n,m,分别表示序列的长度和操作次数。
接下来
m
m
m 行描述对序列的操作,其中第
i
i
i 行包含两个整数
p
i
,
q
i
p_{i}, q_{i}
pi,qi 表示操作类型和参数。当
p
i
=
0
p_{i} = 0
pi=0 时,表示将
a
1
,
a
2
,
⋅
⋅
⋅
,
a
q
i
a_{1}, a_{2}, · · · , a_{q_{i}}
a1,a2,⋅⋅⋅,aqi 降序排列;当
p
i
=
1
p_{i} = 1
pi=1 时,表示将
a
q
i
,
a
q
i
+
1
,
⋅
⋅
⋅
,
a
n
a_{q_{i}}, a_{q_{i+1}}, · · · , a_{n}
aqi,aqi+1,⋅⋅⋅,an 升序排列。
输出格式
输出一行,包含 n n n 个整数,相邻的整数之间使用一个空格分隔,表示操作完成后的序列。
测试样例1
Input:
3 3
0 3
1 2
0 2
Output:
3 1 2
Explanation:
原数列为 (1, 2, 3)。
第 1 步后为 (3, 2, 1)。
第 2 步后为 (3, 1, 2)。
第 3 步后为 (3, 1, 2)。与第 2 步操作后相同,因为前两个数已经是降序了。
评测用例规模与约定
对于
30
30
30% 的评测用例,
n
,
m
≤
1000
n, m ≤ 1000
n,m≤1000;
对于
60
60
60% 的评测用例,
n
,
m
≤
5000
n, m ≤ 5000
n,m≤5000;
对于所有评测用例,
1
≤
n
,
m
≤
100000
1 ≤ n, m ≤ 100000
1≤n,m≤100000,
0
≤
p
i
≤
1
0 ≤ p_{i} ≤ 1
0≤pi≤1,
1
≤
q
i
≤
n
1 ≤ q_{i} ≤ n
1≤qi≤n;
去冗操作
其实看到这个数据规模,五分钟写完 Brute Force,就可以下一道了, O ( m n log n ) O(mn \log n) O(mnlogn) 就能过 60 60 60% 的用例,
多的时间去证明其他程序的正确性可能收益会高点。
不过,骗分就多骗两个吧。
对于连续且 p i p_{i} pi 相同操作,在 p i = 0 p_{i} = 0 pi=0 时只需要做 q i q_{i} qi 最大的操作,在 p i = 1 p_{i} = 1 pi=1 时只需要做 q i q_{i} qi 最小的操作,如图:
显然去掉冗余操作后,还是和原操作是等价的,只需要建立一个栈就能在线性时间内完成去冗,并且代码量较少。
特别的,我可以先将 ( p : 1 , q : 1 ) (p:1,q:1) (p:1,q:1) 压入栈底。
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) { new Main().run(); }
void run() {
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.readInt(), m = in.readInt();
Deque<Step> deque = new ArrayDeque();
deque.push(new Step(1, 1));
while (m-- > 0) {
int p = in.readInt();
int q = in.readInt();
while (deque.size() > 0 && deque.peek().p == p)
if (p == 0)
q = max(q, deque.pop().q);
else
q = min(q, deque.pop().q);
deque.push(new Step(p, q));
}
Integer[] ans = new Integer[n];
for (int i = 0; i < n; i++)
ans[i] = i + 1;
deque.pollLast();
while (deque.size() > 0) {
Step step = deque.pollLast();
if (step.p == 0)
Arrays.sort(ans, 0, step.q, (a, b)->(b - a));
else
Arrays.sort(ans, step.q - 1, n);
}
for (int i = 0; i < n; i++) {
out.print(ans[i]);
out.print(' ');
}
out.flush();
}
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
class Step {
int p, q;
Step(int p, int q) {
this.p = p;
this.q = q;
}
}
class InputReader {
BufferedReader reader;
StringTokenizer token;
InputReader(InputStream in) {
this.reader = new BufferedReader(new InputStreamReader(in));
}
String read() {
while (token == null || !token.hasMoreTokens()) {
try {
token = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return token.nextToken();
}
int readInt() { return Integer.parseInt(read()); }
}
}
挣扎一下
这里仅提供一个思路,
假设 n , m ≤ 10000 , 50000 , 100000 n, m \leq 10000, 50000, 100000 n,m≤10000,50000,100000 各占最后 40 40 40% 的三分之一,
也就是理想下我们没多处理一个量级,就能多拿到 3 3 3 至 4 4 4 分。
可以尝试 去冗 + 桶排基排 混起来乱搞一波, 50000 50000 50000 的数据 5 5 5s 还是能跑下来的。
就,证我绝学。
填数游戏
其实最开始就想直接写到这一步,
但是我忙的同时又有点闲,就拆开写吧。
经过上述去冗操作,可以发现,最后需要操作的是一个 p 0 ∣ 1 p \ 0\mid 1 p 0∣1 交替的序列,为了便于读者理解,
这里将原序列和操作抽象成不等长不同色线段,
特别的,原序列和 p = 1 p = 1 p=1 的操作是一个颜色,因为原序列本就是升序。
将
p
=
0
p=0
p=0 和
p
=
1
p=1
p=1 最大操作范围标记出来。
显然,在
q
q
q 不为端点时,每次操作都有段不变的区间。
图像告诉了我们,如果 q q q 操作的范围盖过了栈里最近的 q q q,那么不仅这个最近的 q q q,连同栈顶 q q q 相反的操作都是可以跳过的。
同时根据这个性质优化后,根据栈内剩余的操作,我们总是能找到一段顺或倒序的不变区间。
将不变区间填入最终的答案,整个算法就大体完成了。
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) { new Main().run(); }
void run() {
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.readInt(), m = in.readInt(), top;
Step[] stack = new Step[m + 1];
for (top = 0; m-- > 0;) {
int p = in.readInt();
int q = in.readInt();
if (p == 0) {
while (top > 0 && stack[top].p == p) q = max(q, stack[top--].q);
while (top > 1 && stack[top - 1].q <= q) top -= 2;
stack[++top] = new Step(p, q);
} else if (top > 0){
while (top > 0 && stack[top].p == p) q = min(q, stack[top--].q);
while (top > 1 && stack[top - 1].q >= q) top -= 2;
stack[++top] = new Step(p, q);
}
}
int[] ans = new int[n + 1];
int a = n, l = 0, r = n - 1;
for (int i = 1; i <= top; i++)
if (stack[i].p == 0)
while (r >= stack[i].q && l <= r) ans[r--] = a--;
else
while (l + 1 < stack[i].q && l <= r) ans[l++] = a--;
if ((top & 1) == 1)
while (l <= r) ans[l++] = a--;
else
while (l <= r) ans[r--] = a--;
for (int i = 0; i < n; i++) {
out.print(ans[i]);
out.print(' ');
}
out.flush();
}
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
class Step {
int p, q;
Step(int p, int q) {
this.p = p;
this.q = q;
}
}
class InputReader {
BufferedReader reader;
StringTokenizer token;
InputReader(InputStream in) {
this.reader = new BufferedReader(new InputStreamReader(in));
}
String read() {
while (token == null || !token.hasMoreTokens()) {
try {
token = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return token.nextToken();
}
int readInt() { return Integer.parseInt(read()); }
}
}
Chtholly Tree
未加限定的珂朵莉树 ( C h t h o l l y T r e e \mathrm{Chtholly Tree} ChthollyTree),就是红黑树上建值域线段树,在随机构造的数据下期望复杂度为 O ( n log log n ) O(n \log \log n) O(nloglogn),
但 J a v a \mathrm{Java} Java 实现起来非常痛苦,于是 p l a n B \mathrm{plan\ B} plan B,改用链表实现,
其在随机构造的数据下期望复杂度为 O ( n log n ) O(n \log n) O(nlogn)。
珂朵莉树的策略就是将值域相同的区间合并成一个节点,
对于任意 [ L , R ] [L,R] [L,R] 上的操作,我们都能转换成珂朵莉树 m e r g e ( s p l i t ( L ) , s p l i t ( R + 1 ) ) \mathrm{merge(split(L), split(R+1))} merge(split(L),split(R+1)) 上的操作。
这里其实是珂朵莉链表而不是树
举个具体且形象的例子对我来说还是太难了,
兄弟们自己找篇博客参考一下吧。
虽然捏个踢烂珂朵莉树的数据很简单,
但就蓝桥的难度而言,
出题人见没见过还是个问题。
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) { new Main().run(); }
void run() {
InputReader in = new InputReader(System.in);
int n = in.readInt(), m = in.readInt();
Node[] root = new Node[n + 1];
int[] P = new int[n + 1];
Range lower, temp, now;
lower = now = new Range(0);
for (int i = 1; i <= n; i++) {
now = now.next = new Range(i);
root[i] = build(1, n, i);
}
now.next = new Range(n + 1);
while (m-- > 0) {
int p = in.readInt();
int L = in.readInt();
int R = n;
if (p == 0) {
R = L;
L = 1;
}
now = lower;
while (now.next.L <= L) now = now.next;
if (L > now.L) {
root[L] = split(root[now.L], L - now.L, P[now.L]);
now = now.next = new Range(L, now.next);
}
temp = now;
Node pq = null;
while (now.L <= R) {
if (now.next.L > R + 1) root[R + 1] = split(root[now.L], R + 1 - now.L, P[R + 1] = P[now.L]);
pq = merge(pq, root[now.L]);
now = now.next;
}
if (now.L == R + 1) temp.next = now;
else temp.next = new Range(R + 1, now);
root[L] = pq;
P[L] = p;
}
StringBuilder ans = new StringBuilder();
while ((lower = lower.next).L <= n)
buildAns(ans, root[lower.L], 1, n, P[lower.L]);
System.out.println(ans);
}
Node split(Node tree, int k, int p) {
if (tree == null) return null;
Node split= new Node(0);
if (p == 0) {
int K = K(tree.right);
if (k <= K) {
if (k != K) split.right = split(tree.right, k, p);
split.left = tree.left;
tree.left = null;
} else split.left = split(tree.left, k - K, p);
} else {
int K = K(tree.left);
if (k <= K) {
if (k != K) split.left = split(tree.left, k, p);
split.right = tree.right;
tree.right = null;
} else split.right = split(tree.right, k - K, p);
}
split.k = tree.k - k;
tree.k = k;
return split;
}
Node merge(Node tree1, Node tree2) {
if (tree1 == null) return tree2;
if (tree2 != null){
tree1.k += K(tree2);
tree1.left = merge(tree1.left, tree2.left);
tree1.right = merge(tree1.right, tree2.right);
}
return tree1;
}
Node build(int L, int R, int k) {
if (L == R) return new Node(1);
Node node = new Node(1);
int mid = L + R >> 1;
if (k <= mid) node.left = build(L, mid, k);
else node.right = build(mid + 1, R, k);
return node;
}
void buildAns(StringBuilder builder, Node root, int L, int R, int p) {
if (root == null) return;
if (L == R) builder.append(L).append(' ');
else {
int mid = L + R >> 1;
if (p == 0) {
buildAns(builder, root.right, mid + 1, R, p);
buildAns(builder, root.left, L, mid, p);
} else {
buildAns(builder, root.left, L, mid, p);
buildAns(builder, root.right, mid + 1, R, p);
}
}
}
int K(Node node) { return node == null ? 0 : node.k; }
class Range {
int L;
Range next;
Range(int L) { this(L, null); }
Range(int L, Range next) {
this.L = L;
this.next = next;
}
}
class Node {
int k = 1;
Node left, right;
Node(int k) { this.k = k; }
}
class InputReader {
BufferedReader reader;
StringTokenizer token;
InputReader(InputStream in) { this.reader = new BufferedReader(new InputStreamReader(in)); }
String read() {
while (token == null || !token.hasMoreTokens()) {
try {
token = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return token.nextToken();
}
int readInt() { return Integer.parseInt(this.read()); }
}
}
#J 括号序列
时间限制: 5.0 5.0 5.0s 内存限制: 512.0 512.0 512.0MB 本题总分: 25 25 25 分
问题描述
给定一个括号序列,要求尽可能少地添加若干括号使得括号序列变得合法,当添加完成后,会产生不同的添加结果,请问有多少种本质不同的添加结果。
两个结果是本质不同的是指存在某个位置一个结果是左括号,而另一个是右括号。
例如,对于括号序列 (((),只需要添加两个括号就能让其合法,有以下几种不同的添加结果:()()()、()(())、(())()、(()()) 和 ((()))。
输入格式
输入一行包含一个字符串 s s s,表示给定的括号序列,序列中只有左括号和右括号。
输出格式
输出一个整数表示答案,答案可能很大,请输出答案除以 1000000007 1000000007 1000000007 (即 1 0 9 + 7 10^{9} + 7 109+7) 的余数。
测试样例1
Input:
((()
Output:
5
评测用例规模与约定
对于
40
40
40% 的评测用例,
∣
s
∣
≤
200
|s| ≤ 200
∣s∣≤200。
对于所有评测用例,
1
≤
∣
s
∣
≤
5000
1 ≤ |s| ≤ 5000
1≤∣s∣≤5000。
动态规划
题目要求尽可能少的添加括号使得括号序列合法,
在既要添加右括号,也要的添加左括号的位置,
只会出现 ) ( \mathrm{)(} )(、 ) ) ( ( \mathrm{))((} ))(( ,而不会出现 ( ) \mathrm{()} () 这种情况。
因为 ( ) \mathrm{()} () 是一次无效添加,有悖我们需要的添加的最优性。
基于上述性质,我们很容易知道,左右括号的添加方案是互不影响的,
因此我们可以分别求出左右括号本质不同的添加结果个数,它们的乘积就是 S S S 的本质不同添加结果个数。
设 f i , j f_{i,j} fi,j 为 S S S 的子串 S [ 1 , i ] S[1,i] S[1,i] 添加 j j j 个右括号的本质不同添加结果个数。
如果末尾字符 S [ i ] S[i] S[i] 为左括号,显然 f i , j = f i − 1 , j − 1 f_{i,j} = f_{i-1,j-1} fi,j=fi−1,j−1,因为在保证合法性的最少添加下,我们仅能在末位添个右括号。
如果末尾字符 S [ i ] S[i] S[i] 为右括号,我们可以简单将本质不同添加结果按在 i i i 处右括号连续的个数分类,
此时 f i , j = ∑ k = 0 j + 1 f i − 1 , k f_{i,j} = \displaystyle\sum_{k=0}^{j+1}f_{i-1,k} fi,j=k=0∑j+1fi−1,k。
但其实到这一步还是不够,因为我们的方程复杂度在 O ( n 3 ) O(n^{3}) O(n3),而题目数据最大在 5000 5000 5000,
过不了,怎么想都过不了。
但将公式简单变形后
f i , j = ∑ k = 0 j f i − 1 , k + f i − 1 , j + 1 = f i , j − 1 + f i − 1 , j + 1 f_{i,j} = \displaystyle\sum_{k=0}^{j}f_{i-1,k} + f_{i-1,j+1}=f_{i,j-1} + f_{i-1,j+1} fi,j=k=0∑jfi−1,k+fi−1,j+1=fi,j−1+fi−1,j+1
就 OJBK 了。
public class Main {
public static void main(String[] args) { new Main().run(); }
int mod = 1000000007;
void run() {
byte[] line = new byte[5555];
try {
int n = System.in.read(line, 1, 5050) - 1;
System.out.println(calc(line, n, false) * calc(line, n, true) % mod);
} catch (java.io.IOException e) {
e.fillInStackTrace();
}
}
long calc(byte[] str, int n, boolean turn) {
if (turn) reverse(str, n);
int[][] dp = new int[n + 1][n + 2];
int opening = 0;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
if (str[i] == '(') {
for (int j = 1; j <= n; j++)
dp[i][j] = dp[i - 1][j - 1];
opening++;
}
else {
dp[i][0] = (dp[i - 1][0] + dp[i - 1][1]) % mod;
for (int j = 1; j <= n; j++)
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j + 1]) % mod;
if (opening > 0) opening--;
}
}
return dp[n][opening];
}
void reverse(byte[] arr, int n) {
for (int i = 1, j = n; i <= j; i++, j--) {
byte temp = (byte)(arr[i] ^ 1);
arr[i] = (byte)(arr[j] ^ 1);
arr[j] = temp;
}
}
}