5.30 NOI 模拟
作者：互联网
$5.30\ NOI $模拟
高三大哥最后一次模拟考了,祝他们好运
\(T1\)装箱游戏
显然可以将四种字母之间的空缺当做状态枚举
那么这道题就很显然了
#include<bits/stdc++.h>
#define MAXN 305
using namespace std;
int n;
double f[4][MAXN][MAXN][MAXN],a,b,c,d;
bool fl[4][MAXN][MAXN][MAXN];
double dp(int op,int x,int y,int z)
{
if(x<0||y<0||z<0) return 0;
if(x==0&&y==0&&z==0) return 1;
if(fl[op][x][y][z]!=0) return f[op][x][y][z];
fl[op][x][y][z]=1;
//op记录的是目前是第几种转移的
//op==0 只有AD
//op==1 ABD
//op==2 ACD
//op==3 ABCD
//我们把x,y,z分别表示第几个空缺会比较好
if(op==0)
{
double s1=dp(op,x-1,y,z);
double s2=0,s3=0,s4;
for(int i=0;i<x;i++)
{
s2=max(s2,dp(1,i,x-i-1,0));
s3=max(s3,dp(2,i,x-i-1,0));
}
s4=dp(op,x-1,y,z);
f[op][x][y][z]=s1*a+s2*b+s3*c+s4*d;
}
else if(op==1)
{
double s1=dp(op,x-1,y,z);
double s2=max(dp(op,x-1,y,z),dp(op,x,y-1,z));
double s3=0;
double s4=dp(op,x,y-1,z);
for(int i=1;i<=y;i++)
{
s3=max(s3,dp(3,x,y-i,i-1));
}
f[op][x][y][z]=s1*a+s2*b+s3*c+s4*d;
}
else if(op==2)
{
double s1=dp(op,x-1,y,z);
double s2=0;
double s3=max(dp(op,x-1,y,z),dp(op,x,y-1,z));
double s4=dp(op,x,y-1,z);
for(int i=1;i<=x;i++)
{
s2=max(s2,dp(3,i-1,x-i,y));
}
f[op][x][y][z]=s1*a+s2*b+s3*c+s4*d;
}
else
{
double s1=dp(op,x-1,y,z);
double s2=max(dp(op,x-1,y,z),dp(op,x,y-1,z));
double s3=max(dp(op,x,y-1,z),dp(op,x,y,z-1));
double s4=dp(op,x,y,z-1);
f[op][x][y][z]=s1*a+s2*b+s3*c+s4*d;
}
return f[op][x][y][z];
}
int main()
{
scanf("%lld%lf%lf%lf%lf",&n,&a,&b,&c,&d);
a/=100.0;b/=100.0;c/=100.0;d/=100.0;
printf("%.6f\n",dp(0,n,0,0));
}
\(T2\)库图鲁
考场上猜到了结论,最后的策略必然是走一段路然后到了一个终点停止,证明比较显然
然后暴力可以枚举最终点然后模拟,可获得\(30pts\)
发现不虑中间移动的过程,如果这个\(monster\)可以达到最终点,那么就需要统计贡献,否则不需要
证明的话:考虑相遇的充要条件,同一时刻位于同一点,我们既然保证了相遇,那么我们就可以同步移动到终点,那么相遇问题可以转化为到达问题
问题成功转化为,树上其他点到树上一个点的贡献和,然后可以使用点分治
首先\(u\neq v,val_{v\rightarrow u}=a_v(\lfloor\frac{h-max(d,1)}{k}\rfloor+1)\)
就是考虑有多少个完整的轮数可以到达,\(h\)是总时间,减去距离证明在这一段时间可以到,然后判断有多少个起点即可
比较套路的,考虑\(d_{u\rightarrow v}=dep_u+dep_c-2\times dep_{lca}\)
假设\(lca_{u,v}=rt,rt\)为当前分治位于的根
\(val_{v\rightarrow u}=a_v(\lfloor\frac{h-(dep_u+dep_v-2\times lca)}{k}\rfloor+1)\)
\(val_{v\rightarrow u}=a_v(\lfloor\frac{h-(dep_u+dep_v)}{k}-\frac{2\times dep_{lca}}{k}\rfloor+1),dep_{lca}=0 ...\)
\(val_{v\rightarrow u}=a_v(\lfloor\frac{h-(dep_u+dep_v)}{k}\rfloor+1)\)
然后发现这个向下取整很寄
然后继续拆
\(val_{v\rightarrow u}=a_v(\lfloor\frac{(h-dep_u)-dep_v}{k}\rfloor+1)\)
考虑我们这个东西,维护一下模数相等的部分乘一下就好了
我们需要先把子树内的删掉,然后计算外面的贡献,很神仙
然后贡献的话,可以考虑全部插入一个线段树里面,然后最后查询一遍即可
#include<bits/stdc++.h>
#define int long long
#define mid ((l+r)>>1)
#define P make_pair
using namespace std;
int n,k,h,q[1000001],val[100001],res=100000000000000000ll;
int ans[1000001];
vector<int>road[1000001];
int vis[1000001],siz[1000001],maxn[1000001],root;
int read(){
int a=0,b=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&(ch!='-')){
ch=getchar();
}
if(ch=='-'){
b=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
a=a*10+ch-'0';
ch=getchar();
}
return a*b;
}
struct tree{
int rt,tr[2000001],son[2000001][2],cnt,num[2000001];
void clear()
{
for(int i=1;i<=cnt;++i) tr[i]=son[i][0]=son[i][1]=num[i]=0;
cnt=rt=0;
return ;
}
void add(int &x,int l,int r,int p,int v)
{
if(r<p||p<l) return ;
if(!x) x=++cnt;
num[x]+=v,tr[x]+=p*v;
if(l==r) return;
add(son[x][0],l,mid,p,v);
add(son[x][1],mid+1,r,p,v);
}
int query(int x,int l,int r,int v)
{
if(l>v) return num[x]*(v+k)-tr[x];
if(r<=v) return num[x]*v-tr[x];
return query(son[x][0],l,mid,v)+query(son[x][1],mid+1,r,v);
}
}T;
void get_root(int x,int f,int alls)
{
siz[x]=1; maxn[x]=0;
for(int i=0;i<road[x].size();++i)
{
if(road[x][i]==f||vis[road[x][i]]) continue;
get_root(road[x][i],x,alls);
maxn[x]=max(maxn[x],siz[road[x][i]]);
siz[x]+=siz[road[x][i]];
}
maxn[x]=max(maxn[x],alls-siz[x]);
if(maxn[x]<=maxn[root]) root=x;
}
int poi[1000001],lons[1000001],son[1000001],cnt;
pair<int,int> ques[1000001];
void find_roads(int x,int f,int v,int sy)
{
++cnt;
poi[cnt]=x;lons[x]=v;//深度
ques[cnt]=P(h-lons[x],x);//我们这个询问要询问
//维护式子的前一半,(h-dep[x])-dep[y]
for(int i=0;i<road[x].size();++i)
{
if(road[x][i]==f||vis[road[x][i]]) continue;
find_roads(road[x][i],x,v+1,sy);
}
}
bool comp(int a,int b)
{
return lons[a]<lons[b];
}
void get_ans(int x)
{
cnt=0;
poi[++cnt]=x;
//把能到的点全部扫一遍
//我们目前统计的都是跨过根的贡献
lons[x]=0;//dep
ques[cnt]=P(h-lons[x],x);
//询问
for(int i=0;i<road[x].size();++i)
{
if(!vis[road[x][i]])
{
int lst=cnt;
//找到这个子树的范围
find_roads(road[x][i],x,1,road[x][i]);
sort(poi+lst+1,poi+cnt+1,comp);
sort(ques+lst+1,ques+cnt+1);
T.clear();
int posr=lst+1,posl=lst+1,sum=0,valsum=0;
for(int j=lst+1;j<=cnt;++j)
{
int q=ques[j].first;
if(q<0) continue;
while(posr<=cnt&&lons[poi[posr]]<=q)
{
T.add(T.rt,0,k,lons[poi[posr]]%k,val[poi[posr]]);
sum+=-lons[poi[posr]]*val[poi[posr]];
valsum+=val[poi[posr]];
++posr;
}
ans[ques[j].second]-=((q*valsum+sum-T.query(T.rt,0,k,q%k))/k+valsum);
}
}
}
T.clear();
sort(poi+1,poi+1+cnt,comp);
sort(ques+1,ques+cnt+1);
int posr=1,posl=1,sum=0,valsum=0;
for(int j=1;j<=cnt;++j)
{
int q=ques[j].first;
if(q<0) continue;
while(posr<=cnt&&lons[poi[posr]]<=q)
{
T.add(T.rt,0,k,lons[poi[posr]]%k,val[poi[posr]]);
sum+=-lons[poi[posr]]*val[poi[posr]];
valsum+=val[poi[posr]];
++posr;
}
ans[ques[j].second]+=((q*valsum+sum-T.query(T.rt,0,k,q%k))/k+valsum);
}
}
void solve(int x)
{
vis[x]=true;
get_ans(x);
for(int i=0;i<road[x].size();++i)
{
if(!vis[road[x][i]])
{
root=0;
get_root(road[x][i],x,siz[road[x][i]]);
solve(root);
}
}
}
void dfs_ans(int x,int f,int v)
{
if(v>h) return ;
for(int i=0;i<road[x].size();++i) if(road[x][i]!=f)dfs_ans(road[x][i],x,v+1);
if(h%k==0) ans[x]-=val[x];
res=min(res,ans[x]);
}
signed main()
{
maxn[0]=1000000;
n=read(),k=read(),h=read();
for(int i=1;i<=n;++i) val[i]=read();
for(int i=1,u,v,w;i<n;++i)
{
u=read(),v=read();
road[u].push_back(v);
road[v].push_back(u);
}
get_root(1,0,n);//easily
solve(root);
dfs_ans(1,1,0);
cout<<res;
}
\(T3\)树
前两问随便线段树维护一下就好了
第三个操作基于一个贪心
我们要求区间的连续两个数绝对值不超过\(k\)
我们要对于点\(i\)
\(a_i+k>=a_{i+1},a_i+k>=a_{i-1}\)
我们对于每个条件从一侧往另一侧扫一遍贪心更改即可,复杂度\(O(nm)\)
考虑优化这个过程
考虑维护差分数组,我们第二个操作最多只会增加两个需改变的点,但每次三操作会减少,我们这个东西有势能保护
我们三操作最后变成了区间赋等差数列即可,范围可以使用二分轻松解决
标签：ch,NOI,val,int,1000001,dep,5.30,MAXN,模拟 来源： https://www.cnblogs.com/Eternal-Battle/p/16328672.html