題目描述

在Byteland一共有$n$個城市，編號依次為$1$到$n$，它們之間計劃修建$m$條雙向道路，其中修建第$i$條道路的費用為$c_i$。Byteasar作為Byteland公路建設專案的總工程師，他決定選定一個區間$[l,r]$，僅使用編號在該區間內的道路。他希望選擇一些道路去修建，使得連通塊的個數儘量少，同時，他不喜歡修建多餘的道路，因此每個連通塊都可以看成一棵樹的結構。為了選出最佳的區間， Byteasar會不斷選擇 $q$ 個區間，請寫一個程式，幫助 Byteasar計算每個區間內修建公路的最小總費用。

輸入輸出格式

輸入格式：

第一行包含三個正整數$n$

接下來 $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\mathrm{\ne }{v}_i,1\le l_i\le$

$N\leq 100,M\leq 100000,Q\leq 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);
	}
}