Lets try to prove $C_1 \le \frac{C_1+C_2}{2}$

We know that $C_1 \le C_2$. Hence, we can write $C_2=C_1+p$ where $p \ge 0$. Now, compare the $L.H.S.$ and the $R.H.S.$

We have-

$C_1 \le \frac{C_1 +C_2}{2}$
$\implies C_1 \le \frac{C_1+(C_1+p)}{2}$
$\implies C_1 \le \frac{2*C_1+p}{2}$
$\implies C_1 \le C_1 + p/2$

$\because p\ge 0$ , the inequality is true for this case.

Similarly we can extend this argument for other cases like $\frac{(C_1+C_2)}{2} \le \frac{(C_1+C_2+C_3)}{3}$

Our constraint is-
$min(a_1,a_2,...,a_{k+1}) \ge$ $\large \frac{b_1+b_2+..+b_{k+1}}{k+1}$
Cross Multiply $k+1$-(Since $k \ge 0$ the sign will not be reversed)
$\implies (k+1)*min(a_1,a_2,...,a_{k+1}) \ge \sum_{j=1}^{j=k}b_j+B_{k+1}$

Also, we are iterating backwards. Meaning, we are starting from maximum $A_i$ to the minimum $A_i$. Hence, the current $A_i$ is the minimum one - no need to waste operations finding the minimum $A_i$!!

Lets dry run over 2 iterations to understand.

First iteration- The tree is empty. The first query happens with pair which has maximum $A_i$. Since the tree is empty, the first query returns $1$ if $A_i\ge B_i$ else we get $0$

We know find what index/range in tree to update (using $index[]$ array which has $B_i$ sorted in the required order). We update the leaf and parent nodes. Now $B_i$ has been added to tree. The tree, which was initially empty, now has $B_i$

I think now you guys can predict what happens in second iteration. You may want to go above at the find paragraph of Section 2. to dry run it :)

#include <bits/stdc++.h>

using namespace std;

const int MaxN = 4e5 + 15;
const int INF = 1e9;

pair<long long, int> tree[MaxN * 32];
int sz;

int L[MaxN * 32], R[MaxN * 32];

int findRes(int x, int l, int r, int k, pair<long long, int> cur)
{
    if(!x)
        return cur.second;

    if(l == r)
    {
        int ll = 0;
        int rr = tree[x].second;

        int res = 0;

        while(ll <= rr)
        {
            int mid = (ll + rr) / 2;
            if(cur.first + l * 1ll * mid <= k * 1ll * (mid + cur.second))
            {
                res = mid;
                ll = mid + 1;
            }else
                rr = mid - 1;
        }

        return cur.second + res;

    }else
    {
        int mid = (l + r) / 2;
        if(cur.first + tree[L[x]].first <= k * 1ll * (tree[L[x]].second + cur.second))
        {
            cur.first += tree[L[x]].first;
            cur.second += tree[L[x]].second;
            return findRes(R[x], mid + 1, r, k, cur);
        }else
            return findRes(L[x], l, mid, k, cur);
    }
}

void up(int x, int l, int r, int pos)
{
    if(l == r)
    {
        tree[x].first += l;
        tree[x].second++;
    }else
    {
        int mid = (l + r) / 2;
        if(mid >= pos)
        {
            if(!L[x])
                L[x] = ++sz;
            up(L[x], l, mid, pos);
        }else
        {
            if(!R[x])
                R[x] = ++sz;
            up(R[x], mid + 1, r, pos);
        }

        tree[x].first = tree[L[x]].first + tree[R[x]].first;
        tree[x].second = tree[L[x]].second + tree[R[x]].second;
    }
}

void solve()
{
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);

    vector <pair<int, int> > a;

    int n;
    cin >> n;
    a.resize(n);
    int root=++sz;

    for(auto & x : a)
        cin >> x.first >> x.second;

    sort(a.begin(), a.end());
    reverse(a.begin(), a.end());

    int ans = 0;

    for(auto x : a)
    {
        up(root, 1, INF, x.second);
        ans = max(ans, findRes(root, 1, INF, x.first, {0, 0}));
    }

    cout << ans << '\n';
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int test;
    cin>>test;
    while (test--){
        solve();
    }
}

#include <bits/stdc++.h>

using namespace std;

const int MaxN = (int)4e5 + 10;
const int MOD = (int)1e9 + 7;
const int INF = 1e9;

int n;
pair < int, int > f[MaxN];
int c[1 << 20], sz;
long long t[1 << 20];


long long readInt(long long l,long long r,char endd){
    long long x=0;
    int cnt=0;
    int fi=-1;
    bool is_neg=false;
    while(true){
        char g=getchar();
        if(g=='-'){
            assert(fi==-1);
            is_neg=true;
            continue;
        }
        if('0'<=g && g<='9'){
            x*=10;
            x+=g-'0';
            if(cnt==0){
                fi=g-'0';
            }
            cnt++;
            assert(fi!=0 || cnt==1);
            assert(fi!=0 || is_neg==false);

            assert(!(cnt>19 || ( cnt==19 && fi>1) ));
        } else if(g==endd){
            if(is_neg){
                x= -x;
            }
            assert(l<=x && x<=r);
            return x;
        } else {
            assert(false);
        }
    }
}
string readString(int l,int r,char endd){
    string ret="";
    int cnt=0;
    while(true){
        char g=getchar();
        assert(g!=-1);
        if(g==endd){
            break;
        }
        cnt++;
        ret+=g;
    }
    assert(l<=cnt && cnt<=r);
    return ret;
}
long long readIntSp(long long l,long long r){
    return readInt(l,r,' ');
}
long long readIntLn(long long l,long long r){
    return readInt(l,r,'\n');
}
string readStringLn(int l,int r){
    return readString(l,r,'\n');
}
string readStringSp(int l,int r){
    return readString(l,r,' ');
}

void upd(int r, int val) {
    r += sz;
    t[r] += val;
    c[r] += 1;
    while (r > 1) {
        t[r >> 1] = t[r] + t[r ^ 1];
        c[r >> 1] = c[r] + c[r ^ 1];
        r >>= 1;
    }
}

int en;

