ZR省选十连测

#1

A

考虑其等价于把$0$看作$<$,$1$看作$>$求满足条件的排列数量。

可以使用容斥加分治$FFT$解决其。

B

太难了，补不动。

C

考虑$g_{i,j},j\in [0,3]$ 为通过$i$往上延伸的$j$长度的链的子树内部权值。

这里只考虑$k=4$ 的情况。

思考我们需要记录前缀合并情况里$s_1>s_3$ 的个数，以及$s_2$ 的寄偶性。

如果随机序列$1,-1$ 其前缀和大概率不大于$\sqrt{n}$,我们随机打碎儿子，然后记录即可。

点击查看代码

#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
using namespace std;

typedef pair <int, int> pii;

const long long INF = 0x3f3f3f3f3f3f3f3f;

long long dp[200010][5];
vector <pii> G[200010];
int n, k;
long long f[2010][2];

void dfs(int x, int last) {
	int son = 0;
	for (auto it : G[x]) {
		int v = it.fi, w = it.se;
		if (v == last) continue;
		dfs(v, x), son++;
	}
	int S = min(2001, son << 1 | 1);
	for (int i = 0; i <= S; i++) {
		f[i][0] = f[i][1] = -INF;
	}
	random_shuffle(G[x].begin(), G[x].end());
	int be = S >> 1;
	f[be][0] = 0;
	for (auto it : G[x]) {
		int v = it.fi, w = it.se;
		if (v == last) continue;
		long long lst[2] = {-INF, -INF};
		for (int i = 0; i < S; i++) {
			long long cur[2] = {f[i][0], f[i][1]};
			for (int j = 0; j < 2; j++) {
				f[i][j] += max(dp[v][0], dp[v][k - 1] + w);
				f[i][j] = max(f[i][j], lst[j] + dp[v][0] + w);
				f[i][j] = max(f[i][j], f[i + 1][j] + dp[v][k - 2] + w);
				if (k == 4) f[i][j] = max(f[i][j], cur[j ^ 1] + dp[v][1] + w);
			}
			lst[0] = cur[0], lst[1] = cur[1];
		}
	}
	dp[x][0] = f[be][0];
	dp[x][1] = f[be + 1][0];
	dp[x][k - 1] = be ? f[be - 1][0] : -INF;
	if (k == 4) dp[x][2] = f[be][1];
}

int main() {
	srand((int)time(NULL));
	scanf("%d%d", &n, &k);
	for (int i = 1; i < n; i++) {
		int x, y, w; scanf("%d%d%d", &x, &y, &w);
		G[x].push_back(mp(y, w));
		G[y].push_back(mp(x, w));
	}
	dfs(1, 1);
	printf("%lld\n", dp[1][0]);
	return 0;
}

#4

A

一个诈骗题，考虑对每个点向外BFS寻找非平凡回路，只要$u\to v$时，$v$在之前遇到过，则该点的答案为$di{s}_v$。

点击查看代码

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
const int Maxn=5000;
const int Inf=0x3f3f3f3f;
int n;
std::vector<int> g[Maxn+5];
int dis[Maxn+5];
bool vis[Maxn+5];
int qu[Maxn+5],qu_f,qu_t;
int init_bfs(int S){
	memset(dis,0x3f,sizeof dis);
	memset(vis,0,sizeof vis);
	dis[S]=0,vis[S]=1;
	qu_f=1,qu_t=0;
	qu[++qu_t]=S;
	while(qu_f<=qu_t){
		int u=qu[qu_f++];
		for(int v:g[u]){
			if(!vis[v]){
				dis[v]=dis[u]+1;
				vis[v]=1;
				qu[++qu_t]=v;
			}
			else if(dis[u]<=dis[v]){
				return dis[u]+1;
			}
		}
	}
	return -1;
}
int main(){
	scanf("%d",&n);
	for(int i=2;i<=n;i++){
		static char s[Maxn+5];
		scanf("%s",s+1);
		int len=0;
		while(s[++len]!='\0');
		len--;
		for(int j=1;j<i;j++){
			if(s[j]=='1'){
				g[i].push_back(j),g[j].push_back(i);
			}
		}
	}
	for(int i=1;i<=n;i++){
		printf("%d\n",init_bfs(i));
	}
	return 0;
}

B

#5

A

写做$f_i=\sum (mex(j,i)\ast f_{j-1})$

