Merge branch 'Sol1Day2' of https://github.com/sahsudhanshu/CP-Chronicles into Sol1Day2

Author: sahsudhanshu

Problems/Mathematics/Day-01/sol/Naman Pal/day001sol02.cpp

@@ -0,0 +1,59 @@
+Submission Link: https://codeforces.com/contest/1225/submission/355608300
+
+/*
+So first I made a vector t which stores data of type pair(int, int) and a map c from vector storing pair(int, int) to int. Now I take input from user each element
+of array a given as input. Now, I do prime factorisation of the input number and if the power is not a multiple of k then I store it in vector t as 
+pair(prime no., power%k). After the loop runs up to the square root of a, if a is still not 1, then the remaining value is a prime number, so we store the pair (a, 1). 
+Then, I increment the value in the map c for the key t[i], which counts how many times this specific signature has appeared. Now in next for loop I made a vector s 
+which also store pair(int, int). Now, I iterated through all the pair in each vector of t and added a pair(p.first, k - p.second) to vector s. This creates the 
+"complement" signature—basically what prime factors and powers are missing to make a perfect k-th power. Then, I look up this vector s in the map c and add its 
+frequency to ans. I also check if s is equal to t[i] (meaning the number is its own complement); if so, I decrement ans by 1 to avoid counting the number pairing 
+with itself. Finally, I divide ans by 2 to remove double counting (since pair (A, B) and (B, A) are the same) and print the result.
+
+Time Complexity: O(N * sqrt(V)), where N is the number of elements and V is the maximum value of an element (since we iterate up to sqrt(V) for factorization).
+Space Complexity: O(N), as we store the prime signatures for all N elements in the vector and map.
+*/
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+    int n, k;
+    cin >> n >> k;
+
+    vector <pair <int, int> > t[n];
+    map<vector<pair<int, int>>, int> c;
+  
+    for (int i = 0; i < n; i++) {
+        int a;
+        cin >> a;
+        for (int j = 2; j * j <= a; j++) {
+            if (a % j == 0) {
+                int p = 0;
+                while (a % j == 0) {
+                    a /= j;
+                    p++;
+                }
+                if (p % k > 0) {
+                    t[i].push_back({j, p % k});
+                }
+            }
+        }
+        if (a != 1) {
+            t[i].push_back({a, 1});
+        }
+        c[t[i]]++;
+    }
+    long long ans = 0;
+    for (int i = 0; i < n; i++) {
+        vector<pair<int, int>> s;
+        for (pair<int, int> p : t[i]) {
+            s.push_back({p.first, k - p.second});
+        }
+        ans += c[s];
+        if (s == t[i]) {
+            ans--;
+        }
+    }
+    ans /= 2;
+    cout << ans << endl;
+}

Problems/Mathematics/Day-01/sol/Rushalverma/Solution2.cpp

