[考试反思]1003csp-s模拟测试58：沉淀

稳住阵脚。

还可以。

至少想拿到的分都拿到了，最后一题的确因为不会按秩合并和线段树分治而想不出来。

对拍了，暴力都拍了。挺稳的。

但是其实也有波折，险些被卡内存。

如果内存使用不连续或申请的内存全部使用的话，切记计算内存，一点都不能开大。

T1：Divisors

直接根号筛，拿map也能过。

遍历map直接begin和end啊。。。

 #include<cstdio>
 int Cnt[];
 struct hash_map{
     int cnt,fir[],l[],to[],w[];
     int &operator[](int x){if(x>Cnt[])return w[];int r=x%;
         for(int i=fir[r];i;i=l[i])if(to[i]==x)return w[i];
         l[++cnt]=fir[r];fir[r]=cnt;to[cnt]=x;return w[cnt];
     }
 }M;
 int main(){
     int m;scanf("%d%d",&Cnt[],&m);
     for(int i=,x;i<=m;++i){
         scanf("%d",&x);
         for(int j=;j*j<=x;++j)if(x%j==)M[j]++,M[x/j]+=(x!=j*j);
     }
     for(int i=;i<=M.cnt;++i)Cnt[M.w[i]]++;
     for(int i=;i<=m;++i)Cnt[]-=Cnt[i];
     for(int i=;i<=m;++i)printf("%d\n",Cnt[i]);
 }

hash_map 581B

hash_map的数组大小要记得计算空间

T2：Market

应该都能看出是个背包。

不读错题问题都不大。

 #include<bits/stdc++.h>
 using namespace std;
 int dp[][];
 vector<pair<int,int> >V[];
 int main(){
     int n,m,v,c,t;memset(dp[],0x3f,sizeof dp[]);
     scanf("%d%d",&n,&m);dp[][]=;
     while(n--)scanf("%d%d%d",&c,&v,&t),V[t].push_back(make_pair(c,v));
     for(int t=;t<=;++t){
         for(int v=;~v;--v)dp[t][v]=dp[t-][v];
         for(int S=;S<V[t].size();++S){
             int C=V[t][S].first,W=V[t][S].second;
             for(int v=;v>=W;--v)dp[t][v]=min(dp[t][v],dp[t][v-W]+C);
         }
         for(int v=;~v;--v)dp[t][v]=min(dp[t][v],dp[t][v+]);
     }
     while(m--)scanf("%d%d",&t,&c),printf("%d\n",upper_bound(dp[t],dp[t]+,c)-dp[t]-);
 }

稍短 641B

不离线询问的话不要开long long。会MLE。

T3：Dash Speed

好题。

考场上一直在想主席树，以为有50000有70000会卡两个log的。显然没有。

这题要处理对于每一个速度的答案。

先考虑l_i=1的特殊性质。

我们从大到小的考虑速度，这样的话就是一个不断解锁边的过程。

不断填边，求最长链。和模拟测试40《影子》的并查集做法一模一样。

如果l_i不是1呢？那就有删边操作了。然而直接做貌似不可撤销。

考虑分治。

如果我们现在要求解速度为1和2时的答案，那么一个暴力的思路就是：

把1能过的所有边连上，求解，撤销。把2能过的所有边连上，求解，撤销。

复杂度是n²的。

我们可以发现上面这个方法存在冗余。如果我们一开始就把1和2的边都连上，在求解1，2时不撤销这些边，就可以快一些了。

我们利用的是线段树的结构，我们现在考虑所有[3，5]的询问，于是加入l<=3&&r>=5的边。

然后是处理3的询问，再加入速度可以接受3的边，求解3，再撤销刚刚加入的这些边就好。。。

然后不断按mid分治下去直到叶节点就是答案。

怎么撤销？

每次修改一个数值时，往一个栈里放修改前的值，然后在线段树处理完某一个节点而回溯时，不断弹栈还原至搜索到线段树该节点之前即可。

倍增LCA并没有被卡T。

然而因为要撤销，所以按照原来那道题打路径压缩并查集是不可行的（过程中修改的点太多），为了保证复杂度，我们采取按秩合并。

按秩合并其实就是把并查集按照深度合并，深度小的往打的里面合并的话那么很大可能总深度不变，或者+1。

只用两棵树深度恰好相等时深度+1，其余时候深度还是原来树的深度。不知道为什么网上给的板子深度数组叫rk。

 int find(int k){return f[k]==k?k:find(f[k]);}
 int merge(int a,int b){
     int A=find(a),B=find(b);
     if(rk[A]>rk[B])f[B]=A;
     else f[A]=B,rk[B]+=(rk[A]==rk[B]);
 }

