蓝桥杯第 3 场算法季度赛第八题升级电缆题解

题目链接：升级电缆

视频讲解链接：b站

貌似大部分人一开始想偏了，想些多 $\log$ 的做法。大思路很简单，常见的最大化最小值，那么就是考虑二分最小值，然后通过限制进行 $c h e c k$ 。

显然 $< m i d$ 的所有速度需要增大，增大会使用开销 $c$ ，考虑 $c$ 之和不超过 $l i m i t$ ，除此之外注意到可能新的 $v$ 还是 $< m i d$ ，所以需要注意上界 $r$ 其实应该是最小的 $s$ ，变化后的速度，这样保证每个比它小的 $v$ 变化以后一定比它大。

先讲讲比较无脑的一些做法，考虑链信息使用树剖维护，那么我们可以任意查询一条链上的信息，这个查询的复杂度是双 $\log$ 的，然后再支持二分杂七杂八的，那么这题可能有一些比较假的 $3 \log$ 做法，可能有些人可以卡过去吧。当然可以用 $G B T$ 优化一个 $\log$ 。

观察到答案显然是跟二分性有关，那么常见的这种树上的思路，并且是多次查询的有两个方向：

二分 + $树类 ds 查询信息进行 check$ 。
在树上进行二分答案。

后者比较苛刻，对于树类问题，常常需要可能某个轴需要维护的是可差分的信息。

说说前者，比较暴力一点，观察到这个题涉及到的一些信息需要维护：

关于 $v, s$ 所在的值域限制轴。
关于 $c$ 开销总和的信息统计。
关于树上链 $(u, v)$ 的限制。

那么我们发现，有两对偏序限制 $(1, 3)$ 。那么我们至少需要维护一个类似树套树的结构才能维护关于第二点 $c$ 的开销总和信息。

考虑特殊的树套树，单 $\log$ 的主席树。

基于第一种做法，显然没啥好说的，既然是使用主席树维护信息，那么观察到 $1$ 的偏序关系即为： $\leq v / s$ ，即为前缀偏序，而 $3$ 的偏序则是树上的范围性查询。显然 $1$ 这点可以直接使用主席树本身就是维护了一个外层的前缀偏序信息，即 $r o o t [i]$ 表示 $v a l \leq i$ 的主席树，内层基于边化点以后再维护一个基于 剖分序 的偏序信息即可通过树上前缀和进行查询。

码量上应该还是不算小的，还需要写一个边化点的树链剖分，不会的可以做做 $Q T r e e$ ，还需要离散化下。这个做法显然是双 $\log$ 的。当然了，考虑下离线做法。对于离线带多次二分而言的题，显然整体二分最为合适，思考下二分答案以后，将所有小于它的边进行激活，然后进行判断该二分到哪一侧。重点是维护边激活操作，其实边化点以后就是若干个单修操作，用树状数组或者线段树都可以。不过这玩意如果是剖分序显然三支 $\log$ 了，所以最好用 $G B T$ 优化到两支 $\log$ ，主要还是链路径信息查询部分，单修复杂度很好控制。

考虑下第二种做法：

需要支持树上二分答案，那么信息要求是比较苛刻的，外轴显然是需要一个用于可差分的信息偏序限制，而维护的信息则为可差分信息，内轴即为真正的二分答案轴。

这其实是一个基础板子，不会的可以去学学树上主席树：Count on a tree

那么问题就很简单了，对外轴维护关于 $(u, v)$ 的偏序，即 $r o o t [u]$ 即为 $u \to 1$ 这条路径上的所有点的累计信息，放在了对应的主席树上。

而二分的轴即为内轴，设置信息的轴，即为 $v / s$ 的值域轴。

而维护的信息必须为可差分信息，那么显然为前两者作用下的 $s u m_{c}$ ，关于这个限制条件下的操作累计和。

这样一来就可以进行正确的主席树上的二分了，然后有些人想要找二分的上界 $s_{m i n}$ 还写了一些树剖、倍增之类的查询链上最小值，这是完全没必要的。

考虑下：当存在 $j < i, s_{j} < s_{i}$ ，那么此时此刻显然 $s_{i}$ 不合法，那么只需要让 $s_{i}$ 左侧不合法就行：