@@ -0,0 +1,94 @@
+/*
+https://codeforces.com/contest/1225/submission/355245357
+
+time complexity: Factorization of each number using seive primes O(log maxA)
+                 total factorization cost - O(nlog maxA)
+                 Each number produces a vector of prime–exponent pairs mod k -> O(log maxA)
+                 total map work - O(nlong maxA)
+                 total complexity = O(nlog maxA)
+                 
+
+
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+using ll = long long;
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    ll k;
+    cin >> n >> k;
+
+    vector<ll> a(n);
+    ll mx = 0;
+    for(int i = 0; i < n; i++){
+        cin >> a[i];
+        mx = max(mx, a[i]);
+    }
+
+
+    ll LIM = sqrt(mx) + 2;
+    vector<int> primes;
+    vector<bool> is_prime(LIM+1, true);
+    is_prime[0] = is_prime[1] = false;
+    for(int i = 2; i <= LIM; i++){
+        if(is_prime[i]){
+            primes.push_back(i);
+            for(ll j = 1LL * i * i; j <= LIM; j += i)
+                is_prime[j] = false;
+        }
+    }
+
+    unordered_map<string, long long> cnt;
+    long long ans = 0;
+
+    for(int idx = 0; idx < n; idx++){
+        ll x = a[idx];
+
+        vector<pair<ll,ll>> v; 
+
+        for(int p: primes){
+            if(1LL * p * p > x) break;
+            if(x % p == 0){
+                ll c = 0;
+                while(x % p == 0){
+                    x /= p;
+                    c++;
+                }
+                c %= k;
+                if(c) v.push_back({p, c});
+            }
+        }
+
+        if(x > 1) v.push_back({x, 1 % k}); 
+
+        string key = "";
+        for(auto &pr: v){
+            key += to_string(pr.first) + "#" + to_string(pr.second) + "|";
+        }
+
+        vector<pair<ll,ll>> u;
+        for(auto &pr: v){
+            ll need = (k - pr.second) % k;
+            if(need) u.push_back({pr.first, need});
+        }
+
+        string key2 = "";
+        for(auto &pr: u){
+            key2 += to_string(pr.first) + "#" + to_string(pr.second) + "|";
+        }
+
+        ans += cnt[key2];
+
+
+        cnt[key]++;
+    }
+
+    cout << ans << "";
+    return 0;
+}

Problems/Mathematics/Day-02/sol/Arnav_Singh/.cph/.Solution1.cpp_8a03896c340660fc53d23e6afdd07dd2.prob

@@ -0,0 +1 @@
+{"name":"Local: Solution2","url":"\\\\wsl.localhost\\Ubuntu\\home\\arnav\\cp\\CP-Chronicles\\Problems\\Mathematics\\Day-02\\sol\\Arnav_Singh\\Solution2.cpp","tests":[{"id":1766903282354,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"\\\\wsl.localhost\\Ubuntu\\home\\arnav\\cp\\CP-Chronicles\\Problems\\Mathematics\\Day-02\\sol\\Arnav_Singh\\Solution2.cpp","group":"local","local":true}

Problems/Mathematics/Day-02/sol/Arnav_Singh/.cph/.Solution2.cpp_2ff86a5bba8a0489efed8cfae804bdee.prob

@@ -0,0 +1,60 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+long long fact[1005];
+const long long MOD = 1e9 + 7;
+void init() {
+    fact[0] = 1;
+    for (int i = 1; i <= 1000; i++)
+        fact[i] = fact[i - 1] * i % MOD;
+}
+long long modpow(long long a, long long b) {
+    long long res = 1;
+    while (b) {
+        if (b & 1) res = res * a % MOD;
+        a = a * a % MOD;
+        b >>= 1;
+    }
+    return res;
+}
+
+int main() {
+    init();
+     int t;
+    cin >> t;
+    while(t--) {
+        int n,k;
+        cin>>n>>k;
+        long long a[n];
+        for (int i = 0; i < n; ++i) {
+            cin>>a[i];
+        }
+        sort(a,a+n);
+        reverse(a,a+n);
+        long long repeat =a[k-1];
+        int avl=0;
+        unordered_map<long long,long long> m;
+        for (int i = 0; i < k; ++i) {
+            m[a[i]]++;
+        }
+        for (int i = 0; i < n; ++i) {
+            if(a[i]==repeat){
+                avl++;
+            }
+        }
+        int ans=1;
+        for(auto &[key,val]:m){
+            if(key==repeat){
+            ans = fact[avl] * modpow(fact[avl - val], MOD - 2) % MOD * modpow(fact[val], MOD - 2) % MOD;
+            }
+            else{
+                ans*=1;
+            }
+        }
+        cout << ans <<'\n';
+    }
+    
+    return 0;
+}
+//time complexity - O(nlogn)
+//https://codeforces.com/contest/1475/submission/355454659

Problems/Mathematics/Day-02/sol/Arnav_Singh/Solution2.cpp

@@ -0,0 +1,51 @@
+// submission link - https://codeforces.com/problemset/submission/1771/355587277
+
+#include <bits/stdc++.h>
+using namespace std;
+
+/*
+Approach:
+1. The maximum absolute difference between any two elements in the array
+   is always (maximum element - minimum element).
+2. A pair (ai, aj) is interesting only if one of them is the minimum value
+   and the other is the maximum value.
+3. Count how many times the minimum value appears (cntMin)
+   and how many times the maximum value appears (cntMax).
+4. Since (ai, aj) and (aj, ai) are considered different pairs,
+   the total number of interesting pairs is:
+      2 * cntMin * cntMax
+5. Special case:
+   - If all elements are equal (min == max), then every ordered pair
+     (i, j) with i ≠ j is valid.
+   - The answer becomes n * (n - 1).
+*/
+
+int main(){
+
+    int t;
+    cin >> t;
+    while(t--){
+        int n;
+        cin >> n;
+
+        vector<long long> a(n);
+        for(int i = 0; i < n; i++) cin >> a[i];
+
+        long long mn = *min_element(a.begin(), a.end());
+        long long mx = *max_element(a.begin(), a.end());
+
+        if(mn == mx){
+            cout << 1LL * n * (n - 1) << "\n";
+            continue;
+        }
+
+        long long cntMin = 0, cntMax = 0;
+        for(long long x : a){
+            if(x == mn) cntMin++;
+            if(x == mx) cntMax++;
+        }
+
+        cout << 2LL * cntMin * cntMax << "\n";
+    }
+    return 0;
+}

