제출 #544058

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
544058		Olympia	Domino (COCI15_domino)	C++17	0 / 160	3482 ms	524288 KiB

domino

#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 <cstdio>
#include <limits.h>

using namespace std;

struct Domino {
    pair<int,int> from, to;
    int 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<int> 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) {
        dp.assign((1 << (int)adj.size()), 0);
        for (int i = 0; i < dp.size(); i++) {
            if (__builtin_popcount(i) > k) {
                continue;
            }
            vector<int> nodes;
            for (int j = 0; j < adj.size(); j++) {
                if (i & (1 << j)) {
                    nodes.push_back(j);
                    //cout << "YES ";
                }
            }
            //cout << adj.size() << " " << i << " " << nodes.size() << " " << __builtin_popcount(i) << '\n';
            assert(nodes.size() == __builtin_popcount(i));
            bool fine = true;
            for (int x: nodes) {
                for (int y: nodes) {
                    if (x == y) continue;
                    if (!adj[x][y]) {
                        fine = false;
                    }
                }
            }
            if (!fine) {
                continue;
            }
            for (int x: nodes) {
                dp[i] += weight[x];
            }
            if (dp[i] == 20) {
                for (int x: nodes) {
                    cout << x << " " << weight[x] << '\n';
                }
                cout << '\n';
            }
        }
        for (int i = 1; i < dp.size(); i++) {
            for (int j = 1; j < adj.size(); j++) {
                if (i & (1 << j)) {
                    dp[i] = max(dp[i], dp[i - (1 << j)]);
                }
            }
        }
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n, m;
    cin >> n >> m;
    int grid[n][n];
    int sm = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> grid[i][j];
            sm += grid[i][j];
        }
    }
    vector<Domino> dominoes;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int dx = -1; dx <= 1; dx++) {
                for (int dy = -1; dy <= 1; dy++) {
                    if (i + dx < 0 || j + dy < 0) continue;
                    if (i + dx == n || j + dy == n) continue;
                    if (abs(dx) + abs(dy) != 1) continue;
                    //if (dx < dy) continue;
                    dominoes.push_back({{i, j}, {i + dx,j + dy}, grid[i][j] + grid[i + dx][j + dy]});
                }
            }
        }
    }
    sort(dominoes.begin(), dominoes.end());
    while (dominoes.size() > 50) {
        dominoes.pop_back();
    }
    vector<pair<int,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;
            //cout << d1.from.first << " " << d1.from.seco
            edges.push_back({d1.cost + d2.cost, {d1, d2}});
        }
    }
    set<Domino> mySet;
    for (auto& p: edges) {
        mySet.insert(p.second.first), mySet.insert(p.second.second);
    }
    map<Domino,int> myMap; int cntr = 0;
    vector<int> weights;
    for (Domino d: mySet) {
        weights.push_back(d.cost);
        myMap[d] = cntr++;
    }
    Graph gr(cntr);
    gr.weight = weights;
    for (auto& e: edges) {
        gr.add_edge(myMap[e.second.first], myMap[e.second.second]);
    }
    gr.solve(m);
    cout << sm << " " << gr.dp.back();
}

컴파일 시 표준 에러 (stderr) 메시지

domino.cpp: In member function 'void Graph::solve(int)':
domino.cpp:47:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   47 |         for (int i = 0; i < dp.size(); i++) {
      |                         ~~^~~~~~~~~~~
domino.cpp:52:31: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   52 |             for (int j = 0; j < adj.size(); j++) {
      |                             ~~^~~~~~~~~~~~
domino.cpp:82:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   82 |         for (int i = 1; i < dp.size(); i++) {
      |                         ~~^~~~~~~~~~~
domino.cpp:83:31: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   83 |             for (int j = 1; j < adj.size(); j++) {
      |                             ~~^~~~~~~~~~~~

• Subtask 1: 0 / 10
• Subtask 2: 0 / 10
• Subtask 3: 0 / 10
• Subtask 4: 0 / 10
• Subtask 5: 0 / 10
• Subtask 6: 0 / 10
• Subtask 7: 0 / 10
• Subtask 8: 0 / 10
• Subtask 9: 0 / 10
• Subtask 10: 0 / 10
• Subtask 11: 0 / 10
• Subtask 12: 0 / 10
• Subtask 13: 0 / 10
• Subtask 14: 0 / 10
• Subtask 15: 0 / 10
• Subtask 16: 0 / 10