oj.uz

답안 #544279

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
544279 2022-04-01T15:00:02 Z Olympia Domino (COCI15_domino) C++17
100 / 160
 4000 ms 42100 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;

struct Domino {
    pair<int, int> from, to;
    int64_t cost;

    bool operator<(const Domino &d1) const {
        if (this->cost != d1.cost) return (this->cost > d1.cost);
        if (this->from != d1.from) return (this->from < d1.from);
        if (this->to != d1.to) return (this->to < d1.to);
        return false;
    }
};

class Graph {
public:
    vector<int64_t> weight;
    vector<vector<int>> adj;
    vector<int> dp;

    void add_edge(int u, int v) {
        adj[u][v] = adj[v][u] = 1;
    }

    Graph(int n) {
        adj.resize(n);
        for (int i = 0; i < n; i++) {
            adj[i].assign(n, 0);
        }
    }

    void solve(int k, bool b) {
        dp.assign((1 << (int) adj.size()), 0);
        for (int i = 1; i < dp.size(); i++) {
            if (__builtin_popcount(i) > k) {
                continue;
            }
            if (__builtin_popcount(i) == 1) {
                dp[i] = weight[log2(i)];
                continue;
            }
            int mx = log2(i);
            int mn = log2(i & -i);
            if (!adj[mx][mn] || !dp[i - (1 << mx)] || !dp[i - (1 << mn)]) {
                continue;
            }
            dp[i] = dp[i - (1 << (int)log2(i))] + weight[(int)log2(i)];
        }
        if (b) return;
        for (int i = 1; i < dp.size(); i++) {
            int x = i;
            while (x != 0) {
                dp[i] = max(dp[i], dp[i - (1 << __builtin_ctzll(x))]);
                x = x & (x - 1);
            }
        }
    }
};

int main() {
    //freopen("balancing.in", "r", stdin);
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n, m;
    scanf("%d%d", &n, &m);
    int64_t grid[n][n];
    int64_t sm = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%lld", &grid[i][j]);
            sm += grid[i][j];
        }
    }
    vector<Domino> dominoes;
    vector<pair<int, int>> pos;
    pos.emplace_back(1, 0);
    pos.emplace_back(0, 1);
    for (int i = 0; i < n; i++) {
        for (auto &p: pos) {
            if (i + p.first < 0 || i + p.first == n) continue;
            for (int j = 0; j < n; j++) {
                if (j + p.second < 0 || j + p.second == n) continue;
                dominoes.push_back({{i, j}, {i + p.first, j + p.second}, grid[i][j] + grid[i + p.first][j + p.second]});
            }
        }
        nth_element(dominoes.begin(), dominoes.begin() + max(7 * (m - 1) + 1, 7), dominoes.end());
        while (dominoes.size() > max(7 * (m - 1) + 1, 7)) {
            dominoes.pop_back();
        }
    }
    vector<pair<int64_t, pair<Domino, Domino>>> edges;
    for (auto &d1: dominoes) {
        for (auto &d2: dominoes) {
            set<pair<int, int>> s;
            s.insert(d1.from), s.insert(d1.to), s.insert(d2.from), s.insert(d2.to);
            if (s.size() != 4) continue;
            edges.push_back({d1.cost + d2.cost, {d1, d2}});
        }
    }
    int t = 20;
    int64_t myMax = 0;
    while (t--) {
        set<Domino> mySet;
        for (auto &p: edges) {
            mySet.insert(p.second.first), mySet.insert(p.second.second);
        }
        vector<Domino> ms;
        for (Domino d: mySet) ms.push_back(d);
        random_shuffle(ms.begin(), ms.end());
        while (ms.size() > 40) {
            ms.pop_back();
        }
        map<Domino, int> myMap;
        int cntr = 0;
        vector<int64_t> weights;
        for (Domino d: ms) {
            weights.push_back(d.cost);
            myMap[d] = cntr++;
        }
        Graph gr(cntr), gr1(cntr / 2), gr2(cntr - cntr / 2);
        gr.weight = weights;
        for (int i = 0; i < cntr / 2; i++) gr1.weight.push_back(weights[i]);
        for (int i = cntr / 2; i < cntr; i++) gr2.weight.push_back(weights[i]);
        for (auto &e: edges) {
            gr.add_edge(myMap[e.second.first], myMap[e.second.second]);
            if (myMap[e.second.first] < cntr / 2 && myMap[e.second.second] < cntr / 2)
                gr1.add_edge(myMap[e.second.second], myMap[e.second.first]);
            if (myMap[e.second.first] >= cntr / 2 && myMap[e.second.second] >= cntr / 2)
                gr2.add_edge(myMap[e.second.second] - cntr / 2, myMap[e.second.first] - cntr / 2);

        }
        gr1.solve(m, true);
        vector<int> cnt[m + 1];
        for (int i = 1; i < gr1.dp.size(); i++) {
            if (gr1.dp[i] != 0) cnt[__builtin_popcount(i)].push_back(i);
        }
        for (int pc = 1; pc <= m; pc++) {
            gr2.solve(m - pc, false);
            for (int i: cnt[pc]) {
                vector<int> nodes;
                for (int j = 0; j < gr1.adj.size(); j++) {
                    if (i & (1 << j)) {
                        nodes.push_back(j);
                    }
                }
                int tot = 0;
                for (int j = 0; j < gr2.adj.size(); j++) {
                    bool fine = true;
                    for (int k: nodes) {
                        if (!gr.adj[j + cntr / 2][k]) {
                            fine = false;
                            break;
                        }
                    }
                    if (fine) {
                        tot += (1 << j);
                    }
                }
                myMax = max((int64_t) gr2.dp[tot] + (int64_t) gr1.dp[i], myMax);
            }
        }
        gr1.solve(m, false);
        myMax = max((int64_t) myMax, (int64_t) gr1.dp.back());
    }
    cout << sm - myMax;
}

