NOIP提高组模拟赛16
A. 茅山道术
简单\(DP\)，只考虑相邻两个同色的是否使用就行
code
#include <cstring>
#include <cstdio>
using namespace std;
const int maxn=1000005;
const int mod=1e9+7;
int rem[maxn],c[maxn],las[maxn],pos[maxn],n;
bool vis[maxn];
int work(int x){
if(x>n)return 1;
if(vis[x])return rem[x];
vis[x]=1;
if(pos[x]&&pos[x]!=x+1)return rem[x]=(1ll*work(pos[x])+work(x+1))%mod;
return rem[x]=work(x+1);
}
int main(){
freopen("magic.in","r",stdin);
freopen("magic.out","w",stdout);
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%d",&c[i]);
for(int i=n;i>=1;--i){
pos[i]=las[c[i]];
las[c[i]]=i;
}
int aas=work(1);
printf("%d\n",aas);
return 0;
}
B. 泰拳警告
这题不难，如果你知道组合数的一些性质会更加简单，不会像我一样还要想垃圾\(dp\)
期望=概率*得分=总得分/总方案数
把平局看成\(p\)种方案，这样算出总得分最后乘以\((p+2)^n\)的逆元即可
得分与平局数相关，考虑枚举平局数\(k\)，假设我们知道剩下\(n-k\)轮中，只考虑胜负，胜局多于负局的方案数\(f[n-k]\)
那么总得分为\(\sum_{k=0}^n (k+1)\times f[n-k]\times C_n^k\)(可以在\(n\)轮中任意\(k\)轮平局，所以需要乘上\(C_n^k\))
剩下的问题变成求解\(f[n-k]\)
不妨求\(f[i]\)
当前这一轮只有两种情况胜或负
如果当前胜，那么需要知道前\(i-1\)轮 胜场\(>=\)负场 的方案数
也就是 \(f[i-1]+\)前\((i-1)\)轮 胜场等于负场 的方案数
如果\(i-1\)是偶数那么后者的方案数就是\(C_{i-1}^{(i-1)/2}\)，如果\(i-1\)是奇数，那么不存在后者
如果当前负，那么需要知道前\(i-1\)轮，胜场\(>\)负场\(+1\) 的方案数
也就是 \(f[i-1]-\)前\((i-1)\)轮 胜场 等于 负场\(+1\) 的方案数
如果\(i-1\)是奇数那么后者的方案数就是\(C_{i-1}^{(i-1)/2}\)，如果\(i-1\)是偶数,那么不存在后者
这样就能解出\(f[]\)了
code
#include <cstring>
#include <cstdio>
using namespace std;
const int maxn=3000005;
const int mod=998244353;
int jc[maxn],inv[maxn],n,p;
int qpow(int x,int y){
int ans=1;
while(y){
if(y&1)ans=1ll*ans*x%mod;
x=1ll*x*x%mod;
y>>=1;
}
return ans;
}
void ycl(){
jc[0]=jc[1]=inv[0]=1;
for(int i=2;i<=n;++i)jc[i]=1ll*jc[i-1]*i%mod;
inv[n]=qpow(jc[n],mod-2);
for(int i=n-1;i>=1;--i)inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
int get_C(int n,int m){return 1ll*jc[n]*inv[n-m]%mod*inv[m]%mod;}
int f[maxn];
int main(){
freopen("fight.in","r",stdin);
freopen("fight.out","w",stdout);
scanf("%d%d",&n,&p);
ycl();
f[1]=f[2]=1;
for(int i=3;i<=n;++i){
f[i]=1ll*f[i-1]*2%mod;
if(i&1) f[i]=(1ll*f[i]+get_C(i-1,(i-1)>>1))%mod;
else f[i]=(1ll*f[i]-get_C(i-1,i>>1)+mod)%mod;
}
int ans=0,pk=1;
for(int k=0;k<=n;++k){
ans=(ans+1ll*get_C(n,k)*pk%mod*f[n-k]%mod*(k+1)%mod)%mod;
pk=1ll*pk*p%mod;
}
int in=qpow(p+2,n);
in=qpow(in,mod-2);
ans=1ll*ans*in%mod;
printf("%d\n",ans);
return 0;
}
C. 万猪拱塔
奇妙的线段树维护
发现符合要求的子矩阵一定是值域连续的，然后上题解。。。
考虑判定值在区间 \([l,r]\) 内的所有数所在的格子是否形成了一个矩形，记这些
格子的颜色为黑色，其它的格子颜色为白色。
考虑所有的 \((n + 1) ×(m + 1)\)个\(2 ×2\)的小正方形 (部分超出边界也算)，则所有
黑色格子形成一个矩形，当且仅当恰好有 \(4\) 个小正方形内部有 \(1\) 个黑色格子，
并且没有任何一个小正方形内部有 \(3\) 个黑色格子
从小到大枚举 \(r\) ，对每个\(l ≤r\)，记 \(f(l)\) 表示染黑权值在 \([l,r]\)内的格子后，有多
少小正方形内部有\(1\)个或\(3\)个黑色格子
可以发现有 \(f(l) ≥4\),\(f(r) = 4\) ，于是只需要对每个 \(l\) 维护 \(f(l)\) 最小值，最小值的
数目和取得最小值的所有 \(l\) 之和
每次\(r\) 增加\(1\) 时，会影响到周边的\(4\) 个\(2 ×2\) 的小正方形，在线段树上修改即可
时间复杂度 \(O(nm log nm)\)
code
#include <cstring>
#include <cstdio>
#include<algorithm>
#include<unordered_map>
typedef long long ll;
using namespace std;
void swap(int &x,int &y){x^=y;y^=x;x^=y;}
ll min(ll x,ll y){return x<y?x:y;}
ll max(ll x,ll y){return x>y?x:y;}
const int maxn=200005;
const int mod=998244353;
unordered_map<ll,ll>mp[maxn];
struct node{ll cnt,lazy,sum,min;}ret;
int n,m;
struct tree{
node t[maxn<<2|1];
void built(int x ,int l,int r){
if(l==r){
t[x].cnt=1;
t[x].sum=l;
return;
}
int mid=(l+r)>>1;
built(x<<1,l,mid);
built(x<<1|1,mid+1,r);
}
void push_up(int x){
t[x].sum=t[x].cnt=0;
t[x].min=min(t[x<<1].min,t[x<<1|1].min);
if(t[x].min==t[x<<1].min)t[x].cnt+=t[x<<1].cnt,t[x].sum+=t[x<<1].sum;
if(t[x].min==t[x<<1|1].min)t[x].cnt+=t[x<<1|1].cnt,t[x].sum+=t[x<<1|1].sum;
}
void push_down(int x){
t[x<<1].lazy+=t[x].lazy;
t[x<<1|1].lazy+=t[x].lazy;
t[x<<1].min+=t[x].lazy;
t[x<<1|1].min+=t[x].lazy;
t[x].lazy=0;
}
void modify(int x,int l,int r,int L,int R,ll z){
if(L>R)return;
if(L<=l&&r<=R){
t[x].lazy+=z;
t[x].min+=z;
return;
}
int mid=(l+r)>>1;
if(t[x].lazy)push_down(x);
if(L<=mid)modify(x<<1,l,mid,L,R,z);
if(R>mid)modify(x<<1|1,mid+1,r,L,R,z);
push_up(x);
}
void query(int x,int l,int r,int L,int R){
if(L<=l&&r<=R){
if(t[x].min==4){
ret.sum+=t[x].sum;
ret.cnt+=t[x].cnt;
}
return;
}
if(t[x].lazy)push_down(x);
int mid=(l+r)>>1;
if(L<=mid)query(x<<1,l,mid,L,R);
if(R>mid)query(x<<1|1,mid+1,r,L,R);
}
}T;
struct tpp{int x,y;}tp[maxn];
int ls[25];
void work(int x,int y,int w){
ll cnt=0,p,k=1;
ls[++cnt]=mp[x][y];
ls[++cnt]=mp[x-1][y-1];
ls[++cnt]=mp[x-1][y];
ls[++cnt]=mp[x][y-1];
sort(ls+1,ls+cnt+1);
p=lower_bound(ls+1,ls+cnt+1,w)-ls;//防止更新非法状态
for(p;p>=1;--p,k*=-1)T.modify(1,1,n,ls[p-1]+1,ls[p],k);
}
int main(){
freopen("pig.in","r",stdin);
freopen("pig.out","w",stdout);
scanf("%d%d",&n,&m);
for(int i=0;i<=n+1;++i)mp[0][i]=mp[n+1][i]=mp[i][0]=mp[i][n+1]=maxn;
for(int i=1;i<=n;++i)
for(int j=1;j<=m;++j){
scanf("%d",&mp[i][j]);
tp[mp[i][j]].x=i;tp[mp[i][j]].y=j;
}
n=n*m;
T.built(1,1,n);
long long ans=0;
for(int i=1;i<=n;++i){
//对受影响的四个矩形进行操作
work(tp[i].x,tp[i].y,i);
work(tp[i].x+1,tp[i].y+1,i);
work(tp[i].x+1,tp[i].y,i);
work(tp[i].x,tp[i].y+1,i);
//查询当前贡献
T.query(1,1,n,1,i);
ans=(ans+(i+1)*ret.cnt-ret.sum+mod)%mod;
ret.cnt=ret.sum=0;
}
printf("%lld\n",ans);
return 0;
}
D. 抑郁刀法
不会。这题给我的唯一收获--了解了什么是\(NPC\)问题
粘一下题解
考虑对图进行收缩，对于度数为 \(1\)的点，可以直接将其删掉，并将最后答案乘
上 \((k −1)\)
对于度数为 \(2\) 的点，记它连向的两个点分别为\(a,b\)
将这个点删掉，若最后 \(a,b\) 之间同色，则有 \(k −1\) 种情况它与 \(a,b\) 都异色，有 \(1\)
种情况它与 \(a,b\) 都同色
若 \(a,b\) 之间异色，则有 \(k −2\) 种情况它与 \(a,b\) 都异色，有\(1\)种情况与\(a\)同色，\(1\) 种情况与 \(b\) 同色
我们为每两个点之间记录\(f(a,b),g(a,b)\)分别表示它们同色时答案乘上的系数，异色时答案乘上的系数。
在删掉度数为\(2\)的点时更新对应的 \(f(a,b)\) 即可
最终得到的图中，每个点度数至少为 \(3\) ，结合 \(m ≤n + 5\) 可算出 \(n ≤10,m ≤15\)
对这个图做状压 \(dp\) ，并考虑上 \(f,g\) 的系数即可
状压 \(dp\) ，每次选择一个未染色的子集进行染色，时间复杂度 \(O(nm3^n)\)
code
