Submission #47051793

---

Source Code Expand

#include <bits/stdc++.h>
#include <atcoder/modint>

namespace {
using ModInt [[maybe_unused]] = atcoder::modint998244353;
using Num [[maybe_unused]] = long long int;
using Vec [[maybe_unused]] = std::vector<Num>;
using Set [[maybe_unused]] = std::set<Num>;
using Mset [[maybe_unused]] = std::multiset<Num>;
using Edges [[maybe_unused]] = std::vector<std::vector<Num>>;

template<typename T>
using Q [[maybe_unused]] = std::queue<T>;

template<typename T>
using PQ [[maybe_unused]] = std::priority_queue<T, std::vector<T>, std::greater<T>>;
}

void solve(std::istream& is, std::ostream& os) {
    Num n {0};
    std::string rows;
    std::string cols;
    is >> n >> rows >> cols;

    std::string base(n, '.');
    base.at(n-3) = 'A';
    base.at(n-2) = 'B';
    base.at(n-1) = 'C';

    std::vector<std::vector<std::string>> lines(3);
    do {
        Num index {0};
        while(base.at(index) == '.') {
            ++index;
        }
        const Num pre = base.at(index) - 'A';
        lines.at(pre).push_back(base);
    } while(std::next_permutation(base.begin(), base.end()));

    Num size = static_cast<Num>(lines.at(0).size());
    Num total_size {1};
    for(Num i{0}; i<n; ++i) {
        total_size *= size;
    }

    for(Num pattern{0}; pattern<total_size; ++pattern) {
        std::vector<std::string*> ss(5);
        Num p = pattern;
        for(Num y{0}; y<n; ++y) {
            Num pre = rows.at(y) - 'A';
            ss.at(y) = &(lines.at(pre).at(p % size));
            p /= size;
        }

        bool failed {false};
        for(Num x{0}; x<n; ++x) {
            const auto target = cols.at(x);
            bool first {true};
            std::array<Num, 3> counts {0, 0, 0};

            for(Num ty{0}; ty<n; ++ty) {
                const auto c = ss.at(ty)->at(x);
                if (c == '.') {
                    continue;
                }

                counts.at(c - 'A') += 1;
                if (first) {
                    if (c != target) {
                        failed = true;
                    }
                }
                first = false;
            }

            failed |= std::any_of(counts.begin(), counts.end(), [](const auto& x) {return x != 1;});
        }

        if (!failed) {
            os << "Yes\n";
            for(Num y{0}; y<n; ++y) {
                os << *ss.at(y) << "\n";
            }
            return;
        }
    }

    os << "No\n";
}

int main(void) {
    solve(std::cin, std::cout);
    return 0;
}

Submission Info

Judge Result