Problems/Mathematics/Day-02/sol/Arnav_Singh/Solution2.exe

@@ -0,0 +1,76 @@
+// submission llink - https://codeforces.com/contest/1475/submission/355598230
+
+#include <bits/stdc++.h>
+using namespace std;
+
+static const long long MOD = 1000000007;
+
+/*
+Approach:
+1. To maximize the total number of followers, we must select the k bloggers
+   with the largest follower counts.
+2. Sort the array in descending order.
+3. Let `threshold` be the k-th largest value (a[k-1] after sorting).
+4. All values greater than `threshold` must be selected.
+5. Among the bloggers with follower count equal to `threshold`:
+   - `need` = how many of them appear in the top k positions
+   - `total` = how many times `threshold` appears in the entire array
+6. The number of ways to choose these bloggers is:
+      C(total, need)
+7. Use factorials and modular inverses to compute combinations efficiently
+   modulo 1e9+7.
+*/
+
+long long modpow(long long a, long long b){
+    long long res = 1;
+    while(b){
+        if(b & 1) res = res * a % MOD;
+        a = a * a % MOD;
+        b >>= 1;
+    }
+    return res;
+}
+
+int main(){
+  
+    const int MAXN = 1000;
+    vector<long long> fact(MAXN + 1), invfact(MAXN + 1);
+
+    fact[0] = 1;
+    for(int i = 1; i <= MAXN; i++)
+        fact[i] = fact[i - 1] * i % MOD;
+
+    invfact[MAXN] = modpow(fact[MAXN], MOD - 2);
+    for(int i = MAXN; i > 0; i--)
+        invfact[i - 1] = invfact[i] * i % MOD;
+
+    auto comb = [&](int n, int r){
+        if(r < 0 || r > n) return 0LL;
+        return fact[n] * invfact[r] % MOD * invfact[n - r] % MOD;
+    };
+
+    int t;
+    cin >> t;
+    while(t--){
+        int n, k;
+        cin >> n >> k;
+
+        vector<int> a(n);
+        for(int i = 0; i < n; i++) cin >> a[i];
+
+        sort(a.begin(), a.end(), greater<int>());
+
+        int threshold = a[k - 1];
+        int need = 0, total = 0;
+
+        for(int i = 0; i < k; i++)
+            if(a[i] == threshold) need++;
+
+        for(int i = 0; i < n; i++)
+            if(a[i] == threshold) total++;
+
+        cout << comb(total, need) << "\n";
+    }
+
+    return 0;
+}