void solve() {
//  scanf("%d", &n);
    n = readIntLn(1, 4e5);
    en += n;
    assert (en <= 4e5);
//  k * min(a1, a2, ..., ai) >= b1 + ... + bi
    vector < pair < int, int > > idx(n);
    for (int i = 0; i < n; ++i) {
        f[i].first = readIntSp(1, 1e9);
        f[i].second = readIntLn(1, 1e9);
//      scanf("%d%d", &f[i].first, &f[i].second);
    }
    sort(f, f + n);
    for (int i = 0; i < n; ++i) {
        idx[i] = make_pair(f[i].second, i);
    }
    sz = 1;
    while (sz < n) {
        sz *= 2;
    }
    sort(idx.begin(), idx.end());
    for (int i = 0; i < 2 * sz; ++i) {
        t[i] = c[i] = 0;
    }
    int ans = 0;
    for (int i = n - 1; i >= 0; --i) {
        if (f[i].first >= f[i].second) {
            ans = max(ans, 1);
        }
        long long cur = f[i].second;
        int now = 1, root = 1;
        while (root < sz) {
            if ((t[root] + cur) <= 1LL * (c[root] + now) * f[i].first) {
                now += c[root];
                ans = max(ans, now);
                break;
            }
            root <<= 1;
            if ((t[root] + cur) <= 1LL * (c[root] + now) * f[i].first) {
                now += c[root];
                cur += t[root];
                ans = max(ans, now);
                root |= 1;
            }
        }
        int where = lower_bound(idx.begin(), idx.end(), make_pair(f[i].second, i)) - idx.begin();
        upd(where, +f[i].second);
    }
    printf("%d\n", ans);
}

int main() {
//  freopen("input.txt", "r", stdin);
    int t = readIntLn(1, 1e3);
    while (t --> 0) {
        solve();
    }
    assert (getchar() == EOF);
    return 0;
}

$B_i$ are sorted! Also, even child stores sum from range $[l,mid]$ and odd child stores from $[mid+1,r]$. Assume their sizes are same (i.e mid-l+1==r-mid).

Sort all pairs increasing by $(A_i, B_i)$. We're trying to fix the element with minimal $A_i$. After that, let's take all $(A_j, B_j) \ge (A_i, B_i)$, let's sort them by $B$ and consider only $B's$.

Now we're interested in finding the maximal $K$ such that $A_i >= (B_1+...+B_k+B_i) / (K + 1)$. It can be done with some logarithmic search on a segment tree with compressed coordinates of array $B$.

Prove it: if you have sorted array $C = (C_1, C_2, ..., C_k).$ $Now, C_1 / 1 \le (C_1 + C_2) / 2 \le (C_1 + C_2 + C_3) / 3 \le... \le (C_1 + ... + C_k) / k$.

Once again, let's fix $A_i$ $(i = n..1)$ one by one and maintain all sorted $B(j = i+1..n$) in segment tree. Let's find the largest $k$ such $(C_1+...+C_k+B_i)/(K+1) \le A_i$. Make sure that ST contains exactly ${2}^{l}$ leaves.

Okay, ($C_1+...+C_i)/i \le (C_1+...+C_{i+1})/(i+1)$, $C_1 <= C_2 <= ... <= C_{i+1}$Let's prove it:

$(C_1+...+C_i)/i*(i+1) \le C_1+ ... + C_{i+1}$

$(C_1+...+C_i)*1/i \le C_{i+1}$

$(C_1+...+C_i)*1/i \le (C_{i+1}+...+C_{i+1})*1/i$

$0 \le 1/i((C_{i+1} - C_{1}), + ... + (C_{i+1} - C_{i}))$

I hope it's clear :)

Tester's Suggestion- Be careful when ALL elements are included and when answer is $0$!!

