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[];
 long long ans=;
 inline void _swap(int *a,int *b,int step) {
     for (int i=;i<=step;i++) swap(a[i],b[i]);
 }
 inline bool check(int x,int y) {return a[x+y]+==a[x+y+];}
 int dfs(int x,int y) {
     if (x==n+) return ans+=f[y];
     int w[],cnt=;
     int step=<<(x-);
     for (int i=;i<<<n;i+=<<x) {
         if (!check(i,step)) w[++cnt]=i;
         if (cnt>) return ;
     }
     if (cnt==) dfs(x+,y);
     if (cnt==) {
         _swap(a+w[],a+w[]+step,step);
         if (check(w[],step)) dfs(x+,y+);
         _swap(a+w[],a+w[]+step,step);
     }
     if (cnt==) {
         int *l1=a+w[],*l2=a+w[],*r1=a+w[]+step,*r2=a+w[]+step;
         _swap(l1,l2,step);
         if (check(w[],step)&&check(w[],step)) dfs(x+,y+);
         _swap(l1,l2,step);
         _swap(l1,r2,step);
         if (check(w[],step)&&check(w[],step)) dfs(x+,y+);
         _swap(l1,r2,step);
         _swap(r1,l2,step);
         if (check(w[],step)&&check(w[],step)) dfs(x+,y+);
         _swap(r1,l2,step);
         _swap(r1,r2,step);
         if (check(w[],step)&&check(w[],step)) dfs(x+,y+);
         _swap(r1,r2,step);
     }
 }

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

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*];
 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[]=;
     for (int l=,r=,u=q[];l<=r;u=q[++l]) {
         f[u][]=fa[u];
         for (int i=;i<maxk;i++) {
             if (f[f[u][i-]][i-]==) break;
             f[u][i]=f[f[u][i-]][i-];
         }
         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]+;
             q[++r]=edge[i].to;
         }
     }
     for (int i=n;i>;i--) {
         int u=q[i];
         s[u]++;s[fa[u]]+=s[u];
     }
     s[]++;
     for (int i=;i<=n;i++) {
         int u=q[i];
         dfn[u]=g[fa[u]]+;
         g[fa[u]]+=s[u];
         g[u]=dfn[u];
     }
 }
 inline int up(int x,int y) {
     for (int i=;i<maxk;i++) if ((<<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-;i+;i--) {
         if (f[x][i]==f[y][i]) continue;
         x=f[x][i];y=f[y][i];
     }
     return f[x][];
 }
 inline ll getdist(int x,int y) {return dis[x]+dis[y]-dis[lca(x,y)]*;}
 ll ans;
 typedef set<int,cmp>::iterator iter;
 inline void ins(int x) {
     if (ma.size()==) {
         ma.insert(x);return ;
     }
     if (ma.size()==) {
         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()==) return ;
     if (ma.size()==) {
         ans=;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=;i<n;i++) {
         int x,y,z;
         scanf("%d%d%d",&x,&y,&z);
         addedge(x,y,z);
     }
     bfs();
     for (int i=;i<=m;i++) {
         int x;
         scanf("%d",&x);
         b[x]^=;
         if (b[x]) ins(x);
         else del(x);
         if (ma.size()>=) printf("%lld\n",ans+getdist(*ma.begin(),*ma.rbegin()));
         else printf("0\n");
     }
     return ;
 }

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=;
 #define maxn 80100
 // template
 inline int power(ll x,int y,int mod) {
     ll t=;
     for (;y;y>>=,(x*=x)%=mod)
         if (y&) (t*=x)%=mod;
     return t;
 }
 int w[maxn];
 void fft(int *a,int n,int dep=) {
     if (n==) return ;
     static int tmp[maxn];
     int mid=n>>;
     fft(a,mid,dep+);fft(a+(<<dep),mid,dep+);
     for (int i=;i<mid;i++) {
         int s=a[(i<<)<<dep];
         int t=a[(i<<|)<<dep]*1ll*w[i<<dep]%mod;
         tmp[i]=(s+t)%mod;
         tmp[i+mid]=(s-t)%mod;
     }
     for (int i=;i<n;i++) a[i<<dep]=tmp[i];
 }
 int fft_g=;
 int N;
 inline void fft_init(){
     w[]=;
     int step=power(fft_g,(mod-)/N,mod);
     for (int i=;i<N-;i++) w[i+]=w[i]*1ll*step%mod;
 }
 int p;
 bool isroot(int x) {
     int sum=;
     for (int i=;i<p-;i++) {
         (sum*=x)%=p;
         if (sum==) return ;
     }
     return ;
 }
 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=;
     for (int i=;i<p&&!root;i++) if (isroot(i)) root=i;

     for (int i=,j=;i<p-;i++,(j*=root)%=p) ind[j]=i;
     for (int i=;i<=S;i++) {
         int x;
         scanf("%d",&x);
         if (x) g[ind[x]]=;
     }
     N=p<<;
     while (N&(N-)) N++;
     invN=power(N,mod-,mod);
     fft_init();
 }
 inline void muil(int *x,int *g){
     static int y[maxn];
     for (int i=;i<N;i++) y[i]=g[i];
     fft(x,N),fft(y,N);
     for (int i=;i<N;i++) x[i]=x[i]*1ll*y[i]%mod;
     reverse(w+,w+N);
     fft(x,N);
     reverse(w+,w+N);
     for (int i=;i<N;i++) x[i]=x[i]*1ll*invN%mod;
     for (int i=p-;i<N;i++) (x[i%(p-)]+=x[i])%=mod,x[i]=;
 }
 inline int solve(){
     f[]=;
     for (;n;n>>=) {
         if (n&) muil(f,g);
         muil(g,g);
     }
     return (f[ind[X]]+mod)%mod;
 }
 int main(){
     prepare();
     printf("%d\n",solve());
     return ;
 }