Problem:
Score : 500 points

Problem Statement

We have N camels numbered 1,2,\ldots,N.
Snuke has decided to make them line up in a row.

The happiness of Camel i will be L_i if it is among the K_i frontmost camels, and R_i otherwise.

Snuke wants to maximize the total happiness of the camels. Find the maximum possible total happiness of the camel.

Solve this problem for each of the T test cases given.

Constraints

All values in input are integers.

1 \leq T \leq 10^5

1 \leq N \leq 2 \times 10^{5}

1 \leq K_i \leq N

1 \leq L_i, R_i \leq 10^9

The sum of values of N in each input file is at most 2 \times 10^5.

Input

Input is given from Standard Input in the following format:

T
\mathrm{case}_1
\vdots
\mathrm{case}_T

Each case is given in the following format:

N
K_1 L_1 R_1
\vdots
K_N L_N R_N

Output

Print T lines. The i-th line should contain the answer to the i-th test case.

Sample Input 1

3
2
1 5 10
2 15 5
3
2 93 78
1 71 59
3 57 96
19
19 23 16
5 90 13
12 85 70
19 67 78
12 16 60
18 48 28
5 4 24
12 97 97
4 57 87
19 91 74
18 100 76
7 86 46
9 100 57
3 76 73
6 84 93
1 6 84
11 75 94
19 15 3
12 11 34

Sample Output 1

25
221
1354

In the first test case, it is optimal to line up the camels in the order 2, 1.

Camel 1 is not the frontmost camel, so its happiness will be 10.

Camel 2 is among the two frontmost camels, so its happiness will be 15.

In the second test case, it is optimal to line up the camels in the order 2, 1, 3.

Camel 1 is among the two frontmost camels, so its happiness will be 93.

Camel 2 is the frontmost camel, so its happiness will be 71.

Camel 3 is among the three frontmost camels, so its happiness will be 57.

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include<iostream>
#include<iomanip>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<algorithm>
#include<cmath>
#include<string>
#include<queue>
#include<stack>
#include<functional>
#include<tuple>
#include<cctype>
#include<stdint.h>
#include<random>
#include <bits/stdc++.h>

using namespace std;

typedef long double ld;
typedef int_fast64_t ll;
typedef pair<ll, ll> pii;
typedef pair<ll, pii> piii;
typedef pair<pii, pii> piiii;
typedef pair<ll, bool> pib;

typedef vector<bool> vb;

typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;

typedef vector<double> vf;

typedef queue<ll> qi;

typedef long double ld;

#define mp make_pair
#define mt make_tuple
#define pb push_back

#define rep(i, N) for(ll i = 0; i < N; i++)
#define repa(i, a, N) for(ll i = a; i < N; i++)
#define repr(i, N) for(ll i = N-1; i >= 0; i--)

#define drep(i, N, j, M) rep(i, N) rep(j, M)
#define trep(i, N, j, M, k, L) rep(i, N) rep(j, M) rep(k, L)

#define all(A) A.begin(), A.end()
#define uni(A) A.erase(unique(all(A)), A.end())

const ll LLMAX = numeric_limits<ll>::max() / 3;
const ld LDMAX = numeric_limits<ld>::max() / 3;
const ld PI = 3.141592653589793;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;

template <ll Modulus>
class modint {
public:
	ll a;
	constexpr modint(const ll x = 0) noexcept : a(x % Modulus) {}
	constexpr ll &value() noexcept { return a; }
	constexpr const ll &value() const noexcept { return a; }
	constexpr modint operator+() const noexcept { return *this; }
	constexpr modint operator-() const noexcept { return modint(0LL) -= modint(*this); }
	constexpr modint operator+(const modint rhs) const noexcept { return modint(*this) += rhs; }
	constexpr modint operator-(const modint rhs) const noexcept { return modint(*this) -= rhs; }
	constexpr modint operator*(const modint rhs) const noexcept { return modint(*this) *= rhs; }
	constexpr modint operator/(const modint rhs) const noexcept { return modint(*this) /= rhs; }
	constexpr modint &operator+=(const modint rhs) noexcept { a += rhs.a; if (a >= Modulus) { a -= Modulus; }return *this; }
	constexpr modint &operator-=(const modint rhs) noexcept { if (a < rhs.a) { a += Modulus; }a -= rhs.a; return *this; }
	constexpr modint &operator*=(const modint rhs) noexcept { a = a * rhs.a % Modulus; return *this; }
	constexpr modint &operator/=(modint rhs) noexcept { ll exp = Modulus - 2; while (exp) { if (exp % 2) { *this *= rhs; }rhs *= rhs; exp /= 2; }return *this; }
};
typedef modint<MOD> mod;

