Tutorial: Algortihmic Grand Prix Added except Last

Author: Ishwarendra

AlgorithmicGrandPrix/Codes/A_AliceOrBob.cpp

@@ -0,0 +1,30 @@
+#include "bits/stdc++.h"
+
+using i64 = long long;
+
+void solve()
+{
+    int a, b;
+    std::cin >> a >> b;
+    
+    int c = std::min(a % b, b - a % b);
+    int k1 = (c - a) / b;
+    int k2 = (-c - a) / b;
+    
+    i64 A = a + 1LL * k1 * b;
+    i64 B = a + 1LL * k2 * b;
+    
+    if (A != B and std::abs(A) == std::abs(B))
+        std::cout << "YES\n";
+    else
+        std::cout << "NO\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    
+    while (t--) 
+        solve();
+}

AlgorithmicGrandPrix/Codes/B_SuperDonutsAndNikhilesh.cpp

@@ -0,0 +1,60 @@
+#include "bits/stdc++.h"
+
+using i64 = long long;
+
+void solve()
+{
+    int n, k;
+    std::cin >> n >> k;
+
+    std::vector<int> h(n);
+    std::vector a(n, std::array<int, 2>());
+    for (int i = 0; i < n; i++)  
+        std::cin >> h[i];
+
+    for (int i = 0; i < n; i++)
+    {
+        std::cin >> a[i][1];
+        a[i][0] = h[i];
+    }
+
+    std::sort(std::begin(a), std::end(a));
+    std::multiset<std::pair<int, int>> m;
+
+    std::vector<int> ans;
+    int cnt = 0;
+    for (int i = 0, id = 0; i < n; i++)
+    {
+        while (id < n and a[id][0] <= k)
+        {
+            m.emplace(-a[id][1], a[id][0]);
+            id++;
+        }
+
+        if (m.empty())
+            break;
+
+        cnt++;
+        auto [energy_gain, height] = *std::begin(m);
+        m.erase(std::begin(m));
+
+        k += -energy_gain;
+        ans.emplace_back(k);
+    }
+
+    std::cout << cnt << "\n";
+    for (int i = 0; i < cnt; i++)
+        std::cout << ans[i] << " ";
+    std::cout << "\n";
+}   
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    
+    while (t--)
+        solve();
+    
+    return 0;
+}

AlgorithmicGrandPrix/Codes/C_ShivalikHostelRoom.cpp

@@ -0,0 +1,35 @@
+#include "bits/stdc++.h"
+
+int main()
+{
+    int n, k;
+    std::cin >> n >> k;
+
+    std::vector<int> a(n);
+    for (int i = 0; i < n; i++) 
+        std::cin >> a[i];
+
+    std::sort(std::begin(a), std::end(a));
+
+    std::vector qry(k, std::array<int, 2>());
+    for (auto &[c, s] : qry)
+        std::cin >> c >> s;
+
+    std::sort(std::begin(qry), std::end(qry), [&](const auto &x, const auto &y)
+    {
+        return x[1] > y[1];
+    });
+
+    for (int i = 0, id = 0; i < n and id < k; id++)
+    {   
+        auto [c, s] = qry[id];
+        while (i < n and c > 0)
+        {
+            a[i] = std::max(a[i], s);
+            i++;
+            c--;
+        }
+    }
+
+    std::cout << std::accumulate(std::begin(a), std::end(a), 0LL);
+}

AlgorithmicGrandPrix/Codes/D_RomanDisputes.cpp

@@ -0,0 +1,35 @@
+#include "bits/stdc++.h"
+
+using i64 = long long;
+
+void solve()
+{
+    int n;
+    std::cin >> n;
+
+    std::vector<int> a(n);
+    for (int i = 0; i < n; i++)  
+        std::cin >> a[i];
+
+    std::sort(std::begin(a), std::end(a));
+    int z = 0;
+    for (int i = 0; i < n - 1; i++)
+        z = std::gcd(z, a[n - 1] - a[i]);
+
+    i64 y = 0;
+    for (int i = 0; i < n; i++)
+        y += (a.back() - a[i]) / z;
+
+    std::cout << y << " " << z << "\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    
+    while (t--)
+        solve();
+
+    return 0;
+}

AlgorithmicGrandPrix/Codes/E_DifferenceShouldNotChange_Setter.cpp

@@ -0,0 +1,133 @@
+#include "bits/stdc++.h"
+
+using i64 = long long;
+
+void solve()
+{
+    int n;
+    std::cin >> n;
+
+    std::vector<int> a(n);
+    for (int i = 0; i < n; i++)
+        std::cin >> a[i];
+
+    if (n <= 3)
+    {
+        std::cout << "1\n" << a[0] << "\n";
+
+        std::cout << n - 1 << "\n";
+        for (int i = 1; i < n; i++)
+            std::cout << a[i] << " ";
+        std::cout << "\n";
+        return;
+    }
+    
+    std::vector<int> b, c;
+    std::sort(std::begin(a), std::end(a));
+    auto work = [&](int id1, int id2)
+    {
+        b.emplace_back(a[id1]);
+        b.emplace_back(a[id2]);
+        int d = b[1] - b[0];
+        
+        for (int i = 0; i < n; i++)
+        {
+            if (i == id1 || i == id2)
+                continue;
+
+            if (a[i] - b.back() == d)
+                b.emplace_back(a[i]);
+            else
+                c.emplace_back(a[i]);
+        }
+
+        if (std::size(c) <= 2)
+            return true;
+
+        d = 0;
+        for (int i = 1; i < std::size(c); i++)
+            d = std::gcd(d, c[i] - c[i - 1]);
+
+        std::multiset<int> need;
+        for (int i = 1; i < std::size(c); i++)
+        {
+            if (c[i] - c[i - 1] != d)
+            {
+                int x = c[i - 1];
+                while (x + d != c[i])
+                {
+                    if (std::size(need) > std::size(b))
+                        return false;
+
+                    x += d;
+                    need.emplace(x);
+                }
+            }
+        }
+
+        while (!need.empty())
+        {
+            int min = *std::begin(need);
+            auto it = std::find(std::begin(b), std::end(b), min);
+
+            if (it == std::end(b))
+                return false;
+
+            for (auto p = it; p != std::end(b); p++)
+            {
+                auto del = need.find(*p);
+                if (del != std::end(need))
+                    need.erase(del);
+            }
+
+            c.insert(std::end(c), it, std::end(b));
+            b.erase(it, std::end(b));
+        }
+        std::sort(std::begin(c), std::end(c));
+        for (int i = 2; i < std::size(c); i++)
+        {
+            if (c[i] - c[i - 1] != c[1] - c[0])
+                return false;
+        }
+        
+        return true;
+    };
+
+    for (int i = 0; i < 3; i++)  
+    {
+        int id1 = i, id2 = (i + 1) % 3;
+        if (id1 > id2)
+            std::swap(id1, id2);
+
+        auto possible = work(id1, id2);
+        if (possible)
+        {
+            std::cout << std::size(b) << "\n";
+            for (int x : b)
+                std::cout << x << " ";
+            std::cout << "\n";
+
+            std::cout << std::size(c) << "\n";
+            for (int x : c)
+                std::cout << x << " ";
+            std::cout << "\n";
+            return;
+        }
+
+        b.clear();
+        c.clear();
+    }
+
+    std::cout << "-1\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    
+    while (t--)
+        solve();
+
+    return 0;
+}