paulzrm's blog

发表于 分类于

题目链接：300iq contest 2 B. Bitwise Xor

乡下人没见过 Trie 树，学会了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mxn=2e7+7;
const int md=998244353;
int ch[mxn][2],cnt=1,cc[mxn],n,ans;ll x,a[mxn];
inline void add(int&x,int y){x+=y;if(x>=md)x-=md;}
int main(){
    ios_base::sync_with_stdio(false);
    cin>>n>>x;
    for(int i=1;i<=n;++i)cin>>a[i];
    sort(a+1,a+n+1);
    for(int i=1;i<=n;++i){
        int dp=1,cur=1;
        for(int j=59;~j;--j){
            int c=a[i]>>j&1,d=x>>j&1;
            if(d==0)add(dp,cc[ch[cur][!c]]);
            cur=ch[cur][c^d];
        }
        add(dp,cc[cur]),add(ans,dp),cur=1;
        for(int j=59;~j;--j){
            int c=a[i]>>j&1;
            if(!ch[cur][c])ch[cur][c]=++cnt;
            cur=ch[cur][c];add(cc[cur],dp);
        }
    }cout<<ans;
}

发表于 分类于

题目链接：[AGC044C] Strange Dance

乡下人 × 2。这次是低位在上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include<bits/stdc++.h>
using namespace std;
const int mxn=5e6+6;
int ch[mxn][3],tag[mxn],n,root,cnt,val[mxn];
string s;
inline void build(int&x,int dep,int id,int ml){
    if(!x)x=++cnt;
    if(dep==n){
        val[x]=id;
        return;
    }
    build(ch[x][0],dep+1,id,ml*3);
    build(ch[x][1],dep+1,id+ml,ml*3);
    build(ch[x][2],dep+1,id+ml*2,ml*3);
}
inline void pushdown(int x){
    if(tag[x]){
        tag[ch[x][0]]^=tag[x];
        tag[ch[x][1]]^=tag[x];
        tag[ch[x][2]]^=tag[x];
        tag[x]=0;
        swap(ch[x][1],ch[x][2]);
    }
}
inline void go(int x,int dep){
    if(dep==n)return;
    pushdown(x);
    swap(ch[x][1],ch[x][2]),swap(ch[x][0],ch[x][1]);
    go(ch[x][0],dep+1);
}
inline void S(){tag[root]^=1;}
inline void R(){go(root,0);}
int ans[mxn],cc;
inline void get(int x,int dep,int id,int ml){
    if(dep==n){
        ++cc;
        ans[val[x]]=id;
        return;
    }
    pushdown(x);
    get(ch[x][0],dep+1,id,ml*3);
    get(ch[x][1],dep+1,id+ml,ml*3);
    get(ch[x][2],dep+1,id+ml*2,ml*3);
}
int main(){
    ios_base::sync_with_stdio(false);
    cin>>n>>s;
    build(root,0,0,1);
    for(int i=0;i<s.size();++i){
        if(s[i]=='S')S();
        else R();
    }
    get(root,0,0,1);
    for(int i=0;i<cc;++i)cout<<ans[i]<<' ';
    cout<<'\n';
}

发表于 分类于

本文迁移自洛谷原文。

考虑到最多只会有一个 。

  • 没有任何一个 。

那么我们可以考虑类似 meet-in-the-middle 的做法。

令 表示考虑了前 个数，此时乘积为 ， 的最大值， 的定义类似，不过是从 开始倒着的。dp 的时候枚举 ，枚举 ，再枚举满足 第二维大小的所有 即可。

则我们这种情况下的最好答案就是枚举一个中间断点 ，和 左边的部分的乘积 ， 的最小值了。

此时我们需要证明，在所有选择的 都 的情况下， 和 的第二维都只要开到 即可。

不妨设一个 ，初始为 最大的位置，令 为 左边所有 的乘积， 为 右边所有 的乘积。

我们贪心的考虑，如果 ，就让 ；如果 ，就让 。在移动 的同时维护 和 的值。

此时第二维就需要开到一个 的大小。因为 是 级别的，所以 ，故第二维只需要开到 即可。因为 ，所以 ，得证。