考虑我们只要每次每次后缀加入一个数动态维护$mex$即可，考虑我们每次加入后缀时，直接查询在$mex=a_i$的$[l,r]$里查询前缀$mex$的位置，并直接更新其前缀为$mex<-mex+1$,考虑每次都把对应位置的$mex$变为大于其权值，一个数只会变一次，所以复杂度有所保证。

B

考虑有结论

结论一：当$a<b<c$，有$a\oplus c>=min(a\oplus b,b\oplus c)$，那么即最小值异或对只会出现在相邻的$i,j$

结论二：当$b>=a$,$a\oplus a>=b-a$,当有这两个结论时我们就可以做$sub1,sub2,sub3$

我们考虑当$w>min(a_i-a_j)$时，可以构造出答案为$min(a_i-a_j)$,那么我们只要每次都枚举小于$min(a_i-a_j)$的$x$，记录其答案即可。

考虑实际上加入一个数时其$mn$递减，那么只要枚举时对新加入的对统计即可，那么复杂度为$O(\sum \frac{2^V}{i})=O(V{2}^V)$

点击查看代码

//晦暗的宇宙，我们找不到光，看不见尽头，但我们永远都不会被黑色打倒。——Quinn葵因
#include<bits/stdc++.h>
#define ll long long
#define N 1000005

using std::set;

set<int>A;

int V,n;

#define inf (1ll << 21)

int mn = inf;

ll ans[inf];

int main(){
	scanf("%d%d",&V,&n);
	for(int i = 0;i < inf;++i)
	ans[i] = inf;
	for(int i = 1;i <= n;++i){
		int opt,x;
		scanf("%d%d",&opt,&x);
		if(opt == 1){
			A.insert(x);
			set<int>::iterator it = A.lower_bound(x);
			set<int>::iterator cur = it;
			if(it != A.begin()){
				-- it;
//				std::cout<<"("<<*it<<" "<<x<<")"<<"\n"; 
				mn = std::min(mn,x - *it);
				for(int i = 0;i <= mn;++i)
				ans[i] = std::min(ans[i],1ll * (i + *it) ^ (i + x)),ans[i] = (i == 0) ? ans[i] : std::min(ans[i - 1],ans[i]);
			}
			it = ++cur;
			if(it != A.end()){
				mn = std::min(mn,*it - x);
//				std::cout<<"("<<x<<" "<<*it<<")"<<"\n"; 				
				for(int i = 0;i <= mn;++i)
				ans[i] = std::min(ans[i],1ll * (i + *it) ^ (i + x)),ans[i] = (i == 0) ? ans[i] : std::min(ans[i - 1],ans[i]);				
			} 
//			std::cout<<mn<<"\n";
		}else{
			if(x > mn)
			std::cout<<mn<<"\n";
			else
			std::cout<<ans[x]<<"\n"; 
		}
	}
}

结论三：考虑到答案的最终贡献方式，一定是让所有相邻对的某一位的后$k$位归$0$,即可贡献维护的答案$x$不超过$Vn$个，考虑直接对这$Vn$个维护即可。

点击查看代码

ans[i] = std::min(ans[i],1ll * (i + *it) ^ (i + x)),ans[i] = (i == 0) ? ans[i] : std::min(ans[i - 1],ans[i]);
			}
			it = ++cur;
			if(it != A.end()){
				mn = std::min(mn,*it - x);
//				std::cout<<"("<<x<<" "<<*it<<")"<<"\n"; 				
				for(int i = 0;i <= mn;++i)
				ans[i] = std::min(ans[i],1ll * (i + *it) ^ (i + x)),ans[i] = (i == 0) ? ans[i] : std::min(ans[i - 1],ans[i]);				
			} 
