题解：P11411 兰奇的卡牌游戏
题解：P11411 兰奇的卡牌游戏
今天来讲一个超级缝合题目，所以要先讲一些前置。
前置知识 \(1\) ——单调栈
[USACO06NOV] Bad Hair Day S
题目描述
农夫约翰有 \(N\) 头奶牛正在过乱头发节。
每一头牛都站在同一排面朝右，它们被从左到右依次编号为 \(1, 2, \cdots, N\)。编号为 \(i\) 的牛身高为 \(h_i\)。第 \(N\) 头牛在最前面，而第 \(1\) 头牛在最后面。
对于第 \(i\) 头牛前面的第 \(j\) 头牛，如果 \(h_i>h_{i+1}, h_i>h_{i+2}, \cdots, h_i>h_j\)，那么认为第 \(i\) 头牛可以看到第 \(i+1\) 到第 \(j\) 头牛。
定义 \(C_i\) 为第 \(i\) 头牛所能看到的牛的数量。请帮助农夫约翰求出 \(C _ 1 + C _ 2 + \cdots + C _ N\)。
输入格式
输入共 \(N + 1\) 行。
第一行为一个整数 \(N\)，代表牛的个数。
接下来 \(N\) 行，每行一个整数 \(a _ i\)，分别代表第 \(1, 2, \cdots, N\) 头牛的身高。
输出格式
输出共一行一个整数，代表 \(C _ 1 + C _ 2 + \cdots + C _ N\)。
样例 #1
样例输入 #1
6
10
3
7
4
12
2
样例输出 #1
5
提示
数据规模与约定
对于 \(100\%\) 的数据，保证 \(1 \leq N \leq 8 \times 10 ^ 4\)，\(1 \leq h _ i \leq 10 ^ 9\)。
思路
单调栈板子，保证栈顶最大，从前往后遍历，栈顶比当前小的就删掉。并在每次入栈后将栈中剩余统计入答案。
code
#include<bits/stdc++.h>
using namespace std;
const int N=8e4+5;
int n;
int st[N];
int h[N];
int cur;
int ans;
int main(){
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
cin>>n;
for(int i=1;i<=n;i++) cin>>h[i];
for(int i=1;i<=n;i++){
while(cur&&h[i]>=st[cur]) cur--;
// if(cur==0||h[i]>st[cur]) st[++cur]=h[i];
ans+=cur;
st[++cur]=h[i];
}
cout<<ans<<endl;
return 0;
}
OK,再看下一个前置知识。
前置知识 \(2\) ——笛卡尔树
【模板】笛卡尔树
题目描述
给定一个 \(1 \sim n\) 的排列 \(p\)，构建其笛卡尔树。
即构建一棵二叉树，满足：
- 每个节点的编号满足二叉搜索树的性质。
- 节点 \(i\) 的权值为 \(p_i\)，每个节点的权值满足小根堆的性质。
输入格式
第一行一个整数 \(n\)。
第二行一个排列 \(p_{1 \dots n}\)。
输出格式
设 \(l_i,r_i\) 分别表示节点 \(i\) 的左右儿子的编号（若不存在则为 \(0\)）。
一行两个整数，分别表示 \(\operatorname{xor}_{i = 1}^n i \times (l_i + 1)\) 和 \(\operatorname{xor}_{i = 1}^n i \times (r_i + 1)\)。
样例 #1
样例输入 #1
5
4 1 3 2 5
样例输出 #1
19 21
提示
【样例解释】
| \(i\) | \(l_i\) | \(r_i\) |
|---|---|---|
| \(1\) | \(0\) | \(0\) |
| \(2\) | \(1\) | \(4\) |
| \(3\) | \(0\) | \(0\) |
| \(4\) | \(3\) | \(5\) |
| \(5\) | \(0\) | \(0\) |
【数据范围】
对于 \(30\%\) 的数据，\(n \le 10^3\)。
对于 \(60\%\) 的数据，\(n \le 10^5\)。
对于 \(80\%\) 的数据，\(n \le 10^6\)。
对于 \(90\%\) 的数据，\(n \le 5 \times 10^6\)。
对于 \(100\%\) 的数据，\(1 \le n \le 10^7\)。
思路
以当前为根，从左往右走，如果能放在当前右子树，否则就一直往上找，直到找到当前的权值 \(p_i\) 比当前点的权值 \(p_i\) 大，则符合条件，放在其右子树。对于向上找时跳过的不符合条件的点，则将其放在当前接入点的左儿子。
那么，这样子的复杂度就是 \(O(N^2)\) 。考虑将向上遍历直到找到当前的权值 \(p_i\) 比当前点的权值 \(p_i\) 大这一步骤优化，即找到先前序列中位于该位置之前的以一个大于该值的树。由此想到了单调栈。
所以做法大致是“贪心 \(+\) 单调栈”。
code
注意要输入解绑，不然会 \(TLE\) （实践出真知）。
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e7+5;
int st[N];
int a[N];
int n;
int l[N],r[N];
void build(){
int top=0,cur=0;
for(int i=1;i<=n;i++){
while(cur&&a[st[cur]]>a[i]) cur--;
//cur:插在某个结点的右子树上
if(cur) r[st[cur]]=i;
//cur<top:插在某个结点的左子树上
if(cur<top) l[i]=st[cur+1];
st[++cur]=i;
top=cur;
}
}
signed main(){
ios::sync_with_stdio(NULL);
cin.tie(NULL);
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
build();
int ans=0;
for(int i=1;i<=n;i++) ans^=1LL*i*(l[i]+1);
cout<<ans<<" ";
ans=0;
for(int i=1;i<=n;i++) ans^=1LL*i*(r[i]+1);
cout<<ans<<endl;
return 0;
}
前置 \(3\) ：最近公共祖先（LCA）
【模板】最近公共祖先（LCA）
题目描述
如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。
输入格式
第一行包含三个正整数 \(N,M,S\)，分别表示树的结点个数、询问的个数和树根结点的序号。
接下来 \(N-1\) 行每行包含两个正整数 \(x, y\)，表示 \(x\) 结点和 \(y\) 结点之间有一条直接连接的边（数据保证可以构成树）。
接下来 \(M\) 行每行包含两个正整数 \(a, b\)，表示询问 \(a\) 结点和 \(b\) 结点的最近公共祖先。
输出格式
输出包含 \(M\) 行，每行包含一个正整数，依次为每一个询问的结果。
样例 #1
样例输入 #1
5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5
样例输出 #1
4
4
1
4
4
提示
对于 \(30\%\) 的数据，\(N\leq 10\)，\(M\leq 10\)。
对于 \(70\%\) 的数据，\(N\leq 10000\)，\(M\leq 10000\)。
对于 \(100\%\) 的数据，\(1 \leq N,M\leq 500000\)，\(1 \leq x, y,a ,b \leq N\)，不保证 \(a \neq b\)。
样例说明：
该树结构如下：
第一次询问：\(2, 4\) 的最近公共祖先，故为 \(4\)。
第二次询问：\(3, 2\) 的最近公共祖先，故为 \(4\)。
第三次询问：\(3, 5\) 的最近公共祖先，故为 \(1\)。
第四次询问：\(1, 2\) 的最近公共祖先，故为 \(4\)。
第五次询问：\(4, 5\) 的最近公共祖先，故为 \(4\)。
故输出依次为 \(4, 4, 1, 4, 4\)。
2021/10/4 数据更新 @fstqwq：应要求加了两组数据卡掉了暴力跳。
大致思路
就原本是两个点一步一步往上跳直到跳到同一点上。优化的方法是根据两个节点的的深度，如不同，向上调整深度大的节点，使得两个节点在同一层上，如果正好是祖先，结束；否则，将两个节点同时上移，查询最近公共祖先(两个过程均使用倍增加速)。
code
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+5;
int n,m,rt;
vector<int>g[N];
int read()
{
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
return x*f;
}
int f[N][21];//f[i][j] 结点i往上跳2^j步的祖先结点
//f[i][j]=f[f[i][j-1]][j-1]
int d[N];//d[i] 结点i处于第几层
void dfs(int u,int fa)
{
f[u][0]=fa;
for(int i=0;i<(int)g[u].size();i++)
{
int v=g[u][i];
if(v==fa) continue;
d[v]=d[u]+1;
dfs(v,u);
}
}
int get_lca(int x,int y)
{
//d[x]>d[y]
if(d[x]<d[y]) swap(x,y);
int cha=d[x]-d[y];
for(int i=20;i>=0;i--)
if(cha>>i&1) x=f[x][i];//x和y处于同一层
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 main()
{
n=read();m=read();rt=read();
for(int i=1;i<n;i++)
{
int x=read(),y=read();
g[x].push_back(y);g[y].push_back(x);
}
d[rt]=1;
dfs(rt,rt);
for(int j=1;j<=20;j++)
for(int i=1;i<=n;i++)
f[i][j]=f[f[i][j-1]][j-1];
while(m--)
{
int x=read(),y=read();
printf("%d\n",get_lca(x,y));
}
return 0;
}
最后看本题
思路
题目要求编号单调递增，可以满足小根堆的性质，权值可以满足左小右大，即二叉搜索树的限制。
所以所谓生成阶段就是生成了一颗笛卡尔树。且权值是第一关键字，编号是第二关键字。
最大得分就树的直径，可以枚举树的重心 \(r\) ,判断每个节点于 \(k/2\) 之间的关系并统计答案即可。
思路和官方题解比较相近，主要是实现方式不同。
code
#include <bits/stdc++.h>
using namespace std;
const int N=1e7+50,M=1e5+5,mod=1e9+7;
const double pi=acos(-1);
int n,k,rt;
struct node
{
int a,b;//编号，权值
}Qian[N];
bool cmp(node a,node b){return a.a<b.a;}
int r_son[N],l_son[N];
void build()
{
stack<int>s;
for(int i=1;i<=n;i++)
{
while(!s.empty()&&Qian[s.top()].b>Qian[i].b)
{
l_son[i]=s.top();
s.pop();
}
if(!s.empty())r_son[s.top()]=i;
s.push(i);
}
while(!s.empty())
{
rt=s.top();
s.pop();
}
}
vector<int>g[N];
void rebuild()
{
for(int i=1;i<=n;i++)
{
if(l_son[i])
{
g[i].push_back(l_son[i]);
g[l_son[i]].push_back(i);
}
if(r_son[i])
{
g[i].push_back(r_son[i]);
g[r_son[i]].push_back(i);
}
}
}
int f[2005][32];//倍增信息
int dep[N];//点深度
void dfs(int u,int fa)
{
dep[u]=dep[fa]+1;f[u][0]=fa;
for(auto v:g[u])if(v!=fa) dfs(v,u);
}
void Wula()
{
dfs(rt,0);
for(int j=1;j<20;j++)
for(int i=1;i<=n;i++)
f[i][j]=f[f[i][j-1]][j-1];
}
int LCA(int x,int y)
{
if(dep[x]<dep[y])swap(x,y);//x>=y,跳y
int dis=dep[x]-dep[y];
for(int i=0;i<11;i++)
if(dis>>i&1) x=f[x][i];
if(x==y) return x;
for(int i=10;i>=0;i--)
if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];
return f[x][0];
}
int path(int x,int y)
{
return max(0,dep[x]+dep[y]-2*dep[LCA(x,y)]);
}
int main()
{
cin>>n>>k;
for(int i=1;i<=n;i++) cin>>Qian[i].a,Qian[i].b=i;
sort(Qian+1,Qian+n+1,cmp);
build();
rebuild();
Wula();
int AC=1e9+7;
if(k%2==0)
{
int sd=k/2;
for(int i=1;i<=n;i++)
{
int cnt=0;
for(int j=1;j<=n;j++)
{
int ad=path(i,j);
cnt+=(ad>sd?1:0);
}
AC=min(AC,cnt);
}
cout<<AC<<endl;
}
else
{
int Ying=k/2;
for(int i=1;i<=n;i++)
{
for(auto v:g[i])
{
int cnt=0;
for(int j=1;j<=n;j++)
{
int ad=path(i,j),ad2=path(v,j);
cnt+=(ad>Ying&&ad2>Ying?1:0);
}
AC=min(AC,cnt);
}
}
cout<<AC<<endl;
}
return 0;
}
最后在此处鸣谢 \(FRZ\) ， \(Win\) ， \(QC\) 等人对笔者的帮助。
yingxilin
Qian·JX の joker
2024-12-23 于玉山一中
浙公网安备 33010602011771号