Currently Test Bank is empty :( . Give me some solutions to analyze and we will add it. Community requested to contribute by giving any failing case in format-

Input Expected Output Cause of Error

do{
        int cnt=0;
        for (int i=1;i<=n;i++){
            if (a[i]&&a[i]!=p[i]){
                cnt-=100;
            }
        }
        for (int i=2;i<=n;i++){
            if (p[i]>p[i-1]){
                cnt++;
            }
        }
        ans+=(cnt==k);
    }
    while (next_permutation(p+1,p+n+1));

#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>

#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define files(name) name!=""?freopen(name".in","r",stdin),freopen(name".out","w",stdout):0
#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define elif else if
#define mp make_pair
#define pb push_back
#define fir first
#define sec second

using namespace std;
#define int long long

typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef long long ll;

const int arr=2e5+10;
const int ar=2e3+10;
const ld pi=acos(-1);
const ld eps=1e-10;
const ll md=1e9+7;

///---program start---///

int a[arr];
int p[arr];

void solve()
{
    int n,k;
    cin>>n>>k;
    for (int i=1;i<=n;i++){
        cin>>a[i];
    }
    for (int i=1;i<=n;i++){
        p[i]=i;
    }

    int ans=0;
    do{
        int cnt=0;
        for (int i=1;i<=n;i++){
            if (a[i]&&a[i]!=p[i]){
                cnt-=100;
            }
        }
        for (int i=2;i<=n;i++){
            if (p[i]>p[i-1]){
                cnt++;
            }
        }
        ans+=(cnt==k);
    }
    while (next_permutation(p+1,p+n+1));

    cout<<ans<<"\n";
}

main()
{
    #ifdef I_love_Maria_Ivanova
        files("barik");
        freopen("debug.txt","w",stderr);
    #endif

    int test;
    cin>>test;
    while (test--){
        solve();
    }
}

Its VERY scary for newbies. Dont open it!!

for (int i = 2; i <= n; ++i) {
        memset(ndp, 0, sizeof(ndp));
        for (int mask = 0; mask < 1 << 8; ++mask) {
            for (int last = 0; last < 8; ++last) {
                for (int cnt = 0; cnt < 8; ++cnt) {
                    if (dp[mask][last][cnt] > 0) {
                        if (p[i] == 0) {

#include <bits/stdc++.h>

using namespace std;

const int MaxN = (int)4e5 + 10;
const int MOD = (int)1e9 + 7;
const int INF = 1e9;

int p[10];
int dp[1 << 8][11][8];
int ndp[1 << 8][12][8];

void solve() {
    int n, k;
    scanf("%d%d", &n, &k);
    set < int > s;
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &p[i]);
        if (p[i] > 0) {
            assert (!s.count(p[i]));
            s.insert(p[i]);
        }
    }
    memset(dp, 0, sizeof(dp));
    if (p[1] == 0) {
        for (int i = 1; i <= n; ++i) {
            dp[1 << (i - 1)][i - 1][0] = 1;
        }
    } else {
        dp[1 << (p[1] - 1)][p[1] - 1][0] = 1;
    }
    for (int i = 2; i <= n; ++i) {
        memset(ndp, 0, sizeof(ndp));
        for (int mask = 0; mask < 1 << 8; ++mask) {
            for (int last = 0; last < 8; ++last) {
                for (int cnt = 0; cnt < 8; ++cnt) {
                    if (dp[mask][last][cnt] > 0) {
                        if (p[i] == 0) {
                            for (int nlast = 0; nlast < 8; ++nlast) {
                                if (~mask & (1 << nlast)) {
                                    ndp[mask | (1 << nlast)][nlast][cnt + (nlast > last)] += dp[mask][last][cnt];
                                }
                            }
                        } else {
                            if (~mask & (1 << (p[i] - 1))) {
                                ndp[mask | (1 << (p[i] - 1))][p[i] - 1][cnt + (p[i] - 1 > last)] += dp[mask][last][cnt];
                            }
                        }
                    }
                }
            }
        }
        memcpy(dp, ndp, sizeof(ndp));
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans += dp[(1 << n) - 1][i][k];
    }
    printf("%d\n", ans);
}

int main() {
//  freopen("input.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while (t --> 0) {
        solve();
    }
    return 0;
}

Simply because, if the element corresponding to that $A_i$ is at some other position, and all elements occur only once, then a mismatch at the position where $A_i\neq 0$ is confirmed.

Permutation: solution with bitmasks. Make a dp table as-

$dp[i][mask][last][cnt]$

How many permutations with filled first $i$ positions. Subset of elements on those positions = mask.

$q[i] = last$

and there was cnt $p[i] > p[i-1]$

Transitions processing in $O(N)$ if p[i+1] = 0 and in $O(1)$ if p[i+1] != 0

$O({2}^{N}*{N}^{3}*K)$

Currently Empty

Focus on condition $min(R_1,R_2,..,R_{k-1}) \ge L_i$. What are we comparing? What things are hence, needed to be stored in set? Did we account of $L_1,L_2,..L_{k-1}$ anywhere above? Is it necessary to hence, store $L_1,L_2...$?

Obviously! When $R_1\ge L_2$ where lines are $\{L_1,R_1\}$ and $\{L_2,R_2\}$. When will they not intersect hence? Easy to see now, if $L_2>R_1$.

 #pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>

#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define files(name) name!=""?freopen(name".in","r",stdin),freopen(name".out","w",stdout):0
#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define elif else if
#define mp make_pair
#define pb push_back
#define fir first
#define sec second

using namespace std;
#define int long long

typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef long long ll;

const int arr=2e5+10;
const int ar=2e3+10;
const ld pi=acos(-1);
const ld eps=1e-10;
const ll md=1e9+7;

///---program start---///

#define arr (int)(4e5+10)

int f[arr];
int rf[arr];

int bpow(int a,int n)
{
    int res=1;
    while (n){
        if (n&1){
            res=res*a%md;
        }
        n/=2;
        a=a*a%md;
    }
    return res;
}

int C(int n,int k) /// ways to comb
{
    if (k<0||k>n){
        return 0;
    }
    return f[n]*rf[k]%md*rf[n-k]%md;
}

void solve()
{
    int n,k;
    cin>>n>>k;
    vector<pii> a(0);
    for (int i=0;i<n;i++){
        int l,r;
        cin>>l>>r;
        a.pb({l,r});
    }
    sort(all(a));
    multiset<int> R;
    R.clear();
    int ans=C(n,k); /// all ways
    for (auto i:a){
        while (!R.empty()&&*R.begin()<i.fir){ /// delete all segments where r[j]<i.first
            R.erase(R.begin());
        }
        ans-=C(len(R),k-1); /// minus bad ways
        ans%=md;
        ans+=md;
        ans%=md;
        R.insert(i.sec);
    }
    cout<<ans<<"\n";
}

main()
{
    #ifdef I_love_Maria_Ivanova
        files("barik");
        freopen("debug.txt","w",stderr);
    #endif

    fast;

    /// precalc factorial and inverse
    f[0]=1;
    for (int i=1;i<arr;i++){
        f[i]=f[i-1]*i%md;
    }
    rf[arr-1]=bpow(f[arr-1],md-2);
    for (int i=arr-2;i>=0;i--){
        rf[i]=rf[i+1]*(i+1)%md;
    }

    int test;
    cin>>test;
    while (test--){
        solve();
    }
}

    #include <bits/stdc++.h>

using namespace std;

const int MaxN = (int)4e5 + 10;
const int MOD = (int)1e9 + 7;
const int INF = 1e9;

int n, k;
int fact[MaxN], rfact[MaxN], inv[MaxN];
pair < int, int > p[MaxN];
int fenw[MaxN];

long long readInt(long long l,long long r,char endd){
    long long x=0;
    int cnt=0;
    int fi=-1;
    bool is_neg=false;
    while(true){
        char g=getchar();
        if(g=='-'){
            assert(fi==-1);
            is_neg=true;
            continue;
        }
        if('0'<=g && g<='9'){
            x*=10;
            x+=g-'0';
            if(cnt==0){
                fi=g-'0';
            }
            cnt++;
            assert(fi!=0 || cnt==1);
            assert(fi!=0 || is_neg==false);

            assert(!(cnt>19 || ( cnt==19 && fi>1) ));
        } else if(g==endd){
            if(is_neg){
                x= -x;
            }
            assert(l<=x && x<=r);
            return x;
        } else {
            assert(false);
        }
    }
}
string readString(int l,int r,char endd){
    string ret="";
    int cnt=0;
    while(true){
        char g=getchar();
        assert(g!=-1);
        if(g==endd){
            break;
        }
        cnt++;
        ret+=g;
    }
    assert(l<=cnt && cnt<=r);
    return ret;
}
long long readIntSp(long long l,long long r){
    return readInt(l,r,' ');
}
long long readIntLn(long long l,long long r){
    return readInt(l,r,'\n');
}
string readStringLn(int l,int r){
    return readString(l,r,'\n');
}
string readStringSp(int l,int r){
    return readString(l,r,' ');
}


int comb(int n, int k) {
    if (n < k) {
        return 0;
    }
    return 1LL * fact[n] * rfact[k] % MOD * rfact[n - k] % MOD;
}

bool cmp(pair < int, int > a, pair < int, int > b) {
    return a.first < b.first || a.first == b.first && a.second > b.second;
}

int en;

void solve() {
    n = readIntSp(1, 4e5);
    en += n;
    assert (en <= 4e5);
    k = readIntLn(1, n);
    for (int i = 1; i <= n; ++i) {
        p[i].first = readIntSp(1, 1e9);
        p[i].second = readIntLn(p[i].first, 1e9);
    }
    sort(p + 1, p + n + 1, cmp);
    multiset < int > f;
    int bad = 0;
    for (int i = 1; i <= n; ++i) {
        while (!f.empty() && *f.begin() < p[i].first) {
            f.erase(f.begin());
        }
        bad = (bad + 1LL * comb(f.size(), k - 1)) % MOD;
        f.insert(p[i].second);
    }
    printf("%d\n", (comb(n, k) - bad + MOD) % MOD);
}

int main() {
//  freopen("input.txt", "r", stdin);
    fact[0] = rfact[0] = 1;
    for (int i = 1; i < MaxN; ++i) {
        inv[i] = i == 1 ? 1 : 1LL * (MOD - MOD / i) * inv[MOD % i] % MOD;
        fact[i] = 1LL * i * fact[i - 1] % MOD;
        rfact[i] = 1LL * inv[i] * rfact[i - 1] % MOD;
    }
    int t = readIntLn(1, 1e3);
    while (t --> 0) {
        solve();
    }
    assert (getchar() == EOF);
    return 0;
}

Ans: Say we dont do that. If we insert smaller $R_i$ first and then larger $R_i$, we may do wrong at step where we calculate number of bad ways, because the large segment may not have been inserted till then. Also, some smaller segments which intersect with larger one, but not with the small segment before them may get deleted. This will cause WA.

We already sorted lines by their starting point. Hence a line appearing at earlier is guaranteed to start before current line $i$. And if that line (say line $j$) has $R_j>L_i$, they obviously intersect. We dont need the $L_i$ values once the line is inserted mainly due to our previous step of sorting the line :)

What was our condition for all $k$ lines to intersect?

$min(R_1,R_2,..,R_{k-1}) \ge L_i$

Multiset gives us smallest $R_i$. Think the rest of it now!

???

Currently Empty

Remember that NO NEW BIT is set in AND operation. A bit which is $0$ (unset) is never set. A bit which is $1$ may be unset, or may remain set. In BEST case, the number can remain as it is. Of course, the maximum number will have at least 1 bit which is going to be unset. Hence, best case answer is minimum number of the two.

               if (t == 1) {//Add element, increase frequency
                cnt[x] += 1;
            } else if (t == 2) {//Remove element, reduce frequency.
                cnt[x] -= 1;
            }

 #include <bits/stdc++.h>

using namespace std;

//HEADER START
void init(int,vector<int>);
void insert(int);
void erase(int);
int f(int);
//HEADER END

const int max_N=75000;
const int max_M=75000;
const int max_K=18;

const int bsize=1.66*sqrt(75000);

int q_size;
int q_val[bsize+1];
int q_type[bsize+1];
int cnt[1<<max_K];
int dp[1<<max_K];

/// recalc array dp where dp[i] count of j in A that i&j==i
void recalc()
{
    for (int i=0;i<(1<<max_K);i++){
        dp[i]=cnt[i];
    }
    for (int i=0;i<max_K;i++){
        for (int mask=(1<<max_K)-1;mask>=0;mask--){
            if (!(mask&(1<<i))){
                dp[mask]+=dp[mask^(1<<i)];
            }
        }
    }
}

void init(int n,int k,vector<int> a)
{
    for (auto i:a){
        cnt[i]++;
    }
    recalc();
}

void insert(int x)
{
    if (q_size>=bsize){
        q_size=0;
        recalc();
    }
    cnt[x]++;
    q_val[q_size]=x;
    q_type[q_size]=1;
    q_size++;
}

void erase(int x)
{
    if (q_size>=bsize){
        q_size=0;
        recalc(); /// recalc if q bigger than sqrt(m)
    }
    cnt[x]--;
    q_val[q_size]=x;
    q_type[q_size]=-1;
    q_size++;
}

/// return count of j in A that j&mask==mask
int get_nad_mask(int mask)
{
    int res=dp[mask];
    for (int i=0;i<q_size;i++){
        if ((q_val[i]&mask)==mask){
            res+=q_type[i];
        }
    }
    return res;
}

int f(int x)
{
    int res=0;
    for (int i=max_K-1;i>=0;i--){
        if (get_nad_mask(res^(1<<i))>=x){ /// easy to see :)
            res+=(1<<i);
        }
    }
    return res;
}

//GRADER START

main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    srand(time(NULL));

    int n,m,k;
    cin>>n>>m>>k;
    vector<int> a(n);
    for (auto& i:a){
        cin>>i;
    }
    init(n,k,a);
    vector<int> v;
    for (int i=0;i<m;i++){
        int type,x;
        cin>>type>>x;
        if (type==1){
            insert(x);
        }
        else if (type==2){
            erase(x);
        }
        else{
            v.push_back(f(x));
        }
    }
    for(auto a : v){
        cout << a << "\n";
    }
}

 #include <bits/stdc++.h>

    using namespace std;

    const int MaxN = (int)4e5 + 10;
    const int MOD = (int)1e9 + 7;
    const int INF = 1e9;

    const int K = 9; //Rebuild SOS every (1 << K) queries

    int n, m, k;
    int a[MaxN], T[MaxN], X[MaxN];
    int cnt[1 << 18], foo[1 << 18];
    //cnt[i] denotes the number of elements = i in the array A
    //foo[i] array needed for Sum-over-Subsets

    void SOS() { // sum-over-subsets
        memcpy(foo, cnt, sizeof(foo));
        for (int bit = 0; bit < k; ++bit) {
            for (int mask = 0; mask < 1 << k; ++mask) {
                if (~mask & (1 << bit)) {
                    foo[mask] += foo[mask ^ (1 << bit)];
                }
            }
        }
    }

    int main() {
    //  freopen("input.txt", "r", stdin);
        scanf("%d%d%d", &n, &m, &k);
        assert (n <= 75000); assert (m <= 75000);
        for (int i = 1; i <= n; ++i) {
            scanf("%d", &a[i]);
            ++cnt[a[i]];
        }
        SOS(); //initial caculating
        for (int i = 1; i <= m; ++i) {
            int t, x;
            scanf("%d%d", &t, &x);
            T[i] = t;
            X[i] = x;
            if (t == 1) {
                cnt[x] += 1;
            } else if (t == 2) {
                cnt[x] -= 1;
            } 
            if ((i & ((1 << K) - 1)) == 0) { // rebuild
                SOS();  //help the program
            }
            if (t == 3) {
                int ans = 0;
                //constructing the answer from the highest bit to lowest one bit-by-bit
                //checking if we have 2^(k-1) in the answer,
                //
                for (int bit = k - 1; bit >= 0; --bit) {
                    int taked = ans | (1 << bit);
                    int cur = foo[taked]; //cur = the number of elements that has (ans | 2^bit) as submask
                    //recalculating in O(2^K)
                    for (int j = i; (j & ((1 << K) - 1)) != 0; --j) {
                        if (T[j] == 1) {
                            if ((X[j] & taked) == taked) {
                                ++cur;
                            }
                        }
                        if (T[j] == 2) {
                            if ((X[j] & taked) == taked) {
                                --cur;
                            }
                        }
                    }
                    if (cur >= x) { // checking if this number >= x then the answer for this query |= 2^bit
                        ans |= 1 << bit;
                    }
                }
                printf("%d\n", ans);
            }
        }
        return 0;
    }

Lets consider the worst case. Say $i$ is the highest bit. If by setting bit $i$, ALL the lower bits have to remain unset, we observe we still obtain a better answer. Setting $i'th$ bit adds ${2}^{i-1}$ to answer (0-based indexing!). While adding all other lower bits adds ${2}^{i-2}+{2}^{i-3}....={2}^{i-1}-1$ which is less than current answer obtained by setting $i'th$ bit. Hence, greedy stands proved :)

NO! Recall that we are storing "How many numbers exist such that ans is their sub-mask". This means we can simply take any $x$ of them to get answer. So exactly $==x$ not needed in given implementation.

" My solution have complexity $O(\sqrt{m}*{2}^{k}*k+m*sqrt{m}*k)$

Let’s define $g(a)$=(count of $bєA$ that $b\&a==a$). Then easy to call $f(x)$

res=0 for (i=k-1;I>=0;i—) if (g(res+1<< k)>=x) res+=1<< k

$g(a)$ will be calculated using sqrt evristic

After $\sqrt{m}$ requests we can recalculate array G with size ${2}^{k}$ with complexity $O({2}^{k}*k)$. Each $g(a)$ we will calculate using array $G$ and $O(\sqrt{m})$ requests, which not considered in $G$. "

Currently Empty. Give me solutions giving WA so I can help you there :)