constexpr const mod operator+(const ll a, const mod b) noexcept{ return mod(a) += b; }
constexpr const mod operator-(const ll a, const mod b) noexcept{ return mod(a) -= b; }
constexpr const mod operator*(const ll a, const mod b) noexcept{ return mod(a) *= b; }
constexpr const mod operator/(const ll a, const mod b) noexcept{ return mod(a) /= b; }

template <class T> class SegTree {
	ll n;vector<T> data;T def;function<T(T, T)> operation;function<T(T, T)> update;T _query(ll a, ll b, ll k, ll l, ll r) {if (r <= a || b <= l) return def;if (a <= l && r <= b)return data[k];else {T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);return operation(c1, c2);}}
public:
	// _n: サイズ, _def: 初期値・単位元, _operation: クエリ, _update: 更新
	SegTree(ll _n, T _def, function<T(T, T)> _operation,function<T(T, T)> _update): def(_def), operation(_operation), update(_update) {n = 1;while (n < _n) {n *= 2;}data = vector<T>(2 * n - 1, def);}
	// iの値をxに変更
	void change(ll i, T x) {i += n - 1;data[i] = update(data[i], x);while (i > 0) {i = (i - 1) / 2;data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);}}
	// [a, b)の区間クエリ実行
	T query(ll a, ll b) {return _query(a, b, 0, 0, n);}
	// 添え字アクセス
	constexpr const T operator[](ll i) const noexcept {return data[i + n - 1];}
	constexpr const ll size() const noexcept { return n; }
	constexpr const T unit() const noexcept { return def; }
};

/*
SegTree<ll> st(N, LLMAX,
	// a: left child, b: right child
	[](ll a, ll b) {return min(a, b); },
	// d: old, x: query
	[](ll d, ll x) {return x; });
// */


template<class t, class u>ostream& operator<<(ostream& os, const pair<t, u>& p) { return os << "{" << p.first << "," << p.second << "}"; }
template<class t>ostream& operator<<(ostream& os, const vector<t>& v) { os << "{";	for (auto e : v)os << e << ",";	return os << "}" << endl; }
template<class t, class u>ostream& operator<<(ostream& os, const unordered_map<t, u>& m) { os << "{"; for (auto itr = m.begin(); itr != m.end(); ++itr) { os << "(" << itr->first << ", " << itr->second << "), "; }	return os << "}"; }
template<class t>ostream& operator<<(ostream& os, const set<t>& m) { os << "{";	for (auto itr = m.begin(); itr != m.end(); ++itr) { os << *itr << ", "; }return os << "}"; }
template<class t>ostream& operator<<(ostream& os, const multiset<t>& m) { os << "{"; for (auto itr = m.begin(); itr != m.end(); ++itr) { os << *itr << ", "; }return os << "}"; }
template<ll Modulus>ostream& operator<<(ostream& os, const modint<Modulus>& m) { return os << (m.a + Modulus) % Modulus; }

template<class t>ostream& operator<<(ostream& os, const SegTree<t>& st) {
	os << "{";
	ll s = st.size();
	rep(i, s){
		t v = st[i];
		if (v == st.unit()) {
			os << "-, ";
		}
		else {
			os << v << ", ";
		}
	}
	return os << "}\n";
}

typedef vector<mod> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;


template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

void No() { cout << "No" << endl; }
void Yes() { cout << "Yes" << endl; }
void NO() { cout << "NO" << endl; }
void YES() { cout << "YES" << endl; }

//x^n(mod M) ←普通にpow(x,n)では溢れてしまうため，随時mod計算
ll mpow(ll x, ll n) { 
	ll ans = 1;
	while (n != 0) {
		if (n & 1) ans = ans * x % MOD;
		x = x * x % MOD;
		n = n >> 1;
	}
	return ans;
}