综上，该部分复杂度为 。

  • 存在恰好一个 。

那么我们可以直接枚举这个 ，发现 左侧和右侧 的乘积均 。令 表示现暂时不选 ，其他所有位置都选之后乘积为 时的最大值。这个可以利用 和 快速处理。

然后我们枚举除了 的所有 的乘积 ，推出 的值最小是多少，计算出 即第 个数的贡献，乘上 即可。

该部分复杂度为 。

综上，总复杂度为 ，可以不知道为什么但只跑了 1.5s 通过此题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<bits/stdc++.h>
using namespace std;
const int B=177830;
const int B2=6600;
int n,w,a[103];
double f[103][B+3],g[103][B+3],ans;
vector<int>v;
double h[B2+3];
int main(){
	cin>>n>>w;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	f[0][1]=1;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=B;j++)
			for(int k=1;k<=B/j;k++)
				f[i][j*k]=max(f[i][j*k],f[i-1][j]*(1.0*(a[i]/k)/a[i]));
		for(int j=B;j>0;j--)
			f[i][j]=max(f[i][j],f[i][j+1]);
	}
	g[n+1][1]=1;
	for(int i=n;i;i--){
		for(int j=1;j<=B;j++)
			for(int k=1;j*k<=B;k++)
				g[i][j*k]=max(g[i][j*k],g[i+1][j]*(1.0*(a[i]/k))/a[i]);
		for(int j=B;j>0;j--)
			g[i][j]=max(g[i][j],g[i][j+1]);
	}
	for(int i=0;i<=n;++i)for(int j=1;j<=B;++j)
	    if((w+j-1)/j<=B)ans=max(ans,f[i][j]*g[i+1][(w+j-1)/j]);
	for(int i=1;i<=n;++i){
		if(1){
			for(int j=1;j<=B2;++j)h[j]=0;
			for(int j=1;j<=B2;++j)
				for(int k=1;k*j<=B2;++k)
					h[j*k]=max(h[j*k],f[i-1][j]*g[i+1][k]);
			for(int j=B2;j;--j)h[j]=max(h[j],h[j+1]);
			for(int j=1;j<=B2;++j){
				int ee=(w+j-1)/j;ee=max(ee,1);
				if(ee>a[i])continue;
				int e2=a[i]/ee;
				ans=max(ans,1.0*e2/(1.0*a[i])*h[j]);
			}
		}
	}
	cout<<fixed<<setprecision(15)<<ans*w<<'\n';
}

发表于 分类于

本文迁移自洛谷原文。

题目翻译是错误的，正确的如下：

给定两个正整数 ，你需要求出有多少个正整数 满足 且 ，其中 是 的各位数字之和。

题解：

这个 的数据范围并不常见，但是可以发现大概是根号的复杂度。

显然无法分块，考虑怎么做到根号分治。我们先对 设定一个阈值 ，其中 是 级别。

当 时，最大的 不过 ，所以我们可以去先枚举数字和 ，然后就可以发现， 的 的个数不会超过 个。直接枚举这些数就可以了。复杂度 。

我们可以考虑把 做为一维压到数位 dp 里了。令 表示考虑到从高到低第 位，此时的数 ，数字和为 ，是否已经小于 的数的个数。这样就可以 dp 了，复杂度 。