void build(int v, int l, int r) {
        if (l != r) {
            build(v + v, l, (l + r) / 2);
            build(v + v + 1, (l + r) / 2 + 1, r);//Build Child nodes first
            tr[v] = max(tr[v + v], tr[v + v + 1]);
        } else {
            tr[v] = dp[l];
        }
        add[v] = -1LL << 60;//Used in lazy propagation. Can ignore right now. Just initializing this 
            //array.
    }

            int u, v, r, t;
            scanf("%d%d%d%d", &u, &v, &r, &t);
            //possible 3 cases:
            r++;
            //1: u is parent of v in DFS-order, then we need to try to update
            //the DP for Batman from nodes that are up on u and sons of u that
            //aren't parents of v -> (subtree v)
            //(subtree v) -> (the tree above u, u and sons of u that aren't parents of v)
            //thes segments are continuous in the DFS-order, we can apply segment tree with lazy propagation
            //for the next function A[x] = max(A[x], Value), X = L..R
            if (isPar(u, v)) {//u is parent of v.
                int w = getPar(v, u);
                long long X = max(get(1, 1, n, 1, in[w] - 1), get(1, 1, n, out[w] + 1, n));
                   //From before entering u's sub-tree or after coming out of u's sub-tree
                long long Y = get(1, 1, n, in[v], out[v]);//From V's subtree
                if (X >= r) {
                    upd(1, 1, n, in[v], out[v], X + t);//We end up in v's subtree
                }
                if (Y >= r) {
                    upd(1, 1, n, 1, in[w] - 1, Y + t);//Can land up in or out of
                    upd(1, 1, n, out[w] + 1, n, Y + t);//u's sub-tree. Both must be 
                                   //updated.
                }
            } else if (isPar(v, u)) { // V is parent of U
                //Absolutely similar case to the case of above
                //Cause the direction doesn't matter
                int w = getPar(u, v);//Do on your own for this half!
                long long X = get(1, 1, n, in[u], out[u]);
                long long Y = max(get(1, 1, n, 1, in[w] - 1), get(1, 1, n, out[w] + 1, n));
                if (X >= r) {
                    upd(1, 1, n, 1, in[w] - 1, X + t);
                    upd(1, 1, n, out[w] + 1, n, X + t);
                }
                if (Y >= r) {
                    upd(1, 1, n, in[u], out[u], Y + t);
                }
            } else { //The easiest case
                //U isn't parent of V and V isn't parent of U
                //Batman can go only from 
                //(subtree u) -> (subtree v)
                //(subtree v) -> (subtree u)
                //and reclalculating DP:
                long long X = get(1, 1, n, in[u], out[u]);
                long long Y = get(1, 1, n, in[v], out[v]);//Check comments above :)
                if (X >= r) {
                    upd(1, 1, n, in[v], out[v], X + t);
                }
                if (Y >= r) {
                    upd(1, 1, n, in[u], out[u], Y + t);//dp[v]==>Destination. Remember!
                }
            }

