SDOI Day1

好了做了SDOI day1的3道题，来讲下做法及感想吧

T1：排序（暴力，搜索）

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=3990

我们可以很轻易的发现，对于一个操作方案，交换两个操作顺序不会影响答案，因此我们可以从小到大枚举答案，可以发现，对于第i种操作过后，每个2^i的块必须是连续的

那么在第i种操作之前，最多只能有2个块不连续，那么如果没有块不连续，不用执行该种操作；只有一个块不连续，交换这个块的两小块；两个块分4种情况讨论，用dfs暴力搜索即可

时间复杂度看上去是O(4^N)，但好像可以证出复杂度其实是O(2^NlogN)N=20都能跑过

CODE：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 5000
int a[maxn],n,f[15];
long long ans=0;
inline void _swap(int *a,int *b,int step) {
    for (int i=1;i<=step;i++) swap(a[i],b[i]);
}
inline bool check(int x,int y) {return a[x+y]+1==a[x+y+1];}
int dfs(int x,int y) {
    if (x==n+1) return ans+=f[y];
    int w[5],cnt=0;
    int step=1<<(x-1);
    for (int i=0;i<1<<n;i+=1<<x) {
        if (!check(i,step)) w[++cnt]=i;
        if (cnt>2) return 0;
    }
    if (cnt==0) dfs(x+1,y);
    if (cnt==1) {
        _swap(a+w[1],a+w[1]+step,step);
        if (check(w[1],step)) dfs(x+1,y+1);
        _swap(a+w[1],a+w[1]+step,step);
    }
    if (cnt==2) {
        int *l1=a+w[1],*l2=a+w[2],*r1=a+w[1]+step,*r2=a+w[2]+step;
        _swap(l1,l2,step);
        if (check(w[1],step)&&check(w[2],step)) dfs(x+1,y+1);
        _swap(l1,l2,step);
        _swap(l1,r2,step);
        if (check(w[1],step)&&check(w[2],step)) dfs(x+1,y+1);
        _swap(l1,r2,step);
        _swap(r1,l2,step);
        if (check(w[1],step)&&check(w[2],step)) dfs(x+1,y+1);
        _swap(r1,l2,step);
        _swap(r1,r2,step);
        if (check(w[1],step)&&check(w[2],step)) dfs(x+1,y+1);
        _swap(r1,r2,step);
    }
}

