Noip模拟16 2021.7.15

题目真是越来越变态了

T1 Star Way To Heaven

首先，你要看出这是一个最小生成树的题（妙吧？）

为什么可以呢？

我们发现从两点连线的中点过是最优的，但是上下边界怎么办呢？

我们把上下边界看作两个点，每个点和它都连边，这样就可以跑最小生成树了

然而不能用kruskar，多一个$log$就会炸列

只能选用$prim$算法$n^2$已经是最优秀的了

找到生成树里面最大的边/2即可

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 inline int read(){
 4     int x=0,f=1; char ch=getchar();
 5     while(ch<'0'||ch>'9'){ if(ch=='-') f=-1; ch=getchar(); }
 6     while(ch>='0'&&ch<='9'){ x=(x<<1)+(x<<3)+(ch^48); ch=getchar(); }
 7     return x*f;
 8 }
 9 const int NN=6005,inf=0x7fffffff;
10 int n,m,k,x[NN],y[NN];
11 double d[NN];
12 inline double dis(double x1,double y1,double x2,double y2){
13     return sqrt(fabs(x2-x1)*fabs(x2-x1)+fabs(y2-y1)*fabs(y2-y1));
14 }
15 namespace WSN{
16     inline int main(){
17         n=read(); m=read(); k=read();
18         double maxn=0;
19         for(int i=1;i<=k;i++){
20             x[i]=read(); y[i]=read();
21         }
22         for(int i=1;i<=k;i++) d[i]=y[i];
23         d[k+1]=m;
24         while(1){
25             double minn=inf; int v;
26             for(int j=1;j<=k+1;j++)
27                 if(d[j]<minn && d[j]){
28                     minn=d[j];
29                     v=j;
30                 }
31             maxn=max(maxn,d[v]); d[v]=0;
32             if(v==k+1){
33                 printf("%.8lf\n",(double)maxn/2);
34                 return 0;
35             }
36             for(int j=1;j<=k;j++){
37                 double D=dis(x[j],y[j],x[v],y[v]);
38                 if(d[j]>D) d[j]=D;
39             }
40             d[k+1]=min(d[k+1],(double)m-y[v]);
41         }
42         return 0;
43     }
44 }
45 signed main(){return WSN::main();}

T2 God Knows

好吧，这题skyh大佬都写了一堆而且放上了代码。

首先考虑$n^2$的转移柿子，比较像友好城市：

设$dp_i$表示已经处理到的边。

$dp[i]=\min \limits_{j<i,p[j]<p[i],\forall k,j<k<i,p[k]<p[j]或p[k]>p[i]}dp[j]+c[i]$

这样我们可以先处理出可能为起点的点，然后找与其不相交的点进行转移。

 1 #include<bits/stdc++.h>
 2 #define lid (id<<1)
 3 #define rid (id<<1|1)
 4 using namespace std;
 5 inline int min(int a,int b){return a<b?a:b;}
 6 inline int max(int a,int b){return a>b?a:b;}
 7 inline void swap(int &a,int &b){a^=b^=a^=b;}
 8 inline int read(){
 9     int x=0,f=1; char ch=getchar();
10     while(ch<'0'||ch>'9'){ if(ch=='-') f=-1; ch=getchar(); }
11     while(ch>='0'&&ch<='9'){ x=(x<<1)+(x<<3)+(ch^48); ch=getchar(); }
12     return x*f;
13 }
14 const int NN=5e5+5,inf=0x7fffffff;
15 int n,p[NN],c[NN],dp[NN];
16 namespace WSN{
17     inline int main(){
18         n=read();
19         memset(dp,0x3f,sizeof(dp));
20         for(int i=1;i<=n;i++) p[i]=read();
21         for(int i=1;i<=n;i++) c[i]=read();
22         int las=inf;
23         for(int i=1;i<=n;i++)
24             if(las>p[i]){
25                 las=p[i];
26                 dp[i]=c[i];
27             }
28         for(int i=2;i<=n;i++){
29             int las=0;
30             for(int j=i-1;j>=1;j--)
31                 if(p[j]<p[i]&& las<p[j]){
32                     dp[i]=min(dp[i],dp[j]+c[i]);
33                     las=p[j];
34                 }
35         }
36         las=0;int ans=inf;
37         for(int i=n;i>=1;i--){
38             if(las<p[i]){
39                 las=p[i];
40                 ans=min(ans,dp[i]);
41             }
42         }
43         printf("%d\n",ans);
44         return 0;
45     }
46 }
47 signed main(){return WSN::main();}

然后考虑正解，参考skyh大佬的做法

转化题目含义就是求极长上升子序列的最小权值。

需要考虑维护一个单调栈，然而他又需要用线段树进行维护，这样

我们把这题叫做线段树维护单调栈优化dp 确实比较优秀。。

