CSP-J 2022 解题报告
--------------cadifobp0802
T1乘方
题目背景
由于众所周知的原因，官方数据现置于子任务 0，剩余的子任务为民间数据。
题目描述
小文同学刚刚接触了信息学竞赛，有一天她遇到了这样一个题：给定正整数 a a a 和 b b b，求 a b a^b ab 的值是多少。
a b a^b ab 即 b b b 个 a a a 相乘的值，例如 2 3 2^3 23 即为 3 3 3 个 2 2 2 相乘，结果为 2 × 2 × 2 = 8 2 \times 2 \times 2 = 8 2×2×2=8。
“简单！”小文心想，同时很快就写出了一份程序，可是测试时却出现了错误。
小文很快意识到，她的程序里的变量都是 int 类型的。在大多数机器上，int 类型能表示的最大数为
2
31
−
1
2^{31} - 1
231−1，因此只要计算结果超过这个数，她的程序就会出现错误。
由于小文刚刚学会编程，她担心使用 int 计算会出现问题。因此她希望你在
a
b
a^b
ab 的值超过
10
9
{10}^9
109 时，输出一个 -1 进行警示，否则就输出正确的
a
b
a^b
ab 的值。
然而小文还是不知道怎么实现这份程序，因此她想请你帮忙。
输入格式
输入共一行，两个正整数 a , b a, b a,b。
输出格式
输出共一行，如果
a
b
a^b
ab 的值不超过
10
9
{10}^9
109，则输出
a
b
a^b
ab 的值，否则输出 -1。
样例 #1
样例输入 #1
10 9
样例输出 #1
1000000000
样例 #2
样例输入 #2
23333 66666
样例输出 #2
-1
提示
对于
10
%
10 \%
10% 的数据，保证
b
=
1
b = 1
b=1。
对于
30
%
30 \%
30% 的数据，保证
b
≤
2
b \le 2
b≤2。
对于
60
%
60 \%
60% 的数据，保证
b
≤
30
b \le 30
b≤30，
a
b
≤
10
18
a^b \le {10}^{18}
ab≤1018。
对于
100
%
100 \%
100% 的数据，保证
1
≤
a
,
b
≤
10
9
1 \le a, b \le {10}^9
1≤a,b≤109。
我的思路
这道题其实不算太难。当a=1时，无论b为多少答案都为1，容易爆时间，所以需要特殊考虑。而当a=2时，b>=30时就超过了10^9；则当a>=3时只会更小，所以不用担心会爆掉。因为最大不超过10^9,在int范围内，只需要循环到值比10^9大或者爆int为负数时跳出即可。
#include <bits/stdc++.h>
using namespace std;
int a, b, ans = 1;
int main(){
scanf("%d%d", &a, &b);
//特判a=1
if (a == 1)
ans = 1;
else
for (int i = 1; i <= b; ++i) {
ans *= a;
//不合题意跳出
if (ans > 1e9 || ans < 0) {
ans = -1;
break;
}
}
printf("%d\n", ans);
return 0;
}
T2解密
题目背景
由于众所周知的原因，官方数据现置于子任务 0，剩余的子任务为民间数据。
题目描述
给定一个正整数 k k k，有 k k k 次询问，每次给定三个正整数 n i , e i , d i n_i, e_i, d_i ni,ei,di，求两个正整数 p i , q i p_i, q_i pi,qi，使 n i = p i × q i n_i = p_i \times q_i ni=pi×qi、 e i × d i = ( p i − 1 ) ( q i − 1 ) + 1 e_i \times d_i = (p_i - 1)(q_i - 1) + 1 ei×di=(pi−1)(qi−1)+1。
输入格式
第一行一个正整数 k k k，表示有 k k k 次询问。
接下来 k k k 行，第 i i i 行三个正整数 n i , d i , e i n_i, d_i, e_i ni,di,ei。
输出格式
输出 k k k 行，每行两个正整数 p i , q i p_i, q_i pi,qi 表示答案。
为使输出统一，你应当保证 p i ≤ q i p_i \leq q_i pi≤qi。
如果无解，请输出 NO。
样例 #1
样例输入 #1
10
770 77 5
633 1 211
545 1 499
683 3 227
858 3 257
723 37 13
572 26 11
867 17 17
829 3 263
528 4 109
样例输出 #1
2 385
NO
NO
NO
11 78
3 241
2 286
NO
NO
6 88
提示
【样例 #2】
见附件中的 decode/decode2.in 与 decode/decode2.ans。
【样例 #3】
见附件中的 decode/decode3.in 与 decode/decode3.ans。
【样例 #4】
见附件中的 decode/decode4.in 与 decode/decode4.ans。
【数据范围】
以下记 m = n − e × d + 2 m = n - e \times d + 2 m=n−e×d+2。
保证对于
100
%
100\%
100% 的数据，
1
≤
k
≤
10
5
1 \leq k \leq {10}^5
1≤k≤105，对于任意的
1
≤
i
≤
k
1 \leq i \leq k
1≤i≤k，
1
≤
n
i
≤
10
18
1 \leq n_i \leq {10}^{18}
1≤ni≤1018，
1
≤
e
i
×
d
i
≤
10
18
1 \leq e_i \times d_i \leq {10}^{18}
1≤ei×di≤1018
，
1
≤
m
≤
10
9
1 \leq m \leq {10}^9
1≤m≤109。
| 测试点编号 | k ≤ k \leq k≤ | n ≤ n \leq n≤ | m ≤ m \leq m≤ | 特殊性质 |
|---|---|---|---|---|
| 1 1 1 | 1 0 3 10^3 103 | 1 0 3 10^3 103 | 1 0 3 10^3 103 | 保证有解 |
| 2 2 2 | 1 0 3 10^3 103 | 1 0 3 10^3 103 | 1 0 3 10^3 103 | 无 |
| 3 3 3 | 1 0 3 10^3 103 | 1 0 9 10^9 109 | 6 × 1 0 4 6\times 10^4 6×104 | 保证有解 |
| 4 4 4 | 1 0 3 10^3 103 | 1 0 9 10^9 109 | 6 × 1 0 4 6\times 10^4 6×104 | 无 |
| 5 5 5 | 1 0 3 10^3 103 | 1 0 9 10^9 109 | 1 0 9 10^9 109 | 保证有解 |
| 6 6 6 | 1 0 3 10^3 103 | 1 0 9 10^9 109 | 1 0 9 10^9 109 | 无 |
| 7 7 7 | 1 0 5 10^5 105 | 1 0 18 10^{18} 1018 | 1 0 9 10^9 109 | 保证若有解则 p = q p=q p=q |
| 8 8 8 | 1 0 5 10^5 105 | 1 0 18 10^{18} 1018 | 1 0 9 10^9 109 | 保证有解 |
| 9 9 9 | 1 0 5 10^5 105 | 1 0 18 10^{18} 1018 | 1 0 9 10^9 109 | 无 |
| 10 10 10 | 1 0 5 10^5 105 | 1 0 18 10^{18} 1018 | 1 0 9 10^9 109 | 无 |
我的想法(1
我先把题目中的描述化成了以下两个式子：
p
i
+
q
i
=
n
i
−
e
i
×
d
i
+
2
p_i + q_i = n_i - e_i \times d_i + 2
pi+qi=ni−ei×di+2
p
i
×
q
i
=
n
i
p_i \times q_i = n_i
pi×qi=ni,
所以当我们用m记下第一个算式的值，然后依次去遍历
p
i
p_i
pi、
q
i
q_i
qi，如果乘积等于
n
i
n_i
ni，则是有解的；否则输出NO,时间复杂度为O(km/2)，是能拿到一定分的。（代码比赛时打的，已经找不到了）
于是我们就需要找到改进方法。我们知道和相同的两个数差值越小，乘积越大，所以从1到m/2的遍历的结果是一个单调递增的，那么就可以考虑用二分查找。代码如下：
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int k;
ll n, e, d;
void binarysearch(ll l, ll len, ll h, ll q){
ll left = l, right = len;
bool f = false;
while (left <= right){
ll mid = (left + right) >> 1, mip = h - mid;
if (mid * mip > q)
right = mid - 1;
else if (mid * mip < q)
left = mid + 1;
else if (mid * mip == q) {
f = true;
printf("%lld %lld\n", mid, mip);
break;
}
}
if (!f)
printf("NO\n");
}
int main(){
scanf("%d", &k);
for (int i = 1; i <= k; ++i) {
scanf("%lld%lld%lld", &n, &e, &d);
ll m = n - e * d + 2;
if (m <= 0) {
printf("NO\n");
continue;
}
ll z = (ll)sqrt(n) + 1;
binarysearch(1, z, m, n);
}
return 0;
}
我的想法(2
依据想法1推出来的式子很容易想到韦达定理，所以可以转化为一元二次方程，用求根公式求出结果。代码只有一层循环，如下：
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll k, n, e, d;
ll solve(ll b){
ll delta = b * b - 4 * n;
//判断有无实数根
if(delta < 0)
return -1;
//由于根可能不是整数，所以需要判断
ll sqde = sqrt(delta);
if (sqde * sqde != delta)
return -1;
if ((b - sqde) % 2)
return -1;
return (b - sqde) / 2;
}
int main(){
scanf("%lld", &k);
for (int i = 1; i <= k; ++i){
scanf("%lld%lld%lld", &n, &e, &d);
ll ca = n - e * d + 2;
//解方程
ll ans = solve(ca);
if (ans == -1)
printf("NO\n");
else
printf("%lld %lld\n", ans, n / ans);
}
return 0;
}
T3逻辑表达式
题目背景
由于众所周知的原因，官方数据现置于子任务 0，剩余的子任务为民间数据。
由于本题情况多样，上传了两个 Subtask 对应两份不同的民间数据。Subtask 0 中强度较低，Subtask 1 中强度较高。分数是计算两个 Subtask 中最低分。
upd 2022.10.29 21:41 \text{upd 2022.10.29 21:41} upd 2022.10.29 21:41：Subtask 1 已重新加强。
题目描述
逻辑表达式是计算机科学中的重要概念和工具，包含逻辑值、逻辑运算、逻辑运算优先级等内容。
在一个逻辑表达式中，元素的值只有两种可能：
0
0
0（表示假）和
1
1
1（表示真）。元素之间有多种可能的逻辑运算，本题中只需考虑如下两种：“与”（符号为 &）和“或”（符号为 |）。其运算规则如下：
0
&
0
=
0
&
1
=
1
&
0
=
0
0 \mathbin{\&} 0 = 0 \mathbin{\&} 1 = 1 \mathbin{\&} 0 = 0
0&0=0&1=1&0=0，
1
&
1
=
1
1 \mathbin{\&} 1 = 1
1&1=1；
0
∣
0
=
0
0 \mathbin{|} 0 = 0
0∣0=0，
0
∣
1
=
1
∣
0
=
1
∣
1
=
1
0 \mathbin{|} 1 = 1 \mathbin{|} 0 = 1 \mathbin{|} 1 = 1
0∣1=1∣0=1∣1=1。
在一个逻辑表达式中还可能有括号。规定在运算时，括号内的部分先运算；两种运算并列时，& 运算优先于 | 运算；同种运算并列时，从左向右运算。
比如，表达式 0|1&0 的运算顺序等同于 0|(1&0)；表达式 0&1&0|1 的运算顺序等同于 ((0&1)&0)|1。
此外，在 C++ 等语言的有些编译器中，对逻辑表达式的计算会采用一种“短路”的策略：在形如 a&b 的逻辑表达式中，会先计算 a 部分的值，如果
a
=
0
a = 0
a=0，那么整个逻辑表达式的值就一定为
0
0
0，故无需再计算 b 部分的值；同理，在形如 a|b 的逻辑表达式中，会先计算 a 部分的值，如果
a
=
1
a = 1
a=1，那么整个逻辑表达式的值就一定为
1
1
1，无需再计算 b 部分的值。
现在给你一个逻辑表达式，你需要计算出它的值，并且统计出在计算过程中，两种类型的“短路”各出现了多少次。需要注意的是，如果某处“短路”包含在更外层被“短路”的部分内则不被统计，如表达式 1|(0&1) 中，尽管 0&1 是一处“短路”，但由于外层的 1|(0&1) 本身就是一处“短路”，无需再计算 0&1 部分的值，因此不应当把这里的 0&1 计入一处“短路”。
输入格式
输入共一行，一个非空字符串 s s s 表示待计算的逻辑表达式。
输出格式
输出共两行，第一行输出一个字符 0 或 1，表示这个逻辑表达式的值；第二行输出两个非负整数，分别表示计算上述逻辑表达式的过程中，形如 a&b 和 a|b 的“短路”各出现了多少次。
样例 #1
样例输入 #1
0&(1|0)|(1|1|1&0)
样例输出 #1
1
1 2
样例 #2
样例输入 #2
(0|1&0|1|1|(1|1))&(0&1&(1|0)|0|1|0)&0
样例输出 #2
0
2 3
提示
【样例解释 #1】
该逻辑表达式的计算过程如下，每一行的注释表示上一行计算的过程：
0&(1|0)|(1|1|1&0)
=(0&(1|0))|((1|1)|(1&0)) //用括号标明计算顺序
=0|((1|1)|(1&0)) //先计算最左侧的 &，是一次形如 a&b 的“短路”
=0|(1|(1&0)) //再计算中间的 |，是一次形如 a|b 的“短路”
=0|1 //再计算中间的 |，是一次形如 a|b 的“短路”
=1
【样例 #3】
见附件中的 expr/expr3.in 与 expr/expr3.ans。
【样例 #4】
见附件中的 expr/expr4.in 与 expr/expr4.ans。
【数据范围】
设 ∣ s ∣ \lvert s \rvert ∣s∣ 为字符串 s s s 的长度。
对于所有数据，
1
≤
∣
s
∣
≤
10
6
1 \le \lvert s \rvert \le {10}^6
1≤∣s∣≤106。保证
s
s
s 中仅含有字符 0、1、&、|、(、) 且是一个符合规范的逻辑表达式。保证输入字符串的开头、中间和结尾均无额外的空格。保证
s
s
s
中没有重复的括号嵌套（即没有形如 ((a)) 形式的子串，其中 a 是符合规范的逻辑表
达式）。
| 测试点编号 | ∣ s ∣ ≤ \lvert s \rvert \le ∣s∣≤ | 特殊条件 |
|---|---|---|
| 1 ∼ 2 1 \sim 2 1∼2 | 3 3 3 | 无 |
| 3 ∼ 4 3 \sim 4 3∼4 | 5 5 5 | 无 |
| 5 5 5 | 2000 2000 2000 | 1 |
| 6 6 6 | 2000 2000 2000 | 2 |
| 7 7 7 | 2000 2000 2000 | 3 |
| 8 ∼ 10 8 \sim 10 8∼10 | 2000 2000 2000 | 无 |
| 11 ∼ 12 11 \sim 12 11∼12 | 10 6 {10}^6 106 | 1 |
| 13 ∼ 14 13 \sim 14 13∼14 | 10 6 {10}^6 106 | 2 |
| 15 ∼ 17 15 \sim 17 15∼17 | 10 6 {10}^6 106 | 3 |
| 18 ∼ 20 18 \sim 20 18∼20 | 10 6 {10}^6 106 | 无 |
其中：
特殊性质 1 为：保证
s
s
s 中没有字符 &。
特殊性质 2 为：保证
s
s
s 中没有字符 |。
特殊性质 3 为：保证
s
s
s 中没有字符 ( 和 )。
【提示】
以下给出一个“符合规范的逻辑表达式”的形式化定义：
- 字符串
0和1是符合规范的； - 如果字符串
s是符合规范的，且s不是形如(t)的字符串（其中t是符合规范的），那么字符串(s)也是符合规范的； - 如果字符串
a和b均是符合规范的，那么字符串a&b、a|b均是符合规范的； - 所有符合规范的逻辑表达式均可由以上方法生成。
我的想法(1
这道题我们可以看到字符串长度为3时可以得到十分，于是骗分的邪念冒了出来。直接硬核枚举骗十分。当然长度为5时也可以枚举，这里我只打了前面十分：
#include <bits/stdc++.h>
using namespace std;
string str;
int main(){
getline (cin, str);
int len = str.size();
if (len == 3) {
if (str == "1&0")
printf("%d\n%d %d\n", 0, 0, 0);
else if (str == "1&1")
printf("%d\n%d %d\n", 1, 0, 0);
else if (str == "0&1")
printf("%d\n%d %d\n", 0, 1, 0);
else if (str == "0&0")
printf("%d\n%d %d\n", 0, 1, 0);
else if (str == "1|0")
printf("%d\n%d %d\n", 1, 0, 1);
else if (str == "1|1")
printf("%d\n%d %d\n", 1, 0, 1);
else if (str == "0|1")
printf("%d\n%d %d\n", 1, 0, 0);
else if (str == "0|0")
printf("%d\n%d %d\n", 0, 0, 0);
}
else
printf("%d\n%d %d\n", 0, 0, 0);
return 0;
}
我的想法(2
这道题所出现的符号优先级为括号>与>或。所以我们可以逐一对其进行操作。括号我们可以在读入的时候匹配好，这样就提前划分为一块一块的，计算到时单独拎出来算。由于同等计算从左往右进行，所以我们可以以最低级的或符号把字符串划分为一个个的区间，每个区间内只有括号（递归完成）和与运算，这样就清晰多了。代码如下（100分）：
#include <bits/stdc++.h>
using namespace std;
#define MAXN 1000010
struct nod {
//v:当前是或非 ym:当前与的短路统计 hm:当前或的短路统计
int v, ym, hm;
nod(int _v, int _ym, int _hm): v(_v), ym(_ym), hm(_hm){}
};
string s;
//vh数组记录每个括号的结束位置
int vh[MAXN];
void readp() {
cin >> s;
stack<int>ojn;
//遍历记录下每个括号的结束位置
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '(')
ojn.push(i);
else if (s[i] == ')') {
vh[ojn.top()] = i;
ojn.pop();
}
}
}
void dat(nod &a, nod b, char op) {
//在区间内进行计算与数据传递tmp->anp
if (op == '&')
a = nod(a.v && b.v, a.ym + b.ym, a.hm + b.hm);
//当一个区间结束是进行计算与数据传递anp->ang
else
a = nod(a.v || b.v, a.ym + b.ym, a.hm + b.hm);
}
nod dfs(int l, int r) {
//防止开始最外层套括号
if (s[l] == '(' && vh[l] == r)
dfs(l + 1, r - 1);
//ang:整个字符串的结果 anp:每个字符串区间的结果 tmp:当前参数
nod ang = nod(false, 0, 0), anp = nod(true, 0, 0), tmp = nod(true, 0, 0);
for (int i = l; i <= r; ++i) {
//记录当前参数
if (s[i] == '0' || s[i] == '1')
tmp = nod(s[i] - '0', 0, 0);
//遇到括号递归求解
else if (s[i] == '(') {
tmp = dfs(i + 1, vh[i] - 1);
i = vh[i];
}
//以'|'划分区间，计算每个区间内的值最后汇总
else if (s[i] == '|') {
//区间最后一次计算
if (anp.v)
dat(anp, tmp, '&');
else
anp.ym++;
//把区间结果并到整个字符串结果上
if (!ang.v)
dat(ang, anp, '|');
else
ang.hm++;
//进入下一个区间
anp = nod(true, 0, 0);
}
//区间内只会有与运算
else if (anp.v)
dat(anp, tmp, '&');
else
anp.ym++;
}
//最后一个区间的最后一个参数(没有'|'分隔得单独考虑)
if (anp.v)
dat(anp, tmp, '&');
else
anp.ym++;
//得出最终的解
if (!ang.v)
dat(ang, anp, '|');
else
ang.hm++;
//传回参数
return ang;
}
int main(){
readp();
nod cfaw = dfs(0, s.size() - 1);
//输出
printf("%d\n%d %d\n", cfaw.v, cfaw.ym, cfaw.hm);
return 0;
}
T4上升点列
题目背景
由于众所周知的原因，官方数据现置于子任务 0，剩余的子任务为民间数据。
题目描述
在一个二维平面内，给定 n n n 个整数点 ( x i , y i ) (x_i, y_i) (xi,yi)，此外你还可以自由添加 k k k 个整数点。
你在自由添加 k k k 个点后，还需要从 n + k n + k n+k 个点中选出若干个整数点并组成一个序列，使得序列中任意相邻两点间的欧几里得距离恰好为 1 1 1 而且横坐标、纵坐标值均单调不减，即 x i + 1 − x i = 1 , y i + 1 = y i x_{i+1} - x_i = 1, y_{i+1} = y_i xi+1−xi=1,yi+1=yi 或 y i + 1 − y i = 1 , x i + 1 = x i y_{i+1} - y_i = 1, x_{i+1} = x_i yi+1−yi=1,xi+1=xi。请给出满足条件的序列的最大长度。
输入格式
第一行两个正整数 n , k n, k n,k 分别表示给定的整点个数、可自由添加的整点个数。
接下来 n n n 行，第 i i i 行两个正整数 x i , y i x_i, y_i xi,yi 表示给定的第 i i i 个点的横纵坐标。
输出格式
输出一个整数表示满足要求的序列的最大长度。
样例 #1
样例输入 #1
8 2
3 1
3 2
3 3
3 6
1 2
2 2
5 5
5 3
样例输出 #1
8
样例 #2
样例输入 #2
4 100
10 10
15 25
20 20
30 30
样例输出 #2
103
提示
【样例 #3】
见附件中的 point/point3.in 与 point/point3.ans。
第三个样例满足 k = 0 k = 0 k=0。
【样例 #4】
见附件中的 point/point4.in 与 point/point4.ans。
【数据范围】
保证对于所有数据满足： 1 ≤ n ≤ 500 1 \leq n \leq 500 1≤n≤500， 0 ≤ k ≤ 100 0 \leq k \leq 100 0≤k≤100。对于所有给定的整点，其横纵坐标 1 ≤ x i , y i ≤ 10 9 1 \leq x_i, y_i \leq {10}^9 1≤xi,yi≤109，且保证所有给定的点互不重合。对于自由添加的整点，其横纵坐标不受限制。
| 测试点编号 | n ≤ n \leq n≤ | k ≤ k \leq k≤ | x i , y i ≤ x_i,y_i \leq xi,yi≤ |
|---|---|---|---|
| 1 ∼ 2 1 \sim 2 1∼2 | 10 10 10 | 0 0 0 | 10 10 10 |
| 3 ∼ 4 3 \sim 4 3∼4 | 10 10 10 | 100 100 100 | 100 100 100 |
| 5 ∼ 7 5 \sim 7 5∼7 | 500 500 500 | 0 0 0 | 100 100 100 |
| 8 ∼ 10 8 \sim 10 8∼10 | 500 500 500 | 0 0 0 | 10 9 {10}^9 109 |
| 11 ∼ 15 11 \sim 15 11∼15 | 500 500 500 | 100 100 100 | 100 100 100 |
| 16 ∼ 20 16 \sim 20 16∼20 | 500 500 500 | 100 100 100 | 10 9 {10}^9 109 |
我的想法(1
这道题我在比赛时只打出了普通的搜索，还存在一些问题。这里就不多的赘述。要注意的是每次路径只有x轴或y轴增加1两种选择。代码如下（25分）：
#include <bits/stdc++.h>
using namespace std;
#define MAXN 10010
const int dx[] = {1, 0};
const int dy[] = {0, 1};
int g[MAXN][MAXN], x[MAXN], y[MAXN], n, k, ans = 0;
void readp() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x[i], &y[i]);
g[x[i]][y[i]] = 1;
}
}
void dfs(int xx, int yy, int s, int wy) {
if (wy == k && (g[xx + 1][yy] == 0) && (g[xx][yy + 1] == 0)) {
ans = max(ans, s);
return;
}
for (int i = 0; i <= 1; ++i) {
int h = xx + dx[i], l = yy + dy[i];
if (g[h][l])
dfs(h, l, s + 1, wy);
else if (g[h][l] == 0 && wy < k)
dfs(h, l, s + 1, wy + 1);
}
}
int main(){
readp();
for (int i = 1; i <= n; ++i) {
dfs(x[i], y[i], 1, 0);
}
printf("%d\n", ans);
return 0;
}
我的想法(2
这道题存在一个有趣的性质，就是每到一个点，那么这个点就只能往x轴和y轴中至少一个大于该点坐标的坐标走，所以搜索可以每次遍历他能够到达的点，并且放置点走，这样会简单许多。那么每次走到一个点，放置的点数相同，接下来的选择是相同的，就可以用数组记录下当前情况，对搜索进行剪枝。
本以为写不到满分，结果最后数据过了,真水 :
#include <bits/stdc++.h>
using namespace std;
#define MAXN 510
int x[MAXN], y[MAXN], n, k, ans = 0, dp[MAXN][MAXN];
void readp() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}
memset(dp, -1, sizeof(dp));
}
void dfs(int pos, int cnt, int wy) {
//剪枝
if (cnt <= dp[pos][wy])
return;
else
dp[pos][wy] = cnt;
//记录当前最大值
if (cnt + k > ans) {
ans = cnt + k;
}
//遍历所以可能到达的点
for (int i = 1; i <= n; ++i) {
//计算到达该点需放置的点数
int cd = x[i] - x[pos] + y[i] - y[pos] - 1;
if (i != pos && x[i] >= x[pos] && y[i] >= y[pos] && cd <= wy) {
dfs(i, cnt + 1, wy - cd);
}
}
}
int main(){
readp();
for (int i = 1; i <= n; ++i) {
dfs(i, 1, k);
}
printf("%d\n", ans);
return 0;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
