oj.uz

답안 #544431

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
544431 2022-04-01T22:08:47 Z Olympia Sirni (COCI17_sirni) C++17
98 / 140
 5000 ms 655904 KB 
#include <vector>
#include <algorithm>
#include <iostream>
#include <set>
#include <cmath>
#include <map>
#include <random>
#include <cassert>
#include <ctime>
#include <bitset>
#include <stack>
#include <cstdlib>
#include <queue>
#include <stdint.h>
#include <vector>
#include <cassert>
#include <numeric>
#include <iostream>
#include <algorithm>
#include <functional>
#include <cstdio>
#include <limits.h>

#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")

using namespace std;

class DisjointSetUnion {
protected:
    vector<int> parent;
    vector<int> compSize;
    const int n;
    int connectedComponents;
public:
    int getConnectedComponents() const {
        return connectedComponents;
    }

public:
    DisjointSetUnion(int sz) : n(sz), connectedComponents(sz) {
        parent.resize(sz), compSize.resize(sz);
        for (int i = 0; i < n; i++) {
            parent[i] = i, compSize[i] = 1;
        }
    }

    int find_head(int x) const {
        int cur = x;
        while (cur != parent[cur]) {
            cur = parent[cur];
        }
        return cur;
    }

    void join(int x, int y) {
        x = find_head(x);
        y = find_head(y);
        if (x == y) {
            return;
        }
        if (compSize[x] > compSize[y]) {
            swap(x, y);
            //ensures that compSize[x1] <= compSize[y1]
        }
        parent[x] = y;
        compSize[y] += compSize[x];
        connectedComponents--;
    }

    bool comp(int x, int y) {
        return (find_head(x) == find_head(y));
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int N;
    cin >> N;
    vector<int> v(N);
    DisjointSetUnion dsu(N);
    for (int i = 0; i < N; i++) {
        cin >> v[i];
    }
    if (N <= 1e3) {
        vector<pair<int, pair<int, int>>> vec;
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                vec.emplace_back(min(v[i] % v[j], v[j] % v[i]), make_pair(i, j));
            }
        }
        sort(vec.begin(), vec.end());
        int64_t ans = 0;
        for (int i = 0; i < vec.size(); i++) {
            if (dsu.comp(vec[i].second.first, vec[i].second.second)) {
                continue;
            }
            dsu.join(vec[i].second.first, vec[i].second.second);
            ans += vec[i].first;
        }
        cout << ans;
        return 0;
    }
    //sort(v.begin(), v.end());
    int MX = 0;
    map<int, int> myMap;
    for (int i = 0; i < N; i++) {
        MX = max(MX, v[i]);
        myMap[v[i]] = i;
    }
    vector<vector<int>> indices(MX + 1);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j <= MX; j += v[i]) {
            indices[j].push_back(i);
        }
    }
    int64_t tot = 0;
    for (int mx = 0; mx < 100; mx++) {
        for (int i = 0; i < N; i++) {
            if (v[i] - mx < 0) {
                continue;
            }
            for (int ind: indices[v[i] - mx]) {
                if (v[i] % v[ind] == mx) {
                    if (dsu.comp(i, ind)) {
                        continue;
                    }
                    dsu.join(i, ind);
                    tot += mx;
                    if (dsu.getConnectedComponents() == 1) {
                        cout << tot << '\n';
                        exit(0);
                    }
                }
            }
        }
    }

}

Compilation message

sirni.cpp:25: warning: ignoring '#pragma GCC optimization' [-Wunknown-pragmas]
   25 | #pragma GCC optimization ("O3")
      | 
sirni.cpp:26: warning: ignoring '#pragma GCC optimization' [-Wunknown-pragmas]
   26 | #pragma GCC optimization ("unroll-loops")
      | 
sirni.cpp: In function 'int main()':
sirni.cpp:96:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, std::pair<int, int> > >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   96 |         for (int i = 0; i < vec.size(); i++) {
      |                         ~~^~~~~~~~~~~~

Subtask #1
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 52 ms 6596 KB Output is correct
2 Correct 67 ms 6612 KB Output is correct
3 Correct 55 ms 6596 KB Output is correct

Subtask #2
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 67 ms 6576 KB Output is correct
2 Correct 70 ms 6596 KB Output is correct
3 Correct 56 ms 6596 KB Output is correct

Subtask #3
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 61 ms 6632 KB Output is correct
2 Correct 48 ms 6596 KB Output is correct
3 Correct 59 ms 6596 KB Output is correct

Subtask #4
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 262 ms 46472 KB Output is correct
2 Correct 771 ms 76428 KB Output is correct
3 Correct 381 ms 62472 KB Output is correct

Subtask #5
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 46 ms 29404 KB Output is correct
2 Correct 3851 ms 202464 KB Output is correct
3 Correct 260 ms 32388 KB Output is correct

Subtask #6
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 506 ms 56624 KB Output is correct
2 Correct 1027 ms 103820 KB Output is correct
3 Correct 308 ms 56720 KB Output is correct

Subtask #7
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 71 ms 12104 KB Output is correct
2 Correct 1106 ms 101248 KB Output is correct
3 Correct 369 ms 62660 KB Output is correct

Subtask #8
0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 480 ms 277668 KB Output is correct
2 Execution timed out 5070 ms 655904 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #9
0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 399 ms 289512 KB Output is correct
2 Execution timed out 5082 ms 622476 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #10
0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Incorrect 195 ms 242040 KB Output isn't correct
2 Halted 0 ms 0 KB -