//			std::cout<<mn<<"\n";
		}else{
			if(x > mn)
			std::cout<<mn<<"\n";
			else
			std::cout<<ans[x]<<"\n"; 

C

考虑每次维护中间块$[OL,OR]=k$这一块的最小生成树，然后左边的在中间$k$个点虚树上的边，后缀维护，还有右边整块的前缀。

然后考虑删除时直接暴力重构。

#6

给我心态打崩了。
坐牢，签到都没签上。

A

怎么开局一直想着枚举左端点。
考虑强制钦定最小值的位置，设$l_i$为左边比$h_i$的大的数，$r_i$为在右边比他大的数。
$x=l_i+r_i+1$
$i=l_i+1$
考虑其对于一个询问$k$的贡献实际上是
$min(i,x-i+1,k,x-k+1)$

考虑对于所有$k$都维护一个这样的贡献，那么其实际上可以通过拆成系数和常数分开维护。

(借一下rsx的代码)

#6 A

#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
using std::cin;
using std::cout;
template <typename T>
inline T min(const T &x, const T &y) {
	return x < y ? x : y;
}
template <typename T>
struct Fenwick_Tree {
	int limit;
	T t[MAXN];
	void add(int x, T y) {
		for (; x <= limit; x += x & -x) {
			t[x] += y;
		}
		return;
	}
	T sum(int x) {
		T ret = 0;
		for (; x; x -= x & -x) {
			ret += t[x];
		}
		return ret;
	}
	void build(int _N) {
		limit = _N;
	}
};
Fenwick_Tree <int> cyc;
int N, L, R, A[MAXN], Pos[MAXN];
long long K[MAXN], B[MAXN];
void add(long long *qjy, int l, int r, long long v) {
	qjy[l] += v;
	qjy[r + 1] -= v;
}
int main() {
	std::ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> N >> L >> R;
	for (int i = 1; i <= N; ++i) {
		cin >> A[i];
		Pos[A[i]] = i;
	}
	cyc.build(N);
	for (int i = 1; i <= N; ++i) {
		cyc.add(Pos[N - i + 1], 1);
		int Tk = cyc.sum(Pos[N - i + 1]);
		int Tmp = min(Tk, i - Tk + 1);
		add(K, 1, Tmp, 1);
		add(B, Tmp + 1, i - Tmp, Tmp);
		add(K, i - Tmp + 1, i, -1);
		add(B, i - Tmp + 1, i, i + 1);
	}
	for (int i = 1; i <= N; ++i) {
		K[i] += K[i - 1];
		B[i] += B[i - 1];
	}
	long long SUM = 0;
	for (int i = L; i <= R; ++i) {
		SUM ^= K[i] * i + B[i];
	}
	cout << SUM << '\n';
	return 0;
}

B

考虑对格子上的史莱姆进行$dp$,这样发现其可以发现史莱姆合并的操作不影响答案。

则有$X_{i,j}=\frac{1}{4}\ast (\sum _{(x,y)isnextto(i,j)X_{x,y}})+T_{x,y}$

于是可以直接高斯消元得到$40$分。

#6 B 40分

#include<bits/stdc++.h>
#define ll long long 
#define N 105
#define mod 998244353
#define I4 748683265
#define pii std::pair<int,int>
#define mp std::make_pair


int dx[] = {-1,0,1,-0};
int dy[] = {0,-1,0,1};

int n,X[N],Y[N],a[N][N],T[N],ans;

#define mpi std::map<pii,int>

mpi P,C;

inline ll qpow(ll a,ll b){
	ll res = 1;
	while(b){
		if(b & 1)res = res * a % mod;
		a = a * a % mod;
		b >>= 1; 
	}
	return res;
}

inline void guass(int n){	
	for(int i = 1;i <= n;++i){
		int pos = i;
		for(int j = i;j <= n;++j)
		if(a[j][i]){
			pos = j;
			break;
		}
		if(pos ^ i)std::swap(a[i],a[pos]);
		int w = qpow(a[i][i],mod - 2);
		for(int j = 1;j <= n;++j){
			if(j == i)continue;
			int t = 1ll * a[j][i] * w % mod;
			for(int k = i;k <= n + 1;++k)
			a[j][k] = ((a[j][k] - 1ll * t * a[i][k] % mod) % mod + mod) % mod;
		}		
	}	
	for(int i = 1;i <= n;++i)
	a[i][n + 1] = 1ll * (1ll * a[i][n + 1] * (mod - 1) % mod * qpow(a[i][i],mod - 2)) % mod;
}

inline void solve(){
	for(int i = 1;i <= n;++i){
//		std::cout<<"DEL "<<i<<std::endl;
		for(int j = 0;j < 4;++j){
			int x = X[i] + dx[j],y = Y[i] + dy[j];
//			std::cout<<x<<" "<<y<<"\n";
			if(P.find(mp(x,y)) == P.end())continue;
			a[i][P[mp(x,y)]] = (I4) % mod; 
		}
		a[i][i] = mod - 1;
		a[i][n + 1] = T[i];
	}
	guass(n);
	for(auto i : C){
		int sx = i.first.first,sy = i.first.second,res = 0;
//		std::cout<<sx<<" "<<sy<<std::endl; 
		for(int j = 0;j < 4;++j){
			int nx = sx + dx[j];
			int ny = sy + dy[j];
			if(P.find(mp(nx,ny)) == P.end())continue;
			res = (res + a[P[mp(nx,ny)]][n + 1]) % mod;
		}
	ans = ans ^ (1ll * I4 * res % mod);
	}
	std::cout<<ans<<"\n";
}

int main(){
	scanf("%d",&n);
	for(int i = 1;i <= n;++i){
		scanf("%d%d%d",&X[i],&Y[i],&T[i]);
		P[mp(X[i],Y[i])] = i;
	}
	for(int i = 1;i <= n;++i)
	for(int j = 0;j < 4;++j){
		int x = X[i] + dx[j],y = Y[i] + dy[j];
		if(P.find(mp(x,y)) == P.end())C[mp(x,y)] = 1;
	}
	solve();
}

当$n\le 2000$时，考虑当我们每一列的元素只在$[i-m,i+m]$中有值可以稀疏矩阵消元。

但是我发现有份代码直接对矩阵随机打乱然后记录有元素的值，跑的也很快。

#6 B 60分

inline void guass(int n){
	std::random_shuffle(a+1,a+n+1);
	for(R int i=1;i<=n;++i)
		for(R int j=1;j<=n+1;++j) if(a[i][j]) mw[i].insert(j);
	for(R int i=1;i<=n;++i){
		R int j=i;
		for(;j<=n;++j) if(a[j][i]) break;
		if(j^i) std::swap(a[i],a[j]),std::swap(mw[i],mw[j]);
		R int ha=qpow(a[i][i],P-2);
		for(j=1;j<=n;++j){
			if(j==i) continue;
			if(mw[j].find(i)==mw[j].end())continue;
			R int qc=1LL*(P-a[j][i])*ha%P;
			for(auto k:mw[i]){
				if(!a[j][k]) mw[j].insert(k);
				a[j][k]=(a[j][k]+1LL*qc*a[i][k])%P;
				if(!a[j][k]) mw[j].erase(k);
			}
		}
	}
	for(R int i=1;i<=n;++i){
		a[i][n+1]=(a[i][n+1]*(P-1LL)%P*qpow(a[i][i],P-2))%P;
	}
}

考虑矩阵情况，可以直接手动消元把除第一列的元素都用第一列表示，最后使用最后一列的关系对其消元，这样只有$O(\sqrt{n})$个元，其复杂度为$O(n^{\frac{3}{2}})$

#7

A

考虑一次操作二会改变奇偶性。
一定是先操作二一次，然后再检查子区间是否有全偶区间即可。
当带0时，其把序列划分位若干子区间。
考虑扫描线即可。
找到前面第一个不是偶数的子区间即可。

B

$xpp$原本想考的是随机下最大上升子序列只有根号。

但是随机太好了。

被某些根号算法草爆了。

这里提供一个线段树覆盖代替原本的暴力并查集的做法。

点击查看代码

#include<bits/stdc++.h>
#define ll long long 
#define N 15005

int n,m,q,mx,a[N];

int sum[35000];

#define mid ((l + r) >> 1)
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)

