CodeForces and FenwickTree solutions.

mitkonikov · mitkonikov · commit 4ab547ff63e1 · 2022-10-08T00:46:20.000+02:00
diff --git a/Binary Search/CodeForces - C_Poisoned_Dagger.cpp b/Binary Search/CodeForces - C_Poisoned_Dagger.cpp
@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+#define ll long long
+
+using namespace std;
+
+// [start,end)
+ll binary_search(function<bool(ll)> func, ll start, ll end) {
+    /* func:int ->bool
+        returns smallest int x where func(x) evaluates to true, searches in [start,end), it is assumed the values are false, .. , false, true ...
+    */
+
+    if (end <= start) return end;   // has to be here, otherwise func(end-1) in next line could be a problem
+    if (!func(end-1)) return end;
+    while (end - start > 1) {
+        ll mid = (start + end) / 2;
+        if (func(mid)) end = mid; else start = mid;
+    }
+
+    return (func(start) ? start : end);
+};
+
+void testCase() {
+    ll n, h;
+    cin >> n >> h;
+
+    vector<ll> a(n);
+    for (int i = 0; i < n; i++) {
+        cin >> a[i];
+    }
+
+    a.push_back((ll)2e18);
+    n++;
+
+    ll k = binary_search([&](ll K) {
+        ll damage = h;
+        for (int i = 1; i < n; i++) {
+            damage = damage - min(K, a[i] - a[i-1]);
+            if (damage <= 0) break;
+        }
+
+        return (damage <= 0);
+    }, 0LL, h * 2);
+    
+    ll damage = h;
+    for (int i = 1; i < n; i++) {
+        damage = damage - min(k-1, a[i] - a[i-1]);
+        if (damage <= 0) break;
+    }
+
+    if (damage <= 0) {
+        cout << k - 1 << endl;
+    } else {
+        cout << k << endl;
+    }
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    return 0;
+}
diff --git a/Bit Operations/D_-_AND_and_SUM.cpp b/Bit Operations/D_-_AND_and_SUM.cpp
@@ -0,0 +1,43 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+void testCase() {
+    ll A, S;
+    cin >> A >> S;
+
+    bool ok = true;
+    bool carry = false;
+    for (int i = 0; i < 61 && ok; i++) {
+        if ((1LL << i) > A && (1LL << i) > S) break;
+        if (A & (1LL << i)) {
+            if (S & (1LL << i)) {
+                if (!carry) ok = false;
+            } else {
+                if (carry) ok = false;
+                carry = true;
+            }
+        } else {
+            if (S & (1LL << i)) {
+                if (carry) {
+                    carry = false;
+                }
+            }
+        }
+    }
+
+    cout << (ok && !carry ? "Yes" : "No") << endl;
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    return 0;
+}
diff --git a/CodeForces/C_Column_Swapping.cpp b/CodeForces/C_Column_Swapping.cpp
@@ -0,0 +1,77 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+void testCase() {
+    int n, m;
+    cin >> n >> m;
+
+    vector<vector<int>> a(n, vector<int>(m, 0));
+    vector<vector<int>> s(n, vector<int>(m, 0));
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            cin >> a[i][j];
+            s[i][j] = a[i][j];
+        }
+    }
+
+    for (int i = 0; i < n; i++) {
+        sort(s[i].begin(), s[i].end());
+    }
+
+    map<int, bool> col_needed;
+    bool ok = true;
+    for (int i = 0; i < n && ok; i++) {
+        int cols = 0;
+        for (int j = 0; j < m && ok; j++) {
+            if (a[i][j] != s[i][j]) {
+                cols++;
+                col_needed[j] = true;
+            }
+
+            if (cols > 2) {
+                ok = false; break;
+            }
+        }
+    }
+
+    if (!ok || col_needed.size() > 2) {
+        cout << -1 << endl;
+        return;
+    }
+
+    if (col_needed.size() == 0) {
+        cout << 1 << " " << 1 << endl;
+        return;
+    }
+
+    vector<int> sw;
+    for (auto it: col_needed) {
+        sw.push_back(it.first);
+    }
+
+    for (int i = 0; i < n; i++) {
+        swap(a[i][sw[0]], a[i][sw[1]]);
+        ok &= is_sorted(a[i].begin(), a[i].end());        
+    }
+
+    if (!ok) {
+        cout << -1 << endl;
+        return;
+    }
+
+    cout << sw[0] + 1 << " " << sw[1] + 1 << endl;
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    return 0;
+}
diff --git a/CodeForces/C_Double_Sort.cpp b/CodeForces/C_Double_Sort.cpp
@@ -0,0 +1,59 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+void testCase() {
+    int n;
+    cin >> n;
+
+    vector<int> a(n), b(n);
+    for (int i = 0; i < n; i++) cin >> a[i];
+    for (int i = 0; i < n; i++) cin >> b[i];
+
+    bool ok = true;
+    vector<pair<int, int>> swaps;
+    swaps.reserve(n * n);
+    for (int i = 0; i < n; i++) {
+        int min_id = i;
+        for (int j = i + 1; j < n; j++) {
+            if (a[j] <= a[min_id] && b[j] <= b[min_id]) {
+                min_id = j;
+            }
+        }
+
+        if (i == min_id) continue;
+        swap(a[i], a[min_id]);
+        swap(b[i], b[min_id]);
+        swaps.push_back({ i, min_id });
+    }
+
+    ok &= is_sorted(a.begin(), a.end());
+    ok &= is_sorted(b.begin(), b.end());
+    if (!ok) {
+        cout << -1 << endl;
+    } else {
+        if (swaps.empty()) {
+            cout << 0 << endl;
+            return;
+        }
+
+        cout << swaps.size() << endl;
+        for (int i = 0; i < swaps.size(); i++) {
+            cout << swaps[i].first + 1 << " " << swaps[i].second + 1 << endl;
+        }
+    }
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    cout << flush;
+    return 0;
+}
diff --git a/CodeForces/C_Infinite_Replacement.cpp b/CodeForces/C_Infinite_Replacement.cpp
@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+void testCase() {
+    string s, t;
+    cin >> s >> t;
+
+    string tmp = t;
+    sort(tmp.begin(), tmp.end());
+    if (tmp.front() == 'a' && t.size() >= 2) {
+        cout << -1 << endl;
+        return;
+    }
+
+    int count = 0;
+    for (int i = 0; i < s.size(); i++) {
+        if (s[i] == 'a') count++;
+    }
+
+    if (s.size() == count) {
+        if (tmp.front() == 'a') {
+            cout << 1 << endl;
+            return;
+        }
+    }
+
+    cout << (1LL << count) << endl;
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    return 0;
+}
diff --git a/CodeForces/C_Make_Equal_With_Mod.cpp b/CodeForces/C_Make_Equal_With_Mod.cpp
@@ -0,0 +1,44 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+void testCase() {
+    int n;
+    cin >> n;
+    vector<int> v(n);
+    bool is_one = false;
+    bool is_cons = false;
+    for (int i = 0; i < n; i++) {
+        cin >> v[i];
+        if (v[i] == 1) is_one = true;
+    }
+    sort(v.begin(), v.end());
+    for (int i = 1; i < n; i++) {
+        if (v[i] == v[i-1] + 1) {
+            is_cons = true;
+            break;
+        }
+    }
+    if (!is_one) {
+        cout << "YES" << endl;
+    } else {
+        if (is_cons) {
+            cout << "NO" << endl;
+        } else {
+            cout << "YES" << endl;
+        }
+    }
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    return 0;
+}
diff --git a/CodeForces/C_Pōja_Verdon.cpp b/CodeForces/C_Pōja_Verdon.cpp
@@ -0,0 +1,18 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+ 
+using namespace std;
+ 
+int main() {
+    int n;
+    cin >> n;
+    int sum = 0;
+    for (int i = 0; i < n; i++) {
+        int a;
+        cin >> a;
+        sum += a;
+    }
+    cout << sum << endl;
+    return 0;
+}
diff --git a/CodeForces/C_Restoring_the_Duration_of_Tasks.cpp b/CodeForces/C_Restoring_the_Duration_of_Tasks.cpp
@@ -0,0 +1,34 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+void testCase() {
+    int n;
+    cin >> n;
+
+    vector<int> arrival(n), finish(n);
+    for (int i = 0; i < n; i++) cin >> arrival[i];        
+    for (int i = 0; i < n; i++) cin >> finish[i];
+
+    int last_arrived = arrival[0];
+    for (int i = 0; i < n; i++) {
+        cout << finish[i] - last_arrived << " ";
+        if (i+1<n) last_arrived = max(finish[i], arrival[i+1]);
+    }
+
+    cout << endl;
+}
+
+int main() {
+    int t;
+    cin >> t;
+
+    while (t--) {
+        testCase();
+    }
+
+    cout << flush;
+    return 0;
+}
diff --git a/CodeForces/C_Where_is_the_Pizza.cpp b/CodeForces/C_Where_is_the_Pizza.cpp
diff --git a/Dynamic Programming/CodeForces - C_Palindrome_Basis.cpp b/Dynamic Programming/CodeForces - C_Palindrome_Basis.cpp
diff --git a/Fenwick Tree/CodeForces - C_Rooks_Defenders.cpp b/Fenwick Tree/CodeForces - C_Rooks_Defenders.cpp
diff --git a/Fenwick Tree/CodeForces - D_Pashmak_and_Parmida_s_problem.cpp b/Fenwick Tree/CodeForces - D_Pashmak_and_Parmida_s_problem.cpp
