7.14考试总结(NOIP模拟15)[夜莺与玫瑰·影子·玫瑰花精]
梦总是有会醒来的时候，不会醒的梦总有一天会变成悲伤。
前言
这次考试的思维含量有一点大（此时距离考试还有 7min 而我的总结还没写完。。）
但是对于以前的考试来讲还是有所进步的，毕竟在考试的时候还是第一次尝试着自己推柿子，最后也是成功的推出部分分的柿子。。
唯一遗憾的一点就是在 wzr 的领导下，我在 256MB 的内存下开了 \(10^4\times 10^4\) 的 long long 数组。
然后，就 MLE 0pts 了，我的 35 分就。。。（现在距离所谓的考试还有 2min ，但是考试突然没了）
再然后又说 14:40 开始考。。。起起伏伏。。。
对于第三题的话，裸的暴力，处理之后直接 sort 就可以搞到 60pts ，但是我一想到 sort 的复杂度就直接开了一个数组，手动一个一个按顺序插入，最后弄巧成拙，喜提 0pts。
虽然现在正在考试中，但这并不影响我写之前的考试总结，毕竟仅剩下 7min 了，我对于别的题也没有什么好的想法。
T1 夜莺与玫瑰
解题思路
对于 60pts 来说，显然的是要一个对于每一次询问 \(\mathcal{{O}}(n^2)\) 查询的办法。
于是我苦死冥想了整整 100min 想到了这个部分分。
（第一次隔天写文章。。），对于每一种线的最短线段一定会满足 \(\gcd(i-1,j-1)=1\) 。
在下面计算以及说明的时候为了方便，我们把所有的初始变量都减去一个 1 ，所以关于下面的说明可能会口胡多或者少一个 1 读者请意会一下（逃。
然后在 \((n,m)\) 的区间内，对于最短的线段（算上重复的）一共会有 \((n-i)\times (m-j)\) 条。
但是通过画图就可以发现 重复的就会有 \((n-2\times i)\times (m-2\times j)\) 条。
也就是下面的柿子：
\[\sum\limits_{i=1}^{n-1}\sum\limits_{j=1}^{m-1}[\gcd(i,j)=1]((n-i)\times(m-j)-\max(n-2\times i,0)\times \max(m-2\times j,0))
\]
对于这个柿子维护二维前缀和。
第一个前缀和计算范围内的 \(\gcd\) 的数量，可以理解为从某一点出发的最短线段的个数。
然后在此基础上维护一个二维前缀和 \(pre_{n,m}=[\gcd(i,j)=1]((n-i)\times(m-j)\)。
然后我们尝试把这个柿子运用到之前的柿子上发现， 其实：
\[(n-2\times i)\times (m-2\times j)=4\times(\dfrac{n}{2}-i)\times(\dfrac{m}{2}-j)=4\times pre_{\frac{n}{2},\frac{m}{2}}
\]
接下来就可以直接套用公式并且对于奇数的情况进行处理就好了。
code
#include<bits/stdc++.h>
using namespace std;
inline int read()
{
int x=0,f=1;
char ch=getchar();
while(ch>'9'||ch<'0')
{
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
{
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x*f;
}
const int N=1e4+10,M=4e3+10,mod=1073741824;
int T,n,m,f[M][M],vis[M][M],pre[M][M];
struct Node
{
int x,y;
}q[N];
int Gcd(int x,int y)
{
if(!y) return x;
return Gcd(y,x%y);
}
void Init()
{
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
vis[i][j]=(Gcd(i,j)==1);
vis[i][j]+=vis[i][j-1]+vis[i-1][j]-vis[i-1][j-1];
pre[i][j]=vis[i][j]+pre[i][j-1]+pre[i-1][j]-pre[i-1][j-1];
}
}
int solve(int x,int y)
{
int ans=0,mix=x/2,miy=y/2;
ans=pre[x-1][y-1];
ans=(ans+(4ll*mod-4*pre[mix-1][miy-1]))%mod;
if(x&1) for(int i=1;i<=miy;i++) ans=(ans+1ll*(2ll*mod-2ll*vis[mix][i-1]))%mod;
if(y&1) for(int i=1;i<=mix;i++) ans=(ans+1ll*(2ll*mod-2ll*vis[i-1][miy]))%mod;
if(x&1 && y&1) ans=(ans+1ll*(mod-vis[mix][miy]))%mod;
return (ans*2+x+y)%mod;
}
signed main()
{
T=read();
for(int i=1;i<=T;i++)
{
q[i].x=read();
q[i].y=read();
n=max(n,q[i].x);
m=max(m,q[i].y);
}
Init();
for(int i=1;i<=T;i++)
printf("%d\n",solve(q[i].x,q[i].y));
return 0;
}
T2 影子
解题思路
对于暴力算法可以分别以每个节点为根，分别查询这个节点到其他节点的距离以及最小值。
时间复杂度 \(\mathcal{O}(n^2)\) 空间复杂度 \(\mathcal{O}(n)\)
然后在考场上我搞了一个 \(n^2\) 的复杂度，再然后就 MLE 0pts，痛失 35pts（\(code\)） 。
正解是首先对于所有的节点按节点值从大到小进行排序（这样在搞的时候就不用考虑节点权值的关系了），然后把当前集合中的最长路的长度和两个端点用冰茶几维护。
用冰茶几合并这个节点以及与他有连边的节点所在的联通块。
维护的时候主要分为两大种情况：
-
原来的两个联通块分别的长度
-
由两个最长路的两个端点分别连接而成，共有 4 种。
每次冰茶几维护直接用两种值的乘积，更新既可，代码实现不算太难。。
code
#include<bits/stdc++.h>
#define int long long
using namespace std;
inline int read()
{
int x=0,f=1;
char ch=getchar();
while(ch>'9'||ch<'0')
{
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
{
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x*f;
}
const int N=1e5+10,M=2e4,INF=1e9;
int n,m,T,ans,tim,fat[N],dep[N],son[N],siz[N],dfn[N],fa[N],topp[N],dis[N],clo[N];
int tot,head[N<<1],nxt[N<<1],ver[N<<1],edge[N<<1];
struct Node
{
int id,val;
}s[N];
struct Road
{
int l,r,len;
void clear()
{
l=r=len=0;
}
}pat[N],dist[10];
void add_edge(int x,int y,int val)
{
ver[++tot]=y;
edge[tot]=val;
nxt[tot]=head[x];
head[x]=tot;
}
void dfs1(int x)
{
pat[x].l=pat[x].r=x;
siz[x]=1;
for(int i=head[x];i;i=nxt[i])
{
int to=ver[i];
if(siz[to]) continue ;
dis[to]=dis[x]+edge[i];
dep[to]=dep[x]+1;
fat[to]=x;
dfs1(to);
siz[x]+=siz[to];
if(siz[to]>siz[son[x]])
son[x]=to;
}
}
void dfs2(int x,int tp)
{
topp[x]=tp;
dfn[x]=++tim;
if(son[x]) dfs2(son[x],tp);
for(int i=head[x];i;i=nxt[i])
if(!dfn[ver[i]])
dfs2(ver[i],ver[i]);
}
int LCA(int x,int y)
{
if(!x||!y) return 0;
if(x==y) return x;
while(topp[x]^topp[y])
{
if(dep[topp[x]]<dep[topp[y]])
swap(x,y);
x=fat[topp[x]];
}
if(dep[x]>dep[y])
swap(x,y);
return x;
}
bool comp(Node x,Node y)
{
return x.val>y.val;
}
int find(int x)
{
if(fa[x]==x) return fa[x];
return fa[x]=find(fa[x]);
}
int Dist(int x,int y)
{
return dis[x]+dis[y]-2*dis[LCA(x,y)];
}
bool cmp(Road x,Road y)
{
return x.len>y.len;
}
void merge(int x,int y)
{
int minn=clo[x];
x=fa[find(x)];
y=fa[find(y)];
dist[1]=pat[x];
dist[2]=pat[y];
dist[3]=(Road){pat[x].l,pat[y].l,Dist(pat[x].l,pat[y].l)};
dist[4]=(Road){pat[x].l,pat[y].r,Dist(pat[x].l,pat[y].r)};
dist[5]=(Road){pat[x].r,pat[y].l,Dist(pat[x].r,pat[y].l)};
dist[6]=(Road){pat[x].r,pat[y].r,Dist(pat[x].r,pat[y].r)};
sort(dist+1,dist+7,cmp);
pat[x]=dist[1];
fa[y]=x;
ans=max(ans,dist[1].len*minn);
}
void solve(int x)
{
for(int i=head[x];i;i=nxt[i])
if(clo[ver[i]]>=clo[x])
merge(x,ver[i]);
}
void dfs3(int x,int fro)
{
for(int i=head[x];i;i=nxt[i])
{
int to=ver[i];
if(to==fro) continue ;
dfs3(to,x);
}
dis[x]=dep[x]=dfn[x]=siz[x]=son[x]=topp[x]=head[x]=fa[x]=fat[x]=clo[x]=0;
pat[x].clear();
}
void work()
{
n=read();
for(int i=1;i<=n;i++)
{
clo[i]=read();
s[i]=(Node){i,clo[i]};
}
for(int i=1,x,y,val;i<n;i++)
{
x=read();
y=read();
val=read();
add_edge(x,y,val);
add_edge(y,x,val);
}
for(int i=1;i<=n;i++)
fa[i]=i;
sort(s+1,s+n+1,comp);
dfs1(1);
dfs2(1,1);
for(int i=1;i<=n;i++)
solve(s[i].id);
printf("%lld\n",ans);
dfs3(1,0);
tot=tim=ans=0;
}
signed main()
{
T=read();
while(T--) work();
return 0;
}
T3 玫瑰花精
解题思路
有一点像之前做过的 旅馆，但是不完全一样。
用线段树维护序列，主要维护 7 个值：lmx,ll,rr,rmx,llen,rlen,len
主要分为三个区间：
-
与整个区间的左边界相连的最长长度（llen）以及端点（ll）
-
同样的与整个区间的右边界相连的最长长度（rlen）以及端点（rr）
-
整个区间内的除了左右两个区间的所有未入住的区间中最长的长度（len）以及左右端点（lmx，rmx）
然后在维护时候主要对于上面的三个区间进行查找。
然后就是单点修改，区间查询，在搞的时候比较考验码力，具体实现细节见代码：
code
#include<bits/stdc++.h>
#define ls x<<1
#define rs x<<1|1
using namespace std;
inline int read()
{
int x=0,f=1;
char ch=getchar();
while(ch>'9'||ch<'0')
{
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
{
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x*f;
}
const int N=2e5+10,M=1e6+10;
int n,m,s[M];
struct Segment_Tree
{
int lmx,ll,rr,rmx,llen,rlen,len;
}tre[N<<2];
inline void push_up(int x,int l,int r)
{
int mid=(l+r)>>1;
if( max( ((tre[rs].len+1)>>1),((tre[rs].llen+tre[ls].rlen+1)>>1) ) <= ((tre[ls].len+1)>>1) )
{
tre[x].len=tre[ls].len;
tre[x].lmx=tre[ls].lmx;
tre[x].rmx=tre[ls].rmx;
}
else if( max( ((tre[rs].len+1)>>1),((tre[ls].len+1)>>1) ) <= ((tre[rs].llen+tre[ls].rlen+1)>>1) )
{
tre[x].len=tre[rs].llen+tre[ls].rlen;
tre[x].lmx=tre[ls].rr;
tre[x].rmx=tre[rs].ll;
}
else if( max( ((tre[rs].llen+tre[ls].rlen+1)>>1),((tre[ls].len+1)>>1) ) <= ((tre[rs].len+1)>>1) )
{
tre[x].len=tre[rs].len;
tre[x].lmx=tre[rs].lmx;
tre[x].rmx=tre[rs].rmx;
}
tre[x].ll=tre[ls].ll;
tre[x].rr=tre[rs].rr;
tre[x].llen=tre[ls].llen;
tre[x].rlen=tre[rs].rlen;
if(tre[x].llen==mid-l+1)
{
tre[x].llen=mid-l+1+tre[rs].llen;
tre[x].ll=tre[rs].ll;
}
if(tre[x].rlen==r-mid)
{
tre[x].rlen=r-mid+tre[ls].rlen;
tre[x].rr=tre[ls].rr;
}
}
inline void build(int x,int l,int r)
{
tre[x].len=tre[x].llen=tre[x].rlen=r-l+1;//将可以入住的区间搞到最大
tre[x].lmx=tre[x].rr=l;//同时更新左右端点
tre[x].ll=tre[x].rmx=r;
if(l==r) return ;
int mid=(l+r)>>1;
build(ls,l,mid);
build(rs,mid+1,r);
}
inline void insert(int x,int l,int r,int pos)
{
if(l==r)
{
tre[x].len=tre[x].llen=tre[x].rlen=0;//标记入住
tre[x].lmx=tre[x].rr=pos+1;//三个区间错开
tre[x].ll=tre[x].rmx=pos-1;
return ;
}
int mid=(l+r)>>1;
if(pos<=mid) insert(ls,l,mid,pos);//向下递归
else insert(rs,mid+1,r,pos);
push_up(x,l,r);
}
inline void delate(int x,int l,int r,int pos)
{
if(l==r)
{
tre[x].len=tre[x].llen=tre[x].rlen=1;
tre[x].lmx=tre[x].rr=tre[x].ll=tre[x].rmx=pos;
return ;
}
int mid=(l+r)>>1;
if(pos<=mid) delate(ls,l,mid,pos);//递归更新
else delate(rs,mid+1,r,pos);
push_up(x,l,r);
}
inline void solve1(int pos)
{
int ans=(tre[1].lmx+tre[1].rmx)>>1;
if(tre[1].llen>=(tre[1].len+1)/2) ans=1;//只剩下1节点或者左侧的长度大于中间最大的一半
else if(tre[1].rlen>(tre[1].len+1)/2) ans=n;//只剩下n节点或者右侧更优
s[pos]=ans;
insert(1,1,n,ans);//记录并更新
printf("%d\n",ans);
}
inline void solve2(int pos)
{
delate(1,1,n,s[pos]);
}
signed main()
{
n=read();
m=read();
build(1,1,n);
while(m--)
{
int opt,pos;
opt=read();
pos=read();
if(opt==1) solve1(pos);
else solve2(pos);
}
return 0;
}
