CSES - Putka Open 2025 – 5/5

Submission details
Task:	Yhdistelmät
Sender:	sharph2
Submission time:	2025-11-29 11:56:55 +0200
Language:	C++ (C++17)
Status:	READY
Result:	62

Feedback
group	verdict	score
#1	ACCEPTED	16
#2	ACCEPTED	17
#3	ACCEPTED	29
#4	TIME LIMIT EXCEEDED	0

Test results
test	verdict	time	group
#1	ACCEPTED	0.00 s	1, 2, 3, 4	details
#2	ACCEPTED	0.00 s	1, 3, 4	details
#3	ACCEPTED	0.00 s	1, 4	details
#4	ACCEPTED	0.00 s	1, 4	details
#5	ACCEPTED	0.01 s	1, 4	details
#6	ACCEPTED	0.00 s	1, 4	details
#7	ACCEPTED	0.01 s	1, 4	details
#8	ACCEPTED	0.01 s	1, 4	details
#9	ACCEPTED	0.01 s	1, 4	details
#10	ACCEPTED	0.01 s	1, 4	details
#11	ACCEPTED	0.00 s	2, 3, 4	details
#12	ACCEPTED	0.00 s	3, 4	details
#13	TIME LIMIT EXCEEDED	--	4	details
#14	TIME LIMIT EXCEEDED	--	4	details
#15	TIME LIMIT EXCEEDED	--	4	details
#16	TIME LIMIT EXCEEDED	--	4	details
#17	TIME LIMIT EXCEEDED	--	4	details
#18	ACCEPTED	0.00 s	1, 2, 3, 4	details
#19	ACCEPTED	0.00 s	1, 2, 3, 4	details
#20	TIME LIMIT EXCEEDED	--	4	details
#21	TIME LIMIT EXCEEDED	--	4	details

Code

#include <climits>
#include <cstdint>
#include <iostream>
#include <tuple>
#include <vector>

using namespace std;

struct Maski {
    uint64_t a = 0;
    uint64_t b = 0;

    void lisaa(int x) {
        if(x < 64) {
            a |= uint64_t{1} << x;
        } else {
            b |= uint64_t{1} << (x - 64);
        }
    }
    void poista(int x) {
        if(x < 64) {
            a &= ~(uint64_t{1} << x);
        } else {
            b &= ~(uint64_t{1} << (x - 64));
        }
    }
    bool hae(int x) const {
        if(x < 64) {
            return (a & (uint64_t{1} << x)) != 0;
        } else {
            return (b & (uint64_t{1} << (x - 64))) != 0;
        }
    }

    int lkm() const {
        return __builtin_popcountll(a) + __builtin_popcountll(b);
    }

    bool operator==(const Maski& m) const {
        return a == m.a && b == m.b;
    }
    bool operator!=(const Maski& m) const {
        return a != m.a || b != m.b;
    }

    Maski operator&(const Maski& m) const {
        return {a & m.a, b & m.b};
    }
    Maski operator|(const Maski& m) const {
        return {a | m.a, b | m.b};
    }
};

int n, m;
vector<int> esineenHinta;
vector<int> yhdistelmanPalkkio;
vector<Maski> yhdistelmanEsineet;
vector<Maski> esineenYhdistelmat;

pair<int, Maski> hae(Maski esineet, Maski yhdistelmat);