按秩合并大概的板子

然后就差不多了。

 #include<cstdio>
 #include<vector>
 #include<iostream>
 using namespace std;
 int n,m,fir[],l[],to[],cnt,ans[],u[],v[],L[],R[];
 void link(int a,int b){l[++cnt]=fir[a];to[cnt]=b;fir[a]=cnt;}
 int p1[],p2[],mx[],f[][],F[],rk[],dep[],stans[];
 int stp1[],stp2[],stmx[],stF[],strk[],o[],top,ANS;
 vector<int>V[];
 void insert(int p,int l,int r,int i){
     if(L[i]<=l&&r<=R[i]){V[p].push_back(i);return;}
     if(R[i]>l+r>>)insert(p<<|,(l+r>>)+,r,i);
     if(L[i]<=l+r>>)insert(p<<,l,l+r>>,i);
 }
 int find(int k){return F[k]==k?k:find(F[k]);}
 void dfs(int p,int fa){
     f[p][]=fa;dep[p]=dep[fa]+;F[p]=p1[p]=p2[p]=p;
     for(int i=;i<=;++i)f[p][i]=f[f[p][i-]][i-];
     for(int i=fir[p];i;i=l[i])if(to[i]!=fa)dfs(to[i],p);
 }
 int dt(int a,int b){
     int sub=dep[a]-dep[b],A=a,B=b;
     if(sub<)a^=b^=a^=b,sub=-sub;
     for(int i=;~i;--i)if(sub&<<i)a=f[a][i];
     if(a==b)return sub;
     for(int i=;~i;--i)if(f[a][i]!=f[b][i])a=f[a][i],b=f[b][i];
     return dep[A]+dep[B]-*dep[f[a][]];
 }
 void copy(int x){++top;o[top]=x;stp1[top]=p1[x];stp2[top]=p2[x];stmx[top]=mx[x];stF[top]=F[x];strk[top]=rk[x];stans[top]=ANS;}
 void recover(){int x=o[top];mx[x]=stmx[top];F[x]=stF[top];ANS=stans[top];p1[x]=stp1[top];p2[x]=stp2[top];rk[x]=strk[top];--top;}
 void merge(int i){//printf("merge:%d %d\n",u[i],v[i]);
     int x=u[i],y=v[i],X=find(x),Y=find(y);
     int mdt,mp1,mp2,Ldt,Lp,Rdt,Rp,res;
     if(mx[X]>mx[Y])mdt=mx[X],mp1=p1[X],mp2=p2[X];
     else mdt=mx[Y],mp1=p1[Y],mp2=p2[Y];
     Ldt=dt(p1[X],x);res=dt(p2[X],x);
     if(Ldt>res)Lp=p1[X];else Ldt=res,Lp=p2[X];
     Rdt=dt(p1[Y],y);res=dt(p2[Y],y);
     if(Rdt>res)Rp=p1[Y];else Rdt=res,Rp=p2[Y];
     copy(X);copy(Y);
     if(rk[X]>rk[Y])X^=Y^=X^=Y;rk[Y]+=(rk[X]==rk[Y]);
     if(Ldt+Rdt+>mdt)mx[Y]=Ldt+Rdt+,p1[Y]=Lp,p2[Y]=Rp;
     else mx[Y]=mdt,p1[Y]=mp1,p2[Y]=mp2;
     F[X]=Y;ANS=max(ANS,mx[Y]);//printf("ANS:%d\n",ANS);
 }
 void Divide_and_Conquer(int p,int l,int r){int re=top;//printf("%d %d\n",l,r);
     for(int i=;i<V[p].size();++i)merge(V[p][i]);
     if(l==r){ans[l]=ANS;goto ed;}
     Divide_and_Conquer(p<<,l,l+r>>);
     Divide_and_Conquer(p<<|,(l+r>>)+,r);
 ed:    while(top>re)recover();
 }
 int main(){//freopen("t3.in","r",stdin);freopen("t3.out","w",stdout);
     scanf("%d%d",&n,&m);
     for(int i=;i<n;++i)scanf("%d%d%d%d",&u[i],&v[i],&L[i],&R[i]),link(u[i],v[i]),link(v[i],u[i]),insert(,,n,i);
     dfs(,);Divide_and_Conquer(,,n);
     int v;while(m--)scanf("%d",&v),printf("%d\n",ans[v]);
 }

稍长