ll fac_size = 1e6;
vm fac(fac_size + 1); //n! (mod MOD)
vm ifac(fac_size + 1); //k!^{M-2} (mod MOD)
bool fac_calculated = false;

void pre_calc_comb() {
	fac[0] = 1;
	ifac[0] = 1;
	for (ll i = 0; i < fac_size; i++) {
		fac[i + 1] = fac[i] * (i + 1); // n!(mod M)
		ifac[i + 1] = ifac[i] * mpow(i + 1, MOD - 2); // k!^{M-2} (mod M) ←累乗にmpowを採用
	}
	fac_calculated = true;
}

mod comb(ll a, ll b) { //aCbをmod計算
	if (!fac_calculated)
		pre_calc_comb();

	if (a == 0 && b == 0)return 1;
	if (a < b || a < 0)return 0;
	mod tmp = ifac[a - b] * ifac[b];
	return tmp * fac[a];
}

ll gcd(ll a, ll b)
{
	if (a == 0)
		return b;
	if (b == 0)
		return a;

	if (a%b == 0)
	{
		return(b);
	}
	else
	{
		return(gcd(b, a%b));
	}
}

ll N, M, K, Q;
ll ans = 0;
ll H, W;
string S;

void solveD() {
	cin >> N;

	vi X(N, 0);
	rep(i, N) {
		char x;
		cin >> x;
		X[i] = x - '0';
	}

	rep(i, N) {
		cout << X[i] << endl;
	}
}

ll solveT() {
	cin >> N;
	vector<piii> KLR(N);
	rep(i, N) {
		ll k, l, r;
		cin >> k >> l >> r;

		KLR[i] = mp(k, mp(l, r));
	}
	sort(all(KLR));

	set<pii> left;
	set<pii> right;
	left.insert(mp(LLMAX, -1));
	right.insert(mp(LLMAX, -1));
	ll nl = 0, nr = 0;
	ll ans = 0;
	rep(i, N) {
		ll k = KLR[i].first;
		ll l = KLR[i].second.first;
		ll r = KLR[i].second.second;

		if (l > r) {
			ll diff = l - r;
			if (nl < k) {
				left.insert(mp(diff, i));
				nl++;
				ans += l;
			}
			else {
				auto itr = left.begin();
				pii lmax = *itr;

				if (lmax.first < diff) {
					left.erase(itr);
					right.insert(mp(LLMAX, lmax.second));
					left.insert(mp(diff, i));
					nr++;

					ans += l - diff;
				}
				else {
					right.insert(mp(LLMAX, i));
					ans += r;
				}
			}
		}
		else {
			ll diff = r - l;
			if (nr < N - k) {
				right.insert(mp(diff, i));
				nr++;
				ans += r;
			}
			else {
				auto itr = right.begin();
				pii rmax = *itr;
				if (rmax.first < diff) {
					right.erase(itr);
					left.insert(mp(LLMAX, rmax.second));
					right.insert(mp(diff, i));
					nl++;
					ans += r - diff;
				}
				else {
					left.insert(mp(LLMAX, i));
					ans += l;
				}
			}
		}
	}
	return ans;
}

void solve() {
	ll T;
	cin >> T;

	vi A(T);
	rep(i, T) {
		A[i] = solveT();

	}
	rep(i, T) {
		cout << A[i] << endl;
	}
}

	/*
	vvi dp(N+1, vi(N+2, 0));
	// [1]人までを考えて
	// [2]人が左に入っているとしたときの最大値

	rep(i, N) {
		ll k = KLR[i].first;
		ll l = KLR[i].second.first;
		ll r = KLR[i].second.second;
		rep(n, i+1) {
			if (n < k)
				chmax(dp[i + 1][n + 1], dp[i][n] + l);
			if( i - n < N - k)
				chmax(dp[i + 1][n], dp[i][n] + r);
		}
	}

	ll ans = 0;
	rep(i, N+1) {
		chmax(ans, dp[N][i]);
	}
	return ans;
	*/

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	solve();
	return 0;
}