結果

問題 No.1521 Playing Musical Chairs Alone
ユーザー nok0nok0
提出日時 2021-05-28 13:18:33
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
RE  
実行時間 -
コード長 4,748 bytes
コンパイル時間 9,270 ms
コンパイル使用メモリ 336,556 KB
実行使用メモリ 5,248 KB
最終ジャッジ日時 2024-11-07 02:58:58
合計ジャッジ時間 9,837 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 RE -
testcase_02 RE -
testcase_03 AC 2 ms
5,248 KB
testcase_04 AC 2 ms
5,248 KB
testcase_05 RE -
testcase_06 AC 24 ms
5,248 KB
testcase_07 RE -
testcase_08 RE -
testcase_09 RE -
testcase_10 RE -
testcase_11 RE -
testcase_12 RE -
testcase_13 RE -
testcase_14 RE -
testcase_15 RE -
testcase_16 RE -
testcase_17 RE -
testcase_18 RE -
testcase_19 RE -
testcase_20 RE -
testcase_21 RE -
testcase_22 RE -
testcase_23 RE -
testcase_24 RE -
testcase_25 RE -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>

#include <atcoder/modint>
using namespace std;

#pragma region datastructure Matrix
#include <cassert>
#include <iostream>
#include <vector>

template <class T>
struct Matrix {
private:
	std::vector<std::vector<T>> A;

	static Matrix I(size_t n) {
		Matrix mat(n);
		for(int i = 0; i < n; i++) mat[i][i] = 1;
		return mat;
	}

public:
	Matrix() = default;

	Matrix(std::vector<std::vector<T>> &vvec) { A = vvec; }

	Matrix(size_t n, size_t m) : A(n, std::vector<T>(m, 0)) {}

	Matrix(size_t n, size_t m, T init) : A(n, std::vector<T>(m, init)) {}

	Matrix(size_t n, std::vector<T> &vec) : A(n, vec) {}

	Matrix(size_t n) : A(n, std::vector<T>(n, 0)) {}

	size_t height() const { return A.size(); }

	size_t width() const { return A[0].size(); }

	inline const std::vector<T> &operator[](int k) const {
		return A[k];
	}

	inline std::vector<T> &operator[](int k) {
		return A[k];
	}

	Matrix &operator+=(const Matrix &B) {
		size_t n = height(), m = width();
		assert(n == B.height() and m == B.width());
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				(*this)[i][j] += B[i][j];
		return *this;
	}

	Matrix &operator-=(const Matrix &B) {
		size_t n = height(), m = width();
		assert(n == B.height() and m == B.width());
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				(*this)[i][j] -= B[i][j];
		return *this;
	}

	Matrix &operator*=(const Matrix &B) {
		size_t n = height(), m = B.width(), p = width();
		assert(p == B.height());
		std::vector<std::vector<T>> C(n, std::vector<T>(m, 0));
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				for(int k = 0; k < p; k++)
					C[i][j] += (*this)[i][k] * B[k][j];
		A.swap(C);
		return *this;
	}

	Matrix &operator^=(long long k) {
		Matrix B = Matrix::I(height());
		while(k > 0) {
			if(k & 1) B *= (*this);
			*this *= *this;
			k >>= 1ll;
		}
		A.swap(B.A);
		return *this;
	}

	bool operator==(const Matrix &B) {
		size_t n = height(), m = width();
		if(n != B.height() or m != B.width()) return false;
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				if((*this)[i][j] != B[i][j]) return false;
		return true;
	}

	Matrix operator+(const Matrix &B) const {
		return (Matrix(*this) += B);
	}

	Matrix operator-(const Matrix &B) const {
		return (Matrix(*this) -= B);
	}

	Matrix operator*(const Matrix &B) const {
		return (Matrix(*this) *= B);
	}

	Matrix operator^(const long long &k) const {
		return (Matrix(*this) ^= k);
	}

	Matrix &operator+=(const T &t) {
		int n = height(), m = width();
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				(*this)[i][j] += t;
		return *this;
	}

	Matrix &operator-=(const T &t) {
		int n = height(), m = width();
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				(*this)[i][j] -= t;
		return *this;
	}

	Matrix &operator*=(const T &t) {
		int n = height(), m = width();
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				(*this)[i][j] *= t;
		return *this;
	}

	Matrix &operator/=(const T &t) {
		int n = height(), m = width();
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				(*this)[i][j] /= t;
		return *this;
	}

	Matrix operator+(const T &t) const {
		return (Matrix(*this) += t);
	}

	Matrix operator-(const T &t) const {
		return (Matrix(*this) -= t);
	}

	Matrix operator*(const T &t) const {
		return (Matrix(*this) *= t);
	}

	Matrix operator/(const T &t) const {
		return (Matrix(*this) /= t);
	}

	friend std::ostream &operator<<(std::ostream &os, Matrix &p) {
		size_t n = p.height(), m = p.width();
		for(int i = 0; i < n; i++) {
			os << '[';
			for(int j = 0; j < m; j++)
				os << p[i][j] << (j == m - 1 ? "]\n" : ",");
		}
		return (os);
	}

	T determinant() {
		Matrix B(*this);
		size_t n = height(), m = width();
		assert(n == m);
		T ret = 1;
		for(int i = 0; i < n; i++) {
			int idx = -1;
			for(int j = i; j < n; j++)
				if(B[j][i] != 0) idx = j;
			if(idx == -1) return 0;
			if(i != idx) {
				ret *= -1;
				swap(B[i], B[idx]);
			}
			ret *= B[i][i];
			T vv = B[i][i];
			for(int j = 0; j < n; j++) B[i][j] /= vv;
			for(int j = i + 1; j < n; j++) {
				T a = B[j][i];
				for(int k = 0; k < n; k++) {
					B[j][k] -= B[i][k] * a;
				}
			}
		}
		return ret;
	}
};
#pragma endregion

#include "testlib.h"
using mint = atcoder::modint1000000007;
int n, k, l;
int main() {
    registerValidation();
    n = inf.readInt(1,100);
    inf.readSpace();
    k = inf.readInt(1,100000);
    inf.readSpace();
    l = inf.readInt(1,n);
    inf.readEoln();
    inf.readEof();
	Matrix<mint> mat(1, n), mul(n, n);
	mat[0][0] = 1;
	for(int i = 0; i < n; i++)
		for(int j = 1; j <= l; j++)
			mul[i][(i + j) % n] = 1;
	mat *= mul ^ k;
	for(int i = 0; i < n; i++)
		cout << mat[0][i].val() << '\n';
	return 0;
}
0