本文回顾了NOIP2018原创模拟赛的三道题目，包括小凯的数字、密室和PION贪吃蛇，详细解析了每道题目的背景、描述、输入输出格式、样例及数据范围，分享了作者的比赛心得和解题思路。
比赛传送门
题解传送门
自
测
时
间
：
2018.9.23
用
时
：
2
小
时
14
分
40
秒
得
分
：
100
+
100
+
60
=
260
自测时间：2018.9.23\quad用时：2小时14分40秒\quad得分：100+100+60=260
自测时间：2018.9.23用时：2小时14分40秒得分：100+100+60=260
T1 U32670 小凯的数字
题目背景
NOIP2018 原创模拟题T1
NOIP DAY1 T1 or DAY 2 T1 难度
是否发现与NOIP2017 DAY1 T1 有异曲同工之妙
说明：#10,bug已修复
题目描述
小凯有一天突发奇想，写下了一串数字：
l
(
l
+
1
)
(
l
+
2
)
.
.
.
(
r
−
1
)
r
l
(
l
+
1
)
(
l
+
2
)
.
.
.
(
r
−
1
)
r
l(l+1)(l+2)...(r-1)rl(l+1)(l+2)...(r−1)r
l(l+1)(l+2)...(r−1)rl(l+1)(l+2)...(r−1)r
例如：
l
=
2
,
r
=
5
l=2,r=5
l=2,r=5时，数字为：
2345
2345
2345
l
=
8
,
r
=
12
l=8,r=12
l=8,r=12时数字为：
89101112
89101112
89101112
小凯很喜欢数字9，所以他想问你他写下的数字除以9的余数是多少
例如： l = 2 , r = 5 l=2,r=5 l=2,r=5时， 2345 m o d    9 = 5 2345 \mod 9 = 5 2345mod9=5
输入输出格式
输入格式：
第一行为数字 Q Q Q,表示小凯有 Q Q Q个问题
第 2 , ⋯   , Q + 1 2,\cdots,Q+1 2,⋯,Q+1行，每行两个数字 l,r 表示数字范围
输出格式：
对于每行的问题输出一行，一个数字，表示小凯问题的回答
输入输出样例
输入样例#1：
2
2 5
8 12
输出样例#1：
5
5
输入样例#2：
3
1 999
123 456
13579 24680
输出样例#2：
0
6
0
说明
样例1解释： 2345 m o d    9 = 5 2345 \mod 9 = 5 2345mod9=5 89101112 m o d    9 = 5 89101112 \mod 9 = 5 89101112mod9=5
30
%
30\%
30% 数据满足：
Q
≤
10
;
l
,
r
≤
100
Q\le 10;l,r\le100
Q≤10;l,r≤100
50
%
50\%
50% 数据满足：
Q
≤
100
;
l
,
r
≤
10000
Q\le100;l,r\le10000
Q≤100;l,r≤10000
70
%
70\%
70% 数据满足：
Q
≤
1000
;
l
,
r
≤
1
0
6
Q\le1000;l,r\le10^6
Q≤1000;l,r≤106
100
%
100\%
100%数据满足：
Q
≤
10000
;
l
,
0
<
r
≤
1
0
12
Q
≤
10000
;
且
l
≤
r
Q\le10000;l,0<r\le10^{12}Q\le10000;且 l\le r
Q≤10000;l,0<r≤1012Q≤10000;且l≤r
我的方法和题解的不一样。
记这个自然数为
l
(
l
+
1
)
(
l
+
2
)
⋯
(
r
−
1
)
r
‾
\overline{l(l+1)(l+2)\cdots(r-1)r}
l(l+1)(l+2)⋯(r−1)r。
显然答案可以变形为
(
l
×
1
0
r
−
l
m
o
d
  
9
+
(
l
+
1
)
(
l
+
2
)
⋯
(
r
−
1
)
(
r
)
‾
m
o
d
  
9
)
m
o
d
  
9
(l\times 10^{r-l}\mod 9+\overline{(l+1)(l+2)\cdots(r-1)(r)}\mod 9)\mod 9
(l×10r−lmod9+(l+1)(l+2)⋯(r−1)(r)mod9)mod9
而
l
×
1
0
r
−
l
m
o
d
  
9
=
(
l
m
o
d
  
9
)
×
(
1
0
r
−
l
m
o
d
  
9
)
m
o
d
  
