Codeforces Round #728 (Div. 2)

A. Pretty Permutations

There are $n$ cats in a line, labeled from $1$ to $n$, with the $i$-th cat at position $i$. They are bored of gyrating in the same spot all day, so they want to reorder themselves such that no cat is in the same place as before. They are also lazy, so they want to minimize the total distance they move. Help them decide what cat should be at each location after the reordering.

For example, if there are $3$ cats, this is a valid reordering: $[3,1,2]$. No cat is in its original position. The total distance the cats move is $1+1+2=4$ as cat $1$ moves one place to the right, cat $2$ moves one place to the right, and cat $3$ moves two places to the left.

Input

The first line contains a single integer $t$ ($1\le t\le 100$) — the number of test cases. Then $t$ test cases follow.

The first and only line of each test case contains one integer $n$ ($2\le n\le 100$) — the number of cats.

It can be proven that under the constraints of the problem, an answer always exist.

Output

Output $t$ answers, one for each test case. Each answer consists of $n$ integers — a permutation with the minimum total distance. If there are multiple answers, print any.

Example

input

2
2
3

output

2 1 
3 1 2 

Note

For the first test case, there is only one possible permutation that satisfies the conditions: $[2,1]$.

The second test case was described in the statement. Another possible answer is $[2,3,1]$.

#include <iostream>
#include <algorithm>
using namespace std;

int main(){
	int t;
	cin >> t;
	while(t--){
		int n;
		cin >> n;
		if(n%2==0){
			for(int i=1; i<n; ){
				cout << i+1 <<" " << i <<" ";
				i += 2;
			}
			cout << endl;
		}
		else{
			for(int i=1; i<=n-3; ){
				cout << i+1 <<" " << i <<" ";
				i += 2;
			}
			cout << n << " " << n-2 << " " << n-1 << " " ;
			cout << endl;
		}
	}
	return 0;
}

B. Pleasant Pairs

You are given an array $a_1,a_2,\dots ,a_n$ consisting of $n$ distinct integers. Count the number of pairs of indices $(i,j)$ such that $i<j$ and $a_i\cdot a_j=i+j$.

Input

The first line contains one integer $t$ ($1\le t\le 10^4$) — the number of test cases. Then $t$ cases follow.

The first line of each test case contains one integer $n$ ($2\le n\le 10^5$) — the length of array $a$.

The second line of each test case contains $n$ space separated integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le 2\cdot n$) — the array $a$. It is guaranteed that all elements are distinct.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$.

Output

For each test case, output the number of pairs of indices $(i,j)$ such that $i<j$ and $a_i\cdot a_j=i+j$.

Example

input

3
2
3 1
3
6 1 5
5
3 1 5 9 2

output

1
1
3

Note

For the first test case, the only pair that satisfies the constraints is $(1,2)$, as $a_1\cdot a_2=1+2=3$

For the second test case, the only pair that satisfies the constraints is $(2,3)$.

For the third test case, the pairs that satisfy the constraints are $(1,2)$, $(1,5)$, and $(2,3)$.

分析

a[i] * a[j] ，根据 a[i] 来找 a[j] ， i + j 一定是 a[i] 的倍数，i 是不变的，所以 j 的增加量一定是a[i] 的倍数。

#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
ll a[N];
 
int main(){
	int T;
	cin >> T;
	while(T--){
		int n;
		cin >> n;
		ll ans = 0;
		for(int i = 1; i <= n; i++)
			cin >> a[i];
			
		for(int i = 1; i <= n; i++)
			for(int j = a[i] - i; j <= n; j += a[i]){
				if(j <= i)
					continue;
				if(a[i] * a[j] == i + j)
					ans++;
			}
		cout << ans << endl;
	}
	return 0;
 } 

C. Great Graphs

Farmer John has a farm that consists of $n$ pastures connected by one-directional roads. Each road has a weight, representing the time it takes to go from the start to the end of the road. The roads could have negative weight, where the cows go so fast that they go back in time! However, Farmer John guarantees that it is impossible for the cows to get stuck in a time loop, where they can infinitely go back in time by traveling across a sequence of roads. Also, each pair of pastures is connected by at most one road in each direction.

Unfortunately, Farmer John lost the map of the farm. All he remembers is an array $d$, where $d_i$ is the smallest amount of time it took the cows to reach the $i$-th pasture from pasture $1$ using a sequence of roads. The cost of his farm is the sum of the weights of each of the roads, and Farmer John needs to know the minimal cost of a farm that is consistent with his memory.

Input

The first line contains one integer $t$ ($1\le t\le 10^4$) — the number of test cases. Then $t$ cases follow.

The first line of each test case contains a single integer $n$ ($1\le n\le 10^5$) — the number of pastures.

The second line of each test case contains $n$ space separated integers $d_1,d_2,\dots ,d_n$ ($0\le d_i\le 10^9$) — the array $d$. It is guaranteed that $d_1=0$.

It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.

Output

For each test case, output the minimum possible cost of a farm that is consistent with Farmer John’s memory.

Example

input

3
3
0 2 3
2
0 1000000000
1
0

output

-3
0
0

Note

In the first test case, you can add roads

• from pasture $1$ to pasture $2$ with a time of $2$,
• from pasture $2$ to pasture $3$ with a time of $1$,
• from pasture $3$ to pasture $1$ with a time of $-3$,
• from pasture $3$ to pasture $2$ with a time of $-1$,
• from pasture $2$ to pasture $1$ with a time of $-2$.

The total cost is $2+1+-3+-1+-2=-3$.

In the second test case, you can add a road from pasture $1$ to pasture $2$ with cost $1000000000$ and a road from pasture $2$ to pasture $1$ with cost $-1000000000$. The total cost is $1000000000+-1000000000=0$.

In the third test case, you can’t add any roads. The total cost is $0$.

分析

相当于负向的边全部加上，正向只在相邻pasture加边

#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;

const int N = 1E5 + 10;
int a[N]; 
ll sum,ans;

int main(){
	int T;
	cin >> T;
	while(T--){
		int n;
		cin >> n;
		sum = ans = 0;
		for(int i=0; i<n; i++){
			cin >> a[i];
			sum += a[i];
		}
		sort(a, a+n);	// 由小到大排序 
		ans = sum;
		for(int i=1; i<n-1; i++){
			sum -= 1ll*(n-i)*(a[i]-a[i-1]);
			ans += sum;
		}
		ans -= a[n-1];
		cout << -ans <<endl; 
	}
	return 0;
}