Skip to content
This repository was archived by the owner on Oct 2, 2021. It is now read-only.
Open
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
295 changes: 295 additions & 0 deletions cpp template.txt
Original file line number Diff line number Diff line change
@@ -0,0 +1,295 @@
// -------------------------Solution by Aditya Raj------------------------- //
//--------------------------//
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <complex>
#include <queue>
#include <set>
#include <unordered_set>
#include <list>
#include <chrono>
#include <random>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <iomanip>
#include <fstream>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> p32;
typedef pair<ll,ll> p64;
typedef pair<double,double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int> > vv32;
typedef vector<vector<ll> > vv64;
typedef vector<vector<p64> > vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
double eps = 1e-12;
ll MOD = 998244353;
ll mod = 1000000007;
#define forn(i,e) for(ll i = 0; i < e; i++)
#define forsn(i,s,e) for(ll i = s; i < e; i++)
#define rforn(i,s) for(ll i = s; i >= 0; i--)
#define rforsn(i,s,e) for(ll i = s; i >= e; i--)
#define nl "\n"
#define dbg(x) cout<<#x<<" = "<<x<<ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 2e18
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define MAXN 1e5 + 5
#define int long long

// -------------------Modular Operations------------------- //

int add(int x, int y)
{
int res = x + y;
return(res >= mod ? res - mod : res);
}

int multiply(int x, int y)
{
int res = x * y;
return(res >= mod ? res % mod : res);
}

int subtract(int x, int y)
{
int res = x - y;
return(res < 0 ? res + mod : res);
}

int power(long long x, unsigned int y, int p)
{
int res = 1;

x = x % p;

if (x == 0) return 0;

while (y > 0)
{
if (y & 1)
res = (res*x) % p;

y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}

// -------------------Sieve of Erastothenes------------------- //

bool sieve_of_eratosthenes(int n)
{
vector<bool> is_prime(n+1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++) {
if (is_prime[i] && (long long)i * i <= n) {
for (int j = i * i; j <= n; j += i)
is_prime[j] = false;
}
}
return is_prime[n];
}

// -------------------Number of Divisors------------------- //

int NODiv(int n)
{
int cnt = 0;
for(int i = 1;i * i <= n;i++)
{
if(i * i == n)
{
cnt++;
continue;
}
cnt += 2;
}
return cnt;
}

// -------------------nCr(Binomial)------------------- //

int nCr(int n, int k)
{
if(n < k)
{
return 0;
}
if(k == 0)
{
return 1;
}
int res = 1;
for (int i = n - k + 1; i <= n; ++i)
res *= i;
for (int i = 2; i <= k; ++i)
res /= i;
return res;
}

// -------------------Checking Prime (O(root(n))------------------- //

bool isPrime(int x) {
for (int d = 2; d * d <= x; d++) {
if (x % d == 0)
return false;
}
return true;
}
// -------------------Adding Egdes to the Graph------------------- //

vector<vector<int>>adj;
void addEdge(int x, int y)
{
adj[x].push_back(y);
adj[y].push_back(x);
}

// -------------------DFS------------------- //

// vector<bool>visited; // resize in the solve() with n + 1
// void dfs(int v)
// {
// visited[v] = true;
// for(auto i:adj[v])
// {
// if(!visited[i])
// {
// dfs(i);
// }
// }
// }

// -------------------DIJKSTRA------------------- //

// vector<int>d;
// vector<int>p;

// void dijkstra(int s)
// {
// int n = adj.size();
// d.assign(n, INF);
// p.assign(n, -1);
// d[s] = 0;
// using pii = pair<int, int>;
// priority_queue<pii, vector<pii>, greater<pii>>q;
// q.push({0, s});
// while(!q.empty())
// {
// int v = q.top().second;
// int d_v = q.top().first;
// q.pop();
// if(d_v != d[v])
// {
// continue;
// }
// for (auto edge : adj[v])
// {
// int to = edge.first;
// int len = edge.second;
// if (d[v] + len < d[to])
// {
// d[to] = d[v] + len;
// p[to] = v;
// q.push({d[to], to});
// }
// }
// }
// }

// -------------------RESTORING SHORTEST PATH------------------- //

// vector<int>path;

// void restore_path(int s, int t)
// {
// for(int v = t;v != s;v = p[v])
// {
// path.push_back(v);
// }
// path.push_back(s);
// reverse(path.begin(), path.end());
// }

// -------------------Important Notes------------------- //

// For Interactive Problems remember to remove multi test cases condition //

// (int)log2(x) + 1 -> to calculate number of bits of a number
// s.erase(0, min(s.find_first_not_of('0'), s.size()-1)); //for removing leading zero's
// (int index = str.find(substr, pos)) != string::npos // for checking substring 'substr' in string 'str'

// -----------------------Solve------------------------ //
// #define REP for(int i = 0;i < n;i++)
void solve(){
int n;
cin >> n;
vector<ll> a1(n);
vector<ll> b(n);
for(int i = 0;i < n;i++){
cin>>a1[i];
}
for(int i = 0;i < n;i++){
cin>>b[i];
}
ll z=a1[n-1];
ll count=1;
for(ll i=n-2;i>=0;i--){
ll z1=z+a1[i];
a1[i]=count*a1[i]-z;
z=z1;
count++;
}
z=b[n-1];
count =1;
for(ll i=n-2;i>=0;i--){
ll z1=z+b[i];
b[i]=count*b[i]-z;
z=z1;
count++;
}
ll answer=0;
a1[n-1]=0;
b[n-1]=0;
for(ll i=0;i<n;i++){
answer+=a1[i];
answer-=b[i];
}
ll x1 = answer/2;
cout << x1 << endl;
}
signed main()
{
fast_cin();
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ll t;
cin >> t;
int k = 1;
while(t--) {
// cout<<"Case #"<<k<<": ";
k++;
solve();
}
return 0;
}