均衡一下取 最优。

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include<bits/stdc++.h>
#define ll long long
#define int ll
using namespace std;
ll k,m,n;
int ee[13];
ll dp[13][10000][91][2];
inline void add(ll&x,ll y){x+=y;}
signed main(){
	cin>>k>>m;
	ll ans=0;ll tm=m;
	for(int i=1;;++i){
		ee[i]=tm%10;
		tm/=10;
		if(tm==0){
			n=i;
			break;
		}
	}
	reverse(ee+1,ee+n+1);
	if(k>=10000){
		for(int i=0;i<=90;++i){
			for(ll ee=i;ee<=m;ee+=k){
				ll t=ee,cnt=0;
				while(t){
					cnt+=t%10;
					t/=10;
				}
				if(cnt%k==i)++ans;
			}
		}
		cout<<ans-1<<'\n';
		return 0;
	}
	dp[1][0][0][0]=1;
	for(int i=1;i<=n;++i){
		for(int j=0;j<k;++j){
			for(int sm=0;sm<=90;++sm){
				{//f=0
					for(int t=0;t<ee[i];++t){
						if(sm+t<=90){
							add(dp[i+1][(j*10+t)%k][sm+t][1],dp[i][j][sm][0]);
						}
					}
					if(sm+ee[i]<=90)add(dp[i+1][(j*10+ee[i])%k][sm+ee[i]][0],dp[i][j][sm][0]);
				}
				{//f=1
					for(int t=0;t<10;++t)if(sm+t<=90)add(dp[i+1][(j*10+t)%k][sm+t][1],dp[i][j][sm][1]);
				}
			}
		}
	}
	for(int ee=0;ee<=90;++ee)add(ans,dp[n+1][ee%k][ee][0]),add(ans,dp[n+1][ee%k][ee][1]);
	cout<<ans-1<<'\n';
}

发表于 分类于

本文迁移自洛谷原文。

link

题目大意：

给出一个长度为 的序列和 个询问。对于每个询问，输入 ，输出满足 的 的对数。

题解：

考虑我们固定一个起点 ，从 到 扩张区间的右端点 ，考虑区间 gcd 的变化。

显然，这个 gcd 最多只会变化 次（ 是值域），因为每次变化必然是砍掉一个（或一些）质因数，而质因数的个数是 级别的。

所以我们可以考虑枚举开头，每次二分出下一个变化点的位置，每个开头二分 次，就可以求出所有可能的 gcd 的值并得到出现次数了。

注意用 表预处理一下 gcd，复杂度就可以做到 了。

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mxn=1e6+6;
int st[mxn][20],n,q,a[mxn],lg[mxn];
inline int ask(int l,int r){
	int t=lg[r-l+1];
	return __gcd(st[l][t],st[r-(1<<t)+1][t]);
}
map<int,ll>cnt;
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>q;
	for(int i=1;i<=n;++i)cin>>a[i],st[i][0]=a[i];
	for(int i=2;i<=n;++i)lg[i]=lg[i>>1]+1;
	for(int j=1;j<20;++j)for(int i=1;i<=n;++i)st[i][j]=__gcd(st[i][j-1],st[i+(1<<(j-1))][j-1]);
	for(int i=1;i<=n;++i){
		int cur=i,val=a[i];
		while(1){
			int lo=cur,hi=n+1,md;
			for(;lo<hi-1;){
				md=lo+hi>>1;
				if(ask(i,md)!=val)hi=md;
				else lo=md;
			}
			cnt[val]+=hi-cur;
			cur=hi;val=ask(i,hi);
			if(hi==n+1)break;
		}
	}
	for(;q--;){
		int x;cin>>x;
		cout<<cnt[x]<<'\n';
	}
}

发表于 分类于

本文迁移自洛谷原文。

link

题目大意：

平面上有 个点，两个点可以构成一组配对当且仅当它们的横坐标或纵坐标相等。

对于从 到 的每个 ，询问在去掉第 个点后，剩下 个点是否能配成 对，满足每个点恰好出现在一组配对中。询问间互相独立。

题解：

先有一个很重要结论：

如果有两个点 他们能匹配上，我们对 之间连一条边。

然后，如果一个连通块的大小是偶数，那么它一定可以达到完美匹配。

证明：

考虑取出两个当前没有匹配上的点 和 。

由于他们是在一个连通块里，所以一定可以找到一条从 到 的路径。

将这条路径上相邻的进行匹配，如果有摧毁的原有匹配那么按照与路径平行的方向找到下一个待匹配的，可以证明一定能将两个匹配被摧毁的不在路径上的点匹配到一起。

所以，如果原图有多个连通块：

  • 如果有多个大小为奇数的连通块，则所有答案都是 NG。

  • 也就是说，我们可以无视掉所有大小为偶数的连通块（这些块内的点的答案都是NG，因为删掉这种点，最终还是会有至少一个大小为奇数的连通块，不符合）。

  • 所以，我们只要在那唯一一个大小为奇数的连通块中，考虑删掉那些点可以使得剩下所有连通块的大小都是偶数。

