#1111000 (C++23) No.3226 2×2行列累乗

• 問題: No.3226 2×2行列累乗
• ユーザー: Taiki0715
• 提出日時: 2025-08-08 21:46:57
• 言語: C++23 (gcc 13.3.0 + boost 1.87.0)
• 結果: AC
• 実行時間: 2 ms / 2,000 ms
• コード長: 62,018 bytes
• コンパイル時間: 7,100 ms
• コンパイル使用メモリ: 427,056 KB
• 実行使用メモリ: 7,720 KB
• 最終ジャッジ日時: 2025-08-08 21:47:05
• 合計ジャッジ時間: 8,077 ms
• ジャッジサーバーID （参考情報）: judge1 / judge3

ファイルパターン	結果
sample	AC * 3
other	AC * 27

ソースコード

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ull=unsigned long long;
using P=pair<ll,ll>;
template<typename T>using minque=priority_queue<T,vector<T>,greater<T>>;
template<typename T>bool chmax(T &a,const T &b){return (a<b?(a=b,true):false);}
template<typename T>bool chmin(T &a,const T &b){return (a>b?(a=b,true):false);}
template<typename T1,typename T2>istream &operator>>(istream &is,pair<T1,T2>&p){is>>p.first>>p.second;return is;}
template<typename T1,typename T2,typename T3>istream &operator>>(istream &is,tuple<T1,T2,T3>&a){is>>std::get<0>(a)>>std::get<1>(a)>>std::get<2>(a);return is;}
template<typename T,size_t n>istream &operator>>(istream &is,array<T,n>&a){for(auto&i:a)is>>i;return is;}
template<typename T>istream &operator>>(istream &is,vector<T> &a){for(auto &i:a)is>>i;return is;}
template<typename T1,typename T2>void operator++(pair<T1,T2>&a,int n){a.first++,a.second++;}
template<typename T1,typename T2>void operator--(pair<T1,T2>&a,int n){a.first--,a.second--;}
template<typename T>void operator++(vector<T>&a,int n){for(auto &i:a)i++;}
template<typename T>void operator--(vector<T>&a,int n){for(auto &i:a)i--;}
#define overload3(_1,_2,_3,name,...) name
#define rep1(i,n) for(int i=0;i<(int)(n);i++)
#define rep2(i,l,r) for(int i=(int)(l);i<(int)(r);i++)
#define rep(...) overload3(__VA_ARGS__,rep2,rep1)(__VA_ARGS__)
#define reps(i,l,r) rep2(i,l,r)
#define all(x) x.begin(),x.end()
#define pcnt(x) __builtin_popcountll(x)
#define fin(x) return cout<<(x)<<'\n',static_cast<void>(0)
#define yn(x) cout<<((x)?"Yes\n":"No\n")
#define uniq(x) sort(all(x)),x.erase(unique(all(x)),x.end())
template<typename T>
inline int fkey(vector<T>&z,T key){return lower_bound(z.begin(),z.end(),key)-z.begin();}
ll myceil(ll a,ll b){return (a+b-1)/b;}
template<typename T,size_t n,size_t id=0>
auto vec(const int (&d)[n],const T &init=T()){
  if constexpr (id<n)return vector(d[id],vec<T,n,id+1>(d,init));
  else return init;
}
#ifdef LOCAL
#include<debug.h>
#define SWITCH(a,b) (a)
#else
#define debug(...) static_cast<void>(0)
#define debugg(...) static_cast<void>(0)
#define SWITCH(a,b) (b)
template<typename T1,typename T2>ostream &operator<<(ostream &os,const pair<T1,T2>&p){os<<p.first<<' '<<p.second;return os;}
#endif
struct Timer{
  clock_t start;
  Timer(){
    start=clock();
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout<<fixed<<setprecision(16);
  }
  inline double now(){return (double)(clock()-start)/1000;}
  #ifdef LOCAL
  ~Timer(){
    cerr<<"time:";
    cerr<<now();
    cerr<<"ms\n";
  }
  #endif
}timer;
void SOLVE();
int main(){
  int testcase=1;
  //cin>>testcase;
  for(int i=0;i<testcase;i++){
    SOLVE();
  }
}
#include<concepts>
template<typename T,int N,int M=N>
struct ConstantMatrix{
private:
  std::array<std::array<T,M>,N>dat;
public:
  ConstantMatrix(){
    dat.fill([](){std::array<T,M>res;res.fill(T());return res;}());
  }
  static ConstantMatrix E(){
    static_assert(N==M);
    ConstantMatrix res;
    for(int i=0;i<N;i++)res[i][i]=T(1);
    return res;
  }
  inline  ConstantMatrix &operator+=(const ConstantMatrix&rhs){
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)(*this)[i][j]+=rhs[i][j];
    return *this;
  }
  inline ConstantMatrix &operator-=(const ConstantMatrix&rhs){
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)(*this)[i][j]-=rhs[i][j];
    return *this;
  }
  inline ConstantMatrix &operator*=(const ConstantMatrix&rhs){
    static_assert(N==M);
    ConstantMatrix res;
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)for(int k=0;k<M;k++)res[i][k]+=(*this)[i][j]*rhs[j][k];
    (*this)=std::move(res);
    return *this;
  }
  friend ConstantMatrix operator+(const ConstantMatrix&lhs,const ConstantMatrix&rhs){return ConstantMatrix(lhs)+=rhs;}
  friend ConstantMatrix operator-(const ConstantMatrix&lhs,const ConstantMatrix&rhs){return ConstantMatrix(lhs)-=rhs;}
  template<int K>friend ConstantMatrix<T,N,K> operator*(const ConstantMatrix&lhs,const ConstantMatrix<T,M,K>&rhs){
    ConstantMatrix<T,N,K>res;
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)for(int k=0;k<K;k++)res[i][k]+=lhs[i][j]*rhs[j][k];
    return res;
  }
  std::array<T,M> &operator[](int i){return dat[i];}
  const std::array<T,M> &operator[](int i)const{return dat[i];}
  friend bool operator==(const ConstantMatrix&lhs,const ConstantMatrix&rhs){
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)if(lhs[i][j]!=rhs[i][j])return false;
    return true;
  }
  friend bool operator!=(const ConstantMatrix&lhs,const ConstantMatrix&rhs){
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)if(lhs[i][j]!=rhs[i][j])return true;
    return false;
  }
  T det()const{
    static_assert(N==M);
    T res=1;
    ConstantMatrix mat(*this);
    for(int i=0;i<M;i++){
      int idx=-1;
      for(int j=i;j<N;j++)if(mat[j][i]!=T()){
        idx=j;
        break;
      }
      if(idx==-1)return T();
      if(i!=idx)std::swap(mat[i],mat[idx]),res=-res;
      res*=mat[i][i];
      T inv_ii=mat[i][i].inv();
      for(int j=i+1;j<M;j++)mat[i][j]*=inv_ii;
      for(int j=i+1;j<N;j++){
        T coef=-mat[j][i];
        for(int k=i+1;k<M;k++)mat[j][k]+=coef*mat[i][k];
      }
    }
    return res;
  }
  ConstantMatrix inv()const{
    static_assert(N==M);
    ConstantMatrix res=E(),mat=(*this);
    for(int i=0;i<N;i++){
      int id=-1;
      for(int j=i;j<N;j++)if(mat[j][i]!=T()){
        id=j;
        break;
      }
      if(id==-1)return ConstantMatrix();
      if(i!=id){
        std::swap(mat[i],mat[id]);
        std::swap(res[i],res[id]);
      }
      T inv=mat[i][i].inv();
      for(int j=0;j<N;j++)if(i!=j){
        T x=mat[j][i];
        for(int k=0;k<N;k++){
          mat[j][k]-=mat[i][k]*x;
          res[j][k]-=res[i][k]*x;
        }
      }
    }
    return res;
  }
  template<std::integral U>
  ConstantMatrix pow(U k)const{
    static_assert(N==M);
    ConstantMatrix res=ConstantMatrix::E(),a(*this);
    while(k){
      if(k&1)res*=a;
      a*=a;
      k>>=1;
    }
    return res;
  }
  std::vector<std::vector<T>>to_vector()const{
    std::vector<std::vector<T>>res(N,std::vector<T>(M));
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)res[i][j]=dat[i][j];
    return res;
  }
  friend std::istream &operator>>(std::istream&is,ConstantMatrix&rhs){
    for(int i=0;i<N;i++)for(int j=0;j<M;j++)is>>rhs[i][j];
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os,const ConstantMatrix&rhs){
    for(int i=0;i<N;i++){
      for(int j=0;j<M;j++)os<<rhs[i][j]<<" \n"[j+1==M];
    }
    return os;
  }
};
#include<type_traits>
#include<optional>
template<typename T>
constexpr std::enable_if_t<std::numeric_limits<T>::digits<=32,int>msb(T n){return n==0?-1:31-__builtin_clz(n);}
template<typename T>
constexpr std::enable_if_t<(std::numeric_limits<T>::digits>32),int>msb(T n){return n==0?-1:63-__builtin_clzll(n);}

