Noip模拟10 2021.6.27

T1 入阵曲

好了，又一个考试败笔题。

也就是在那个时候，小 F 学会了矩阵乘法。让两个矩阵乘几次就能算出斐波那契数， 真是奇妙无比呢。
不过， 小 F 现在可不想手算矩阵乘法——他觉得好麻烦。取而代之的，是一个简单的小问题。

题目清奇的叙述i引起小马清奇的思路——矩阵快速幂优化dp。于是开始了推柿子。。。

一小时，两小时，可恶，还没推出来，唉出来了。。等等，不对。。。

两个半小时将近三小时的时候，算了打暴力吧。。

然后就，唉。

可是这题并非矩阵乘法，草。。。。

那他疯狂diss我干嘛~～

60分很好拿到，不过当时太慌就没打前缀和，n^6暴力直接跑了，惨淡45。。。

正解就是在60暴力上加了一个优化。

he[k]表示两行之间的矩形的前缀和，num[k]表示出现的矩形的对数（记录有几对）。

因为，在模k意义下的前缀和，任取两个矩形前缀和相减必定是k的倍数。

num也就是统计模k相同的矩阵的个数。

#include<bits/stdc++.h>
#define write(X) printf("%lld",X)
#define read(X) scanf("%lld",&X)
#define rint register long long
#define int long long
using namespace std;

const int NN=1e6+10;
int n,m,p,rp;
int num[NN],he[NN];
int sum[405][405],a[405][405];

inline void init(){
    read(n); read(m); read(p);
    for(rint i=1;i<=n;i++) for(rint j=1;j<=m;j++)
        read(a[i][j]),a[i][j]%=p;
    for(rint i=1;i<=n;i++) for(rint j=1;j<=m;j++)
        sum[i][j]=(sum[i][j-1]+a[i][j])%p;
    for(rint i=1;i<=n;i++) for(rint j=1;j<=m;j++)
        sum[i][j]=(sum[i][j]+sum[i-1][j])%p;
}

namespace WSN{
    inline int main(){
        init();
        for(rint i=0;i<n;i++)
            for(rint j=i+1;j<=n;j++){
                num[0]=1;
                for(rint k=1;k<=m;k++){
                    he[k]=(sum[j][k]-sum[i][k]+p)%p;
                    rp+=num[he[k]]++;
                }
                for(int k=1;k<=m;k++) num[he[k]]=0;
            }
        write(rp); putchar('\n');
        return 0;
    }
}
signed main(){return WSN::main();}

T2 将军令

题目猛一看，这不就是小胖守皇宫吗？不过K的值更大就不会考虑了。。

其实，应该考虑贪心。

从深度最深的点开始向上找他的K级父亲，这样的话从K级父亲开始将能够管到的点全部标记，找就可以了。

#include<bits/stdc++.h>
#define r(X) scanf("%d",&X)
#define w(X) printf("%d\n",X)
#define Min(A,B) ((A)<(B)?(A):(B))
#define rint register int
using namespace std;

const int NN=1e5+10;
int n,k,t,d[NN],fa[NN][25],ans;
bool vis[NN];
struct SNOW{int to,next;}; SNOW e[NN<<1]; int head[NN],tot;
inline void add(int x,int y){ e[++tot]=(SNOW){y,head[x]}; head[x]=tot;}
struct snow{
    int dep,id;
}; snow m[NN];
inline bool cmp(snow a,snow b){return a.dep>b.dep;}

inline void dfs1(int f,int x){
    for(rint i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y==f) continue;
        m[y].dep=m[x].dep+1; fa[y][1]=x;
        for(rint j=2;j<=Min(k,m[y].dep);j++) fa[y][j]=fa[fa[y][j-1]][1];
        dfs1(x,y);
    }
}

inline void dfs2(int pre,int x,int tmp){
    vis[x]=1;
    if(!tmp) return;
    for(rint i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y==pre) continue;
        dfs2(x,y,tmp-1);
    }
}