然后发现这玩意很像一个圆方树，所以建出圆方树后跑一下就行了。

注意：

如果暴力建原图的话边的条数是 的，所以我们可以对行和列的 分别建点，然后将点连向行/列即可。

最终只有 个点是真的，大小算 ，那些代表行/列/点双的点大小都要算 。

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include<bits/stdc++.h>
using namespace std;
const int mxn=2e6+6;
vector<int>g[mxn];int k,n;
int X[mxn],Y[mxn];
bool used[mxn];
int cnt,cur;
vector<int>vtmp,odd;
inline void dfs(int x){
	used[x]=1;
	if(x<=n)vtmp.push_back(x),++cur;
	for(int y:g[x])
		if(!used[y])dfs(y);
}
int dfn[mxn],low[mxn],sta[mxn],idx,top,ca;vector<int>ans[mxn];
vector<int>ng[mxn];
inline void tarjan(int x,int fa){
	int son=0;
	low[x]=dfn[x]=++idx;sta[++top]=x;
	for(int y:g[x]){
		if(!dfn[y]){
			tarjan(y,x);
			++son;
			low[x]=min(low[x],low[y]);
			if(low[y]>=dfn[x]){
				++ca;
				while(sta[top+1]!=y)ans[ca].push_back(sta[top--]);
				ans[ca].push_back(x);
			}
		}else if(y!=fa)low[x]=min(low[x],dfn[y]);
	}
	if(fa==0 and son==0)ans[++ca].push_back(x);
}
int siz[mxn],fa[mxn];
inline void go(int x,int par=0){
	fa[x]=par;
	if(x>ca and x<=ca+n)siz[x]=1;
	for(int y:ng[x])if(y!=par){
		go(y,x);
		siz[x]+=siz[y];
	}
}
int imp[mxn],res[mxn];
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>k;n=2*k+1;
	int base=n+1,base2=n*3+5;
	for(int i=1;i<=n;++i){
		cin>>X[i]>>Y[i];
		g[i].push_back(base+X[i]);
		g[base+X[i]].push_back(i);
		g[i].push_back(base2+Y[i]);
		g[base2+Y[i]].push_back(i);
	}
	for(int i=1;i<=n;++i){
		if(!used[i]){
			cur=0;vtmp.clear();
			dfs(i);
			if(cur%2==1){
				++cnt;
				odd=vtmp;
				if(cnt>1){
					for(int j=1;j<=n;++j)cout<<"NG\n";
					return 0;
				}
			}
		}
	}
//	for(int i:odd)cerr<<i<<' ';cerr<<'\n';
	for(int i:odd)imp[i]=1;
	for(int i=1;i<=n;++i)if(imp[i] and !dfn[i]){
		top=0;
		tarjan(i,0);
	}
	for(int i=1;i<=ca;++i)for(int j:ans[i])ng[i].push_back(ca+j),ng[ca+j].push_back(i);
	go(1);
	for(int i=ca+1;i<=ca+n;++i){
		if(imp[i-ca]){
			int tot=odd.size()-1;
			int bad=0;
			for(int j:ng[i])if(j!=fa[i]){
				if(siz[j]%2==1){
					bad=1;
					break;
				}
				tot-=siz[j];
			}
			if(tot%2==1)bad=1;
			if(bad)res[i-ca]=-1;
		}
	}
	for(int i=1;i<=n;++i){
		if(!imp[i] or res[i]==-1)cout<<"NG\n";
		else cout<<"OK\n";
	}
}

发表于 分类于

本文迁移自洛谷原文。

link

题目大意：

给定 ，。有 种商品，编号从 到 ，第 种商品最多能拿 个。

共 次询问。每次询问给定 ，，求第 种商品 恰好 拿走 个的前提下，在 种商品中一共拿走 个商品的方案数。两种方案不同当且仅当存在一种商品在二方案中被拿走的个数不同。输出答案对 取模的结果。

