Minimum Spanning Tree

graph/minimum_spanning_tree/checker.cpp

@@ -0,0 +1,99 @@
+#include "testlib.h"
+#include <vector>
+#include <map>
+#include <utility>
+
+using namespace std;
+using ll = long long;
+
+struct E
+{
+    int a, b;
+    ll dist;
+};
+
+struct UnionFind
+{
+    vector<int> p, r;
+    int gn;
+    UnionFind(int n = 0) : p(n, -1), r(n, 1), gn(n) {}
+    void merge(int a, int b)
+    {
+        int x = group(a), y = group(b);
+        if (x == y)
+            return; // same
+        gn--;
+        if (r[x] < r[y])
+        {
+            p[x] = y;
+        }
+        else
+        {
+            p[y] = x;
+            if (r[x] == r[y])
+                r[x]++;
+        }
+    }
+    int group(int a)
+    {
+        if (p[a] == -1)
+            return a;
+        return p[a] = group(p[a]);
+    }
+    bool same(int a, int b) { return group(a) == group(b); }
+};
+
+ll read_ans(int n, int m, vector<E> edges, InStream &stream)
+{
+    ll x = stream.readLong();
+    ll sum = 0;
+    UnionFind uf(n);
+    for (int i = 0; i < n - 1; i++)
+    {
+        int ei = stream.readInt(0, m);
+        auto e = edges[ei];
+        if (uf.same(e.a, e.b))
+        {
+            stream.quit(_wa, "input isn't tree");
+        }
+        uf.merge(e.a, e.b);
+        sum += e.dist;
+    }
+
+    if (x != sum)
+    {
+        stream.quitf(_wa, "X(" I64 ") isn't correct, sum = " I64, x, sum);
+    }
+    return x;
+}
+
+int main(int argc, char *argv[])
+{
+    setName("compare mst");
+    registerTestlibCmd(argc, argv);
+
+    // input
+    int n = inf.readInt();
+    int m = inf.readInt();
+    vector<E> edges(m);
+    for (int i = 0; i < m; i++)
+    {
+        int a = inf.readInt();
+        int b = inf.readInt();
+        ll c = inf.readLong();
+        edges[i] = {a, b, c};
+    }
+
+    ll x_ans = read_ans(n, m, edges, ans);
+    ll x_ouf = read_ans(n, m, edges, ouf);
+
+    if (x_ans < x_ouf)
+    {
+        quitf(_wa, "There is the better solution");
+    }
+    if (x_ans > x_ouf)
+    {
+        quitf(_fail, "Participate find better answer");
+    }
+    quitf(_ok, "OK: " I64, x_ouf);
+}

graph/minimum_spanning_tree/gen/example_00.in

@@ -0,0 +1,8 @@
+4 7
+0 1 4
+0 2 2
+0 3 3
+1 2 6
+1 3 8
+2 3 1
+1 1 0

graph/minimum_spanning_tree/gen/example_01.in

@@ -0,0 +1,4 @@
+4 3
+0 1 1
+1 2 2
+3 1 3

graph/minimum_spanning_tree/gen/example_02.in

@@ -0,0 +1,6 @@
+6 5
+0 1 1000000000
+1 2 1000000000
+2 3 1000000000
+3 4 1000000000
+4 5 1000000000

graph/minimum_spanning_tree/gen/max_random.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include "random.h"
+#include "../params.h"
+
+using namespace std;
+
+struct E
+{
+    int from, to, cost;
+};
+
+int main(int, char *argv[])
+{
+    long long seed = atoll(argv[1]);
+    auto gen = Random(seed);
+
+    int n = gen.uniform(N_MAX - 100, N_MAX);
+    int m = gen.uniform(n - 1, (int)N_MAX);
+
+    vector<E> edges;
+    for (int i = 1; i < n; i++)
+    {
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({gen.uniform(0, i - 1), i, c});
+    }
+    for (int i = n - 1; i < m; i++)
+    {
+        int a = gen.uniform(0, n - 1);
+        int b = gen.uniform(0, n - 1);
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({a, b, c});
+    }
+
+    auto idx = gen.perm<int>(n);
+    printf("%d %d\n", n, m);
+    for (auto e : edges)
+    {
+        printf("%d %d %d\n", idx[e.from], idx[e.to], e.cost);
+    }
+    return 0;
+}

graph/minimum_spanning_tree/gen/random.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include "random.h"
+#include "../params.h"
+
+using namespace std;
+
+struct E
+{
+    int from, to, cost;
+};
+
+int main(int, char *argv[])
+{
+    long long seed = atoll(argv[1]);
+    auto gen = Random(seed);
+
+    int n = gen.uniform(1LL, N_MAX);
+    int m = gen.uniform(n - 1, (int)N_MAX);
+
+    vector<E> edges;
+    for (int i = 1; i < n; i++)
+    {
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({gen.uniform(0, i - 1), i, c});
+    }
+    for (int i = n - 1; i < m; i++)
+    {
+        int a = gen.uniform(0, n - 1);
+        int b = gen.uniform(0, n - 1);
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({a, b, c});
+    }
+
+    auto idx = gen.perm<int>(n);
+    printf("%d %d\n", n, m);
+    for (auto e : edges)
+    {
+        printf("%d %d %d\n", idx[e.from], idx[e.to], e.cost);
+    }
+    return 0;
+}

