Submission #29702213

---

Source Code Expand

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); ++i)

std::vector<std::string> split(const std::string& text, const char delim);

using ll = long long int;
using llu = unsigned long long int;

const char B = '#';
const char W = '.';

void show(const vector<vector<char>>& table){
    for (const auto& line : table) {
        for (const auto& item : line) {
            cout << item;
        }
        cout << endl;
    }
}

enum class Direction{
    UP = 0,
    DOWN,
    LEFT,
    RIGHT,
    UP_LEFT,
    UP_RIGHT,
    DOWN_LEFT,
    DOWN_RIGHT
};

const vector<Direction> all_dir = {
    Direction::UP,
    Direction::DOWN,
    Direction::LEFT,
    Direction::RIGHT,
    Direction::UP_LEFT,
    Direction::UP_RIGHT,
    Direction::DOWN_LEFT,
    Direction::DOWN_RIGHT
};

// pair(Y, X)
const map<Direction, pair<int, int>> dir_map = {
    {Direction::UP, make_pair(-1, 0)},
    {Direction::DOWN, make_pair(+1, 0)},
    {Direction::LEFT, make_pair(0, -1)},
    {Direction::RIGHT, make_pair(0, +1)},
    {Direction::UP_LEFT, make_pair(-1, -1)},
    {Direction::UP_RIGHT, make_pair(-1, 1)},
    {Direction::DOWN_LEFT, make_pair(+1, -1)},
    {Direction::DOWN_RIGHT, make_pair(+1, +1)},
};

int count_b_line(const int N, const vector<vector<char>>& table, const int i, const int j){
    map<char, int> count;

    for (const auto& dir : all_dir) {
        count[B] = 0;
        count[W] = 0;
        int next_i = i;
        int next_j = j;

        for (int n = 0; n < 6; ++n) {
            count[table[next_i][next_j]]++;

            if (2 < count[W]) {
                count[W] = 2;
                break;
            }

            const auto& target_dir = dir_map.at(dir);
            next_i += target_dir.first;
            next_j += target_dir.second;

            if (next_i < 0 || N <= next_i) {
                break;
            }
            if (next_j < 0 || N <= next_j) {
                break;
            }
        }
        if (6 <= count[B] + count[W]) {
            return 6;
        }
    }

    return 0;
}

int main(){
    string buffer;
    getline(cin, buffer);
    const int N = stoi(buffer);

    vector<vector<char>> table;
    vector<pair<int, int>> b_point;

    table.resize(N);

    for (int i = 0; i < N; ++i) {
        table[i].reserve(N);
        getline(cin, buffer);

        for (int j = 0; j < N; ++j) {
            if (buffer[j] == B) {
                b_point.emplace_back(make_pair(i, j));
            }
            table[i].emplace_back(buffer[j]);
        }
    }

    for (const auto& p : b_point) {
        if (6 <= count_b_line(N, table, p.first, p.second)) {
            cout << "Yes" << endl;
            return 0;
        }
    }
    cout << "No" << endl;

    return 0;
}

std::vector<std::string> split(const std::string& text, char delim) {
    std::vector<std::string> elems;
    std::stringstream ss(text);
    std::string item;
    while (std::getline(ss, item, delim)) {
    if (!item.empty()) {
            elems.emplace_back(item);
        }
    }
    return elems;
}

Submission Info

Judge Result