I am also hoping to reach pupil in this contest...

Reaching Expert after solving just 50–60 problems? How is this even possible? Share your secrets, legends!

The peak needs some more time and practice to truely becomes "tourist Peak".

Dude, you haven't even tested.

bro have inherited all testers comments.

All the testers say the same thing

As a problem setter, throughout heaven and earth this round alone is honored one

similar thing happened with me as well

Who are you?

your videos are really goated fr

You can do it, bro.

A bamboo doesn't grow an inch for about 3 years before it grows to around 90 feet in just a couple of weeks.

I've been stuck in newbie for more than a year

I find mind tricking problem enjoyable, since I don't know many ad-hoc problem

Graph questions are much more beautiful.

Bro, it was too obviously that you have used chatgpt

Correct submissions count towards total penalty too (just their submission time).

Author's solution uses only maps and dfs

one can use an array which tracks how many colours does a single colour shares edge with,

Could you please share the link to his video? I couldn't find it on youtube

I think using unordered_map with default hashing is fine, because the keys passed to unordered_map is small enough (up to $$$2 \cdot 10^5$$$). My solution using unordered_map (329528711) has passed and is fast enough.

I think it is very good performance for first time :)

https://codeforces.me/contest/2126/submission/329521554

Here's my relevant code. You just needed the smallest digit that appeared in the number.

void solve() {
    int n;
    cin >> n;
    int m = n % 10;
    while (n > 0) {
        m = min(m, n % 10);
        n /= 10;
    }
    cout << m << '\n';
}

string s;
cin >> s;
cout << *min_element(s.begin(), s.end()) << '\n';

:D

it's common situation on Div 3/4 round; Therefore, use m1/m2/m3 codeforces

we can use an array to precompute how many colour does a single colour shares edge with

Hi can you share me your approach for D. My Approach is failing at test case-2

void solve(){
    int n,k; cin>>n>>k;
    vector<vector<int>>a(n,vector<int>(3));
    for(int i=0;i<n;++i){
        cin>>a[i][0]>>a[i][1]>>a[i][2];
    }    
    auto cmp=[&](const vector<int>& b, const vector<int>& c)->bool{
        return b[1]>c[1];
    };
    sort(all(a),cmp);
    vector<int>mp(n,-1);
    for(int i=0;i<n-1;++i){
        if(a[i][0]<=a[i+1][1]){
            mp[i]=i+1;
        }
    }
    debug(mp);
    vector<bool>vis(n,0);
    for(int i=0;i<n;++i){
        if(vis[i]) continue;
        int val=i;
        int mx=a[val][2];
        set<int>st;
        while(val!=-1){
            mx=max(mx,a[val][2]);
            vis[val]=true;
            st.insert(val);
            val=mp[val];
        }
        for(int i:st){
            mp[i]=mx;
        }
    }
    int ans=0;
    for(int i=0;i<n;++i){
        if(a[i][0]<=k && k<=a[i][1]){
            ans=max(mp[i],ans);
        }
    }
    cout<<ans<<endl;
}

Edited:

I figured out out edge case

I was using DSU like approach to merge all casinos with overlapping intervals into same group and assigning them their largest reachable value, but turns out we can't win any value within range [l,r] for a casino, rather we would have a specific value 'real'. Thus we can't guarantee that we can play at any casino which will have an overlapping interval

cool bro, it's just beginning; Good luck!

I wasted a lot of time on it until I realized I had missed an important piece of information given in the constraints, that $$$l_i \leq real_i \leq r_i$$$. This makes the problem way easier.

almost 20% of them are cheaters

Same question. How solve F?

Just sort the casinos you receive by the amount they are going to give you (because going back is pointless) Then you greedily check where you can advance.

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

#define pii pair<int,int>

struct Pol {
    int l,r,v;
};

bool fun(Pol a, Pol b) {
    return a.v<b.v;
}

void solve() {
    int n, k; cin>>n>>k;
    Pol *pool =new Pol[n];
    for(int i=0; i<n; i++) {
        int a,b,c;
        cin>>a>>b>>c;
        Pol pl; pl.l=a; pl.r=b; pl.v=c;
        pool[i]=pl;
    }

    int pre=k;
    sort(pool,pool+n,fun);

    for(int i=0; i<n; i++) {
        if(pool[i].v>pre) {
            if( pool[i].l<=pre && pre<=pool[i].r ) {
                pre=pool[i].v;
            }
        }
    }

    cout<<pre<<endl;

}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    int t=1;
    cin>>t;
    while(t--) solve();

    return 0;
}

create a list that is lcm(p[i], s[i]) and recreate p and s and check if they are same

check if res[i] = lcm(a[i], b[i]) works and if not then nothing can work

I did something way more convoluted than what's being suggested. I checked if p[n]==s1 and then for i from 0 to n-2: gcd(p[i],s[i+1])==p[n]. Also checked each of p and s are valid by checking if p[i]%p[i+1]==0 and s[i+1]%s[i]==0

To construct a valid array a such that:

`p[i] = gcd(p[i-1], a[i])`
`s[i] = gcd(a[i], s[i+1])`
`p[n-1] == s[0]`   // i.e., gcd of the entire array

We observe the following:

1. From p[i] = gcd(p[i-1], a[i]), it must be that: p[i-1] % p[i] == 0

2. From s[i] = gcd(a[i], s[i+1]), it must be that: s[i+1] % s[i] == 0

3. Since a[i] must satisfy both prefix and suffix GCD conditions, it must be divisible by both p[i] and s[i]. So: a[i] % p[i] == 0 and a[i] % s[i] == 0 ⇒ a[i] must be a multiple of lcm(p[i], s[i])

To check if such an a[i] is valid, try setting: a[i] = lcm(p[i], s[i])

Then check whether: gcd(p[i-1], a[i]) == p[i]

Substitute a[i] = lcm(p[i], s[i])

= gcd(p[i-1], lcm(p[i], s[i]))

= gcd(p[i-1], (p[i] * s[i]) / gcd(p[i], s[i]))

= p[i] * gcd(p[i-1] / p[i], s[i] / gcd(p[i], s[i]))

So, for this to equal p[i], we must have: gcd(p[i-1] / p[i], s[i] / gcd(p[i], s[i])) == 1

If this condition fails at any index i, then no valid array a[] exists.