noip模拟27[妹子图·腿·腰](fengwu半仙的妹子们)
\(noip模拟27 solutions\)
这次吧，我本来以为我能切掉两个题，结果呢？？只切掉了一个
不过，隔壁Varuxn也以为能切两个，可惜了，他一个都没切。。。。。。
确实他分比我高一点，但是吧，这个人就改题非常慢，所以结论就是
我牛逼，牛逼到家了
所以我应该是挂掉了100pts，下次注意，下次AK
\(T1 妹子图(graph)\)
这个题有一堆做法，而且旗鼓相当，复杂度都一样，跑的也差不多快
我的做法是在无向图上跑魔改拓扑排序+魔改DIJ，非常的恶心，但是吧，理解之后极其简单
按照堆优化的DIJ搞了一个优先队列，这样我们先把半仙的家能够连到的地方压到队列中
因为我们是按照边权小的在前面，所以我们当前找到的一定是当前困难抵抗值能够到达的最大的图
显然有一些困难抵抗值能够见到的妹子种类数是一样的，这些我们就不必保存了
这样的话，我们的数组里最多只有2e5个点，直接保证了时间和空间复杂度
我们开始弹队列，然后更新这个数组，这里面存的东西就是
能够看到当前这么多妹子的最小困难抵抗值，和能够看到的妹子
最后的时候直接在这个数组里二分查找，搞一搞边界就好了
复杂度是\(O(nlogn+qlogn)\)
AC_code
#include<bits/stdc++.h>
using namespace std;
#define re register int
#define ll long long
const int N=5e5+5;
int n,m,qq,hom,opt,mod;
int c[N];
ll num[N],fro[N],bas[N],cnt;
int to[N*2],nxt[N*2],val[N*2],head[N],rp;
void add_edg(int x,int y,int z){
to[++rp]=y;
val[rp]=z;
nxt[rp]=head[x];
head[x]=rp;
}
int ton[N],sum;
bool vis[N];
struct node{
int val,tag;
node(){}
node(int x,int y){
val=x;tag=y;
}
bool operator < (node x)const{
return val>x.val;
}
};
priority_queue<node> q;
signed main(){
scanf("%d%d%d%d%d",&n,&m,&qq,&hom,&opt);
if(opt)scanf("%d",&mod);
for(re i=1;i<=n;i++){
scanf("%d",&c[i]);
}
for(re i=1,x,y,z;i<=m;i++){
scanf("%d%d%d",&x,&y,&z);
add_edg(x,y,z);
add_edg(y,x,z);
}
ton[c[hom]]++;sum++;
for(re i=head[hom];i;i=nxt[i])
q.push(node(val[i],to[i]));
int cge=0;bas[++cnt]=1;num[cnt]=sum;
while(!q.empty()){
int dis=q.top().val;
int now=q.top().tag;
q.pop();
if(vis[now])continue;
vis[now]=true;
cge=max(cge,dis);
ton[c[now]]++;
if(ton[c[now]]==1){
sum++;
if(bas[cnt]!=cge)
bas[++cnt]=cge;
num[cnt]=sum;
}
for(re i=head[now];i;i=nxt[i]){
q.push(node(val[i],to[i]));
}
}
bas[++cnt]=1e9+1;
for(re i=1;i<=cnt;i++){
fro[i]=fro[i-1]+1ll*num[i-1]*(bas[i]-bas[i-1]);
//cout<<bas[i]<<" "<<num[i]<<" "<<fro[i]<<endl;
}
ll lans=0;
for(re i=1;i<=qq;i++){
ll x,y;
scanf("%lld%lld",&x,&y);
if(opt==1){
x=(x^lans)%mod+1;
y=(y^lans)%mod+1;
}
if(x>y)swap(x,y);
int ld=upper_bound(bas+1,bas+cnt+1,x)-bas;
int rd=upper_bound(bas+1,bas+cnt+1,y)-bas-1;
//cout<<ld<<" "<<rd<<" "<<num[ld]<<" "<<bas[ld]<<endl;
ll ans=fro[rd]-fro[ld];
ans+=1ll*(bas[ld]-x)*num[ld-1];
ans+=1ll*(y-bas[rd]+1)*num[rd];
printf("%lld\n",ans);
lans=ans;
}
}
\(T2\;妹子腿(tree)\)
真是没想到啊，没想到，这个竟然是个大暴力，主要是他还能过，气死人，比线段树还快
考场上没敢写，气人。
就是维护被标记的点的标记时间以及和要查询的点的距离，
这个距离就是树剖+LCA，完事！！！
注意优化，要不然过不了，如果要标记的点已经在不断的扩散中被标记了，就不要加进去了。
AC_code
#include<bits/stdc++.h>
using namespace std;
#define re register int
#define fi first
#define se second
#define pa pair<int,int>
#define mpa(x,y) make_pair(x,y)
const int N=1e5+5;
int n,m;
int to[N*2],nxt[N*2],head[N],rp;
void add_edg(int x,int y){
to[++rp]=y;
nxt[rp]=head[x];
head[x]=rp;
}
int fa[N],dep[N];
int siz[N],son[N],top[N];
void dfs1(int x){
siz[x]=1;son[x]=0;
for(re i=head[x];i;i=nxt[i]){
int y=to[i];
if(y==fa[x])continue;
fa[y]=x;dep[y]=dep[x]+1;
dfs1(y);
siz[x]+=siz[y];
if(!son[x]||siz[y]>siz[son[x]])son[x]=y;
}
}
void dfs2(int x,int f){
top[x]=f;
if(son[x])dfs2(son[x],f);
for(re i=head[x];i;i=nxt[i]){
int y=to[i];
if(y==fa[x]||y==son[x])continue;
dfs2(y,y);
}
}
int LCA(int x,int y){
while(top[x]!=top[y]){
if(dep[top[x]]<dep[top[y]])swap(x,y);
x=fa[top[x]];
}
return dep[x]<dep[y]?x:y;
}
int DIS(int x,int y){
return dep[x]+dep[y]-2*dep[LCA(x,y)];
}
pa ji[N];
int cnt;
signed main(){
scanf("%d%d",&n,&m);
for(re i=1,x,y;i<n;i++){
scanf("%d%d",&x,&y);
add_edg(x,y);add_edg(y,x);
}
dfs1(1);dfs2(1,1);
for(re i=1,typ,x;i<=m;i++){
scanf("%d%d",&typ,&x);
if(typ==1){
int flag=0;
for(re j=1;j<=cnt;j++){
if(DIS(ji[j].fi,x)<=i-ji[j].se){
flag=1;break;
}
}
if(flag==1)continue;
ji[++cnt]=mpa(x,i);
}
if(typ==2)cnt=0;
if(typ==3){
int flag=0;
for(re j=1;j<=cnt;j++){
if(DIS(ji[j].fi,x)<=i-ji[j].se){
flag=1;break;
}
}
if(flag==1)printf("wrxcsd\n");
else printf("orzFsYo\n");
}
}
}
\(T3\;妹子腰(序列)\)
这个题我一眼就是原题，而且是昨天的原题
后来发现不对，是极长上升而不是最长上升
所以我忘记了如何维护这个东西了，考完试又去回顾了一下，好难哟！！！
就是一个\(O(log^2n)\)的线段树，注意维护一个底线，来保证是极长的。。
AC_code
#include<bits/stdc++.h>
using namespace std;
#define re register int
#define ll long long
const int N=2e5+5;
const ll inf=0x3f3f3f3f3f3f3f3f;
const ll mod=998244353;
int n,a[N],maxd;
struct node{
#define ls x<<1
#define rs x<<1|1
ll sum[N*4];
int mxra[N*4];
ll work(int x,int l,int r,int maxn){
//cout<<x<<" "<<l<<" "<<r<<endl;
if(l==r){
if(mxra[x]>maxn)return sum[x];
return 0;
}
int mid=l+r>>1;
if(maxn>mxra[x])return 0;
else if(maxn>mxra[rs])return work(ls,l,mid,maxn);
else{
ll ret=0;
ret=(ret+work(rs,mid+1,r,maxn))%mod;
ret=(ret+work(ls,l,mid,mxra[rs]))%mod;
return ret;
}
}
void pushup(int x){
mxra[x]=max(mxra[ls],mxra[rs]);
//sum[x]=(sum[ls]+sum[rs])%mod;
return ;
}
void ins(int x,int l,int r,int pos,int mx,int v){
if(l==r){
mxra[x]=mx;
sum[x]=v;
return ;
}
int mid=l+r>>1;
if(pos<=mid)ins(ls,l,mid,pos,mx,v);
else ins(rs,mid+1,r,pos,mx,v);
pushup(x);return ;
}
ll query(int x,int l,int r,int pos){
if(pos==0)return 0;
if(r<=pos){
ll ret=work(x,l,r,maxd);
maxd=max(maxd,mxra[x]);
return ret;
}
int mid=l+r>>1;ll ret=0;
if(pos>mid)ret=(ret+query(rs,mid+1,r,pos))%mod;
ret=(ret+query(ls,l,mid,pos))%mod;
return ret;
}
#undef ls
#undef rs
}xds;
ll ans,dp[N];
signed main(){
scanf("%d",&n);
for(re i=1;i<=n;i++)scanf("%d",&a[i]);
for(re i=1;i<=n;i++){
maxd=0;
dp[i]=xds.query(1,1,n,a[i]-1);
//cout<<dp[i]<<" ";
if(dp[i]==0)dp[i]=1;
xds.ins(1,1,n,a[i],i,dp[i]);
//cout<<dp[i]<<endl;
}
int mx=0;
for(re i=n;i>=1;i--){
if(a[i]>mx)ans=(ans+dp[i])%mod,mx=a[i];
}
printf("%lld",ans);
}
QQ:2953174821
