text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.size();
int ans = 0;
for (int i = 1; i < n; i++) {
// if (s[i] == '@') continue;
if (i == 1) {
if (s[i] == s[i-1]) {
s[i] = '@';
ans++;
}
} else {
if (s[i] == s[i-1] || s[i] == s[i-2]) {
s[i] = '@';
ans++;
}
}
}
cout << ans << "\n";
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int ll
bool check(int a, int b, int c, int opt){
if(opt) return a <= c && b > c;
return a < c && b >= c;
}
int32_t main() {
int t, n, k;
cin >> t;
while(t--) {
string s, ss;
cin >> s;
n = s.length();
vector<int> change(n, 0);
int ans = 0;
for(int i = 1 ; i < n ; i++) {
if(s[i-1] == s[i] && !change[i-1]) change[i] = 1, ans++;
else if(i > 1 && s[i-2] == s[i] && !change[i-2]) change[i] = 1, ans++;
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long int
#define double long double
#define ll long long
#define pb push_back
#define mp make_pair
#define fe first
#define se second
#define nl "\n"
#define ub upper_bound
#define lb lower_bound
#define sz(x) (int)(x.size())
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define rko ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//----------------------------------------------------------------------------------------------------------------------------------------------------
const double pi = 3.14159265358979323;
int mod = 1000000000 + 7;
// // int mod = 998244353;
const double pii = acos(-1.0);
const int INF = 1e18;
const int inf = 1e9;
//----------------------------------------------------------------------------------------------------------------------------------------------------
ll power(ll x,ll y){ll res=1;x=x;while(y>0){if(y&1)res=(res*x);y=y>>1;x=(x*x);}return res;}
ll powe(ll x, ll y){x = x%mod, y=y%(mod-1);ll ans = 1;while(y>0){if (y&1){ans = (1ll * x * ans)%mod;}y>>=1;x = (1ll * x * x)%mod;}return ans;}
ll gcd(ll a,ll b){if (a==0)return b;return gcd(b%a,a);}
ll lcm(ll a,ll b){return (a/gcd(a,b)*b);}
bool isPrime(int n){if(n<2) return false;for(int i=2;i*i<=n;i++)if(n%i==0) return false;return true;}
ll ncr(ll n,ll r){ll res=1;if(r>n)return 0;if(r>n-r)r=n-r;for(ll i=0;i<r;i++){res*=(n-i);res/=(i+1);}return res;}
ll add(ll a, ll b){return((a % mod + b % mod) % mod);}
ll sub(ll a, ll b){return((a % mod - b % mod + mod) % mod);}
ll mul(ll a, ll b){return(((a % mod) * (b % mod)) % mod);}
ll divi(ll a, ll b){return(mul(a, powe(b, mod - 2)) % mod);}
//-------------------------------------------------------------------------------------------------------------------------------------------------------
void fun()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
//786
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------
const int N = 2e5 + 7;
//--------------------------------------------------------------------------------------------------------------------------------------------------------
// int fact[N];
// void pre()
// {
// fact[0] = 1;
// for(int i=1;i<N;i++)
// {
// fact[i] = mul(fact[i-1], i);
// }
// }
// int ncrr(int n, int r)
// {
// if(n < r) return 0;
// return divi(fact[n], (mul(fact[r], fact[n-r])));
// }
//--------------------------------------------------------------------------------------------------------------------------------------------------------
signed main()
{
rko;
fun();
// pre();
int tests=1; cin >> tests;
while(tests--)
{
string s; cin >> s;
int n = sz(s);
int ans = 0;
for(int i=1;i<n;i++)
{
if(s[i] == s[i-1]) ans++, s[i] = '$';
if(i > 1) if(s[i] == s[i-2]) if(s[i-2] != '$') s[i] = '$', ans++;
}
cout << ans << '\n';
}
cerr << "time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
return 0;
} |
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<bitset>
#include<cmath>
#include<ctime>
#include<queue>
#include<map>
#include<set>
#define int long long
#define lowbit(x) (x&(-x))
#define mid ((l+r)>>1)
#define lc (x<<1)
#define rc (x<<1|1)
#define max Max
#define min Min
#define abs Abs
using namespace std;
inline int read()
{
int ans=0,f=1;
char c=getchar();
while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){ans=(ans<<1)+(ans<<3)+c-'0';c=getchar();}
return ans*f;
}
inline void write(int x)
{
if(x<0) putchar('-'),x=-x;
if(x/10) write(x/10);
putchar((char)(x%10)+'0');
}
template<typename T>inline T Abs(T a){return a>0?a:-a;};
template<typename T,typename TT>inline T Min(T a,TT b){return a>b?b:a;}
template<typename T,typename TT> inline T Max(T a,TT b){return a>b?a:b;}
const int N=1e5+5;
int t,n;
char s[N];
signed main()
{
t=read();
while(t--)
{
scanf("%s",s+1);
n=strlen(s+1);
int ans=0;
for(int i=2;i<=n;++i)
if((s[i]==s[i-1]||s[i]==s[i-2]))
ans++,s[i]='\000';
printf("%lld\n",ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e5+15;
char s[N];
int dp[N][2][2];
int solveDp(int ind,int p1,int p2,int n) {
if(ind==n+1) {
return 0;
}
int &ret = dp[ind][p1][p2];
if(ret!=-1) {
return ret;
}
ret = 1e9;
bool needChange = false;
if(ind-1>=1 && !p1) {
if(s[ind]==s[ind-1]) {
//must change
needChange = true;
}
}
if(ind-2>=1 && !p2) {
if(s[ind]==s[ind-2]) {
needChange = true;
}
}
ret = min(ret, solveDp(ind+1,1,p1,n) + 1);
if(!needChange) {
ret = min(ret, solveDp(ind+1,0,p1,n));
}
return ret;
}
void solve2() {
scanf(" %s ",s+1);
int n = strlen(s+1);
for(int i=0;i<=n;++i) {
for(int j=0;j<2;++j) {
for(int k=0;k<2;++k)
dp[i][j][k] = -1;
}
}
printf("%d\n",solveDp(1,0,0,n));
}
void solve() {
int n;
scanf("%d",&n);
while(n--) {
solve2();
}
}
int main() {
//freopen("input.txt","r",stdin);
solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define p_ary(ary,a,b) do { cout << "["; for (int count = (a);count < (b);++count) cout << ary[count] << ((b)-1 == count ? "" : ", "); cout << "]\n"; } while(0)
#define p_map(map,it) do {cout << "{";for (auto (it) = map.begin();;++(it)) {if ((it) == map.end()) {cout << "}\n";break;}else cout << "" << (it)->first << "=>" << (it)->second << ", ";}}while(0)
template<typename T1,typename T2>ostream& operator<<(ostream& os,const pair<T1,T2>& a) {os << "(" << a.first << ", " << a.second << ")";return os;}
const char newl = '\n';
int main() {
int q;
cin >> q;
while (q--) {
int n;
string s;
cin >> s;
n = s.size();
int ans = 0;
for (int i = 1;i < n;++i) {
if (s[i-1] == s[i]) {
s[i] = '0';
ans++;
} else if (1 < i && s[i-2] == s[i]) {
s[i] = '0';
ans++;
}
}
cout << ans << newl;
}
} |
//firstly save by ctrl+s before running the code
//press f5 to debug and input in terminal
//typcast by e.g (long long)variable and for constant e.g 5ll
//-----------------------------------------------------------------------------------------------------------------------------
//count set bits using __builtin_popcount(n);
// cout << fixed << setprecision(10) << pi <<" "<<npi<<endl;-->synax to set precision for float/double datatype pi , npi
//ceil or floor used for double and return double
//log also return double
//use floor(n)==n to see if a double n is integer
//for int x,y to get ceil in x/y do as (x+(y-1))/y and x/y itself equals floor only (but returns int)
//log2(n)==floor(log2(n))-->to check if power of 2
//------------------------------------------FUN BEIGINS!-----------------------------------------------------------------------
#include<bits/stdc++.h>
#include<fstream>
#define N 1000000007
#define M 998244353
using namespace std;
#define ll long long
#define pll pair<ll,ll>
#define vll vector<ll>
#define vpll vector<pll>
#define vvll vector<vll>
#define endl "\n" //"\n" not flushes output but endl do
#define umap unordered_map<ll,ll>
//------------------------------------------------------------------------------------------------------------------------------
vector<vector<long long>>adj;
map<long,bool>vis,viss;
vector<long long>rnk,parent,sz;
#define sieve_max 1000000
ll spf[sieve_max+1];
umap mp;
void yg(vll v, ll l, ll r,ll prev){
if(r<l)return;
if(r==l){mp[r]=prev; return;}
ll mx=LLONG_MIN;
ll ct=0;
for(ll i=l;i<=r;i++){if(v[i]>mx){
mx=v[i]; ct=i;
}}
mp[ct]=prev;
yg(v,l,ct-1,prev+1); yg(v,ct+1,r,prev+1);
return;
}
int main(){
ios_base::sync_with_stdio(false); cin.tie(NULL);
ll t,temp;
cin>>t;
while(t--){
mp.clear();
ll n;
cin>>n; vll v;
for(ll i=0;i<n;i++){
cin>>temp; v.push_back(temp);
}
yg(v,0,n-1,0);
for(ll i=0;i<n;i++)cout<<mp[i]<<" ";
cout<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define watch(x) cout << (#x) << " = " << (x) << endl
#define ll long long
#define mp make_pair
#define fi first
#define se second
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define INF INT_MAX
int tests;
int arrSize;
unordered_map<int, int> permutation, revn;
int depth[100];
int curIndex, curNum;
void build(int tl, int tr, int curDepth) {
if (tl > tr || tl < 0 || tr >= arrSize) {
return;
}
int curMax = 0;
int maxIndex;
for (int i = tl; i <= tr; ++i) {
if (revn[i] > curMax) {
curMax = revn[i];
maxIndex = i;
}
}
depth[maxIndex] = curDepth;
build(tl, maxIndex-1, curDepth+1);
build(maxIndex+1, tr, curDepth+1);
return;
}
int main(void) {
unordered_map<int, int>::iterator it;
cin >> tests;
while (tests--) {
permutation.clear(); revn.clear();
fill(depth, depth+100, 0);
curIndex = 0;
cin >> arrSize;
for (int i = 0; i < arrSize; ++i) {
cin >> curNum;
permutation[curNum] = curIndex;
revn[curIndex] = curNum;
++curIndex;
}
build(0, arrSize-1, 0);
for (int i = 0; i < arrSize; ++i) {
cout << depth[i] << " ";
}
cout << "\n";
}
} |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 107;
int tc, n, a[nmax], d[nmax];
void recur(int l, int r, int cnt)
{
if( l>r ) return ;
int p = l;
for( int i=l; i<=r; ++i ) {
if( a[i]>a[p] ) {
p = i;
}
}
d[p] = cnt;
recur(l, p-1, cnt+1);
recur(p+1, r, cnt+1);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> tc;
while (tc--) {
cin >> n;
for( int i=1; i<=n; ++i )
cin >> a[i];
recur(1, n, 0);
for( int i=1; i<=n; ++i )
cout << d[i] << ' ' ;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define a first
#define b second
typedef long long int ll;
typedef pair<int, int> pr;
ll t, n;
vector<ll> v, w;
void f(int s, int e, int cnt)
{
if (s > e) return;
if (s == e) { w[s] = cnt; return; }
int ma = e;
for (int i = s; i < e; i++) {
if (v[ma] < v[i]) ma = i;
}
w[ma] = cnt;
f(s, ma - 1, cnt + 1);
f(ma + 1, e, cnt + 1);
}
int main()
{
ios_base::sync_with_stdio(0);
cout.tie(0); cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
v.resize(n); w.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
f(0, n - 1, 0);
for (int i = 0; i < n; i++) cout << w[i] << " ";
cout << '\n';
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
void make_tree(int l,int r,vector<int> arr,int depth,vector<int>& depth_arr){
int idx=l;
int temp=arr[l];
for(int i=l+1;i<=r;i++){
if(arr[i]>temp){
temp=arr[i];
idx=i;
}
}
depth_arr[idx]=depth;
if(idx>l) make_tree(l,idx-1,arr,depth+1,depth_arr);
if(idx<r) make_tree(idx+1,r,arr,depth+1,depth_arr);
}
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
int temp;
vector<int> arr,depth_arr(n,0);
for(int i=0;i<n;i++){
cin>>temp;
arr.push_back(temp);
}
make_tree(0,n-1,arr,0,depth_arr);
for(int i=0;i<n;i++) cout<<depth_arr[i]<<' ';
cout<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
// Wait, N is up to a hundred!?
#ifdef DEBUG
#define debug(...) __VA_ARGS__
#else
#define endl '\n'
#define debug(...)
#endif
#define debugf(...) debug(printf(__VA_ARGS__))
const int N = 128;
const int oo = 0x3f3f3f3f;
int t[N<<1];
int a[N];
int take(int i, int j) {
return a[i] > a[j] ? i : j;
}
void build() {
for (int i = N-1; i > 0; i--)
t[i] = take(t[i<<1], t[i<<1|1]);
}
int query(int l, int r) {
int ans = 0;
for (l+=N, r+=N; l < r; l>>=1, r>>=1) {
if (l&1) ans = take(ans, t[l++]);
if (r&1) ans = take(ans, t[--r]);
}
return ans;
}
int answer[N];
void dfs(int l, int r, int dep = 0) {
if (r - l < 1) return;
int u = query(l, r);
answer[u] = dep;
dfs(l, u, dep + 1);
dfs(u+1, r, dep + 1);
}
void solve() {
int n; cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
t[i+N] = i;
}
build();
dfs(1, n+1);
for (int i = 1; i <= n; i++)
cout << answer[i] << ' ';
cout << endl;
for (int i = 1; i <= n; i++)
t[i+N] = 0;
}
int (((((((main)))))))() {
cin.tie(0)->sync_with_stdio(false);
a[0] = -oo;
int q; cin >> q;
while (q--) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<int> a,ans;
void f(int l, int r, int d){
if(l>r) return;
int mxv=0;
int mxidx=0;
for(int i=l;i<=r;i++){
if(a[i]>mxv){
mxv=a[i];
mxidx=i;
}
}
ans[mxidx]=d;
f(l,mxidx-1,d+1); f(mxidx+1,r,d+1);
}
void solve(){
int n; cin>>n;
a.resize(n);
ans.resize(n);
for(auto& ai:a)
cin>>ai;
f(0,n-1,0);
for(auto ansi:ans)
cout<<ansi<<" ";
cout<<"\n";
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int T; cin>>T;
while(T--){
solve();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int ans[100001];
void recursion(int st,int en,int cd,int arr[]) {
if(st==en) {
ans[st]=cd;
return;
}
int maxx=INT_MIN;
for(int i=st;i<=en;i++) maxx=max(maxx,arr[i]);
for(int i=st;i<=en;i++) {
if(arr[i]==maxx) {
ans[i]=cd;
if(i!=st) recursion(st,i-1,cd+1,arr);
if(i!=en) recursion(i+1,en,cd+1,arr);
break;
}
}
return;
}
int main() {
int t=1;
cin>>t;
while(t--) {
int n;
cin>>n;
int arr[n];
for(int i=0;i<n;i++) cin>>arr[i];
recursion(0,n-1,0,arr);
for(int i=0;i<n;i++) cout<<ans[i]<<" ";
cout<<endl;
}
return 0;
} |
/*
Author - Param Kothari
Ah shit, here we go again
*/
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define pb push_back
#define mk make_pair
typedef long long ll;
typedef long double ld;
int n;
vector<int> a;
vector<int> res;
void rec(int l, int r, int depth){
if(l > r)
return;
if(l == r){
res[l] = depth;
return;
}
int idx = -1, maxi = -1;
for(int i = l; i <= r; i++){
if(maxi < a[i]){
maxi = a[i];
idx = i;
}
}
assert(idx != -1);
res[idx] = depth;
rec(l, idx - 1, depth + 1);
rec(idx + 1, r, depth + 1);
return;
}
void solve(){
cin >> n;
a.clear();
a.resize(n);
for(int i = 0; i < n; i++){
cin >> a[i];
a[i]--;
res.pb(0);
}
rec(0, n - 1, 0);
for(int i = 0; i < n; i++){
cout << res[i] << " ";
}
cout << "\n";
return;
}
int main(){
IOS;
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++){
solve();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int solve()
{
int n;
cin>>n;
int a[n+1];
int p1[n+1];
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
for(int i=1;i<=n;i++)
{
p1[a[i]] = i;
}
int ans[n+1];
for(int i=n;i>=1;i--)
{
int f=p1[i]-1;
int b=p1[i]+1;
while(b<=n && a[b] < i)
b++;
while(f>=1 && a[f] < i)
f--;
if(f>0 && b>n)
ans[i] = ans[a[f]] + 1;
else if (f==0 && b<=n)
ans[i] = ans[a[b]] + 1;
else if(f>0 && b<=n)
ans[i] = max(ans[a[b]], ans[a[f]]) + 1;
else ans[i] = 0;
}
for(int i=1;i<=n;i++)
cout<<ans[a[i]]<<" ";
cout<<endl;
return(0);
}
int main()
{
int t;
cin>>t;
while(t--)
{
solve();
}
} |
#include <bits/stdc++.h>
#define ld long double
#define mp make_pair
#define pb push_back
#define se second
#define fs first
#define mod 1000000000 + 7
typedef long long int ll;
using namespace std;
void solve()
{
ll n; cin>>n;
ll A[n+1];
for(int i=1;i<=n;i++) cin>>A[i];
ll D[n+1];
for(int i=1;i<=n;i++) D[i]=0;
ll nextGRight[n+1];
for(int i=1;i<=n;i++) nextGRight[i]=-1;
stack <ll> S;
S.push(1);
for(int i=2;i<=n;i++){
while(S.size() && A[i]>A[S.top()]){
nextGRight[S.top()]=A[i];
S.pop();
}
S.push(i);
}
while(S.size()){
S.pop();
}
// for(int i=1;i<=n;i++) cout<<nextGRight[i]<<" ";
// cout<<endl;
ll nextGLeft[n+1];
for(int i=1;i<=n;i++) nextGLeft[i]=-1;
S.push(n);
for(int i=n-1;i>=1;i--){
while(S.size() && A[i]>A[S.top()]){
nextGLeft[S.top()]=A[i];
S.pop();
}
S.push(i);
}
// for(int i=1;i<=n;i++) cout<<nextGLeft[i]<<" ";
// cout<<endl;
map<ll,ll> M;
for(int i=1;i<=n;i++) M[A[i]]=i;
for(int I=n-1;I>=1;I--){
ll i=M[I];
ll leftNG = nextGLeft[i];
ll rightNG = nextGRight[i];
ll mini;
if(leftNG!=-1 && rightNG!=-1) mini=min(rightNG, leftNG);
else if(leftNG==-1) mini=rightNG;
else mini=leftNG;
//cout<<i<<" "<<leftNG<<" "<<rightNG<<" "<<M[mini]<<endl;
D[M[I]]=D[M[mini]]+1;
}
for(int i=1;i<=n;i++) cout<<D[i]<<" ";
cout<<endl;
}
int main()
{
ll t;
cin>>t;
while (t--){
solve();
}
return 0;
}
|
#include <cstring>
#include <iostream>
#include <algorithm>
#include <deque>
#include <queue>
#include <set>
#include <map>
using namespace std;
typedef pair<int,int> PII;
typedef long long LL;
const int N = 110;
int n;
int a[N];
int cnt[N];
void dfs(int u,int l,int r){
if(l > r)return;
int j = l;
for(int i = l;i <= r;i++){
if(a[i] > a[j]){
j = i;
}
}
cnt[j] = u;
dfs(u + 1,l,j - 1);
dfs(u + 1,j + 1,r);
}
int main(){
int T;
cin >> T;
while(T--){
cin >> n;
for(int i = 0;i < n;i++)cin >> a[i];
dfs(0,0,n - 1);
for(int i = 0;i < n;i++)cout << cnt[i] << ' ';
cout << endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int INF = 0x3f3f3f3f;
int x;
int n;
int a[1005], b[1005];
void ok(int l, int r, int k){
if(l > r || l < 1 || r > n) return ;
int ans = 0, ii;
for(int i = l; i <= r; i ++ ){
if(a[i] > ans){
ans = a[i];
ii = i;
}
}
b[ii] = k;
ok(l, ii - 1, k + 1), ok(ii + 1, r, k + 1);
}
int main(){
int t;
cin >> t;
while(t -- ){
memset(a, 0, sizeof a);
memset(b, 0, sizeof b);
cin >> n;
for(int i = 1; i <= n; i ++ ){
cin >> a[i];
}
ok(1, n, 0);
for(int i = 1; i <= n; i ++ ){
cout << b[i] << " ";
}
cout << endl;
}
return 0;
}
|
/*
author:ujwalll
*/
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
#define nx cout << "\n";
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
#define pp pair<ll, ll>
#define ppi pair<int, int>
typedef long long int ll;
#define pri(x) printf("%d ", x);
#define prl(x) printf("%lld ", x);
#define fi first;
#define se second;
#define pb push_back;
#define mp make_pair;
#define all(v) v.begin(), v.end()
bool isPowerOfTwo(ll x){
return x && (!(x & (x - 1)));
}
void fastio(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long binpow(long long a, long long b){
long long res = 1;
while (b > 0)
{
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
// int dfstimer(int node, int par){
// st[node]=timer;
// ft[timer]=node;
// timer++;
// for(auto i:adj[node]){
// if(i!=par)dfs(i,node);
// }
// et[node]=timer;
// ft[timer]=node;
// timer++;
// }
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, -1, 0, 1, 1, -1, -1, 1};
////////////////////////////////////////////////////////////////////
map<int,int> m;
int n;
int a[105],b[105];
void solve(int s, int cur, int e, int cnt){
m[a[cur]]=cnt;
// cout<<s<<" "<<cur<<" "<<e<<"\n";
if(s>=e)return;
int mxi = 0,mx = 0;
if(cur!=s){
for(int i=s;i<cur;i++){
if(a[i]>mx){
mxi=i;
mx=a[i];
}
}
solve(s,mxi,cur-1,cnt+1);
}
if(cur!=e){
mxi=0,mx=0;
for(int i=cur+1;i<=e;i++){
if(a[i]>mx){
mxi=i;
mx=a[i];
}
}
solve(cur+1,mxi,e,cnt+1);
}
}
int main(){
fastio();
int tc = 1;
cin>>tc;
while(tc--){
m.clear();
cin>>n;
int mxi=0,mx=0;
rep(i,n){
cin>>a[i];
if(a[i]>mx){
mx=a[i];
mxi=i;
}
b[i]=a[i];
}
solve(0,mxi,n-1,0);
// sort(a,a+mxi);
// sort(a+mxi+1,a+n);
rep(i,n){
cout<<m[a[i]];
cout<<" ";
}
nx;
}
return 0;
} |
/*
ID: shubham147
TASK: gift1
LANG: C++14
*/
// #include <ext/pb_ds/assoc_container.hpp> // Common file
// #include <ext/pb_ds/tree_policy.hpp>
// #include <functional> // for less
#include<bits/stdc++.h>
// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimization("unroll-loops")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC optimize("fast-math")
// #pragma GCC optimize("no-stack-protector")
#define ll long long
#define f(i,a,b) for(ll i=a;i<b;i++)
#define mod 1000000007
#define mp make_pair
#define ff first
#define ss second
#define rf(i,a,b) for(ll i=a;i>=b;i--)
#define sc(a) scanf("%lld",&a)
#define pf printf
#define sz(a) (int)(a.size())
#define psf push_front
#define ppf pop_front
#define ppb pop_back
#define pb push_back
#define pq priority_queue
#define all(s) s.begin(),s.end()
#define sp(a) setprecision(a)
#define rz resize
#define ld long double
#define inf (ll)1e18
#define ub upper_bound
#define lb lower_bound
#define bs binary_search
#define eb emplace_back
const double pi = acos(-1);
ll binpow(ll a, ll b){ll res=1;while(b!=0){if(b&1)res*=a;a*=a;b>>=1;}return res;}
// using namespace __gnu_pbds;
using namespace std;
// typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_nd_update> new_data_set;
ll n;
vector<ll> a,d;
void fn(ll l, ll r, ll depth)
{
if(l>r)
return;
ll id=l,mx=-inf;
f(i,l,r+1)
{
if(a[i]>mx)
mx=a[i],id=i;
}
d[id]=depth;
if(id!=l)
fn(l,id-1,depth+1);
if(id!=r)
fn(id+1,r,depth+1);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("gift1.in","r",stdin);
// freopen("gift1.out","w",stdout);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ll t=1;
cin>>t;
while(t--)
{
cin>>n;
a.rz(n),d.rz(n);
f(i,0,n)
cin>>a[i];
fn(0LL,n-1,0LL);
f(i,0,n)
cout<<d[i]<<" ";
cout<<"\n";
a.clear(),d.clear();
}
} |
#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define fi first
#define se second
#define pb push_back
#define pk pop_back
using namespace std;
ll mod = 1e9 + 7;
ll kol = 0;
vector <ll> a;
vector <ll> ans;
void f(ll l, ll r, ll d)
{
if(l == r)
{ans[l] = d;return;}
ll mx = 0, q = 0;
for(ll i = l; i <= r; ++i)
{
if(mx < a[i])
{
mx = a[i];
q = i;
}
}
ans[q] = d;
if(q != l)
f(l, q - 1, d + 1);
if(q != r)
f(q + 1, r, d + 1);
}
void solve()
{
ll n = 0, m = 0, k = 0, sum = 0;
string s;
cin >> n;
a.resize(n + 1);
ans.resize(n + 1);
for(ll i = 1; i <= n; ++i)
cin >> a[i];
f(1, n, 0);
for(ll i = 1; i <= n; ++i)
cout << ans[i] << " ";
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
ll qwe = 1;
cin >> qwe;
while(qwe--)
{
solve();
cout << "\n";
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,j,n) for(ll i=j;i<n;i++)
#define scn(a) scanf("%lld",&a)
#define scns(a,b) scanf("%lld %lld",&a,&b)
#define print(a) printf("%d\n",a)
#define vec vector<ll>
#define pb push_back
#define pairs pair<ll,ll>
#define f first
#define s second
#define all(v) v.begin(),v.end()
#define mem(a,b) memset(a,b,sizeof(a))
#define tc ll t; cin>>(t); while(t--)
const ll N = 1e5+5;
ll n,a[105],ans[105];
void rec(ll l,ll r,ll rv)
{
if(l>r || l<0 || r>=n)
return;
ll mx=0,li,ri,ind=-1;
for(ll i=l;i<=r;i++)
{
if(a[i]>mx)
mx=a[i],li=i-1,ri=i+1,ind=i;
}
if(ind!=-1 && ans[ind]==0)
ans[ind]=rv;
rec(l,li,rv+1);
rec(ri,r,rv+1);
}
int main()
{
tc{
scn(n);
rep(i,0,n)
{
scn(a[i]);
ans[i]=0;
}
ll l=0,r=n-1,rV=0;
rec(l,r,0);
rep(i,0,n)
cout<<ans[i]<<" ";
cout<<endl;
}
} |
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
const int N = 110;
struct node
{
ll x, y;
}a[N];
void dfs(int l, int r, int u)
{
if(l > r) return ;
int f = l;
for (int i = l; i <= r; i ++ )
if(a[f].x < a[i].x)
f = i;
a[f].y = u;
dfs(l, f - 1, u + 1);
dfs(f + 1, r, u + 1);
}
int main()
{
int t;
cin >> t;
while(t --)
{
int n;
cin >> n;
for (int i = 0; i < n; i ++ )
{
cin >> a[i].x;
a[i].y = 0;
}
dfs(0, n - 1, 0);
for (int i = 0; i < n; i ++ )
cout << a[i].y << " ";
cout << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string>
#include <math.h>
#include <iomanip>
#include <queue>
#include <map>
using namespace std;
const int MAX = 102;
int answer[MAX];
int a[MAX];
void solution(int left, int right, int level) {
int maxV = 0;
int index = -1;
for (int i = left; i <= right; ++i) {
if (maxV < a[i]) {
maxV = a[i];
index = i;
}
}
if (answer[index] == -1) {
answer[index] = level;
solution(left, index - 1, level + 1);
solution(index + 1, right, level + 1);
}
}
int main() {
//freopen("D.in", "rt", stdin);
std::ios::sync_with_stdio(false);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
memset(answer, -1, sizeof(answer));
memset(a, 0, sizeof(a));
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
solution(0, n - 1, 0);
for (int i = 0; i < n; ++i) {
cout << answer[i];
if (i != n - 1) cout << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int n, pRoot;
int v[110], dist[110];
int maxPos(int left, int right) {
int pos = -1;
for (int i = left; i <= right; i++)
if (pos == -1 || v[pos] < v[i])
pos = i;
return pos;
}
void tree(int left, int right, int node) {
if (left == right) {
dist[left] = dist[node] + 1;
return;
}
int pMax = maxPos(left, right);
dist[pMax] = dist[node] + 1;
if (left <= pMax - 1)
tree(left, pMax - 1, pMax);
if (pMax + 1 <= right)
tree(pMax + 1, right, pMax);
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
dist[i] = 0;
}
pRoot = maxPos(1, n);
if (pRoot > 1)
tree(1, pRoot - 1, pRoot);
if (pRoot < n)
tree(pRoot + 1, n, pRoot);
for (int i = 1; i <= n; i++)
cout << dist[i] << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1000000000
#define PI 3.1415926536
#define debug(n) cout << #n << " : "<< n << endl
#define foi(n) for(int i=0; i<(n); i++)
#define foj(n) for(int j=0; j<(n); j++)
#define scv(v) for(auto &x:v) cin>>x
inline bool isvowel(char c){return (c=='a'||c=='e'||c=='i'||c=='o'||c=='u');}
typedef unsigned long long ull;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int,int> pii;
typedef pair<long long, long long> pll;
template <class T> void print(const T &cont){
for(auto x: cont) cout << x << ' ';
cout << '\n';
}
vi res;
void make_tree(vi &a, int l, int h, int depth) {
if(l>h) return;
int i=l;
for(int j=l; j<=h; j++) {
if(a[j] > a[i]) {
i = j;
}
}
res[i] = depth;
make_tree(a, l, i-1, depth + 1);
make_tree(a, i+1, h, depth + 1);
}
void input(){
int n, x,m;
cin>>n;
vi a(n);
scv(a);
res.resize(n);
make_tree(a, 0, n-1, 0);
print(res);
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t=1;
cin>>t;
while (t--)
input();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int N = 101;
vector< int > vc(N), depth(N);
void get_depth (int l, int r, int d) {
if (l == r) return;
if (r - l == 1) {
depth[l] = d;
return;
}
int pos = max_element(vc.begin() + l, vc.begin() + r) - vc.begin();
depth[pos] = d;
get_depth(l, pos, d + 1);
get_depth(pos + 1, r, d + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> vc[i];
int l = 0, r = n, d = 0;
get_depth(l, r, d);
for (int i = 0; i < n; i++) cout << depth[i] << " ";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
#define ios ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define ll long long
using namespace std;
ll int mod=1e9+7;//998244353;
ll int mul(ll int x, ll int y)
{
return (x * 1ll * y) % mod;
}
ll int add(ll int x,ll int y)
{
x += y;
while(x >= mod) x -= mod;
while(x < 0) x += mod;
return x;
}
long long power(long long a, long long b,ll m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = mul(res,a);
a = mul(a,a);
b >>= 1;
}
return res%m;
}
ll int n;
ll int a[105];
ll int d[105];
ll int fun(int i,int j,int l)
{
if(i>j)
return 0;
if(i==j)
{
d[i]=l;
return 0;
}
ll int ma=0;
ll int o=0;
for(int k=i;k<=j;k++)
{
ma=max(ma,a[k]);
if(ma==a[k])
o=k;
}
d[o]=l;
return fun(i,o-1,l+1)+fun(o+1,j,l+1);
}
int main() {
ios;
ll int t;
cin>>t;
while(t--)
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
memset(d,0,sizeof(d));
fun(0,n-1,0);
for(int i=0;i<n;i++)
cout<<d[i]<<" ";
cout<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
void solve(unordered_map<int, int> index, int arr[], int v[], int l, int r, int height){
if(l > r){
return;
}
int max_ele=INT_MIN;
for(int i=l; i<=r; i++){
max_ele = max(arr[i], max_ele);
}
v[index[max_ele]] = ++height;
solve(index, arr, v, l, index[max_ele]-1, height);
solve(index, arr, v, index[max_ele]+1, r, height);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
int v[n];
unordered_map<int, int> index;
for (int i = 0; i < n; i++) {
cin >> arr[i];
index[arr[i]] = i;
}
int height = 0;
v[index[n]] = height;
solve(index, arr, v, 0, index[n]-1, height);
solve(index, arr, v, index[n]+1, n-1, height);
for(int i=0; i<n; i++){
cout<<v[i]<<" ";
}
cout<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
bool noroot=false;
void helper(vector<int>&a,vector<int>&dis,int st,int end,int root)
{
if(st>end)
{
return;
}
int mxind=-1;
int mxvl=INT_MIN;
for(int i=st;i<=end;i++)
{
if(a[i]>mxvl)
{
mxvl=a[i];
mxind=i;
}
}
if(root>-1)
{
dis[mxind]=dis[root]+1;
}
else
{
dis[mxind]=0;
}
helper(a,dis,st,mxind-1,mxind);
helper(a,dis,mxind+1,end,mxind);
}
int main() {
int t,n;
cin>>t;
//long long int n;
while(t--)
{
cin>>n;
vector<int> a(n,0);
vector<int> dis(n,0);
for(int i=0;i<n;i++)
cin>>a[i];
int st=0;
int end=n-1;
helper(a,dis,st,end,-1);
for(int i=0;i<n;i++)
cout<<dis[i]<<" ";
cout<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define bitcount __builtin_popcount
#define pb push_back
#define mp make_pair
#define bitcountll __builtin_popcountl;
#define all(v) v.begin(), v.end()
int arr[300000]={};
struct node {
int data;
struct node *left;
struct node *right;
node(int val)
{
data = val;
left = NULL;
right = NULL;
}
};
int ans[100000];
int n;
int check(int left,int right){
int maxs=-1;
int ans=-1;
for(int i=left;i<right;i++){
if(arr[i]>maxs){
ans=i;
maxs=arr[i];
}
}
return ans;
}
void solves(int left,int right,int deps)
{
if(left==right)
return;
int bigg=check(left,right);
solves(left,bigg,deps+1);
solves(bigg+1,right,deps+1);
ans[bigg]=deps;
}
void solve() {
long long a,b,k;
string s,t,p;
cin >> n;
for(int i=0;i<n;i++){
cin >> a;
arr[i]=a;
}
solves(0,n,0);
for(int i=0;i<n;i++)
cout << ans[i] << " ";
}
int main() {
#ifndef ONLINE_JUDGE
// system("clear");
freopen("Test0.in", "r", stdin);
// freopen("Test0.out", "w", stdout);
#endif
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
//cout << fixed;
cout<< setprecision(10);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[100], n;
void ans(int l, int r, vector<int> &a, int c){
if(l > r || l<0 || r>=n || l>=n || r<0) return;
else if(l == r) d[l] = c++;
else{
int f = -1, m = 0;
for(int i = l; i <= r; i++){
if(a[i]>m){
f = i; m = a[i];
}
}
d[f] = c++;
ans(l, f-1, a, c);
ans(f+1, r, a, c);
}
return;
}
int main(){
int T; cin>>T;
while(T--){
int i; cin>>n;
vector<int> a(n);
for(i=0; i<n; i++) d[i] = -1;
for(i=0; i<n; i++) cin>>a[i];
ans(0, n-1, a, 0);
for(i = 0; i < n; i++) cout<<d[i]<<" "; cout<<"\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cerr << #x << " = " << x << "\n";
void makeTree(int left, int right, vector<pair<int, int>> &a, int depth) {
if (left == right) {
return;
}
auto split = max_element(a.begin() + left, a.begin() + right);
split->second = depth;
depth++;
makeTree(left, split - a.begin(), a, depth); // Left side.
makeTree(split - a.begin() + 1, right, a, depth); // Right side.
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n, an;
cin >> t;
while (t--) {
vector<pair<int, int>> a;
cin >> n;
int largest = n;
for (int i = 0; i < n; i++) {
cin >> an;
a.push_back({an, -1});
}
makeTree(0, a.size(), a, 0);
for (auto x : a) {
cout << x.second << " ";
}
cout << "\n";
}
return 0;
}
|
#include <iostream>
#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<string.h>
#include<iomanip>
#include<string.h>
#include<string>
#include<cmath>
#include<set>
#include<map>
#define ll long long
using namespace std;
struct
{
ll id=0;
ll num;
}a[105];
ll n;
void dg(int st,int ed)
{
int i,j,maxx=0;
if(st>ed||ed>n||st<1)
return;
for(i=st;i<=ed;i++)
{
a[i].id++;
if(a[i].num>maxx){
maxx=a[i].num;
j=i;}
}
dg(st,j-1);
dg(j+1,ed);
}
int main()
{
ll t;
cin>>t;
while(t--)
{
ll i,j;
cin>>n;
ll maxx=0;
for(i=1;i<=n;i++)
{
cin>>a[i].num;
a[i].id=0;
if(a[i].num>maxx){
maxx=a[i].num;
j=i;}
}
dg(1,j-1);
dg(j+1,n);
for(i=1;i<=n;i++)
cout<<a[i].id<<" ";
cout<<endl;
}
return 0;
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int nax = 2e5 + 5;
const int mod = 1e9 + 7;
int n, a[nax], depth[nax];
void func(int l, int r, int d){
if(l > r){
return;
}
int mx = -1, idx = -1;
for(int i = l; i <= r; i++){
if(a[i] > mx){
mx = a[i];
idx = i;
}
}
depth[idx] = d;
func(l, idx - 1, d + 1);
func(idx + 1, r, d + 1);
}
void run_case(){
cin >> n;
for(int i = 1; i <= n; i++){
cin >> a[i];
}
func(1, n, 0);
for(int i = 1; i <= n; i++){
cout << depth[i] << ' ';
}
cout << '\n';
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
cin >> T;
while(T--){
run_case();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define ff first
#define ss second
#define pi pair<int,int>
#define INF 1e18
#define db double
#define vec vector<ll>
#define test cout<<" test_rounds"<<endl
#define ull unsigned long long int
#define cntone(n) __builtin_popcount(n)
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define pai acos(-1.0)
#define mod 1e9+7
#define dbl long double
#define mk make_pair(ll,ll)
#define mem(a,b) memset(a,b,sizeof(a))
#define sz(s) int(s.size())
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
ll dx[]={0,1,0,-1};
ll dy[]={1,0,-1,0};
ll dxx[]={0,1,0,-1,1,1,-1,-1};
ll dyy[]={1,0,-1,0,1,-1,1,-1};
ll a[205];
ll solve()
{
ll cnt=0;
return cnt;
}
bool cmp(ll a,ll b){
return a>b;
}
int main()
{
fastio;
int t;
cin>>t;
while(t--)
{
ll n,m;
cin>>n;
ll c[n+2],d[n+2];
mem(c,0);
mem(d,0);
for(int i=1;i<=n;i++)
{
cin>>a[i];
for(int j=i-1;j>=1;j--)
{
if(a[j]>a[i])
{c[a[i]]=c[a[j]]+1;break;
}
}
}
for(int i=n;i>=1;i--)
{
for(int j=i+1;j<=n;j++)
{
if(a[j]>a[i])
{
d[a[i]]=d[a[j]]+1;
break;
}
}
}
for(int i=1;i<=n;i++)
{
cout<<c[a[i]]+d[a[i]]<<" ";
}
cout<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int ans[1000],ar[1000];
void solve(int a,int b,int l){
if(a>b) return;
int mx=0,mi;
for(int i=a;i<=b;i++){
if(ar[i]>mx){
mx=ar[i];
mi=i;
}
}
ans[mi]=l;
solve(a,mi-1,l+1);
solve(mi+1,b,l+1);
}
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
for(int i=0;i<n;i++) cin>>ar[i];
solve(0,n-1,0);
for(int i=0;i<n;i++) cout<<ans[i]<<" ";
cout<<"\n";
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define seti set<int>
#define setl set<long long >
#define loop(j,n) for(int i=j;i<n;i++)
#define ll long long
#define all(a) a.begin(),a.end()
#define ts(i) to_string(i)
#define pb push_back
#define ff first
#define ss second
#define mk make_pair
#define fastio ios_base::sync_with_stdio(false); cin.tie(0);cout.tie(0);
#define MAX 200001
int INF=1e9;
//##########################################################
ll countfactor(ll n)
{
ll count = 0;
ll t = 0;
ll num = 0;
for (ll i = 2 ; i * i <= n; i++)
{
if (n % i == 0)
{
ll temp = n;
while (temp % i == 0)
{
temp = temp / i;
count++;
}
}
if (count > t)
{
num = i;
}
t = max(t, count);
count = 0;
}
return num;
}
//#######################
int binomialCoeff(int n, int k)
{
//base case
if (k > n)
return 0;
if (k == 0 || k == n)
return 1;
// Recur
return binomialCoeff(n - 1, k - 1)
+ binomialCoeff(n - 1, k);
}
//###################################
ll gcd(ll x,ll y)
{
if(y==0)
return x;
return gcd(y,x%y);
}
////#############################
bool isPrime(ll n)
{
// Corner cases
if (n <= 1) return false;
if (n <= 3) return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n%2 == 0 || n%3 == 0) return false;
for (ll i=5; i*i<=n; i=i+6)
if (n%i == 0 || n%(i+2) == 0)
return false;
return true;
}
//######################
int N=1e9;
vector<int>pr;
void sieve()
{
bool prime[N+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=N; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=N; i += p)
prime[i] = false;
}
}
for(int i=2;i<=N;i++)
{
if(prime[i]==true)
pr.pb(i);
}
}
//########## SEGMENTREE_SUM_START ####################
//########## SEGMENT_TREE_END ####################
ll power(ll x, unsigned ll y)
{
ll res = 1; // Initialize result
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = res*x;
// y must be even now
y = y>>1; // y = y/2
x = x*x; // Change x to x^2
}
return res;
}
bool check(string expr)
{
stack<char> s;
char x;
// Traversing the Expression
for (int i = 0; i < (int)expr.length(); i++)
{
if (expr[i] == '(' || expr[i] == '['
|| expr[i] == '{')
{
// Push the element in the stack
s.push(expr[i]);
continue;
}
// IF current current character is not opening
// bracket, then it must be closing. So stack
// cannot be empty at this point.
if (s.empty())
return false;
switch (expr[i]) {
case ')':
// Store the top element in a
x = s.top();
s.pop();
if (x == '{' || x == '[')
return false;
break;
case '}':
// Store the top element in b
x = s.top();
s.pop();
if (x == '(' || x == '[')
return false;
break;
case ']':
// Store the top element in c
x = s.top();
s.pop();
if (x == '(' || x == '{')
return false;
break;
}
}
// Check Empty Stack
return (s.empty());
}
vector<int>T(1000);
vector<pair<int,int>>p;
void divide(vector<int>A,int left,int right,int d)
{
if(left<0 || right>=A.size())
{
return ;
}
if(left>right)
{
return ;
}
int mx=-1;
int index=-1;
for(int i=left;i<=right;i++)
{
if(mx<A[i])
{
index=i;
mx=max(mx,A[i]);
}
}
T[index]=d;
divide(A,left,index-1,d+1);
//T.push_back(l);
divide(A,index+1,right,d+1);
//T.push_back(r);
//p.push_back({l,r});
return ;
}
void test_case()
{
int n;
cin>>n;
vector<int>A(n);
int mx=-1;
for(int i=0;i<n;i++)
{
cin>>A[i];
mx=max(mx,A[i]);
}
divide(A, 0,n-1,0);
//cout<<index<<endl;
/*for(int i=0;i<T.size();i++)
{
cout<<T[i]<<" ";
}
cout<<endl;*/
/*for(int i=p.size()-1;i>=0;i--)
{
cout<<p[i].first<<" "<<p[i].second<<" ";
cout<<"\n";
}*/
for(int i=0;i<n;i++)
{
cout<<T[i]<<" ";
}
cout<<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t;
cin>>t;
while(t--)
test_case();
#ifndef ONLINE_JUDGE
cout<<(double_t)clock()/CLOCKS_PER_SEC<<"sec"<<endl;
#endif
}
|
#include <bits/stdc++.h>
#define int long long
#define buff_sm ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
int t,n,a[101],c[101];
void bruh(int dinh, int l, int r){
int lon = a[l], vt = l;
for(int i = l; i <= r; i++){
if(a[i]>lon){
lon = a[i];
vt = i;
}
}
c[lon] = dinh;
//cout << lon << endl;
if(vt!=r) bruh(dinh + 1, vt + 1, r);
if(vt!=l) bruh(dinh + 1, l, vt - 1);
}
signed main(){
buff_sm
cin >> t;
while(t!=0){
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i];
bruh(0, 0, n - 1);
for(int i = 0; i < n; i++) cout << c[a[i]] << " ";
cout << endl;
t--;
}
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int ll
#define ld long double
#define ff first
#define ss second
#define io ios_base::sync_with_stdio(false); cin.tie(NULL);
#define yes cout<<"YES"
#define no cout<<"NO"
#define loop(i,a,n) for(int i=a;i<n;i++)
#define rloop(i,n,a)for(int i=n-1;i>=a;i--)
#define test int tt=1; cin>>tt; while(tt--)
#define pb push_back
#define pi 3.141592653589793238
#define all(v) v.begin(),v.end()
#define vecl vector<int>
#define pii pair<int,int>
#define vpii vector<pii>
const int MOD = 1e9 + 7;
int fast_expo(int x, int p) {
if (p == 0) return 1;
else if (p % 2 == 0) { int t = fast_expo(x, p / 2) % MOD; return (t * t) % MOD;}
else return (x * (fast_expo(x, p - 1)) % MOD) % MOD;
}
int gcd(int a, int b) {
if (a == 0 || b == 0) return a + b;
else return gcd(b % a, a);
}
int lcm(int a, int b)
{
return (a * b) / gcd(a, b);
}
vecl v;
void primeFactors(int n)
{
// Print the number of 2s that divide n
while (n % 2 == 0)
{
v.pb(2);
n = n / 2;
}
// n must be odd at this point. So we can skip
// one element (Note i = i +2)
for (int i = 3; i <= sqrt(n); i = i + 2)
{
// While i divides n, print i and divide n
while (n % i == 0)
{
v.pb(i);
n = n / i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (n > 2)
v.pb(n);
}
//int t[101][101];
void calc(vecl &a, int l, int r, vecl &b, int d)
{
if (l >= r)
return;
int mx = 0, ans = 0;
loop(i, l, r)
{
mx = max(mx, a[i]);
}
loop(i, l, r)
{
if (mx == a[i])
{
ans = i; break;
}
}
b[ans] = d;
calc(a, ans + 1, r, b, d + 1);
calc(a, l, ans, b, d + 1);
}
void solve()
{
int n;
cin >> n;
vecl a(n);
loop(i, 0, n)
{
cin >> a[i];
}
//memset(t,-1, sizeof t);
int l = 0, r = n;
vecl ans(n + 1, 0);
int d = 0;
calc(a, l, r, ans, d);
loop(i, 0, n)
cout << ans[i] << " ";
}
signed main() {
io
#ifndef ONLINE_JUDGE
freopen("inputf.in", "r", stdin);
freopen("outputf.out", "w", stdout);
#endif
//calc();
test
{
solve();
cout << endl;
}
return 0;
} |
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<vector>
#include<cmath>
#include<set>
#include <cstdlib>
#include <ctime>
#include <cstdlib>
#include <numeric>
#include <queue>
using namespace std;
typedef long long ll;
#define fr first
#define sc second
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define pll pair<long long ,long long >
#define mod ((ll)1000000007)
#define inf ((ll)100000000000)
#define endl "\n"
ll mas[105];
ll p[105];
void sfb(int l,int r,int k){
int u=l;
if(l==r){
return;
}
for(int i=l;i<r;i++){
if(mas[u]<mas[i])
u=i;
}
p[u]=k;
k++;
sfb(l,u,k);
sfb(u+1,r,k);
}
int main() {
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll t,n,fl,k,a,b,c,m;
cin>>t;
while(t--){
cin>>n;
for(int i=0;i<n;i++)
cin>>mas[i];
sfb(0,n,0);
for(int i=0;i<n;i++){
cout<<p[i]<<" ";
}
cout<<endl;
}
}
|
#include <bits/stdc++.h>
typedef long long ll;
#define lp(i,n) for(ll i = 0;i < ll(n);i++)
#define rlp(i,n) for(ll i = ll(n);i >= 0;i--)
#define rg(i,a,b) for(ll i = ll(a);i <= ll(b);i++)
#define re return
#define pb push_back
#define sz(s) (ll)(s.size())
#define fx(n) fixed<<setprecision(n)
#define NeverGiveUp ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define all(c) c.begin(),c.end()
#define allr(c) c.rbegin(),c.rend()
#define F first
#define S second
/*freopen("input.txt","r", stdin);
freopen("output.txt","w", stdout);*/
using namespace std;
/*ll mx = INT_MIN;
ll mn = INT_MAX;*/
/*ll xd,dx[4]={1,0,-1,0};
ll yd,dy[4]={0,1,0,-1};
bool valid(ll xd,ll yd,ll n,ll m){return xd>-1&&xd<n&&yd>-1&&yd<m;}*/
const int sz = 2e6+5;
const ll md = 1e9+7;
//ll lcm(ll a,ll b){return a*b/__gcd(a,b);}
ll n,depth[sz];
void solve(deque<ll>&d,ll c){
if(!sz(d))re;
deque<ll>h1,h2;
ll mx=max_element(all(d))-d.begin();
depth[d[mx]]=c;
lp(i,mx)h1.pb(d[i]);
rg(i,mx+1,sz(d)-1)h2.pb(d[i]);
solve(h1,c+1);
solve(h2,c+1);
}
int main()
{
NeverGiveUp
ll t=1;
cin>>t;
while(t--){
cin>>n;
deque<ll>a(n+10);
lp(i,n)cin>>a[i];
solve(a,0);
lp(i,n)cout<<depth[a[i]]<<' ';
cout<<'\n';
}
re 0;
}
|
#include<bits/stdc++.h>
#include<cstring>
#define ll long long
#define ull unsigned long long
#define pb push_back
#define ff first
#define ss second
#define all(v) (v.begin(), v.end())
#define rall(v) (v.rbegin(), v.rend())
#define pi acos(-1.0)
#define FastRead ios_base::sync_with_stdio(0);cin.tie(0); cout.tie(0);
#define bug(a) cerr << #a << " : " << a << endl
using namespace std;
const ll mod = 1e9+7;
//const ll mx = 2e6+10;
int posx[] = {1,-1, 0, 0};
int posy[] = {0, 0, 1,-1};
int depth[2000], arr[2000];
vector<int>tree[2000];
map<ll, bool>vis;
void rec(int l, int r, int root)
{
if(l>r)return;
int mx=arr[l], pos=l;
for(int i=l; i<=r; i++){
if(mx<arr[i]){
mx=arr[i];
pos=i;
}
}
//cout << l << " " << r << " " << root << " " << mx << endl;
tree[root].pb(mx);
tree[mx].pb(root);
rec(l, pos-1, mx);
rec(pos+1, r, mx);
}
void Bfs(int src)
{
queue<ll>q;
q.push(src);
vis[src] = true;
while(!q.empty()){
int u = q.front();
q.pop();
for(auto x: tree[u]){
if(!vis[x]){
q.push(x);
depth[x]+=depth[u]+1;
vis[x] = true;
}
}
}
}
int main()
{
FastRead
#ifdef Mfc_Tanzim
freopen("input.txt","r", stdin);
// freopen("output.txt","w", stdout);
#endif /// Mfc_Tanzim
int t=1, n, k, m, a, b, c, d;
cin >> t;
while(t--){
cin >> n;
for(int i=1; i<=n; i++){
cin >> arr[i];
}
rec(1, n, 0);
Bfs(0);
for(int i=1; i<=n; i++){
cout << depth[arr[i]]-1 << " ";
}
cout << endl;
for(int i=0; i<=n; i++){
tree[i].clear();
depth[i]=0;
}
vis.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define ll long long
#define ld long double
const ll MOD=998244353;
const ll LMAX=1e18;
const ll MAX=2e5+5;
void calculate(vector<ll> &v,ll s,ll e,ll dia,vector<ll> &ans)
{
if(s>e)
{
return;
}
if(s==e)
{
ans[s]=dia;
return;
}
ll max1=-1;
ll ind=-1;
for(ll i=s;i<=e;i++)
{
max1=max(max1,v[i]);
if(max1==v[i])
{
ind=i;
}
}
ans[ind]=dia;
calculate(v,s,ind-1,dia+1,ans);
calculate(v,ind+1,e,dia+1,ans);
}
int main() {
ios_base::sync_with_stdio();
cin.tie();
cout.tie();
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
vector<ll> v(n);
vector<ll> ans(n);
for(ll i=0;i<n;i++)
{
cin>>v[i];
}
ll max1=-1;
ll ind=-1;
for(ll i=0;i<n;i++)
{
max1=max(max1,v[i]);
if(max1==v[i])
{
ind=i;
}
}
ans[ind]=0;
calculate(v,0,ind-1,1,ans);
calculate(v,ind+1,n-1,1,ans);
for(ll i=0;i<n;i++)
{
cout<<ans[i]<<" ";
}
cout<<endl;
}
return 0;
}
|
/*
author : dunk_066
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int mod=1e9+7;
#define FAST ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define all(c) c.begin(),c.end()
#define pb push_back
#define vi(a,x) vector<int>a(x)
#define vl(a,x) vector<ll>a(x)
#define ss second
#define ff first
const int N = 1e2+2;
vector<int>g[N];
void build(int u,int l,int r,vector<int>&a){
if(l < 0 || r >= a.size() || r < 0 || l >= a.size()){
return;
}
if(l == r){
g[u].pb(a[l]);
return;
}
int mxm = 0,pos = 0;
for(int i = l;i <= r;i++) {
if(a[i] > mxm) mxm = a[i],pos = i;
}
g[u].pb(mxm);
if(pos != l) build(mxm, l , pos-1, a);
if(pos != r) build(mxm, pos+1, r, a);
}
void solve(){
int n;cin>>n;
vi(a,n);int mxm = 0,pos = 0;
for(int i = 0;i < n;i++) {
cin>>a[i];
if(a[i] > mxm) mxm = a[i],pos = i;
}
if(pos != 0) build(mxm, 0 , pos-1, a);
if(pos != n-1) build(mxm, pos+1, n-1, a);
unordered_map<int,int>mp;
queue<int>q;
vi(vis,n+1);
q.push(mxm);int dist = 0;
while(!q.empty()){
int sz = (int)q.size();
for(int i = 0;i < sz;i++){
int tp = q.front();q.pop();
mp[tp] = dist;
vis[tp] = 1;
for(int v:g[tp]){
if(vis[v] == 0) q.push(v);
}
}
dist++;
}
for(int it:a) cout<<mp[it]<<' ';
cout<<'\n';
for(int i = 0;i <= n;i++) g[i].clear();
}
int main(){
FAST;
int t=1;cin>>t;
while(t--)
solve();
#ifndef ONLINE_JUDGE
cout << "\nTime Elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " sec\n";
#endif
return 0;
}
// ============== Notes =============== //
// common bugs
// - int overflow (especially intermediate expressionns)
// - array bounds (indices bigger than MAXN?)
// - special cases (n=1? graph not connected?) |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
typedef pair<string,int> psi;
typedef pair<int,string> pis;
typedef array<int,2> aii;
typedef array<int,3> aiii;
typedef array<int,4> aiiii;
typedef unsigned long long ull;
typedef long long int ll;
typedef array<ll,2> all;
typedef array<ll,3> alll;
#define pb push_back
#define ff first
#define ss second
#define MAX 100005
#define MOD 1000000007
#define INF 1e9+100
vector<int>adj[MAX];
int xMove[] = { 0,1,0,-1,1,1,-1,-1, 2, 2, -2, -2, 1, 1, -1, -1 };
int yMove[] = { 1,0,-1,0,1,-1,1,-1, 1, -1, 1, -1, 2, -2, 2, -2 };
int arr[101],ans[101];
void dfs(int lo, int hi, int d)
{
if(lo>hi)
return;
if(lo==hi)
{
ans[arr[lo]]=d;
return;
}
int mx=0,idx;
for(int i=lo;i<=hi;i++)
{
if(arr[i]>mx)
mx=arr[i],idx=i;
}
ans[arr[idx]]=d;
dfs(lo,idx-1,d+1);
dfs(idx+1,hi,d+1);
}
int main()
{
//freopen("input.in","r",stdin);
//freopen("output.txt","w",stdout);
cin.tie(0),cout.tie(0);
ios_base::sync_with_stdio(0);
cout.setf(ios::fixed);
cout.precision(10);
int TC=1;
int n,k,m,q;
cin>>TC;
for(int t1=1; t1<=TC; t1++)
{
cin>>n;
for(int i=0;i<n;i++)
cin>>arr[i];
dfs(0,n-1,0);
for(int i=0;i<n;i++)
cout<<ans[arr[i]]<<" ";
cout<<"\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#define ll long long int
#define mod 1000000007
using namespace std;
template <class T>
void read_array(vector<T> &arr, int n)
{
T x;
for (int i = 0; i < n; i++)
{
cin >> x;
arr.push_back(x);
}
}
template <class T>
void print_array(vector<T> &arr)
{
for (int i = 0; i < arr.size(); i++)
cout << arr[i] << " ";
cout << "\n";
}
template <class T>
void read_matrix(vector<vector<T>> &matrix, int r, int c)
{
T x;
for (int i = 0; i < r; i++)
{
vector<T> temp;
for (int j = 0; j < c; j++)
{
cin >> x;
temp.push_back(x);
}
matrix.push_back(temp);
}
}
template <class T>
void print_matrix(vector<vector<T>> &matrix)
{
for (int i = 0; i < matrix.size(); i++)
{
for (int j = 0; j < matrix[i].size(); j++)
{
cout << matrix[i][j] << " ";
}
cout << "\n";
}
}
template <class T, class U>
void print_pairs(vector<pair<T, U>> &arr)
{
for (int i = 0; i < arr.size(); i++)
{
cout << arr[i].first << " " << arr[i].second << "\n";
}
}
template <class T, class U>
void print_map(map<T, U> &mp)
{
for (auto i : mp)
{
cout << i.first << " " << i.second << "\n";
}
}
template <class T>
void print_set(set<T> &arr)
{
for (auto i : arr)
{
cout << i << " ";
}
cout << "\n";
}
int KMP(string s, string p)
{
int n = s.size();
int m = p.size();
vector<int> lps;
lps.push_back(0);
int i = 0, j = 1;
while (j < m)
{
if (p[j] == p[i])
{
i += 1;
j += 1;
lps.push_back(i);
}
else
{
if (i == 0)
{
lps.push_back(0);
j += 1;
}
else
i = lps[i - 1];
}
}
int cnt = 0;
i = 0;
j = 0;
while (j < n)
{
if (s[j] == p[i])
{
i += 1;
j += 1;
}
if (i == m)
{
cnt += 1;
i = lps[i - 1];
}
if ((j < n) && (s[j] != p[i]))
{
if (i == 0)
j += 1;
else
i = lps[i - 1];
}
}
return cnt;
}
bool is_odd(int num)
{
if (num & 1)
return true;
return false;
}
bool is_even(int num)
{
if (num & 1)
return false;
return true;
}
void swap(int &x, int &y)
{
int temp = x;
x = y;
y = temp;
}
ll power(ll x, ll y)
{
ll res = 1;
x %= mod;
while (y)
{
if (y & 1)
res = (res * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return res;
}
void StringTokenizer(vector<string> &tokens, string &s, char ch)
{
stringstream ss(s);
string temp;
while (getline(ss, temp, ch))
tokens.push_back(temp);
}
void build(vector<int> &arr, vector<int> &depth, int low, int high, int d)
{
//cout << low << " " << high << "\n";
if (low > high)
return;
int index = low, mx = arr[low];
for (int i = low + 1; i <= high; i++)
{
if (arr[i] > mx)
{
mx = arr[i];
index = i;
}
}
//cout << arr[index] << " " << d << "\n";
depth[arr[index]] = d;
build(arr, depth, low, index - 1, d + 1);
build(arr, depth, index + 1, high, d + 1);
return;
}
void solve()
{
//code
int n;
cin >> n;
vector<int> arr;
read_array(arr, n);
vector<int> depth(n + 1, 0);
build(arr, depth, 0, n - 1, 0);
for (int i = 0; i < n; i++)
cout << depth[arr[i]] << " ";
cout << "\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
//code
int t = 1;
cin >> t;
while (t--)
{
solve();
}
return 0;
} |
#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const int N=110;
int deep[N];
int num[N];
void dfs(int l,int r,int now,int dp)//1,5,2,0
{
if(l==r) return ;
if(l<now)
{
int tar=now-1;
for(int i=l;i<now-1;i++)
{
if(num[i]>num[tar]) tar=i;
}
deep[tar]=dp+1;
dfs(l,now-1 ,tar , dp+1);
}
if(r>now)
{
int tar=now+1;
for(int i=now+2;i<=r;i++)
{
if(num[i]>num[tar]) tar=i;
}
deep[tar]=dp+1;
dfs(now+1,r,tar,dp+1);
}
}
int main()
{
IOS
int t; cin>>t;
while(t--)
{
int n; cin>>n;
for(int i=1;i<=n;i++)
{
cin>>num[i];
}
memset(deep,0,sizeof(deep));
int tar=1;
for(int i=2;i<=n;i++)
{
if(num[i]>num[tar]) tar=i;
}
deep[tar]=0;
dfs(1,n,tar,0);
for(int i=1;i<=n;i++) cout<<deep[i]<<" ";
cout<<endl;//2222
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#define ll int64_t
#define F first
#define S second
#define pii pair<int,int>
//#define __int128_t int
int a[101];
vector <int> g[101];
int d[101];
int rec (int l, int r) {
int mx = l;
for (int i=l+1;i<=r;++i) {
if (a[mx] < a[i]) mx = i;
}
if (mx > l) {
g[mx].push_back(rec(l, mx-1));
}
if (mx < r) {
g[mx].push_back(rec(mx+1, r));
}
return mx;
}
void dfs(int v, int p) {
d[v] = d[p] + 1;
for (int i:g[v])
dfs(i, v);
}
void solve () {
int n;
cin >> n;
for (int i=0;i<n;++i) {
cin >> a[i];
g[i].clear();
d[i] = 0;
}
int root = rec(0, n-1);
d[root] = 0;
for (int i:g[root])
dfs(i, root);
for (int i=0;i<n;++i)
cout << d[i] << ' ';
cout << '\n';
}
int32_t main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
int qt;
cin >> qt;
for (;qt;--qt) {
solve();
//cout << ((solve()) ? "YES\n" : "NO\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int a[101],d[101];
int n;
void dfs(int l,int r,int depth)
{
int pos=l;
for(int i=l;i<=r;i++)if(a[pos]<a[i])pos=i;
d[pos]=depth;
if(l<=pos-1)dfs(l,pos-1,depth+1);
if(pos+1<=r)dfs(pos+1,r,depth+1);
}
int main()
{
int t;
cin>>t;
while(t--)
{
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
memset(d,0,sizeof(d));
dfs(1,n,0);
for(int i=1;i<=n;i++)cout<<d[i]<<" ";
cout<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define inf 1e16
#define ll long long
vector<int> p(105);
struct node{
int val;
node* left, *right;
node(int x){
val = x;
left = right = NULL;
}
};
vector<int> d(105);
node* build(int s, int e){
if(s>e)
return NULL;
int mx = 0, idx = -1;
for(int i=s;i<=e;i++){
if(p[i] > mx){
mx = p[i];
idx = i;
}
}
node* root = new node(idx);
root->left = build(s,idx-1);
root->right = build(idx+1,e);
return root;
}
void depth(node* root, int dep){
if(!root)
return;
d[root->val] = dep;
depth(root->left,dep+1);
depth(root->right,dep+1);
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
ll t;
cin>>t;
while(t--){
ll n;
cin>>n;
for(int i=0;i<n;i++)
cin>>p[i];
node* root = build(0,n-1);
depth(root,0);
for(int i=0;i<n;i++)
cout<<d[i]<<" ";
cout<<"\n";
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
struct node{
int val;node* left;node*right;
};
node* f(int a[],int b,int e){
if(b>e)return NULL;
if(b==e){
node* root=new node();
root->val=a[b];root->left=NULL;root->right=NULL;return root;
}
int i,m,j;m=0;for(i=b;i<=e;i++){
if(a[i]>m){m=a[i];j=i;}
}
node* root=new node();
root->val=m;root->left=NULL;root->right=NULL;
root->left=f(a,b,j-1);
root->right=f(a,j+1,e);return root;
}
int main(){
long long int i,j,n,t,x;cin>>t;
while(t--){
cin>>n;int a[n];
for(i=0;i<n;i++)cin>>a[i];
node* root=f(a,0,n-1);
queue<pair<node*,int>>q;
q.push(make_pair(root,0));map<int,int>m;
while(!q.empty()){
node* r=q.front().first;
x=q.front().second;m[r->val]=x;q.pop();
if(r->left)q.push(make_pair(r->left,x+1));
if(r->right)q.push(make_pair(r->right,x+1));
}
for(i=0;i<n;i++){
cout<<m[a[i]]<<" ";
}
cout<<endl;
}
}
|
// Jai Mata Di..
//
// @ author : Sanjit Anand (sanjit_15)
//
#include <bits/stdc++.h>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long
#define PI 3.1415926535897932384626
#define gc getchar_unlocked
#define fo(i,n) for(i=0;i<n;i++)
#define rep(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define endl "\n"
#define pb push_back
#define pf pop_front
#define ppb pop_back
#define ppf pop_front
#define mp make_pair
#define F first
#define S second
#define trav(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define ppc __builtin_popcount
#define ppcll __builtin_popcountll
template<typename T1,typename T2>istream& operator>>(istream& in,pair<T1,T2> &a){in>>a.fr>>a.sc;return in;}
template<typename T1,typename T2>ostream& operator<<(ostream& out,pair<T1,T2> a){out<<a.fr<<" "<<a.sc;return out;}
template<typename T,typename T1>T amax(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T amin(T &a,T1 b){if(b<a)a=b;return a;}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<vi> vvi;
typedef set<int> si;
typedef list<int> li;
const long long INF = 1e18;
const long long MOD = 1000000007;
const long long MM = 998244353;
const int N = 10005;
int mpow(int base, int exp, int m);
int gcd(int a, int b);
void rec(int ar[], int start, int end, int level[], int t){
if(start >= end){
level[start]=t;
return;
}
int max_element = -1*INF, max_idx = -1;
for(int i=start; i<=end; i++){
if(ar[i] > max_element){
max_element = ar[i];
max_idx = i;
}
}
// cout << max_idx << "\n";
level[max_idx]=t;
t++;
if(start <= max_idx-1){
rec(ar,start,max_idx-1,level,t);
}
if(end >= max_idx+1){
rec(ar,max_idx+1,end,level,t);
}
return;
}
void solve() {
int n;
cin >> n;
int level[n];
int ar[n];
for(int i=0; i<n; i++){
cin >> ar[i];
level[i] = 0;
}
rec(ar,0,n-1,level,0);
for(int i=0; i<n; i++){
cout << level[i] << " ";
}
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#ifdef NCR
pmain();
#endif
#ifdef SIEVE
sieve();
#endif
int t = 1;
cin >> t;
while(t--) {
solve();
}
return 0;
}
int gcd(int a, int b){
return b==0 ? a : gcd(b,a%b);
}
int mpow(int base, int exp, int m=MOD) {
base %= m;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % m;
base = ((long long)base * base) % m;
exp >>= 1;
}
return result;
} |
#include<bits/stdc++.h>
#include<algorithm>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define repb(i,a,b) for(ll i=a;i>=b;i--)
#define err() cout<<"=================================="<<endl;
#define errA(A) for(auto i:A) cout<<i<<" ";cout<<endl;
#define err1(a) cout<<#a<<" "<<a<<endl
#define err2(a,b) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<endl
#define err3(a,b,c) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<" "<<#c<<" "<<c<<endl
#define err4(a,b,c,d) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<" "<<#c<<" "<<c<<" "<<#d<<" "<<d<<endl
#define pb push_back
#define all(A) A.begin(),A.end()
#define allr(A) A.rbegin(),A.rend()
#define ft first
#define sd second
#define pll pair<ll,ll>
#define V vector<ll>
#define S set<ll>
#define VV vector<V>
#define Vpll vector<pll>
#define VVpll vector<Vpll>
#define endl "\n"
const ll logN = 20;
const ll N=100005;
const ll M = 1000000007;
const ll M2=998244353 ;
const ll INF = 1e12;
#define PI 3.14159265
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
ll pow1(ll a,ll b){
ll res=1;
while(b>0){
if(b&1){
res=(res*a)%M;
}
a=(a*a)%M;
b>>=1;
}
return res%M;
}
map<ll,ll>mp;
V a;
ll n;
void recur(ll depth,ll ind1=0, ll ind2=n-1 )
{
if(ind1>ind2)return;
ll mx_ind;
ll mx=LLONG_MIN;
rep(i,ind1,ind2+1)
{
if(a[i]>mx)
{
mx=a[i];
mx_ind=i;
}
}
mp[mx_ind]=depth;
recur(depth+1,ind1,mx_ind-1);
recur(depth+1,mx_ind+1,ind2);
return;
}
int main()
{
fast;
#ifndef ONLINE_JUDGE
freopen("../input.txt", "r", stdin);
freopen("../output.txt", "w", stdout);
#endif
ll T=1;
cin>>T;
while(T--)
{
cin>>n;
a=V(n);
rep(i,0,n)cin>>a[i];
recur(0);
for(auto it:mp)
cout<<it.sd<<" ";
cout<<endl;
mp.clear();
}
} |
//
// main.cpp
// Problem Solving
//
// Created by Murad Al Wajed on 11/2/21.
//
#include<cstdio>
#include<iostream>
#include<vector>
#include<map>
#include<stack>
#include<queue>
#include<bitset>
#include<list>
#include<iomanip>
#include<string>
#include<climits>
#include<sstream>
#include<fstream>
#include<cctype>
#include<time.h>
#include<assert.h>
#include<set>
#include<numeric>
#include<functional>
#include<cstring>
#include<cmath>
#include<iterator>
#include<memory.h>
#include<utility>
#include<ctime>
#include<algorithm>
#define ll long long
#define dbl double
#define vl vector<ll>
#define sf(zz) scanf("%I64d",&zz)
#define sf2(zz,zzz) scanf("%I64d %I64d",&zz,&zzz)
#define sf3(zz,zzz,zzzz) scanf("%I64d %I64d %I64d",&zz,&zzz,&zzzz)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
#define reset(a,d) memset(a,d,sizeof(a))
#define pb(a,b) a.push_back(b)
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define min4(a,b,c,d) min(min(a,b),min(c,d))
#define max4(a,b,c,d) max(max(a,b),max(c,d))
#define DIST(x1,y1, x2, y2) (((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)))
#define DIST3D(x1,x2, y1, y2, z1, z2) (((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)) + ((z1-z2)*(z1-z2)))
#define ALL(x) (x).begin(),(x).end()
#define LLA(x) x.rbegin(), x.rend()
#define SORT(v) sort(ALL(v))
#define inf 1e15
#define PI acos(-1.0)
std::string sss="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
//-----------------------------------------------------------//
using namespace std;
ll arr[100+10], dep[100+10];
void dp(ll l, ll r, ll cnt){
if(l>r)return;
ll mx=0,mxind=l;
for(int i=l;i<=r;i++){
if (arr[i] > mx){
mx = arr[i];
mxind = i;
}
}
dep[mxind] = cnt;
dp(l, mxind-1, cnt+1);
dp(mxind+1,r, cnt+1);
}
void CASE(){
// cout<<"hm\n";
ll n,i,j;
cin>>n;
reset(arr,0);
reset(dep,0);
for(i=0;i<n;i++){
cin>>arr[i];
}
dp(0,n-1,0);
for(i=0;i<n;i++){
cout<<dep[i]<<" ";
}
cout<<"\n";
}
int main(){
int t = 1;
cin>>t;
for(int i=0;i<t;i++)CASE();
}
|
#include <iostream>
#include <vector>
#include <queue>
#define ll long long
#define pii pair<long long, long long >
#define st first
#define nd second
using namespace std;
struct node
{
ll l, r, root;
};
int main()
{
long long t;
cin >> t;
while (t--)
{
ll n;
cin >> n;
ll a[n];
ll st[n+1];
for (int i=0;i<n;i++)
{
st[i]=0;
cin >> a[i];
}
st[n]=0;
queue <node> q;
q.push({0,n-1,0});
while (q.size())
{
ll l = q.front().l,r=q.front().r,root = q.front().root;
q.pop();
if (l>r) continue;
ll maxx = 0 ,tmproot=0;
for (int i=l;i<=r;i++)
{
if (a[i] >= maxx)
{
maxx= a[i];
tmproot=i;
}
}
st[tmproot] = root + 1;
q.push({l,tmproot-1,root+1});
q.push({tmproot+1,r,root+1});
}
for (int i=0;i<n;i++)
cout << st[i]-1 << " " ;
cout << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 2e5+10;
const ll inf = 1e18+10;
const ll MOD = 1e9+7;
int d[N], a[N];
void f(int l, int r, int curr) {
//printf("here %d %d\n", l, r);
if(l > r) return;
int here = 0, ind=-1;
for(int i = l; i <= r; i++) {
if(a[i] > here) {
ind = i;
here = a[i];
}
}
d[here] = curr;
if(l <= ind-1)f(l, ind-1, curr+1);
if(ind+1 <= r)f(ind+1, r, curr+1);
return;
}
int main() {
/*freopen("breedflip.in", "r", stdin);
freopen("breedflip.out", "w", stdout);
*/
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
for(int i = 1; i <= n; i++)cin >> a[i];
f(1, n, 0);
for(int i = 1; i <= n; i++) printf("%d ", d[a[i]]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define maxn 105
int a[maxn];
int f[maxn][maxn];
int ds[maxn];
int nho[maxn];
void DFS(int dau,int cuoi,int cnt){
int val=f[dau][cuoi];
int here=nho[val];
ds[val]=cnt+1;
if(here>dau) DFS(dau,here-1,cnt+1);
if(here<cuoi) DFS(here+1,cuoi,cnt+1);
}
int main(){
int T;
scanf("%d",&T);
for(int k=1;k<=T;++k){
int n;
scanf("%d",&n);
for(int i=1;i<=n;++i)
scanf("%d",&a[i]);
for(int i=1;i<=n;++i)
nho[a[i]]=i;
for(int i=1;i<=n;++i){
f[i][i]=a[i];
for(int j=i-1;j>=1;--j){
f[j][i]=max(f[j+1][i],a[j]);
}
}
DFS(1,n,-1);
for(int i=1;i<=n;++i)
printf("%d ",ds[a[i]]);
printf("\n");
for(int i=1;i<=n;++i)
nho[i]=0;
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
f[i][j]=0;
}
}
|
#include <iostream>
#include <bits/stdc++.h>
#define inf 1000000007
#define ll long long
#define fr first
#define sc second
using namespace std;
//fast I/O
auto optimizer = []() { // makes I/O fast
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
return 0;
}();
//power mode where (x^y) % p is calculated in log (y) time
int power(ll x, ll y, ll 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;
}
//Code -
void func(vector<ll>& vect, vector<ll>& pos, ll s, ll e, ll depth){
if(s > e || s > vect.size()-1 || e < 0){
return;
}
ll index = s;
ll prev = vect[s];
for(ll i = s+1; i <= e; i++){
if(vect[i] > prev){
index = i;
prev = vect[i];
}
}
pos[index] = depth;
func(vect,pos,s,index-1,depth+1);
func(vect,pos,index+1,e,depth+1);
}
int main() {
ll n,i,j,t,m,temp;
cin >> t;
for(i = 0; i < t; i++){
cin >> n;
vector<ll> vect;
for(j = 0; j < n; j++){
cin >> temp;
vect.push_back(temp);
}
vector<ll> pos(n,0);
func(vect,pos,0,n-1,0);
for(j = 0; j < n; j++){
cout << pos[j] << " ";
}
cout << endl;
}
return 0;
} |
#include<iostream>
#include<vector>
using namespace std;
void max(vector<int>v,int b,int e,int dp,int d[]){
if(b>e) return;
if(b==e) { d[e]=dp; return;}
int m = b;
for(int i=b;i<=e;i++){
if(v[i]>v[m])m =i;
}
d[m] = dp;
max(v,b,m-1,dp+1,d); max(v,m+1,e,dp+1,d);
}
int main(){
int o,n,x;
cin >> o;
while(o--){
vector<int> v; int d[101] = {0}; cin>>n;
while(n--){
cin>>x;
v.push_back(x);
}
max(v,0,v.size()-1,0,d);
for(int i = 0;i<v.size();i++){
cout << d[i] << " ";
}
cout << endl;
}
} |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
#define mod 1000000007
#define setbits(x) __builtin_popcountll(x)
#define pii pair<long long int,long long int>
#define setp(x,y) fixed<<setprecision(y)<<x
#define print(ar,n); for(ll int i=0;i<n;i++) cout<<ar[i]<<" ";
#define take_array(ar,n) for(ll int i=0;i<n;i++) cin>>ar[i];
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cerr.tie(0);
using namespace std;
bool prime[1000005];
void sieve(){
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=1000005; p++){
if (prime[p] == true) {
for (int i=p*p; i<=1000005; i += p)
prime[i] = false;
}
}
}
string toLower(string s){
for(int i=0;i<s.size();i++)
if(s[i]>='A' && s[i]<='Z') s[i]=s[i]+32;
return s;
}
map<int,int> mp;
void calC(int ar[],int low,int high,int dep,int n){
if(low>high) return;
int mx=INT_MIN,index=-1;
for(int i=low;i<=high;i++){
if(ar[i]>mx){
mx=ar[i];
index=i;
}
}
if(mp.find(index)==mp.end()) mp[index]=dep;
else return;
calC(ar,low,index-1,dep+1,n);
calC(ar,index+1,high,dep+1,n);
}
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
#endif
int t;
cin>>t;
while(t--){
mp.clear();
int n;
cin>>n;
int ar[n],i;
for(i=0;i<n;i++){
cin>>ar[i];
}
int dep=0;
calC(ar,0,n-1,dep,n);
for(map<int,int>::iterator i=mp.begin();i!=mp.end();i++){
cout<<i->second<<" ";
}
cout<<"\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define MemeSet ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl '\n'
#define ll long long
const int N = 105;
int arr[N], ans[N], n;
void solve(int l, int r, int d){
if(r < l) return;
int mxI, mx = 0;
for(int i = l; i <= r; i++){
if(arr[i] > mx){
mx = arr[i];
mxI = i;
}
}
ans[mxI] = d;
solve(l, mxI - 1, d + 1);
solve(mxI + 1, r, d + 1);
}
int main() {
MemeSet
int t;
cin >> t;
while(t--){
cin >> n;
for(int i = 0; i < n; i++) cin >> arr[i];
solve(0, n - 1, 0);
for(int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
} |
#include<bits/stdc++.h>
#define f first
#define s second
#define _ ios::sync_with_stdio(0);cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX = 1e5+10;
const int MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
pair<int,int> seg[2*110];
int n;
vector<int> v;
vector<int> dp;
void build(){
for(int i = 0; i < n; i++) seg[n+i] = {v[i], i};
for(int i = n-1; i >= 0; i--)
seg[i] = seg[i*2].f >= seg[i*2+1].f ? seg[i*2] : seg[i*2+1];
}
pair<int,int> query(int a, int b){
pair<int,int> ret = {-1, -1};
for(a += n, b += n; a <= b; ++a /= 2, --b /= 2){
if (a % 2 == 1) ret = (ret.f >= seg[a].f ? ret : seg[a]);
if (b % 2 == 0) ret = (ret.f >= seg[b].f ? ret : seg[b]);
}
return ret;
}
void get_dp(int l, int r, int dpt=0){
if(l > r) return;
pair<int,int> mx = query(l, r);
dp[mx.s] = dpt;
get_dp(mx.s+1, r, dpt+1);
get_dp(l, mx.s-1, dpt+1);
}
void solve(){
cin >> n;
v = vector<int>(n);
dp = vector<int>(n);
for(int &x: v)
cin >> x;
build();
get_dp(0, n-1);
for(int i = 0; i < n; i++){
if(i) cout << " " ;
cout << dp[i];
}
cout << endl;
}
int main(){_
int t = 1;
cin >> t;
while(t--)
solve();
}
|
#include<bits/stdc++.h>
using namespace std;
#define e "\n"
#define ll long long
#define fio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define mod 1000000007
int ans[105],b;
void fun(vector<int>arr,int i,int n, int c)
{
//cout << i << " " << n << " " << c << e;
if(i >= n)
return;
if(i == n-1)
{
ans[i] = c;
return;
}
int k,mx = arr[i];
for(k=i+1;k<n;k++)
{
if(arr[k] > mx)
mx = arr[k];
}
for(k=i;k<n;k++)
{
if(arr[k] == mx)
{
ans[k] = c;
//cout << "k " << k << " " <<arr[k] << " " << ans[k] << e;
break;
}
}
fun(arr,k+1,n,c+1);
fun(arr,i,k,c+1);
}
int main()
{
int t;
fio;
t = 1;
cin >> t;
while(t--)
{
memset(ans,0,sizeof(ans));
int n;
cin >> n;
int a,i;
vector<int>arr;
for(i=0;i<n;i++)
{
cin >> a;
arr.push_back(a);
}
int c = 0;
fun(arr,0,n,c);
for(i=0;i<n;i++)
{
cout << ans[i] << " ";
}
cout << e;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define IO ios_base::sync_with_stdio(false); cin.tie(NULL);
#define endl '\n'
int main() { IO;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (auto& x : v) { cin >> x; }
map<int, int> d;
d[-1] = -1;
d[n + 1] = -1;
for (int i = n; i > 0; --i) {
const int index = distance(v.begin(), find(v.begin(), v.end(), i));
auto it = d.lower_bound(index);
auto right = it->second;
advance(it, -1);
auto left = it->second;
d[index] = max(right, left) + 1;
}
for (int i = 0; i < n; ++i) {
if (i) { cout << " "; }
cout << d[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
#define sei set<int>
#define sell set<ll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(), v.end()
#define all_(v) v.rbegin(), v.rend()
#define foa(i, v) for (auto i : v)
#define fo(i, a, b) for (int i = a; i < b; i++)
#define fo_(i, a, b) for (int i = a; i >= b; i--)
#define tt \
ll t; \
cin >> t; \
while (t--)
#define M1(a) memset(a, 0, sizeof a)
#define M_(a) memset(a, -1, sizeof a)
#define deb(x) cerr << #x << " = " << x << endl
#define pb push_back
#define fi first
#define se second
#define N 1000005
#define M 1000000007
#define OK order_of_key
#define FO find_by_order
#define nmax 1000100
#define bolt \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
/*/-----------------------------MODULAR ARITHMETIC----------------------------------/*/
inline ll add(ll x, ll y, ll mod) {
x += y;
if (x >= mod) return x - mod;
return x % mod;
}
inline ll sub(ll x, ll y, ll mod) {
x -= y;
if (x < 0) return x + mod;
return x;
}
inline ll mul(ll x, ll y, ll mod) {
return (x * 1ll * y) % mod;
}
inline ll expo(ll x, ll y, ll mod) {
ll ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x, mod);
x = mul(x, x, mod);
y >>= 1;
}
return ans % mod;
}
inline ll inv(ll x, ll mod) {
return expo(x, mod - 2, mod);
}
/*/-----------------------------INLINE FUNCTIONS----------------------------------/*/
inline ll gcd(ll a, ll b) {if (b == 0) return a; return gcd(b, a % b);}
inline ll lcm(ll a, ll b) {return (a / gcd(a, b) * b);}
inline bool prime(ll n) {ll i; for (i = 2; i <= sqrt(n); i++) {if (n % i == 0)return false;} return true;}
inline ll ceil(ll num, ll den) {return ((num + den - 1) / den);}
//Prime Numbers
vector<bool> p(N + 1, true);
void sieve(){
ll i, j, k;
p[0] = p[1] = false;
for (i = 2; i * i <= N; i++)
if (p[i])
for (j = i * i; j <= N; j++)
p[j] = false;
}
/*/-----------------------------Exponentiation----------------------------------/*/
ll power(ll a, ll b)
{
ll r = 1;
while (b)
{
if (b % 2 == 1)
r = r * a;
b /= 2;
a *= a;
}
return r;
}
ll power(ll a, ll b, ll m)
{
a = a % m;
ll r = 1;
while (b)
{
if (b % 2 == 1)
r = (r * a) % m;
b /= 2;
a = (a * a) % m;
}
return r;
}
// 1 2 1 , 1 2 1 3 1 2 1, 1 2 1 3 1 2 1 4 1 2 1 3 1 2 1 ...
ll Power(ll a, ll b)
{
if (b == 0)
return 1;
else if (b % 2 == 0)
return power(a * a, b / 2);
else
return a * power(a, b - 1);
}
//Prime Factors
vector<ll> factors(ll n)
{
vector<ll> r;
ll i, j;
for (i = 1; i * i <= n; i++)
{
if (n % i == 0)
{
r.push_back(i);
if (n / i != i)
r.push_back(n / i);
}
}
return r;
}
bool sortbysec(const pair<ll, ll> &a, const pair<ll, ll> &b) { return (a.second < b.second); }
vi ans(1000),v(10000);
void fun(int l, int r, int d){
if(l>r)return;
int te = l;
fo(i,l,r+1)
if(v[i]>v[te]) te = i;
ans[te]=d;
fun(l,te-1,d+1);
fun(te+1,r,d+1);
return;
}
int main()
{
bolt;
tt
{
ll n;
cin>>n;
fo(i,0,n)
cin>>v[i];
fun(0,n-1,0);
fo(i,0,n)
cout<<ans[i]<<' ';
cout<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int int64_t
vector<int> A, D;
void calcDepth(int left, int right, int depth) {
int idx = max_element(A.begin()+left, A.begin()+right+1) - A.begin();
D[idx] = depth;
if (left <= idx-1) calcDepth(left, idx-1, depth+1);
if (idx+1 <= right) calcDepth(idx+1, right, depth+1);
return;
}
void solve() {
int N; cin >> N;
A.clear(); A.resize(N); for (auto &x : A) cin >> x;
D.clear(); D.resize(N);
calcDepth(0, N-1, 0);
for (auto x : D) cout << x << " "; cout << endl;
return;
}
signed main() {
ios_base::sync_with_stdio(false); cin.tie(nullptr);
int T; cin >> T; for (int t = 1; t <= T; ++t) solve();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
void solve(int& n, int *a, int *ans, int l, int r, int level) {
if(l>r) return;
int mxIdx = l;
for(int i=l; i<=r; i++) {
if(a[mxIdx] < a[i]) {
mxIdx = i;
}
}
ans[mxIdx] = level;
solve(n, a, ans, l, mxIdx-1, level+1);
solve(n, a, ans, mxIdx+1, r, level+1);
}
int32_t main() {
int t; cin >> t;
while(t--) {
int n; cin >> n;
int a[n]; for(int i=0; i<n; i++) cin >> a[i];
int ans[n];
solve(n, a, ans, 0, n-1, 0);
for(int i=0; i<n; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <array>
#include <algorithm>
#include <utility>
#include <map>
#include <queue>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
#define ll long long
#define ld long double
#define eps 1e-8
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
// change if necessary
#define MAXN 1000000
using namespace std;
void solve() {
int n; cin >> n;
vector<int> nums(n);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
for (int i = 0; i < n; i++) {
int ans = 0;
// before
int cur_max = 0;
for (int j = i; j >= 0; j--) {
if (nums[j] > cur_max) {
ans++;
cur_max = nums[j];
}
}
// after
cur_max = 0;
for (int j = i; j < n; j++) {
if (nums[j] > cur_max) {
ans++;
cur_max = nums[j];
}
}
cout << ans - 2 << ' ';
}
cout << '\n';
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int t; cin >> t;
while (t--) solve();
return 0;
}
|
/*#include <bits/stdc++.h>
# define ll long long
using namespace std;
int main()
{
vector<int>v={1,2,3,4,5};
int k=*max_element(v.begin()+0,v.begin()+2);
cout<<k;
return 0;
}*/
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,x;
cin>>n;
vector<int>v;
unordered_map<int,int>u;
for(int i=0;i<n;i++)
{
cin>>x;
v.push_back(x);
u[x]=i;
}
int k,s,e,c,p,maa;
for(int i=0;i<n;i++)
{
k=u[v[i]];
s=0,e=n-1,c=0;
while(s<=e)
{
maa=*max_element(v.begin()+s,v.begin()+e+1);
p=u[maa];
if(k==p)
break;
if(k<p)
e=p-1;
else
s=p+1;
c+=1;
}
cout<<c<<" ";
}
cout<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node {
ll val;
node *left;
node *right;
node(ll x) : val(x), left(NULL), right(NULL) {}
};
void level_order(node *root,ll arr[],ll n)
{
unordered_map<ll,ll> mp;
queue<node*> q;
q.push(root);
ll level=0;
while(!q.empty())
{
ll size=q.size();
while(size--)
{
node *n = q.front();
mp[n->val]=level;
//cout<<n->val<<" ";
q.pop();
if (n->left)
q.push(n->left);
if (n->right)
q.push(n->right);
}
level++;
}
for(ll i=0;i<n;i++)
cout<<mp[arr[i]]<<" ";
cout<<endl;
}
node* make_tree(ll arr[],ll st,ll en)
{
if(st>en)
return NULL;
ll ma=INT_MIN;
ll mi;
for(ll i=st;i<=en;i++)
{
if(ma<arr[i])
{
ma=arr[i];
mi=i;
}
}
node* root=new node(ma);
root->left=make_tree(arr,st,mi-1);
root->right=make_tree(arr,mi+1,en);
return root;
}
void preorder(node* root)
{
if(root)
return ;
cout<<root->val<<" ";
preorder(root->left);
preorder(root->right);
}
void solve(void)
{
unordered_map<ll,ll> mp;
ll n;
cin>>n;
ll arr[n];
for(ll i=0;i<n;i++)
{
cin>>arr[i];
mp[arr[i]]=i;
}
node* root=make_tree(arr,0,n-1);
level_order(make_tree(arr,0,n-1),arr,n);
}
int main()
{
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
//cout.precision(10);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t=1;
cin>>t;
while(t--)
solve();
return 0;
}
|
/**
* author: Dragon_hao
* created Tue Feb 16 23:14:09 2021
**/
#include<bits/stdc++.h>
#define N 201
using namespace std;
int n, a[N], v[N], d[N];
int tree[4 * N];
void pushup(int i){
tree[i] = max(tree[i << 1], tree[i << 1 | 1]);
}
void build(int i,int l,int r)
{
if(l == r) {
tree[i] = a[l];
return;
}
int mid= (l +r)/2;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
pushup(i);
}
int query(int i,int l,int r,int x,int y)
{
if(x <= l && r <= y) return tree[i];
int maxm = 0;
int mid = (l + r) / 2;
if(x <= mid) maxm = max(maxm ,query(i << 1 ,l, mid ,x ,y));
if(y > mid) maxm = max(maxm ,query(i << 1 | 1, mid + 1, r, x, y));
return maxm;
}
void find(int x, int y, int deep) {
if(x > y) return;
int tmp = query(1, 1, n, x, y);
d[v[tmp]] = deep;
find(x, v[tmp] - 1, deep + 1);
find(v[tmp] + 1, y, deep + 1);
}
int main()
{
int T;
cin >> T;
while(T--){
scanf("%d", &n);
for(int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[a[i]] = i;
}
build(1, 1, n);
find(1, n, 0);
for(int i = 1; i <= n; i++) printf("%d ", d[i]);
printf("\n");
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
#define whatis(x) cout << #x << " is " << x;
#define whatisl(x) cout << #x << " is " << x<<"\n";
#define testcase ll tt; cin >> tt; while(tt--)
#define testcase1 ll tt; tt=1; while(tt--)
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);
#define pb push_back
#define vars ll i,j,k,x,y,z,a,b,c,var,n,m,sum=0,ind1=0,ind2=0,ans=0,flag=0,limit1=0,limit2=0,limit3=0;
#define vll vector<ll>
#define pll pair<ll,ll>
#define sll set<ll>
#define pint pair<int,int>
#define f(i,n) for(i=0;i<n;i++)
#define all(a) (a).begin(), (a).end()
#define mk(i,j) make_pair(i,j)
#define cir(n,arr) cin>>n; ll arr[n];f(i,n){cin>>arr[i];}
#define cor(n,arr) f(i,n){cout<<arr[i]<<" ";}cout<<endl;
#define cik(n,k,arr) cin>>n>>k;ll arr[n];f(i,n){cin>>arr[i];}
#define suffix(n,arr,suff) ll suff[n],summation1=0; for(i=n-1;i>=0;i++){summation1+=arr[i];suff[i]=summation1;}
#define prefix(n,arr,pref) ll pref[n],summation=0; f(i,n){summation+=arr[i];pref[i]=summation;}
#define yes cout<<"YES"<<endl;
#define no cout<<"NO"<<endl;
#define pr(x) cout<<x<<endl;
#define prs(x) cout<<x<<" ";
ll inf = 1e18;
ll mod = 1e9 + 7;
void solve(ll arr[],ll n, ll l, ll r, ll curr, ll brr[])
{
if(l>r)
{
return;
}
ll i,j,k,maxi=-1;
for(i=l;i<=r;i++)
{
if(arr[i]>maxi)
{
maxi=arr[i];
j=i;
}
}
brr[j]=curr;
solve(arr,n,l,j-1,curr+1,brr);
solve(arr,n,j+1,r,curr+1,brr);
}
void jack()
{
vars
cir(n,arr)
ll curr=0;
ll brr[n];
f(i,n)
{
brr[i]=-1;
}
solve(arr,n,0,n-1,curr,brr);
cor(n,brr)
}
int main()
{
boost vars
/*#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif*/
testcase
{
jack();
}
} |
#include<iostream>
#include<vector>
#include<map>
#include<string>
#define ll long long
using namespace std;
void anss(vector<int> arr,int l,int r,int d,vector<int>&ansarr){
int max_ind = -1;
int max = -89;
for(int i = l;i<=r;i++){
if(arr[i]>max){max = arr[i];max_ind=i;}
}
int p = max_ind;
int lll = p-1;
int rr=p+1;
ansarr[max_ind]=d;
d++;
if(lll>=l){
anss(arr,l,lll,d,ansarr);
}
if(rr<=r){
anss(arr,rr,r,d,ansarr);
}
}
int main(){
int t ;
cin>>t;
// t = 1;
map<ll,ll>arr;
ll y= 1000000000000;
for(ll i = 1;i*i*i<=y;i++){
// arr.push_back(i*i*i);
arr[i*i*i]=0;
}
while(t--){
int n;
cin>>n;
vector<int>arr;
vector<int>ansarr;
for(int i = 0;i<n;i++){
int a;cin>>a;arr.push_back(a);
ansarr.push_back(-1);
}
int d = 0;
anss(arr,0,n-1,d,ansarr);
for(int i = 0;i<n;i++){
cout<<ansarr[i]<<" ";
}cout<<endl;
// cout<<ans<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int t, n;
int a[105];
map<int, int> mp;
void dfs(int left, int right, int dep)
{
if(left < 0 || right < 0 || left > n || right > n || left > right) return ;
int Max = INT_MIN;
int index = left;
for(int i = left; i <= right; i++)
{
if(a[i] > Max) Max = a[i], index = i;
}
mp[index] = dep;
if(left == right) return ;
else
{
dfs(left, index - 1, dep + 1);
dfs(index + 1, right, dep + 1);
}
}
int main()
{
scanf("%d", &t);
while(t--)
{
scanf("%d", &n);
for(int i = 0; i < n; i++) scanf("%d", &a[i]);
mp.clear();
int left = 0, right = n - 1;
dfs(left, right, 0);
for(int i = 0; i < n ; i++)
{
if(i != n - 1) printf("%d ", mp[i]);
else printf("%d\n", mp[i]);
}
}
// system("pause");
} |
#include <bits/stdc++.h>
using namespace std;
#define TC 1
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define deb(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using ll = long long;
void init() {
;
}
struct Node {
int val;
Node *left, *right;
Node(int x) : val(x), left(NULL), right(NULL) {
}
};
Node* build(vector<int>& v, int l, int r) {
if (l > r) return NULL;
if (l == r) {
return new Node(v[l]);
}
int max_index = l, max_value = v[l];
for (int i=l+1; i<=r; i++) {
if (v[i] > max_value) {
max_value = v[i];
max_index = i;
}
}
Node* root = new Node(max_value);
root->left = build(v, l, max_index-1);
root->right = build(v, max_index+1, r);
return root;
}
void populateDepth(Node* root, vector<int>& res, int d=0) {
if (!root)
return;
res[root->val] = d;
populateDepth(root->left, res, d+1);
populateDepth(root->right, res, d+1);
}
void solve() {
int n; cin >> n;
vector <int> v(n);
for (auto &it : v)
cin >> it;
Node* root = build(v, 0, n-1);
vector<int> depth(n+1);
populateDepth(root, depth);
for (int i=0; i<n; i++)
cout << depth[v[i]] <<" ";
cout << "\n";
}
int main() {
IOS
init();
int t = 1;
if (TC)
cin >> t;
while (t--) {
solve();
}
}
|
#include<bits/stdc++.h>
using namespace std;
struct Node{
int val;
int index;
int li;
int ri;
};
bool s(Node& n1,Node& n2){
return (n2.val>n1.val);
}
Node * root = NULL;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t; cin >> t;
while(t--){
int n; cin >> n;
int depth[n];
for(int i=0;i<n;i++){
depth[i] =0;
}
vector<Node>a(n);
for(int i=0;i<n;i++){
cin >> a[i].val;
a[i].index = i;
a[i].li = 0;
a[i].ri =0;
}
sort(a.begin(),a.end(),s);
for(int i=n-1;i>=0;i--){
if(i==(n-1)){
depth[a[i].index] = 0;continue;
}
int c = n-1;
while(1){
int d;
if(a[i].index > a[c].index){
d= a[c].ri;
if(d==0){
a[c].ri = i; depth[a[i].index] = depth[a[c].index]+1; break;
}
else{
c = d;
}
}
else{
d =a[c].li;
if(d==0){
a[c].li = i;depth[a[i].index] = depth[a[c].index]+1; break;;
}
else{
c=d;
}
}
}
}
for(int i=0;i<n;i++){
cout << depth[i] << " ";
}
cout << "\n";
}
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define LL long long
#define N 200
#define INF 0x3f3f3f3f
using namespace std;
int T,n,a[N],sum = 0,ans[N],tag,maxx,xu[N];
struct node
{
int l,r,val;
}t[N*4];
void build(int p,int l,int r)
{
t[p].l = l,t[p].r = r;
int ls = p<<1,rs = (p<<1)|1,mid = (l+r)>>1;
if( l!=r )
{
build(ls,l,mid);
build(rs,mid+1,r);
t[p].val = max( t[ls].val , t[rs].val );
}
else t[p].val = a[l];
}
int check(int p,int l,int r)
{
int ls = p<<1,rs = p<<1|1,mid = (t[p].l+t[p].r)>>1;
if( l==t[p].l && r==t[p].r ) return t[p].val;
if( r<=mid ) return check(ls,l,r);
else if( l>mid ) return check(rs,l,r);
else return max( check(ls,l,mid) , check(rs,mid+1,r) );
}
void work(int p,int h,int l,int r)
{
int pos;
ans[p] = h;
if( l==r ) return ;
if( l<p )
{
pos = check(1,l,p-1);
pos = xu[ pos ];
work(pos,h+1,l,p-1);
}
if( r>p )
{
pos = check(1,p+1,r);
pos = xu[ pos ];
work(pos,h+1,p+1,r);
}
return ;
}
int main()
{
// freopen("in.txt","r",stdin);
cin>>T;
while(T--)
{
memset(xu,0,sizeof(xu));
memset(ans,0,sizeof(ans));
memset(t,0,sizeof(t));
maxx = -1;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
xu[ a[i] ] = i;
if( a[i]>maxx )
{
tag = i;
maxx = a[i];
}
}
build(1,1,n);
work(tag,0,1,n);
for(int i=1;i<=n;i++) printf("%d ",ans[i]);
cout<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
#define endl "\n"
using ll = long long;
using namespace std;
ll arr[103];
ll ans[103];
void recurse_fill(ll l, ll r, ll d){
if(l > r){
return;
}
ll posm, mx;
mx = -1;
for(ll i = l; i <= r; ++i){
if(arr[i] > mx){
mx = arr[i];
posm = i;
}
}
ans[posm] = d;
recurse_fill(l, posm-1, d+1);
recurse_fill(posm+1, r, d+1);
}
void solve(){
ll n;
cin >> n;
for(ll i = 0; i < n; ++i){
ll x;
cin >> x;
arr[i] = x;
}
recurse_fill(0, n-1, 0);
for(ll i = 0; i < n; ++i){
cout << ans[i] << ' ';
}
cout << endl;
}
int main(){
ll t;
cin >> t;
while(t--){
solve();
}
} |
#include<stdio.h>
int s[10010],ss[10010];
void didi(int l,int r,int d)
{
if(l>r)
return ;
int max1=l;
for(int i=l; i<=r; i++)
{
if(s[i]>s[max1])
max1=i;
}
ss[max1]=d;
didi(l,max1-1,d+1);
didi(max1+1,r,d+1);
}
int main()
{
int a;
scanf("%d",&a);
while(a--)
{
int x;
scanf("%d",&x);
for(int i=0; i<x; i++)
scanf("%d",&s[i]);
didi(0,x-1,0);
for(int i=0; i<x; i++)
printf("%d ",ss[i]);
printf("\n");
}
}
|
#include <iostream>
#include <bits/stdc++.h>
#define Momen83 ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define ld long double
#define endll '\n'
#define sz(a) (int)(a).size()
#define File freopen("string.in.txt","r",stdin); freopen("string.out.txt","w",stdout);
#define fl(i,a,b) for(int i=a;i<b;i++)
const int Mod =1e9+7 , N=1e5+1;
using namespace std;
int a[101],n,dep[101];
int cal_max(int a[],int s,int e)
{
int mx=0,mxi=0;
for(int i=s;i<=e;i++)
{
if(mx<a[i]){mx=a[i];mxi=i;}
}
return mxi;
}
void solve(int s,int e,int d)
{
if(s>e){return;}
int index= cal_max(a,s,e);
dep[index]=d;
solve(s,index-1,d+1);
solve(index+1,e,d+1);
}
int main()
{
Momen83;
int tc;cin>>tc;
while(tc--)
{
memset(dep,-1,sizeof dep);
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
solve(0,n-1,0);
for(int i=0;i<n;i++)
{
cout<<dep[i]<<" ";
}
}
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdlib>
using namespace std;
int n,m;
int a[1005];
struct node{
int to,next;
}tr[1005];
int head[1005],tot;
void add(int u,int v)
{
tr[tot].to=v;
tr[tot].next=head[u];
head[u]=tot++;
}
int dv[1005];
int solve(int l,int r)
{
int root,lt,rt;
if(l==r)
return r;
if(l>r)
return -1;
for(int i=l;i<=r;i++)
if(a[i]==*max_element(a+l,a+1+r))
{
root=i;
break;
}
lt=solve(l,root-1),rt=solve(root+1,r);
if(lt!=-1) add(root,lt);
if(rt!=-1) add(root,rt);
return root;
}
void find(int u,int tmp)
{
dv[u]=tmp;
if(head[u]==-1)
return;
int nextu;
for(int i=head[u];~i;i=tr[i].next)
{
nextu=tr[i].to;
find(nextu,tmp+1);
}
}
int main()
{
int T;
cin>>T;
while(T--)
{
int root;
tot=0;
memset(head,-1,sizeof head);
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
solve(1,n);
for(int i=1;i<=n;i++)
if(a[i]==n)
root=i;
find(root,0);
for(int i=1;i<=n;i++)
cout<<dv[i]<<' ';
cout<<endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include <cstring>
using namespace std;
typedef long long ll;
#define FastIO cin.sync_with_stdio(false), cin.tie(nullptr)
#define pb push_back
#define fs first
#define sc second
#define mkp make_pair
#define endl '\n'
// IO
#define multitest signed __T; cin >> __T; while(__T--)
template<typename T>
void _read(T& t);
template<typename T>
void _read(vector<T>& v);
template<typename T1, typename T2>
void _read(pair<T1, T2>& p);
template<typename T>
void _read(T& t) { cin >> t; }
template<typename T>
void _read(vector<T>& v) { for (unsigned _i = 0; _i < v.size(); _i++)_read(v[_i]); }
template<typename T1, typename T2>
void _read(pair<T1, T2>& p) { _read(p.first); _read(p.second); }
void _masterread() {}
template<typename T, typename... V>
void _masterread(T& t, V& ... v) { _read(t); _masterread(v...); }
#define re(...)_masterread(__VA_ARGS__)
template<typename T>
void _print(T t);
template<typename T>
void _print(vector<T>& v);
template<typename T1, typename T2>
void _print(pair<T1, T2>& p);
template<typename T>
void _print(T t) { cout << t; }
template<typename T>
void _print(vector<T>& v) { for (unsigned _i = 0; _i < v.size(); _i++)_print(v[_i]), cout << (_i == v.size() - 1 ? "" : " "); }
template<typename T1, typename T2>
void _print(pair<T1, T2>& p) { _print(p.first); cout << " "; _print(p.second); }
void _masterprint() { cout << endl; }
template<typename T, typename... V>
void _masterprint(T t, V... v) { _print(t); if (sizeof...(v))cout << " "; _masterprint(v...); }
#define pr(...)_masterprint(__VA_ARGS__)
// DEBUG
// colored output???
template <typename T> // start forward declaration
void _debug(T t);
template<typename T1, typename T2>
void _debug(pair<T1, T2> p);
template<typename T>
void _debug(vector<T>v);
template <typename T> // end forward declaration
void _debug(T t) { cerr << t; }
template<typename T1, typename T2>
void _debug(pair<T1, T2> p) { cerr << "{"; _debug(p.first); cerr << ", "; _debug(p.second); cerr << "}"; }
template<typename T>
void _debug(vector<T>v) { cerr << "("; for (unsigned _i = 0; _i < v.size(); _i++)_debug(v[_i]), cerr << (_i == v.size() - 1 ? "" : ", "); cerr << ")"; }
void _masterdebug() { cerr << "]\n"; }
template<typename T, typename... V>
void _masterdebug(T t, V... v) { _debug(t); if (sizeof...(v))cerr << ", "; _masterdebug(v...); }
#define debug(...) cerr<<"["<<#__VA_ARGS__<<"] = [";_masterdebug(__VA_ARGS__)
#define int long long
vector<int> A, D;
void rec(int l, int r, int d) {
if (l > r) {
return;
}
if (l == r) {
D[l] = d;
return;
}
int mx = l;
for (int i = l; i <= r; i++) {
if (A[i] > A[mx]) {
mx = i;
}
}
D[mx] = d;
rec(l, mx - 1, d + 1);
rec(mx + 1, r, d + 1);
}
void solve() {
int n; re(n);
A = vector<int>(n); re(A);
D = vector<int>(n);
rec(0, n - 1, 0);
pr(D);
}
signed main() {
FastIO;
int t;
cin >> t;
while(t--)
solve();
}
|
#include<bits/stdc++.h>
using namespace std;
const int N=110;
int a[N],d[N];
int n,m;
void dfs(int l,int r,int id,int dist)
{
if(l==r) return ;
if(l<id)
{
int idl=id-1;
for(int i=l;i<id-1;i++)
if(a[i]>a[idl]) idl=i;
d[idl]=dist+1;
dfs(l,id-1,idl,dist+1);
}
if(r>id)
{
int idr=id+1;
for(int i=id+2;i<=r;i++)
if(a[i]>a[idr]) idr=i;
d[idr]=dist+1;
dfs(id+1,r,idr,dist+1);
}
}
int main()
{
int t;cin>>t;
while(t--)
{
memset(d,0,sizeof d);
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
int id=1;
for(int i=2;i<=n;i++)
if(a[i]>a[id])
id=i;
dfs(1,n,id,0);
for(int i=1;i<=n;i++) cout<<d[i]<<" ";
cout<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (long long i = (a); i <= (b); ++i)
#define REPD(i, a, b) for (long long i = (a); i >= (b); --i)
#define FORI(i, n) REP(i, 1, n)
#define FOR(i, n) REP(i, 0, long long(n) - 1)
#define mp make_pair
#define pb push_back
#define pii pair<long long, long long>
#define vi vector<long long>
#define ll long long
#define SZ(x) long long((x).size())
#define DBG(v) cerr << #v << " = " << (v) << endl;
#define FOREACH(i, t) for (auto i = t.begin(); i != t.end(); ++i)
#define fi first
#define se second
vector<int>dep;
vector<int>a;
int n;
void dfs(vector<int>v,int depth){
if(v.size()==0)return;
int max1=-1;
for(int i=0;i<v.size();i++){
max1=max(max1,v[i]);
}
dep[max1]=depth;
vector<int>l,r;
bool found=false;
for(int i=0;i<v.size();i++){
if(v[i]==max1){
found=true;
continue;
}
if(found){
r.push_back(v[i]);
}
else {
l.push_back(v[i]);
}
}
dfs(l,depth+1);
dfs(r,depth+1);
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin>>t;
while(t--){
cin>>n;
dep.clear();
dep.resize(n+1);
a.clear();
a.resize(n);
for(int i=0;i<n;i++)cin>>a[i];
dfs(a,0);
for(int i=1;i<=n;i++){
cout<<dep[a[i-1]]<<" ";
}
cout<<"\n";
}
}
|
#include<bits/stdc++.h>
using namespace std;
int n,a[101]={0};
void PT(int x,int y,int depth=0){
if(y-x<2){
return ;
}
int loca=x+1;
int max=a[x+1];
for(int i=x+1;i<y;i++){
if(a[i]>max){
max=a[i];
loca=i;
}
}
a[loca]=depth;
PT(x,loca,depth+1);
PT(loca,y,depth+1);
}
void slove(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
}
PT(0,n+1);
for(int i=1;i<=n;i++){
cout<<a[i]<<" ";
}
}
int main(){
long t=1;
cin>>t;
while(t--){
slove();
cout<<'\n';
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
using namespace std;
typedef long long LL;
const int N = 110;
int T;
int n;
int a[N], res[N];
void dfs(int l, int r, int dep) {
if (l > r || l < 1 || r > n) return;
if (l == r) {
res[l] = dep;
return;
}
int pos, Max = -1;
for (int i = l; i <= r; i ++)
if (Max < a[i]) {
Max = a[i];
pos = i;
}
res[pos] = dep;
dfs(l, pos - 1, dep + 1);
dfs(pos + 1, r, dep + 1);
return;
}
int main() {
cin >> T;
while (T --) {
cin >> n;
for (int i = 1; i <= n; i ++) cin >> a[i];
dfs(1, n, 0);
for (int i = 1; i <= n; i ++) cout << res[i] << " \n"[i == n];
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int t,n,a[111],pos[111];
void build(int l,int r,int depth)
{
if(l>r) return;
int maxn=0,maxpos;
for(int i=l;i<=r;i++)
{
if(a[i]>maxn)
{
maxn=a[i];
maxpos=i;
}
}
pos[maxpos]=depth;
build(l,maxpos-1,depth+1);
build(maxpos+1,r,depth+1);
}
int main()
{
cin>>t;
for(int i=1;i<=t;i++)
{
cin>>n;
for(int j=1;j<=n;j++) cin>>a[j];
build(1,n,0);
for(int j=1;j<=n;j++) cout<<pos[j]<<" ";
cout<<endl;
}
return 0;
} |
//This Is It
#include<bits/stdc++.h>
using namespace std;
//Code Written By Jaydeep Nayak
#define ll long long
#define pb push_back
#define mp make_pair
#define pll pair<long long,long long>
map<ll,ll> m1;
map<ll,ll>::iterator itr;
void buildTree(ll* tree,ll* arr,ll left,ll right,ll index){
if(left == right){
tree[index] = arr[left];
return;
}
if(left > right){
return;
}
ll mid = (left + right)/2;
buildTree(tree,arr,left,mid,(2*index));
buildTree(tree,arr,(mid+1),right,(2*index + 1));
tree[index] = max(tree[2*index],tree[2*index + 1]);
}
ll queryTree(ll* tree,ll* arr,ll index,ll left,ll right,ll leftQ,ll rightQ){
if((left >= leftQ)&&(right <= rightQ)){
return tree[index];
}
if((left > rightQ) || (right < leftQ)){
return -1;
}
ll mid = (left + right)/2;
ll p1= queryTree(tree,arr,(2*index),left,(mid),leftQ,rightQ);
ll p2 = queryTree(tree,arr,(2*index + 1),(mid+1),right,leftQ,rightQ);
return max(p1,p2);
}
ll ans[102];
void retAns(ll left,ll right,ll level,ll* arr,ll* tree,ll n){
ll vlu;
if(left > right){
return;
}
if(left == right){
vlu = arr[left];
ans[left] = level;
return;
}
ll maxVal = queryTree(tree,arr,1,0,n-1,left,right);
ll indi = m1[maxVal];
ans[indi] = level;
retAns(left,(indi-1),(level + 1),arr,tree,n);
retAns((indi+1),right,(level+1),arr,tree,n);
}
int main(){
ll t;
cin>>t;
while(t--){
m1.clear();
memset(ans,-1,sizeof(ans));
ll n;
cin>>n;
ll arr[n];
for(ll i=0;i<n;i++){
cin>>arr[i];
m1.insert(mp(arr[i],i));
}
ll tree[4*n + 1];
buildTree(tree,arr,0,n-1,1);
retAns(0,n-1,0,arr,tree,n);
for(ll i=0;i<n;i++){
cout<<ans[i]<<" ";
}
cout<<endl;
}
}
|
/*
********************
** MANAN DIYORA **
** DA-IICT **
** diyora13 **
********************
*/
#include <bits/stdc++.h>
using namespace std;
//#include <time.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl '\n'
#define setpre(x,d) fixed<<setprecision(d)<<x
#define fill(a,x) memset(a,x,sizeof(a));
#define inarr(a,n) for(int i=0;i<n;i++) cin>>a[i];
#define outarr(a,n) for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;
#define maxa(a,n) *max_element(a,a+n)
#define mina(a,n) *min_element(a,a+n)
#define fr(i,s,e) for(ll i=s;i<e;i++)
#define rf(i,s,e) for(ll i=s-1;i>=e;i--)
#define deb1(x) cout<<#x<<" : "<<x<<endl;
#define deb2(x,y) cout<<#x<<" : "<<x<<"\t"<<#y<<" : "<<y<<endl;
#define deb3(x,y,z) cout<<#x<<" : "<<x<<"\t"<<#y<<" : "<<y<<"\t"<<#z<<" : "<<z<<endl;
#define deb4(x,y,z,w) cout<<#x<<" : "<<x<<"\t"<<#y<<" : "<<y<<"\t"<<#z<<" : "<<z<<"\t"<<#w<<" : "<<w<<endl;
#define deb5(x,y,z,w,v) cout<<#x<<" : "<<x<<"\t"<<#y<<" : "<<y<<"\t"<<#z<<" : "<<z<<"\t"<<#w<<" : "<<w<<"\t"<<#v<<" : "<<v<<endl;
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define sz size()
#define len length()
#define all(v) v.begin(),v.end()
#define PI 3.141592653589793
#define MOD 1000000007
#define NN (const int)5e5+10
typedef long long int ll;
typedef long double lld;
typedef pair<long long,long long> pll;
typedef vector<long long> vll;
typedef vector<pair<long long,long long> > vpll;
// bool sortbysec(const pair<int,int> &a,const pair<int,int> &b) { return (a.second < b.second); }
// void fileio() { freopen("input.txt","r",stdin); freopen("output.txt","w",stdout); }
// vll fact(NN),invfact(NN);
// void EE(ll a,ll b,ll &x,ll &y) { if(b==0) { x=1,y=0; return ; } EE(b,a%b,x,y); ll temp=x; x=y; y=temp-(a/b)*y; }
// ll inverse(ll a,ll mod) { ll x,y; EE(a,mod,x,y); return (x+mod)%mod; }
// void build() { fact[0]=1; fr(i,1,NN) fact[i]=(fact[i-1]*i)%MOD; invfact[NN-1]=inverse(fact[NN-1],MOD); rf(i,NN-1,0) invfact[i]=(invfact[i+1]*(i+1))%MOD; }
// ll ncr(ll n,ll r) { if(n<0 || r<0 || r>n) return 0; return (fact[n]*((invfact[n-r]*invfact[r])%MOD))%MOD; }
// ll choose(ll n,ll k) { if(k==0) return 1; return (n* choose(n-1,k-1))/k; }
// ll logy(ll x,ll y) { return ceil((lld)(log(x)/log(y))); }
ll powe(ll a,ll b) { ll re=1; while(b){ if(b&1) re=(re*a); a=(a*a); b=b>>1;} return re; }
ll n,a[105]={0},aa[105]={0};
ll id(ll l,ll r)
{
ll idd=l;
fr(i,l,r+1)
if(a[i]>a[idd]) idd=i;
return idd;
}
void findmax(ll l,ll r,ll ans)
{
// deb3(l,r,ans)
if(l>r) return ;
if(l==r)
{
aa[l]=ans;
return ;
}
ll idd=id(l,r);
// deb4(idd,l,r,ans)
findmax(l,idd-1,ans+1);
findmax(idd+1,r,ans+1);
aa[idd]=ans;
}
int main()
{
IOS
ll tt=1;
cin>>tt;
while(tt--)
{
cin>>n; inarr(a,n);
findmax(0,n-1,0);
fr(i,0,n) cout<<aa[i]<<" "; cout<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
long long t, n, arr[N], ans[N];
void findans(long long l, long long r, long long depth){
if(l > r) return;
long long maxindx = l;
for(int i = l + 1; i <= r; i++){
if(arr[i] > arr[maxindx]) maxindx = i;
}
ans[maxindx] = depth;
findans(l, maxindx - 1, depth + 1);
findans(maxindx + 1, r, depth + 1);
}
void solve(){
cin >> n;
for(int i = 0; i < n; i++) cin >> arr[i];
findans(0, n - 1, 0);
for(int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
}
int main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);
cin >> t;
while(t--){
solve();
}
} |
//#pragma GCC optimize ("O3", "unroll-loops")
//#pragma GCC target ("avx2")
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#define LL long long
#define PII pair<int, int>
#define PLL pair<LL, LL>
#define all_of(v) (v).begin(), (v).end()
#define sort_unique(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define fi first
#define se second
const int MAXN = (int)1e7 + 9487;
//const LL INF = (LL) 1e9 + 8763;
//const LL MOD = (LL) 998244353;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define div dddivvvvvvvvvv
int mpf[MAXN], pw[MAXN], ans[MAXN];
LL div[MAXN];
vector<int> P;
void solve() {
int c;
cin >> c;
cout << ans[c] << '\n';
}
void prep() {
for (int i = 1; i < MAXN; i++) {
ans[i] = -1;
mpf[i] = i;
}
div[1] = 1, pw[1] = 1;
for (int i = 2; i < MAXN; i++) {
ans[i] = -1;
if (mpf[i] == i) {
P.push_back(i);
pw[i] = i;
div[i] = (i + 1);
}
// assert(i % pw[i] == 0 && i / pw[i] % mpf[i] != 0);
// if (i <= 10000000) {
// LL sum = 0;
// for (LL x = 1; x * x <= i; x++) {
// if (i % x == 0) {
// sum += x;
// if (x != i / x) {
// sum += i / x;
// }
// }
// }
//
// if (sum != div[i]) {
// cout << "WTF " << i << " -> " << sum << ' ' << div[i] << endl;
// }
//// cout << "CHK " << i << endl;
// }
for (int p : P) {
if ((LL)i * p >= MAXN) {
break;
}
mpf[i * p] = p;
if (i % p == 0) {
pw[i * p] = pw[i] * p;
div[i * p] = div[i / pw[i]] * (((LL)pw[i * p] * p - 1) / (p - 1));
break;
}
else {
pw[i * p] = p;
div[i * p] = div[i] * (1 + p);
}
}
}
for (int i = MAXN - 1; i >= 1; i--) {
if (div[i] < MAXN) {
ans[div[i]] = i;
}
}
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
prep();
int tc = 1;
cin >> tc;
for (int i = 1; i <= tc; i++) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = (int) 1e7 + 100;
long long s[N];
int d[N];
int ans[N];
int main() {
fill(d, d + N, -1);
d[1] = 1;
for (int i = 2; i * i < N; i++) {
if (d[i] == -1) {
d[i] = i;
for (int j = i * i; j < N; j += i) {
if (d[j] == -1) {
d[j] = i;
}
}
}
}
s[1] = 1;
for (int i = 2; i < N; i++) {
if (d[i] == -1) {
d[i] = i;
s[i] = i + 1;
} else {
int j = i;
s[i] = 1;
while (j % d[i] == 0) {
j /= d[i];
s[i] = s[i] * d[i] + 1;
}
s[i] *= s[j];
}
}
fill(ans, ans + N, -1);
for (int i = N - 1; i > 0; i--) {
if(s[i]<N){ // avoiding overflow.
ans[s[i]] = i;
}
}
int tests;
cin >> tests;
while (tests-- > 0) {
int c;
cin >> c;
cout << ans[c] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MX = 10000000;
ll X[10101010];
ll Y[10101010];
vector<int> primes;
int ans[10101010];
int main() {
X[1] = Y[1] = 1;
for(int i = 2; i <= MX; i++) {
if(!X[i]) { primes.push_back(i); X[i] = Y[i] = i + 1; }
for(int j : primes) {
if((ll)i * j > MX) break;
if(i % j == 0) {
Y[i * j] = Y[i] * j + 1;
X[i * j] = X[i] / Y[i] * Y[i * j];
break;
}
else {
X[i * j] = X[i] * X[j];
Y[i * j] = Y[j];
}
}
}
for(int i = 1; i <= MX; i++) {
if(X[i] > MX) continue;
if(!ans[X[i]]) ans[X[i]] = i;
}
int tc; scanf("%d", &tc);
while(tc--) {
int c; scanf("%d", &c);
if(!ans[c]) puts("-1");
else printf("%d\n", ans[c]);
}
return 0;
} |
#include <bits/stdc++.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>
#define INF 0x3f3f3f3f
#define LLINF 0x3f3f3f3f3f3f3f3f
#define eps 1e-8
#define pb push_back
#define fi first
#define se second
#define SZ(x) (int)x.size()
#define ALL(x) x.begin(), x.end()
#define db1(x) cout << #x << " = " << x << endl
#define db2(x, y) cout << #x << " = " << x << " " << #y << " = " << y << endl
#define gg cout << "---------QAQ--------\n"
#define MEM(a, b) memset(a, b, sizeof(a))
using namespace std;
typedef unsigned long long ull;
typedef long double ld;
typedef long long ll;
const int N = 1e7 + 10, M = 5100;
const int mod = 1e9 + 7;
int n, l, r, s;
int g[N], f[N], v[N], p[N];
int mi[N];
void pre() {
int tot = 0;
g[1] = f[1] = 1;
n = N-2;
for (int i = 2; i <= n; ++i) {
if (!v[i]) v[i] = 1, p[++tot] = i, g[i] = i + 1, f[i] = i + 1;
for (int j = 1; j <= tot && i <= n / p[j]; ++j) {
v[p[j] * i] = 1;
if (i % p[j] == 0) {
g[i * p[j]] = g[i] * p[j] + 1;
f[i * p[j]] = f[i] / g[i] * g[i * p[j]];
break;
} else {
f[i * p[j]] = f[i] * f[p[j]];
g[i * p[j]] = 1 + p[j];
}
}
}
//for (int i = 1; i <= n; ++i) f[i] = (f[i - 1] + f[i]);
MEM(mi, 0x3f);
for(int i = 1; i <= n; ++i)
{
if(f[i] > 10000000) continue;
mi[f[i]] = min(mi[f[i]], i);
}
}
void sol()
{
scanf("%d", &n);
if(mi[n] == INF) puts("-1");
else printf("%d\n", mi[n]);
}
int main()
{
pre();
int _; scanf("%d", &_); while (_--)
sol();
return 0;
}
/*
*/ |
#include <cstdio>
#include <algorithm>
#define ll long long int
using namespace std;
const int MAX = 1e7+10;
int t, c;
int ans[MAX];
int prime[MAX], pcount;
bool vis[MAX];
ll d[MAX], f[MAX];
void eular() {
for (int i = 1; i <= MAX; i++) ans[i] = MAX;
ans[1] = 1;
for (int i = 2; i < MAX; i++) {
if (!vis[i]) {
vis[i] = 1;
prime[pcount++] = i;
d[i] = f[i] = i + 1;
if (ans[i + 1] > i) ans[i + 1] = i;
}
for (int j = 0; j < pcount && (ll)prime[j] * i < MAX; j++) {
vis[prime[j] * i] = 1;
if (i % prime[j] == 0) {
f[prime[j] * i] = f[i] * prime[j] + 1;
d[prime[j] * i] = d[i] / f[i] * f[prime[j] * i];
} else {
f[prime[j] * i] = f[prime[j]];
d[prime[j] * i] = d[i] * f[prime[j] * i];
}
if (d[prime[j] * i] < MAX && ans[d[prime[j] * i]] > prime[j] * i) ans[d[prime[j] * i]] = prime[j] * i;
if (i % prime[j] == 0) break;
}
}
}
int main() {
eular();
scanf("%d", &t);
while(t--) {
scanf("%d", &c);
if (ans[c] != MAX) printf("%d\n", ans[c]);
else printf("-1\n");
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
//#define int long long
#define maxn 10000050
vector<int> sums(maxn,1);
vector<int> rev(maxn,-1);
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
for(int i=2;i<maxn;i++){
for(int j=i;j<maxn;j+=i){
sums[j] += i;
}
}
for(int i=1;i<maxn;i++){
if(sums[i]<maxn&&rev[sums[i]]==-1){
rev[sums[i]] = i;
}
}
int n;
cin >> n;
int input;
for(int i=0;i<n;i++){
cin >> input;
cout << rev[input] << "\n";
}
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define F first
#define S second
#define pii pair<int, int>
#define vi vector<int>
#define vb vector<bool>
#define vii vector<pii>
#define vvi vector<vector<int>>
#define P_B push_back
#define M_P make_pair
#define endl "\n"
#define MOD 1000000007
#define pi 3.141592653589793238
// void file_io()
// {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// }
const int N = 1e7 + 5;
vi min_factor(N, -1);
vi answer(N, -1);
vi sum(N, -1);
void primeFactorize() {
min_factor[1] = 1;
sum[1] = 1;
for (int i = 2; i*i < N; i++) {
if(min_factor[i] != -1) continue;
min_factor[i] = i;
for (int j = i*i; j < N; j += i) {
if(min_factor[j] != -1) continue;
min_factor[j] = i;
}
}
for (int i = 2; i < N; i++) {
if(min_factor[i] == -1) {
sum[i] = i+1;
min_factor[i] = i;
} else {
int x = i;
sum[i] = 1;
while(x%min_factor[i] == 0) {
sum[i] = sum[i]*min_factor[i] + 1;
x /= min_factor[i];
}
sum[i] = sum[i]*sum[x];
}
}
for (int i = N-1; i >= 1; i--) {
if(sum[i] < N) answer[sum[i]] = i;
}
}
int32_t main() {
// file_io();
primeFactorize();
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int T; cin>>T; while(T--)
{
int n;
cin >> n;
cout << answer[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> sieve(10000000 + 1);
iota(sieve.begin(), sieve.end(), 0);
for(int i = 2; i * i < (int)sieve.size(); ++i) {
if(sieve[i] != i)
continue;
for(long long j = (long long)i * i; j < (int)sieve.size(); j += i)
if(sieve[j] == j)
sieve[j] = i;
}
vector<long long> sum_d(sieve.size());
sum_d[1] = 1;
for(int i = 2; i < (int)sieve.size(); ++i) {
if(i == sieve[i])
sum_d[i] = i + 1;
else {
int x = 1, y = i;
while(y % sieve[i] == 0)
x *= sieve[i], y /= sieve[i];
if(y == 1 && x == i)
sum_d[i] = sum_d[i / sieve[i]] + i;
else sum_d[i] = sum_d[x] * sum_d[y];
}
}
vector<int> ans(sieve.size(), 1e9);
for(int i = 0; i < (int)sieve.size(); ++i)
if(sum_d[i] < (int)sieve.size())
ans[sum_d[i]] = min(i, ans[sum_d[i]]);
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
if(ans[n] == 1e9)
cout << -1 << "\n";
else cout << ans[n] << "\n";
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.