using std::bitset;
using std::array;
using std::vector;

bitset<35000>tag;

vector<array<int,4>>M;

inline void cov(int u,int l,int r,int tl,int tr){
	if(tag[u])return ;
	if(tl <= l && r <= tr){tag[u] = 1,sum[u] = r - l + 1;return ;}
	if(tl <= mid)
	cov(ls(u),l,mid,tl,tr);
	if(tr > mid)
	cov(rs(u),mid + 1,r,tl,tr);
	tag[u] = tag[ls(u)] & tag[rs(u)],sum[u] = sum[ls(u)] + sum[rs(u)];
}

int main(){
	scanf("%d%d%d",&n,&m,&q);
	for(int i = 1;i <= n;++i){
		scanf("%d",&a[i]);
		M.push_back({i,i,a[i],0}); 
	}
	for(int i = 1;i <= m;++i){
		int l,r,x;
		scanf("%d%d%d",&l,&r,&x);
		M.push_back({l,r,x,i});
	}
	std::sort(M.begin(), M.end(), [&](array<int, 4> x, array<int, 4> y) { return x[2] < y[2]; });
	while(q -- ){
		int l1,r1,l2,r2;
		scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
		memset(sum,0,sizeof(sum)),tag.reset();
		ll ans = 0;
		int lst = 0;
		for (auto &p : M) if (!p[3] || p[3] >= l1 && p[3] <= r1) {
			int l = std::max(l2, p[0]), r = std::min(r2, p[1]);
			if (l <= r) cov(1, 1, n, l, r);
			ans += 1ll * p[2] * (sum[1] - lst);
			if ((lst = sum[1]) == r2 - l2 + 1) break;
		}
		printf("%lld\n", ans);		
	}	
}

