Add files via upload

Author: BrandonTang89

Other_Tasks/CF2062_A_String.py

@@ -0,0 +1,3 @@
+
+for _ in range(int(input())):
+    print(input().count('1'))

Other_Tasks/CF2062_B_Clockwork.py

@@ -0,0 +1,16 @@
+for _ in range(int(input())):
+    
+    n = int(input())
+    
+    arr = [int(x) for x in input().split()]
+    
+    for i in range(n):
+        if arr[i] <= 2*i:
+            print("NO")
+            break
+        if arr[i] <= 2*(n-i-1):
+            print("NO")
+            break
+    else:
+        print("YES")
+    

Other_Tasks/CF2062_C_Cirno_and_Operations.py

@@ -0,0 +1,17 @@
+
+def diff(arr):
+    ans = [arr[i+1] - arr[i] for i in range(len(arr)-1)]
+    return ans
+
+for _ in range(int(input())):
+    n = int(input())
+    arr = [int(x) for x in input().split()]
+    
+    best = sum(arr)
+    while len(arr) > 1:
+        arr = diff(arr)
+        best = max(best, sum(arr))
+        best = max(best, -sum(arr))
+    
+    print(best)
+    

Other_Tasks/CF2062_D_Balanced_Tree.cpp

@@ -0,0 +1,78 @@
+#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);
+
+vector<vector<int>> adjlist;
+vector<int> visited;
+vector<int> parent;
+vector<ll> r, l;
+vector<pair<ll, ll>> memo; // value, totalIncrease
+
+void rootTree(int u){
+    visited[u] = 1;
+    for (auto v: adjlist[u]){
+        if (!visited[v]){
+            parent[v] = u;
+            rootTree(v);
+        }
+    }
+}
+
+pair<ll, ll> dp(int u){
+    if (memo[u].first != -1) return memo[u];
+
+    ll maxChildValue = 0;
+    ll totalIncrease = 0;
+    for (auto v: adjlist[u]){
+        if (v == parent[u]) continue;
+        pair<ll, ll> p = dp(v);
+        maxChildValue = max(maxChildValue, p.first);
+        totalIncrease += p.second;
+    }
+    ll thisValue = max(l[u], min(maxChildValue, r[u]));
+
+    for (auto v: adjlist[u]){
+        if (v == parent[u]) continue;
+        pair<ll, ll> p = dp(v);
+        totalIncrease += max(0LL, p.first - thisValue);
+    }
+
+    return memo[u] = {thisValue, totalIncrease};
+}
+
+int main(){
+    int tc;
+    cin >> tc;
+    while (tc--){
+        int n;
+        cin >> n;
+        adjlist.assign(n, vector<int>());
+        l.assign(n, 0);
+        r.assign(n, 0);
+        for (int i = 0; i < n; i++){
+            cin >> l[i] >> r[i];
+        }
+        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);
+        }
+
+        visited.assign(n, 0);
+        parent.assign(n, -1);
+        rootTree(0);
+
+        memo.assign(n, {-1, -1});
+        pair<ll, ll> p = dp(0);
+        cout << p.second + p.first << endl;
+    }
+
+    return 0;
+}

Other_Tasks/CF2062_E1_The_Game_Easy_Version.cpp

@@ -0,0 +1,124 @@
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+
+int n;
+int maxi;
+vector<int> numMaxInSubtree;
+vector<vector<int>> adjlist;
+vector<int> value, parent;
+void countMaxInSubtree(int u) {
+    numMaxInSubtree[u] = (value[u] == maxi);
+    for (auto v : adjlist[u]) {
+        if (v == parent[u]) continue;
+        parent[v] = u;
+        countMaxInSubtree(v);
+        numMaxInSubtree[u] += numMaxInSubtree[v];
+    }
+}
+
+int main() {
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        cin >> n;
+        adjlist.assign(n, vector<int>());
+        value.assign(n, 0);
+        numMaxInSubtree.assign(n, 0);
+        maxi = 0;
+        
+        set<int> svs;
+        for (int i = 0; i < n; i++) {
+            cin >> value[i];
+            maxi = max(maxi, value[i]);
+            svs.insert(value[i]);
+        }
+        vector<int> uniqueVals = vector<int>(svs.begin(), svs.end());
+        reverse(uniqueVals.begin(), uniqueVals.end()); // reverse to get the values in decreasing order
+
+        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);
+        }
+
+        parent.assign(n, -1);
+        parent[0] = 0;
+        countMaxInSubtree(0);
+
+        int totalMax = numMaxInSubtree[0];
+        if (svs.size() == 1) {
+            cout << 0 << endl;
+            continue;
+        }
+
+        int secondMax = *(--(--svs.end()));
+
+        vector<int> criticalPath;
+        int u = 0;
+        int prevVal = value[u];
+        while (true) {
+            criticalPath.push_back(u);
+
+            int newu = -1;
+            for (auto v : adjlist[u]) {
+                if (v == parent[u]) {
+                    continue;
+                }
+                if (numMaxInSubtree[v] == totalMax) {
+                    newu = v;
+                }
+            }
+
+            if (newu == -1) {
+                break;
+            }
+            u = newu;
+        }
+
+        set<int> critpathSet(criticalPath.begin(), criticalPath.end());
+        vector<int> critNodeToIdx(n, -1);
+        for (int i = 0; i < criticalPath.size(); i++) {
+            critNodeToIdx[criticalPath[i]] = i;
+        }
+
+        map<int, vector<int>> m;
+        for (int i = 0; i < n; i++) {
+            m[value[i]].push_back(i);
+        }
+
+
+        int curEnd = criticalPath.size() - 1;
+        int ans = 0;
+        for (int i = 1; i < uniqueVals.size() && !ans; i++) { // iterate over unique values in decreasing order
+            int val = uniqueVals[i];
+            int newEnd = curEnd;
+            for (auto u : m[val]) {
+                if (critpathSet.find(u) == critpathSet.end()) { // if we find this value not on a critical path, we can pick it
+                    ans = u + 1;
+                    break;
+                }
+
+                assert(critNodeToIdx[u] != -1);
+                if (critNodeToIdx[u] > curEnd) {    // if we find a node of this value deeper than a node of a bigger value, we can pick it
+                    ans = u + 1;
+                    break;
+                }
+
+                newEnd = min(newEnd, critNodeToIdx[u]);
+            }
+
+            curEnd = newEnd;
+        }
+
+        cout << ans << endl;
+    }
+
+    return 0;
+}