graph/minimum_spanning_tree/gen/small.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include "random.h"
+#include "../params.h"
+
+#define SMALL_N_MAX 1000
+
+using namespace std;
+
+struct E
+{
+    int from, to, cost;
+};
+
+int main(int, char *argv[])
+{
+    long long seed = atoll(argv[1]);
+    auto gen = Random(seed);
+
+    int n = gen.uniform(1, SMALL_N_MAX);
+    int m = gen.uniform(n - 1, (int)N_MAX);
+
+    vector<E> edges;
+    for (int i = 1; i < n; i++)
+    {
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({gen.uniform(0, i - 1), i, c});
+    }
+    for (int i = n - 1; i < m; i++)
+    {
+        int a = gen.uniform(0, n - 1);
+        int b = gen.uniform(0, n - 1);
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({a, b, c});
+    }
+
+    auto idx = gen.perm<int>(n);
+    printf("%d %d\n", n, m);
+    for (auto e : edges)
+    {
+        printf("%d %d %d\n", idx[e.from], idx[e.to], e.cost);
+    }
+    return 0;
+}

graph/minimum_spanning_tree/gen/small_c01.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include "random.h"
+#include "../params.h"
+
+#define SMALL_N_MAX 1000
+
+using namespace std;
+
+struct E
+{
+    int from, to, cost;
+};
+
+int main(int, char *argv[])
+{
+    long long seed = atoll(argv[1]);
+    auto gen = Random(seed);
+
+    int n = gen.uniform(1, SMALL_N_MAX);
+    int m = gen.uniform(n - 1, 2 * n);
+
+    vector<E> edges;
+    for (int i = 1; i < n; i++)
+    {
+        int c = gen.uniform(0, 1);
+        edges.push_back({gen.uniform(0, i - 1), i, c});
+    }
+    for (int i = n - 1; i < m; i++)
+    {
+        int a = gen.uniform(0, n - 1);
+        int b = gen.uniform(0, n - 1);
+        int c = gen.uniform(0, 1);
+        edges.push_back({a, b, c});
+    }
+
+    auto idx = gen.perm<int>(n);
+    printf("%d %d\n", n, m);
+    for (auto e : edges)
+    {
+        printf("%d %d %d\n", idx[e.from], idx[e.to], e.cost);
+    }
+    return 0;
+}

graph/minimum_spanning_tree/gen/star.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+#include "random.h"
+#include "../params.h"
+
+using namespace std;
+
+struct E
+{
+    int from, to, cost;
+};
+
+int main(int, char *argv[])
+{
+    long long seed = atoll(argv[1]);
+    auto gen = Random(seed);
+
+    int n = N_MAX;
+    int m = n - 1;
+
+    vector<E> edges;
+    for (int i = 1; i < n; i++)
+    {
+        int c = gen.uniform(0LL, C_MAX);
+        edges.push_back({0, i, c});
+    }
+
+    vector<int> idx = gen.perm<int>(n);
+    printf("%d %d\n", n, m);
+    for (auto e : edges)
+    {
+        printf("%d %d %d\n", idx[e.from], idx[e.to], e.cost);
+    }
+    return 0;
+}

graph/minimum_spanning_tree/hash.json