namespace WSN{
    inline int main(){
        r(n); r(k); r(t);
        for(rint i=1,x,y;i<n;i++)
            r(x),r(y),add(x,y),add(y,x),m[i].id=i;
        if(k==0) {w(n);return 0;}
        m[n].id=n;
        dfs1(0,1);
        sort(m+1,m+n+1,cmp);
        for(rint i=1;i<=n;i++) if(!vis[m[i].id]){
            rint f=fa[m[i].id][k];
            ans++,dfs2(-1,f,k);
        }
        w(ans);
        return 0;
    }
}
signed main(){return WSN::main();}

T3 星空

此题思维量较大，融合状压，最短路，差分思想于一体。

记录1为灭，0为开。

首先可以看到操作是在一段上取反，可以用差分O(1)进行修改，于是我们先维护一个差分数组nu（注意n++，以为要把最后一个数的差分记上）。这样，这个0/1串差分数组上就有不超过2×k个1（因为原数组中每出现一个1，差分数组中要可能出现两个）。

这样问题转化为：

需要从一串数上取间隔为b[i]的两个数进行取反，问最少多少次把整个串变成0

然后我们再看，如果把每次操作视为一次移动，即把一段长度为b[i]左端点的数移动到右端点+1并与之相抑或。若两者都是1，则相消，若一个是1，一个是0，则可看作移动，两个都是0，则可以看作不动。这样，问题转化成：

在一个有n个节点的无向图中，每个节点连m条边，你要找到每一个1移动到另一个1的最短距离，求总的最短距离

这样的话可以用spfa（其实直接bfs也可以，以为不用去再更新之前的点的距离）求最短路。预处理出每个最短路因此我们可以发现用状压比较好解决，压的是不超过2×k个1的状态。

再提一下，在进行状压的时候，不用顾及前面枚举过的点，那些点的值已经处理好了，因此直接先找到你要取的点，即NUM1+1，从这一个开始枚举后面的是1的点就行。

#include<bits/stdc++.h>
#define r(X) scanf("%d",&X)
#define w(X) printf("%d\n",X)
using namespace std;

int n,k,m,b[70];
bool a[60005],vis[60005];
bool nu[60005];//差分
queue<int> q;
vector<int> sh;
int dis[17][60005];//一维只开为1的点
int dp[1<<18];
inline void bfs(){
    for(int i=0;i<sh.size();i++){
        int st=i,dian=sh[i];
        for(int i=0;i<=n;i++) vis[i]=0;
        dis[st][dian]=0;  vis[st]=true; q.push(dian);
        while(!q.empty()){
            int x=q.front(); q.pop(); vis[x]=false;
            for(int i=1;i<=m;i++){
                int y1=x+b[i],y2=x-b[i];
                if(y1<=n){
                    if(dis[st][y1]>dis[st][x]+1){
                        dis[st][y1]=dis[st][x]+1;
                        if(!vis[y1]) vis[y1]=true,q.push(y1);
                    }
                }
                if(y2>0){
                    if(dis[st][y2]>dis[st][x]+1){
                        dis[st][y2]=dis[st][x]+1;
                        if(!vis[y2]) vis[y2]=true,q.push(y2);
                    }
                }
            }
        }
    }
}

namespace WSN{
    inline int main(){
        r(n); r(k); r(m);
        for(int i=1,x;i<=k;i++) r(x),a[x]=1;
        for(int i=1;i<=m;i++) r(b[i]);
        n++;
        for(int i=1;i<=n;i++){
            nu[i]=a[i]^a[i-1];
            if(nu[i]) sh.push_back(i);
        }
        int pot=sh.size();
        for(int i=0;i<=pot;i++) for(int j=0;j<=n;j++)
            dis[i][j]=99999999;
        bfs();
        int ti=(1<<pot)-1;
        memset(dp,0x3f,sizeof(dp));
        dp[0]=0;
        for(int sta=0;sta<=ti;sta++){
            int num1=0; while((sta&(1<<num1))) num1++;
            for(int i=num1+1;i<=pot;i++){
                if(!(sta&(1<<i))) dp[sta|1<<i|1<<num1]=min(dp[sta|1<<i|1<<num1],dp[sta]+dis[num1][sh[i]]);
            }
        }
        w(dp[ti]);
        return 0;
    }
}
signed main(){return WSN::main();}

总结一下这次打挂：

先打暴力，在没打暴力的时候想正解显然是非常弱智的行为（由杠哥大定理可得），

还有就是别被题目的无关题干骗了，觉得是啥就打啥。。。