这样我们就可以在$log$的复杂度优化一层循环，总复杂度为$O(nlogn)$

 1 #include<bits/stdc++.h>
 2 #define lid (id<<1)
 3 #define rid (id<<1|1)
 4 using namespace std;
 5 inline int min(int a,int b){return a<b?a:b;}
 6 inline int max(int a,int b){return a>b?a:b;}
 7 inline void swap(int &a,int &b){a^=b^=a^=b;}
 8 inline int read(){
 9     int x=0,f=1; char ch=getchar();
10     while(ch<'0'||ch>'9'){ if(ch=='-') f=-1; ch=getchar(); }
11     while(ch>='0'&&ch<='9'){ x=(x<<1)+(x<<3)+(ch^48); ch=getchar(); }
12     return x*f;
13 }
14 const int NN=5e5+5,inf=0x7fffffff;
15 int n,p[NN],c[NN],t;
16 struct SNOWtree{
17     int ll[NN<<2],rr[NN<<2];
18     int down[NN<<2],minn[NN<<2],upmin[NN<<2];//站底元素 站内最小元素 更新后站内最小元素
19     void build(int id,int l,int r){
20         ll[id]=l; rr[id]=r;
21         down[id]=-1; minn[id]=upmin[id]=inf;
22         if(l==r) return;
23         int mid=(l+r)>>1;
24         build(lid,l,mid); build(rid,mid+1,r);
25     }
26     int calc(int id,int it){
27         if(ll[id]==rr[id]) return down[id]>it? minn[id]:inf;
28         if(down[rid]>it) return min(upmin[lid],calc(rid,it));
29         return calc(lid,it);
30     }
31     int query(int id,int l,int r){
32         if(l<=ll[id]&&rr[id]<=r){
33             int ans=calc(id,t);
34             t=max(down[id],t);
35             return ans;
36         }
37         int ans=inf;
38         if(r>=ll[rid]) ans=min(ans,query(rid,l,r));//询问时先找右侧
39         if(l<=rr[lid]) ans=min(ans,query(lid,l,r));
40         return ans;
41     }
42     void insert(int id,int pos,int tail,int val){
43         if(ll[id]==rr[id]){
44             minn[id]=val;
45             down[id]=tail;
46             return;
47         }
48         if(pos<=rr[lid]) insert(lid,pos,tail,val);
49         else insert(rid,pos,tail,val);
50         down[id]=max(down[lid],down[rid]);
51         minn[id]=min(minn[rid],upmin[lid]=calc(lid,down[rid]));
52     }
53 }tr;
54 namespace WSN{
55     inline int main(){
56         // freopen("1.in","r",stdin);
57         n=read();
58         for(int i=1;i<=n;i++) p[i]=read();
59         for(int i=1;i<=n;i++) c[i]=read();
60         ++n; p[n]=n;
61         tr.build(1,0,n);tr.insert(1,0,0,0);//建立原始节点作为起点（0）与终点（n+1），这样不必再找到每种可能的起点
62         for(int i=1;i<=n;i++){
63             t=-1; //每次更新t值，延伸出一条链进行查找
64             int wsn=tr.query(1,0,p[i]-1)+c[i];//更新并查找p[i]之前的信息
65             tr.insert(1,p[i],i,wsn);//对p[i]的信息加入
66             if(i==n) printf("%d\n",wsn);
67         }
68         return 0;
69     }
70 }
71 signed main(){return WSN::main();}

带注释

T3 Lost My Music

比较轻松的打完暴力，预估20，结果50。。

惊喜

正解竟是斜率维护凸包。。。。

先推一个大佬的斜率优化dp笔记

我们看到这个柿子跟题目问的很相似啊。。

不就是取个负数吗

扫它纳，我们用可持久化栈维护一个下凸包，其斜率递增，那么我们就找到需要查的点与已经查到的点连线中斜率最大的即为答案

也就是凸包切线。

我们记录$ant_{i,j}$为i的第$2^j$级祖先，直接倍增找到最优值记录答案就可以了。

原本应该每次找完暴力弹栈再加上回溯所有要用的儿子，然而这种暴力弹栈操作会被菊花图卡掉变成$n^2$

所以应用倍增思想

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 inline int read(){
 4     int x=0,f=1; char ch=getchar();
 5     while(ch<'0'||ch>'9'){ if(ch=='-') f=-1; ch=getchar(); }
 6     while(ch>='0'&&ch<='9'){ x=(x<<1)+(x<<3)+(ch^48); ch=getchar(); }
 7     return x*f;
 8 }
 9 const int NN=505000;
10 int n,c[NN],fa[NN],dis[NN];
11 int q[NN],ant[NN][22];
12 double ans[NN];
13 struct SNOW{int to,next;};SNOW e[NN]; int head[NN],rp;
14 inline double calc(int x,int y){return (double)(c[x]-c[y])/(dis[y]-dis[x]);}//先是祖先，后是子孙
15 inline void add(int x,int y){e[++rp]=(SNOW){y,head[x]}; head[x]=rp;}
16 inline void dque(int p){
17     int fp=fa[p];
18     for(int i=20;i>=0;i--)
19         if(ant[ant[fp][i]][0] && calc(ant[ant[fp][i]][0],ant[fp][i])<calc(ant[fp][i],p))
20             fp=ant[ant[fp][i]][0];
21     if(ant[fp][0] && calc(ant[fp][0],fp)<calc(fp,p)) fp=ant[fp][0];
22     ant[p][0]=fp; ans[p]=calc(ant[p][0],p);
23     for(int i=1;i<=20;i++) ant[p][i]=ant[ant[p][i-1]][i-1];
24 }
25 namespace WSN{
26     inline int main(){
27         n=read(); q[1]=1;
28         for(int i=1;i<=n;i++) c[i]=read();
29         for(int i=2;i<=n;i++){int f=read();add(f,i); fa[i]=f;}
30         for(int h=1,t=1;h<=t;h++){
31             dis[q[h]]=dis[fa[q[h]]]+1;
32             dque(q[h]);
33             for(int i=head[q[h]];i;i=e[i].next) q[++t]=e[i].to;
34         }
35         for(int i=2;i<=n;i++) printf("%.8lf\n",ans[i]);
36         return 0;
37     }
38 }
39 signed main(){return WSN::main();}