long long get(int v, int L, int R, int l, int r) {
            if (l > r) {//Out of range or invalid range
                return -1LL << 60;
            }
            tr[v] = max(tr[v], add[v]);//Update the node.
            push(v, L, R);//Push updates to children
            if (L == l && r == R) {//Completely in the range
                return tr[v];
            }
            int M = (L + R) / 2;
            push(v, L, R);
            if (r <= M) {//Query right child if left child out of range
                push(v + v + 1, M + 1, R);//Update child before querying
                return get(v + v, L, M, l, r);
            }
            if (l > M) {//Query left child if right child out of range
                push(v + v, L, M);
                return get(v + v + 1, M + 1, R, l, r);
            }
            return max(get(v + v, L, M, l, M), get(v + v + 1, M + 1, R, M + 1, r));
        }

 void push(int v, int L, int R) {
        if (L != R) {//Update children of v
            add[v + v] = max(add[v + v], add[v]);//add[v] is an array to store lazy updates.
            add[v + v + 1] = max(add[v + v + 1], add[v]);
        }
        tr[v] = max(tr[v], add[v]);//Update leaf
    }

void upd(int v, int L, int R, int l, int r, long long val) {
        if (l > r) {//Invalid range
            return;
        }
        push(v, L, R);//push lazy update
        if (L == l && r == R) {
            add[v] = max(add[v], val);//add[v] is an array to store lazy updates.
            push(v, L, R);//Push lazy updates
            return;
        }
        int M = (L + R) / 2;
        push(v, L, R);
        if (r <= M) {//Refer to query function
            upd(v + v, L, M, l, r, val);//Push lazy updates to one and update required child
            push(v + v + 1, M + 1, R);
        } else if (l > M) {
            push(v + v, L, M);//Push update to the child which wont be traversed any more
            upd(v + v + 1, M + 1, R, l, r, val);//Traverse the other child
        } else {
            upd(v + v, L, M, l, M, val);//Remember leaves must be updated first
            upd(v + v + 1, M + 1, R, M + 1, r, val);
        }
        tr[v] = max(tr[v + v], tr[v + v + 1]);
        tr[v] = max(tr[v], add[v]);//Update and lazy update the node.
    }

  #pragma GCC optimize("O3")
