Add files via upload

Author: BrandonTang89

Other_Tasks/CF2029_A_Set.py

@@ -0,0 +1,5 @@
+t = int(input())
+for _ in range(t):
+    l, r, k = map(int, input().split())
+    q = r//k
+    print(max(0, q-l+1))

Other_Tasks/CF2029_B_Replacement.py

@@ -0,0 +1,27 @@
+t = int(input())
+
+for _ in range(t):
+    n = int(input())
+    s = [int(x) for x in str(input())]
+    
+    ones = s.count(1)
+    zeros = s.count(0)
+    
+    r = [int(x) for x in str(input())]
+    
+    if ones == 0 or zeros == 0:
+        print("NO")
+        continue
+    
+    for i in range(len(r)):
+        if ones == 0 or zeros == 0:
+            print("NO")
+            break
+        
+        if r[i] == 0:
+            ones -= 1
+        else:
+            zeros -= 1
+        
+    else:
+        print("YES")

Other_Tasks/CF2029_C_New_Rating.cpp

@@ -0,0 +1,51 @@
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>  
+using namespace std;
+
+typedef long long ll;
+typedef vector<int> vi;
+#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
+
+
+int main(){
+    int t;
+    cin >> t;
+    while (t--){
+        int n;
+        cin >> n;
+        vector<int> arr(n);
+        for (int i = 0; i < n; i++){
+            cin >> arr[i];
+        }
+
+        vector<int> oriRate(n); // original rating after looking through arr[0].. arr[i]
+
+        int x = 0;
+        for (int i = 0; i < n; i++){
+            if (arr[i] > x) x++;
+            else if (arr[i] < x) x--;
+            oriRate[i] = x;
+        }
+
+        vector <int> brr(n); // max rating post arr[0]..arr[i] assuming at least 1 skip
+        int cur = 0;
+        for (int i=0; i<n; i++){
+            brr[i] = cur;
+            cur = max(cur, (oriRate[i]));
+        }
+
+        vector<int> crr = brr;
+        for (int i=0; i<n-1; i++){
+            int nx = crr[i];
+            if (arr[i+1] > nx) nx++;
+            else if (arr[i+1] < nx) nx--;
+            crr[i+1] = max(crr[i+1], nx);
+        }   
+
+        cout << crr[n-1] << endl;
+
+    }
+
+    return 0;
+}

Other_Tasks/CF2029_D_Cool_Graph.cpp

@@ -0,0 +1,109 @@
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+typedef vector<int> vi;
+#define fast_cin()                    \
+    ios_base::sync_with_stdio(false); \
+    cin.tie(NULL);                    \
+    cout.tie(NULL);
+
+int n, e;
+vector<unordered_set<int>> adjlist;
+int main() {
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        cin >> n >> e;
+        adjlist.assign(n, unordered_set<int>());
+
+        vector<tuple<int, int, int>> ans;
+        for (int i = 0; i < e; i++) {
+            int u, v;
+            cin >> u >> v;
+            u--;
+            v--;
+            adjlist[u].insert(v);
+            adjlist[v].insert(u);
+        }
+
+        queue<int> q;  // nodes that have > degree 1
+        for (int i = 0; i < n; i++) {
+            if (adjlist[i].size() > 1) {
+                q.push(i);
+            }
+        }
+
+        while (!q.empty()) {
+            int u = q.front();
+            q.pop();
+            while (adjlist[u].size() > 1) {
+                int v1 = *adjlist[u].begin();
+                int v2 = *(++adjlist[u].begin());
+                assert(v1 != v2);
+
+                ans.emplace_back(u, v1, v2);
+                adjlist[v2].erase(u);
+                adjlist[v1].erase(u);
+                adjlist[u].erase(v1);
+                adjlist[u].erase(v2);
+                if (adjlist[v1].find(v2) == adjlist[v1].end()) {
+                    // delete each other too
+                    adjlist[v1].insert(v2);
+                    adjlist[v2].insert(v1);
+                } else {
+                    adjlist[v1].erase(v2);
+                    adjlist[v2].erase(v1);
+                }
+            }
+        }
+
+        vector<pair<int, int>> pairs;
+        vector<int> singles;
+
+        for (int i = 0; i < n; i++) {
+            if (adjlist[i].size() == 0) {
+                singles.push_back(i);
+            } else if (adjlist[i].size() == 1) {
+                if (i < *adjlist[i].begin()) pairs.emplace_back(i, *adjlist[i].begin());
+            } else {
+                assert(false);
+            }
+        }
+
+        if (pairs.size() == 0) {  // empty
+            assert(ans.size() <= 2 * max(n, e));
+
+            cout << ans.size() << endl;
+            for (auto [u, v1, v2] : ans) {
+                cout << u + 1 << " " << v1 + 1 << " " << v2 + 1 << endl;
+            }
+            continue;
+        }
+
+        // make a tree
+        int root = pairs[0].first;
+        for (int i = 1; i < pairs.size(); i++) {
+            ans.emplace_back(root, pairs[i].first, pairs[i].second);
+        }
+
+        int curl = pairs[0].first;
+        int curr = pairs[0].second;
+
+        for (auto s : singles) {
+            ans.emplace_back(curl, curr, s);
+            curr = curl;
+            curl = s;
+        }
+
+        cout << ans.size() << endl;
+        assert(ans.size() <= 2 * max(n, e));
+        for (auto [u, v1, v2] : ans) {
+            cout << u + 1 << " " << v1 + 1 << " " << v2 + 1 << endl;
+        }
+    }
+
+    return 0;
+}