pair<int, Maski> hae2(Maski esineet, Maski yhdistelmat) {
    int suosituinEsineIdx = -1;
    int suosituinEsineYhdistelmaLkm = 0;
    for(int esineIdx = 0; esineIdx < n; ++esineIdx) {
        if(esineet.hae(esineIdx)) {
            int yhdistelmaLkm = (esineenYhdistelmat[esineIdx] & yhdistelmat).lkm();
            if(yhdistelmaLkm > suosituinEsineYhdistelmaLkm) {
                suosituinEsineIdx = esineIdx;
                suosituinEsineYhdistelmaLkm = yhdistelmaLkm;
            }
        }
    }

    if(suosituinEsineIdx == -1) {
        return {0, {}};
    }

    Maski loputEsineet = esineet;
    loputEsineet.poista(suosituinEsineIdx);

    int tulosTuotto = 0;
    Maski tulosEsineet;

    // Valitaan esine suosituinEsineIdx mukaan
    {
        int palkkiot = 0;
        Maski loputYhdistelmat = yhdistelmat;
        for(int yhdistelmaIdx = 0; yhdistelmaIdx < m; ++yhdistelmaIdx) {
            if(yhdistelmat.hae(yhdistelmaIdx) && (yhdistelmanEsineet[yhdistelmaIdx] & loputEsineet) == Maski()) {
                loputYhdistelmat.poista(yhdistelmaIdx);
                palkkiot += yhdistelmanPalkkio[yhdistelmaIdx];
            }
        }
        tie(tulosTuotto, tulosEsineet) = hae(loputEsineet, loputYhdistelmat);
        tulosTuotto += palkkiot - esineenHinta[suosituinEsineIdx];
        tulosEsineet.lisaa(suosituinEsineIdx);
    }

    // Jätetään esine suosituinEsineIdx valitsematta
    {
        Maski loputYhdistelmat = yhdistelmat;
        for(int yhdistelmaIdx = 0; yhdistelmaIdx < m; ++yhdistelmaIdx) {
            if(yhdistelmat.hae(yhdistelmaIdx) && yhdistelmanEsineet[yhdistelmaIdx].hae(suosituinEsineIdx)) {
                loputYhdistelmat.poista(yhdistelmaIdx);
            }
        }
        auto [tuotto2, esineet2] = hae(loputEsineet, loputYhdistelmat);
        if(tuotto2 > tulosTuotto) {
            tulosTuotto = tuotto2;
            tulosEsineet = esineet2;
        }
    }

    return {tulosTuotto, tulosEsineet};
}

struct UF {
    int vanhempi[100];

    UF() {
        for(int i = 0; i < 100; ++i) {
            vanhempi[i] = i;
        }
    }

    int hae(int x) {
        if(vanhempi[x] != x) {
            vanhempi[x] = hae(vanhempi[x]);
        }
        return vanhempi[x];
    }

    void yhdista(int x, int y) {
        x = hae(x);
        y = hae(y);
        vanhempi[x] = y;
    }
};

pair<int, Maski> hae(Maski esineet, Maski yhdistelmat) {
    UF uf;
    for(int yhdistelmaIdx = 0; yhdistelmaIdx < m; ++yhdistelmaIdx) {
        if(yhdistelmat.hae(yhdistelmaIdx)) {
            Maski jaljEsineet = esineet & yhdistelmanEsineet[yhdistelmaIdx];
            int edellinen = -1;
            for(int esineIdx = 0; esineIdx < n; ++esineIdx) {
                if(jaljEsineet.hae(esineIdx)) {
                    if(edellinen != -1) {
                        uf.yhdista(edellinen, esineIdx);
                    }
                    edellinen = esineIdx;
                }
            }
        }
    }

    int tulosTuotto = 0;
    Maski tulosEsineet;

    Maski jaljEsineet = esineet;
    for(int esineIdx = 0; esineIdx < n; ++esineIdx) {
        if(jaljEsineet.hae(esineIdx)) {
            jaljEsineet.poista(esineIdx);
            Maski komponentinEsineet;
            komponentinEsineet.lisaa(esineIdx); 
            for(int esineIdx2 = esineIdx + 1; esineIdx2 < n; ++esineIdx2) {
                if(jaljEsineet.hae(esineIdx2) && uf.hae(esineIdx) == uf.hae(esineIdx2)) {
                    jaljEsineet.poista(esineIdx2);
                    komponentinEsineet.lisaa(esineIdx2);
                }
            }
            Maski komponentinYhdistelmat;
            for(int yhdistelmaIdx = 0; yhdistelmaIdx < m; ++yhdistelmaIdx) {
                if(yhdistelmat.hae(yhdistelmaIdx) && (yhdistelmanEsineet[yhdistelmaIdx] & komponentinEsineet) != Maski()) {
                    komponentinYhdistelmat.lisaa(yhdistelmaIdx);
                }
            }
            auto [tuotto2, esineet2] = hae2(komponentinEsineet, komponentinYhdistelmat);
            tulosTuotto += tuotto2;
            tulosEsineet = (tulosEsineet | esineet2);
        }
    }

    return {tulosTuotto, tulosEsineet};
}

