6.26考试总结(NOIP模拟10)[入阵曲·将军令·星空]
对于虚伪而言，真实的光明或许过于耀眼了
前言
这一次吧，考得特别烂，主要是这次考试想搞一下特殊性质，然后一不小心就因小失大弄巧成拙了下，下次注意吧。。
T1 入阵曲
暴力
思路
对于这个题的话，暴力的话55pts是没有问题的，无非是二维前缀和优化一下。
然后针对于特殊性质我们可以再骗到20pts，我们发现矩形是否整除 K 是与矩阵内的数字和矩形的边长是有关系的，接下来暴力扫就可以了。。
有一个比较遗憾的地方就是这个题考试的时候搞了1.5h，但是码最基础的暴力实际上只用了20min，然后对于特殊性质搞了挺长时间，主要是搞因数那一块思路错了，最后对于这个特殊性质草草地打了上面那个暴力就走了。。
code
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=4e2+10;
int n,m,ans,temp,mod,h[N][N],z[N][N],s[N][N],t[N][N];
int cnt,ys[N];
bool flag;
void check()
{
/*
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
cout<<t[i][j]<<' ';
cout<<endl;
}
// */
freopen("date.in","r",stdin);
// freopen("date.out","w",stdout);
}
inline void work(int x,int y)
{
for(int i=1;i<=x;i++)
for(int j=1;j<=y;j++)
if((t[x][y]-t[i-1][y]-t[x][j-1]+t[i-1][j-1])%mod==0)
ans++;
}
inline void solve_1()
{
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
h[i][j]=h[i][j-1]+s[i][j];
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
z[i][j]=z[i][j-1]+s[j][i];
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
t[i][j]=t[i][j-1]+z[j][i];
// check();
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
work(i,j);
}
inline void solve_2()
{
if(mod%temp==0)
mod/=temp;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(i*j%mod==0)
ans+=(n-i+1)*(m-j+1);
}
#undef int
int main()
{
#define int register long long
#define ll long long
// check();
scanf("%lld%lld%lld",&n,&m,&mod);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
scanf("%lld",&s[i][j]);
temp=s[1][1];
if(s[i][j]!=temp)
flag=true;
}
if(flag) solve_1();
else solve_2();
printf("%lld",ans);
return 0;
}
正解
思路
对于正解就是在先前暴力的思路上优化，发现在\(\bmod k\)的意义下相同的前缀和任意取两个枚举相减一定是 k 的倍数了。
因此我们枚举每一行以及他下面的行，然后再枚举列，对于不同的\(\bmod k\)余数记录并且更新就好了，最后注意清空就好了。
code
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=4e2+10,M=1e6+10;
int n,m,ans,mod,cnt[M],tmp[N],z[N][N],s[N][N],t[N][N];
inline void init()
{
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
z[i][j]=z[i][j-1]+s[j][i];
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
t[i][j]=(t[i][j-1]+z[j][i])%mod;
}
#undef int
int main()
{
#define int register long long
#define ll long long
scanf("%lld%lld%lld",&n,&m,&mod);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%lld",&s[i][j]);
init();
for(int i=0;i<n;i++)
for(int j=i+1;j<=n;j++)
{
cnt[0]=1;
for(int k=1;k<=m;k++)
{
tmp[k]=(t[j][k]-t[i][k]+mod)%mod;
ans+=cnt[tmp[k]];
cnt[tmp[k]]++;
}
for(int k=1;k<=m;k++)
cnt[tmp[k]]=0;
}
printf("%lld",ans);
return 0;
}
T2 将军令
暴力
思路
其实吧，这个题比上一个题还要遗憾。。
对于本题的暴力，直接dfs就好，但是考试的时候一开始想的是在树上直接进行的dfs，然后发现深度搜索好像压根就不行。。。
于是我们用将近1h换来了几乎0pts，然后考虑更改dfs思路。
想到一个比较妙的方法，我们不是在树上进行dfs，而是对于可以覆盖到的驿站，以及有小队的驿站的数量进行深搜，然后对于每一个没有过小队的点进行尝试。
- 注意：一定要在加小队的同时，扩散可以覆盖到的驿站，并及时进行回溯，不然就会5pts(code)
然后我们考虑特殊性质，发现对于所有节点到1距离不超过2的情况我们直接在1节点加入小队，在有子节点的深度为1的节点处加小队就好了。
暴力+特殊性质共计50pts。
当然，如果你打过小胖守皇宫这个题的话，对于k=1的情况也是50pts（反正我是一点都不记得了。。）
code
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+10,M=N<<1,INF=1e9;
int n,m,ans=INF,task,dep[N],f[N][20];
vector<int> v[N];
bool vis[N],vis1[N];
struct Edge
{
int tot,head[N],nxt[M],ver[M];
void add(int x,int y)
{
ver[++tot]=y;
nxt[tot]=head[x];
head[x]=tot;
}
}e;
void check()
{
freopen("date.in","r",stdin);
// freopen("date.out","w",stdout);
}
void dfs(int x,int fa)
{
dep[x]=dep[fa]+1;
f[x][0]=fa;
for(int i=0;f[x][i];i++)
f[x][i+1]=f[f[x][i]][i];
for(int i=e.head[x];i;i=e.nxt[i])
if(e.ver[i]!=fa)
dfs(e.ver[i],x);
}
int LCA(int x,int y)
{
if(x==y)
return x;
if(dep[x]>dep[y])
x^=y^=x^=y;
for(int i=20;i>=0;i--)
if(dep[f[y][i]]>=dep[x])
y=f[y][i];
if(x==y)
return x;
for(int i=20;i>=0;i--)
if(f[x][i]!=f[y][i])
{
x=f[x][i];
y=f[y][i];
}
return f[x][0];
}
int dist(int x,int y)
{
return dep[x]+dep[y]-2*dep[LCA(x,y)];
}
void dfs1(int tot,int cnt)
{
if(cnt>n)
return ;
if(tot>=n)
{
ans=min(ans,cnt);
return ;
}
if(cnt>=ans)
return ;
vector<int > vi;
for(int i=1;i<=n;i++)
{
if(vis[i])
continue;
bool temp=vis1[i];
vis[i]=vis1[i]=true;
vi.clear();
for(int j=1;j<=n;j++)
{
if(vis1[j])
continue;
for(int k=0;k<v[j].size();k++)
if(vis[v[j][k]])
{
vis1[j]=true;
tot++;
vi.push_back(j);
break;
}
}
dfs1(tot+(!temp),cnt+1);
tot-=vi.size();
vis[i]=false;
vis1[i]=temp;
for(int j=0;j<vi.size();j++)
vis1[vi[j]]=false;
}
}
void solve_1()
{
dfs(1ll,0ll);
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
{
int dis=dist(i,j);
if(dis<=m)
{
v[i].push_back(j);
v[j].push_back(i);
}
}
dfs1(0ll,0ll);
}
void solve_2()
{
// /*
dfs(1,0);
int flag=0;
int sum=0;
for(int i=2;i<=n;i++)
if(dep[i]==2&&e.nxt[e.head[i]])
sum++;
ans=sum+1;
// */
// ans=2;
}
#undef int
int main()
{
#define int register long long
#define ll long long
scanf("%lld%lld%lld",&n,&m,&task);
for(int i=1,x,y;i<n;i++)
{
scanf("%lld%lld",&x,&y);
e.add(x,y);
e.add(y,x);
}
if(!m) ans=n;
else if(task!=2) solve_1();
else solve_2();
printf("%lld",ans);
return 0;
}
正解
思路
与消防局的设立有亿些相似。
正解是贪心，首先对于深度从大到小排序，用dis数组记录距离这个点最近的有小队的驿站的数量。
如果一个点的dis大于k，那么我们直接在他的第k级祖先加入小队，然后更新深度更小的节点的dis值就好了。
最后统计一下dis为0的节点数就是答案了。
code
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+10,M=N<<1,INF=1e9;
int n,m,ans,task,id[N],dep[N],fa[N],dis[N],f[N];
struct Edge
{
int tot,head[N],nxt[M],ver[M];
void add(int x,int y)
{
ver[++tot]=y;
nxt[tot]=head[x];
head[x]=tot;
}
}e;
void dfs(int x,int fat)
{
dep[x]=dep[fat]+1;
fa[x]=fat;
for(int i=e.head[x];i;i=e.nxt[i])
if(e.ver[i]!=fat)
dfs(e.ver[i],x);
}
bool comp(int x,int y)
{
return dep[x]>dep[y];
}
#undef int
int main()
{
#define int register long long
#define ll long long
scanf("%lld%lld%lld",&n,&m,&task);
fill(dis+0,dis+n+1,INF);
for(int i=1,x,y;i<n;i++)
{
scanf("%lld%lld",&x,&y);
e.add(x,y);
e.add(y,x);
}
for(int i=1;i<=n;i++)
id[i]=i;
dfs(1ll,0ll);
sort(id+1,id+n+1,comp);
for(int i=1;i<=n;i++)
{
int cnt=0,x=id[i];
if(dis[x]<=m)
continue;
f[0]=x;
while(cnt<m&&f[cnt])
{
f[cnt+1]=fa[f[cnt]];
cnt++;
if(f[cnt])
dis[x]=min(dis[x],dis[f[cnt]]+cnt);
}
if(!f[cnt])
cnt=max(cnt-1,0ll);
if(dis[x]>m)
{
dis[f[cnt]]=0;
int fat=f[cnt],sum=0;
while(fat&&sum<=m)
{
dis[fat]=min(dis[fat],sum);
fat=fa[fat];
sum++;
}
}
}
for(int i=1;i<=n;i++)
if(!dis[i])
ans++;
printf("%lld",ans);
return 0;
}
T3 星空
解题思路
对于暴力就不多讲了，骗一下\(ans \le 4\)的分就好了，多了也骗不到。。
正解思路非常妙，官方的题解上说需要差分，但是个人感觉和差分关系下不大，无非是处理一下开关状态不同的边界，然后记录罢了。
其实如果时间允许的话我们可以通过bfs求出任意一点与其他点之间变成统一状态的最小操作次数。
但是我们发现所有真正有用的点只有\(2\times k\)个，所以只要bfs这几个点求出到其他点的距离就可以了。
然后由于k的数据比较小，我们直接对于k进行状压就好了，暴力枚举每一个边界点然后更新f数组，最后的满状态的就是ans了。
code
#include<bits/stdc++.h>
using namespace std;
const int N=4e4+10,M=18,K=70.,INF=1061109567;
int n,m,cnt,k,dis[M][N],len[K],f[1<<M],tmp[M];
bool s[N];
queue<int > q;
void bfs(int pos,int val)
{
dis[pos][val]=0;
q.push(val);
while(!q.empty())
{
int num=q.front();
q.pop();
for(int i=1;i<=m;i++)
{
if(num-len[i]>=0&&dis[pos][num-len[i]]>dis[pos][num]+1)
{
dis[pos][num-len[i]]=dis[pos][num]+1;
q.push(num-len[i]);
}
if(num+len[i]<=n&&dis[pos][num+len[i]]>dis[pos][num]+1)
{
dis[pos][num+len[i]]=dis[pos][num]+1;
q.push(num+len[i]);
}
}
}
}
int get_first(int state)
{
int sum=0;
while(!(state&(1<<sum)))
sum++;
return sum;
}
int work(int state)
{
if(f[state]!=INF)
return f[state];
if(!state)
return 0;
int pos=get_first(state);
for(int i=pos+2;i<=cnt;i++)
if(state&(1<<(i-1)))
f[state]=min(f[state],work(state^(1<<pos)^(1<<(i-1)))+dis[pos+1][tmp[i]]);
return f[state];
}
int main()
{
scanf("%d%d%d",&n,&k,&m);
memset(dis,0x3f,sizeof(dis));
memset(f,0x3f,sizeof(f));
for(int i=1,x;i<=k;i++)
{
scanf("%d",&x);
s[x]=true;
}
for(int i=1;i<=m;i++)
scanf("%d",&len[i]);
for(int i=0;i<=n;i++)
if(s[i]!=s[i+1])
tmp[++cnt]=i;
for(int i=1;i<=cnt;i++)
bfs(i,tmp[i]);
printf("%d",work((1<<cnt)-1));
return 0;
}
