24.10.20（换根哈希）

星期一：

阴间场 cf渡劫成功，拿下三题，终于上蓝🥳🥳🥳

贴 cf round978 div2 C cf传送门

答案取到n+1但初始化没到n+1，wa了一发，很烦😿

思路：dp【i】【1/2/3】表示第一行的第 i列对应第二行的 i-1/ i /i+1列，且左边全部分配完毕的最多得分，答案即为 dp【n+1】【2】

这题的分配区域感觉就像填俄罗斯方块，有可变换方向的三角形和长条形

观察一下可发现上下两行的分配进度一直都会很接近，如第一行第一个空在 i列，那么如果第二行的第一空在 i-1列之前，其实第二行也只能补长条到 i-1/ i /i+1列，故设定状态

不是每个状态都是有效的，先把dp数组初始化为-1（注意这里要初始化到n+1，否则多组样例会出错），设dp【1】【2】为 0。遍历所有状态，若状态合法，则考虑可以怎么填方块转移到下一个状态，讨论一下即可，这题适合用向后推的转移写法。

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
ll n;
int a[3][N];
int dp[N][4];
void solve(){cin >> n;for(int i=1;i<=n+1;i++)    //初始化到n+1,否则多组样例会出错！！！for(int j=1;j<=3;j++)dp[i][j]=-1;for(int i=1;i<=2;i++){for(int j=1;j<=n;j++){
//			cin >> a[i][j];char ch; cin >> ch;if(ch=='A') a[i][j]=1;else a[i][j]=-1;}}dp[1][2]=0;for(int i=1;i<=n;i++){for(int j=1;j<=3;j++){if(dp[i][j]!=-1){if(j==2){int sum1=a[1][i]+a[1][i+1]+a[1][i+2];int sum2=a[2][i]+a[2][i+1]+a[2][i+2];dp[i+3][2]=max(dp[i][j]+(sum1>0)+(sum2>0),dp[i+3][2]);int sum3=a[1][i]+a[2][i];dp[i+1][3]=max(dp[i][j]+(sum3+a[2][i+1]>0),dp[i+1][3]);dp[i+2][1]=max(dp[i][j]+(sum3+a[1][i+1]>0),dp[i+2][1]);}else if(j==1){int sum1=a[1][i]+a[1][i+1]+a[1][i+2];int sum2=a[2][i-1]+a[2][i]+a[2][i+1];dp[i+3][1]=max(dp[i][j]+(sum1>0)+(sum2>0),dp[i+3][1]);int sum3=a[1][i]+a[2][i-1]+a[2][i];dp[i+1][2]=max(dp[i][j]+(sum3>0),dp[i+1][2]);}else if(j==3){int sum1=a[1][i]+a[1][i+1]+a[1][i+2];int sum2=a[2][i+1]+a[2][i+2]+a[2][i+3];dp[i+3][3]=max(dp[i][j]+(sum1>0)+(sum2>0),dp[i+3][3]);int sum3=a[1][i]+a[1][i+1]+a[2][i+1];dp[i+2][2]=max(dp[i][j]+(sum3>0),dp[i+2][2]);}}}}cout << dp[n+1][2] << "\n";
}

补 cf round978 div2 D cf传送门

昨天只看到是个交互就去睡了，其实思路也比较简单，不过剩半小时应该是调不出来

思路：可发现，先忽略冒牌的情况，i-j若是1，即表明 i与 j为同一阵营，否则相反阵营。顺着问n-1次，可以把所有人分为两集合，随手写个样例就能发现，阵营从冒牌开始会反着放，即冒牌之后的人都会被放到相反阵营，那么即可二分去找冒牌这个点

注意处理下边界情况

代码如下：

