Yes, you got it right. The letter d just accidentally rotated itself mid-typing. Thanks!

they may have private groups to discuss and organize contests and let people who have free time to test

Back in 2019 I once randomly got a message in CF from MikeMirzayanov asking if I would be available to test a round. Not sure if they still use this approach to recruit testers.

as per me edu 190 was a fairly good round

Why is it the case?

Наконец-то правильный ответ на пост!

Here you are!

GoodLuck xD

It's been 15 minutes, and I'm still being treated like a 'robot'.

I swear I've solved C on Leetcode 2-3 years back, just can't pinpoint which problem was it. Anyone remembers?

My O(n∗Log2(n)^2) approach wasn't working,try multiple possible O(n∗Log2(n)^2) soln,every soln leads to tle,idk why :(

+1

how did you use map in it ?

Because main part of this problem — write optimal code, because you use map with size nlog And this is too slow

In map u need to use map<pair<int,int>,int> pair cuz u need to store a[i] and the value u choose to make it .. i ignored duplicates and didnt use map cuz atmost operations are 3.5x10^8 <2sec but using map optimizes the code

100% Agree. Not only that, but the samples also don't clarify that. I had to write stress-tests for my WA2 solution, pass stress tests, get wrong answer and only then see that the problem asks for something clearly different. And the triplet part doesn't even contribute to the problem in a meaningful way, it's effectively the same with the subgraphs.

C shouldn't return a TLE because of map but sadly the limit was an overkill

For problem E did you use fft or something to calculate the convolution or did you not have to calculate it at all?

i don't think the intended solution for c involved using hashmaps i simply bruteforced it

u can simply iterate over all possible values the minimum value of the array can be converted to

In C i mean the observation that the numbers must be equal to a number that can be reached from the minimum is the most important part, no matter how it is implemented

could'nt agree with D, easy implementation

In c hashmap was not required.

how did you find what values final equalized value can take ?

Depends on your brute force. It takes O (log N) steps for a number to reach 1 or 2. So in my head, a good brute force approach should work.

There's no need to do that, there's a simpler approach:

1. Notice that any a[i] only decreases. It follows that at each step we must decrease the i-th number.

2. For optimization, we can use a map.

3. Edge case: when the map size is 2, the answer will be count(x — 1) if x == 0 mod 2 and x != 2, and when x == 2 the answer will be min(count(x), count(x — 1))

Sounds like it should work.

#include <bits/stdc++.h>
using namespace std;
#define int long long

using ll = long long;
using pii = pair<int,int>;
using vi = vector<int>;
using vll = vector<long long>;

#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define repn(i,n) for(int i=0; i<(n); ++i)

const int INF = 1e18;
const int MOD = 1e9 + 7;

/*
========================================
            Problem Statement
========================================


pass hoja pls 
========================================
*/

/*
    gx = (x+1)/2
    cx = 1 + x mod2 
    fx< x      it converges at t ? 
    commong convergence point for all 
        total cost = sig(i =1 )^n   s(ai, k t ) c(s)
    at the end 1 and 2 ? 
        at 1    min of both 1 and 2 sum  > ?   
        x = m.2^v2(x)
        v2(x/2)=v2(x)-1
        v2(x+1)>=1 ????????
*/


int f(int tgt,int n , vector<int> &a){
    int kl = 0 ; 
    repn(i,n){
        int ct = a[i]; 
        if(tgt==2 && ct==1){
            kl++;
            continue ; 
        }
        while(ct>tgt){
            kl+=1 + (ct%2);
            ct = (ct+1)/2;
        }
    }
    return kl;
}
void solve() {
    int n  ;cin>>n;
    vi  a(n) ;
    for(int i  =0 ; i <n ;i++)cin>>a[i];
    vector<pair<int,int>> cands ;
    int ct = a[0] , kl = 0 ; 
    while(ct>1){
        if(ct%2 ==0 ){
            while(ct%2==0){
                cands.pb({ct,kl});
                ct/=2;
                kl++;
            }
        }else {
            cands.pb({ct,kl});
            ct++;
            kl++;
        }
    }
    cands.pb({1,kl});
    if(a[0] == 1) cands.pb({2,1});
    for(int i =1 ;i < n;i++){
        vector<pair<int,int>> curr_path;
        ct = a[i]; kl = 0 ; 
        while(ct>1) {
            if(ct%2==0) {
                while (ct % 2 == 0) {
                    curr_path.push_back({ct, kl});
                    ct/=2; 
                    kl++;
                }
            } else {
                curr_path.push_back({ct, kl});
                ct++; 
                kl++;
            }
        }
        curr_path.pb({1,kl});
        if(a[i] == 1) curr_path.pb({2,1});

        vector<pair<int,int>> next_cands;
        for(auto & cand: cands){
            for(auto &cp: curr_path){
                if(cand.first ==cp.first){
                    next_cands.pb({cand.first,cand.second+cp.second});
                    break;
                }
            }
        }
        cands = next_cands;
    }
    int ans = INF; 
    for(auto cand:cands){
        ans = min(ans,cand.second);
    }
    cout<<ans<<endl;
}
int32_t main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t = 1;
    cin >> t;

    while (t--) solve();

    return 0;
}        

i did this for c i am not really sure if its optimal tho i am basically tryna simulate paths from every number down to 1

For problems like $$$B$$$, I always visualize them as mountains with peaks at height $$$a_i$$$, and you can think of the operation as "lifting the mountains up". So when $$$i-1$$$th mountain is taller than $$$i$$$, we need to lift the $$$i$$$ th mountain by atleast $$$a_{i-1} - a_i$$$. This visualization always helps me solve such problems.

did it accpeted?

I did lots of optimisation for my java code , i am precomputing min distance still it is getting TLE like why? `int t = sc.nextInt();` ` while (t-- > 0) {` ` int n = sc.nextInt();` long a[]=new long[n]; ` Map<Long, Integer>map=new HashMap<>();` for(int i=0;i<n;i++){ a[i]=sc.nextLong(); } Map<Long, Long>mp=new HashMap<>(); long ans=Long.MAX_VALUE; ` for(int i=0;i<n;i++){` long temp=a[i]; ` Set<Long> set=new HashSet<>();` map.merge(temp, 1, (x, y)->x+y); ` long it=0;` set.add(temp); ` mp.merge(temp, it, (x, y)->x+y);` if(map.get(temp)==n){ ans=Math.min(ans, mp.get(temp)); } while(true){ if(temp%2==0){ temp=temp/2; }else{ temp++; } ` if(set.contains(temp))break;` map.merge(temp, 1, (x, y)->x+y); it++; ` set.add(temp);` mp.merge(temp, it, (x, y)->x+y); ` if(map.get(temp)==n){` ` ans=Math.min(ans, mp.get(temp));` ` }` ` }` ` ` } ``

For C:- I am trying to understand why this Java solution gets TLE.

Idea:

For each number, I generate all reachable values using:

• even → x/2
• odd → x+1

I maintain:

• map[value] = number of elements that can reach value
• mp[value] = cumulative operations needed to reach value

So I am not recomputing distances; I accumulate them while traversing.

Whenever map[value] == n, that value becomes a candidate answer.

Code:https://codeforces.me/contest/2231/submission/375593971

Expected complexity:

• Each number follows a single chain
• Chain length should be around O(log ai)
• sum(n) ≤ 1e5

So I expected roughly O(n log A).

Is the TLE mainly due to:

• HashMap.merge() overhead?
• Creating HashSet for each element?
• Long boxing/unboxing?
• Some hidden complexity I am missing?

I want to understand the exact reason for TLE rather than replacing the approach.