AtCoder practice solutions.

mitkonikov · mitkonikov · commit dcae1584c37e · 2024-04-09T20:17:29.000+02:00
diff --git a/AtCoder/A_Penalty_Kick.cpp b/AtCoder/A_Penalty_Kick.cpp
@@ -0,0 +1,15 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+int main() {
+    int N;
+    cin >> N;
+    for (int i = 0; i < N; i++) {
+        cout << ((i + 1) % 3 == 0 ? 'x' : 'o');
+    }
+    cout << endl;
+    return 0;
+}
diff --git a/AtCoder/B_Farthest_Point.cpp b/AtCoder/B_Farthest_Point.cpp
@@ -0,0 +1,59 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+template<class T>
+struct Point {
+    typedef Point P;
+    T x, y;
+    explicit Point(T x=0, T y=0) : x(x), y(y) {}
+    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
+    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
+    P operator+(P p) const { return P(x+p.x, y+p.y); }
+    P operator-(P p) const { return P(x-p.x, y-p.y); }
+    P operator*(T d) const { return P(x*d, y*d); }
+    P operator/(T d) const { return P(x/d, y/d); }
+    T dot(P p) const { return x*p.x + y*p.y; }
+    T cross(P p) const { return x*p.y - y*p.x; }
+    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
+    T dist2() const { return x*x + y*y; }
+    double dist() const { return sqrt((double)dist2()); }
+    // angle to x-axis in interval [-pi, pi]
+    double angle() const { return atan2(y, x); }
+    P unit() const { return *this/dist(); } // makes dist()=1
+    P perp() const { return P(-y, x); } // rotates +90 degrees
+    P normal() const { return perp().unit(); }
+    // returns point rotated 'a' radians ccw around the origin
+    P rotate(double a) const {
+        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
+    friend ostream& operator<<(ostream& os, P p) {
+        return os << "(" << p.x << "," << p.y << ")"; }
+    void GCD() {
+        int GCD = gcd(x, y);
+        x /= GCD; y /= GCD;
+    }
+};
+
+int main() {
+    int N;
+    cin >> N;
+    vector<Point<int>> A(N);
+    for (int i = 0; i < N; i++) {
+        cin >> A[i].x >> A[i].y;
+    }
+    for (int i = 0; i < N; i++) {
+        ll mx_dist = LLONG_MIN;
+        int ans = -1;
+        for (int j = 0; j < N; j++) {
+            if (i == j) continue;
+            if ((A[i]-A[j]).dist2() > mx_dist) {
+                mx_dist = (A[i]-A[j]).dist2();
+                ans = j;
+            }
+        }
+        cout << ans + 1 << endl;
+    }
+    return 0;
+}
diff --git a/AtCoder/C_Colorful_Beans.cpp b/AtCoder/C_Colorful_Beans.cpp
@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+int main() {
+    map<int, int> mp;
+    int N;
+    cin >> N;
+    for (int i = 0; i < N; i++) {
+        int a, c;
+        cin >> a >> c;
+        auto it = mp.find(c);
+        if (it == mp.end()) {
+            mp[c] = a;
+        } else {
+            mp[c] = min(mp[c], a);
+        }
+    }
+    int best = 0;
+    for (auto [c, v]: mp) {
+        if (v > best) {
+            best = v;
+        }
+    }
+    cout << best << endl;
+    return 0;
+}
diff --git a/AtCoder/F_Oddly_Similar.cpp b/AtCoder/F_Oddly_Similar.cpp
@@ -0,0 +1,33 @@
+#pragma GCC optimize("O3")
+#pragma GCC optimize("unroll-loops")
+
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+int A[2001][2001];
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    int N, M;
+    cin >> N >> M;
+    for (int i = 0; i < N; i++) {
+        for (int j = 0; j < M; j++) {
+            cin >> A[i][j];
+        }
+    }
+    int ans = 0;
+    for (int i = 0; i < N; i++) {
+        for (int j = i + 1; j < N; j++) {
+            int count = 0;
+            for (int k = 0; k < M; k++) {
+                if (A[i][k] == A[j][k]) count++;
+            }
+            ans += ((count & 1) > 0);
+        }
+    }
+    cout << ans << endl;
+    return 0;
+}
diff --git a/BFS/AtCoder - D_Medicines_on_Grid.cpp b/BFS/AtCoder - D_Medicines_on_Grid.cpp
@@ -0,0 +1,104 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+int H, W;
+vector<vector<int>> adj;
+vector<int> dfs_visited;
+vector<string> A;
+
+int mp(int x, int y) {
+    return (x * W) + y;
+}
+
+const int dx[4] = { 0, 0, -1, 1 };
+const int dy[4] = { -1, 1, 0, 0 };
+
+inline bool valid(int x, int y, int w, int h) {
+    return (x >= 0 && x < w && y >= 0 && y < h);
+}
+
+map<pair<int, int>, int> points;
+
+void bfs(int x, int y, int e) {
+    if (e == 0) return;
+    struct BFS {
+        int x, y, e;
+    };
+    queue<BFS> q;
+    q.push({ x, y, e });
+    int me = mp(x, y);
+    vector<vector<bool>> visited(H, vector<bool>(W, false));
+    visited[x][y] = true;
+    while (!q.empty()) {
+        auto top = q.front();
+        q.pop();
+        for (auto dir = 0; dir < 4; dir++) {
+            int nx = top.x + dx[dir];
+            int ny = top.y + dy[dir];
+            if (valid(nx, ny, H, W) && !visited[nx][ny] && A[nx][ny] != '#') {
+                visited[nx][ny] = true;
+                if (points.count({ nx, ny })) {
+                    adj[me].push_back(mp(nx, ny));
+                }
+                if (top.e - 1 > 0) { 
+                    q.push({ nx, ny, top.e - 1 });
+                }
+            }
+        }
+    }
+}
+
+void dfs(int u) {
+    dfs_visited[u] = true;
+    for (auto v: adj[u]) {
+        if (dfs_visited[v]) continue;
+        dfs(v);
+    }
+}
+
+int main() {
+    cin >> H >> W;
+    A.resize(H);
+    for (int i = 0; i < H; i++) {
+        cin >> A[i];
+    }
+    int N;
+    cin >> N;
+    adj.resize(H * W + 100);
+    dfs_visited.resize(H * W + 100);
+    for (int i = 0; i < N; i++) {
+        int X, Y, E;
+        cin >> X >> Y >> E;
+        X--; Y--;
+        points[{ X, Y }] = E;
+    }
+    for (int i = 0; i < H; i++) {
+        for (int j = 0; j < W; j++) {
+            if (A[i][j] == 'T') {
+                points[{ i, j }] = 0;
+            }
+        }
+    }
+    for (auto [p, e]: points) {
+        bfs(p.first, p.second, e);
+    }
+    for (int i = 0; i < H; i++) {
+        for (int j = 0; j < W; j++) {
+            if (A[i][j] == 'S') {
+                dfs(mp(i, j));
+            }
+        }
+    }
+    for (int i = 0; i < H; i++) {
+        for (int j = 0; j < W; j++) {
+            if (A[i][j] == 'T') {
+                cout << (dfs_visited[mp(i, j)] ? "Yes" : "No") << endl;
+                return 0;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/Centroid Decomposition/E_Minimize_Sum_of_Distances.cpp b/Centroid Decomposition/E_Minimize_Sum_of_Distances.cpp
@@ -0,0 +1,119 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl '\n'
+
+using namespace std;
+
+vector<vector<int>> adj;
+
+struct CentroidDecomposition {
+    vector<vector<int>> G;
+    vector<ll> C;
+    vector<int> sz, pa;
+    vector<ll> ans;
+    vector<bool> checked;
+
+    CentroidDecomposition(int N) {
+        G.resize(N);
+        sz.resize(N);
+        pa.resize(N);
+        ans.resize(N);
+        checked.resize(N);
+        C.resize(N);
+        for (int i = 0; i < N; ++i) {
+            G[i].clear();
+        }
+    }
+    void addEdge(int u, int v) {
+        G[u].push_back(v);
+        G[v].push_back(u);
+    }
+    int dfs(int u, int p) {
+        sz[u] = 1;
+        for (auto v : G[u]) {
+            if (v == p || checked[v]) continue;
+            sz[u] += dfs(v, u);
+        }
+        return sz[u];
+    }
+    int centroid(int u, int p, int n) {
+        for (auto v : G[u]) {
+            if (v == p || checked[v]) continue;
+            if (sz[v] > n / 2) return centroid(v, u, n);
+        }
+        return u;
+    }
+    pair<ll, ll> dfs2(int u, int p, int c, int d) {
+        // dis[c][u] = d;
+        pair<ll, ll> result = { 0, C[u] };
+        for (auto v : G[u]) {
+            if (v == p || checked[v]) continue;
+            auto ch = dfs2(v, u, c, d + 1);
+            result.first += ch.first + ch.second;
+            result.second += ch.second;
+        }
+        return result;
+    }
+    void dfs3(int u, int p, int c, pair<ll, ll> push) {
+        push.first += push.second;
+        ans[u] += push.first;
+        for (auto v : G[u]) {
+            if (v == p || checked[v]) continue;
+            dfs3(v, u, c, push);
+        }
+    }
+    void build(int u, int p) {
+        int n = dfs(u, p);
+        int c = centroid(u, p, n);
+        if (p == -1) p = c;
+        pa[c] = p;
+
+        vector<pair<ll, ll>> results(G[c].size());
+        pair<ll, ll> sum = { 0, 0 };
+        for (int i = 0; i < G[c].size(); i++) {
+            auto v = G[c][i];
+            if (v == p || checked[v]) continue;
+            results[i] = dfs2(v, c, c, 1);
+            results[i].first += results[i].second;
+            sum.first += results[i].first;
+            sum.second += results[i].second;
+        }
+
+        ans[c] += sum.first;
+
+        for (int i = 0; i < G[c].size(); i++) {
+            auto v = G[c][i];
+            if (v == p || checked[v]) continue;
+            pair<ll, ll> push = sum;
+            push.first -= results[i].first;
+            push.second -= results[i].second;
+            push.second += C[c];
+            dfs3(v, c, c, push);
+        }
+
+        checked[c] = true;
+        for (auto v : G[c]) {
+            if (v == p || checked[v]) continue;
+            build(v, c);
+        }
+    }
+};
+
+int main() {
+    int N;
+    cin >> N;
+    CentroidDecomposition cd(N + 3);
+    for (int i = 0; i < N - 1; ++i) {
+        int a, b;
+        cin >> a >> b;
+        cd.addEdge(a, b);
+    }
+    for (int i = 0; i < N; i++) {
+        cin >> cd.C[i + 1];
+    }
+    cd.build(1, 0);
+    ll ans = LLONG_MAX;
+    for (int i = 1; i <= N; i++) ans = min(ans, cd.ans[i]);
+    cout << ans << endl;
+    return 0;
+}
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # Competitive Programming Problems and Solutions
 
-![](https://img.shields.io/static/v1?label=Solutions&message=1251&color=brightgreen)
+![](https://img.shields.io/static/v1?label=Solutions&message=1257&color=brightgreen)
 
 This repository is meant as a public place to store my competitive programming solutions to various of competitive programming problems on sites such as:
  - [CodeForces](https://codeforces.com/)