int main() {
    cin.sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;

    esineenHinta.resize(n);
    esineenYhdistelmat.resize(n);
    for(int& x : esineenHinta) {
        cin >> x;
    }

    yhdistelmanPalkkio.resize(m);
    yhdistelmanEsineet.resize(m);
    for(int yhdistelmaIdx = 0; yhdistelmaIdx < m; ++yhdistelmaIdx) {
        int k;
        cin >> k >> yhdistelmanPalkkio[yhdistelmaIdx];
        for(int j = 0; j < k; ++j) {
            int esineIdx;
            cin >> esineIdx;
            --esineIdx;
            yhdistelmanEsineet[yhdistelmaIdx].lisaa(esineIdx);
            esineenYhdistelmat[esineIdx].lisaa(yhdistelmaIdx);
        }
    }

    Maski kaikkiEsineet;
    for(int esineIdx = 0; esineIdx < n; ++esineIdx) {
        kaikkiEsineet.lisaa(esineIdx);
    }
    Maski kaikkiYhdistelmat;
    for(int yhdistelmaIdx = 0; yhdistelmaIdx < m; ++yhdistelmaIdx) {
        kaikkiYhdistelmat.lisaa(yhdistelmaIdx);
    }

    auto [tuotto, esineet] = hae(kaikkiEsineet, kaikkiYhdistelmat);

    cout << tuotto << "\n";

    int lkm = 0;
    for(int i = 0; i < n; ++i) {
        if(esineet.hae(i)) {
            ++lkm;
        }
    }
    cout << lkm << "\n";

    for(int i = 0; i < n; ++i) {
        if(esineet.hae(i)) {
            cout << i + 1 << " ";
        }
    }
    cout << "\n";

    return 0;
}

Test details

Test 1

Group: 1, 2, 3, 4

Verdict: ACCEPTED

input
`20 20 80 69 91 47 74 75 94 22 100 43...` view save

correct output
`446 11 2 3 5 8 10 13 14 15 17 19 20` view save

user output
`446 11 2 3 5 8 10 13 14 15 17 19 20` view save

Test 2

Group: 1, 3, 4

Verdict: ACCEPTED

input
`20 20 5 42 7 18 55 64 64 83 73 44 22...` view save

correct output
`425 11 1 2 3 4 7 10 13 16 18 19 20` view save

user output
`425 11 1 2 3 4 7 10 13 16 18 19 20` view save

Test 3

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 30 98 55 69 40 3 95 12 64 56 3...` view save

correct output
`284 8 1 3 8 10 15 16 18 19` view save

user output
`284 8 1 3 8 10 15 16 18 19` view save

Test 4

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 11 44 58 8 16 52 20 43 24 31 4...` view save

correct output
`348 10 2 4 5 7 11 13 15 16 18 20` view save

user output
`348 10 2 4 5 7 11 13 15 16 18 20` view save

Test 5

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 53 44 5 37 88 36 81 47 85 97 3...` view save

correct output
`119 13 1 2 4 8 10 11 13 14 16 17 18 1...` view save

user output
`119 13 1 2 4 8 10 11 13 14 16 17 18 1...` view save

Test 6

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 20 27 75 94 48 62 37 55 49 67 ...` view save

