Add files via upload

BrandonTang89 · web-flow · commit 3ae329a803fe · 2024-11-10T20:21:39.000Z
diff --git a/Other_Tasks/CF2028_A_Alice_s_Adventures_in_Chess.py b/Other_Tasks/CF2028_A_Alice_s_Adventures_in_Chess.py
@@ -0,0 +1,25 @@
+for _ in range(int(input())):
+    n, a, b = map(int, input().split())
+    moves = input()
+
+    dx = {"N": 0, "S": 0, "E": 1, "W": -1}
+    dy = {"N": 1, "S": -1, "E": 0, "W": 0}
+    x, y = 0, 0
+
+    found = False
+    for _ in range(30):
+        for move in moves:
+            x += dx[move]
+            y += dy[move]
+
+            if x == a and y == b:
+                found = True
+                break
+
+        if found:
+            break
+
+    if found:
+        print("YES")
+    else:
+        print("NO")
diff --git a/Other_Tasks/CF2028_B_Alice_s_Adventures_in_Permuting.py b/Other_Tasks/CF2028_B_Alice_s_Adventures_in_Permuting.py
@@ -0,0 +1,26 @@
+for _ in range(int(input())):
+    n, b, c = map(int, input().split())
+    if n == 1:
+        if c == 0:
+            print(0)
+        else:
+            print(1)
+        continue
+
+    if b == 0:
+        if n > c + 2:
+            print(-1)
+        else:
+            if n == c + 1 or n == c + 2:
+                print(n - 1)
+            else:
+                print(n)
+        continue
+
+    maxI = (n - 1 - c) // b
+    maxI = max(maxI, -1)
+
+    numSkipped = maxI + 1
+    numLeft = n - numSkipped
+
+    print(numLeft)
diff --git a/Other_Tasks/CF2028_C_Alice_s_Adventures_in_Cutting_Cake.cpp b/Other_Tasks/CF2028_C_Alice_s_Adventures_in_Cutting_Cake.cpp
@@ -0,0 +1,119 @@
+#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);
+
+template <typename T = ll>
+struct StaticSum {
+    const int n;
+    vector<T> pfs;  // arr[i] contains the range sum from 0 to i inclusively
+
+    T rsq(int l, int r) const {              // range sum from l to r inclusively
+        if (r < l) assert(false);            // invalid input
+        if (l < 0 || r >= n) assert(false);  // boundary condition check
+        if (l == 0) return pfs[r];
+        return (pfs[r] - pfs[l - 1]);
+    }
+
+    StaticSum(const vector<T>& arr) : n(arr.size()), pfs(arr) {
+        for (int i = 1; i < n; i++) {
+            pfs[i] += pfs[i - 1];
+        }
+    }
+};
+
+int main() {
+    fast_cin();
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        ll n, m, v;
+        cin >> n >> m >> v;
+        vector<ll> arr(n + 1);
+
+        for (int i = 0; i < n; i++) {
+            cin >> arr[i];
+        }
+
+        vector<ll> brr(n + 1, 0);  // brr[i] is the maximum number of animals that can be fed from arr[i] onward inclusive
+        int curFood = 0;
+        int curAnimals = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            curFood += arr[i];
+            if (curFood >= v) {
+                curAnimals++;
+                curFood = 0;
+            }
+            brr[i] = curAnimals;
+        }
+
+        vector<ll> crr(n + 1);  // crr[i] is the maximum number of animals that can be fed from arr[0] to arr[i] inclusive
+        curFood = 0;
+        curAnimals = 0;
+        for (int i = 0; i < n; i++) {
+            curFood += arr[i];
+            if (curFood >= v) {
+                curAnimals++;
+                curFood = 0;
+            }
+            crr[i] = curAnimals;
+        }
+
+        if (crr[n - 1] < m) {  // not enough to feed m animals
+            cout << -1 << endl;
+            continue;
+        }
+
+        ll ans = 0;
+        StaticSum<ll> ss(arr);
+
+        int right = 0;
+        int animalsFed = brr[right];
+        while (animalsFed >= m) {
+            right++;
+            animalsFed = brr[right];
+        }
+        right--;
+        animalsFed = brr[right];
+
+        if (right - 1 >= 0) {
+            ans = max(ans, ss.rsq(0, right - 1));  // all animals on the right of what we eat
+        }
+        // cout << "right: " << right << " ans: " << ans << endl;
+
+        int left = 0;
+        for (int i = 1; i < m; i++) {
+            // i animals on the left, m-i animals on the right
+            while (crr[left] < i) {
+                left++;
+            }
+
+            while (brr[right] >= m - i) {
+                right++;
+            }
+            right--;
+
+            // cout << "i = " << i << " left = " << left << " right = " << right << endl;
+            if (left + 1 <= right - 1) ans = max(ans, ss.rsq(left + 1, right - 1));
+        }
+
+        while (crr[left] < m) {
+            left++;
+        }
+
+        // cout << "left: " << left << " ans: " << ans << endl;
+
+        if (left + 1 <= n - 1) ans = max(ans, ss.rsq(left + 1, n - 1));  // all animals on the left
+
+        cout << ans << endl;
+    }
+
+    return 0;
+}
diff --git a/Other_Tasks/CF2028_D_Alice_s_Adventures_in_Cards.cpp b/Other_Tasks/CF2028_D_Alice_s_Adventures_in_Cards.cpp
@@ -0,0 +1,104 @@
+#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() {
+    fast_cin();
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        int n;
+        cin >> n;
+        vector<pair<int, int>> arr(n);
+        for (int i = 0; i < n; i++) {
+            cin >> arr[i].first;
+            arr[i].first -= 1;
+            arr[i].second = i;
+        }
+
+        vector<pair<int, int>> brr(n);
+        for (int i = 0; i < n; i++) {
+            cin >> brr[i].first;
+            brr[i].first -= 1;
+            brr[i].second = i;
+        }
+
+        vector<pair<int, int>> crr(n);
+        for (int i = 0; i < n; i++) {
+            cin >> crr[i].first;
+            crr[i].first -= 1;
+            crr[i].second = i;
+        }
+
+        vector<tuple<int, int, int>> cards;
+        for (int i = 0; i < n; i++) {
+            cards.push_back({arr[i].first, brr[i].first, crr[i].first});
+        }
+
+        auto [a, b, c] = cards[0];
+        int maxa = 0;
+        int maxb = 0;
+        int maxc = 0;
+
+        sort(arr.begin(), arr.end());
+        sort(brr.begin(), brr.end());
+        sort(crr.begin(), crr.end());
+
+        vector<bool> unlocked(n, false);
+        vector<pair<int, char>> unlocker(n, {-1, -1});
+        unlocked[0] = true;
+        for (int i = 0; i < n; i++) {
+            if (!unlocked[i]) continue;
+
+            auto [newmaxA, newmaxB, newmaxC] = cards[i];
+
+            for (int a = maxa; a <= newmaxA; a++) {
+                if (unlocked[arr[a].second]) continue;
+                unlocked[arr[a].second] = true;
+                unlocker[arr[a].second] = {i, 'q'};
+            }
+            for (int b = maxb; b <= newmaxB; b++) {
+                if (unlocked[brr[b].second]) continue;
+                unlocked[brr[b].second] = true;
+                unlocker[brr[b].second] = {i, 'k'};
+            }
+            for (int c = maxc; c <= newmaxC; c++) {
+                if (unlocked[crr[c].second]) continue;
+                unlocked[crr[c].second] = true;
+                unlocker[crr[c].second] = {i, 'j'};
+            }
+
+            maxa = max(maxa, newmaxA);
+            maxb = max(maxb, newmaxB);
+            maxc = max(maxc, newmaxC);
+        }
+
+        if (unlocked[n - 1]) {
+            cout << "YES" << endl;
+            vector<pair<char, int>> ans;
+            int cur = n - 1;
+            while (cur != 0) {
+                ans.push_back({unlocker[cur].second, cur});
+                cur = unlocker[cur].first;
+            }
+
+            reverse(ans.begin(), ans.end());
+            cout << ans.size() << endl;
+            for (auto [c, i] : ans) {
+                cout << c << " " << i + 1 << endl;
+            }
+        } else {
+            cout << "NO" << endl;
+        }
+    }
+
+    return 0;
+}
diff --git a/Other_Tasks/CF2028_E_Alice_s_Adventures_in_the_Rabbit_Hole.cpp b/Other_Tasks/CF2028_E_Alice_s_Adventures_in_the_Rabbit_Hole.cpp
@@ -0,0 +1,117 @@
+#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);
+
+constexpr ll MOD = 998244353;
+int n;
+vector<vector<int>> adjlist;
+vector<int> visited;
+vector<int> parent;
+vector<ll> depth;
+
+constexpr ll mod(ll a, ll n) { return (a % n + n) % n; }
+constexpr ll extEuclid(ll a, ll b, ll &x, ll &y) {  // pass x and y by ref
+    ll xx = y = 0;
+    ll yy = x = 1;
+    while (b) {  // repeats until b == 0
+        ll q = a / b;
+        tie(a, b) = tuple(b, a % b);
+        tie(x, xx) = tuple(xx, x - q * xx);
+        tie(y, yy) = tuple(yy, y - q * yy);
+    }
+    return a;  // returns gcd(a, b)
+               // ax + by = gcd(a, b)
+}
+constexpr ll modInverse(ll a, ll n) {  // returns modular inverse of a mod n
+    ll x, y;
+    extEuclid(a, n, x, y);
+    return mod(x, n);
+}
+
+void labelDfs(int u) {
+    visited[u] = 1;
+    for (int v : adjlist[u]) {
+        if (visited[v] == 0) {
+            parent[v] = u;
+            depth[v] = depth[u] + 1;
+            labelDfs(v);
+        }
+    }
+}
+
+int main() {
+    fast_cin();
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        cin >> n;
+        adjlist.assign(n, vector<int>());
+
+        visited.assign(n, 0);
+        parent.assign(n, -1);
+        depth.assign(n, 0);
+
+        for (int i = 0; i < n - 1; i++) {
+            int u, v;
+            cin >> u >> v;
+            u--;
+            v--;
+            adjlist[u].push_back(v);
+            adjlist[v].push_back(u);
+        }
+
+        // root at 0
+        depth[0] = 0;
+        labelDfs(0);
+
+        vector<pair<int, int>> leaves;  // (depth, node)
+        for (int i = 1; i < n; i++) {
+            if (adjlist[i].size() == 1) {
+                leaves.push_back({depth[i], i});
+            }
+        }
+
+        sort(leaves.begin(), leaves.end());  // shallowest leaves first
+
+        vector<ll> num(n, -1);  // numerator of the probablity
+        vector<ll> den(n, 0);   // denominator of the probability
+
+        num[0] = 1;
+        den[0] = 1;
+
+        for (auto [d, leaf] : leaves) {
+            int u = leaf;
+            int chainLength = 0;  // counts leaf until first finished node (not including finished node)
+            while (num[u] == -1) {
+                u = parent[u];
+                chainLength++;
+            }
+            ll numFactor = num[u];
+            ll denFactor = den[u];
+
+            u = leaf;
+            int idx = 0;
+            while (num[u] == -1) {
+                num[u] = (numFactor * idx) % MOD;
+                den[u] = (denFactor * chainLength) % MOD;
+                u = parent[u];
+                idx++;
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            cout << (num[i] * modInverse(den[i], MOD)) % MOD << " ";
+        }
+        cout << endl;
+    }
+
+    return 0;
+}
