[BZOJ 5216] [Lydsy2017省队十连测]公路建设

BZOJ传送门

题目描述

在Byteland一共有$n$个城市，编号依次为$1$到$n$，它们之间计划修建$m$条双向道路，其中修建第$i$条道路的费用为$c_i$。Byteasar作为Byteland公路建设项目的总工程师，他决定选定一个区间$[l,r]$，仅使用编号在该区间内的道路。他希望选择一些道路去修建，使得连通块的个数尽量少，同时，他不喜欢修建多余的道路，因此每个连通块都可以看成一棵树的结构。为了选出最佳的区间， Byteasar会不断选择 $q$ 个区间，请写一个程序，帮助 Byteasar计算每个区间内修建公路的最小总费用。

输入输出格式

输入格式：

第一行包含三个正整数$n,m,q$，表示城市数、道路数和询问数。

接下来 $m$ 行，每行三个正整数$u_i,v_I,c_i$，表示一条连接城市$u_i$ 和$v_i$ 的双向道路，费用为$c_i$。

接下来$q$ 行，每行两个正整数$l_i,r_i$，表示一个询问。

输出格式：

输出$q$ 行，每行一个整数，即最小总费用。

输入输出样例

输入样例#1：

3 5 2
1 3 2
2 3 1
2 1 6
3 1 7
2 3 7
2 5
3 4

输出样例#1：

7
13

说明

$1\le u_i,v_i\le n,u_i̸=v_i,1\le l_i\le r_i\le m,1\le c_i\le 10^6$

$N\le 100,M\le 100000,Q\le 15000$

解题分析

一开始想的是$LCT$+莫队， 然而发现似乎区间可以取到很大， 时间戳不好维护， GG。

然而想多了… 点数这么少， 直接线段树暴力维护区间内取的边集和答案。 合并区间的时候用归并的方法使边的顺序按边权从小到大排列。 总复杂度$O(nqlogm)$，常数巨大。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <vector>
#include <algorithm>
#include <cmath>
#define R register
#define IN inline
#define W while
#define gc getchar()
#define ll long long
#define MX 100050
template <class T>
IN void in(T &x)
{
	x = 0; R char c = gc;
	for (; !isdigit(c); c = gc);
	for (;  isdigit(c); c = gc)
	x = (x << 1) + (x << 3) + c - 48;
}
int dot, line, q;
int bel[MX];
struct Edge {int from, to, val;} edge[MX];
struct Node
{
	std::vector <int> dat;
	ll ans;
	IN void clear()
	{
		std::vector <int> ().swap(dat);
		ans = 0;
	}
} tree[MX << 2];
int find(R int now) {return bel[now] == now ? now : bel[now] = find(bel[now]);}
namespace SGT
{
	#define ls (now << 1)
	#define rs (now << 1 | 1)
	IN Node merge(const Node &x, const Node &y)
	{
		Node ret; ret.clear();
		R int lsiz = x.dat.size(), rsiz = y.dat.size();
		for (R int i = 1; i <= dot; ++i) bel[i] = i;
		R int l = 0, r = 0, bela, belb;
		W (l < lsiz && r < rsiz)
		{
			if(edge[x.dat[l]].val < edge[y.dat[r]].val)
			{
				bela = find(edge[x.dat[l]].from), belb = find(edge[x.dat[l]].to);
				if(bela == belb) {++l; continue;}
				bel[bela] = belb; ret.dat.push_back(x.dat[l]); ret.ans += edge[x.dat[l]].val; ++l;
			}
			else
			{
				bela = find(edge[y.dat[r]].from), belb = find(edge[y.dat[r]].to);
				if(bela == belb) {++r; continue;}
				bel[bela] = belb; ret.dat.push_back(y.dat[r]); ret.ans += edge[y.dat[r]].val; ++r;
			}
		}
		W (l < lsiz)
		{
			bela = find(edge[x.dat[l]].from), belb = find(edge[x.dat[l]].to);
			if(bela == belb) {++l; continue;}
			bel[bela] = belb; ret.dat.push_back(x.dat[l]); ret.ans += edge[x.dat[l]].val; ++l;
		}
		W (r < rsiz)
		{
			bela = find(edge[y.dat[r]].from), belb = find(edge[y.dat[r]].to);
			if(bela == belb) {++r; continue;}
			bel[bela] = belb; ret.dat.push_back(y.dat[r]); ret.ans += edge[y.dat[r]].val; ++r;
		}
		return ret;
	}
	void build(R int now, R int lef, R int rig)
	{
		if(lef == rig) return tree[now].ans = edge[lef].val, tree[now].dat.push_back(lef), void();
		int mid = lef + rig >> 1;
		build(ls, lef, mid), build(rs, mid + 1, rig);
		tree[now] = merge(tree[ls], tree[rs]);
	}
	IN Node query(R int now, R int lef, R int rig, R int lb, R int rb)
	{
		if(lb <= lef && rb >= rig) return tree[now];
		int mid = lef + rig >> 1;
		if (rb <= mid) return query(ls, lef, mid, lb, rb);
		if(lb > mid) return query(rs, mid + 1, rig, lb, rb);
		else return merge(query(ls, lef, mid, lb, rb), query(rs, mid + 1, rig, lb, rb));
	}
	#undef ls
	#undef rs
}
int main(void)
{
	int lef, rig;
	in(dot), in(line), in(q);
	for (R int i = 1; i <= line; ++i) in(edge[i].from), in(edge[i].to), in(edge[i].val);
	SGT::build(1, 1, line);
	W (q--)
	{
		in(lef), in(rig);
		printf("%lld\n", SGT::query(1, 1, line, lef, rig).ans);
	}
}