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=<<|;
 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=;
 int n,m,d;
 int s[N][N];
 unsigned int dfn[],t[];
 inline int read()
 {
     rint s=;char c=getchar();
     while(c<||c>) c=getchar();
     while(c>=&&c<=)s=(s<<)+(s<<)+(c^),c=getchar();
     return s;
 }
 int main()
 {
     n=read();m=read();d=read();
     for(rint i=;i<=n;++i){
         for(rint j=;j<=m;++j)
             s[i][j]=(s[i-][j]+s[i][j-]-s[i-][j-]+read())%d;
     }
     LL ans=;rint df=;
     for(rint i=;i<=m;++i){
         for(rint j=i;j<=m;++j){
             dfn[]=++df;t[]=;
             for(rint k=;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]=;
                 }
                 else{
                     ans+=t[now];++t[now];
                 }
             }
         }
     }
     printf("%lld\n",ans);
     return ;
 }

T1

T2：将军令：

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

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

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

　　贪心策略证明：

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

　　时间复杂度$O(NK)$

Code：

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

T2

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=;
 const int inf=;
 int n,k,m,tot=;
 int a[N],b[N],v[N],c[],d[][],e[];
 int dp[<<];
 queue<int> q;
 int read()
 {
     int s=;char c=getchar();
     while(c<''||c>'') c=getchar();
     while(c>=''&&c<=''){
         s=(s<<)+(s<<)+c-'';
         c=getchar();
     }
     return s;
 }
 void bfs(int pos)
 {
     int now=c[pos];
     memset(v,,sizeof(v));
     v[now]=;q.push(now);
     while(!q.empty()){
         int x=q.front();q.pop();
         for(int i=;i<=m;i++){
             int y=x+e[i];
             if(y<=n+&&v[y]==){
                 v[y]=v[x]+;q.push(y);
             }
             y=x-e[i];
             if(y>=&&v[y]==){
                 v[y]=v[x]+;q.push(y);
             }
         }
     }
     for(int i=;i<=tot;i++){
         if(i!=pos){
             if(v[c[i]]==) d[pos][i]=inf;
             else d[pos][i]=v[c[i]]-;
         }
     }
 }
 int main()
 {
     n=read();k=read();m=read();
     for(int i=;i<=k;i++){
         int x=read();
         a[x]=;
     }
     for(int i=;i<=n;i++){
         b[i]=a[i]^a[i+];
         if(b[i]==) c[++tot]=i+;
     }
     for(int i=;i<=m;i++)
         e[i]=read();
     for(int i=;i<=tot;i++)
         bfs(i);
     for(int i=;i<(<<tot);i++)
         dp[i]=inf;
     for(int i=;i<(<<tot);i++){
         for(int j=;j<=tot;j++){
             if(((i>>(j-))&)==) continue;
             for(int g=;g<=tot;g++){
                 if(g==j) continue;
                 if(((i>>(g-))&)==) continue;
                 dp[i|(<<(j-))|(<<(g-))]=min(dp[i|(<<(j-))|(<<(g-))],dp[i]+d[j][g]);
             }
         }
     }
     printf("%d\n",dp[(<<tot)-]);
     return ;
 }

T3