当左侧出现 $s$ 时，显然一定 check 失败。这太容易了，设置 $s_{j}$ 处为无穷大，这样一来开销一定超过 $l i m i t$ ，一定不成立，一定往左找，这样一来如果存在最小的 $s$ 是二分答案，那么我们也可以恰好二分到它了。注意 $l i m i t \leq 1 e 18$ ，那么这个无穷大最好使用 $i n t 128$ 来进行存储操作和，至于 $l c a$ 随便倍增求求就行了。单 $\log$ 常数很小，如果是嵌套 $\log$ ，最好离散化下，否则常数是很大的。

参照代码

 #include <bits/stdc++.h>
 
// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
 
#define isPbdsFile
 
#ifdef isPbdsFile
 
#include <bits/extc++.h>
 
#else
 
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>
 
#endif
 
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
 
template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}
 
template <typename T>
T lowBit(T x)
{
    return x & -x;
}
 
template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}
 
template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}
 
template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c) if (b & 1) (ans *= a) %= c;
    return modt(ans, c);
}
 
template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-') sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}
 
template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}
 
template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char)) return;
    if (x < 0) x = -x, putchar('-');
    if (x > 9) write(x / 10);
    putchar(x % 10 ^ 48);
}
 
template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}
 
 
template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;
 
    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow) return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }
 
    T3()
    {
        one = tow = three = 0;
    }
 
    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};
 
template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y) x = y;
}
 
template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y) x = y;
}
 
constexpr int N = 1e5 + 10;
constexpr int MX = 1e9;
constexpr ll INF = 1e18;
constexpr int T = log2(N) + 1;
typedef __int128 i128;
 
struct Node
{
    int left, right;
    i128 sum;
} node[N << 6];
 
#define left(x) node[x].left
#define right(x) node[x].right
#define sum(x) node[x].sum
int cnt;
int fa[N][T + 1], deep[N];
 
inline void add(const int pre, int& curr, const int pos, const ll val, const int l = 1, const int r = MX)
{
    node[curr = ++cnt] = node[pre];
    sum(curr) += val;
    if (l == r) return;
    const int mid = l + r >> 1;
    if (pos <= mid) add(left(pre),left(curr), pos, val, l, mid);
    else add(right(pre),right(curr), pos, val, mid + 1, r);
}
 
inline int query(const int rtU, const int rtV, const int rtLCA, const ll sumV, const int l = 1, const int r = MX)
{
    if (l == r) return l;
    const int mid = l + r >> 1;
    const i128 leftSum = sum(left(rtU)) + sum(left(rtV)) - 2 * sum(left(rtLCA));
    if (leftSum > sumV) return query(left(rtU),left(rtV),left(rtLCA), sumV, l, mid);
    return query(right(rtU),right(rtV),right(rtLCA), sumV - leftSum, mid + 1, r);
}
 
typedef tuple<int, int, int, int> t4;
vector<t4> child[N];
int n, q;
int root[N];
 
inline void dfs(const int curr, const int pa)
{
    deep[curr] = deep[fa[curr][0] = pa] + 1;
    forn(i, 1, T) fa[curr][i] = fa[fa[curr][i - 1]][i - 1];
    for (const auto [nxt,v,c,s] : child[curr])
    {
        if (nxt == pa) continue;
        root[nxt] = root[curr];
        add(root[nxt], root[nxt], v, c);
        add(root[nxt], root[nxt], s, INF);
        dfs(nxt, curr);
    }
}
 
inline int LCA(int x, int y)
{
    if (deep[x] < deep[y]) swap(x, y);
    forv(i, T, 0) if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
    if (x == y) return x;
    forv(i, T, 0) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
    return fa[x][0];
}
 
inline void solve()
{
    cin >> n;
    forn(i, 1, n-1)
    {
        int x, y, v, c, s;
        cin >> x >> y >> v >> c >> s;
        child[x].emplace_back(y, v, c, s);
        child[y].emplace_back(x, v, c, s);
    }
    dfs(1, 0);
    cin >> q;
    while (q--)
    {
        int u, v;
        ll sum;
        cin >> u >> v >> sum;
        const int lca = LCA(u, v);
        cout << query(root[u], root[v], root[lca], sum) << endl;
    }
}
 