int main(){
    scanf("%d",&n);
    f[0]=1;
    for (int i=1;i<=n;i++) f[i]=f[i-1]*i;
    for (int i=1;i<=(1<<n);i++) {
        scanf("%d",a+i);
        a[i]--;
    }
    dfs(1,0);
    printf("%lld
",ans);
    return 0;
}

T2：寻宝游戏（平衡树，dfn序）

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=3991

这道题真的想不出来啊= =

贴下同学的题解吧= =

大概就是这样子的，看上去还是非常的形象的，但我根本没想到啊QAQ

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
using namespace std;
typedef long long ll;
#define maxn 101000
#define maxk 23
struct edges{
    int to,next,dist;
}edge[maxn*2];
int q[maxn],f[maxn][maxk],g[maxn],dfn[maxn];
struct cmp{
    bool operator ()(int x,int y) {return dfn[x]<dfn[y];}
};
set<int,cmp> ma;
int next[maxn],l;
inline void addedge(int x,int y,int z) {
    edge[++l]=(edges){y,next[x],z};next[x]=l;
    edge[++l]=(edges){x,next[y],z};next[y]=l;
}
int fa[maxn],dep[maxn],n,s[maxn];
ll dis[maxn];
inline void bfs(){
    q[1]=1;
    for (int l=1,r=1,u=q[1];l<=r;u=q[++l]) {
        f[u][0]=fa[u];
        for (int i=1;i<maxk;i++) {
            if (f[f[u][i-1]][i-1]==0) break;
            f[u][i]=f[f[u][i-1]][i-1];
        }
        for (int i=next[u];i;i=edge[i].next) {
            if (edge[i].to==fa[u]) continue;
            fa[edge[i].to]=u;dis[edge[i].to]=dis[u]+edge[i].dist;
            dep[edge[i].to]=dep[u]+1;
            q[++r]=edge[i].to;
        }
    }
    for (int i=n;i>1;i--) {
        int u=q[i];
        s[u]++;s[fa[u]]+=s[u];
    }
    s[1]++;
    for (int i=1;i<=n;i++) {
        int u=q[i];
        dfn[u]=g[fa[u]]+1;
        g[fa[u]]+=s[u];
        g[u]=dfn[u];
    }
}
inline int up(int x,int y) {
    for (int i=0;i<maxk;i++) if ((1<<i)&y) x=f[x][i];
    return x;
}
inline int lca(int x,int y) {
    if (dep[x]<dep[y]) swap(x,y);
    x=up(x,dep[x]-dep[y]);
    if (x==y) return x;
    for (int i=maxk-1;i+1;i--) {
        if (f[x][i]==f[y][i]) continue;
        x=f[x][i];y=f[y][i];
    }
    return f[x][0];
}
inline ll getdist(int x,int y) {return dis[x]+dis[y]-dis[lca(x,y)]*2;}
ll ans;
typedef set<int,cmp>::iterator iter;
inline void ins(int x) {
    if (ma.size()==0) {
        ma.insert(x);return ;
    }
    if (ma.size()==1) {
        ans=getdist(x,*ma.begin());
        ma.insert(x);
        return ;
    }
    iter it=ma.lower_bound(x);
    iter last=it;it--;
    if (last!=ma.end()&&last!=ma.begin()) ans-=getdist(*it,*last);
    if (last!=ma.begin()) ans+=getdist(*it,x);
    if (last!=ma.end()) ans+=getdist(x,*last);
    ma.insert(x);
}    
inline void del(int x){
    ma.erase(x);
    if (ma.size()==0) return ;
    if (ma.size()==1) {
        ans=0;return ;
    }
    iter it=ma.lower_bound(x);
    iter last=it;it--;
    if (last!=ma.end()&&last!=ma.begin()) ans+=getdist(*it,*last);
    if (last!=ma.begin()) ans-=getdist(*it,x);
    if (last!=ma.end()) ans-=getdist(x,*last);
}
bool b[maxn];
int main(){
    int m;
    scanf("%d%d",&n,&m);
    for (int i=1;i<n;i++) {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        addedge(x,y,z);
    }
    bfs();
    for (int i=1;i<=m;i++) {
        int x;
        scanf("%d",&x);
        b[x]^=1;
        if (b[x]) ins(x);
        else del(x);
        if (ma.size()>=2) printf("%lld
",ans+getdist(*ma.begin(),*ma.rbegin()));
        else printf("0
");
    }
    return 0;
}

T3：序列统计（FFT）

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=3992

这道题分明就是原题好不好= =

首先我们可以很容易的写出状态转移f[i][[j*a[k]]+=f[i-1][j];

30%的分数可用矩阵乘法优化

我们取下离散对数（就是mod m意义下的），然后这个方程就变成了f[i][ind[j]+ind[a[k]]]+=sigma(f[i-1][ind[j]*cnt[inda[k]])

可以发现变成了卷积形式了，好像可以用fft优化了

但发现n很大

借鉴一下矩阵乘法的优化，可以发现多项式乘法满足结合律，那么我们可以愉快的学习快速幂的形式，变成f0*cnt^n次方了

时间复杂度是 mlogm logn完美解决本题

还有一件事，求离散对数可以不用大步小步法，因为p很小，可以直接p^2求出来

顺便提下原题是lydcjj(greenclouds)的kpmcup#1中的T1（ORZ），除了取离散对数其他都一模一样的

要不是做了MX的组合数和看过云神的题，还真不一定做得出来

总结一下：

作为省选题，还是很不错的

思考复杂度都不低（虽然有人说3道都是原题QAQ，自己还是太弱）但是编程复杂度并不高，前两道都能秒，第3道套个fft模板也能秒

还是这种考思维的比较好玩，像陈老师这种业界毒瘤的数据结构题真是丧心病狂(づ￣ 3￣)づ

 Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int mod=1004535809;
#define maxn 80100
// template
inline int power(ll x,int y,int mod) {
    ll t=1;
    for (;y;y>>=1,(x*=x)%=mod) 
        if (y&1) (t*=x)%=mod;
    return t;
}
int w[maxn];
void fft(int *a,int n,int dep=0) {
    if (n==1) return ;
    static int tmp[maxn];
    int mid=n>>1;
    fft(a,mid,dep+1);fft(a+(1<<dep),mid,dep+1);
    for (int i=0;i<mid;i++) {
        int s=a[(i<<1)<<dep];
        int t=a[(i<<1|1)<<dep]*1ll*w[i<<dep]%mod;
        tmp[i]=(s+t)%mod;
        tmp[i+mid]=(s-t)%mod;
    }
    for (int i=0;i<n;i++) a[i<<dep]=tmp[i];
}
int fft_g=3;
int N;
inline void fft_init(){
    w[0]=1;
    int step=power(fft_g,(mod-1)/N,mod);
    for (int i=0;i<N-1;i++) w[i+1]=w[i]*1ll*step%mod;
}
int p;
bool isroot(int x) {
    int sum=1;
    for (int i=1;i<p-1;i++) {
        (sum*=x)%=p;
        if (sum==1) return 0;
    }
    return 1;
}
int n,X,S;
int ind[maxn];
int f[maxn],g[maxn],invN;
inline void prepare(){
    scanf("%d%d%d%d",&n,&p,&X,&S);
    int root=0;
    for (int i=1;i<p&&!root;i++) if (isroot(i)) root=i;
    
    for (int i=0,j=1;i<p-1;i++,(j*=root)%=p) ind[j]=i;
    for (int i=1;i<=S;i++) {
        int x;
        scanf("%d",&x);
        if (x) g[ind[x]]=1;
    }
    N=p<<1;
    while (N&(N-1)) N++;
    invN=power(N,mod-2,mod);
    fft_init();
}
inline void muil(int *x,int *g){
    static int y[maxn];
    for (int i=0;i<N;i++) y[i]=g[i];
    fft(x,N),fft(y,N);
    for (int i=0;i<N;i++) x[i]=x[i]*1ll*y[i]%mod;
    reverse(w+1,w+N);
    fft(x,N);
    reverse(w+1,w+N);
    for (int i=0;i<N;i++) x[i]=x[i]*1ll*invN%mod;
    for (int i=p-1;i<N;i++) (x[i%(p-1)]+=x[i])%=mod,x[i]=0;
}
inline int solve(){
    f[0]=1;
    for (;n;n>>=1) {
        if (n&1) muil(f,g);
        muil(g,g);
    }
    return (f[ind[X]]+mod)%mod;
}
int main(){
    prepare();
    printf("%d
",solve());
    return 0;
}