Compilation message

domino.cpp:25: warning: ignoring '#pragma GCC optimization' [-Wunknown-pragmas]
   25 | #pragma GCC optimization ("O3")
      | 
domino.cpp:26: warning: ignoring '#pragma GCC optimization' [-Wunknown-pragmas]
   26 | #pragma GCC optimization ("unroll-loops")
      | 
domino.cpp: In member function 'void Graph::solve(int, bool)':
domino.cpp:61:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   61 |         for (int i = 1; i < dp.size(); i++) {
      |                         ~~^~~~~~~~~~~
domino.cpp:77:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   77 |         for (int i = 1; i < dp.size(); i++) {
      |                         ~~^~~~~~~~~~~
domino.cpp: In function 'int main()':
domino.cpp:97:23: warning: format '%lld' expects argument of type 'long long int*', but argument 2 has type 'int64_t*' {aka 'long int*'} [-Wformat=]
   97 |             scanf("%lld", &grid[i][j]);
      |                    ~~~^   ~~~~~~~~~~~
      |                       |   |
      |                       |   int64_t* {aka long int*}
      |                       long long int*
      |                    %ld
domino.cpp:114:32: warning: comparison of integer expressions of different signedness: 'std::vector<Domino>::size_type' {aka 'long unsigned int'} and 'const int' [-Wsign-compare]
  114 |         while (dominoes.size() > max(7 * (m - 1) + 1, 7)) {
      |                ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
domino.cpp:161:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  161 |         for (int i = 1; i < gr1.dp.size(); i++) {
      |                         ~~^~~~~~~~~~~~~~~
domino.cpp:168:35: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  168 |                 for (int j = 0; j < gr1.adj.size(); j++) {
      |                                 ~~^~~~~~~~~~~~~~~~
domino.cpp:174:35: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  174 |                 for (int j = 0; j < gr2.adj.size(); j++) {
      |                                 ~~^~~~~~~~~~~~~~~~
domino.cpp:92:10: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
   92 |     scanf("%d%d", &n, &m);
      |     ~~~~~^~~~~~~~~~~~~~~~
domino.cpp:97:18: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
   97 |             scanf("%lld", &grid[i][j]);
      |             ~~~~~^~~~~~~~~~~~~~~~~~~~~

Subtask #1
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 28 ms 2260 KB Output is correct
2 Correct 37 ms 2300 KB Output is correct

Subtask #2
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 340 KB Output is correct
2 Correct 1 ms 340 KB Output is correct

Subtask #3
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 424 ms 31800 KB Output is correct
2 Correct 614 ms 31796 KB Output is correct

Subtask #4
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 340 KB Output is correct
2 Correct 2 ms 340 KB Output is correct

Subtask #5
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 243 ms 18092 KB Output is correct
2 Correct 325 ms 18040 KB Output is correct

Subtask #6
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 121 ms 8124 KB Output is correct
2 Correct 140 ms 8140 KB Output is correct

Subtask #7
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 513 ms 32056 KB Output is correct
2 Correct 590 ms 32120 KB Output is correct

Subtask #8
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 837 ms 3000 KB Output is correct
2 Correct 716 ms 2744 KB Output is correct

Subtask #9
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1283 ms 34216 KB Output is correct
2 Correct 1255 ms 34260 KB Output is correct

Subtask #10
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4058 ms 10008 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #11
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 19 ms 468 KB Output is correct
2 Correct 20 ms 404 KB Output is correct

Subtask #12
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4074 ms 41504 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #13
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4077 ms 13140 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #14
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4073 ms 18664 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #15
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 3818 ms 8936 KB Output is correct
2 Execution timed out 4051 ms 8948 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #16
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4058 ms 42100 KB Time limit exceeded
2 Halted 0 ms 0 KB -