template<typename T>
constexpr std::enable_if_t<std::numeric_limits<T>::digits<=32,int>lsb(T n){return n==0?-1:__builtin_ctz(n);}
template<typename T>
constexpr std::enable_if_t<(std::numeric_limits<T>::digits>32),int>lsb(T n){return n==0?-1:__builtin_ctzll(n);}

template<typename T>
constexpr std::enable_if_t<std::is_integral_v<T>,T>floor_pow2(T n){return n==0?0:T(1)<<msb(n);}

template<typename T>
constexpr std::enable_if_t<std::is_integral_v<T>,T>ceil_pow2(T n){return n<=1?1:T(1)<<(msb(n-1)+1);}

template<std::integral T>
constexpr T safe_div(T a,T b){return a/b-(a%b&&(a^b)<0);}
template<std::integral T>
constexpr T safe_ceil(T a,T b){return a/b+(a%b&&(a^b)>0);}
constexpr unsigned long long binary_gcd(unsigned long long a,unsigned long long b){
  if(a==0||b==0||a==b)return a<b?b:a;
  int n=lsb(a),m=lsb(b);
  while(a!=b){
    if(a>b)a=(a-b)>>lsb(a-b);
    else b=(b-a)>>lsb(b-a);
  }
  return a<<(n<m?n:m);
}
namespace base64_decode_impl{
constexpr int ctoi(char c){
  if('A'<=c&&c<='Z')return c-'A';
  else if('a'<=c&&c<='z')return c-'a'+26;
  else if('0'<=c&&c<='9')return c-'0'+52;
  else if(c=='+')return 62;
  else if(c=='/')return 63;
  else return -1;
}
template<int N>
constexpr std::array<bool,N>bin_decode(const char*c){
  std::array<bool,N>res;
  for(int i=0,j=0;i<N;i+=6,j++){
    int now=ctoi(c[j]);
    for(int k=0;k<6;k++)if(i+k<N)res[i+k]=now>>k&1;
  }
  return res;
}
template<typename T,int N,int bit_width>
constexpr std::array<T,N>base64_decode(const char*c){
  static_assert(std::is_integral_v<T>);
  std::array<T,N>res;
  std::array<bool,N*bit_width>bin=bin_decode<N*bit_width>(c);
  for(int i=0;i<N;i++){
    res[i]=0;
    for(int j=0;j<bit_width;j++){
      if(bin[i*bit_width+j]){
        res[i]|=T(1)<<j;
      }
    }
  }
  return res;
}
}
using base64_decode_impl::base64_decode;
#ifdef LOCAL
#include<primality_test_table.hpp>
#else
namespace isprime_impl{
const std::array<uint16_t,16384>base_table1=base64_decode<uint16_t,16384,16>("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");
}
#endif
namespace isprime_impl{
using u16=uint16_t;
using u32=uint32_t;
using u64=uint64_t;
using u128=__uint128_t;
constexpr u16 base_table2[8]={15,135,13,60,15,117,65,29};
constexpr u64 reduce(u128 v,u64 r,u64 mod){
  return (v+u128(u64(v)*-r)*mod)>>64;
}
constexpr bool isprime(unsigned long long n){
  if(n<64)return 2891462833508853932ll>>n&1;
  if(n%2==0)return false;
  int k=lsb(n-1);
  u64 d=(n-1)>>k;
  u64 r=n;
  for(int i=0;i<5;i++)r*=2-n*r;
  u64 r2=-u128(n)%n;
  u64 p1=reduce(r2,r,n),m1=reduce(u128(n-1)*r2,r,n);
  if(p1>=n)p1-=n;
  if(m1>=n)m1-=n;
  u64 base1=2,base2=7,base3=61;
  if(n>=u64(1)<<32){
    base2=base_table1[u32(n*0xAD625B89)>>18];
    base3=base_table2[base2>>13];
  }
  base1=reduce(u128(base1)*r2,r,n);
  base2=reduce(u128(base2)*r2,r,n);
  base3=reduce(u128(base3)*r2,r,n);
  u64 x1=p1,x2=p1,x3=p1;
  while(d>0){
    if(d&1){
      x1=reduce(u128(x1)*base1,r,n);
      x2=reduce(u128(x2)*base2,r,n);
      x3=reduce(u128(x3)*base3,r,n);
    }
    base1=reduce(u128(base1)*base1,r,n);
    base2=reduce(u128(base2)*base2,r,n);
    base3=reduce(u128(base3)*base3,r,n);
    d>>=1;
  }
  if(x1>=n)x1-=n;
  if(x2>=n)x2-=n;
  if(x3>=n)x3-=n;
  bool f1=x1==p1||x1==m1;
  bool f2=x2==p1||x2==m1;
  bool f3=x3==p1||x3==m1;
  while(--k){
    x1=reduce(u128(x1)*x1,r,n);
    x2=reduce(u128(x2)*x2,r,n);
    x3=reduce(u128(x3)*x3,r,n);
    if(x1>=n)x1-=n;
    if(x2>=n)x2-=n;
    if(x3>=n)x3-=n;
    f1|=x1==m1;
    f2|=x2==m1;
    f3|=x3==m1;
  }
  return f1&&f2&&f3;
}
}
using isprime_impl::isprime;
std::vector<unsigned long long>factorize(unsigned long long n)noexcept{
  std::vector<unsigned long long>ret;
  auto div=[](unsigned long long x)noexcept->unsigned long long {
    unsigned long long r=x;
    for(int i=0;i<5;i++)r*=2-r*x;
    unsigned long long r2=-__uint128_t(x)%x;
    auto redc=[&r,&x](__uint128_t t)->unsigned long long {
      t=(t+__uint128_t((unsigned long long)t*-r)*x)>>64;
      return t>=x?t-x:t;
    };
    unsigned long long a=0,b=0;
    const unsigned long long one=redc(r2);
    unsigned long long e=one;
    int m=1ll<<((63-__builtin_clzll(x))>>3);
    while(true){
      unsigned long long ca=a,cb=b;
      unsigned long long sk=one;
      for(int i=0;i<m;i++){
        a=redc(__uint128_t(a)*a+e);
        b=redc(__uint128_t(b)*b+e);
        b=redc(__uint128_t(b)*b+e);
        unsigned long long c=redc(a),d=redc(b);
        sk=redc(__uint128_t(sk)*(c>d?c-d:d-c));
      }
      unsigned long long g=binary_gcd(redc(sk),x);
      if(g>1){
        if(g<x)return g;
        for(int i=0;i<m;i++){
          ca=redc(__uint128_t(ca)*ca+e);
          cb=redc(__uint128_t(cb)*cb+e);
          cb=redc(__uint128_t(cb)*cb+e);
          unsigned long long c=redc(ca),d=redc(cb);
          unsigned long long cg=binary_gcd(c>d?c-d:d-c,x);
          if(cg>1){
            if(cg<x)return cg;
            else{
              e+=one;
              a=b=0;
              break;
            }
          }
        }
      }
    }
  };
  static unsigned long long st[64];
  int p=0;
  while(!(n&1)){
    n>>=1;
    ret.push_back(2);
  }
  if(n==1)return ret;
  st[p++]=n;
  while(p){
    unsigned long long now=st[--p];
    if(isprime(now)){
      ret.push_back(now);
      continue;
    }
    unsigned long long d=div(now);
    st[p++]=d;
    now/=d;
    if(now!=1)st[p++]=now;
  }
  return ret;
}
constexpr int carmichael_constexpr(int n){
  if(n==998244353)return 998244352;
  if(n==1000000007)return 1000000006;
  if(n<=1)return n;
  int res=1;
  int t=0;
  while(n%2==0){
    n/=2;
    t++;
  }
  if(t==2)res=2;
  else if(t>=3)res=1<<(t-2);
  for(int i=3;i*i<=n;i++)if(n%i==0){
    int c=0;
    while(n%i==0){
      n/=i;
      c++;
    }
    int prod=i-1;
    for(int j=0;j<c-1;j++)prod*=i;
    res=std::lcm(res,prod);
  }
  if(n!=1)res=std::lcm(res,n-1);
  return res;
}
template<typename T>
std::enable_if_t<std::is_integral_v<T>,T>carmichael(T n){
  auto f=factorize(n);
  std::sort(f.begin(),f.end());
  T res=1;
  for(int l=0,r=0;l<f.size();l=r){
    while(r<f.size()&&f[l]==f[r])r++;
    if(f[l]==2){
      if(r-l==2)res=2;
      else if(r-l>=3)res=T(1)<<(r-l-2);
    }
    else{
      T prod=f[l]-1;
      for(int i=0;i<r-l-1;i++)prod*=f[l];
      res=std::lcm(res,prod);
    }
  }
  return res;
}
struct BarrettReduction{
private:
  using i64=long long;
  using u64=unsigned long long;
  using u32=unsigned int;
  using u128=__uint128_t;
  u32 m;
  u64 im;
public:
  BarrettReduction():m(0),im(0){}
  BarrettReduction(u32 n):m(n),im(u64(-1)/n+1){}
  inline i64 quo(u64 x)const{
    if(m==1)return x;
    u64 y=u64((u128(x)*im)>>64);
    u32 r=x-y*m;
    return m<=r?y-1:y;
  }
  inline u32 rem(u64 x)const{
    if(m==1)return 0;
    u64 y=u64((u128(x)*im)>>64);
    u32 r=x-y*m;
    return m<=r?r+m:r;
  }
  inline std::pair<u64,u32>quo_rem(u64 x)const{
    if(m==0)return std::make_pair(x,0);
    u64 y=u64((u128(x)*im)>>64);
    u32 r=x-y*m;
    return m<=r?std::make_pair(y-1,r+m):std::make_pair(y,r);
  }
  inline u32 pow(u32 a,u64 p)const{
    u32 res=m!=1;
    while(p){
      if(p&1)res=rem(u64(res)*a);
      a=rem(u64(a)*a);
      p>>=1;
    }
    return res;
  }
};
template<int id>
struct arbitrary_modint{
private:
  using uint=unsigned int;
  using mint=arbitrary_modint;
  uint v;
  static uint umod;
  static int car;
  static BarrettReduction br;
  mint sqrt_impl()const{
    if(this->val()<=1)return *this;
    if(umod%8==1){
      mint b=2;
      while(b.pow((umod-1)/2).val()==1)b++;
      int m2=umod-1,e=0;
      while(m2%2==0)m2>>=1,e++;
      mint x=this->pow((m2-1)/2);
      mint y=(*this)*x*x;
      x*=*this;
      mint z=b.pow(m2);
      while(y.val()!=1){
        int j=0;
        mint t=y;
        while(t.val()!=1)t*=t,j++;
        z=z.pow(1<<(e-j-1));
        x*=z;
        z*=z;
        y*=z;e=j;
      }
      return x;
    }
    else if(umod%8==5){
      mint ret=this->pow((umod+3)/8);
      if((ret*ret).val()==this->val())return ret;
      else return ret*mint::raw(2).pow((umod-1)/4);
    }
    else{
      return this->pow((umod+1)/4);
    }
  }
public:
  using value_type=uint;
  arbitrary_modint():v(0){}
  template<typename T,std::enable_if_t<std::is_unsigned_v<T>,std::nullptr_t> =nullptr>
  arbitrary_modint(T x):v(br.rem(x)){}
  template<typename T,std::enable_if_t<std::is_signed_v<T>,std::nullptr_t> =nullptr>
  arbitrary_modint(T x){
    x%=(int)umod;
    if(x<0)x+=(int)umod;
    v=x;
  }
  static void set_mod(int m_){
    assert(1<=m_);
    umod=m_;
    car=carmichael(umod);
    br=BarrettReduction(umod);
  }
  static int mod(){return umod;}
  static mint raw(int x){
    mint res;
    res.v=x;
    return res;
  }
  inline uint val()const{return v;}
  inline mint &operator+=(const mint &b){
    this->v+=b.v;
    if(this->v>=umod)this->v-=umod;
    return *this;
  }
  inline mint &operator-=(const mint &b){
    this->v-=b.v;
    if(this->v>=umod)this->v+=umod;
    return *this;
  }
  inline mint &operator*=(const mint &b){
    this->v=br.rem((unsigned long long)this->v*b.v);
    return *this;
  }
  inline mint &operator/=(const mint &b){
    *this*=b.inv();
    return *this;
  }
  inline mint operator+()const{return *this;}
  inline mint operator-()const{return mint()-*this;}
  friend inline mint operator+(const mint &a,const mint &b){return mint(a)+=b;}
  friend inline mint operator-(const mint &a,const mint &b){return mint(a)-=b;}
  friend inline mint operator*(const mint &a,const mint &b){return mint(a)*=b;}
  friend inline mint operator/(const mint &a,const mint &b){return mint(a)/=b;}
  friend inline bool operator==(const mint &a,const mint &b){return a.val()==b.val();}
  friend inline bool operator!=(const mint &a,const mint &b){return !(a==b);}
  friend inline bool operator<(const mint&a,const mint&b){return a.val()<b.val();}
  friend inline bool operator>(const mint&a,const mint&b){return a.val()>b.val();}
  friend inline bool operator<=(const mint&a,const mint&b){return a.val()<=b.val();}
  friend inline bool operator>=(const mint&a,const mint&b){return a.val()>=b.val();}
  inline mint operator++(int){
    mint ret=*this;
    *this+=mint::raw(1);
    return ret;
  }
  inline mint operator--(int){
    mint ret=*this;
    *this-=mint::raw(1);
    return ret;
  }
  mint pow(long long n)const{
    mint ret=mint::raw(1),a(*this);
    while(n){
      if(n&1)ret*=a;
      a*=a;
      n>>=1;
    }
    return ret;
  }
  inline mint inv()const{
    return pow(car-1);
  }
  std::optional<mint>sqrt()const{
    if(this->val()<=1||this->pow((umod-1)/2)==1)return std::make_optional(this->sqrt_impl());
    else return std::nullopt;
  }
  static unsigned int order(){return car;}
  friend std::istream &operator>>(std::istream &is,mint &b){
    long long a;
    is>>a;
    b=mint(a);
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os,const mint &b){
    os<<b.val();
    return os;
  }
};
template<int id>typename arbitrary_modint<id>::uint arbitrary_modint<id>::umod=2;
template<int id>int arbitrary_modint<id>::car=1;
template<int id>BarrettReduction arbitrary_modint<id>::br;
template<int id>
struct std::hash<arbitrary_modint<id>>{
  std::size_t operator()(arbitrary_modint<id>x)const{
    return std::hash<unsigned int>()(x.val());
  }
};
using mint=arbitrary_modint<2>;
void SOLVE(){
  int a,b,c,d,s,t;
  ll n;
  int k;
  cin>>a>>b>>c>>d>>s>>t>>n>>k;
  mint::set_mod(k);
  ConstantMatrix<mint,2>mat;
  mat[0][0]=a;
  mat[0][1]=b;
  mat[1][0]=c;
  mat[1][1]=d;
  ConstantMatrix<mint,2,1>mat2;
  mat2[0][0]=s;
  mat2[1][0]=t;
  mat2=mat.pow(n)*mat2;
  cout<<mat2[0][0]<<' '<<mat2[1][0]<<endl;
}