部分分是 和 。

题解：

部分分是基础 。

令 表示考虑到第 种物品，当前已经选了 个时的方案数。转移为 。

然后每次询问暴力求一遍 dp，可以拿到第一个部分分。

然后我们可以发现第二个部分分中 小 大，就可以考虑预处理出所有询问要恰好拿走的商品 id 做最后一个物品的 dp 数组（很容易发现这些商品之间的顺序无关紧要），就可以了。预处理复杂度 。

正解还是要看到这个商品之间的顺序无关紧要。

再观察这个转移式子，。

考虑反过来由 推向 ，会有什么效果？

相当于 再加上 （如果 ）。

再根据商品之间无关紧要， 这个数组为考虑完全部的 个物品之后得到的 dp 值，前面商品的顺序再怎么换也不会影响到它，所以我们可以枚举假设最后一个选的是 号物品， 的倒推即可。总时间复杂度 。

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<bits/stdc++.h>
using namespace std;
const int mxn=2005;
const int md=1000000007;
inline void add(int&x,int y){
	x+=y;
	if(x>=md)x-=md;
}
inline void del(int&x,int y){
	x-=y;
	if(x<0)x+=md;
}
int n,m,q,a[mxn],f[mxn][mxn],g[mxn][mxn];
int main(){
	ios_base::sync_with_stdio(false);
	cin>>n>>m>>q;for(int i=1;i<=n;++i)cin>>a[i];
	f[1][0]=1;
	for(int i=1;i<=n;++i){
		int t=0;
		for(int j=0;j<=m*2;++j){
			add(t,f[i][j]);
			if(j>a[i])del(t,f[i][j-a[i]-1]);
			f[i+1][j]=t;
		}
	}
	for(int i=1;i<=n;++i){
		g[i][0]=1;
		for(int j=1;j<=m;++j){
			g[i][j]=(f[n+1][j]-f[n+1][j-1]+md)%md;
			if(j>a[i])add(g[i][j],g[i][j-a[i]-1]);
		}
	}
	for(;q--;){
		int x,k;cin>>x>>k;
		if(k>m)cout<<0<<'\n';
		else cout<<g[x][m-k]<<'\n';
	}
}

发表于 分类于

本文迁移自洛谷原文。

link

题目大意：

有一个 （）的正方形矩阵，初始全部为 ，下标从 开始。

有 （）次操作：

  • 将所有满足 的点 的值加上 。

  • 将所有满足 的点 的值加上 。

  • 查询所有满足 ， 的点 的最大值，并求出值为最大值的点的个数。

部分分：

题解：

我们考虑维护两个数组 ，其中 表示所有满足 的点加的和， 表示所有满足 的点加的和。

对于一个点 ，他的值就是 ，所以我们维护 就可以知道全矩阵的值了， 和 操作的复杂度都为 。

关键在于这个询问。

我们可以枚举所有可能的 （就是 的值），那么可以发现，那些在 已知的条件下可行的 就是连续的一些奇数或者偶数。用数据结构维护可以做到 ，得到部分分。

再继续考虑。

考虑特殊化，查询的是一个正方形。

如果我们从小到大枚举所有的 ，且枚举的时候让 （就是按照 ，， 的顺序枚举），可以发现每次只会新增两个可能的 ，不会变少，所以我们只要暴力用新增的两个 更新就行了。

同理，我们再按照 ， 的顺序枚举，两种情况合并后就是答案了。

