NOIP模拟测试17

T1：入阵曲

　　题目大意：给定一个N*M的矩形，问一共有多少个子矩形，使得矩形内所有书的和为k的倍数。

　　60%：N，M<=80

　　　　枚举矩形的左上角和右下角，用二维前缀和求出数字之和。

　　　　时间复杂度$O(N^4)$

　　100%

　　　　我们发现美剧每个矩形的复杂度已经为N⁴，那么我们改为枚举矩形的边界。先枚举左右边界，再从上到下枚举下边界，两个矩形相减便可得出所有矩形，枚举时将每个矩形的区间和压入桶中，每次枚举时直接在桶中查询，左右边界更换时清桶。注意下边界要从0开始枚举。

　　　　时间复杂度$O(N^3)$

　　　　记得要卡常。

Code：

#include<iostream>
#include<cstdio>
const int L=1<<20|1;
char buffer[L],*S,*T;
#define getchar() ((S==T&&(T=(S=buffer)+fread(buffer,1,L,stdin),S==T))?EOF:*S++)
#define LL unsigned long long
#define rint register unsigned int
using namespace std;
const unsigned int N=410;
int n,m,d;
int s[N][N];
unsigned int dfn[2000010],t[2000010];
inline int read()
{
    rint s=0;char c=getchar();
    while(c<48||c>57) c=getchar();
    while(c>=48&&c<=57)s=(s<<3)+(s<<1)+(c^48),c=getchar();
    return s;
}
int main()
{
    n=read();m=read();d=read();
    for(rint i=1;i<=n;++i){
        for(rint j=1;j<=m;++j)
            s[i][j]=(s[i-1][j]+s[i][j-1]-s[i-1][j-1]+read())%d;
    }
    LL ans=0;rint df=0;
    for(rint i=1;i<=m;++i){
        for(rint j=i;j<=m;++j){
            dfn[0]=++df;t[0]=1;
            for(rint k=1;k<=n;++k){
                register int now=((s[k][j]-s[k][j-i])%d+d)%d;
                if(dfn[now]!=df){
                    dfn[now]=df;t[now]=1;
                }
                else{
                    ans+=t[now];++t[now];
                }
            }
        }
    }
    printf("%lld
",ans);
    return 0;
}

T2：将军令：

　　题目大意：给定一棵树，和一个距离K，在某个节点驻扎军队可以占领所有与该节点距离不超过K的点，求最少要驻扎多少军队。

　　此题和小胖守皇宫类似，不过权值均为一，可以用贪心做。

　　将所有的点按深度排序，从前往后扫，遇到未标记的点，则从他的K辈祖先处开始进行dfs，暴力标记，将ans加一，扫到最后的结果即是答案。

　　贪心策略证明：

　　　　由于每次找的是深度最大的点，那么每次dfs一定能标记到当前子树的所有儿子，同时要想使其他子树需要的军队尽可能少，则应再次条件下尽可能向上，越向上越能标记更多的点。证明完毕，贪心策略正确。

　　时间复杂度$O(NK)$

Code：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=100010;
int n,k,t,m=0,ans=0;
int fi[N],d[N],f[N];
bool v[N];
struct edge{
    int v,ne;
}e[N<<1];
struct point{
    int d,id;
}p[N];
void add(int x,int y)
{
    e[++m].v=y;
    e[m].ne=fi[x];fi[x]=m;
}
bool comp(const point a1,const point a2)
{
    return a1.d>a2.d;
}
int read()
{
    int s=0;char c=getchar();
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9'){
        s=(s<<3)+(s<<1)+c-'0';
        c=getchar();
    }
    return s;
}
void dfs(int x,int pa)
{
    p[x].id=x;
    for(int i=fi[x];i!=0;i=e[i].ne){
        int y=e[i].v;
        if(y==pa) continue;
        f[y]=x;
        p[y].d=p[x].d+1;
        dfs(y,x);
    }
}
void work(int x,int pa,int d)
{
    v[x]=true;
    if(d==0) return;
    for(int i=fi[x];i!=0;i=e[i].ne){
        int y=e[i].v;
        if(y==pa) continue;
        work(y,x,d-1);
    }
}
int main()
{
    n=read();k=read();t=read();
    for(int i=1;i<n;i++){
        int x=read(),y=read();
        add(x,y);add(y,x);
    }
    p[1].d=0;dfs(1,0);
    sort(p+1,p+n+1,comp);
    for(int i=1;i<=n;i++){
        int x=p[i].id;
        if(!v[x]){
            for(int i=1;i<=k&&f[x]!=0;i++)
                x=f[x];
            work(x,0,k);ans++;
        }
    }
    printf("%d
",ans);
    return 0;
}

T3：星空

　　题目大意：给一个0/1串，每次能将一个给定长度的区间去反，求最少要几次将整个串变为零。

　　0/1串长度：N<=40000，区间长度数：M<=64，1的个数：K<=8

　　24%做法：N<=16

　　　　直接状压，跑BFS即可。DFS会T飞

　　复杂度$O(N*2^N)$

　　100%做法：

　　　　我们发现相对于N，K很小，可以用来做做文章。

　　开始转化题意：

　　　　我们设灯亮为0，灯灭为1，则序列全为0时，所有灯都点亮。

　　　　不难发现当N很大时，该序列中仅有K个1，我们从0位开始将每一位与其后一位亦或，则最多有2K个数与前一位不同，最多有2K个1，每次选择一段区间[L，R]取反，仅会改变第L-1位和第R位的值，相当于将序列中一定距离的点同时取反。

　　题意转化为：给一个0/1串，每次选择相距给定长度的点同时取反，最少几次能将整个串全变为0。

　　若选择的两个书均为0，没有任何意义;

　　若选择的两个数均为1，则相互抵消;

　　若其中一个数为0，另一个数为1，相当与将1移动一定距离。

　　题意再次转化为：数轴上有最多2K个点，每次将一个点移动一段距离，两个点碰在一起后同时消失，最少几次能让所有点消失。

　　此时K的范围状压可以接受，BFS算出两点间移动的最少次数，用状压DP简单解决。

　　时间复杂度$O(MNK+K*2^K)$或$O(MNK+K^2*2^K)$

Code：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=40010;
const int inf=99999999;
int n,k,m,tot=0;
int a[N],b[N],v[N],c[20],d[20][20],e[100];
int dp[1<<16];
queue<int> q;
int read()
{
    int s=0;char c=getchar();
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9'){
        s=(s<<3)+(s<<1)+c-'0';
        c=getchar();
    }
    return s;
}
void bfs(int pos)
{
    int now=c[pos];
    memset(v,0,sizeof(v));
    v[now]=1;q.push(now);
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=1;i<=m;i++){
            int y=x+e[i];
            if(y<=n+1&&v[y]==0){
                v[y]=v[x]+1;q.push(y);
            }
            y=x-e[i];
            if(y>=1&&v[y]==0){
                v[y]=v[x]+1;q.push(y);
            }
        }
    }
    for(int i=1;i<=tot;i++){
        if(i!=pos){
            if(v[c[i]]==0) d[pos][i]=inf;
            else d[pos][i]=v[c[i]]-1;
        }
    }
}
int main()
{
    n=read();k=read();m=read();
    for(int i=1;i<=k;i++){
        int x=read();
        a[x]=1;
    }
    for(int i=0;i<=n;i++){
        b[i]=a[i]^a[i+1];
        if(b[i]==1) c[++tot]=i+1;    
    }
    for(int i=1;i<=m;i++)
        e[i]=read();
    for(int i=1;i<=tot;i++)
        bfs(i);
    for(int i=1;i<(1<<tot);i++)
        dp[i]=inf;
    for(int i=0;i<(1<<tot);i++){
        for(int j=1;j<=tot;j++){
            if(((i>>(j-1))&1)==1) continue;
            for(int g=1;g<=tot;g++){
                if(g==j) continue;
                if(((i>>(g-1))&1)==1) continue;
                dp[i|(1<<(j-1))|(1<<(g-1))]=min(dp[i|(1<<(j-1))|(1<<(g-1))],dp[i]+d[j][g]);
            }
        }
    }
    printf("%d
",dp[(1<<tot)-1]);
    return 0;
}