結果

問題 No.2825 Sum of Scores of Sets of Specified Sections
ユーザー 🦠みどりむし🦠みどりむし
提出日時 2024-04-13 11:21:13
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 219 ms / 3,000 ms
コード長 4,220 bytes
コンパイル時間 1,354 ms
コンパイル使用メモリ 119,192 KB
実行使用メモリ 6,944 KB
最終ジャッジ日時 2024-07-26 20:00:59
合計ジャッジ時間 3,765 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,816 KB
testcase_01 AC 219 ms
6,812 KB
testcase_02 AC 217 ms
6,944 KB
testcase_03 AC 216 ms
6,940 KB
testcase_04 AC 27 ms
6,940 KB
testcase_05 AC 10 ms
6,940 KB
testcase_06 AC 2 ms
6,944 KB
testcase_07 AC 25 ms
6,944 KB
testcase_08 AC 14 ms
6,944 KB
testcase_09 AC 10 ms
6,944 KB
testcase_10 AC 9 ms
6,940 KB
testcase_11 AC 3 ms
6,940 KB
testcase_12 AC 2 ms
6,944 KB
testcase_13 AC 9 ms
6,940 KB
testcase_14 AC 33 ms
6,940 KB
testcase_15 AC 33 ms
6,944 KB
testcase_16 AC 33 ms
6,940 KB
testcase_17 AC 34 ms
6,940 KB
testcase_18 AC 34 ms
6,944 KB
testcase_19 AC 34 ms
6,944 KB
testcase_20 AC 34 ms
6,940 KB
testcase_21 AC 35 ms
6,944 KB
testcase_22 AC 34 ms
6,940 KB
testcase_23 AC 35 ms
6,944 KB
testcase_24 AC 6 ms
6,944 KB
testcase_25 AC 6 ms
6,944 KB
testcase_26 AC 6 ms
6,944 KB
testcase_27 AC 6 ms
6,940 KB
testcase_28 AC 2 ms
6,944 KB
testcase_29 AC 2 ms
6,940 KB
testcase_30 AC 2 ms
6,940 KB
testcase_31 AC 1 ms
6,944 KB
testcase_32 AC 62 ms
6,940 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <cassert>
#include <iostream>
#include <vector>
#include <ranges>

#include <atcoder/modint>


using mint = atcoder::modint998244353;


std::istream& operator>>(std::istream& is, mint& v) {
    int r; is >> r, v = r;
    return is;
}

std::ostream& operator<<(std::ostream& os, const mint& v) {
    return os << v.val();
}


template<class ValueType>
struct matrix {
    using size_type = std::ptrdiff_t;
    using value_type = ValueType;

  private:
    size_type _height, _width;
    std::vector<std::vector<value_type>> _data;

    size_type height() const { return this->_height; }
    size_type width() const { return this->_width; }

  public:
    matrix(const size_type n, const size_type m)
      : _height(n), _width(m), _data(n, std::vector<value_type>(m))
    {}

    void resize(const size_type n, const size_type m) {
        this->_height = n, this->_width = m;
        this->_data.resize(n);
        for(auto& row : this->_data) row.resize(m);
    }

    static matrix identity(const size_type n) {
        matrix res(n, n);
        for(const size_type i : std::views::iota(0, n)) res[i][i] = 1;
        return res;
    }

    inline const std::vector<value_type>& operator[](const size_type p) const { return this->_data[p]; }
    inline std::vector<value_type>& operator[](const size_type p) { return this->_data[p]; }

    matrix& operator+=(const matrix& rhs) {
        const size_type n = this->height(), m = this->width();
        assert(n == rhs.height() && m == rhs.width());
        for(size_type i : std::views::iota(0, n)) {
            for(size_type j : std::views::iota(0, m)) {
                (*this)[i][j] += rhs[i][j];
            }
        }
        return *this;
    }

    matrix& operator*=(const matrix& rhs) {
        const size_type n = this->height(), m = rhs._width, l = this->width();
        assert(l == rhs._height);
        matrix product(n, m);
        for(size_type i : std::views::iota(0, n)) {
            for(size_type j : std::views::iota(0, m)) {
                for(size_type k : std::views::iota(0, l)) {
                    product[i][j] += (*this)[i][k] * rhs[k][j];
                }
            }
        }
        this->resize(n, m);
        this->_data = std::move(product._data);
        return *this;
    }

    matrix& transpose() {
        matrix res(this->width(), this->height());

        for(const size_type i : std::views::iota(0, this->height())) {
            for(const size_type j : std::views::iota(0, this->width())) {
                res[j][i] = (*this)[i][j];
            }
        }

        this->resize(res.height(), res.width());
        this->_data = std::move(res._data);
        return *this;
    }

    value_type det() const {
        auto X = this->_data;
        value_type res = 1;

        for(const size_type i : std::views::iota(0, this->width())) {
            size_type pivot = {-1};

            for(const size_type j : std::views::iota(i, this->width())) {
                if(X[j][i] != 0) pivot = j;
            }

            if(pivot == -1) return 0;

            if(i != pivot) {
                res *= -1;
                std::swap(X[i], X[pivot]);
            }

            res *= X[i][i];

            const value_type inv = 1 / X[i][i];
            for(const size_type j : std::views::iota(0, this->width())) {
                X[i][j] *= inv;
            }

            for(const size_type j : std::views::iota(i + 1, this->width())) {
                const value_type v = X[j][i];
                for(const size_type k : std::views::iota(0, this->width())) {
                    X[j][k] -= X[i][k] * v;
                }
            }
        }

        return res;
    }

    friend matrix operator+(matrix a, const matrix& b) { return a += b; }
    friend matrix operator*(matrix a, const matrix& b) { return a *= b; }

    friend std::istream& operator>>(std::istream& is, matrix& p) {
        for(auto& row : p._data) {
            for(auto& v : row) is >> v;
        }
        return is;
    }
};


int main() {
    int n, m; std::cin >> n >> m;
    matrix<mint> A(n, m), B(n, m); std::cin >> A >> B;
    std::cout << (matrix<mint>::identity(n) + A * B.transpose()).det() - 1 << "\n";
    return 0;
}
0