#include <bits/stdc++.h>

#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define files(name) name!=""?freopen(name".in","r",stdin),freopen(name".out","w",stdout):0
#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define elif else if
#define mp make_pair
#define pb push_back
#define fir first
#define sec second

using namespace std;
///#define int long long

typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef long long ll;

const int arr=2e5+10;
const int ar=2e3+10;
const ld pi=acos(-1);
const ld eps=1e-10;
const ll md=1e9+7;

///---program start---///

ll inf=1e18;

/// segment tree of maximums in segment with range updates
struct segment_tree
{
    int n;
    vector<ll> t;
    vector<ll> push;

    segment_tree()
    {
        n=0;
        t.clear();
        push.clear();
    }
    segment_tree(int n)
    {
        this->n=n;
        t.assign(4*n+10,-inf);
        push.assign(4*n+10,-inf);
    }

    void make_push(int v)
    {
        if (push[v]==-inf){
            return;
        }
        t[v*2]=max(t[v*2],push[v]);
        t[v*2+1]=max(t[v*2+1],push[v]);
        push[v*2]=max(push[v*2],push[v]);
        push[v*2+1]=max(push[v*2+1],push[v]);
        push[v]=-inf;
    }
    void upd(int v,int l,int r,int tl,int tr,ll val)
    {
        if (l>tr||r<tl||tl>tr){
            return;
        }
        if (l>=tl&&r<=tr){
            t[v]=max(t[v],val);
            push[v]=max(push[v],val);
            return;
        }
        make_push(v);
        int m=(l+r)/2;
        upd(v*2,l,m,tl,tr,val);
        upd(v*2+1,m+1,r,tl,tr,val);
        t[v]=max(t[v*2],t[v*2+1]);
    }
    ll get(int v,int l,int r,int tl,int tr)
    {
        if (l>tr||r<tl||tl>tr){
            return -inf;
        }
        if (l>=tl&&r<=tr){
            return t[v];
        }
        make_push(v);
        int m=(l+r)/2;
        return max(
                get(v*2,l,m,tl,tr),
                get(v*2+1,m+1,r,tl,tr)
            );
    }
    ll get(int l,int r)
    {
        if (l<=r){
            return get(1,1,n,l,r);
        }
        else{
            return max(
                    get(1,1,n,1,r),
                    get(1,1,n,l,n)
                );
        }
    }
    void upd(int l,int r,ll val)
    {
        if (l<=r){
            upd(1,1,n,l,r,val);
        }
        else{
            upd(1,1,n,1,r,val);
            upd(1,1,n,l,n,val);
        }
    }
};

#define arr (int)(1e6+10)

int tin[arr];
int tout[arr];
int T;
vi reb[arr];
const int M=20;
int p[arr][M];

void dfs1(int v,int pred)
{
    p[v][0]=pred;
    for (int i=1;i<M;i++){
        p[v][i]=p[p[v][i-1]][i-1];
    }
    tin[v]=++T;
    for (auto wh:reb[v]){
        if (wh!=pred){
            dfs1(wh,v);
        }
    }
    tout[v]=T;
}

/// return next vertex after u in simple path (u,v)
bool is_pred(int u,int v) /// u is pred v
{
    return tin[u]<=tin[v]&&tout[u]>=tout[v];
}

int n,S,P;
segment_tree ST;

int get_next(int u,int v) /// u is pred v
{
    for (int i=M-1;i>=0;i--){
        if (is_pred(u,p[v][i])&&u!=p[v][i]){
            v=p[v][i];
        }
    }
    return v;
}

void upd_way(int u,int v,ll r,ll t)
{
    if (is_pred(u,v)){ /// trivial :)
        ll val1=ST.get(tin[v],tout[v]);
        int kek=get_next(u,v);
        ll val2=ST.get(tout[kek]+1,tin[kek]-1);
        if (val1>r){
            val1+=t;
            ST.upd(tout[kek]+1,tin[kek]-1,val1);
        }
        if (val2>r){
            val2+=t;
            ST.upd(tin[v],tout[v],val2);
        }
    }
    elif (is_pred(v,u)){ /// trivial :)
        swap(u,v);
        ll val1=ST.get(tin[v],tout[v]);
        int kek=get_next(u,v);
        ll val2=ST.get(tout[kek]+1,tin[kek]-1);
        if (val1>r){
            val1+=t;
            ST.upd(tout[kek]+1,tin[kek]-1,val1);
        }
        if (val2>r){
            val2+=t;
            ST.upd(tin[v],tout[v],val2);
        }
    }
    else{ /// trivial :)
        ll val1=ST.get(tin[v],tout[v]);
        ll val2=ST.get(tin[u],tout[u]);
        if (val1>r){
            val1+=t;
            ST.upd(tin[u],tout[u],val1);
        }
        if (val2>r){
            val2+=t;
            ST.upd(tin[v],tout[v],val2);
        }
    }
}