Other_Tasks/CF2029_E_Common_Generator.cpp

@@ -0,0 +1,108 @@
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+typedef vector<int> vi;
+#define fast_cin()                    \
+    ios_base::sync_with_stdio(false); \
+    cin.tie(NULL);                    \
+    cout.tie(NULL);
+
+typedef long long ll;
+typedef vector<ll> vll;
+
+constexpr ll inf = 1e18;
+int _sieve_size;
+vector<ll> lowestpf, primes;
+void smallestPF(ll upperbound = (ll)4e5 + 2) {
+    _sieve_size = upperbound + 1;
+    lowestpf.assign(_sieve_size, inf);
+
+    for (ll i = 2; i < _sieve_size; i++) {
+        if (lowestpf[i] == inf) {
+            lowestpf[i] = i;
+            for (ll j = i * i; j < _sieve_size; j += i) {
+                lowestpf[j] = min(lowestpf[j], i);
+            }
+            primes.push_back(i);
+        }
+    }
+}  // Time: O(n log log n)
+
+vector<tuple<ll, ll>> prime_factorise_sieve(ll n) {
+    assert(n < _sieve_size && n >= 1);
+    vector<tuple<ll, ll>> prime_factors;
+    while (n != 1) {
+        ll p = lowestpf[n];
+        ll e = 0;
+        while (lowestpf[n] == p) {
+            n /= p;
+            e++;
+        }
+        prime_factors.push_back({p, e});
+    }
+    return prime_factors;
+}  // Time: O(log n)
+
+constexpr int top = 4e5;
+
+int main() {
+    fast_cin();
+    smallestPF();
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        vll arr(n);
+        for (int i = 0; i < n; i++) {
+            cin >> arr[i];
+        }
+
+        // check if any element is a prime
+        int numPrimes = 0;
+        int thePrime = -1;
+        for (int i = 0; i < n; i++) {
+            if (lowestpf[arr[i]] == arr[i]) {
+                numPrimes++;
+                thePrime = arr[i];
+            }
+        }
+
+        if (numPrimes == 0) {
+            cout << 2 << endl;
+            continue;
+        }
+        if (numPrimes == 1 && thePrime == 2) {
+            cout << 2 << endl;
+            continue;
+        }
+        if (numPrimes > 1) {
+            cout << -1 << endl;  // impossible
+            continue;
+        }
+
+        bool canDo = true;
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == thePrime) {
+                continue;
+            }
+            int pf = lowestpf[arr[i]];
+            if (thePrime * pf  > arr[i] && (thePrime * 2  > arr[i] - pf)) {
+                canDo = false;
+                break;
+            }
+        }
+
+        if (canDo) {
+            cout << thePrime << endl;
+        } else {
+            cout << -1 << endl;
+        }
+    }
+
+    return 0;
+}