考后总结：
kzsn这次终于AC了两道题了！！！
感动，虽然与巨佬还有很大差距！
T1，其实我有小失误，我当时不确定自己的ST表写的对不对，所以不太敢写。
考场我去写了线段树求区间最值，按理说这样的复杂度O(nlognlogn)，肯定过不去的！
不过呢，在补题的过程中，我还是把ST表给补了，并写了个博客来记忆！
居然还学了个“滚动数组式的ST表”，真不错。
T2，还是忘了打表找规律，而且连基本的组合数都没有理解(多半是当时做晕了！)
补题时倒是思路很清晰。。。
对了，从巨佬口中得知，像这样有倍数关系的东西，可以多往倍数方面想，而非因数。
T3，拉丁方阵，很好想的构造题，但当时似乎脑子有点晕，一直不太敢写上去，于是拿了将近1小时去证明。。。
不过还好，至少证明出来后，自己勇敢的写了上去。
T4，应该是一道找规律题，可惜自己没搞出来。
应该先从简单的形式：1.没有障碍；2.只有一个障碍；3.两个障碍或多个障碍！
其实讲题的时候我没怎么听得懂，只好自己后来又慢慢推，事实证明自己还是能找到规律的，就是感觉思路每次都很不清晰，总要想很久。
T1 单词表
你要将 n 个单词填入Excel表格。
填写规律：按
照列的顺序从上到下一次填入单词，当一列填满后再开始填写下一列，
Excel表格会根据每一列的单词长度动态调整当前列的宽度。
每一列的宽度与列中最长单词保持一致。
同时为了分隔两列单词，两列间会留一个字符长度的空白。
注意：除了最后一列，其他列必须填满。
由于电脑屏幕宽度有限，每一行最多只能有 w 个字符。
问，在宽度不超过 w 的前提下，高度最少为多少。
数据范围：
1<=n<=10^6, 1<=ai<=w<=10^9
这道题读题很关键啊，听说有巨佬读题读挂了。我也看了好久，才发现它的顺序就是输入顺序。
如果我们需要判断 i 行能不能行，其实是很好判断的。
由于高度为 i ，所以每一列分别为 [(k-1)*i+1, k*i]，我们只需要在这 n/i 列每列都求最大值，即可知道宽度。
kzsn最开始还不太敢写，就是因为枚举的那个 n/i ，这样枚举是调和级数！
所以可以证明，这样枚举也就 O(n lnn)，接下来就需要大约 O(1)求最大值！
对了，赛后这道题调成了 32M，其实还是可以做的。
由于我们用ST表的区间跨度是逐渐上升的，所以ST表的前一维没必要记了。
只需要一遍求值，一遍更新ST表即可。跑的飞快！
#include<stdio.h>
inline int max(const int x,const int y){return x>y?x:y;}
#define re register int
#define LL long long
static char buf[1<<20], *p1, *p2;
#define gc() (p1==p2&&(p2=(p1=buf)+fread(buf, 1, 1<<20, stdin), p1==p2)?EOF:*p1++)
inline int read(){
int x=0;
char c=gc();
for(;c<'0'||c>'9';c=gc());
for(;c>='0'&&c<='9';c=gc())x=(x<<1)+(x<<3)+c-'0';
return x;
}
const int N=1e6+6;
int f[N];
signed main()
{
int n=read(), w=read();
for(re i=1;i<=n;++i) f[i]=read();
for(re i=1, S=1; i<=n; ++i)
{
if(i>=(S*2)){
for(re j=1;j<=n;++j)
f[j]=j+S<=n?max(f[j], f[j+S]):f[j];
S<<=1;
}
LL ret=0;
int lst=1;
for(re j=i;j<=n && ret<=1ll*w;)
{
ret+=(lst<=j-S+1)?max(f[lst], f[j-S+1]):f[lst];
if(j!=n)ret++;else break;
lst=j+1;
j+=i;
if(j>n)j=n;
}
if(ret<=w){printf("%d", i);return 0;}
}
return 0;
}
View Code
T2 序列与改写 NKOJ8700
一个数 x ，可以改变成 y ，当且仅当：
1. x % y == 0;
2. (x & y) == y;
给你一个序列 ai ，每一步从序列中任选一个可以被改变的数并改写。
经过若干次修改后，数列变得不能修改。问有多少种改写方式。
结果 mod 998244353。
数据范围：
1<=n<=2000; 1<=ai<=1000000;
遇到这种题，以后一定要打一下表，来看每个数最多会被改写多少次。
经过打表可以得到，一个数最多会被改写4次。
这道题使用dp。
我们设 dp[i][j] 表示将前 i 个数全部变得不能修改 用 j 步 的方案数。
如果第 i+1 个数我们用了 k 次才将它变得不能修改， 那么 dp[i+1][j+k] += dp[i][k] * cnt[i+1][k] * C[j+k][j]。
其中，cnt[i][j] 表示第 i 个数用 j 次操作变不能修改的方案数，这个可以提前预处理出。
C[n][m] 是组合数，从 n 个里面选 m 个的方案数。
组合数这里指的是：当前k步操作可以穿插在这j+k中的任意位置。
对了，大佬说了，像这种有倍数关系的东西，可以多往枚举倍数去想，而非去找一个数的因数。
#include<bits/stdc++.h>
using namespace std;
#define re register int
#define LL long long
const int N=5e6+6, mo=998244353;
LL fac[N], inv[N];
inline LL getc(int x,int y)
{
if(x<y)return 0;
if(y==0||y==x)return 1;
return fac[x]*inv[y]%mo*inv[x-y]%mo;
}
inline LL ksm(LL x, int y)
{
LL ret=1;
while(y)
{
if(y&1)ret=ret*x%mo;
y>>=1;
x=x*x%mo;
}
return ret;
}
int las[N], ed[N], nt[N], tt;
inline void add(int x,int y){ed[++tt]=y;nt[tt]=las[x];las[x]=tt;}
int cnt[2005][10];
LL dp[2005][8005];
inline void DFS(int x, int step, int id)
{
int flag=0;
for(re i=las[x];i;i=nt[i])
{
int v=ed[i];
flag=1;
DFS(v, step+1, id);
}
if(!flag)cnt[id][step]++;
}
signed main()
{
int n;
scanf("%d",&n);
fac[0]=1;
for(re i=1;i<=n*4;++i)
fac[i]=fac[i-1]*i%mo;
inv[4*n]=ksm(fac[4*n], mo-2);
for(re i=4*n-1;i;--i)
inv[i]=inv[i+1]*(i+1)%mo;
for(re i=1;i<=1000000;++i)
for(re j=2;i*j<=1000000;++j)
if(((i*j)&i)==i)add(i*j, i);
for(re i=1;i<=n;++i)
{
int x;
scanf("%d",&x);
DFS(x, 0, i);
}
dp[0][0] = 1;
for(re i=0;i<=n;++i)
{
for(re j=0;j<=n*4;++j)
if(dp[i][j])
{
for(re k=0;k<=4;++k)
if(cnt[i+1][k])
dp[i+1][j+k]=(dp[i+1][j+k]+dp[i][j]*cnt[i+1][k]%mo*getc(j+k, k)%mo)%mo;
}
}
int ans=0;
for(re i=0;i<=4*n;++i)
ans=(ans+dp[n][i])%mo;
printf("%d", ans);
return 0;
}
View Code
T3 拉丁方阵 NKOJ8701
拉丁方阵是一类 n * n 的整数矩阵，矩阵的每一行每一列都是 1 ~ n 的排列。
对矩阵的操作:
每次选择一行一列，将这个“十”字形区域每个数加 1 或减 1.
现在给定两个拉丁方阵 A 和 B，请通过若干操作将 A 变成 B。
数据范围：
2<=n<=100
这道题的结论很好想，就是将AB矩阵对应位相减后，若某位置为负数，就加1，若为正数，就减1。
至于为什么呢，“读者自证不难”！
#include<bits/stdc++.h>
using namespace std;
#define re register int
#define py pair<int,int>
vector<py>A, B;
int a[105][105], b[105][105], c[105][105];
signed main()
{
int n;
scanf("%d",&n);
for(re i=1;i<=n;++i)
for(re j=1;j<=n;++j)
scanf("%d",&a[i][j]);
for(re i=1;i<=n;++i)
for(re j=1;j<=n;++j)
scanf("%d",&b[i][j]);
for(re i=1;i<=n;++i)
for(re j=1;j<=n;++j)
c[i][j]=a[i][j]-b[i][j];
for(re i=1;i<=n;++i)
for(re j=1;j<=n;++j)
{
if(c[i][j]>0)
{
while(c[i][j])
{
A.push_back(py(i, j));
c[i][j]--;
}
}
if(c[i][j]<0)
{
while(c[i][j])
{
B.push_back(py(i, j));
c[i][j]++;
}
}
}
printf("%d\n", (int)A.size()+(int)B.size());
for(py i:A)printf("%d %d +\n", i.first, i.second);
for(py i:B)printf("%d %d -\n", i.first, i.second);
return 0;
}
T4 寻路游戏 NKOJ8702
一个 n * m 的矩阵，有 k 个障碍物。
因此每一行以及每一列中最多只有 个障碍物。
同时，为了保证棋盘的连通性，每个障碍物周围相邻的 8 格都不会有其它障碍物。
求任意两个格子(不能是障碍物)作为起点终点的所有情况下最短路径的长度总和。
矩阵上每一步只能在上下左右四个方向中选择一个移动一格。
数据范围：
1<=n,m<=1000
这道题需要很长时间的推理。
problem1 ：如果没有障碍物我们该怎么做？
solution1 ： 由于这个距离是曼哈顿距离，所以我们可以把距离拆成 x 方向，和 y 方向来分别求，这个特别好写，O(n)。
problem2：有障碍会有什么影响？
solution2：这会导致一些点对的距离增加2,。
problem3：有一个障碍物怎么搞？
solution3：对于障碍物为中心的十字架形的地方会影响，其余无影响。所以跟solution1差不多得到一定答案，再加上一些最短路会增加2的点对。
problem4：很多障碍物怎么办？
solution4：会发现，当且仅当一连串障碍物是挨在一起的且递增或递减，才会导致不同行或列的点所需代价增加2。
这里我们可以O(k)算出这些代价
注意要开longlong，交题前一定要严格检查long long
#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
#define re register int
#define int long long
const int N=1005;
int mp[N][N], A[N], B[N];
int ans, k;
struct node{
int x, y;
bool operator<(const node&p)const{
return y<p.y;
}
}p0[N], p[N];
int cnt[N][2];
inline void solve(int n)
{
sort(p+1, p+1+k);
for(re i=1;i<=k;++i)
{
cnt[i][0]=n-p[i].x;
cnt[i][1]=p[i].x-1;
}
for(re i=1;i<=k;++i)
{//可结合自己画的图来看
int j=i, sum=cnt[i][1];
while(j<k && p[j].y+1==p[j+1].y && p[j].x<p[j+1].x)
{
j++;
ans += sum * cnt[j][0] * 4;
sum += cnt[j][1];
}
i = j;
}
}
signed main()
{
int n, m;
scanf("%lld%lld%lld",&n,&m,&k);
for(re i=1;i<=k;++i)
{
int x, y;
scanf("%lld%lld",&x,&y);
ans += ((x-1)*(n-x) + (y-1)*(m-y)) * 4;
A[x]=B[y]=1;
p0[i]=(node){x, y};
}
for(re i=1, tot=0, num=0; i<=n; ++i)
{
int t=m-A[i];
ans += t*tot*2;
num += t;
tot += num;
}
for(re i=1, tot=0, num=0; i<=m; ++i)
{
int t=n-B[i];
ans += t*tot*2;
num += t;
tot += num;
}
// 坐标转换
for(re i=1;i<=k;++i)p[i]=(node){p0[i].x, p0[i].y};
solve(n);
for(re i=1;i<=k;++i)p[i]=(node){p0[i].x, -p0[i].y};
solve(n);
for(re i=1;i<=k;++i)p[i]=(node){p0[i].y, p0[i].x};
solve(m);
for(re i=1;i<=k;++i)p[i]=(node){p0[i].y, -p0[i].x};
solve(m);
printf("%lld", ans);
return 0;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
