Merge branch 'opencodeiiita:main' into main

Author: suzzzal

Problems/Binary-Search/Day-10/q001.md

@@ -0,0 +1 @@
+[PROBLEM LINK](https://codeforces.com/contest/2169/problem/D1)

Problems/Binary-Search/Day-10/q002.md

@@ -0,0 +1 @@
+[PROBLEM LINK](https://www.codechef.com/problems/PERRANGES?tab=statement)

Problems/Data-structures/Day-09/sol/Aiyaan_Mahajan/q2sol.cpp

@@ -0,0 +1,80 @@
+/*
+DAY 8
+Q2 Enemy Is Weak
+
+*/
+/*
+
+
+For each position j (as middle element), count how many elements on its left are greater than a[j] and how many on its right are smaller than a[j]. Multiply these two counts - this gives triplets with j as middle. Sum this for all positions.
+Use Fenwick Tree (BIT) to efficiently count elements in ranges. Since values go up to 10^9, compress them to 1..n first. Two passes: left-to-right for greater left counts, right-to-left for smaller right counts.
+
+*/
+#include <bits/stdc++.h>
+using namespace std;
+
+int ft[1000005];
+int n;
+
+void upd(int idx, int val){
+    for(; idx<=n; idx+=idx&-idx)
+        ft[idx]+=val;
+}
+
+int qry(int idx){
+    int ans=0;
+    for(; idx>0; idx-=idx&-idx)
+        ans+=ft[idx];
+    return ans;
+}
+
+int main(){
+    cin>>n;
+    vector<int> a(n);
+    for(int i=0;i<n;i++) cin>>a[i];
+    
+    // compress coordinates 
+    vector<int> sorted_vals=a;
+    sort(sorted_vals.begin(),sorted_vals.end());
+    map<int,int> mp;
+    for(int i=0;i<n;i++){
+        mp[sorted_vals[i]]=i+1;
+    }
+    
+    vector<int> compressed(n);
+    for(int i=0;i<n;i++){
+        compressed[i]=mp[a[i]];
+    }
+    
+    vector<long long> left_cnt(n), right_cnt(n);
+    
+    // left pass
+    memset(ft,0,sizeof(ft));
+    for(int i=0;i<n;i++){
+        int pos=compressed[i];
+        left_cnt[i]=qry(n)-qry(pos);
+        upd(pos,1);
+    }
+    
+    // right pass
+    memset(ft,0,sizeof(ft));
+    for(int i=n-1;i>=0;i--){
+        int pos=compressed[i];
+        right_cnt[i]=qry(pos-1);
+        upd(pos,1);
+    }
+    
+    long long ans=0;
+    for(int i=0;i<n;i++){
+        ans+=left_cnt[i]*right_cnt[i];
+    }
+    
+    cout<<ans<<"\n";
+    
+    return 0;
+}
+
+//Tc =O(nlogn) per test  SC = O(n)
+/*
+My submission : https://codeforces.com/contest/61/submission/356391525
+*/

Problems/Data-structures/Day-09/sol/BEESA-MANISH/Solution1.cpp

@@ -0,0 +1,76 @@
+/*
+Submission link - https://cses.fi/problemset/result/15829712/
+
+TC - o((N + Q) log(N+Q) )
+SC - O(N + Q)
+
+Approach (Simple & Short):
+
+Compress salary values since they can be as large as 10^9.
+Use a Fenwick Tree to store and manage salary frequencies.
+On updates, reduce the count of the old salary and increase the new one.
+For range queries, get the answer using prefix sums from the Fenwick Tree.
+
+*/
+
+
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 600005;
+int n, q;
+int cur_p[200005];
+int t[N];
+struct Query {
+    int type, a, b;
+} qs[200005];
+ 
+void add(int i, int v) {
+    for (; i < N; i += i & -i) t[i] += v;
+}
+ 
+int sum(int i) {
+    int s = 0;
+    for (; i > 0; i -= i & -i) s += t[i];
+    return s;
+}
+ 
+int main() {
+    ios::sync_with_stdio(0); cin.tie(0);
+    cin >> n >> q;
+    vector<int> coords;
+    for (int i = 1; i <= n; i++) {
+        cin >> cur_p[i];
+        coords.push_back(cur_p[i]);
+    }
+    for (int i = 0; i < q; i++) {
+        char op; cin >> op;
+        cin >> qs[i].a >> qs[i].b;
+        if (op == '!') {
+            qs[i].type = 1;
+            coords.push_back(qs[i].b);
+        } else {
+            qs[i].type = 2;
+            coords.push_back(qs[i].a);
+            coords.push_back(qs[i].b);
+        }
+    }
+    sort(coords.begin(), coords.end());
+    coords.erase(unique(coords.begin(), coords.end()), coords.end());
+ 
+    auto get_idx = [&](int x) {
+        return lower_bound(coords.begin(), coords.end(), x) - coords.begin() + 1;
+    };
+ 
+    for (int i = 1; i <= n; i++) add(get_idx(cur_p[i]), 1);
+ 
+    for (int i = 0; i < q; i++) {
+        if (qs[i].type == 1) {
+            add(get_idx(cur_p[qs[i].a]), -1);
+            cur_p[qs[i].a] = qs[i].b;
+            add(get_idx(cur_p[qs[i].a]), 1);
+        } else {
+            cout << sum(get_idx(qs[i].b)) - sum(get_idx(qs[i].a) - 1) << "\n";
+        }
+    }
+    return 0;
+}

Problems/Data-structures/Day-09/sol/BEESA-MANISH/Solution2.cpp

@@ -0,0 +1,72 @@
+/*
+
+Submission link: https://codeforces.com/contest/61/submission/356395307
+
+TC- o(n log n)
+SC - o(n)
+
+Approach:
+Take each element as one by one and treat that element as middle element,count number of elements greater than that element on left side of that element and count
+number of elements smaller than that element on right side of that element. 
+
+Use a Fenwick Tree (Binary Indexed Tree) to efficiently count elements in ranges, Since array values can be as large as 10^9, first compress the values to ranks 1..n
+
+Do the left to right pass in Fenwick tree to count number of elements greater than current element on left side.
+
+Reset Fenwick tree and do right to left pass to count number of elements smaller than current element on right side.
+
+Finally, for each element multiply the two counts and sum them up to get the final answer.
+
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+const int N = 1000005;
+int n;
+int a[N], t[N];
+int l_big[N], r_small[N];
+
+void add(int i, int v) {
+    for (; i <= n; i += i & -i) t[i] += v;
+}
+
+int sum(int i) {
+    int s = 0;
+    for (; i > 0; i -= i & -i) s += t[i];
+    return s;
+}
+
+int main() {
+    ios::sync_with_stdio(0); cin.tie(0);
+    cin >> n;
+    vector<int> v;
+    for (int i = 0; i < n; i++) {
+        cin >> a[i];
+        v.push_back(a[i]);
+    }
+    sort(v.begin(), v.end());
+
+    for (int i = 0; i < n; i++) {
+        int rk = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
+        l_big[i] = i - sum(rk);
+        add(rk, 1);
+    }
+
+    memset(t, 0, sizeof(t));
+
+    for (int i = n - 1; i >= 0; i--) {
+        int rk = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
+        r_small[i] = sum(rk - 1);
+        add(rk, 1);
+    }
+
+    ll total = 0;
+    for (int i = 0; i < n; i++) {
+        total += (ll)l_big[i] * r_small[i];
+    }
+    cout << total << endl;
+
+    return 0;
+}

Problems/Data-structures/Day-09/sol/Krishna200608/Solution1.cpp

@@ -0,0 +1,140 @@
+/*
+Submission Link:
+https://cses.fi/paste/df31068806cfc4bef186a9/
+*/
+
+/*
+Problem: Salary Queries
+Link: https://cses.fi/problemset/task/1144/
+Author: Krishna200608
+
+Short Problem Statement:
+Maintain an array of salaries. Process queries to update a salary or count employees
+with salaries in a range [a, b]. Values up to 10^9 require coordinate compression.
+
+Approach:
+    Coordinate Compression: Collect all initial salaries and update values.
+    Sort and remove duplicates to map large values to indices.
+    Use a Fenwick Tree (BIT) over compressed indices.
+    Point updates for salary changes.
+    Range queries using prefix sums on BIT.
+
+Time : O(Q log(N+Q))
+Space Complexity: O(N+Q)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+#define MOD 1000000007
+const int M = 1e9 + 7;
+const double PI = acos(-1.0);
+#define INF 1e18
+#define pb push_back
+#define ppb pop_back
+#define ll long long
+#define no cout << "NO" << endl
+#define yes cout << "YES" << endl
+#define ff first
+#define ss second
+#define inn(x) int x; cin >> x
+#define ill(x) ll x; cin >> x
+#define all(x) x.begin(), x.end()
+#define in(a) for (int i = 0; i < (int)a.size(); i++) cin >> a[i]
+#define out(a) for (int i = 0; i < (int)a.size(); i++) cout << a[i] << " "
+typedef vector<int> vi;
+typedef vector<ll> vll;
+#define ceil_div(n, x) (((n) % (x) == 0) ? ((n) / (x)) : ((n) / (x) + 1))
+#define debug(x) cout << "x -> " << x << endl
+#define outt(x) cout << x << endl
+#define endl "\n"
+
+const int MAX_M = 600005;
+int bit[MAX_M];
+int max_val;
+
+void update(int idx, int val) {
+    for (; idx <= max_val; idx += idx & -idx)
+        bit[idx] += val;
+}
+
+int query(int idx) {
+    int sum = 0;
+    for (; idx > 0; idx -= idx & -idx)
+        sum += bit[idx];
+    return sum;
+}
+
+void solve() {
+    int n, q;
+    if (!(cin >> n >> q)) return;
+
+    vi p(n);
+    vi vals;
+
+    for (int i = 0; i < n; i++) {
+        cin >> p[i];
+        vals.pb(p[i]);
+    }
+
+    struct Qry {
+        char type;
+        int k, x;
+    };
+
+    vector<Qry> qs(q);
+
+    for (int i = 0; i < q; i++) {
+        cin >> qs[i].type >> qs[i].k >> qs[i].x;
+        if (qs[i].type == '!') vals.pb(qs[i].x);
+    }
+
+    sort(all(vals));
+    vals.erase(unique(all(vals)), vals.end());
+    max_val = vals.size();
+
+    auto get_idx = [&](int v) {
+        return lower_bound(all(vals), v) - vals.begin() + 1;
+    };
+
+    for (int x : p) {
+        update(get_idx(x), 1);
+    }
+
+    for (int i = 0; i < q; i++) {
+        if (qs[i].type == '!') {
+            int k = qs[i].k - 1;
+            int x = qs[i].x;
+            update(get_idx(p[k]), -1);
+            p[k] = x;
+            update(get_idx(x), 1);
+        } else {
+            int a = qs[i].k;
+            int b = qs[i].x;
+
+            int r = upper_bound(all(vals), b) - vals.begin();
+            int l = lower_bound(all(vals), a) - vals.begin();
+
+            outt(query(r) - query(l));
+        }
+    }
+}
+
+signed main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(nullptr);
+    cout.tie(nullptr);
+
+    auto begin = chrono::high_resolution_clock::now();
+
+    int t = 1;
+    while (t--) {
+        solve();
+    }
+
+    auto end = chrono::high_resolution_clock::now();
+    auto elapsed = chrono::duration_cast<chrono::nanoseconds>(end - begin);
+    cerr << "Time measured: " << elapsed.count() * 1e-6 << "ms";
+
+    return 0;
+}