signed int main()
{
    // MyFile
    Spider
    //------------------------------------------------------
    // clock_t start = clock();
    int test = 1;
    //    read(test);
    // cin >> test;
    forn(i, 1, test) solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
    // clock_t end = clock();
    // cerr << "time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
}

时 间 复 杂 度 为 ： 预 处 理 O (n (\log n + \log V)), 查 询 O (q \log V)

posted @ 2024-06-30 02:58 Athanasy 阅读(63) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称： Athanasy
园龄： 1年5个月
粉丝： 34
关注： 5

+加关注

2025年3月

日

一

二

三

四

五

六

Athanasy

蓝桥杯第 3 场算法季度赛第八题升级电缆题解

题目链接：升级电缆

视频讲解链接：b站

公告

搜索

常用链接

合集

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	#include <bits/stdc++.h>

	// #pragma GCC optimize(2)
	// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
	// #pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")

	#define isPbdsFile

	#ifdef isPbdsFile

	#include <bits/extc++.h>

	#else

	#include <ext/pb_ds/priority_queue.hpp>
	#include <ext/pb_ds/hash_policy.hpp>
	#include <ext/pb_ds/tree_policy.hpp>
	#include <ext/pb_ds/trie_policy.hpp>
	#include <ext/pb_ds/tag_and_trait.hpp>
	#include <ext/pb_ds/hash_policy.hpp>
	#include <ext/pb_ds/list_update_policy.hpp>
	#include <ext/pb_ds/assoc_container.hpp>
	#include <ext/pb_ds/exception.hpp>
	#include <ext/rope>

	#endif

	using namespace std;
	using namespace __gnu_cxx;
	using namespace __gnu_pbds;
	typedef long long ll;
	typedef long double ld;
	typedef pair<int, int> pii;
	typedef pair<ll, ll> pll;
	typedef tuple<int, int, int> tii;
	typedef tuple<ll, ll, ll> tll;
	typedef unsigned int ui;
	typedef unsigned long long ull;
	#define hash1 unordered_map
	#define hash2 gp_hash_table
	#define hash3 cc_hash_table
	#define stdHeap std::priority_queue
	#define pbdsHeap __gnu_pbds::priority_queue
	#define sortArr(a, n) sort(a+1,a+n+1)
	#define all(v) v.begin(),v.end()
	#define yes cout<<"YES"
	#define no cout<<"NO"
	#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
	#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
	#define forn(i, a, b) for(int i = a; i <= b; i++)
	#define forv(i, a, b) for(int i=a;i>=b;i--)
	#define ls(x) (x<<1)
	#define rs(x) (x<<1\|1)
	#define endl '\n'
	//用于Miller-Rabin
	[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};

	template <typename T>
	int disc(T* a, int n)
	{
	return unique(a + 1, a + n + 1) - (a + 1);
	}

	template <typename T>
	T lowBit(T x)
	{
	return x & -x;
	}

	template <typename T>
	T Rand(T l, T r)
	{
	static mt19937 Rand(time(nullptr));
	uniform_int_distribution<T> dis(l, r);
	return dis(Rand);
	}

	template <typename T1, typename T2>
	T1 modt(T1 a, T2 b)
	{
	return (a % b + b) % b;
	}

	template <typename T1, typename T2, typename T3>
	T1 qPow(T1 a, T2 b, T3 c)
	{
	a %= c;
	T1 ans = 1;
	for (; b; b >>= 1, (a = a) %= c) if (b & 1) (ans = a) %= c;
	return modt(ans, c);
	}

	template <typename T>
	void read(T& x)
	{
	x = 0;
	T sign = 1;
	char ch = getchar();
	while (!isdigit(ch))
	{
	if (ch == '-') sign = -1;
	ch = getchar();
	}
	while (isdigit(ch))
	{
	x = (x << 3) + (x << 1) + (ch ^ 48);
	ch = getchar();
	}
	x *= sign;
	}

	template <typename T, typename... U>
	void read(T& x, U&... y)
	{
	read(x);
	read(y...);
	}

	template <typename T>
	void write(T x)
	{
	if (typeid(x) == typeid(char)) return;
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 ^ 48);
	}

	template <typename C, typename T, typename... U>
	void write(C c, T x, U... y)
	{
	write(x), putchar(c);
	write(c, y...);
	}


	template <typename T11, typename T22, typename T33>
	struct T3
	{
	T11 one;
	T22 tow;
	T33 three;

	bool operator<(const T3 other) const
	{
	if (one == other.one)
	{
	if (tow == other.tow) return three < other.three;
	return tow < other.tow;
	}
	return one < other.one;
	}

	T3()
	{
	one = tow = three = 0;
	}

	T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
	{
	}
	};

	template <typename T1, typename T2>
	void uMax(T1& x, T2 y)
	{
	if (x < y) x = y;
	}

	template <typename T1, typename T2>
	void uMin(T1& x, T2 y)
	{
	if (x > y) x = y;
	}

	constexpr int N = 1e5 + 10;
	constexpr int MX = 1e9;
	constexpr ll INF = 1e18;
	constexpr int T = log2(N) + 1;
	typedef __int128 i128;

	struct Node
	{
	int left, right;
	i128 sum;
	} node[N << 6];

	#define left(x) node[x].left
	#define right(x) node[x].right
	#define sum(x) node[x].sum
	int cnt;
	int fa[N][T + 1], deep[N];

	inline void add(const int pre, int& curr, const int pos, const ll val, const int l = 1, const int r = MX)
	{
	node[curr = ++cnt] = node[pre];
	sum(curr) += val;
	if (l == r) return;
	const int mid = l + r >> 1;
	if (pos <= mid) add(left(pre),left(curr), pos, val, l, mid);
	else add(right(pre),right(curr), pos, val, mid + 1, r);
	}

	inline int query(const int rtU, const int rtV, const int rtLCA, const ll sumV, const int l = 1, const int r = MX)
	{
	if (l == r) return l;
	const int mid = l + r >> 1;
	const i128 leftSum = sum(left(rtU)) + sum(left(rtV)) - 2 * sum(left(rtLCA));
	if (leftSum > sumV) return query(left(rtU),left(rtV),left(rtLCA), sumV, l, mid);
	return query(right(rtU),right(rtV),right(rtLCA), sumV - leftSum, mid + 1, r);
	}

	typedef tuple<int, int, int, int> t4;
	vector<t4> child[N];
	int n, q;
	int root[N];

	inline void dfs(const int curr, const int pa)
	{
	deep[curr] = deep[fa[curr][0] = pa] + 1;
	forn(i, 1, T) fa[curr][i] = fa[fa[curr][i - 1]][i - 1];
	for (const auto [nxt,v,c,s] : child[curr])
	{
	if (nxt == pa) continue;
	root[nxt] = root[curr];
	add(root[nxt], root[nxt], v, c);
	add(root[nxt], root[nxt], s, INF);
	dfs(nxt, curr);
	}
	}

	inline int LCA(int x, int y)
	{
	if (deep[x] < deep[y]) swap(x, y);
	forv(i, T, 0) if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
	if (x == y) return x;
	forv(i, T, 0) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
	return fa[x][0];
	}

	inline void solve()
	{
	cin >> n;
	forn(i, 1, n-1)
	{
	int x, y, v, c, s;
	cin >> x >> y >> v >> c >> s;
	child[x].emplace_back(y, v, c, s);
	child[y].emplace_back(x, v, c, s);
	}
	dfs(1, 0);
	cin >> q;
	while (q--)
	{
	int u, v;
	ll sum;
	cin >> u >> v >> sum;
	const int lca = LCA(u, v);
	cout << query(root[u], root[v], root[lca], sum) << endl;
	}
	}

	signed int main()
	{
	// MyFile
	Spider
	//------------------------------------------------------
	// clock_t start = clock();
	int test = 1;
	// read(test);
	// cin >> test;
	forn(i, 1, test) solve();
	// while (cin >> n, n)solve();
	// while (cin >> test)solve();
	// clock_t end = clock();
	// cerr << "time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
	}

Athanasy

蓝桥杯第 3 场 算法季度赛第八题 升级电缆题解

题目链接：升级电缆

视频讲解链接：b站

公告

搜索

常用链接

合集

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

蓝桥杯第 3 场算法季度赛第八题升级电缆题解