再考虑把查询一般化为长方形，则可以按照类似辗转相减法的方法每次割出最大的正方形去查询，然后合并所有的答案，可以证明单次询问复杂度为 ，故总时间复杂度为 。

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include<bits/stdc++.h>
using namespace std;
const int mxn=1e4+9;
const int base=5003;
int n,q,s1[mxn],s2[mxn];
inline pair<int,int> G(pair<int,int> x,pair<int,int> y){
	if(x.first!=y.first){
		if(x.first>y.first)return x;
		else return y;
	}
	x.second+=y.second;
	return x;
}
inline pair<int,int> go(int a,int b,int c,int d){
	int cur,cnt,len;
	pair<int,int>rt={-1145141919,0};
	cur=-1145141919,cnt=0,len=-2;
	for(int sum1=a+b,sum2=c+d;sum1<=a+d;sum1+=2,sum2-=2){ //第一类
		len+=2;
		if(s2[a-b+base-len]>cur)cur=s2[a-b+base-len],cnt=1;
		else if(s2[a-b+base-len]==cur)++cnt;
		if(len!=0){
			if(s2[a-b+base+len]>cur)cur=s2[a-b+base+len],cnt=1;
			else if(s2[a-b+base+len]==cur)++cnt;
		}
		if(s1[sum1]+cur>rt.first){
			rt.first=s1[sum1]+cur;
			rt.second=cnt;
		}else if(s1[sum1]+cur==rt.first){
			rt.second+=cnt;
		}
		if(sum1!=sum2){
			if(s1[sum2]+cur>rt.first){
				rt.first=s1[sum2]+cur;
				rt.second=cnt;
			}else if(s1[sum2]+cur==rt.first){
				rt.second+=cnt;
			}
		}
	}
	len=-1,cnt=0,cur=-1145141919;
	for(int sum1=a+b+1,sum2=c+d-1;sum1<=a+d;sum1+=2,sum2-=2){ //第二类
		len+=2;
		if(s2[a-b+base-len]>cur)cur=s2[a-b+base-len],cnt=1;
		else if(s2[a-b+base-len]==cur)++cnt;
		if(len!=0){
			if(s2[a-b+base+len]>cur)cur=s2[a-b+base+len],cnt=1;
			else if(s2[a-b+base+len]==cur)++cnt;
		}
		if(s1[sum1]+cur>rt.first){
			rt.first=s1[sum1]+cur;
			rt.second=cnt;
		}else if(s1[sum1]+cur==rt.first){
			rt.second+=cnt;
		}
		if(sum1!=sum2){
			if(s1[sum2]+cur>rt.first){
				rt.first=s1[sum2]+cur;
				rt.second=cnt;
			}else if(s1[sum2]+cur==rt.first){
				rt.second+=cnt;
			}
		}
	}
	return rt;
}
inline auto solve(int a,int b,int c,int d){//割成极大正方形
	if(c-a==d-b)return go(a,b,c,d);
	int l=min(c-a,d-b);
	if(c-a>d-b){
		pair<int,int> rt=go(a,b,a+l,b+l);
		rt=G(rt,solve(a+l+1,b,c,d));
		return rt;
	}else{
		pair<int,int> rt=go(a,b,a+l,b+l);
		rt=G(rt,solve(a,b+l+1,c,d));
		return rt;
	}
}
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>q;
	for(;q--;){
		int tp,a,b,c,d;
		cin>>tp;
		if(tp==1){
			cin>>a>>b>>c;
			for(int i=a;i<=b;++i)s1[i]+=c;
		}
		if(tp==2){
			cin>>a>>b>>c;
			a+=base,b+=base;
			for(int i=a;i<=b;++i)s2[i]+=c;
		}
		if(tp==3){
			cin>>a>>b>>c>>d;
			auto p=solve(a,c,b,d);
			cout<<p.first<<' '<<p.second<<'\n';
		}
	}
}

发表于 分类于

本文迁移自洛谷原文。

link

题目大意：

给你一棵有 () 个节点的树，其中一些节点是特殊节点，相邻两个点的距离为 。

有 () 次询问，每次给你两个点 ，你需要求出从 走到 的最小时间。

一开始，你的速度是每 个时间单位走 个距离单位。假设在某一时刻你到了一个特殊节点，那么你的速度就会变为 个时间单位走 个距离单位，这次询问内有效。

题解：

显然有两种过程：

  • 从 直接走到 ，花费时间 。

  • 从 走到 链上某个节点 ，再从 走到某个特殊节点 ，再从 返回 ，最后从 走到 。

第一种情况平凡，我们考虑第二种。

有以下结论：

  • 第二种情况下的答案

  • 一定是到 距离最近的特殊节点。显然，因为 只和 一项有关。

