这道题选啵

题解：B4392 [常州市赛 2025] 压缩

Sun, 04 Oct 2026 00:00:00 GMT

题面传送门：B4392 [常州市赛 2025] 压缩

题目大意#

给个含 0,1 与通配符 # 的字符串（通配符可任意赋值为 0,1），相同的字串可以消到只剩下一个，求消完后最短的字串长度（答案唯一）。

思路讲解#

可以从测试点的特殊性质入手。若字符串中无 0，则说明剩下的一定是 1 或通配符，通配符赋值为 1，答案为 1。同理，若没有 1，答案就是 0。

若字符串长度不超过 333，则答案串的长度不会超过 333。列举答案串的所有情况如下：

字符串长度	情况 111	情况 222	情况 333	情况 444	情况 555	情况 666	情况 777	情况 888
1	1	0
2	00 （压缩为 0）	01	10	11 (压缩为 1)
3	000（压缩为 0）	001 （压缩为 01）	010	011（压缩为 01）	100（压缩为 10）	101	110（压缩为 10）	111 (压缩为 1)

情况数屈指可数，进一步思考后发现，这些情况其实就只有以下几种答案：
1，0，01，10，101，010。

观察这些答案和原情况的关系，得出来一个基本分类讨论框架：

如果 1 与 0 不同时存在，那么即使有通配符，也可以构造一个长度为 111 的答案。
如果原串长度大于等于 222，且其头尾不等，那么中间部分（长度为 222 无中间，直接输出）的每一个数都可以通过头尾两个不同的数构造子串进行消除，消除到 01 或 10。
若长度大于 222，头尾相等，则也可以构造子串消除到 010 或 101。

发现了疑点，通配符该怎么办呢？如果字符串不满足上方的条件 111，那就让其优先满足条件 222，因为其答案相对较短。找到通配符所在位置，与另外一个头或尾位置字符相反就可以了。

不可能有通配符同时在头尾的情况，若同时在头尾，构造出来条件 222 会发现有两个答案。

此框架有推广性，可以用于任意长度的字符串，所以问题就解决了。

代码实现#

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
string s;
4
char c1,c2;
5
bool b[2];
6
int main(){
7
  cin>>s;
8
  for(int i=0;i<s.size();i++){
9
    if(s[i]!='#') b[s[i]-'0']=1;
10
  }
11
  if(b[1]==1&&b[0]==0){
12
    cout<<1;
13
  }else if(b[1]==0&&b[0]==1){
14
    cout<<0;
15
  }else{
16
    c1=s[0];c2=s[s.size()-1];
17
    if(c1!=c2){
18
      if(c1=='#'){
19
        if(c2=='0') cout<<"10";
20
        else cout<<"01";
21
      }else if(c2=='#'){
22
        if(c1=='1') cout<<"10";
23
        else cout<<"01";
24
      }else{
25
        cout<<c1<<c2;
26
      }
27
    }else{
28
      if(c1=='0'){
29
        cout<<"010";
30
      }else if(c1=='1'){
31
        cout<<"101";
32
      }
33
    }
34
  }
35
  return 0;
36
}

展开收起