@@ -0,0 +1,50 @@
+{
+  "example_00.in": "020c548c74d1ad61da527d9dd149e5510cba1a30459fe3f933b6ec0b742f87d0",
+  "example_00.out": "ad3c92a1dec31cb7cb05f6f2dfd5c7a1517f73b86a3c7cc1b131a17c0c01dd84",
+  "example_01.in": "4859c57ba64d8088c41b77c192a9535ac0682e0e478848d9a8fd238a2c4b7691",
+  "example_01.out": "fe8b5f684b0ffe72aab5b90254f0e42855029fd343c56e3104a70847446f8fbf",
+  "example_02.in": "026aafd663e40b9bbc108768553e0b89a3bf8130e4bdc46c29296f864c5e41bb",
+  "example_02.out": "4906a5c6228e0dec625c797d8d5364f4871b8f067dd9a45314123b4c95e98897",
+  "max_random_00.in": "c58ac9ee4e3a587a14ed8281e3e0caa8181fefb559848b6b40fcaf1908226aef",
+  "max_random_00.out": "ccc6e029a5ecce3d7aa745e4292376ec14d6eff04a785024bb2a3751ef5d23ca",
+  "max_random_01.in": "7923205b114a3b91eeffa3b34ffbf3dd2457f7514876c4919c92fe8af944d4f2",
+  "max_random_01.out": "df2845e7acf93627476de3e95535f035085b2293196c44db491cfa7598a2c5be",
+  "max_random_02.in": "e922cddc347c430132015acd94835261383f14d436d16376f68b78903d06b975",
+  "max_random_02.out": "a55460cb0b6c90cd3273669f883ae075ae53ccb82a15681f0ca1315ac6941ecd",
+  "max_random_03.in": "dfef6713c2ac6309f9cd4a1fe5f39e0ba5d13f98731891d25ca8a8c5d55a6cd9",
+  "max_random_03.out": "67dc7b4e2ea0fe1d9255adbde32288bc12ab46ac3aa968f5e9f1c3a8ad6de773",
+  "max_random_04.in": "38a30545074ddfa969bc382751d6502f71f00a5058a8a76238196051b5cc555f",
+  "max_random_04.out": "e012e0efa2bf36beb0edd0b7e218dc4be1f583c9283a0ea9b04832d75b45542f",
+  "random_00.in": "a0f03f21f6e3a29c879eea983c3473c3afa70f7f5430b5bf2a18539af7ef699c",
+  "random_00.out": "122afece5bc74f5b78fd0035190db8118b80f14f33b638a19d7704bacf4c3635",
+  "random_01.in": "9b6c3e3c0d9159d31eb122334e1d06a4613c49c64486b035ae9e12026a337ff8",
+  "random_01.out": "f96404c4027d65c3c0f1ef0d05707c563c02ea541fe3c00a875ec4ac217139d8",
+  "random_02.in": "8f14df85adeec8b34d1b36fc72964f913ae71e3adc1fbb5ad6c34fe3ea292099",
+  "random_02.out": "463eebcf2e0e49e932744789799f96f1a11ffad6066fb95caa38b42c4ff10c18",
+  "random_03.in": "6f64c9c91034c30f948b9e5ef46c9fffe8180b4da26153d914020324279af08b",
+  "random_03.out": "a940d1d2c9a9ab9d6e9d9698a09e95b5da123e64f71c59c9c9f8bb8018d49734",
+  "random_04.in": "fc3fa49fbcc1b2ad3cf9e8d022a43b5dc6bae05e7ead475b461633e0de8c1824",
+  "random_04.out": "36a2e62876674197f64b16846adde3455903a690daa3d9ab9836184e998c6a3e",
+  "small_00.in": "4e40f0736cda259a70522b2426b2a204466eefcfa8fcb0851af8958e2722f2fe",
+  "small_00.out": "78cc7cd0c89413f9508b2f2e7505633ed77d5e759b1485c90f2e191a618846ab",
+  "small_01.in": "d8cce13331750d77510a5cbe326615a7634d03770aa24d508cdc19dbda581319",
+  "small_01.out": "1296881c571229c44b864c0329a9bd2bbfc71e799ce224311a6caba3ba3771db",
+  "small_02.in": "4eb698b18026e57cb664db73a563368b7f9aeba5e80dc9971481c67814a16f85",
+  "small_02.out": "8edb40464d90b4bf3b3fd7ad346b9d2084ede859e648b5610d86d5916d80b7a1",
+  "small_03.in": "709461c35d8545f3dd6f16f794aa7ec4d7c2bb6b0fda4e4c45fa3eb365754c49",
+  "small_03.out": "06ec70360e6f935a5d30ebac62f623f305015949556f48327d3b56c6bc39fce7",
+  "small_04.in": "1b6de416fb67cba7028997613ec9f582eb232932435673343dae01f431859d84",
+  "small_04.out": "c8f1bc9ec7bc4617c8604fde9be53bb4b103aa93391354b10cabef8a21a3ddc4",
+  "small_c01_00.in": "d6ae2e7f8aab2edb91bd490c49f78935a8de13bdd6a98706535aeb404488f5f4",
+  "small_c01_00.out": "1283061d42d34c40215f25708c2ed79cef988d23fa94505399f7db7c55da5715",
+  "small_c01_01.in": "adba72e6de177bfb7b20342c7ee7ba64d59a56038d8c28db221d6d68cf6f0160",
+  "small_c01_01.out": "6d5795ec5a608e963b9eab5975154efc4de80ca9b6d9aecf1f423360ba58f0a5",
+  "small_c01_02.in": "c9ce0284afdc5d36aa3f6db85e2d1181c577257f1a4d66f939b2caa7f0180a2a",
+  "small_c01_02.out": "bf67253783063fe495b47673ed4ae6eb7620d96dedbef401e1edc9a61696a9fa",
+  "small_c01_03.in": "b2d2764bb9f05bdda5ee45c40685bae660dcca23a673ba1290c43387dc449c64",
+  "small_c01_03.out": "b298fbfb80d91dd96867e00759cb03341025a1ddf3ec60e3b818c5f955d417c1",
+  "small_c01_04.in": "aece442481b2b2fd40bcaaf5373afbb575c933f71abfd8b0235d84aeead3398f",
+  "small_c01_04.out": "68bafc3fc12336a5dcffdea04b456c3b72b52ac94c5f2b78dccaed9de8e01034",
+  "star_00.in": "2b04764631aa1eaa5d7a46373025f7fd0993db946bef83b6d0499942878330b5",
+  "star_00.out": "127cbf4cce1ef5dafcf4a542c9cc571fe3dc9d972b5183d75976c8196fbe5a1e"
+}