NOIP2018 解题报告
NOIP2018 解题报告
前记
在本届noip，作为第一年参加提高组的我，感受到了各位大佬神仙恐怖如斯的实力。身在弱省，但是依旧难以取得成绩，果然oi赛场，菜是原罪
好了，到了赛后，还是总结一下题目，重整旗鼓才是
D1T1 铺设道路
题目：
春春是一名道路工程师，负责铺设一条长度为 n 的道路。
铺设道路的主要工作是填平下陷的地表。整段道路可以看作是 n 块首尾相连的区域，一开始，第 i 块区域下陷的深度为 d[i].
春春每天可以选择一段连续区间 [L,R] ,填充这段区间中的每块区域，让其下陷深度减少 1。在选择区间时，需要保证，区间内的每块区域在填充前下陷深度均不为 0 。
春春希望你能帮他设计一种方案，可以在最短的时间内将整段道路的下陷深度都变为 0 .
好好说话：
就是说给你一个数列，a1,a2...an, 要求每一次操作可以使一段连续的数字减少1，询问到所有数字变成0，最少需要操作多少次？
解题：
初看到题，不禁窃喜一阵，“嘿，今年noip肯定不会爆零了”。因为这道题竟然是2013年的noip原题“积木大赛”的平行世界，而且清清楚楚的记得是在和高二训练时，训练赛上一道我当时就已经ac了的题。
思路非常简单，甚至谈不上是贪心：假如对于当前状态存在一段连续且极大的正整数(从l到r)，那么这次操作一定就是将l到r的所有数字减少1,操作次数+1.
然后，运用分治的思想，每次从头到尾找到一段连续的正整数，即可以最优策略的一步。处理之后，递归处理两侧即可。细节也比较简单。
震惊，洛谷竟然直接将铺设道路的标签加上了“2013年noip”
代码如下：
#include <cstdio>
const int MAX=1e5+5;
int n,ans;
int road[MAX];
void finds(int,int);
int main(){
//freopen("test.in","r",stdin);
//freopen("test.out","w",stdout);
scanf("%d",&n);
for(int i=1;i<=n;++i) scanf("%d",&road[i]);
finds(1,n);
printf("%d",ans);
return 0;
}
void finds(int l,int r){
if(l>r) return;
int rec,mid=0x3f3f3f3f;
for(int i=l;i<=r;++i){
if(road[i]<mid){
mid=road[i];
rec=i;
}
}
for(int i=l;i<=r;++i) road[i]-=mid;
ans+=mid;
finds(l,rec-1); finds(rec+1,r);
}
D1T2 货币系统
题目：
在网友的国度中共有 n 种不同面额的货币，第 i 种货币的面额为 a[i]，你可以假设每一种货币都有无穷多张。为了方便，我们把货币种数为 n、面额数组为 a[1..n] 的货币系统记作 (n,a)。
在一个完善的货币系统中，每一个非负整数的金额 x 都应该可以被表示出，即对每一个非负整数 x，都存在 n 个非负整数 t[i] 满足 a[i]×t[i] 的和为 x。然而， 在网友的国度中，货币系统可能是不完善的，即可能存在金额 x 不能被该货币系统表示出。例如在货币系统 n=3, a=[2,5,9] 中，金额 1,3 就无法被表示出来。
两个货币系统 (n,a) 和 (m,b) 是等价的，当且仅当对于任意非负整数 x，它要么均可以被两个货币系统表出，要么不能被其中任何一个表出。
现在网友们打算简化一下货币系统。他们希望找到一个货币系统 (m,b)，满足 (m,b) 与原来的货币系统 (n,a) 等价，且 m 尽可能的小。他们希望你来协助完成这个艰巨的任务：找到最小的 m
好好说话：
给你一些正整数，要求若一个数字可以由数字乘以特定的系数表示出来（\(m=\sum_{i=1}^{all num} k_i\times a_i\)）,那么这个数字就应该被剔除。求剩下的数字个数。
题解：
第一眼看，有点执着于“唯一分解定理”
但是，其实这道题只要推一推样例就会恍然大悟。一推样例，就会猛地发现，不论给出什么样的数据，正整数中最小的那一个一定无法被代替。接着，便可以联想到，将这些正整数排序，越小的数字越不容易被别的数字替代，越大的数字越容易被替代。
至此，这道题的贪心思路已经出来了。我们只需要排一遍序，从小到大用背包判断每一个数能否被前面的数字替代即可
然而，考场上我竟然就是忘记了背包，竟然用了dfs暴力遍历所有种可能性？果然士别三日，就更能发觉三日前的沙雕
代码如下：
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAX=105;
int t,n;
int coin[MAX];
bool vis[25005];
int read();
int main(){
//freopen("test.in","r",stdin);
//freopen("test.out","w",stdout);
t=read();
for(;t;--t){
n=read(); for(int i=1;i<=n;++i) coin[i]=read();
sort(coin+1,coin+1+n);
memset(vis,false,sizeof(vis));
vis[0]=true;
int ans=0;
for(int i=1;i<=n;++i){
if(vis[coin[i]]==false){
ans++;
for(int j=0;j<=25000-coin[i];++j){
if(vis[j]) vis[j+coin[i]]=true;
}
}
}
printf("%d\n",ans);
}
return 0;
}
int read(){
char tmp=getchar(); int sum=0;
while(tmp<'0'||tmp>'9') tmp=getchar();
while(tmp>='0'&&tmp<='9'){
sum=sum*10+tmp-'0';
tmp=getchar();
}
return sum;
}
D1T3 旅行
题目如下：
小 Y 是一个爱好旅行的 OIer。她来到 X 国，打算将各个城市都玩一遍。
小Y了解到， X国的 n 个城市之间有 m 条双向道路。每条双向道路连接两个城市。 不存在两条连接同一对城市的道路，也不存在一条连接一个城市和它本身的道路。并且， 从任意一个城市出发，通过这些道路都可以到达任意一个其他城市。小 Y 只能通过这些 道路从一个城市前往另一个城市。
小 Y 的旅行方案是这样的：任意选定一个城市作为起点，然后从起点开始，每次可 以选择一条与当前城市相连的道路，走向一个没有去过的城市，或者沿着第一次访问该 城市时经过的道路后退到上一个城市。当小 Y 回到起点时，她可以选择结束这次旅行或 继续旅行。需要注意的是，小 Y 要求在旅行方案中，每个城市都被访问到。
为了让自己的旅行更有意义，小 Y 决定在每到达一个新的城市（包括起点）时，将 它的编号记录下来。她知道这样会形成一个长度为 n 的序列。她希望这个序列的字典序 最小，你能帮帮她吗？ 对于两个长度均为 n 的序列 A 和 B，当且仅当存在一个正整数 x，满足以下条件时， 我们说序列 A 的字典序小于 B。
·对于任意正整数 1≤i<x，序列 A 的第 i 个元素 \(a_i\)和序列 B 的第 i 个元素 \(b_i\) 相同。
·序列 A 的第 x 个元素的值小于序列 B 的第 x 个元素的值。
好好说话：
给出一个树或者是基环树，让你找出最小的dfs序。对于基环树，则可以进行“反悔”操作，即可以从环的左右两边分别走，而不必必须从某一边入，然后完整的走一个环
题解：
还原赛场思路。“哦，60%是树。嗯，dfs一遍就ok”，心中已是窃喜不已。
接着，“嗯？为什么剩下的数据在树的基础上格外给了一条边？那是什么？”......于是，深陷沉思中，再也得出什么有用的结论
现在，我已经知道了，树上加上一条边即构成了基环树，那么该怎么解决呢。
考虑如下的事实：每走一条没有访问过的边，必定会走向一个没有访问过的点（嗯，基环树上好像并不是如此，但是接着看下去），所以想要n个点的dfs序，最少只需要走n-1条为访问过的边，而在这些由走n-1条推出的答案中，必定含有本数据的最优解。（显然嘛，最优解怎么会没有事，到处闲逛，它不会再由为访问过的边访问一次已访问过的点，这么做没意义）
所以我们可以暴力断边，每次都枚举断的那一条边，然后跑一遍dfs即可
但是！这个\(n^2\)的算法并不是最优秀的。还存在一个更厉害的\(n \log n\)的算法：
考虑一下什么时候我们可以反悔？
1.一定是在环上，否则子树的点将永远再也访问不到
2.回溯后的点，一定要小于由当前的访问到的最小的点的点权。否则回溯过去之后，dfs序并不会得到优化。
嗯，主要思路就这么多。模拟一下思路，用代码展示出来，就是这道题的另外一种解法。
补充一点，需要提前跑一遍dfs，判断出环的根节点rt，在环上且紧邻rt的两个节点中，较小的u1和较大的u2
代码如下：
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <ctime>
using namespace std;
const int MAX=5e3+5;
int n,m;
int ecnt,edge[MAX<<1],head[MAX],nxt[MAX<<1],vis[MAX];
int ban[MAX<<1],cur;
int ans[MAX],vis1[MAX],vis2[MAX];
int rt,u1,u2;
clock_t s,e;
vector <int> edg[MAX];
int read();
void insert(int,int,int);
void dfs1(int,int);
void dfs2(int,int);
int getnxt(int,int);
void dfs3(int,int);
void dfs4(int,int,int);
int read();
int main(){
//freopen("test.in","r",stdin);
//freopen("test.out","w",stdout);
n=read(); m=read();
for(register int i=1;i<=m;++i){
int u,v; u=read(); v=read();
ban[++ecnt]=u; ban[++ecnt]=v;
edg[u].push_back(v);
edg[v].push_back(u);
}
for(register int i=1;i<=n;++i) sort(edg[i].begin(),edg[i].end());
if(n==m+1){
dfs1(1,1);
return 0;
}
else{
// for(register int i=1;i<=n;++i){
// ++cur;
// for(register int j=1;j<=n;++j) vis[j]=false;
// dfs2(1,1);
// bool flag=false;
// if(ans[i][0]!=n){
// continue;
// }
// if(ans[0][0]!=n){
// for(register int j=0;j<=ans[cur][0];++j) ans[0][j]=ans[i][j];
// continue;
// }
// for(register int j=1;j<=n;++j){
// if(ans[0][j]<ans[i][j]){
// flag=true;
// break;
// }
// if(ans[0][j]>ans[i][j]) break;
// }
// if(flag) continue;
// for(register int j=0;j<=ans[cur][0];++j) ans[0][j]=ans[cur][j];
// }
// for(register int i=1;i<=n;++i) printf("%d ",ans[0][i]);
dfs3(1,0); dfs4(1,0,0);
for(int i=1;i<=n;++i) printf("%d ",ans[i]);
}
return 0;
}
int read(){
char tmp=getchar(); int sum=0; bool flag=false;
while(tmp<'0'||tmp>'9'){
if(tmp=='-') flag=true;
tmp=getchar();
}
while(tmp>='0'&&tmp<='9'){
sum=sum*10+tmp-'0';
tmp=getchar();
}
return flag?-sum:sum;
}
void insert(int from,int to,int id){
edge[id]=to; nxt[id]=head[from]; head[from]=id;
}
void dfs1(int u,int f){
printf("%d ",u);
vis[u]=true;
for(int i=0;i<edg[u].size();++i){
int v=edg[u][i];
if(!vis[v]){
dfs1(v,u);
}
}
}
void dfs2(int u,int f){
// ans[cur][++ans[cur][0]]=u;
vis[u]=true;
int ban1=ban[(cur<<1)-1],ban2=ban[(cur<<1)];
// for(int i=0;i<edg[u].size();++i){
// int v=edg[u][i];
// if(u==ban1&&v==ban2||u==ban2&&v==ban1) continue;
// if(!vis[v]){
// dfs2(v,u);
// }
// }
if(u==ban1){
for(int i=0;i<edg[u].size();++i){
int v=edg[u][i];
if(v==ban2) continue;
if(!vis[v]){
dfs2(v,u);
}
}
}
if(u==ban2){
for(int i=0;i<edg[u].size();++i){
int v=edg[u][i];
if(v==ban1) continue;
if(!vis[v]){
dfs2(v,u);
}
}
}
else{
for(int i=0;i<edg[u].size();++i){
int v=edg[u][i];
if(!vis[v]){
dfs2(v,u);
}
}
}
}
int getnxt(int i,int j){
while(++j,j<edg[i].size()&&vis2[edg[i][j]]);
if(j<edg[i].size()) return j;
else return 0;
}
void dfs3(int u,int f){
vis1[u]=1;
for(int i=0;i<edg[u].size();++i){
int v=edg[u][i]; if(v==f) continue;
if(!rt&&vis1[v]){
vis1[u]=2; rt=v; u2=u;
}
else if(!vis1[v]) dfs3(v,u);
if(vis1[v]==2&&v!=rt){
vis1[u]=2;
if(!u1&&u==rt) u1=v;
}
}
}
void dfs4(int u,int f,int mx){
ans[++ans[0]]=u;
vis2[u]=1;
for(int i=0;i<edg[u].size();++i){
int v=edg[u][i]; if(v==f||vis2[v]) continue;
int nx=getnxt(u,i);
if(mx&&!nx&&vis1[u]==2&&vis1[v]==2&&!vis2[u2]&&v>mx) return;
if(u==rt&&v==u1){
dfs4(v,u,edg[u][nx]);
}
else{
dfs4(v,u,mx?(nx?edg[u][nx]:mx):0);
}
}
}
D2T1 赛道修建
题目：
C 城将要举办一系列的赛车比赛。在比赛前，需要在城内修建 mm 条赛道。
C 城一共有 n 个路口，这些路口编号为 1,2,…,n，有 n−1 条适合于修建赛道的双向通行的道路，每条道路连接着两个路口。其中，第 i 条道路连接的两个路口编号为 \(a_i\)和\(b_i\)，该道路的长度为 \(l_i\)。借助这 n-1n−1 条道路，从任何一个路口出发都能到达其他所有的路口。
一条赛道是一组互不相同的道路 \(e_1,e_2,...,e_k\)，满足可以从某个路口出发，依次经过 道路 \(e_1,e_2,...,e_k\)（每条道路经过一次，不允许调头）到达另一个路口。一条赛道的长度等于经过的各道路的长度之和。为保证安全，要求每条道路至多被一条赛道经过。
目前赛道修建的方案尚未确定。你的任务是设计一种赛道修建的方案，使得修建的 m 条赛道中长度最小的赛道长度最大（即 m 条赛道中最短赛道的长度尽可能大）
好好说话：
说实话，感觉题目挺明了的，就不解释了
题解：
一看,"求最小值的最大值"，十有八九是二分答案
二分答案很重要的部分就是判断当前答案是否可性。由于已经二分\(\log n\)了，所以可以完整的跑一遍dp，不用担心超时。
那么dp怎么处理？设\(f_k\)表示以k节点为根的子树可以为k的父节点提供的最大长度。因为到点i，能组成经过点i的赛道必定不会超过两条。（赛道不可以掉头，一条道只能被一条赛道使用），所以可以考虑将\(f_k|k\in son of k\)两两配对，要求最小的要配对和可以大于等于二分值且最小的那一个边，原理也是不言而喻的。
那有没有可能其实当前的链不应该配对，而是应该留着给上面使用的？
答案是不会的，当前的链不论如何，只会为答案贡献1，不论所处何处。
确定思路之后，引入了multiset这个完美适用于这个情况的STL（虽然说我本人比较抵制使用STL，但是考试时间就是生命，真像）
multiset是set的一种“类型”，即支持重复元素的set，总结一下其用法
.insert(),即简单的插入一个数字
.size(),即当前multiset中剩余的元素个数
.empty(),即当前multiset是否为空
.erase(i),去掉所有大小为i的元素
.find(i),返回一个大小为i的位置指针
.lower_bound(i),返回一个大于等于i的元素位置指针
multiset<int>::iterator 即multiset位置指针的命名方式
代码如下：
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <set>
using namespace std;
const int MAX=5e4+5;
int n,m;
int edge[MAX<<1],head[MAX],nxt[MAX<<1],w[MAX<<1],upper_dis;
int dis[MAX];
int limit,cnt,f[MAX];
int read();
void insert(int,int,int,int);
void getdis();
void maxlength(int,int,int);
bool check();
int dfs(int,int);
int binary(int,int,int,int);
multiset <int> son[MAX];
int main(){
//freopen("test.in","r",stdin);
n=read(); m=read();
for(int i=1;i<n;++i){
int u,v,w; u=read(); v=read(); w=read();
insert(u,v,w,(i<<1)-1); insert(v,u,w,(i<<1));
}
getdis();
// cout<<upper_dis<<endl;
int l=0,r=upper_dis;
while(l<=r){
int mid=(l+r)>>1;
limit=mid;
if(check()) l=mid+1;
else r=mid-1;
}
printf("%d",r);
return 0;
}
int read(){
char tmp=getchar(); int sum=0; bool flag=false;
while(tmp<'0'||tmp>'9'){
if(tmp=='-') flag=true;
tmp=getchar();
}
while(tmp>='0'&&tmp<='9'){
sum=(sum<<3)+(sum<<1)+tmp-'0';
tmp=getchar();
}
return flag?-sum:sum;
}
void insert(int from,int to,int wei,int id){
edge[id]=to; nxt[id]=head[from]; head[from]=id; w[id]=wei;
}
void getdis(){
maxlength(1,1,0);
int top=0,cur;
for(int i=1;i<=n;++i){
if(top<dis[i]){
top=dis[i]; cur=i;
}
}
dis[cur]=0;
maxlength(cur,cur,0);
int tar; top=0;
for(int i=1;i<=n;++i){
if(top<dis[i]){
top=dis[i]; tar=i;
}
}
upper_dis=dis[tar];
}
void maxlength(int u,int f,int d){
dis[u]=d;
int n,top=0;
for(int i=head[u];i;i=nxt[i]){
int v=edge[i]; if(v==f) continue;
maxlength(v,u,d+w[i]);
}
}
bool check(){
cnt=0;
dfs(1,1);
if(cnt>=m) return true;
else return false;
}
int dfs(int u,int fa){
son[u].clear();
for(int i=head[u];i;i=nxt[i]){
int v=edge[i]; if(v==fa) continue;
int tmp=dfs(v,u)+w[i];
if(tmp>=limit) cnt++;
else son[u].insert(tmp);
}
int l,r; l=0; r=son[u].size()-1;
int mx=0;
while(!son[u].empty()){
if(son[u].size()==1){
return max(mx,*son[u].begin());
}
multiset<int>::iterator it=son[u].lower_bound(limit-*son[u].begin());
if(it==son[u].begin()&&son[u].count(*it)==1) it++;
if(it==son[u].end()){
mx=max(mx,*son[u].begin());
son[u].erase(son[u].find(*son[u].begin()));
}
else{
cnt++;
son[u].erase(son[u].find(*it));
son[u].erase(son[u].find(*son[u].begin()));
}
}
return mx;
}
int binary(int u,int l,int r,int tar){
// while(l<=r){
// int mid=(l+r)<<1;
// if(son[u][mid]>=tar) r=mid-1;
// else l=mid+1;
// }
// return l;
}
~~
## 未完待续
可能永远也不会完结了`(*>﹏<*)′
太难了~~ 学了这么多，当年的noip还是题解最香