世界真的很大
今天中秋佳节,霉运缠身,居然MLE,不然我rank1,哎哎
立个flag明天我要翻盘。
今天的题整体来说不太难,第二题除外,第一题是常数巨大的线段树,算法一样写的不好就T,幸好我的代码比较优美233
但有什么用呢,MLE,提莫的
看题先:
1.
这道题由于原来做过一道类似的,那时还太NAIVE,现在一看就是水题了。
自带26常数的线段树233
线段树保存26个字母每个出现了多少次,然后每次查询区间内每个字母出现了几次,然后按照升序降序挨个挨个排好,一次操作就是26 * n * logn的,非常完美。但是由于线段树本来常数就大,而且这道题又自带26的大常数,尽管时限是2s,但还是非常容易T,当时我想了各种这样的优化,读优都加上了,好说歹说是卡过去了
有什么用呢?MLE了
完整代码:
#include<stdio.h>
#include<cstring>
using namespace std;
struct node
{
int sum[27],flag;
node *ls,*rs;
void pushdown(int lf,int rg)
{
if(flag!=0)
{
int mid=(lf+rg)>>1;
memset(ls->sum,0,sizeof(ls->sum));
memset(rs->sum,0,sizeof(rs->sum));
ls->flag=rs->flag=flag;
ls->sum[flag]=(mid-lf+1);
rs->sum[flag]=(rg-mid);
flag=0;
}
}
void update()
{
for(int i=1;i<=26;i++)
sum[i]=ls->sum[i]+rs->sum[i];
}
}pool[400010],*tail=pool,*root;
int n,m,tmp[30];
char s[100010];
inline int read()
{
int X=0,w=1; char ch=0;
while(ch<'0' || ch>'9') {if(ch=='-') w=-1;ch=getchar();}
while(ch>='0' && ch<='9') X=(X<<3)+(X<<1)+ch-'0',ch=getchar();
return X*w;
}
inline node *build(int lf,int rg)
{
node *nd=++tail;
if(lf==rg)
{
memset(nd->sum,0,sizeof(nd->sum));
nd->sum[s[lf]-'a'+1]=1,nd->flag=0;
nd->ls=nd->rs=0;
return nd;
}
int mid=(lf+rg)>>1;
nd->ls=build(lf,mid);
nd->rs=build(mid+1,rg);
nd->update();
return nd;
}
inline void modify(node *nd,int lf,int rg,int L,int R,int delta)
{
if(L<=lf && rg<=R)
{
memset(nd->sum,0,sizeof(nd->sum));
nd->sum[delta]=rg-lf+1,nd->flag=delta;
return ;
}
nd->pushdown(lf,rg);
int mid=(lf+rg)>>1;
if(L<=mid) modify(nd->ls,lf,mid,L,R,delta);
if(R>mid) modify(nd->rs,mid+1,rg,L,R,delta);
nd->update();
}
inline int query(node *nd,int lf,int rg,int L,int R,int typ)
{
if(L<=lf && rg<=R)
return nd->sum[typ];
int mid=(lf+rg)>>1,rt=0;
nd->pushdown(lf,rg);
if(L<=mid) rt+=query(nd->ls,lf,mid,L,R,typ);
if(R>mid) rt+=query(nd->rs,mid+1,rg,L,R,typ);
return rt;
}
inline int query(node *nd,int lf,int rg,int pos)
{
if(lf==rg)
{
for(int i=1;i<=26;i++)
if(nd->sum[i]) return i;
}
nd->pushdown(lf,rg);
int mid=(lf+rg)>>1;
if(pos<=mid) return query(nd->ls,lf,mid,pos);
else return query(nd->rs,mid+1,rg,pos);
}
int main()
{
freopen("string.in","r",stdin);
freopen("string.out","w",stdout);
scanf("%d%d",&n,&m);
scanf("%s",s+1);
root=build(1,n);
while(m--)
{
int opt,L,R;
L=read(),R=read(),opt=read();
for(int i=1;i<=26;i++)
tmp[i]=query(root,1,n,L,R,i);
if(opt)
{
int lf=L;
for(int i=1;i<=26;i++)
if(tmp[i])
{
modify(root,1,n,lf,lf+tmp[i]-1,i);
lf+=tmp[i];
}
}
else
{
int lf=L;
for(int i=26;i>=1;i--)
if(tmp[i])
{
modify(root,1,n,lf,lf+tmp[i]-1,i);
lf+=tmp[i];
}
}
}
for(int i=1;i<=n;i++)
printf("%c",query(root,1,n,i)+'a'-1);
printf("\n");
return 0;
}
/*
5 2
cabcd
1 3 1
3 5 0
*/
虽然这道题最后的结局是MLE,安慰自己一下,这样也未尝不是好事,我总算是长了点记性,然后学会了一个精确卡空间的办法。
力争下次不要出现这样的错误
2.
这道题坦白讲一点思路没有,考试时因为题读错了暴力都打不出来
然后考完了全班除了已毕业的ZXR大神,无人有任何思路
然后下午ZXR大神分享题解,未果,不明。
然后大神说:“我今天非要把你们讲懂不可!”
然后我就死皮赖脸的听懂了
设f(i,j)表示前i列,处理了里面所有左区间小于i的,留下了j个右区间小于i的状态的方案数
初始状态0,0=0
每次转移讨论这一列是涂左区间还是右区间。
之所以能这样是因为我们发现,交换行(hang)并不会影响答案,因为每一行是独立的
完整代码:
#include<stdio.h>
typedef long long dnt;
const dnt mod=998244353;
int n,m,cl[100010],cr[100010],s[100010],sr[100010];
dnt f[3030][3030],C[3030][3030],saber[3030];
void init()
{
for(int i=0;i<=3000;i++)
{
C[i][0]=1;
for(int j=1;j<=i;j++)
C[i][j]=(C[i-1][j]+C[i-1][j-1])%mod;
}
saber[0]=1;
for(int i=1;i<=3000;i++)
saber[i]=(saber[i-1]*i)%mod;
}
int main()
{
freopen("matrix.in","r",stdin);
freopen("matrix.out","w",stdout);
init();
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
cl[x]++,cr[y]++;
}
for(int i=1;i<=m;i++) sr[i]=sr[i-1]+cr[i];
for(int i=1;i<=m;i++) s[i]=s[i-1]+cl[i]+cr[i];
f[0][0]=1;
for(int i=1;i<=m;i++)
for(int j=0;j<=sr[i-1];j++)
{
if(!f[i-1][j]) continue ;
int K=i-1-s[i-1]+j;
if(K<0) continue ;
dnt A=C[K+1][cl[i]]*saber[cl[i]]%mod;
dnt B=C[K][cl[i]]*saber[cl[i]]%mod;
f[i][j+cr[i]]=(f[i-1][j]*A%mod+f[i][j+cr[i]])%mod;
if(j+cr[i])
f[i][j+cr[i]-1]=(f[i-1][j]*B%mod*(j+cr[i])+f[i][j+cr[i]-1])%mod;
}
printf("%I64d\n",f[m][0]);
return 0;
}
/*
2 6
2 4
5 6
*/
有时考试时会碰见这种出格的难题,但是不可否认的是,这是一道好题。这样的DP转化技巧真的是闻所未闻,算是长见识了
启示是,考试时如果题意有不清楚的地方,记得多用样例去分析,暴力也很重要,暴力分也是分,不要迷迷糊糊的去写暴力。
3.
讲道理这道题再给我一个小时我能想出来233
首先比较轻松想到怎么去模拟,然后就有20分
然后当时仔细研究一波,发现每一位朋友操作不操作,只关于与后缀和异或起来优不优,那么如果预处理后缀和的话,就可以做到2^n*m的复杂度,40分
我去瞟了一眼范围,n最大到30,那就是1e9的范围,枚举n肯定不可能了,只能考虑枚举m
然后问题就转化成了假设朋友就在第m位操作,取什么数最大,那如果要搞定这个筛选过程的话,势必要把整个序列一体化,然后就卡在这里
考完以后,听题解,讲到朋友的每个操作,都相当于把前面几个数都在二进制意义下网左移动一位,然后与后面的所有数异或起来,再找x。
对手做的是将 x在二进制下左移一位。假设异或 i个 数后左移等价于开始时先左移,然后把前 i个数左移一 个数左移一 位。
为什么这样是可行的,是因为,对于按位异或,之后一起左移时位置肯定是对的上的,那么只要保证位置相对,先后顺序其实没有关系。然后尽管x选取本身也会左移,但是鉴于我们并不关心x到底是什么,所以查找时就直接查找x左移之后的值操作后最小的最大值就行了
问题转化为选一个数,使它左移位后与 m+1 个给定数分别异或的最小值大。
将 m+1 个数建立一棵字典树,从上到下遍历来最大化结果:走到一个点时,如往下只有0,说明我们这一位取1异或后只能是1,累计结果中加上这一位的值,只有 1也一 样;如果既有 0又有 1,说明这一位无论怎么取最后都是0, 分别往下走即可 。
完整代码:
#include<stdio.h>
struct node
{
int big,num,dep;
node *ch[2];
}pool[5000010],*tail=pool,*root;
int n,m,a[200010],b[200010];
node *newnode(int p)
{
node *nd=++tail;
nd->dep=p;
nd->ch[0]=nd->ch[1]=0;
return nd;
}
void insert(int x)
{
node *p=root;
for(int i=n-1;i>=0;i--)
{
int idx=((1<<i)&x)>0;
if(!p->ch[idx])
p->ch[idx]=newnode(i);
p=p->ch[idx];
}
}
int wrk(int x)
{
return (x<<1)%(1<<n)+(x<<1)/(1<<n);
}
void dfs(node *nd)
{
if(!nd->ch[1] && !nd->ch[0])
{
nd->big=0,nd->num=1;
return ;
}
if(!nd->ch[1])
{
dfs(nd->ch[0]);
nd->num=nd->ch[0]->num;
nd->big=nd->ch[0]->big+(1<<(nd->dep-1));
}
else if(!nd->ch[0])
{
dfs(nd->ch[1]);
nd->num=nd->ch[1]->num;
nd->big=nd->ch[1]->big+(1<<(nd->dep-1));
}
else
{
dfs(nd->ch[0]),dfs(nd->ch[1]);
if(nd->ch[0]->big > nd->ch[1]->big)
nd->big=nd->ch[0]->big,nd->num=nd->ch[0]->num;
else if(nd->ch[0]->big < nd->ch[1]->big)
nd->big=nd->ch[1]->big,nd->num=nd->ch[1]->num;
else nd->big=nd->ch[0]->big,nd->num=nd->ch[0]->num+nd->ch[1]->num;
}
}
int main()
{
freopen("big.in","r",stdin);
freopen("big.out","w",stdout);
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
scanf("%d",&a[i]),b[1]^=a[i];
root=newnode(n);
for(int i=1;i<=m;i++)
b[i+1]=b[i]^a[i]^wrk(a[i]);
for(int i=1;i<=m+1;i++)
insert(b[i]);
dfs(root);
printf("%d\n%d\n",root->big,root->num);
return 0;
}
这道题考试的时候思路已经比较接近了,但还是失败了。
感觉以后发现无法优化的时候,要更深刻的挖掘题目的隐藏限制,脑子想不出来就打表多分析一下