9
l\times 10^{r-l}\mod 9=(l\mod9)\times(10^{r-l}\mod9)\mod9
l×10r−lmod9=(lmod9)×(10r−lmod9)mod9
而
1
0
r
−
l
m
o
d
  
9
=
1
10^{r-l}\mod9=1
10r−lmod9=1，即原式
=
l
m
o
d
  
9
=l\mod9
=lmod9
以此类推，答案可以写做
∑
i
=
l
r
i
m
o
d
  
9
\sum_{i=l}^ri\mod9
∑i=lrimod9
题解到此处就套用求和公式得解，详见NOIP2018原创模拟赛DAY1题解，而我比赛时尝试前缀和思想求解（其实是没反应过来有个求和公式来着）。
显然，
∑
i
=
1
9
i
m
o
d
  
9
=
0
\sum_{i=1}^9i\mod9=0
∑i=19imod9=0，可将答案变形为
(
s
u
m
[
r
m
o
d
  
9
]
−
s
u
m
[
(
l
−
1
+
9
)
m
o
d
  
9
]
+
9
)
m
o
d
  
9
\Big(sum[r\mod9]-sum[(l-1+9)\mod9]+9\Big)\mod9
(sum[rmod9]−sum[(l−1+9)mod9]+9)mod9，其中
s
u
m
sum
sum为0~8的前缀和。
绕了一圈此题得解，妈妈再也不用担心我爆
l
o
n
g
l
o
n
g
long long
longlong了。
#include<cstdio>
typedef long long ll;
int q,sum[9];
ll l,r;
int main()
{
//freopen("in.txt","r",stdin);
scanf("%d",&q);
for(int i=1;i<9;i++)sum[i]=(sum[i-1]+i)%9;
while(q--)
{
scanf("%lld%lld",&l,&r);
printf("%d\n",(sum[r%9]-sum[(l%9-1+9)%9]+9)%9);
}
return 0;
}
总结
此题作为T1，确实是送分的，参加比赛的人大多拿满了，没啥可说的。
T2 U38181 密室
题目背景
NOIP2018 原创模拟题 T2
NOIP DAY1 T2 or DAY2 T2 难度
题目背景改编自小说《哈利波特与密室》。
说明：#4，bug经修复，感谢：@唐子川
题目描述
密室被打开了。
哈利与罗恩进入了密室，他们发现密室由n个小室组成，所有小室编号分别为：1,2,…,n。所有小室之间有m条通道，对任意两个不同小室最多只有一条通道连接，而每通过一条通道都需要Ci 的时间。
开始时哈利与罗恩都在编号为1的小室里，他们的目标是拯救金妮和寻找日记，但是他们发现金妮和日记可能在两个不同的小室里，为了尽快发现真相，他们决定以最少的时间到达两个目标小室。但是某些小室只有会与蛇对话的人才能进入，也就是只有哈利一个人可以进入。
现在，哈利告诉你密室的结构，请你计算他们到达两个目标小室的最短时间。
输入输出格式
输入格式：
第一行 n , m , k n,m,k n,m,k 表示有 n n n个小室 m m m条通道， k k k间小室只有哈利可以进入。
第二行 k k k 个数，表示只有哈利可以进入的小室的编号。（若 k = 0 k=0 k=0，不包含该行）
接下来 m m m行，每行 3 3 3个数： a , b , c a,b,c a,b,c 表示 a a a小室与 b b b小室之间有一条需要花费 c c c时间的通道。
最后一行，两个数 x , y x,y x,y 表示哈利与罗恩需要去的小室的编号
输出格式：
一行，输出一个数，表示到达两个密室的最短时间。
输入输出样例
输入样例#1：
6 8 1
5
1 2 3
2 3 2
1 3 4
3 4 1
4 6 5
5 6 2
1 6 6
1 5 3
4 6
输出样例#1：
5
输入样例#2：
10 13 3
3 4 10
1 2 1
2 3 2
3 4 3
4 5 4
5 6 5
6 7 10
7 8 5
8 9 10
9 10 3
10 1 2
1 9 6
3 8 10
4 6 3
6 8
输出样例#2：
16
说明
样例解释：
样例一：
哈利： 1 → 5 → 6 1\to5\to6 1→5→6 花费时间为 5 5 5
罗恩： 1 → 3 → 4 1\to3\to4 1→3→4 花费时间为 5 5 5
所以最短时间为 5 5 5
样例二：
如图，橙色表示目标小室，绿色只有哈利可以通过
哈利： 1 → 2 → 3 → 4 → 6 1\to2\to3\to4\to6 1→2→3→4→6 花费时间为 9 9 9
罗恩： 1 → 9 → 8 1\to9\to8 1→9→8 花费时间为 16 16 16
所以最短时间为 16 16 16
数据范围：
10 % 10\% 10% 数据满足： n ≤ 5 n\le5 n≤5
30 % 30\% 30% 数据满足： n ≤ 20 n\le20 n≤20
50 % 50\% 50% 数据满足： n ≤ 1000 n\le1000 n≤1000
70 % 70\% 70% 数据满足： n ≤ 10000 n\le10000 n≤10000
100 % 100\% 100%数据满足： n ≤ 50000 a , b , k ≤ n c ≤ 1000 m ≤ 100000 n\le50000 \quad a,b,k\le n \quad c\le1000 \quad m\le100000 n≤50000a,b,k≤nc≤1000m≤100000，保证罗恩可以在密室 1 1 1
特殊约定：
30 % 30\% 30%数据满足： k = 0 k=0 k=0
建立一张完整的图和一张残图，分别跑两遍dijkstra，求出哈利到
x
,
y
x,y
x,y的最短路
d
i
s
[
1
]
[
x
]
,
d
i
s
[
1
]
[
y
]
dis[1][x],dis[1][y]
dis[1][x],dis[1][y]以及罗恩到
x
,
y
x,y
x,y的最短路
d
i
s
[
2
]
[
x
]
,
d
i
s
[
2
]
[
y
]
dis[2][x],dis[2][y]
dis[2][x],dis[2][y]。然后在全图上以
x
x
x为起点跑一遍dijkstra，求出到y的最短路d[y]。
所求即为：
min
(
max
(
d
i
s
[
1
]
[
x
]
,
d
i
s
[
2
]
[
y
]
)
,
max
(
d
i
s
[
2
]
[
x
]
,
d
i
s
[
1
]
[
y
]
)
,
m
i
n
(
d
i
s
[
1
]
[
x
]
,
d
i
s
[
1
]
[
y
]
)
+
d
[
y
]
)
\min\Big(\max(dis[1][x],dis[2][y]),\max(dis[2][x],dis[1][y]),min(dis[1][x],dis[1][y])+d[y]\Big)
min(max(dis[1][x],dis[2][y]),max(dis[2][x],dis[1][y]),min(dis[1][x],dis[1][y])+d[y])
时间复杂度
O
(
算
不
来
)
O(算不来)
O(算不来)
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=5e4+10;
const int M=1e5+10;
const int INF=2e9;
int n,m,k,hd[3][N],tot[3],dis[3][N],x,y,d[N],vis[N];
bool ban[N];
struct Edge{
int v,w,nx;
}e[3][M<<1];
struct Node{
int to,w;
Node(){}
Node(int _to,int _w):to(_to),w(_w){}
bool operator <(const Node&rhs)const{
return w>rhs.w;}
};
void add(int id,int u,int v,int w)
{
e[id][tot[id]].v=v;
e[id][tot[id]].w=w;
e[id][tot[id]].nx=hd[id][u];
hd[id][u]=tot[id]++;
}
void dijkstra(int id)
{
fill(dis[id],dis[id]+N,INF);
memset(vis,0,sizeof(vis));
priority_queue<Node>q;while(q.size())q.pop();
q.push(Node(1,0));dis[id][1]=0;
while(q.size())
{
Node tmp=q.top();q.pop();
int u=tmp.to;
vis[u]=1;
for(int i=hd[id][u];~i;i=e[id][i].nx)
{
int v=e[id][i].v,w=e[id][i].w;
if(dis[id][v]>dis[id][u]+w)
{
dis[id][v]=dis[id][u]+w;
if(!vis[v])q.push(Node(v,dis[id][v]));
}
}
}
}
void Dijkstra()
{
fill(d,d+N,INF);
memset(vis,0,sizeof(vis));
priority_queue<Node>q;while(q.size())q.pop();
q.push(Node(x,0)),d[x]=0;
while(q.size())
{
Node tmp=q.top();q.pop();
int u=tmp.to;vis[u]=1;
for(int i=hd[1][u];~i;i=e[1][i].nx)
{
int v=e[1][i].v,w=e[1][i].w;
if(d[v]>d[u]+w)
{
d[v]=d[u]+w;
if(!vis[v])q.push(Node(v,d[v]));
}
}
}
}
int main()
{
//freopen("in.txt","r",stdin);
memset(hd,-1,sizeof(hd));
scanf("%d%d%d",&n,&m,&k);
int u,v,w;
for(int i=1;i<=k;i++)scanf("%d",&u),ban[u]=true;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&u,&v,&w);
add(1,u,v,w);add(1,v,u,w);
if(ban[u]||ban[v])continue;
add(2,u,v,w);add(2,v,u,w);
}
scanf("%d%d",&x,&y);
dijkstra(1);dijkstra(2);
int ans=min(max(dis[1][x],dis[2][y]),max(dis[2][x],dis[1][y]));
Dijkstra();
ans=min(ans,min(dis[1][x],dis[1][y])+d[y]);
printf("%d\n",ans);
return 0;
}
总结
实际还是一个最短路问题，建不建两个图都无所谓（题解就没有建双份），然后就是一个分类讨论，很简单，对比NOIP2017DAY1T2……
T3 U38098 PION贪吃蛇
题目背景
NOIP2018原创模拟题 T3
NOIP DAY1 T3 or DAY 2 T2 难度
贪吃蛇大家都玩过吧，当然不同版本有不同规则。下面介绍PION贪吃蛇。
注意：测试点#4,#5错误已修改，感谢：@EnTaroTassadar,@天道
题目描述
表示方法：
该题中贪吃蛇存在于一个
n
n
n 行
m
m
m 列的矩形中，用 ‘.’ 表示空地，用 '#’ 表示蛇身，用 ‘@’表示蛇头，用‘&’表示食物 例如：图一表示
5
∗
6
5*6
5∗6 的矩形，有一条蛇，蛇长度为
7
7
7，有两个食物
基本规则：
1.蛇头每一秒就会移动一格，身体自然会跟着移动，用W表示向上，S表示向下，A表示向左，D表示向右
2.蛇每吃一个食物就长度就会加一，而增加的长度体现在食物所在的地方，你可以把吃食物理解成食物变成了蛇头，之前的蛇头变成了蛇身，这一秒不移动
例如：图二的三幅图展示了第一秒，第二秒，和第三秒的情况
3.蛇如果死亡，身体（包括头）一定会全部变成食物
4.PION贪吃蛇的蛇头碰到自己或别的蛇的身体就会死亡
例如：图三的三幅图展示了第二条蛇撞在别人身体上死亡的过程
5.蛇头撞在边界上也会引起死亡，但蛇头刚好现在边界上不会
例如：图四第二幅图虽然蛇头在边界上，但是只是刚好，如果此时进行D操作蛇就会死亡，如果进行W或S就不会
6.如果有操作使蛇头向相反方向运动，之后如果与身体重合蛇也会死亡（比如：图二第一幅图使用A操作,蛇就会死亡，此时在原地成为三个食物，你也可以理解为蛇下一秒不行动而自杀了）
7.两条蛇蛇头相撞，主动撞上的死亡
8.蛇的移动按编号由小到大进行（编号的含义见下文）
输入输出格式
输入格式：
第一行两个数 n , m , k n,m,k n,m,k 表示 n ∗ m n*m n∗m 的矩形， k k k 表示操作次数
接下来 n n n 行每行 m m m 个字符，表示地图
再接下来 c c c 行（注意：图中有几条蛇就有几行），每行 k k k 个字符，表示有 k k k 个操作（如果执行了某个操作蛇死了，就忽略后面的操作）
我们将蛇编号：按每条蛇蛇头的坐标从小到大编号为 1 , 2 , ⋯   , c 1,2,\cdots,c 1,2,⋯,c（越靠近上边的坐标越小，如果相同越靠近左边的坐标越小）
例如：图三第一幅图两条蛇的蛇头坐标分别为 ( 4 , 3 ) (4,3) (4,3)， ( 3 , 7 ) (3,7) (3,7) 所以较长的蛇编号为 2 2 2，较短的蛇编号为 1 1 1
输出格式：
c + 1 c+1 c+1 行，输出 k k k 次操作后每一条蛇的长度，编号；每一行第一个为长度，第二个数为编号
最后一行输出剩下食物的总个数
注意：输出按长度由大到小排序（长度相同按编号由小到大排序），死亡的蛇长度为 0 0 0
输入输出样例
输入样例#1：
5 7 6
.&…&.
…##@…
.&…&.
…##@…
.&…&.
DWAAAA
WDDDDD
输出样例#1：
5 1
0 2
7
输入样例#2：
9 9 4
…
.#######.
…#.
.@#.&@.#.
&.#.&&.#.
&&######.
.&…
…@####…
…
ASSD
ASDD
WASD
输出样例#2：
22 1
4 2
0 3
6
说明
样例说明：
图五，图六展示了从第0秒开始之后每一秒地图的状态，请看图理解（样例二图四有点小错误）
数据范围：
10 % 10\% 10% 数据满足 n , m ≤ 5 , c = 1 , k ≤ 3 n,m\leq5,c=1,k\leq3 n,m≤5,c=1,k≤3
30 % 30\% 30% 数据满足 n , m ≤ 10 , c ≤ 2 , k ≤ 5 n,m\leq10,c\leq2,k\leq5 n,m≤10,c≤2,k≤5
50 % 50\% 50% 数据满足 n , m ≤ 50 , c ≤ 5 , k ≤ 20 n,m\leq50,c\leq5,k\leq20 n,m≤50,c≤5,k≤20
70 % 70\% 70% 数据满足 n , m ≤ 100 , c ≤ 7 , k ≤ 50 n,m\leq100,c\leq7,k\leq50 n,m≤100,c≤7,k≤50
100 % 100\% 100% 数据满足， n , m ≤ 200 , c ≤ 20 , k ≤ 100 n,m\leq200,c\leq20,k\leq100 n,m≤200,c≤20,k≤100，且图中的蛇不会引起混淆
输入保证图中没有蛇会像这样难以判断：
.#.
##@
#.#
@##
其实就是按照题目要求进行模拟。当时写了份代码只有60分。
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
char s[2100];
int n,m,k,flag,c,num,nxtx[]={1,-1,0,0},nxty[]={0,0,1,-1},vis[100100],cnt,idx[2100][2100];
struct node{
int x,y,kind;
}p[100100];
struct Snake{
int len,id;
deque<int>dq;
bool operator<(const Snake&rhs)const{
return len>rhs.len||(len==rhs.len&&id<rhs.id);}
}snake[500];
void bfs(int pos)
{
queue<int>q;while(q.size())q.pop();
snake[c].len=1;snake[c].id=c;q.push(pos);vis[pos]=1;snake[c].dq.push_back(pos);p[pos].kind=2;
while(q.size())
{
int tmp=q.front();q.pop();
int x=p[tmp].x,y=p[tmp].y;
for(int i=0;i<4;i++)
{
int nx=x+nxtx[i],ny=y+nxty[i];
if(nx>=1&&nx<=n&&ny>=1&&ny<=m&&!vis[idx[nx][ny]]&&p[idx[nx][ny]].kind==2)
{
q.push(idx[nx][ny]);vis[idx[nx][ny]]=1;snake[c].len++;snake[c].dq.push_back(idx[nx][ny]);
}
}
}
}
void des(int id)
{
while(snake[id].dq.size())
{
int pos=snake[id].dq.front();snake[id].dq.pop_front();
p[pos].kind=3;cnt++;
}
snake[id].len=0;
}
int work(int id,int nx)
{
int pos=snake[id].dq.front();
int x=p[pos].x+nxtx[nx],y=p[pos].y+nxty[nx];
if(x<0||x>n||y<0||y>m)
{
des(id);return 0;
}
if(p[idx[x][y]].kind==2)
{
des(id);return 0;
}
if(p[idx[x][y]].kind==3)
{
p[idx[x][y]].kind=2;
snake[id].len++;cnt--;snake[id].dq.push_front(idx[x][y]);return 1;
}
p[idx[x][y]].kind=2;snake[id].dq.push_front(idx[x][y]);p[snake[id].dq.back()].kind=0;snake[id].dq.pop_back();return 1;
}
int main()
{
//freopen("in.txt","r",stdin);
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=n;i++)
{
scanf("%s",s+1);
for(int j=1;j<=m;j++)
{
idx[i][j]=++num;
p[num].x=i;p[num].y=j;
switch(s[j]){
case '.':p[num].kind=0;break;
case '@':p[num].kind=1;break;
case '#':p[num].kind=2;break;
case '&':p[num].kind=3;cnt++;break;
}
}
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(p[idx[i][j]].kind==1)c++,bfs(idx[i][j]);
for(int i=1;i<=c;i++)
{
scanf("%s",s+1);
for(int j=1;j<=k;j++)
{
switch(s[j])
{
case 'W':flag=work(i,1);break;
case 'A':flag=work(i,3);break;
case 'S':flag=work(i,0);break;
case 'D':flag=work(i,2);break;
}
if(!flag)break;
}
}
sort(snake+1,snake+c+1);
for(int i=1;i<=c;i++)printf("%d %d\n",snake[i].len,snake[i].id);
printf("%d\n",cnt);
return 0;
}
后来也就没有改这份代码，重新写了一份。
#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
int n,m,k,c,hd[25][2],mp[210][210],len[25],cnt;
int dx[]={1,0,0,-1},dy[]={0,-1,1,0};
char a[210][210];
string cmd[25];
struct node{
int x,y;
node(){}
node(int _x,int _y):x(_x),y(_y){}
};
struct Snake{
int id,len;
bool operator<(const Snake&rhs)const{
return len>rhs.len||(len==rhs.len&&id<rhs.id);}
}s[25];
queue<node>body[25];
void dfs(int i,int j)
{
if(!mp[i][j]&&(a[i][j]=='#'||(a[i][j]=='@'&&len[c]==0)))
mp[i][j]=c,len[c]++;
else return;
for(int k=0;k<4;k++)
dfs(i+dx[k],j+dy[k]);
body[c].push(node(i,j));
}
void die(int id)
{
len[id]=0;
while(body[id].size())
{
node tmp=body[id].front();body[id].pop();
mp[tmp.x][tmp.y]=-1;
}
}
void Move(int i,int j,int id,int cas)
{
int x=i+dx[cas],y=j+dy[cas];
if(x<1||x>n||y<1||y>m||mp[x][y]>0)
{
die(id);
return;
}
if(mp[x][y]==-1)
{
len[id]++,mp[x][y]=id;
hd[id][0]=x,hd[id][1]=y;
body[id].push(node(x,y));
}
else
{
mp[x][y]=id,hd[id][0]=x,hd[id][1]=y;
body[id].push(node(x,y));
node tmp=body[id].front();body[id].pop();
mp[tmp.x][tmp.y]=0;
}
}
int main()
{
//freopen("in.txt","r",stdin);
std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>n>>m>>k;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
cin>>a[i][j];
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(a[i][j]=='@')
c++,dfs(i,j),hd[c][0]=i,hd[c][1]=j;
else if(a[i][j]=='&')
mp[i][j]=-1;
for(int i=1;i<=c;i++)
cin>>cmd[i];
for(int i=0;i<k;i++)
for(int j=1;j<=c;j++)
if(len[j])
{
switch(cmd[j][i])
{
case 'W':Move(hd[j][0],hd[j][1],j,3);break;
case 'A':Move(hd[j][0],hd[j][1],j,1);break;
case 'S':Move(hd[j][0],hd[j][1],j,0);break;
case 'D':Move(hd[j][0],hd[j][1],j,2);break;
}
}
for(int i=1;i<=c;i++)
s[i].id=i,s[i].len=len[i];
sort(s+1,s+c+1);
for(int i=1;i<=c;i++)
cout<<s[i].len<<" "<<s[i].id<<endl;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(mp[i][j]==-1)
cnt++;
cout<<cnt<<endl;
return 0;
}
总结
放到T3的大模拟确实让我感觉有点惊讶。不过感觉也不是那么难写，至少部分分是有的。
赛后总结
T1手推结论正确，并且不用担心爆 l o n g l o n g longlong longlong的问题。T2之前没有仔细考虑分类讨论的问题，最初的算法是很容易举出反例的但我一开始没有去做。比赛时会因为这种错误丢失不少分数，很不应该，今后比赛时要尽量去证明自己算法的正确性。T3是个大模拟很奇怪，60分也还行吧，过几天再去调试。没有对拍，没有构造数据，做完就交一次，模拟赛期间的第一套模拟题。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