correct output
`478 11 1 2 5 7 10 12 13 15 16 17 18` view save

user output
`478 11 1 2 5 7 10 12 13 15 16 17 18` view save

Test 7

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 32 28 67 72 32 76 53 30 47 67 ...` view save

correct output
`215 10 2 4 5 7 8 9 11 13 16 20` view save

user output
`215 10 2 4 5 7 8 9 11 13 16 20` view save

Test 8

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 39 72 74 79 49 45 73 44 37 4 7...` view save

correct output
`185 13 1 3 5 6 7 8 10 13 14 16 17 18 ...` view save

user output
`185 13 1 3 5 6 7 8 10 13 14 16 17 18 ...` view save

Test 9

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 41 56 65 78 2 13 17 42 83 76 9...` view save

correct output
`95 11 2 4 5 6 7 8 13 14 17 18 19` view save

user output
`95 11 2 4 5 6 7 8 13 14 17 18 19` view save

Test 10

Group: 1, 4

Verdict: ACCEPTED

input
`20 20 43 1 20 61 25 46 2 18 36 1 85 ...` view save

correct output
`111 8 1 2 3 7 8 10 16 19` view save

user output
`111 8 1 2 3 7 8 10 16 19` view save

Test 11

Group: 2, 3, 4

Verdict: ACCEPTED

input
`100 100 992248 852673 366775 737068 56...` view save

correct output
`30642743 46 3 5 6 9 11 12 15 16 17 18 21 2...` view save

user output
`30642743 46 3 5 6 9 11 12 15 16 17 18 21 2...` view save

Test 12

Group: 3, 4

Verdict: ACCEPTED

input
`100 100 153790 361741 45017 47184 9422...` view save

correct output
`16529629 39 2 3 4 5 10 12 14 17 24 25 26 3...` view save

user output
`16529629 39 2 3 4 5 10 12 14 17 24 25 26 3...` view save

Test 13

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 186797 446409 957173 150683 17...` view save

correct output
`14928280 62 1 2 8 9 10 11 12 14 15 16 17 2...` view save

user output
(empty)

Test 14

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 343213 582494 707357 104682 66...` view save

correct output
`11308944 72 1 3 4 5 6 7 8 9 10 11 12 13 14...` view save

user output
(empty)

Test 15

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 922546 12088 805566 351521 644...` view save

correct output
`3311952 10 14 17 26 29 64 65 70 76 83 95` view save

user output
(empty)

Test 16

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 923042 35929 531316 587665 845...` view save

correct output
`519209 6 2 18 45 61 64 86` view save

user output
(empty)

Test 17

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 493725 218022 417464 531537 83...` view save

correct output
`1255541 11 16 19 24 29 30 50 60 62 67 74 ...` view save

user output
(empty)

Test 18

Group: 1, 2, 3, 4

Verdict: ACCEPTED

input
`1 1 2 1 1 1` view save

correct output
`0 0` view save

user output
`0 0` view save

Test 19

Group: 1, 2, 3, 4

Verdict: ACCEPTED

input
`1 1 1 1 2 1` view save

correct output
`1 1 1` view save

user output
`1 1 1` view save

Test 20

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 1000000 1000000 1000000 100000...` view save

correct output
`0 100 1 2 3 4 5 6 7 8 9 10 11 12 13 ...` view save

user output
(empty)

Test 21

Group: 4

Verdict: TIME LIMIT EXCEEDED

input
`100 100 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ...` view save

correct output
`99999900 100 1 2 3 4 5 6 7 8 9 10 11 12 13 ...` view save

user output
(empty)

Putka Open 2025 – 5/5

Yhdistelmät

Code

Test details

Test 1

Test 2

Test 3

Test 4

Test 5

Test 6

Test 7

Test 8

Test 9

Test 10

Test 11

Test 12

Test 13

Test 14

Test 15

Test 16

Test 17

Test 18

Test 19

Test 20

Test 21

Tasks

Submissions (sharph2)