void debug()
{
    for (int i=1;i<=n;i++){
        cout<<ST.get(tin[i],tin[i])<<" ";
    }
    cout<<"\n";
    cout<<string(20,'-')<<"\n";
}

void solve()
{
    cin>>n>>S>>P;
    for (int i=1;i<=n;i++){
        reb[i].clear();
    }
    T=0;
    for (int i=1;i<n;i++){
        int u,v;
        cin>>u>>v;
        reb[u].pb(v);
        reb[v].pb(u);
    }
    dfs1(1,1);
    ST=*new segment_tree(n);
    ST.upd(tin[S],tin[S],P); /// init dp
    int m;
    cin>>m;
    while (m--){
        ll u,v,r,t;
        cin>>u>>v>>r>>t;
        upd_way(u,v,r,t);
//        debug();
    }
    cout<<ST.get(1,n)<<"\n"; /// get max value of all vertex
}

main()
{
    #ifdef I_love_Maria_Ivanova
        files("barik");
        freopen("debug.txt","w",stderr);
    #endif

    fast;

    int test;
    cin>>test;
    while (test--){
        solve();
    }
}

 #include <bits/stdc++.h>

    using namespace std;

    const int MaxN = (int)4e5 + 10;
    const int MOD = (int)1e9 + 7;
    const int INF = (int)1e9;

    const int MaxL = 19;

    int n, in[MaxN], out[MaxN];
    int timer, s, p, m, up[MaxN][MaxL];
    vector < int > g[MaxN];
    long long dp[MaxN];
    long long tr[4 * MaxN], add[4 * MaxN];

    void dfs(int v, int p) {
        in[v] = ++timer;
        up[v][0] = p;
        for (int i = 1; i < MaxL; ++i) {
            up[v][i] = up[up[v][i - 1]][i - 1];
        }
        for (int i = 0; i < (int)g[v].size(); ++i) {
            int to = g[v][i];
            if (to == p) {
                continue;
            }
            dfs(to, v);
        }
        out[v] = timer;
    }

    bool isPar(int u, int v) {
        return in[u] <= in[v] && out[v] <= out[u];
    }

    int getPar(int u, int v) {
        for (int i = MaxL - 1; i >= 0; --i) {
            if (up[u][i] != v && isPar(v, up[u][i])) {
                u = up[u][i];
            }
        }
        return u;
    }

    void push(int v, int L, int R) {
        if (L != R) {
            add[v + v] = max(add[v + v], add[v]);
            add[v + v + 1] = max(add[v + v + 1], add[v]);
        }
        tr[v] = max(tr[v], add[v]);
    }

    void upd(int v, int L, int R, int l, int r, long long val) {
        if (l > r) {
            return;
        }
        push(v, L, R);
        if (L == l && r == R) {
            add[v] = max(add[v], val);
            push(v, L, R);
            return;
        }
        int M = (L + R) / 2;
        push(v, L, R);
        if (r <= M) {
            upd(v + v, L, M, l, r, val);
            push(v + v + 1, M + 1, R);
        } else if (l > M) {
            push(v + v, L, M);
            upd(v + v + 1, M + 1, R, l, r, val);
        } else {
            upd(v + v, L, M, l, M, val);
            upd(v + v + 1, M + 1, R, M + 1, r, val);
        }
        tr[v] = max(tr[v + v], tr[v + v + 1]);
        tr[v] = max(tr[v], add[v]);
    }

    long long get(int v, int L, int R, int l, int r) {
        if (l > r) {
            return -1LL << 60;
        }
        tr[v] = max(tr[v], add[v]);
        push(v, L, R);
        if (L == l && r == R) {
            return tr[v];
        }
        int M = (L + R) / 2;
        push(v, L, R);
        if (r <= M) {
            push(v + v + 1, M + 1, R);
            return get(v + v, L, M, l, r);
        }
        if (l > M) {
            push(v + v, L, M);
            return get(v + v + 1, M + 1, R, l, r);
        }
        return max(get(v + v, L, M, l, M), get(v + v + 1, M + 1, R, M + 1, r));
    }

    void build(int v, int l, int r) {
        if (l != r) {
            build(v + v, l, (l + r) / 2);
            build(v + v + 1, (l + r) / 2 + 1, r);
            tr[v] = max(tr[v + v], tr[v + v + 1]);
        } else {
            tr[v] = dp[l];
        }
        add[v] = -1LL << 60;
    }

    void solve() {
        scanf("%d%d%d", &n, &s, &p);
        for (int i = 1; i <= n; ++i) {
            dp[i] = -1LL << 60;
        }
        for (int i = 0; i < n - 1; ++i) {
            int x, y;
            scanf("%d%d", &x, &y);
            g[x].push_back(y);
            g[y].push_back(x);
        }
        dfs(1, 0); //we need to know in[v]..out[v] for every node, it really simplifies the solution for current problem
        dp[in[s]] = p; //using DFS-order, dp[v] contains in dp[in[v]]
        build(1, 1, n); //building the segment tree for DP
        scanf("%d", &m);
        for (int it = 0; it < m; ++it) {
            int u, v, r, t;
            scanf("%d%d%d%d", &u, &v, &r, &t);
            //possible 3 cases:
            r++;
            //1: u is parent of v in DFS-order, then we need to try to update
            //the DP for Batman from nodes that are up on u and sons of u that
            //aren't parents of v -> (subtree v)
            //(subtree v) -> (the tree above u, u and sons of u that aren't parents of v)
            //thes segments are continuous in the DFS-order, we can apply segment tree with lazy propagation
            //for the next function A[x] = max(A[x], Value), X = L..R
            if (isPar(u, v)) {
                int w = getPar(v, u);
                long long X = max(get(1, 1, n, 1, in[w] - 1), get(1, 1, n, out[w] + 1, n));
                long long Y = get(1, 1, n, in[v], out[v]);
                if (X >= r) {
                    upd(1, 1, n, in[v], out[v], X + t);
                }
                if (Y >= r) {
                    upd(1, 1, n, 1, in[w] - 1, Y + t);
                    upd(1, 1, n, out[w] + 1, n, Y + t);
                }
            } else if (isPar(v, u)) { // V is parent of U
                //Absolutely similar case to the case of above
                //Cause the direction doesn't matter
                int w = getPar(u, v);
                long long X = get(1, 1, n, in[u], out[u]);
                long long Y = max(get(1, 1, n, 1, in[w] - 1), get(1, 1, n, out[w] + 1, n));
                if (X >= r) {
                    upd(1, 1, n, 1, in[w] - 1, X + t);
                    upd(1, 1, n, out[w] + 1, n, X + t);
                }
                if (Y >= r) {
                    upd(1, 1, n, in[u], out[u], Y + t);
                }
            } else { //The easiest case
                //U isn't parent of V and V isn't parent of U
                //Batman can go only from 
                //(subtree u) -> (subtree v)
                //(subtree v) -> (subtree u)
                //and reclalculating DP:
                long long X = get(1, 1, n, in[u], out[u]);
                long long Y = get(1, 1, n, in[v], out[v]);
                if (X >= r) {
                    upd(1, 1, n, in[v], out[v], X + t);
                }
                if (Y >= r) {
                    upd(1, 1, n, in[u], out[u], Y + t);
                }
            }
        }
        for (int i = 1; i <= n; ++i) {
            g[i].clear();
        }
        //outputting the maximal value over all dp[v]
        cout << max(tr[1], add[1]) << "\n";
        timer = 0;
    }

    int main() {
    //  freopen("input.txt", "r", stdin);
        int t;
        scanf("%d", &t);
    //  t = 10;
        while (t --> 0) {
            solve();
        }
        return 0;
    }

ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA $dp[v]=max($Є$ТЬСЯ,ЬСЯ)$ ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYATʹSYAВИ ВИПУСКАЄТЬСЯVYTʹSYAВИ ВИПУСКАЄТЬСЯVYИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYATʹSYAВИ ВИПУСКАЄТ$u,v$ ИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYATʹSYAВИ ВИПУСКАЄТИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYATʹSYAВИ ВИПУСКАЄТИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYATʹSYAВИ ВИПУСКАЄТИПУСКАЄТЬСЯVY VYPUSKAYETʹSYAВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYA ВИ ВИПУСКАЄТЬСЯVY VYPUSKAYETʹSYATʹSYAВИ ВИПУСКАЄТ