题解：P17511 [入门赛 #52] 月饼调配

Sun, 27 Sep 2026 00:00:00 GMT

题目大意#

给定一个树状的仓库分布信息，每个仓库初始有一些月饼，要求月饼通过仓库之间的联络通道（容量有限）搬运至目标状态。求出通过通道搬运的最小次数。

思路讲解#

既然是树形的数据结构，遍历上就肯定要用深搜。我们看样例解释可以总结出一点小规律：

对于若干分别要放出月饼和收入月饼的仓库来说，优先匹配两个距离最近的点进行调配是最省次数的。（距离最近即从一个点到另一个点，所经过的边数最少。）

根据这个规律，可以确定一下大致思路：

树以任意点为根（后文为 111 号点），先搜索到每个叶子节点，计算出它们需要放出或收入多少月饼。
向它的父亲赠出或索要这些月饼（因为是树形数据结构，所以所有调配方案都要经过其父亲之手）。计算此处搬运所需次数。
父亲通过其他孩子赠出或索要到的月饼来调配，尽量满足刚才孩子仓库的需求。
若父亲也无法满足孩子的需要了，就向它的父亲继续赠出或索要。

由于保证月饼礼盒的当前总数与目标总数相同，所以此思路是完全可行的。

代码实现#

搜索部分

此处使用邻接表存图。代码中 cgcgcg 数组计算开始到结束仓库月饼的变化量。
搬运次数只与变化量绝对值和当前边单次可拿的最多数量有关，所以代码中用 abs 函数取了绝对值。当然不要忘了向上取整，若对代码中的取整方法有疑问也可以强转为小数类型，使用 ceil 函数向上取整（可能有精度问题）。

1
vector<pair<int,int> >a[200005];
2
void dfs(int x,int fa){
3
  for(int i=0;i<a[x].size();i++){
4
    int nxt=a[x][i].first,val=a[x][i].second;//这里一定要是局部变量，否则孩子的变量值会影响到父亲导致答案错误
5
    if(nxt!=fa){
6
      dfs(nxt,x);
7
      cg[x]+=cg[nxt];//来自孩子的“赠予或索要”
8
      cnt+=(abs(cg[nxt])+val-1)/val;//计算搬运次数
9
    }
10
  }
11
}

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
long long n,u,v,c,cnt;
4
int s[200005],t[200005],cg[200005];
5
vector<pair<int,int> >a[200005];
6
void dfs(int x,int fa){
7
  for(int i=0;i<a[x].size();i++){
8
    int nxt=a[x][i].first,val=a[x][i].second;
9
    if(nxt!=fa){
10
      dfs(nxt,x);
11
      cg[x]+=cg[nxt];
12
      cnt+=(abs(cg[nxt])+val-1)/val;
13
    }
14
  }
15
}
16
int main(){
17
  cin>>n;
18
  for(int i=1;i<=n;i++){
19
    cin>>s[i];
20
  }
21
  for(int i=1;i<=n;i++){
22
    cin>>t[i];
23
    cg[i]=s[i]-t[i];
24
  }
25
  for(int i=1;i<=n-1;i++){
26
    cin>>u>>v>>c;
27
    a[u].push_back(make_pair(v,c));
28
    a[v].push_back(make_pair(u,c));
29
  }
30
  dfs(1,0);
31
  cout<<cnt;
32
  return 0;
33
}

展开收起

题解：AT_abc473_c [ABC473C] Change Schools

Mon, 31 Aug 2026 00:00:00 GMT

题目大意#

Takahashi 这个人可以从 1∼k1 \sim k1∼k 的所有班级中任选，问有几个选项可以使其他班级的人数都没有他选择的班级人数多。

思路讲解#

可以建桶，记录 Takahashi 这个人没有选择时各班人数，并取一个最大值。

下一步则是暴力枚举每一个班级，如果这个班级人数 +1+1+1 不小于原来的最大值，则说明这种选择是合法的。答案累加后输出即可。

代码实现#

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,k,a[200005],t[200005],maxx,ans;
4
int main(){
5
  cin>>n>>k;
6
  for(int i=1;i<=n;i++){
7
    cin>>a[i];
8
    t[a[i]]++;
9
    maxx=max(maxx,t[a[i]]);
10
  }
11
  for(int i=1;i<=k;i++){
12
    if(t[i]+1>=maxx) ans++;
13
  }
14
  cout<<ans;
15
  return 0;
16
}

展开收起

题解：P2189 小 Z 的传感器

Sun, 30 Aug 2026 00:00:00 GMT

题面传送门：P2189 小 Z 的传感器

题目大意#

在一个无向图中有 qqq 个长度为 kkk 的访问序列，问此序列是否合法，即序列中从第 iii 个点到第 i+1i+1i+1 个点无需经过任何一个在 i+2∼ki+2 \sim ki+2∼k 之间的点。

思路讲解#

由上文可以看出，题目难点就是判断往返两点之间是否经过其他传感器点。可以有一个策略：小 Y 从序列第一个传感器点出发，走所有与其连通且不是传感器的点，看能不能到达与下一个传感器点连通的、不是传感器的点。后续再以此类推，如果都能满足就输出 Yes，反之输出 No。

看上文发现过多要素：连通、无向图，发现并查集可以做。具体思路：

给 2∼k2 \sim k2∼k 之间的传感器点打标记。
给非传感器点和第一个传感器点进行并查集操作，进行操作时仅针对未标记点。
取消 222 号传感器点标记，进行并查集操作，进行操作时仅针对未标记点，判断它跟 111 号传感器点是否在一个连通块内，若不是直接判断不合法。
对其他传感器点做类似步骤 333 的操作。

代码实现#

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,m,k,q,x,y,track[100005],fa[100005],fx,fy;
4
bool b[100005];
5
vector<int>a[100005];
6
int find(int x){
7
  if(fa[x]==x) return x;
8
  return fa[x]=find(fa[x]);
9
}
10
int main(){
11
  ios::sync_with_stdio(0);
12
  cin.tie(0);cout.tie(0);
13
  cin>>n>>m>>k>>q;
14
  for(int i=1;i<=m;i++){
15
    cin>>x>>y;
16
    a[x].push_back(y);
17
    a[y].push_back(x);
18
  }
19
  for(int z=1;z<=q;z++){
20
    for(int i=1;i<=n;i++){
21
      fa[i]=i;
22
      b[i]=0;
23
    }
24
    for(int i=1;i<=k;i++){
25
      cin>>track[i];
26
      b[track[i]]=1;
27
    }
28
    for(int i=1;i<=n;i++){
29
      if(b[i]==1) continue;
30
      for(int j=0;j<a[i].size();j++){
31
        if(b[a[i][j]]==0){
32
          fx=find(i);fy=find(a[i][j]);
33
          if(fx!=fy) fa[fy]=fx;
34
        }
35
      }
36
    }
37
    for(int i=1;i<=k;i++){
38
      b[track[i]]=0;
39
      for(int j=0;j<a[track[i]].size();j++){
40
        if(b[a[track[i]][j]]==0){
41
          fx=find(track[i]);fy=find(a[track[i]][j]);
42
          if(fx!=fy) fa[fy]=fx;
43
        }
44
      }
45
      if(i==1) continue;
46
      fx=find(track[i-1]);fy=find(track[i]);
47
      if(fx!=fy){
48
        cout<<"No\n";
49
        break;
50
      }
51
      if(fx==fy&&i==k){
52
        cout<<"Yes\n";
53
      }
54
    }
55
  }
56
  return 0;
57
}

展开收起

题解：P16487 [GKS 2014 #C] Taking Metro

Fri, 28 Aug 2026 00:00:00 GMT

题面传送门：P16487 [GKS 2014 #C] Taking Metro

题目大意#

给定两个地铁站，求它们之间的最短通勤时间。

思路讲解#

从题面中不难看出，这本质上是道求最短路的题，而这道题的难点在于建图。

我们可以把时间当作边权，这道题对时间的描述就分别有：

车站间的运行时间
换乘通道的步行时间
预期的等待时间

对于前两种描述，我们直接把两个站点连起来，以时间为边权，建边就完成了。
第三种描述看起来类似点权，我们熟知的最短路算法并不能简单地处理点权。因此可以考虑把预期等待时间也转成边来处理。

转化具体思路

常识中，我们要在地铁 iii 号线的站台上等候 wiw_iwi 分钟，然后登上地铁列车。这里的 wiw_iwi 分钟可以说你一直在同一个点。
现在把它改成：地铁一直在那里，且可以一直等着我们，但我们走得很慢，需要 wiw_iwi 分钟才能走上车。这里的 wiw_iwi 分钟，你从站台走上了车，相当于走出了一条边。

综上可以将一个地铁车站分为两部分（站台和车上），对这两部分连边即可。

处理完跑最短路即可。

代码实现#

最短路算法的选择

先计算一下这个图的最大点数 nnn 和最大边数 mmm：

每个测试用例中的车站总数不超过 100010001000，一站分为两部分，所以 n=2000n=2000n=2000。

每个站有两部分，每站各部分之间有无向边，即 200020002000 条有向边；外加每组相邻站有无向边，即最多 9992999^29992 条边，所以 mmm 约为 10610^6106 。

题目还是多测，1≤T≤1001 \le T \le 1001≤T≤100，别说 Floyd 了，直接跑 nnn 遍甚至 n/2n/2n/2 遍（不带车上点）加堆优化的 Dijkstra 也过不了。但题目中 1≤Q≤101 \le Q \le 101≤Q≤10 的范围可以让我们在每次询问的时候跑 Dijkstra 算法，这样就可以通过了。

存储

存储可用链式前向星和邻接表。线路、是否上车、站点号的处理若要通过所有数据，则可以通过创建映射表的方法来解决。主要思想就是赋予每个站一个编号，特别的，不在车上的编号为站点编号 +1000+1000+1000，以达到一分区一编号的效果。

1
for(int i=1;i<=n;i++){
2
    cin>>sn[i]>>w[i];
3
    for(int j=1;j<=sn[i];j++){
4
        num++;
5
        mp[make_pair(i,j)]=num;
6
        if(j!=sn[i]){
7
            cin>>ti;
8
            add(mp[make_pair(i,j)],mp[make_pair(i,j)]+1,ti);
9
            add(mp[make_pair(i,j)]+1,mp[make_pair(i,j)],ti);
10
            //两站站内之间建双向边
11
        }
12
        add(mp[make_pair(i,j)],mp[make_pair(i,j)]+1000,0);
13
        add(mp[make_pair(i,j)]+1000,mp[make_pair(i,j)],w[i]);
14
        //当前站站内外建双向边
15
    }
16
}

展开收起

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int t,n,sn[105],w[105],ti,m,m1,s1,m2,s2,tr,qu,x1,yl,x2,y2;
4
int cnt,to[4005],val[4005],nxt[4005],h[2005];
5
int num,dis[2005],uu,vv,num1,num2;
6
bool b[2005];
7
map<pair<int,int>,int>mp;
8
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > >q;
9
void add(int a,int b,int c){
10
  cnt++;
11
  to[cnt]=b;
12
  val[cnt]=c;
13
  nxt[cnt]=h[a];
14
  h[a]=cnt;
15
}
16
int main(){
17
  ios::sync_with_stdio(0);
18
  cin.tie(0);cout.tie(0);
19
  cin>>t;
20
  for(int z=1;z<=t;z++){
21
    cin>>n;
22
    memset(h,0,sizeof(h));//不清空会导致66行死循环
23
    num=0;cnt=0;//多测不清空，爆零两行泪
24
    for(int i=1;i<=n;i++){
25
      cin>>sn[i]>>w[i];
26
      for(int j=1;j<=sn[i];j++){
27
        num++;
28
        mp[make_pair(i,j)]=num;
29
        if(j!=sn[i]){
30
          cin>>ti;
31
          add(mp[make_pair(i,j)],mp[make_pair(i,j)]+1,ti);
32
          add(mp[make_pair(i,j)]+1,mp[make_pair(i,j)],ti);
33
          //两站站内之间建双向边
34
        }
35
        add(mp[make_pair(i,j)],mp[make_pair(i,j)]+1000,0);
36
        add(mp[make_pair(i,j)]+1000,mp[make_pair(i,j)],w[i]);
37
        //当前站站内外建双向边
38
      }
39
    }
40
    cin>>m;
41
    for(int i=1;i<=m;i++){
42
      cin>>m1>>s1>>m2>>s2>>tr;
43
      add(mp[make_pair(m1,s1)]+1000,mp[make_pair(m2,s2)]+1000,tr);
44
      add(mp[make_pair(m2,s2)]+1000,mp[make_pair(m1,s1)]+1000,tr);
45
      //站外换乘通道建双向边
46
    }
47
    //补药在此处预处理最短路！会TLE
48
    cin>>qu;
49
    cout<<"Case #"<<z<<":\n";
50
    for(int k=1;k<=qu;k++){
51
      cin>>x1>>yl>>x2>>y2;
52
      num1=mp[make_pair(x1,yl)]+1000;num2=mp[make_pair(x2,y2)]+1000;
53
      for(int i=1;i<=1000+num;i++){
54
        dis[i]=0x3fffffff;
55
        b[i]=0;
56
      }
57
      dis[num1]=0;
58
      q.push(make_pair(0,num1));
59
      while(!q.empty()){
60
        uu=q.top().second;
61
        q.pop();
62
        if(b[uu]==1) continue;
63
        b[uu]=1;
64
        for(int j=h[uu];j!=0;j=nxt[j]){//这里是66行
65
          vv=to[j];
66
          if(dis[vv]>dis[uu]+val[j]){
67
            dis[vv]=dis[uu]+val[j];
68
            q.push(make_pair(dis[vv],vv));
69
          }
70
        }
71
      }
72
      cout<<' ';
73
      if(dis[num2]==0x3fffffff){
74
        cout<<"-1\n";
75
      }else{
76
        cout<<dis[num2]<<'\n';
77
      }
78
    }
79
  }
80
  return 0;
81
}

展开收起

题解：P17093 [ICPC 2017 Qingdao R] Chenchen, Tangtang and ZengZeng

Sun, 12 Jul 2026 00:00:00 GMT

题面传送门：P17093 [ICPC 2017 Qingdao R] Chenchen, Tangtang and ZengZeng

题目大意#

给定多个三子棋棋盘，判断获胜情况。

思路讲解#

本题可用字符数组存储。由于只有三行三列，我们可以枚举数组中每行每列每对角线是否有三个相同棋子（但要注意不是空白）。若有则有人获胜，输出这三格的值即可。在枚举完还没有输出结果时，输出一个 ongoing 即可。

对于如何判断有无输出，既可以使用标记变量，有输出就打标记；也可使用 continue 语句，若有输出直接不执行下方的输出 ongoing 指令。

代码实现#

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int t;
4
char c[4][4];
5
int main(){
6
  cin>>t;
7
  for(int z=1;z<=t;z++){
8
    for(int i=1;i<=3;i++){
9
      for(int j=1;j<=3;j++){
10
        cin>>c[i][j];
11
      }
12
    }
13
    if(c[1][1]==c[1][2]&&c[1][2]==c[1][3]&&c[1][1]!='.'){
14
      cout<<c[1][1]<<'\n';
15
      continue;
16
    }
17
    if(c[2][1]==c[2][2]&&c[2][2]==c[2][3]&&c[2][1]!='.'){
18
      cout<<c[2][1]<<'\n';
19
      continue;
20
    }
21
    if(c[3][1]==c[3][2]&&c[3][2]==c[3][3]&&c[3][1]!='.'){
22
      cout<<c[3][1]<<'\n';
23
      continue;
24
    }
25
    if(c[1][1]==c[2][1]&&c[2][1]==c[3][1]&&c[1][1]!='.'){
26
      cout<<c[1][1]<<'\n';
27
      continue;
28
    }
29
    if(c[1][2]==c[2][2]&&c[2][2]==c[3][2]&&c[1][2]!='.'){
30
      cout<<c[1][2]<<'\n';
31
      continue;
32
    }
33
    if(c[1][3]==c[2][3]&&c[2][3]==c[3][3]&&c[1][3]!='.'){
34
      cout<<c[1][3]<<'\n';
35
      continue;
36
    }
37
    if(c[1][1]==c[2][2]&&c[2][2]==c[3][3]&&c[1][1]!='.'){
38
      cout<<c[1][1]<<'\n';
39
      continue;
40
    }
41
    if(c[3][1]==c[2][2]&&c[2][2]==c[1][3]&&c[3][1]!='.'){
42
      cout<<c[3][1]<<'\n';
43
      continue;
44
    }
45
    cout<<"ongoing"<<'\n';
46
  }
47
  return 0;
48
}

展开收起

题解：P16981 [NWERC 2017] 安装应用 / Installing Apps

Tue, 07 Jul 2026 00:00:00 GMT

题面传送门：P16981 [NWERC 2017] 安装应用 / Installing Apps

题目大意#

给出一些应用下载与存储的大小和手机容量，求最多安装应用的数量与方案。

思路讲解#

首先注意到题目中要素齐全：手机容量、物品占用空间等很难不把思路拉到 DP 中，尤其是背包问题。
但要注意，本题的容量会随放入物品而变化，因此在选择下载应用时也要有一定的策略，这个策略可以由贪心得到。
最后，不仅要输出拿取物品数量，还要在数量为正数时输出拿取方案。
综上，得任务列表如下：

贪心策略对应用预处理
动态规划得安装数量
整合拿取路径

贪心

每个应用涉及值众多，此处建议用结构体存储。
我们可以将应用分为两类，分别为 d≤sd \le sd≤s 的应用与 d>sd > sd>s 的应用。
对于第一种应用，更为重要的肯定是存储大小，为了安装的应用尽可能多，应将 sss 更小的应用放在前。
对于第二种应用，有多种排序方法。可以通过计算 ddd 与 sss 的差值来排序，差值越大的排在前面。本方式可以推广到第一种应用上，因此排序规则为按 ddd 与 sss 的差值降序排序。
由于排序方式众多，这里再展示官方的排序方法。

标准解法

1
bool cmp(App a, App b) {
2
    if (a.d <= a.s && b.d > b.s) return true; // a is type 1, b is type 2
3
    if (a.d > a.s && b.d <= b.s) return false;
4
    if (a.d <= a.s && b.d <= b.s) return a.d < b.d; // Type 1: sort by d asc
5
    return a.s > b.s; // Type 2: sort by s desc (or d desc)
6
}

此处策略为：如果安装后变大或不变，按 ddd ‌升序排序。如果安装后变小，按 sss 降序排序。
后文【代码实现】部分展示的是本文中给出的非官方解法。

背包 DP

排序完成后，定义 dpi,jdp_{i,j}dpi,j 表示考虑前 iii 个应用，安装完 jjj 个应用后，手机至少需要多大容量。目标是找到最大的 jjj，使得 dpn,j≤cdp_{n,j} \le cdpn,j≤c。
若在状态转移时沿用此思路，则需计算选定应用空间之和的最小值，计算较复杂。所以可以改变数组定义，改为前 iii 个应用，安装完 jjj 个应用后，手机剩余空间最大值。初始化 dp[0][0]=c，其他位置值为 −1-1−1，防止不剩空间与无法放入混淆。此时目标是找到最大的 jjj，使得 dpn,j≥0dp_{n,j} \ge 0dpn,j≥0。
循环遍历每一个应用，分安装与否两种情况。转移方程如下：
dpi,j={max(dpi,j,dpi−1,j)（不安装）max(dpi,j,dpi−1,j−1−ai.s)（安装）dp_{i,j} = \begin{cases} max(dp_{i,j}, dp_{i-1,j}) &\text{（不安装）}\\ max(dp_{i,j}, dp_{i-1,j-1}-a_{i}.s) &\text{（安装）}\\ \end{cases}dpi,j={max(dpi,j,dpi−1,j)max(dpi,j,dpi−1,j−1−ai.s)（不安装）（安装）
注意 jjj 可为 000，若安装应加条件 j>0j>0j>0。

完成 DP 后，倒序循环找出拿取数量，将此数量记为 numnumnum。

路径整合

查找路径时可以在 DP 过程中，记录每个状态是由哪个状态转移而来（即选没选第 iii 个应用）。最后从最终状态 n,numn, numn,num 反向回溯，即可得到安装了哪些应用，但是为倒序，需要倒序输出或翻转数组。

代码实现#

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,c,dp[505][505],num;
4
bool b[505][505];
5
vector<int>plan;
6
struct data{
7
  int d,s,m,del,pos;
8
}a[505];
9
bool cmp(data x,data y){
10
  return x.del>y.del;
11
}
12
int main(){
13
  cin>>n>>c;
14
  for(int i=1;i<=n;i++){
15
    cin>>a[i].d>>a[i].s;
16
    a[i].m=max(a[i].d,a[i].s);
17
    a[i].del=a[i].d-a[i].s;
18
    a[i].pos=i;
19
  }
20
  sort(a+1,a+n+1,cmp);
21
  memset(dp,-1,sizeof(dp));
22
  dp[0][0]=c;
23
  for(int i=1;i<=n;i++){
24
    for(int j=0;j<=i;j++){
25
      dp[i][j]=max(dp[i][j],dp[i-1][j]);
26
      if(j>0&&dp[i-1][j-1]>=a[i].m&&dp[i-1][j-1]-a[i].s>dp[i][j]){
27
        dp[i][j]=dp[i-1][j-1]-a[i].s;
28
        b[i][j]=1;
29
      }
30
    }
31
  }
32
  for(int i=n;i>=0;i--){
33
    if(dp[n][i]>=0){
34
      num=i;
35
      break;
36
    }
37
  }
38
  cout<<num<<'\n';
39
  if(num==0){
40
    return 0;
41
  }
42
  for(int i=n,j=num;i>0&&j>0;i--){
43
    if(b[i][j]==1){
44
      plan.push_back(a[i].pos);
45
      j--;
46
    }
47
  }
48
  for(int i=plan.size()-1;i>=0;i--){
49
    cout<<plan[i]<<' ';
50
  }
51
  return 0;
52
}

展开收起

题解：P16953 「NLOI Round1」白鸟过河滩

Sat, 20 Jun 2026 00:00:00 GMT

题面传送门：P16953 「NLOI Round1」白鸟过河滩

题目大意#

每组数据给定三组演唱效果与人数，求其商的最大值所在下标。

思路讲解#

首先肯定是要求对应值的商。
此处求商不能直接除，我们可以观察部分样例来得到原因。
5 6 9 3 4 5 这组样例若使用普通除法，即整除，所得结果应该是 111，而答案给出的是 333，这说明本题中算商需要浮点数的参与，因此需要改变数据存储方式。

接下来是对商进行打擂台找最值，并记录结果下标。此处不再赘述。

代码实现#

先说一下存储

1
#include<bits/stdc++.h>
2
using namespace std;
3
int t,maxp;
4
long double maxx,a[4],b[4];
5
int main(){
6
  ...
7
  for(int z=1;z<=t;z++){
8
    ...
9
    cin>>a[1]>>a[2]>>a[3]>>b[1]>>b[2]>>b[3];
10
    ...
11
  }
12
  return 0;
13
}

此处 aaa 数组存演唱效果，bbb 数组存人数。由于要算的商是一一对应的，所以使用数组也可以快速找到答案下标。

WARNING

数据点 444 达到 2×1092 \times 10^92×109，再求商后小数点后位数增长迅猛，double 类型极易溢出，应使用 long double。为防止运算精度问题，上方两数组也应顺便开成 long double。

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int t,maxp;
4
long double maxx,a[4],b[4];
5
int main(){
6
  cin>>t;
7
  for(int z=1;z<=t;z++){
8
    maxx=0;maxp=1;//多测不清空，_____
9
    //小声BB：有可能三个商相等，根据编号最小的规则，应将变量 maxp 初始化为 1。
10
    cin>>a[1]>>a[2]>>a[3]>>b[1]>>b[2]>>b[3];
11
    for(int i=1;i<=3;i++){
12
      if(a[i]/b[i]>maxx){
13
        maxx=a[i]/b[i];
14
        maxp=i;
15
      }
16
    }
17
    cout<<maxp<<'\n';
18
  }
19
  return 0;
20
}

展开收起

题解：P16719 积点

Sun, 31 May 2026 00:00:00 GMT

题面传送门：P16719 积点

题目大意#

每 xxx 分得一次奖励，给出当前积分，求还需获得多少积分以取得下一奖励。

思路讲解#

转化一下题面，问题则变为：
当 nnn 达到 xxx 的倍数时获得奖励，问 nnn 和 xxx 倍数之差。不妨设 n=x×k+bn=x \times k+bn=x×k+b，即 n÷x=kn \div x=kn÷x=k，余数为 bbb。由于我们知道下一个 xxx 的倍数与余数的差值恒定，所以可以让 nnn 对 xxx 取模，再输出 x−n mod xx-n \bmod xx−nmodx 即可。

代码实现#

1
#include<bits/stdc++.h>
2
using namespace std;
3
int x,n;
4
int main(){
5
  cin>>x>>n;
6
  cout<<x-n%x;
7
  return 0;
8
}

题解：P16491 [GKS 2014 #D] GBus count

Sat, 16 May 2026 00:00:00 GMT

题面传送门：P16491 [GKS 2014 #D] GBus count

题目大意#

给出 Gbus 的运营范围，求特定位置的 Gbus 覆盖数量。

思路讲解#

首先想到暴力的思路，每输入一条线路就给这条线路服务的所有城市答案 +1+1+1，时间复杂度约 10610^6106，能过。

观察题面，每条线路覆盖的范围已给出，最好能快速求变化量。差分与前缀和的方法更优。

代码实现#

从差分到前缀和还原

根据差分的基本思路，只需在左端点和右端点之后一个位置对数组进行修改。

注意：本题的城市数量只与 ai,bi,cia_i,b_i,c_iai,bi,ci 的范围有关，故下方求前缀和时循环到 500550055005。

1
for(int i=1;i<=n;i++){
2
  cin>>a[i]>>b[i];
3
  s[a[i]]++;
4
  s[b[i]+1]--;
5
}
6
for(int i=1;i<=5005;i++){
7
  s[i]=s[i-1]+s[i];
8
}

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int t,n,a[505],b[505],p,c,s[5005];
4
int main(){
5
  cin>>t;
6
  for(int z=1;z<=t;z++){
7
    memset(s,0,sizeof(s));//多测不清空，_____
8
    cout<<"Case #"<<z<<": ";
9
    cin>>n;
10
    for(int i=1;i<=n;i++){
11
      cin>>a[i]>>b[i];
12
      s[a[i]]++;
13
      s[b[i]+1]--;
14
    }
15
    for(int i=1;i<=5005;i++){
16
      s[i]=s[i-1]+s[i];
17
    }
18
    cin>>p;
19
    for(int i=1;i<=p;i++){
20
      cin>>c;
21
      cout<<s[c]<<' ';
22
    }
23
    cout<<endl;
24
  }
25
  return 0;
26
}

展开收起

题解：P16247 [蓝桥杯 2026 省研究生组] 魔法矩阵能量值

Sun, 12 Apr 2026 00:00:00 GMT

题面传送门：P16247 [蓝桥杯 2026 省研究生组] 魔法矩阵能量值

题目大意#

根据计算规则模拟求各项能量值之和。

思路讲解#

注意到此题目 n=13n=13n=13，可使用循环枚举出各个位置能量值，再相加。

题目强调，我们必须顺次执行计算规则。可使用多个并列的 if 语句来实现。

代码实现#

AC代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n=13,a[15][15],sum;
4
int main(){
5
  for(int i=1;i<=n;i++){
6
    for(int j=1;j<=n;j++){
7
      a[i][j]=i*j*(i+j);
8
      if(i==j) a[i][j]*=2;
9
      if(i==1||i==n||j==1||j==n) a[i][j]/=2;
10
      if(i==(n+1)/2&&i==j) a[i][j]+=100;//由于13是奇数，所以必有中心点
11
    }
12
  }
13
  for(int i=1;i<=n;i++){
14
    for(int j=1;j<=n;j++){
15
      sum+=a[i][j];
16
    }
17
  }
18
  cout<<sum;
19
  return 0;
20
}

展开收起

此代码也有值得优化的地方。如：改数组为变量节省空间；合并两层循环等。

题解：P15930 [TOPC 2021] Aliquot Sum

Sat, 28 Mar 2026 00:00:00 GMT

题面传送门：P15930 [TOPC 2021] Aliquot Sum

题目大意#

给出一个数，判断这个数的不包括本身的因数和与这个数的大小关系。

思路讲解#

注意到本题特殊时间限制为 888 秒，可直接枚举出读入数的所有因数之和再判断。下面给出求 s(n)s(n)s(n) 思路。

枚举 1∼n1 \sim \sqrt{n}1∼n，可得出 nnn 因数中较小一半，可通过计算得出另一半的因数。要将当前数与 nnn 与此数之商都加入到 s(n)s(n)s(n) 中。
特别地，当前枚举的数的平方等于 nnn 时，s(n)s(n)s(n) 只需加入当前数。

特别注意，n=1n=1n=1 时， s(n)s(n)s(n) 值为零。

代码实现#

本代码在暴力方法的基础上尽可能优化。
提交记录点此直达。

完整代码

1
#include<cstdio>
2
using namespace std;
3
int t,n,s;
4
int main(){
5
  scanf("%d",&t);
6
  while(t--){
7
    scanf("%d",&n);
8
    s=0;
9
    for(int i=1;i*i<=n;i++){
10
      if(n==1) break;
11
      if(n%i==0){
12
        if(i*i!=n&&i!=1) s+=i+n/i;
13
        else s+=i;
14
      }
15
    }
16
    if(s>n) printf("abundant\n");
17
    else if(s<n) printf("deficient\n");
18
    else printf("perfect\n");
19
  }
20
  return 0;
21
}

展开收起

题解：P15929 [TOPC 2021] Olympic Ranking

Fri, 27 Mar 2026 00:00:00 GMT

题面传送门：P15929 [TOPC 2021] Olympic Ranking

变量意义（题中未给出）

ggg 为英文单词 gold 缩写，代表金牌个数；
sss 为英文单词 silver 缩写，代表银牌个数；
bbb 为英文单词 bronze 缩写，代表铜牌个数。

题目大意#

给出各国金银铜牌获得数量，根据特定排序规则寻找第一名。

思路讲解#

注意到题中每个国家有多个信息，且需要根据一部分信息对其排序，因此可使用结构体，此时排序的重点在于排序规则的定义。

代码实现#

结构体定义 & 排序规则

1
struct oly{
2
  int g,s,b;
3
  string name;
4
}a[305];
5
bool cmp(oly x,oly y){
6
  if(x.g!=y.g) return x.g>y.g;//如果金牌数不等，则多者在前
7
  if(x.s!=y.s) return x.s>y.s;//如果银牌数不等，则多者在前
8
  return x.b>y.b;//其他情况则按铜牌数排序
9
}

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n;
4
struct oly{
5
  int g,s,b;
6
  string name;
7
}a[305];
8
bool cmp(oly x,oly y){
9
  if(x.g!=y.g) return x.g>y.g;
10
  if(x.s!=y.s) return x.s>y.s;
11
  return x.b>y.b;
12
}
13
int main(){
14
  cin>>n;
15
  for(int i=1;i<=n;i++){
16
    cin>>a[i].g>>a[i].s>>a[i].b;
17
    getline(cin,a[i].name);//输入国名可能包含空格
18
    a[i].name.erase(0,1);//国名会在前多一个空格，使用此函数进行删除
19
  }
20
  sort(a+1,a+n+1,cmp);
21
  cout<<a[1].name;
22
  return 0;
23
}

展开收起

题解：P15853 [蓝桥杯第二届国际赛] 特殊日期

Sun, 22 Mar 2026 00:00:00 GMT

题面传送门：P15853 [蓝桥杯第二届国际赛] 特殊日期

题目大意#

枚举日期，寻找有至少三位连续数字日期的个数。

思路讲解#

本题分为两大块，一是日期的枚举，二是是否连续的判断。

日期枚举

我们可以定义一个函数，从而使得循环变量 iii 的变化符合生活中日期的变化。
连续性判断

可对八位日期进行拆位，计算连续数字个数，达到 333 就是特殊日期。

代码实现#

循环变量自增函数

1
int nxt(int x){
2
    year=x/10000;month=x%10000/100;day=x%100;
3
    if(month==1||month==3||month==5||month==7||month==8||month==10){
4
        if(day!=31) return x+1;
5
    }else if(month==12){
6
        if(day!=31) return x+1;
7
        return (year+1)*10000+101;
8
    }else if(month==2){
9
        if((year%4==0&&year%100!=0)||year%400==0){
10
            if(day!=29) return x+1;
11
        }else{
12
            if(day!=28) return x+1;
13
        }
14
    }else{
15
        if(day!=30) return x+1;
16
    }
17
    return year*10000+(month+1)*100+1;
18
}

展开收起

对非每月边界的日期直接返回原日期 +1+1+1，对边界日期则对月 +1+1+1，日归零，组成新的日期返回。

连续性检查函数

1
bool check(int x){
2
  pre=x%10;
3
  x/=10;
4
  cnt=1;
5
  while(x!=0){
6
    if(x%10==pre){
7
      cnt++;
8
      if(cnt==3) return 1;
9
    }else{
10
      cnt=1;
11
    }
12
    pre=x%10;
13
    x/=10;
14
  }
15
  return 0;
16
}

展开收起

利用拆位方法，与上一个数进行对比从而判断连续性。

主函数枚举 + 函数调用

1
int main(){
2
    cin>>st>>ed;
3
    for(int i=st;i<=ed;i=nxt(i)){
4
      if(check(i)) ans++;
5
  }
6
  cout<<ans;
7
  return 0;
8
}

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int st,ed,year,month,day,ans,pre,cnt;
4
int nxt(int x){
5
  year=x/10000;month=x%10000/100;day=x%100;
6
    if(month==1||month==3||month==5||month==7||month==8||month==10){
7
    if(day!=31) return x+1;
8
  }else if(month==12){
9
    if(day!=31) return x+1;
10
    return (year+1)*10000+101;
11
  }else if(month==2){
12
    if((year%4==0&&year%100!=0)||year%400==0){
13
      if(day!=29) return x+1;
14
    }else{
15
      if(day!=28) return x+1;
16
    }
17
  }else{
18
    if(day!=30) return x+1;
19
  }
20
  return year*10000+(month+1)*100+1;
21
}
22
bool check(int x){
23
  pre=x%10;
24
  x/=10;
25
  cnt=1;
26
  while(x!=0){
27
    if(x%10==pre){
28
      cnt++;
29
      if(cnt==3) return 1;
30
    }else{
31
      cnt=1;
32
    }
33
    pre=x%10;
34
    x/=10;
35
  }
36
  return 0;
37
}
38
int main(){
39
    cin>>st>>ed;
40
    for(int i=st;i<=ed;i=nxt(i)){
41
      if(check(i)) ans++;
42
  }
43
  cout<<ans;
44
  return 0;
45
}

展开收起

题解：P15524 [ROIR 2015 Day 1] prizes 奖品选择

Sat, 21 Mar 2026 00:00:00 GMT

题面传送门：P15524 [ROIR 2015 Day 1] prizes 奖品选择

题目大意#

给定奖品价值和区间长度，寻找一个区间和一个数，使不与此区间重合的所有同长度区间各项之和小于找到的数。找到的数要尽可能小。

思路讲解#

直接枚举两人所选区间的复杂度接近 O(n2)O(n^2)O(n2)，本题 3≤n≤1053 ≤ n ≤ 10^53≤n≤105 会超时。

题目与总价值有关，且给定了区间的长度，可利用前缀和数组求区间和。

不妨将阿丽莎选择后的剩余部分分出左右，在这两部分中分别求鲍勃的最优选择方案。最优方案求出后，枚举阿丽莎选择的区间寻找最小数字即可。

代码实现#

定义部分

1
int n,k,a[100005];
2
long long s[100005],l[100005],r[100005],ans=1e14;

注意

此处 s,l,rs,l,rs,l,r 三个数组分别求前缀和，左段最优解，右段最优解，ansansans 是寻找到的答案。由于数据范围限制，开 long long 才可保证不越界。

输入 + 求前缀和

1
for(int i=1;i<=n;i++){
2
    cin>>a[i];
3
    s[i]=s[i-1]+a[i];
4
}

左右子段分别找最优解

1
for(int i=k;i<=n;i++){
2
    l[i]=max(l[i-1],s[i]-s[i-k]);
3
}//左段
4
for(int i=n-k+1;i>=1;i--){
5
    r[i]=max(r[i+1],s[i+k-1]-s[i-1]);
6
}//右段

寻找区间 + 输出

1
for(int i=1;i<=n-k+1;i++){
2
    ans=min(ans,max(l[i-1],r[i+k]));
3
}
4
cout<<ans;

在上一步中，使用了类似状态转移的思想，使得答案存于找到区间的左右两侧。互相比对后再与原答案打擂台即为结果。

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,k,a[100005];
4
long long s[100005],l[100005],r[100005],ans=1e14;
5
int main(){
6
  cin>>n>>k;
7
  for(int i=1;i<=n;i++){
8
    cin>>a[i];
9
    s[i]=s[i-1]+a[i];
10
  }
11
  for(int i=k;i<=n;i++){
12
    l[i]=max(l[i-1],s[i]-s[i-k]);
13
  }
14
  for(int i=n-k+1;i>=1;i--){
15
    r[i]=max(r[i+1],s[i+k-1]-s[i-1]);
16
  }
17
  for(int i=1;i<=n-k+1;i++){
18
    ans=min(ans,max(l[i-1],r[i+k]));
19
  }
20
  cout<<ans;
21
  return 0;
22
}

展开收起

题解：P15521 [CCC 2016 J4] Arrival Time

Tue, 03 Mar 2026 00:00:00 GMT

题面传送门：P15521 [CCC 2016 J4] Arrival Time

题目大意#

给出出发时间，考虑高峰期的特殊情况，计算到达时间。

思路讲解#

本题需要对不同出发时间进行分类讨论。可分为两种大情况：

整个行程与高峰期完全无关，出发时间可分为:
5:00前 10:00-13:00 19:00后
整个行程有高峰期的存在，出发时间可分为：
5:00-6:59 7:00-10:00 13:01-14:59 15:00-19:00

1.与高峰期完全无关

非高峰期时间恒为 222 小时。此时的到达时间即为 (h+2) mod 24:m(h+2)\bmod24:m(h+2)mod24:m。

2.有高峰期的存在

出发时间为非高峰，到达时间为非高峰。

（早高峰持续时间较短，此情况仅出现于早高峰前）
出发时间为非高峰，到达时间为高峰。
出发时间为高峰，到达时间为非高峰。
出发时间为高峰，到达时间为高峰。

针对这四种情况，我们要算出状态变化后还需行驶的时间。高峰期由于速度是原来的一半，因此处理时将时间乘二即可。

代码实现#

变量声明

s←s\getss← 输入字符串
h←h\getsh← 出发时间小时部分
m←m\getsm← 出发时间分钟部分
ah←ah\getsah← 到达时间小时部分
am←am\getsam← 到达时间分钟部分
yu←yu\getsyu← 状态变化后还需行驶的时间

输入

输入的数据使用字符串存储，再从字符串中得出出发的小时与分钟。

1
cin>>s;
2
h=(s[0]-'0')*10+s[1]-'0';
3
m=(s[3]-'0')*10+s[4]-'0';

非高峰情况

1
if((h<5)||(h>=19)||(h>=10&&h<13)||((h==5||h==13)&&m==0)){
2
  ah=h+2;
3
  if(ah>=24) ah-=24;
4
  am=m;
5
}

有高峰情况

7:00前出发

1
yu=120-(7*60-(h*60+m));
2
yu*=2;
3
if(yu>180){//到达时间为非高峰
4
  yu-=180;
5
  yu/=2;
6
  ah=10+yu/60;
7
  am=yu%60;
8
}else{
9
  ah=7+yu/60;
10
  am=yu%60;
11
}

7:00-10:00出发

1
yu=120-(10*60-(h*60+m))/2;
2
ah=10+yu/60;
3
am=yu%60;

13:01-14:59出发

1
yu=120-(15*60-(h*60+m));
2
yu*=2;
3
ah=15+yu/60;
4
am=yu%60;

15:00-19:00出发

1
yu=120-(19*60-(h*60+m))/2;
2
ah=19+yu/60;
3
am=yu%60;

输出

输出时占两位，不足用 000 补齐，可使用 printf 函数

1
printf("%02d:%02d",ah,am);

完整代码

1
#include<bits/stdc++.h>
2
using namespace std;
3
string s;
4
int h,m,ah,am,yu;
5
int main(){
6
  cin>>s;
7
  h=(s[0]-'0')*10+s[1]-'0';
8
  m=(s[3]-'0')*10+s[4]-'0';
9
  if((h<5)||(h>=19)||(h>=10&&h<13)||((h==5||h==13)&&m==0)){
10
    ah=h+2;
11
    if(ah>=24) ah-=24;
12
    am=m;
13
  }else{
14
    if(h<7){
15
      yu=120-(7*60-(h*60+m));
16
      yu*=2;
17
      if(yu>180){
18
        yu-=180;
19
        yu/=2;
20
        ah=10+yu/60;
21
        am=yu%60;
22
      }else{
23
        ah=7+yu/60;
24
        am=yu%60;
25
      }
26
    }else if(h>=7&&h<=10){
27
      yu=120-(10*60-(h*60+m))/2;
28
      ah=10+yu/60;
29
      am=yu%60;
30
    }else if(h>=15&&h<=19){
31
      yu=120-(19*60-(h*60+m))/2;
32
      ah=19+yu/60;
33
      am=yu%60;
34
    }else{
35
      yu=120-(15*60-(h*60+m));
36
      yu*=2;
37
      ah=15+yu/60;
38
      am=yu%60;
39
    }
40
  }
41
  printf("%02d:%02d",ah,am);
42
  return 0;
43
}

展开收起

题解：P14566 【MX-S12-T1】取模

Sat, 22 Nov 2025 00:00:00 GMT

题面传送门：P14566 【MX-S12-T1】取模

题目大意#

选取一个正整数 ppp 使 aaa 数组中各项对这个正整数取模的结果的极差（即最大值与最小值的差）最大

思路讲解#

由上文可知，本题是一个找最值的题目，因此考虑贪心

贪心具体分两种思路：

取模结果极差最大，则先找到 aaa 数组中的最大值 maxxmaxxmaxx，正整数 ppp 则为 maxx+1maxx+1maxx+1。此时的结果为 aaa 数组的最大值-最小值
我们发现思路1无法通过样例3和4，此时考虑将ppp直接定为 maxxmaxxmaxx，此时 aaa数组中取模结果最小值为 000，最大值为 aaa数组中的次大值

我们将这两种思路所得结果进行比较即可。

AC代码#

1
#include<bits/stdc++.h>
2
using namespace std;
3
int t,n,a[100005],b1[100005],b2[100005],maxx;
4
int main(){
5
  cin>>t;
6
  for(int z=1;z<=t;z++){
7
    cin>>n;
8
    maxx=-1;
9
    for(int i=1;i<=n;i++){
10
      cin>>a[i];
11
      maxx=max(maxx,a[i]);
12
    }
13
    for(int i=1;i<=n;i++){
14
      b1[i]=a[i]%(maxx+1);
15
      if(maxx!=0) b2[i]=a[i]%maxx;//防止对0取余时报错
16
    }
17
    sort(b1+1,b1+n+1);//可改为打擂台找最值
18
    sort(b2+1,b2+n+1);;//可改为打擂台找最值
19
    cout<<max(b1[n]-b1[1],b2[n]-b2[1])<<endl;
20
  }
21
  return 0;
22
}

展开收起