const int N=2e6+10,M=210;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
ll n;
int a[N];
void solve(){cin >> n;for(int i=1;i<n;i++){cout << "? " << i << " " << i+1 << endl;bool ifs=0; cin >> ifs;if(ifs) a[i+1]=a[i];else a[i+1]=a[i]^1;}int l=1,r=n-1,res=0;    //r<n,避免自己问自己的情况while(l<=r){int mid=l+r>>1;cout << "? " << n << " " << mid << endl;bool ifs; cin >> ifs;if(ifs==(a[mid]==a[n])) r=mid-1;else res=mid,l=mid+1;}if(!res) res=n;if(res==n-1){cout << "? " << n-2 << " " << n-1 << endl;bool ifs1; cin >> ifs1;cout << "? " << n-1 << " " << n-2 << endl;bool ifs2; cin >> ifs2;if(ifs1==ifs2) res++;}cout << "! " << res << endl;
}

补 cf round856 E 换根哈希 cf传送门

思路：先按集合数为n考虑，显然当以 rt为根的深度集合等于给出集合时，rt即好点，可用dfs实现但肯定不能对每个点都dfs一遍，所以可以很自然地想到换根dp

那么如何快速地对给出集合和深度集合进行比较呢，直接比较是O(n)，可以处理出哈希值O(1)比较

hsh【i】=C0+C1*ba+C2*ba^2+C3*ba^3......+Cn-1*ba^n-1，Cj表示深度为j的点的个数，注意因为n<=2e5，所以Cj的值最多也可达到2e5级别，底数需选取一个>2e5的质数

第一遍dfs处理出hsh【i】表示以 i为根的子树的哈希值，第二遍dfs即可进行换根转移，可发现其实哈希值很好转移，hsh【v】+=（hsh【u】- hsh【v】*base）*base

从 u到 v，hsh【v】原本的值保留，hsh【v】子树外的深度集合哈希值即 hsh【u】-hsh【v】*ba 这是对于 u的哈希值，对于 v而言所有深度需要+1，所以再乘个base

最后一个数任意选取，这个值可以是0到n-1，对应的哈希值即1-ba^n-1，即ba的整数次幂，可用map实现

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
vector<int>ve[N];
ll cnt[N],hsh[N],has;
const ll base=2e5+3,MOD=(1ll<<61)-1;  //大于n的质数base
ull add(ull a,ull b){a+=b; if(a>=MOD) a-=MOD;return a;
}
ull mul(ull a,ull b){__int128 c=(__int128)a*b;return add(c>>61,c&MOD);
}
void dfs(int x,int f){hsh[x]=1;for(int v:ve[x]) if(v!=f){dfs(v,x);hsh[x]=add(hsh[x],mul(hsh[v],base));}
}
void dfs2(int x,int f){for(int v:ve[x]) if(v!=f){hsh[v]=add(hsh[v],mul(add(hsh[x],add(-mul(hsh[v],base),MOD)),base));dfs2(v,x);}
}
void solve(){cin >> n;for(int i=1;i<n;i++){int a; cin >> a;cnt[a]++;}ll tb=1;map<ll,bool>mp;for(int i=n-1;~i;i--){has=add(mul(has,base),cnt[i]);mp[tb]=1;tb=mul(tb,base);}for(int i=1;i<n;i++){int u,v; cin >> u >> v;ve[u].push_back(v);ve[v].push_back(u);}dfs(1,0);dfs2(1,0);vector<int>ans;for(int i=1;i<=n;i++) if(mp.count(hsh[i]-has) || mp.count(hsh[i]+MOD-has)) ans.push_back(i);cout << ans.size() << "\n";for(int i:ans) cout << i << " ";cout << "\n";
}

星期二：

重写 cf edu round170 C 双指针 cf传送门