Let's read $in [v], out [v]$ as the input and output time in the tree's traversal. We will maintain online $dp [v]$ - the maximum force that can be obtained if we are at the vertex v. Initially, $dp [i] = - inf$, $i\neq S;$ $dp [s] = p.$

To update $dp$, you need to find a maximum of $dp$ in no more than two segments. Let it be equal to $m_x$. If $m_x> r$, then you need to update the values ​​of $dp$ also at no more than two segments through $m_x + t$. Under the segments we mean the set of vertices for which they $in [i]$ form a continuous interval of numbers. To do this, you can use a tree of segments with a lazy push. Complexity $O (m * log (n))$.

Currently Empty

If input is a positive number, return it. If input is a negative number, multiply it with -1 to make it positive and then return it. This is abs() function in simple words.

Recall that we are using an if-else-if ladder. An else or else-if block (of statements) will not execute if condition of any of the $if's$ above it are satisfied which leads to that $if$ block being executed. Atmost one of the blocks get executed.

$\implies$ if our second condition ($N$ is even) didnt execute, then $N$ is odd.

#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>

#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define files(name) name!=""?freopen(name".in","r",stdin),freopen(name".out","w",stdout):0
#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define elif else if
#define mp make_pair
#define pb push_back
#define fir first
#define sec second

using namespace std;
#define int long long

typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef long long ll;

const int arr=2e5+10;
const int ar=2e3+10;
const ld pi=acos(-1);
const ld eps=1e-10;
const ll md=1e9+7;

///---program start---///

void solve()
{
    int a,b,n;
    cin>>a>>b>>n;
    if (n%2==0){
        int ans=0;
        a=abs(a);
        b=abs(b);
        if (a>b){
            ans=1;
        }
        elif (a<b){
            ans=2;
        }
        else{
            ans=0;
        }
        cout<<ans<<"\n";
    }
    else{
        pii cur1={a<0?-1:a==0?0:1,a};
        pii cur2={b<0?-1:b==0?0:1,a};
        if (cur1.fir>cur2.fir){
            cout<<1<<"\n";
        }
        elif (cur1.fir<cur2.fir){
            cout<<2<<"\n";
        }
        else{
            if (cur1.fir<0){
                if (abs(a)<abs(b)){
                    cout<<1<<"\n";
                }
                elif (abs(a)>abs(b)){
                    cout<<2<<"\n";
                }
                else{
                    cout<<0<<"\n";
                }
            }
            elif (cur1.fir==0){
                cout<<0<<"\n";
            }
            else{
                if (abs(a)<abs(b)){
                    cout<<3-1<<"\n";
                }
                elif (abs(a)>abs(b)){
                    cout<<3-2<<"\n";
                }
                else{
                    cout<<0<<"\n";
                }
            }
        }
    }
}

main()
{
    #ifdef I_love_Maria_Ivanova
        files("barik");
        freopen("debug.txt","w",stderr);
    #endif

    int test;
    cin>>test;
    while (test--){
        solve();
    }
}

#include <bits/stdc++.h>

using namespace std;

const int MaxN = (int)4e5 + 10;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;

void solve() {
    int a, b, n;
    scanf("%d%d%d", &a, &b, &n);
    if (a == b || (n % 2 == 0 && a + b == 0)) {
        printf("0\n");
        return;
    }
    if (n % 2 == 0) {
        printf("%d\n", 1 + (abs(b) > abs(a)));
        return;
    }
    if ((a < 0) != (b < 0)) {
        printf("%d\n", 1 + (a < 0));
        return;
    }
    printf("%d\n", 1 + (a < b));
}

int main() {
//  freopen("input.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while (t --> 0) {
        solve();
    }
    return 0;
}

Say signs are not same. A simple comparison will tell which number is positive (as a positive number is always greater!) and hence no need to consider sign here. Say signs are same, again we handle this case by checking which of the two is greater.

Exponents are same!! Hence, a larger number raised to power $n$ is always greater than smaller number raised to power $n$!!

Currently Empty