結果

問題 No.567 コンプリート
コンテスト
ユーザー rogi52
提出日時 2022-10-17 19:28:16
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 29 ms / 2,000 ms
コード長 5,294 bytes
コンパイル時間 2,046 ms
コンパイル使用メモリ 203,032 KB
最終ジャッジ日時 2025-02-08 07:40:59
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 4
other AC * 12
権限があれば一括ダウンロードができます

ソースコード

diff # 

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

template < class T >
struct vec : public vector< T > {
    vec() : vector< T >() {}
    vec(int n, T e = 0) : vector< T >(n, e) {}
    vec(initializer_list< T > v) : vector< T >(v) {}
    int size() const { return vector< T >::size(); }
    vec& operator+=(const vec& rhs) {
        assert(size() == rhs.size());
        rep(i,size()) (*this)[i] += rhs[i];
        return *this;
    }
    vec& operator-=(const vec& rhs) {
        assert(size() == rhs.size());
        rep(i,size()) (*this)[i] -= rhs[i];
        return *this;
    }
    vec& operator*=(T x) {
        rep(i,size()) (*this)[i] *= x;
        return *this;
    }
    vec& operator/=(T x) {
        x = T(1) / x;
        rep(i,size()) (*this)[i] *= x;
        return *this;
    }
    vec operator+(const vec& rhs) const { return vec(*this) += rhs; }
    vec operator-(const vec& rhs) const { return vec(*this) -= rhs; }
    vec operator*(T x) const { return vec(*this) *= x; }
    vec operator/(T x) const { return vec(*this) /= x; }
    bool operator==(const vec& rhs) const {
        rep(i,size()) if((*this)[i] != rhs[i]) return false;
        return true;
    }
};

template < class T >
T dot(const vec< T >& a, const vec< T >& b) {
    assert(a.size() == b.size());
    T res(0);
    rep(i,a.size()) res += a[i] * b[i];
    return res;
}

template < class T >
struct mat : public vec< vec< T > > {
    mat(int h, int w, T e = 0) : vec< vec< T > >(h, vec< T >(w, e)) {}
    mat(initializer_list< initializer_list< T > > m) : vec< vec< T > >(m.size()) {
        auto it = m.begin();
        for(int i = 0; it != m.end(); i++, it++) (*this)[i] = vec< T >(*it);
    }
    int size() const { return vec< vec< T > >::size(); }
    mat operator*(const mat &rhs) const {
        int N = (*this).size(), M = (*this)[0].size(), K = rhs[0].size();
        assert((*this)[0].size() == rhs.size());
        mat res(N, K);
        rep(k,M)rep(i,N)rep(j,K) res[i][j] += (*this)[i][k] * rhs[k][j];
        return res;
    }
    mat& operator*=(const mat &rhs) { return *this = (*this) * rhs; }
    vec< T > operator*(const vec< T >& rhs) const {
        assert((*this)[0].size() == rhs.size());
        vec< T > res(size());
        rep(i,size()) res[i] = dot((*this)[i], rhs);
        return res;
    }
    vec< T >& operator[](int i) { return vec< vec< T > >::operator[](i); }
    const vec< T >& operator[](int i) const { return vec< vec< T > >::operator[](i); }
    mat& operator/=(T x) { rep(i,size()) (*this)[i] /= x; return *this; }
    mat operator/(T x) const { return (*this) /= x; }
    bool operator==(const mat& rhs) const {
        rep(i,size()) if((*this)[i] != rhs[i]) return false;
        return true;
    }
};

template < class T >
struct msq : public mat< T > {
    msq(int n, T e = 0) : mat< T >(n, n, e) {}
    msq(initializer_list< initializer_list< T > > m) : mat< T >(m) {}
    msq unit() const {
        msq I((*this).size());
        rep(i,(*this).size()) I[i][i] = T(1);
        return I;
    }
    msq pow(ll n) const {
        msq res = unit(), A = (*this);
        while(n > 0) {
            if(n & 1) res *= A;
            A *= A;
            n >>= 1;
        }
        return res;
    }
    T det() const {
        msq A = *this;
        T res = 1;
        rep(i,A.size()) {
            if(A[i][i] == T(0)) {
                for(int j = i + 1; j < A.size(); j++) if(A[j][i] != T(0)) {
                    for(int k = i; k < A.size(); k++) swap(A[i][k], A[j][k]);
                    res *= T(-1);
                    break;
                }
            }
            if(A[i][i] == T(0)) return T(0);
            res *= A[i][i];
            const T x = T(1) / A[i][i];
            for(int k = i; k < A.size(); k++) A[i][k] *= x;
            for(int j = i + 1; j < A.size(); j++) {
                const T x = A[j][i];
                for(int k = i; k < A.size(); k++) A[j][k] -= A[i][k] * x;
            }
        }
        return res;
    }
    msq inv() const {
        msq A = *this, B = unit();
        rep(i,A.size()) {
            if(A[i][i] == T(0)) {
                for(int j = i + 1; j < A.size(); j++) if(A[j][i] != T(0)) {
                    for(int k = i; k < A.size(); k++) swap(A[i][k], A[j][k]);
                    for(int k = 0; k < A.size(); k++) swap(B[i][k], B[j][k]);
                    break;
                }
            }
            if(A[i][i] == T(0)) throw "this matrix is not regular.";
            const T x = T(1) / A[i][i];
            for(int k = i; k < A.size(); k++) A[i][k] *= x;
            for(int k = 0; k < A.size(); k++) B[i][k] *= x;
            for(int j = 0; j < A.size(); j++) if(i != j) {
                const T x = A[j][i];
                for(int k = i; k < A.size(); k++) A[j][k] -= A[i][k] * x;
                for(int k = 0; k < A.size(); k++) B[j][k] -= B[i][k] * x;
            }
        }
        return B;
    }
};

int main(){
    cin.tie(0);
    ios::sync_with_stdio(0);

    using ld = long double;
    int n; cin >> n;
    msq<ld> A(1 << 6, 0);
    rep(S,1<<6)rep(i,6) A[S][S | (1 << i)] += 1.0 / 6.0;
    mat<ld> x(1, 1 << 6, 0);
    x[0][0] = 1;
    cout << fixed << setprecision(20) << (x * A.pow(n))[0][(1 << 6) - 1] << "\n";
}
0