NOIP 2017.10.4 总结+心得

世界真的很大
今天中秋佳节，霉运缠身，居然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;
}

这道题考试的时候思路已经比较接近了，但还是失败了。
感觉以后发现无法优化的时候，要更深刻的挖掘题目的隐藏限制，脑子想不出来就打表多分析一下

---