#8

A

考虑 $(s_i,s_{i+1},t_i,t_{i+1})$ 一定有两个相同，所以最长公共子序列长度至少为 $n$.

考虑限制很紧，一不小心就会大于 $n$ 。

考虑只有两种情况:

$ABABABABC\ast C\ast C\ast C$

$ACACBCBCBCBCACAC$

对着检查即可。

点击查看代码

//晦暗的宇宙，我们找不到光，看不见尽头，但我们永远都不会被黑色打倒。——Quinn葵因
#include<bits/stdc++.h>
#define ll long long
#define N 2000005
#define mod 998244353

char s[N],t[N];

int n;

int T;

bool pre[N],suf[N];

bool check(char a,char b){
	return a == '?' || a == b;
}

ll ans = 0;

inline void calc(char a,char b,char c){
	int now = 1;
	for(int i = 1;i <= (n << 1) + 1;++i)
	if(i & 1)
	now = now * check(s[i],a) * check(t[i],c) % mod;
	else
	now = now * check(s[i],b) * (check(t[i],a) + check(t[i],b)) % mod;
	ans = (ans + now) % mod;
	now = 1;
	for(int i = 1;i <= (n << 1) + 1;++i)
	if(i & 1)
	now = now * check(t[i],a) * check(s[i],c) % mod;
	else
	now = now * check(t[i],b) * (check(s[i],a) + check(s[i],b)) % mod;
	ans = (ans + now) % mod;
	pre[0] = suf[2 * n + 2] = 1;
	for(int i = 1;i <= (n << 1) + 1;++i){
		if(i & 1)
		pre[i] = pre[i - 1] & check(s[i],a) & check(t[i],b);
		else
		pre[i] = pre[i - 1] & check(s[i],c) & check(t[i],c);
	}	
	for(int i =(n << 1) + 1;i >= 1;--i){
		if(i & 1)
		suf[i] = suf[i + 1] & check(s[i],b) & check(t[i],a);
		else
		suf[i] = suf[i + 1] & check(s[i],c) & check(t[i],c);
	}		
	for(int i = 1;i <= (n << 1) + 1;i += 2)
	ans += (i == ((n << 1) + 1)) ? - (pre[i] & suf[i + 1]) : pre[i] & suf[i + 1] ;
} 

int main(){
	scanf("%d",&T);
	while(T -- ){
		ans = 0; 
		scanf("%d%s%s",&n,s + 1,t + 1);
      	calc('A','B','C');
        calc('A','C','B');
        calc('B','A','C');
        calc('B','C','A');
        calc('C','A','B');
        calc('C','B','A');	
		std::cout<<ans<<"\n";
	}
}
/*
2
?????
?????
*/ 

B

考虑树上枚举 $(x,y),LCAz$。

考虑当$z<x<y$或者 $x<y<z$ 相当于给定了一个矩形，其矩形内的点均无效。

那么直接对询问扫描线即可。

考虑只要枚举相邻的$x,y$,那么直接树上启发式合并即可。

#10

C

先考虑菊花的做法，发现其等价于给定点权，一条边的代价为 $abs(a_x+a_y)$。

其可以使用 $Brovka$ 解决。

考虑改为任意树，可以使用点/边分治，将路径改为上述形式解决。

每一轮，每点均找到异子树内的最小权边，共有 $nlog$ 条边。

使用边分治更好处理。

点击查看代码

//晦暗的宇宙，我们找不到光，看不见尽头，但我们永远都不会被黑色打倒。——Quinn葵因
#include<bits/stdc++.h>
#define ll long long
#define N (int)2e6

using std::vector;
using std::pair;

#define pii pair<int,int>
#define mp std::make_pair

int head[N];

struct P{
	int to,next,w;
}E[N * 20];

int cnt = 1;

inline void add(int u,int v,int w){
	E[++cnt].to = v;
	E[cnt].next = head[u];
	E[cnt].w = w;
	head[u] = cnt;
}

inline void adde(int u,int v,int w){
	add(u,v,w);
	add(v,u,w);
}

vector<pii>G[N];

int m;

