标签：就是 ini 顺时针 多少 tree testcase pmt 很多 程序
小蒟蒻duyi CSP爆炸之后一直在颓，所以直到最近才陆续订正完CSP的题/kel 以后不能这么颓了(flag)
设\(f[u]\)表示根到\(u\)的路径上有多少子串是合法括号串。（即题目里的\(k_u\)，此变量名缺乏个性，故换之）
从根向每个节点dfs，容易求出\(c[u]\)：表示从根到\(u\)的路径上，我们能匹配则匹配，最后剩下多少个待匹配的左括号。 例如如下\(s_u\)对应的\(c[u]\)：
((() \(c[u]=2\)。
(())( \(c[u]=1\)。
(()() \(c[u]=1\)。
()))( \(c[u]=1\)。
(()()) \(c[u]=0\)。
如果\(u\)节点上括号为)且\(c[u]\geq 0\)，说明可以以\(u\)节点为结尾，形成一个新的合法子序列。我们大胆猜想，满足上述两个条件时，\(f[u]=f[fa(u)]+1\)，否则\(f[u]=f[fa(u)]\)。 可惜过不了大样例。 仔细分析一下发现我们漏算了很多子串。
如：对于\(s_u=\)(()()，因为\(f[4]=1\)，所以我们会认为\(f[5]=2\)，但其实\(f[5]\)应该等于\(3\)，我们漏算了\([2,5]\)这个合法子串。 事实上，我们这样做只计算出了以\(u\)结尾的最短合法子串。问题就出在，当序列结尾形成一个新的合法子串时，它可能和前面原本已经闭合的的子串拼在一起，结合形成“并列式”子串。 极端的例子如(()()()()中\([8,9]\)这个子串，可以和\([6,7]\)拼，也可以和\([4,7]\)拼，甚至可以和\([2,7]\)拼在一起，分别构成新的并列式子串。
我们称：在同一个括号中的、并列出现的、合法的子串为同一层里的子串。如：(()()( () )) ()中，\([2,3],[4,5],[6,9]\)在同一层，\([1,10],[11,12]\)在同一层。
发现两个合法子串在同一层的条件是：结尾位置的\(c[i]\)相同，且两个子串中间没有经过过一个\(c[x]<c[i]\)的部分。如：(()()) (())里的\([2,3]\)和\([8,9]\)就不在同一层，因为它们是\(c[i]=1\)，但中间经过了一个\(c[6]=0<1\)。
如果子串结尾位置为\(i\)，我们称\(c[i]=k\)的子串位于第\(k\)层。
那么对每个\(u\)，我们要求出，从根到\(u\)的路径上，每一层有多少个并列的合法子串。这样，我们就能知道\(c[u]\)这一层有多少合法子串能和“以\(u\)结尾的最短合法子串”拼接。
看起来这需要一个二维的数组来记录。但我们发现，从“以\(fa(u)\)结尾的串里每一层有多少并列的合法子串”，到“以\(u\)结尾的串里每一层有多少并列的合法子串”，这当中的修改是很小且很特殊的：当\(u\)上是)时，\(c[u]\)这一层会多一个并列的合法子串，而\(c[i]>c[u]\)的这些层，它们的并列合法子串数将清零，这是根据我们前面分析出的“两个合法子串在同一层的条件”中要求它们之间不能存在一个\(c[x]<c[i]\)，现在\(u\)就是这个\(x\)了。
先从父亲处继承，然后单点\(+1\)，并把这个点的后缀清零。主席树可以实现。
时间、空间复杂度：\(O(n\log n)\)。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=5e5+5;
struct EDGE{int nxt,to;}edge[MAXN];
int head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u];edge[tot].to=v;head[u]=tot;}
int n,rt[MAXN],ls[MAXN*30],rs[MAXN*30],val[MAXN*30],cnt;
void modify(int &x,int y,int l,int r,int pos){
x=++cnt;val[x]=val[y];ls[x]=ls[y];rs[x]=rs[y];
val[x]++;
if(l==r)return;
int mid=(l+r)>>1;
if(pos<=mid)modify(ls[x],ls[y],l,mid,pos),rs[x]=0;
else modify(rs[x],rs[y],mid+1,r,pos);
}
int query(int x,int l,int r,int pos){
if(!x)return 0;
if(l==r)return val[x];
int mid=(l+r)>>1;
if(pos<=mid)return query(ls[x],l,mid,pos);
else return query(rs[x],mid+1,r,pos);
}
ll f[MAXN],c[MAXN];
char s[MAXN];
void dfs(int u){
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
f[v]=f[u];c[v]=c[u];rt[v]=rt[u];
if(s[v]=='('){
if(c[v]<0)c[v]=0,rt[v]=0;
c[v]++;
}
else {
c[v]--;
if(c[v]>=0){
f[v]++;
f[v]+=query(rt[v],0,n,c[v]);
modify(rt[v],rt[v],0,n,c[v]);
}
}
dfs(v);
}
}
int main(){
// freopen("brackets.in","r",stdin);
// freopen("brackets.out","w",stdout);
scanf("%d%s",&n,s+1);
for(int i=2,fa;i<=n;++i)scanf("%d",&fa),add_edge(fa,i);
if(s[1]=='(')c[1]=1;else c[1]=-1;
dfs(1);
ll ans=0;
for(int i=1;i<=n;++i)ans^=((ll)i*f[i]);
//cout<<f[i]<<" ";cout<<endl;
//
cout<<ans<<endl;
return 0;
}我看了wqy大佬的题解并决定盗用他的图（雾
首先考虑一条链的情况。
我们观察链上某个节点\(u\)上的数字变动情况。可以发现无论我们先删左边还是先删右边，原来它上面的数字一定会被搬运到了其中一个方向，同时另一个方向一定又过来了一个数，此外还有一个数字反向经过了\(u\)。
也就是下面这种情况（这里是先删除右边那条边）：
再考虑菊花，即围绕着节点\(u\)有多条出边的情况。如果把这些边排成一圈依次拆掉，我们先会把\(u\)上的数挪到某个与它相邻的节点上。然后从这个节点开始，按顺时针顺序，这一圈上每个数依次从\(u\)的某条边进入，然后从顺时针的下一条边出去。最后某个数会进入\(u\)然后不再出去，这就是最终留在\(u\)上的数了。
如果画出来会很优美：
因为是求字典序最小，显然应该按数字\(1\)到\(n\)贪心，每个数字都挪到它能挪到的编号最小的节点上。
不妨以当前数字所在的节点为根。我们做一遍dfs，判断每个点是否能被挪到。节点\(u\)能被挪到，其实分为两个部分的条件：
根到\(u\)的路径上（不包括根和\(u\)）每个节点都能够作为“中转节点”（图中一进一出的那种）；
\(u\)自己能够作为终点节点（图中只进不出的那种）。
考虑条件1，对于每个\(v\)，我们要判断的其实是能否从根一路通畅地走入\(v\)的子树。我们称满足这样条件的\(v\)为“合法”。
如果\(v\)的父亲\(fa(v)\)不合法，则\(v\)肯定也不合法。
如果\(fa(v)\)到\(v\)的这条边已经被以相同的方向使用过，则\(v\)不合法。（根据上图，显然每条边最终都会被以两个方向各走一遍，此处我们只要判断\(fa(v)\)走向\(v\)的方向是否被走过）
如果\(fa(v)\)不为根，我们从\(fa(fa(v))\)走到\(fa(v)\)，再走向\(v\)，相当于在\(fa(v)\)这个节点上一进一出。我们加入这一进一出的路径后，如果恰好把\(fa(v)\)周围所有经过它的路径串成了一圈（首尾相接），但是\(fa(v)\)周围仍然存在还没走过的边，则我们现在还不能走这一进一出。即\(v\)不合法。【注：这部分比较复杂，请结合图和代码仔细理解，具体的实现方式下面会讲。】
考虑条件2，我们判断一个点\(u\)能否作为终点，方法和判\(v\)类似。
如果\(u\)已经存在一条只进不出的边了，则\(u\)不能作为终点。（根据图来看显然每个点只能有一次只进不出的机会。根据实际含义来说就是，之前已经有别的数以\(u\)作为终点了，所以\(u\)不能作为当前数的终点）
如果\(fa(u)\)到\(u\)的这条边已经被以相同的方向使用过，则\(u\)不能作为终点。
如果加入\(fa(u)\)到\(u\)的路径后，\(u\)周围的路径会被串成一圈，但\(u\)周围仍然存在还没走过的边，则\(u\)现在还不能作为终点。
这样，对于每个数我们贪心地选编号最小的、能作为终点的点即可。选出后我们暴力更新这个点到根路径上的信息。
下面讲一些具体实现的问题：
判断一条边以哪个方向走过是比较容易的。需要注意的是：我们的根在不断变化，所以不能以“是从父亲走向儿子”还是“从儿子走向父亲”来判断。我是直接建了个二维的邻接表，state[u][v]=u表示\(u,v\)间的边从\(u\)到\(v\)走过，state[u][v]=v表示\(u,v\)间的边从\(v\)到\(u\)走过，state[u][v]=0表示两个方向都走过，state[u][v]=-1表示两个方向都没走过。
如何判断加入一条路径后，\(u\)周围的所有路径是否会被串成一圈？由于路径是有方向的，若干路径会串成一条链，我们记一条链的开头为\(st\)，结尾为\(ed\)。新加入的路径如果是一进一出，那么我们要判断，如果：进入的那头的链的\(st\)是\(u\)上数字移出的边，走出的那头的链的\(ed\)是\(u\)上数字移入的边，加入这一进一出后，就会把所有边串成一条链了。
所谓\(u\)上数字移入、移出的边是指：对于每个节点\(u\)，都会有唯一的一条移出的边，也会有唯一的一条移入的边。如上图中\(x\rightarrow 1\)就是移出，\(5\rightarrow x\)就是移入。【这部分请结合图和代码重点理解】
最开始时，\(u\)周围的每条边都是一条单独的链。当我们加入一进一出的路径，我们实际上是连起了两条链。这个“连起”的过程，我们可以用并查集维护：对每个\(u\)都开一个并查集，维护它周围的每条链的\(st\)和\(ed\)。一进一出时，进的那条链提供合并后的\(st\)，出的那条链提供合并后的\(ed\)。
最后，请注意特判\(n=1\)时的情况，因为我们的程序中默认每个点都会移出去一次、移进来一次，而\(n=1\)时这种情况根本不会发生。
时间复杂度\(O(n^2\alpha)\)，空间复杂度\(O(n^2)\)。
//problem:P5659
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
namespace Fread{
const int MAXN=1<<20;
char buffer[MAXN],*S,*T;
inline char getchar(){
if(S==T){
T=(S=buffer)+fread(buffer,1,MAXN,stdin);
if(S==T)return EOF;
}
return *S++;
}
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#endif
inline int read(){
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MAXN=2005;
struct EDGE{int nxt,to;}edge[MAXN<<1];
int head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u],edge[tot].to=v,head[u]=tot;}
int n,p[MAXN],d_nu[MAXN],d_in[MAXN],d_out[MAXN],frm[MAXN],to[MAXN],state[MAXN][MAXN];
struct DSU{
int fa[MAXN],st[MAXN],ed[MAXN],sz[MAXN];
int get_fa(int x){
return x==fa[x]?x:(fa[x]=get_fa(fa[x]));
}
void union_s(int frm,int to){
int x=get_fa(frm),y=get_fa(to);
if(x==y)return;
if(sz[x]<sz[y])fa[x]=y,st[y]=st[x],sz[y]+=sz[x];
else fa[y]=x,ed[x]=ed[y],sz[x]+=sz[y];
}
int get_st(int x){
return st[get_fa(x)];
}
int get_ed(int x){
return ed[get_fa(x)];
}
void Init(int x){
fa[x]=st[x]=ed[x]=x;sz[x]=1;
}
}b[MAXN];
/*
tips:
p[num] -> node
d_nu[u]: edge(from u) not used
stata[u][v]:
- -1 not used
- u u->v
- v v->u
- 0 u->v & v->u
*/
int Root,fa[MAXN];
bool flag[MAXN];
void dfs(int u){
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(v==fa[u])continue;
fa[v]=u;
flag[v]=1;
//能否经过u,到达v
if(!flag[u])flag[v]=0;
else if(u!=Root){
if(state[u][fa[u]]==0||state[u][fa[u]]==fa[u]||state[u][v]==0||state[u][v]==u)flag[v]=0;
else if(flag[v]&&b[u].get_st(fa[u])==to[u]&&b[u].get_ed(v)==frm[u]&&d_in[u]+d_out[u]+d_nu[u]*2-2!=0)flag[v]=0;
else if(flag[v]&&b[u].get_ed(v)==fa[u])flag[v]=0;
}
else{
//assert(!to[u]);
if(state[u][v]==0||state[u][v]==u)flag[v]=0;
else if(flag[v]&&b[u].get_ed(v)==frm[u]&&d_in[u]+d_out[u]+d_nu[u]*2-1!=0)flag[v]=0;
}
dfs(v);
}
//能否以u为终点
if(u==Root)flag[u]=0;
else{
if(frm[u])flag[u]=0;
else if(flag[u]&&b[u].get_st(fa[u])==to[u]&&d_in[u]+d_out[u]+d_nu[u]*2-1!=0)flag[u]=0;
}
}
void Init(){
tot=0;
for(int i=1;i<=n;++i){
head[i]=0;
d_nu[i]=d_in[i]=d_out[i]=frm[i]=to[i]=0;
}
}
int main() {
int Testcases=read();while(Testcases--){
Init();
n=read();
for(int i=1;i<=n;++i)p[i]=read();
if(n==1){
puts("1");
continue;
}
for(int i=1,u,v;i<n;++i){
u=read(),v=read(),add_edge(u,v),add_edge(v,u);
d_nu[u]++,d_nu[v]++;
b[u].Init(v),b[v].Init(u);
state[u][v]=state[v][u]=-1;
}
for(int i=1;i<=n;++i){
Root=p[i];
fa[Root]=0,flag[Root]=1;
dfs(Root);
int res=0;
for(int j=1;j<=n;++j)if(flag[j]){res=j;break;}
//assert(res!=0&&res!=Root);
printf("%d ",res);
int u=res;
frm[u]=fa[u];
while(fa[u]!=Root){
//assert(state[u][fa[u]]==state[fa[u]][u]);
if(state[u][fa[u]]==-1){
state[u][fa[u]]=state[fa[u]][u]=fa[u];
d_nu[u]--,d_nu[fa[u]]--;
d_in[u]++,d_out[fa[u]]++;
}else{
//assert(state[u][fa[u]]==u);
state[u][fa[u]]=state[fa[u]][u]=0;
d_in[fa[u]]--,d_out[u]--;
}
int v=u;
u=fa[u];
b[u].union_s(fa[u],v);
}
to[Root]=u;
if(state[u][fa[u]]==-1){
state[u][fa[u]]=state[fa[u]][u]=fa[u];
d_nu[u]--,d_nu[fa[u]]--;
d_in[u]++,d_out[fa[u]]++;
}else{
//assert(state[u][fa[u]]==u);
state[u][fa[u]]=state[fa[u]][u]=0;
d_in[fa[u]]--,d_out[u]--;
}
}
puts("");
}
return 0;
}总结一下要求：
总共要选至少一个位置（不能不选）。
每行至多选一个位置。
每列选的位置数量不超过所选总数的\(\frac{1}{2}\)。
部分分：\(m=2\)或\(3\)时，以\(m=3\)为例，我们可以设\(dp[i][a][b][c]\)表示考虑了\(i\)行，第\(1\)列选了\(a\)个，第\(2\)列选了\(b\)个，第\(3\)列选了\(c\)个的方案数。统计答案时要求\(a,b,c\leq\lfloor\frac{a+b+c}{2}\rfloor\)即可。复杂度\(O(n^{m+1})\)。我考场上就写的这个，得到了64分的好成绩。
发现每列不超过\(\frac{1}{2}\)这个限制很特殊。如果我们枚举哪些列不合法，那么容易发现，不合法的列至多只有\(1\)列。所以我们枚举那一个不合法的列，然后求出：在强制这一列不合法的前提下的方案数。
设\(dp[i][j][k]\)表示考虑了前\(i\)行，共选了\(j\)个数，强制不合法的列选了\(k\)个数，时的方案数。复杂度\(O(n^3m)\)，可以得到\(84\)分的高分(Orz pmt!)。
考虑优化，其实我们关系的只是\(j\)和\(k\)之间的关系。具体地，最后我们要求\(k>\lfloor\frac{j}{2}\rfloor\)，即\(2k-j>0\)。所以我们可以把\([j][k]\)两维压成一维：令\(dp[i][x]\)表示考虑了前\(i\)行，\(2k-j=x\)时的方案数即可。由于\(x\)可能\(<0\)，所以在具体实现时我们把第二维的值统一加\(n\)。
时间复杂度\(O(n^2m)\)。
//problem:P5664
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
inline int read(){
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MOD=998244353;
inline int mod(int x){return x<MOD?(x<0?x+MOD:x):x-MOD;}
int n,m,a[105][2005],s[105],dp[105][205];
int main() {
n=read();m=read();int ans=1;
for(int i=1;i<=n;++i){for(int j=1;j<=m;++j)a[i][j]=read(),s[i]=mod(s[i]+a[i][j]);ans=(ll)ans*(s[i]+1)%MOD;}
ans=mod(ans-1);
for(int l=1;l<=m;++l){
memset(dp,0,sizeof(dp));
dp[0][n]=1;
for(int i=0;i<n;++i){
for(int j=n-i;j<=n+i;++j){
if(!dp[i][j])continue;
dp[i+1][j+1]=mod(dp[i+1][j+1]+(ll)dp[i][j]*a[i+1][l]%MOD);
dp[i+1][j-1]=mod(dp[i+1][j-1]+(ll)dp[i][j]*mod(s[i+1]-a[i+1][l])%MOD);
dp[i+1][j]=mod(dp[i+1][j]+dp[i][j]);
}
}
for(int j=n+1;j<=n+n;++j)ans=mod(ans-dp[n][j]);
}
cout<<ans<<endl;
return 0;
}部分分：设\(dp[i][j]\)表示考虑了前\(i\)个数，当前段的结束位置为\(i\)，上一段的结束位置为\(j\)时的最小代价。转移时枚举上上段的结束位置\(k\)，从\(dp[j][k]\)转移。对于每个\(i,j\)，合法的\(k\)一定是一段后缀（位置可以二分出来），所以记录\(dp\)第二维的后缀最小值即可转移，复杂度\(O(n^2\log n)\)。
我们为什么要用dp的第二维记录一个\(j\)呢？我们把一个东西记录在dp的一维里，必然是因为这个东西“有得有失”。比如做背包时，加入一个物品，增加了价值，但同时也增加了重量。我们不知道如何去平衡这个得失，或者说不知道在此时最优的情况所带来的的“失”是否会使全局更劣，于是我们单开一维，把每一种情况都记录下来，从而保证不错过全局最优解。
回到本题，我们之所以不设\(dp[i]\)，是因为这样我们不知道上一段的和是什么，缺少条件，不好转移。但是如果用一个数组记录下每一个\(i\)是从哪里转移过来的呢？这样我们能否保证，对\(j\)最有利的转移点，也同时最有利于\(j\)后面所有需要从\(j\)转移的点？也就是说，如果这个问题的答案是肯定的，那么不存在“有的有失”的情况，当前最优即全局最优，我们直接贪心、直接钦定，不用经过第二维DP的权衡。
考虑每次转移时，选择满足条件的（上一段的和\(\leq\)当前段和的）点中最靠后的转移。
可以证明，这样做一定是最优的。
备注：我在网上找到了两篇证明，但是证明并不优美且没啥扩展价值，所以就不展开了。附两个链接供读者参考。
感性理解一下结论好像又很显然（雾）
在此结论的基础上，每个位置\(i\)的上一段的结束位置就是确定的了，我们记为\(pre(i)\)。对\(a\)做前缀和，我们记\(s_i=\sum_{j=1}^{i}a_j\)。
则最优的转移点\(pre(i)\)一定是所有满足\(s_i-s_j\geq s_j-s_{pre(j)}\)的\(j\)中最大的。把这个条件转化一下就是\(2s_j-s_{pre(j)}\leq s_i\)。
我们维护一个单调队列。在这个队列中，从队首到队尾，元素的下标单调递增，队内元素\(j\)的\(2s_j-s_{pre(j)}\)也单调递增。因为如果存在一个\(k<j\)使得\(2s_k-s_{pre(k)}\geq2s_j-s_{pre(j)}\)，则\(k\)在任何时候都不会有用。
当需要从\(i\)转移时，我们检查队首。如果队首的下一个元素满足转移条件，则可以把队首弹掉。因为我们总是取满足条件的元素中下标最大的。而\(s_i\)是单调递增的，这个队首如果现在没有用，以后就再也不会有用了。
复杂度\(O(n)\)。
为了避免空间爆炸，我们只开一个长度为\(n\)的数组，即前缀和数组。其他的信息都用结构体或pair装在单调队列里，这样使用的内存大小为任意时刻的最大队列长度，显然是\(\leq n\)的。
//problem:P5665
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
namespace Fread{
const int MAXN=1<<20;
char buffer[MAXN],*S,*T;
inline char getchar(){
if(S==T){
T=(S=buffer)+fread(buffer,1,MAXN,stdin);
if(S==T) return EOF;
}
return *S++;
}
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#endif
inline int read(){
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MAXN=4e7+5;
int n;
ll s[MAXN];
__int128 dp[MAXN];
void big_input(){
int x,y,z,b[2],pj,lj,rj;
x=read(),y=read(),z=read(),b[1]=read(),b[0]=read(),read();
const int moood=(1<<30);
pj=0;
for(int i=1,j=0;i<=n;++i){
if(i>pj){
++j;
pj=read();lj=read();rj=read();
}
if(i>2)b[i&1]=((ll)b[(i&1)^1]*x+(ll)b[i&1]*y+z)%moood;
s[i]=s[i-1]+(b[i&1]%(rj-lj+1))+lj;
}
}
void print(__int128 ans){
const ll base=1e18;
if(ans<base)cout<<(ull)ans<<endl;
else{
cout<<(ll)(ans/base);
ll t=ans%base;int len=0;
while(t)len++,t/=10;
for(int i=1;i<=18-len;++i)cout<<"0";
if(ans%base)cout<<(ll)(ans%base)<<endl;
}
}
int main() {
n=read();int ty=read();
if(!ty)for(int i=1;i<=n;++i)s[i]=s[i-1]+read();
else big_input();
dp[0]=0;
deque<pli>dq;dq.push_back(mk(0,0));
for(int i=1;i<=n;++i){
while(dq.size()>1&&s[i]>=dq[1].fst)dq.pop_front();
__int128 d=s[i]-s[dq.front().scd];dp[i]=dp[dq.front().scd]+d*d;
while(!dq.empty()&&dq.back().fst>=s[i]+d)dq.pop_back();
dq.push_back(mk(s[i]+d,i));
}
print(dp[n]);
return 0;
}不妨先令\(1\)为根。考虑以根作为重心的贡献。
设根最大的子树大小为\(mx\)。
如果割掉的边不在最大的子树内，则割去的子树大小\(t\)要满足\(mx\times 2\leq n-t\)，即\(t\leq n-mx\times 2\)；
否则，割掉的边在最大的子树内，设次大子树大小为\(smx\)，则割去子树大小\(t\)要满足：\(smx\times 2\leq n-t,(mx-t)\times 2\leq n-t\)，即\(mx\times2-n\leq t\leq n-smx\times2\)。
我们用线段树合并求出每个节点子树内每种大小的子树分别有多少。枚举根的每个儿子，分别在根的线段树上做区间查询，就得到了根作为重心的出现次数。
如果暴力枚举根，每次重新做线段树合并，则复杂度\(O(n^2\log n)\)。
考虑换根。发现如果以\(u\)为根，则相比于以\(fa(u)\)为根，在线段树上的变化：只会增加一个\(n-size_u\)，减少一个\(size_u\)。在dfs时用一个树状数组维护根到当前节点的路径上，哪些\(size\)值被增加了，哪些\(size\)值被减少了，回溯时在树状数组上消除贡献即可。
需要注意的是，线段树合并后，原线段树上的信息就会被覆盖，所以我们不能在换根时再到\(u\)的线段树上进行查询，而要在第一遍dfs到\(u\)时就把换根需要的查询信息预处理好。
//problem:P5666
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
namespace Fread{
const int MAXN=1<<20;
char buffer[MAXN],*S,*T;
inline char getchar(){
if(S==T){
T=(S=buffer)+fread(buffer,1,MAXN,stdin);
if(S==T)return EOF;
}
return *S++;
}
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#endif
inline int read(){
int t;cin>>t;return t;
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MAXN=3e5;
struct EDGE{int nxt,to;}edge[MAXN<<1];
int n,head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u],edge[tot].to=v,head[u]=tot;}
int rt[MAXN];
struct SegmentTree{
int cnt,ls[MAXN*40],rs[MAXN*40],sum[MAXN*40];
void modify(int &p,int l,int r,int pos,int x){
if(!p)p=++cnt;assert(cnt<MAXN*40);
sum[p]+=x;
if(l==r)return;
int mid=(l+r)>>1;
if(pos<=mid)modify(ls[p],l,mid,pos,x);
else modify(rs[p],mid+1,r,pos,x);
}
int merge(int x,int y){
if(!x||!y)return x+y;
int z=++cnt;assert(cnt<MAXN*40);
sum[z]=sum[x]+sum[y];
ls[z]=merge(ls[x],ls[y]);
rs[z]=merge(rs[x],rs[y]);
return z;
}
int query(int p,int l,int r,int ql,int qr){
if(ql>qr||!p)return 0;
if(ql<=l&&qr>=r)return sum[p];
int mid=(l+r)>>1,res=0;
if(ql<=mid)res=query(ls[p],l,mid,ql,qr);
if(qr>mid)res+=query(rs[p],mid+1,r,ql,qr);
return res;
}
void Init(){
for(int i=1;i<=cnt;++i)ls[i]=rs[i]=sum[i]=0;cnt=0;
}
SegmentTree(){}
}T1;
int sz[MAXN],f[MAXN],L[MAXN],R[MAXN];
void dfs1(int u,int fa){
sz[u]=1;
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(v==fa)continue;
dfs1(v,u);
sz[u]+=sz[v];
}
int mx=n-sz[u],smx=0;
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(v==fa)continue;
if(sz[v]>mx)smx=mx,mx=sz[v];
else if(sz[v]>smx)smx=sz[v];
}
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(v==fa)continue;
if(smx==mx||sz[v]!=mx){
f[u]+=T1.query(rt[v],1,n,1,n-2*mx);
}else{
f[u]+=T1.query(rt[v],1,n,2*mx-n,n-2*smx);
}
}
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(v==fa)continue;
rt[u]=T1.merge(rt[u],rt[v]);
}
if(fa){
if(smx==mx||n-sz[u]!=mx){
f[u]-=T1.query(rt[u],1,n,L[u]=1,R[u]=n-2*mx);
}else{
f[u]-=T1.query(rt[u],1,n,L[u]=2*mx-n,R[u]=n-2*smx);
}
T1.modify(rt[u],1,n,sz[u],1);
}
}
ll ans;
struct BIT{
int c[MAXN];
void modify(int p,int x){
for(;p<=n;p+=(p&(-p)))c[p]+=x;
}
int query(int p){
int res=0;
for(;p;p-=(p&(-p)))res+=c[p];
return res;
}
int query(int l,int r){
l=max(l,1),r=min(r,n);
if(l>r)return 0;
return query(r)-query(l-1);
}
void Init(){
memset(c,0,sizeof(int)*(n+3));
}
BIT(){}
}T2;
void dfs2(int u,int fa){
if(fa){
T2.modify(sz[u],-1);
T2.modify(n-sz[u],1);
f[u]+=T1.query(rt[1],1,n,L[u],R[u])+T2.query(L[u],R[u]);
}
//cout<<"* "<<u<<" "<<f[u]<<endl;
ans+=(ll)u*f[u];
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(v==fa)continue;
dfs2(v,u);
}
if(fa){
T2.modify(sz[u],1);
T2.modify(n-sz[u],-1);
}
}
void Init(){
memset(head,0,sizeof(int)*(n+3));tot=0;
memset(rt,0,sizeof(int)*(n+3));T1.Init();
T2.Init();
memset(f,0,sizeof(int)*(n+3));
}
int main() {
//freopen("data.txt","r",stdin);
int Testcases=read();while(Testcases--){
Init();
n=read();
for(int i=1,u,v;i<n;++i)u=read(),v=read(),add_edge(u,v),add_edge(v,u);
//for(int i=1;i<=n;++i)ans+=(ll)i*solve_root(i);
dfs1(1,0);
ans=0;dfs2(1,0);
printf("%lld\n",ans);
}
return 0;
}设\(P=\max_{i=1}^{n}\{price_i\}\)。我敲了一个O(nP)的模拟就直接AC了（大雾）
const int MAXN=1e5+5;
int n;
struct node{int type,price,t;}a[MAXN];
deque<int>dq[1005];
int main() {
n=read();
for(int i=1;i<=n;++i)a[i].type=read(),a[i].price=read(),a[i].t=read();
int ans=0;
for(int i=1;i<=n;++i){
if(a[i].type==0){
ans+=a[i].price;
dq[a[i].price].push_back(i);
}
else{
int opt=-1;
for(int j=a[i].price;j<=1000;++j){
while(!dq[j].empty()&&a[dq[j].front()].t<a[i].t-45)dq[j].pop_front();
if(!dq[j].empty()){
if(opt==-1||a[dq[j].front()].t<a[dq[opt].front()].t)opt=j;
}
}
if(opt==-1)ans+=a[i].price;
else dq[opt].pop_front();
}
}
cout<<ans<<endl;
return 0;
}这里讲一下\(O(n\log P)\)的做法。
我们开一棵下标为票价的值域的线段树。线段树的每个叶子节点上放一个deque。非叶子节点存子树内每个deque的front（首元素）的最小值（deque里存的值是车票的编号，其最小值也就是出现时间最早的车票）。特别地，如果一个deque为空，则令该叶子的值为无穷大。
对于一辆地铁，我们直接在它对应的票价的deque上新加入（push_back）一个下标。
对于一辆公交，我们要查询所有尚未使用的、票价不超过\(price_i\)的车票里时间最早的。相当于在线段树上查询一段后缀的最小值。
如果最小值\(<t_i-45\)，则直接将其弹出，因为它已经过期，以后也不会再有用了。继续查询。
如果查询到的最小值为无穷大，说明所有合法的票价都为空了，我们没有匹配到合法的地铁，这辆公交车必须自己买票。
否则说明查到了一班合法的地铁。将其弹出（表示已使用）。
因为每辆地铁只会入队列、出队列一次，每次加入、弹出时涉及到的线段树操作是\(O(\log P)\)的。所以总复杂度\(O(n\log P)\)。
//problem:P5661
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
namespace Fread{
const int MAXN=1<<20;
char buffer[MAXN],*S,*T;
inline char getchar(){
if(S==T){
T=(S=buffer)+fread(buffer,1,MAXN,stdin);
if(S==T)return EOF;
}
return *S++;
}
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#endif
inline int read(){
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MAXN=1e5+5,MAXP=1005,INF=1e9;
int n;
struct node{int type,price,t;}a[MAXN];
struct SegmentTree{
int val[MAXP],pos[MAXN<<2];
deque<int>dq[MAXP];
void push_up(int p){
pos[p]=(val[pos[p<<1]]<=val[pos[p<<1|1]]?pos[p<<1]:pos[p<<1|1]);
}
void build(int p,int l,int r){
if(l==r){
val[l]=INF;
pos[p]=l;
return;
}
int mid=(l+r)>>1;
build(p<<1,l,mid);
build(p<<1|1,mid+1,r);
push_up(p);
}
void modify(int p,int l,int r,int pos,int x){
if(l==r){
if(x==-1){
assert(!dq[l].empty());
dq[l].pop_front();
val[l]=(dq[l].empty()?INF:dq[l].front());
}
else{
dq[l].push_back(x);
val[l]=dq[l].front();
}
return;
}
int mid=(l+r)>>1;
if(pos<=mid)modify(p<<1,l,mid,pos,x);
else modify(p<<1|1,mid+1,r,pos,x);
push_up(p);
}
int query(int p,int l,int r,int ql,int qr){
if(ql<=l&&qr>=r)return pos[p];
int mid=(l+r)>>1,res=0;
if(ql<=mid)res=query(p<<1,l,mid,ql,qr);
if(qr>mid){
int x=query(p<<1|1,mid+1,r,ql,qr);
if(!res||val[res]>val[x])res=x;
}
assert(res!=0);
return res;
}
}T;
int main() {
n=read();
for(int i=1;i<=n;++i)a[i].type=read(),a[i].price=read(),a[i].t=read();
T.build(1,1,1000);
int ans=0;
for(int i=1;i<=n;++i){
if(a[i].type==0){
ans+=a[i].price;
T.modify(1,1,1000,a[i].price,i);
}
else{
while(true){
int x=T.query(1,1,1000,a[i].price,1000);
if(T.val[x]==INF){
ans+=a[i].price;
break;
}
else if(a[T.val[x]].t<a[i].t-45){
T.modify(1,1,1000,x,-1);
}
else{
T.modify(1,1,1000,x,-1);
break;
}
}
}
}
cout<<ans<<endl;
return 0;
}由于同一天内是可以既卖出又买入的，如果我们要将一样纪念品连续持有好几天，则我们可以视作在中间的每一天既卖出、又买入，这样我们可以在每天刚开始的时候，把手上所有的纪念品都换成钱，如果要继续持有，就在今天晚上再换回来。这样的好处是我们只需要DP出当天把所有纪念品换成钱后手上最多有多少钱即可，不用考虑其它资产。
设\(f(i)\)表示第\(i\)天，把所有纪念品换成钱后，手上最多有多少钱。用这些钱我们可以在当天买纪念品、在下一天卖掉，从而在下一天得到更多的钱。
在每一天内，我们可能会买很多种不同的纪念品。设\(g(x)\)表示在当前天，用\(x\)元钱，最多能在第二天（通过把手上的纪念品卖掉）换得多少钱。这相当于是完全背包的模型，因为每样纪念品可以在钱数足够的情况下买无限多个。每样纪念品都是背包的物品，它们的重量是它们在当前天的价格，而它们的价值是它们在下一天的价格。
对第\(i\)天，求出\(g\)后，则\(f(i+1)=g(f(i))\)。
边界是\(f(1)=m\)。
复杂度\(O(TVn)\)，其中\(V\)是任意时刻的最大金币数量。
//problem:P5662
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
namespace Fread{
const int MAXN=1<<20;
char buffer[MAXN],*S,*T;
inline char getchar(){
if(S==T){
T=(S=buffer)+fread(buffer,1,MAXN,stdin);
if(S==T)return EOF;
}
return *S++;
}
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#endif
inline int read(){
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int t,n,m,a[105][105],f[105],g[10004];
int main() {
t=read(),n=read(),m=read();
for(int i=1;i<=t;++i)for(int j=1;j<=n;++j)a[i][j]=read();
f[1]=m;
for(int i=1;i<t;++i){
g[0]=0;
for(int j=1;j<=10000;++j){
g[j]=max(j,g[j-1]);
for(int k=1;k<=n;++k)if(j>=a[i][k])g[j]=max(g[j],g[j-a[i][k]]+a[i+1][k]);
}
f[i+1]=g[f[i]];
}
cout<<f[t]<<endl;
return 0;
}发现编号为\(a\)的工人生产第\(L\)阶段的零件，需要\(1\)提供原材料，当且仅当存在一条\(1\)到\(a\)的路径长度为\(L\)。因为这个“路径”是允许在同一条边上来回横跳的，每横跳一次路径长度加\(2\)，所以我们可以把条件改为：当且仅当存在一条\(1\)到\(a\)的路径，长度\(\leq L\)且奇偶性和\(L\)相同。
所以我们从\(1\)出发，对每个点求从\(1\)到它的奇数最短路和偶数最短路即可。因为每个点只会被入队、出队各一次，所以复杂度\(O(n)\)。
//problem:P5663
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
namespace Fread{
const int MAXN=1<<20;
char buffer[MAXN],*S,*T;
inline char getchar(){
if(S==T){
T=(S=buffer)+fread(buffer,1,MAXN,stdin);
if(S==T)return EOF;
}
return *S++;
}
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#endif
inline int read(){
int f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline ll readll(){
ll f=1,x=0;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MAXN=1e5+5,INF=0x3f3f3f3f;
struct EDGE{int nxt,to;}edge[MAXN<<1];
int n,m,q,head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u],edge[tot].to=v,head[u]=tot;}
int dis[MAXN][2];
void dij(){
memset(dis,0x3f,sizeof(dis));
dis[1][0]=0;
queue<pii>q;q.push(mk(1,0));
while(!q.empty()){
int u=q.front().fst,t=q.front().scd;q.pop();
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
int nd=t+1;
if(nd<dis[v][nd&1]){
dis[v][nd&1]=nd;
q.push(mk(v,nd));
}
}
}
}
int main() {
n=read();m=read();q=read();
for(int i=1,u,v;i<=m;++i)u=read(),v=read(),add_edge(u,v),add_edge(v,u);
dij();
while(q--){
int u=read(),t=read();
if(dis[u][t&1]<=t)puts("Yes");
else puts("No");
}
return 0;
}标签：就是 ini 顺时针 多少 tree testcase pmt 很多 程序
原文地址：https://www.cnblogs.com/dysyn1314/p/12271884.html