思路：其实思路比较明显，一个简简单单双指针就能拿下，但可惜线段树入脑的我选择了硬凹线段树。。开始写的动态开点，写完了发现无法处理查询，因为动态开点在区间查询的merge上很不方便（现在想想应该也不是不能写），就改成了离散化，反正是浪费了挺多时间。

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
ll a[N];
void solve(){int k; cin >> n >> k;for(int i=1;i<=n;i++) cin >> a[i];sort(a+1,a+n+1);int ans=0;for(int i=1,j=1;i<=n;i++){j=max(i,j);           //双指针别忘了这句while(j<n && a[j+1]<=a[j]+1 && a[j+1]-a[i]<k) j++;ans=max(j-i+1,ans);}cout << ans << "\n";
}

补 D cf传送门

赛时想到大概得是m^2的复杂度,但转移不出来

思路：总点数为tot，dp【i】表示 i点智力 tot-i点武力通过的测试数

用f【i】记录测试，若输入 r>0，则对于所有 i>=r，f【i】++，r<0，对于i∈[0,tot+r]，f【i】++，可以使用差分处理，当r==0时再求前缀和还原，还原后即可把f【j】加到dp【j】上

然后tot点数需要加一，注意tot加一后dp【i】的含义也会随之改变，例如tot为6时，dp3表示3智3武，tot加到7后，dp3表示的即3智4武了，3智4武当然可由3智3武转化而来，但同样也可从2智4武变来即dp2，即得dp【i】= max（dp【i-1】，dp【i】），然后这里应该倒着遍历

代码如下:

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
int f[5050],dp[5050];
void solve(){ll m; cin >> n >> m;ll tot=0;for(int i=1;i<=n;i++){int r; cin >> r;if(r>0){if(r<=tot) f[r]++;}else if(r<0){r=-r;r=tot-r;if(r>=0) f[0]++,f[r+1]--;}else{for(int j=1;j<=tot;j++) f[j]+=f[j-1];for(int j=0;j<=tot;j++) dp[j]+=f[j];tot++;for(int j=tot;j;j--) dp[j]=max(dp[j-1],dp[j]);for(int j=0;j<=tot;j++) f[j]=0;}}for(int j=1;j<=tot;j++) f[j]+=f[j-1];for(int j=0;j<=tot;j++) dp[j]+=f[j];cout << *max_element(dp,dp+tot+1) << "\n";
}

星期三：

看了一天林克砍树没看明白，决定还是11月23日后再学

星期四：

补 cf round977 C2 cf传送门

思路：这里为了方便，给a中的排列按1到n赋值

易想到维护每个数的第一次出现下标，记 fi【i】，满足条件即 fi 1 < fi 2 < fi 3...< fi n，如何维护q次修改呢，其实完全用不着什么数据结构，只需要一个变量 c维护有多少 fi i < fi i+1，因为一次修改只会影响 bs和 t的下标

为了方便讨论给0和n+1的值也发个下标

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
ll a[N],b[N],to[N];
set<int>st[N];
bool if1[N];
void solve(){int m,q; cin >> n >> m >> q;for(int i=0;i<=n+1;i++) st[i].clear();for(int i=1;i<=n;i++){cin >> a[i];to[a[i]]=i;st[i].insert(m+1);}for(int i=1;i<=m;i++){cin >> b[i];st[to[b[i]]].insert(i);}int c=0;st[0].insert(0);st[n+1].insert(m+1);for(int i=0;i<=n;i++) c+=if1[i]=(*st[i].begin()<=*st[i+1].begin());if(c==n+1) cout << "YA\n";else cout << "TIDAK\n";while(q--){int s,t; cin >> s >> t;int x=to[b[s]],x2=to[t];st[x].erase(st[x].find(s));st[x2].insert(s);b[s]=t;if(!if1[x-1] && *st[x-1].begin()<=*st[x].begin()) c++,if1[x-1]=1;else if(if1[x-1] && *st[x-1].begin()>*st[x].begin()) c--,if1[x-1]=0;if(!if1[x] && *st[x].begin()<=*st[x+1].begin()) c++,if1[x]=1;else if(if1[x] && *st[x].begin()>*st[x+1].begin()) c--,if1[x]=0;if(x!=x2){if(!if1[x2-1] && *st[x2-1].begin()<=*st[x2].begin()) c++,if1[x2-1]=1;else if(if1[x2-1] && *st[x2-1].begin()>*st[x2].begin()) c--,if1[x2-1]=0;if(!if1[x2] && *st[x2].begin()<=*st[x2+1].begin()) c++,if1[x2]=1;else if(if1[x2] && *st[x2].begin()>*st[x2+1].begin()) c--,if1[x2]=0;}if(c==n+1) cout << "YA\n";else cout << "TIDAK\n";}
}

补24 牛客多校10 F 牛客传送门

思路：赛时以为暴力是O(n^5)，就直接run了，实在不应该

其实想下能放最多点的放法也就能放 2n个点，复杂度算满是O(n^3)，实际上是远没到这么多，实测300ms跑完

代码如下:

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
vector<PII>ve;
bool vi[1010][1010];
void solve(){cin >> n;int x,y; cin >> x >> y;ve.push_back({x,y}); cout << 1;for(int i=1;i<n*n;i++){int x,y; cin >> x >> y;if(vi[x][y]){cout << 0; continue;}for(auto [vx,vy]:ve){if(vx==x){for(int i=1;i<=n;i++) vi[x][i]=1;continue;}else if(vy==y){for(int i=1;i<=n;i++) vi[i][y]=1;continue;}int dx=abs(vx-x),dy=abs(vy-y);int gc=__gcd(dx,dy);dx/=gc,dy/=gc;if(x<vx){if(y<vy){for(int xx=x,yy=y;xx>0 && yy>0;xx-=dx,yy-=dy) vi[xx][yy]=1;for(int xx=x,yy=y;xx<=n && yy<=n;xx+=dx,yy+=dy) vi[xx][yy]=1;//}else{for(int xx=vx,yy=vy;xx<=n && yy>0;xx+=dx,yy-=dy) vi[xx][yy]=1;for(int xx=vx,yy=vy;xx>0 && yy<=n;xx-=dx,yy+=dy) vi[xx][yy]=1;//}}else{if(y<vy){for(int xx=x,yy=y;xx<=n && yy>0;xx+=dx,yy-=dy) vi[xx][yy]=1;for(int xx=x,yy=y;xx>0 && yy<=n;xx-=dx,yy+=dy) vi[xx][yy]=1;//}else{for(int xx=vx,yy=vy;xx>0 && yy>0;xx-=dx,yy-=dy) vi[xx][yy]=1;for(int xx=vx,yy=vy;xx<=n && yy<=n;xx+=dx,yy+=dy) vi[xx][yy]=1;}}}ve.push_back({x,y}); cout << 1;}
}

星期五：

重做24百度之星国赛小度爬丸山 mtj传送门

抛开树上差分板子不谈，赛时能出这题我很满意

思路：先想到既然左边是单调递增，右边单调递减，那么能不能将左右分开维护，答案是可以

易想到dp【i】【j】【0/1】表示到第 i个数，第 j个数作为峰值的左/右子序列个数，但数组肯定开不了那么大，那么考虑第一维能不能舍弃，答案是可以

在这里将数组分为两个，分别维护左右，写俩样例就能发现 ai为峰值的丸山子序列即tl【i】*tr【i】接下来考虑如何维护子序列数量，设ai值为 num，那么转移即 $tl[num]+=\sum_{j=1}^{num-1}tl[j]+1$ 这是一个比较典的转移，任何小于num的值为结尾的子序列，后面都可以再加个num，仍单调，且num一个数字本身也是单调子序列。用树状数组维护即可

还要注意重复计算答案的问题，计算答案时可以算小于num的所有序列数+1，可避免算重

代码如下：

const int N=3e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
int a[N];
ll tl[N],tr[N];
#define lowbit(x) x&-x
inline void add(int x,ll v,bool ifl){if(ifl) for(int i=x;i<=n;i+=lowbit(i)) (tl[i]+=v+mod)%=mod;else for(int i=x;i<=n;i+=lowbit(i)) (tr[i]+=v+mod)%=mod;
}
inline ll ask(int x,bool ifl){ll res=0;if(ifl) for(int i=x;i;i-=lowbit(i)) (res+=tl[i])%=mod;else for(int i=x;i;i-=lowbit(i)) (res+=tr[i])%=mod;return res;
}
void solve(){cin >> n;map<int,int>to; int cnt=0;for(int i=1;i<=n;i++){cin >> a[i];to[a[i]]=1;}for(auto &[x,y]:to) y=++cnt;for(int i=n;i;i--){int num=to[a[i]];add(num,ask(num-1,0)+1,0);}ll ans=0;for(int i=1;i<=n;i++){int num=to[a[i]];add(num,ask(num-1,1)+1,1);
//		(ans+=(ask(num,1)-ask(num-1,1)+mod)%mod*((ask(num,0)-ask(num-1,0)+mod)%mod)%mod)%=mod;//会算重(ans+=(ask(num-1,0)+1)*(ask(num-1,1)+1)%mod)%=mod;add(num,-ask(num-1,0)-1,0);}cout << ans;
}

补24牛客多校7 K 牛客传送门

思路：首先可以找出S的最短前缀满足存在子序列为T，和最短后缀满足存在子序列为rT，设这俩位置为p1和p2，若p1<p2，那么先把前后缀的子序列选上，中间无论是什么都满足题意，所以可以直接对中间一坨求个不同子序列数，这是个很经典的线性dp

上述求的是前后缀不相交的情况，还需补上前后缀相交的情况。若存在相交，则显然相交部分一定是回文串，可以先用字符串哈希预处理T和rT，再遍历一遍相交部分的长度len，需同时满足其回文且pl【m-len】<= pr【m】（前缀匹配第m-len个字符的位置，和后缀匹配最后一个字符的位置，即可ans++

代码如下：

const int N=2e6+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
ll n;
const ull MOD=(1ll<<61)-1,ba=131;
inline ull add(ull a,ull b){a+=b; if(a>=MOD) a-=MOD;return a;
}
inline ull mul(ull a,ull b){__int128 c=(__int128)a*b;return add(c>>61,c&MOD);
}
ull hsh[N],rhsh[N],qb[N];
int pl[N],pr[N];
ll dp[N];
void solve(){ll m; cin >> n >> m;string s,t; cin >> s >> t;s=" "+s,t=" "+t;for(int i=1,j=1;i<=n;i++)if(j<=m && s[i]==t[j]) pl[j++]=i;for(int i=n,j=1;i;i--)if(j<=m && s[i]==t[j]) pr[j++]=i;if(!pl[m] || !pr[m]){cout << 0; return ;}string rt=t; reverse(rt.begin(),rt.end());rt=" "+rt,rt.pop_back();qb[0]=1;for(int i=1;i<=m;i++){qb[i]=mul(qb[i-1],ba);
//		hsh[i]=hsh[i-1]*ba+t[i];hsh[i]=add(mul(hsh[i-1],ba),t[i]);rhsh[i]=add(mul(rhsh[i-1],ba),rt[i]);}ll ans=0;if(pl[m]<pr[m]){int pos[33]={0};
//		cout << pl[m] << " " << pr[m] << endl;for(int i=pl[m]+1;i<pr[m];i++){int num=s[i]-'a'+1;if(!pos[num]) dp[i]=(dp[i-1]*2+1)%mod,pos[num]=i;else dp[i]=(dp[i-1]*2%mod-dp[pos[num]-1]+mod)%mod,pos[num]=i;}(ans+=dp[pr[m]-1]+1)%=mod;
//		cout << ans << "\n";}for(int i=1;i<=m && pl[i]<=pr[m];i++){ull h1=add(hsh[m],add(-mul(hsh[i-1],qb[m-i+1]),MOD)),h2=rhsh[m-i+1];
//		cout << h1 << " " << h2 << "\n";if(h1==h2) (ans+=1)%=mod;}cout << ans << "\n";
//	for(int i=1;i<=m;i++) cout << hsh[i] << " " << rhsh[i] << "\n";
}

星期六：

下午vp了场ccpc好像是，差点被签到模拟腐乳，读题和代码细节真的一言难尽。。

补24 牛客多校6 A 牛客传送门

思路：先考虑二阶段Bob会怎么分，不难想到选取0占比最大的一段前缀长为len，把蛋糕均分len份然后就是一阶段的dfs博弈，暑假写过一丢类似的，需要根据回合来讨论，不过这题比较不同的一点是无论谁的回合都要考虑二阶段Bob的分法

dp【u】表示走到 u点Alice的比例，Alice回合取子节点中最大，否则取最小，dfs结束后，考虑二阶段时，若子节点1的占比大于当前 u，那么Bob将不会给子节点切蛋糕，所以dpu还要和 cp取min

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
ll n;
vector<PII>ve[N];
double dp[N];
void dfs(int u,int f,bool ifg,int c0,int c1){
//	cout <<  u << " " << c0 << " " << c1 << "\n";dp[u]=1.0*c1/(c0+c1);if(ve[u].size()==1) return ;   //叶子节点直接return,无需后续操作double cp=1-ifg;for(auto [k,v]:ve[u]) if(v!=f){dfs(v,u,!ifg,c0+!k,c1+k);ifg?cp=max(dp[v],cp):cp=min(dp[v],cp);  //一阶段}dp[u]=min(cp,dp[u]); //二阶段
}
void solve(){cin >> n;for(int i=1;i<=n;i++) ve[i].clear();for(int i=1;i<n;i++){int u,v,k; cin >> u >> v >> k;ve[u].push_back({k,v});ve[v].push_back({k,u});}double ans=0;for(auto [k,v]:ve[1]) if(k){  //Alice第一次只能走1边dfs(v,1,0,0,1);ans=max(dp[v],ans);}cout << fixed << setprecision(11) << ans << "\n";
}

周日：

补集美11届校赛 F 字符串哈希牛客传送门

被莫名其妙的RE搞了一晚上，心态有点小炸🤕

刚开始还想建个字典树啥的，但完全建不起来

思路：先将字符串粘贴一次，此时需要比较的字符串即s1至sn开头的长度为n字符串

先提出一个问题，已知俩字符串的哈希值，如何快速比较其字典序，方法是二分找到第一个哈希值不同的点，再进行直接比较，复杂度为O(logn)

那么可以把s的哈希数组处理出来，然后将1到n的值排个序，复杂度为O(n*log^2n)，即得字典序第k小的字符串起始下标

代码如下：

const int N=2e6+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
const ull MOD=(1ll<<61)-1,ba=131;
ull hsh[N],qp[N];
inline ull add(ull a,ull b){a+=b; if(a>=MOD) a-=MOD;return a;
}
inline ull mul(ull a,ull b){__int128 c=(__int128)a*b;return add(c>>61,c&MOD);
}
inline ull geth(int l,int r){return add(hsh[r],add(-mul(hsh[l-1],qp[r-l+1]),MOD));
}
int a[N];
void solve(){ll k; cin >> n >> k;string s; cin >> s;s.append(s),s=" "+s;qp[0]=1;for(int i=1;i<=n*2;i++){qp[i]=mul(qp[i-1],ba);hsh[i]=add(mul(hsh[i-1],ba),s[i]);a[i]=i;}sort(a+1,a+n+1,[&](int idx,int bdx){int l=1,r=n,res=n;while(l<=r){int mid=l+r>>1;if(geth(idx,idx+mid-1)!=geth(bdx,bdx+mid-1)) res=mid,r=mid-1;else l=mid+1;}if(res==n) return idx<bdx;        //不加会RE,感觉没道理return s[idx+res-1]<=s[bdx+res-1];});cout << s.substr(a[k],n) << "\n";
}