inline void reb(int u,int fa){
	int lst = 0;
	for(auto vi : G[u]){
		int v = vi.first;
		int w = vi.second;
		if(v == fa)continue;
		if(!lst){
			adde(u,v,w);
			lst = u;
		}else{
			adde(lst,++m,0);
			adde(m,v,w);
			lst = m;
		}
		reb(v,u);
	}
}

int siz[N],re,minn,sum;

int vis[N];

inline void getroot(int u,int fa){
	siz[u] = 1;
	for(int i = head[u];i;i = E[i].next){
		int v = E[i].to;
		if(v == fa || vis[i])continue;
		getroot(v,u);
		siz[u] += siz[v];
		if(std::max(siz[v],sum - siz[v]) < minn)
		minn = std::max(siz[v],sum - siz[v]),re = i;
	}
}

ll dis[N];

int ent;

struct nod {
	int u,v;
	ll w;
	nod(){}
	nod(int _u,int _v,ll _w){u = _u,v = _v,w = _w;}
}e[N * 40];

bool operator < (nod A,nod B){
	return A.w < B.w;
}

int fa[N];

inline int find(int x){return (x == fa[x]) ? x : fa[x] = find(fa[x]);}

pair<ll,int>Vec[3][N];

int sig[3];

inline void calc(int u,int tag,int fa){
	Vec[tag][++sig[tag]] = mp(dis[u],u);
	for(int i = head[u];i;i = E[i].next){
		int v = E[i].to;
		int w = E[i].w;
		if(v == fa || vis[i])continue;
		dis[v] = dis[u] + w;
		calc(v,tag,u);
	}
}

inline ll llabs(ll x){return x > 0 ? x : -x;}

inline void solve(int u){
	if(sum == 1)return;
	minn = 1e9;getroot(u,0);
	vis[re] = vis[re ^ 1] = 1;
//	std::cout<<u<<" "<<sum<<" "<<re<<"\n";
	int x = E[re].to,y = E[re ^ 1].to;
	sig[1] = sig[2] = 0;
	dis[x] = E[re].w;calc(x,1,0);
	dis[y] = 0;calc(y,2,0);
	std::sort(Vec[1] + 1,Vec[1] + sig[1] + 1);
	std::sort(Vec[2] + 1,Vec[2] + sig[2] + 1);
	for(int i=1,j=sig[2];i<=sig[1];i++) {
		while(j&&Vec[2][j].first>-Vec[1][i].first) j--;
		if(j+1<=sig[2]) e[++ent]=nod(Vec[1][i].second,Vec[2][j+1].second,llabs(Vec[1][i].first+Vec[2][j+1].first));
		if(j) e[++ent]=nod(Vec[1][i].second,Vec[2][j].second,llabs(Vec[1][i].first+Vec[2][j].first));
	}
	std::swap(sig[1],sig[2]);
	for(int i=1;i<=std::max(sig[1],sig[2]);i++) swap(Vec[1][i],Vec[2][i]);
	for(int i=1,j=sig[2];i<=sig[1];i++) {
		while(j&&Vec[2][j].first>-Vec[1][i].first) j--;
		if(j+1<=sig[2]) e[++ent]=nod(Vec[1][i].second,Vec[2][j+1].second,llabs(Vec[1][i].first+Vec[2][j+1].first));
		if(j) e[++ent]=nod(Vec[1][i].second,Vec[2][j].second,llabs(Vec[1][i].first+Vec[2][j].first));
	}
	int now = sum - siz[x];
	sum = siz[x];
	solve(x);
	sum = now;
	solve(y);
}

int n;

int main(){
//	freopen("q.in","r",stdin);
//	freopen("q.ans","w",stdout);
	scanf("%d",&n);
	m = n;
	for(int i = 1;i < n;++i){
		int x,y,w;
		scanf("%d%d%d",&x,&y,&w);
		G[x].emplace_back(y,w);
		G[y].emplace_back(x,w);
	}
	reb(1,0);
	sum = m;
	solve(1);
	std::sort(e + 1,e + ent + 1);
	ll ans = 0;
	for(int i = 1;i <= m;++i)fa[i] = i;
	for(int i = 1;i <= ent;++i){
//		std::cout<<e[i].u<<" "<<e[i].v<<" "<<e[i].w<<"\n";
		if(find(e[i].u) ^ find(e[i].v)){
			fa[fa[e[i].u]] = fa[e[i].v];
			ans += e[i].w;
		}
	}
	std::cout<<ans<<"\n";
}