所以我们可以跑一遍 bfs 处理出到所有节点最近的特殊节点的距离 （记为 ） 是多少。

然后在 已知的情况下， 容易算出，我们只需要求出 的最小值就可以了。

比较难算，但我们可以用一个分类讨论的套路把它拆开来：

令 为 的 LCA，进行分类：

  • 在 这条链上

此时 （ 为节点 的深度），所以在 给定的情况下，我们需要求得的是 的最小值，可以直接树剖或者倍增维护。

  • 在 这条链上

同理，不过 变为 ，维护 的最小值即可。

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include<bits/stdc++.h>
using namespace std;
const int mxn=1e5+5;
string s;
int n,k,dst[mxn],top[mxn],sz[mxn],dep[mxn],ord[mxn],cc,fa[mxn],son[mxn];
int st[mxn],ed[mxn];
vector<int>g[mxn];
inline void dfs(int x,int par=1){              //树剖
	fa[x]=par;sz[x]=1;dep[x]=dep[par]+1;
	for(int y:g[x])if(y!=par){
		dfs(y,x);
		if(sz[y]>sz[son[x]])son[x]=y;
		sz[x]+=sz[y];
	}
}
inline void go(int x,int par=1,int tpf=1){
	st[x]=++cc;ord[cc]=x,top[x]=tpf;
	if(son[x]){
		go(son[x],x,tpf);
		for(int y:g[x])if(y!=par and y!=son[x])go(y,x,y);
	}
	ed[x]=cc;
}
int F1(int x){return dst[x]-dep[x];}//left
int F2(int x){return dst[x]+dep[x];}//right
struct SP{
	int VAL[mxn],val[mxn<<2];
	inline void build(int x,int l,int r){
		if(l==r){val[x]=VAL[ord[l]];return;}
		int md=l+r>>1;
		build(x<<1,l,md);
		build(x<<1|1,md+1,r);
		val[x]=min(val[x<<1],val[x<<1|1]);
	}
	inline int ask(int x,int l,int r,int a,int b){
		if(a<=l and r<=b)return val[x];
		if(b<l or r<a)return 1145141;
		int md=l+r>>1;
		return min(ask(x<<1,l,md,a,b),ask(x<<1|1,md+1,r,a,b));
	}
	inline void init(int (*F)(int)){
		for(int i=1;i<=n;++i)VAL[i]=F(i);
		build(1,1,n);
	}
	inline int qryRange(int x,int y){
		int ans=1145141;
		for(;top[x]!=top[y];){
			if(dep[top[x]]>dep[top[y]])swap(x,y);
			ans=min(ans,ask(1,1,n,st[top[y]],st[y]));
			y=top[y],y=fa[y];
		}
		if(dep[x]>dep[y])swap(x,y);
		ans=min(ans,ask(1,1,n,st[x],st[y]));
		return ans;
	}
	inline int lca(int x,int y){
		for(;top[x]!=top[y];){
			if(dep[top[x]]>dep[top[y]])swap(x,y);
			y=top[y],y=fa[y];
		}
		if(dep[x]>dep[y])swap(x,y);
		return x;
	}
}s1,s2;
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>k;
	for(int i=1,u,v;i<n;++i){
		cin>>u>>v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	dfs(1);go(1);
	cin>>s;s=" "+s;queue<int>q;
	for(int i=1;i<=n;++i)dst[i]=6*n;
	for(int i=1;i<=n;++i)if(s[i]=='1')dst[i]=0,q.push(i);  //bfs
	for(;q.size();){
		int x=q.front();q.pop();
		for(int y:g[x])if(dst[y]>dst[x]+3){
			dst[y]=dst[x]+3;
			q.push(y);
		}
	}
	s1.init(F1);
	s2.init(F2);
	for(;k--;){
		int u,v,l;cin>>u>>v;
		l=s1.lca(u,v);
		cout<<dep[u]+dep[v]-2*dep[l]+min(min(dep[u]+s1.qryRange(u,l),dep[u]+s2.qryRange(l,v)-2*dep[l]),dep[u]+dep[v]-2*dep[l])<<'\n';
	}
}
0%