結果

問題 No.2443 特殊線形群の標準表現
コンテスト
ユーザー 👑 p-adic
提出日時 2023-08-07 16:01:22
言語 C++17(gcc12)
(gcc 12.3.0 + boost 1.87.0)
結果
AC  
実行時間 129 ms / 3,000 ms
コード長 7,520 bytes
コンパイル時間 2,709 ms
コンパイル使用メモリ 222,148 KB
最終ジャッジ日時 2025-02-16 00:00:43
ジャッジサーバーID
（参考情報） 		judge2 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 21
権限があれば一括ダウンロードができます

ソースコード

diff # 

#ifdef DEBUG
  #define _GLIBCXX_DEBUG
  #define UNTIE ios_base::sync_with_stdio( false ); cin.tie( nullptr ); signal( SIGABRT , &AlertAbort )
  #define DEXPR( LL , BOUND , VALUE , DEBUG_VALUE ) CEXPR( LL , BOUND , DEBUG_VALUE )
  #define CERR( MESSAGE ) cerr << MESSAGE << endl;
  #define COUT( ANSWER ) cout << ANSWER << endl
  #define ASSERT( A , MIN , MAX ) CERR( "ASSERTチェック： " << ( MIN ) << ( ( MIN ) <= A ? "<=" : ">" ) << A << ( A <= ( MAX ) ? "<=" : ">" ) << ( MAX ) ); assert( ( MIN ) <= A && A <= ( MAX ) )
#else
  #pragma GCC optimize ( "O3" )
  #pragma GCC optimize( "unroll-loops" )
  #pragma GCC target ( "sse4.2,fma,avx2,popcnt,lzcnt,bmi2" )
  #define UNTIE ios_base::sync_with_stdio( false ); cin.tie( nullptr )
  #define DEXPR( LL , BOUND , VALUE , DEBUG_VALUE ) CEXPR( LL , BOUND , VALUE )
  #define CERR( MESSAGE ) 
  #define COUT( ANSWER ) cout << ANSWER << "\n"
  #define ASSERT( A , MIN , MAX ) assert( ( MIN ) <= A && A <= ( MAX ) )
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAIN main
#define TYPE_OF( VAR ) decay_t<decltype( VAR )>
#define CEXPR( LL , BOUND , VALUE ) constexpr LL BOUND = VALUE
#define CIN( LL , A ) LL A; cin >> A
#define CIN_ASSERT( A , MIN , MAX ) TYPE_OF( MAX ) A; SET_ASSERT( A , MIN , MAX )
#define FOR( VAR , INITIAL , FINAL_PLUS_ONE ) for( TYPE_OF( FINAL_PLUS_ONE ) VAR = INITIAL ; VAR < FINAL_PLUS_ONE ; VAR ++ )
#define FOREQ( VAR , INITIAL , FINAL ) for( TYPE_OF( FINAL ) VAR = INITIAL ; VAR <= FINAL ; VAR ++ )
#define REPEAT( HOW_MANY_TIMES ) FOR( VARIABLE_FOR_REPEAT_ ## HOW_MANY_TIMES , 0 , HOW_MANY_TIMES )
#define QUIT return 0
#define SET_ASSERT( A , MIN , MAX ) cin >> A; ASSERT( A , MIN , MAX )

#ifdef DEBUG
  inline void AlertAbort( int n ) { CERR( "abort関数が呼ばれました。assertマクロのメッセージが出力されていない場合はオーバーフローの有無を確認をしてください。" ); }
#endif

template <typename T> inline T Residue( const T& a , const T& p ){ return a >= 0 ? a % p : p - 1 - ( ( - ( a + 1 ) ) % p ); }

// 入力の範囲内で要件
// (1) (T,m_T:T^2->T,i_T:T->T)が群である。
// が成り立つ場合のみサポート。（単位元は引数に渡さなくてよい）
template <typename T , T m_T(const T&,const T&) , T i_T(const T&) , int size_max>
class CumulativeProd_Body
{

protected:
  int m_size;
  T m_a[size_max];
  T m_a_reverse[size_max];

public:
  inline CumulativeProd_Body( const int& size );
  // iからへのpathがi=v_0->...->v_k=jの時m_a[v_0]...m_a[v_k]を
  // Prodや逆順のProdに関して計算する。
  inline T PathProd( const int& i , const int& j );

private:
  virtual int Parent( const int& i ) = 0;
  virtual int LCA( const int& i , const int& j ) = 0;

};


// 通常の配列上の累積積。
// テンプレート引数に単位元e_T:1->Tも渡す。
template <typename T , T m_T(const T&,const T&) , const T& e_T() , T i_T(const T&) , int size_max>
class CumulativeProd :
  public CumulativeProd_Body<T,m_T,i_T,size_max>
{

 public:
  inline CumulativeProd( const T ( &a )[size_max] , const int& size );

  // 0 <= iかつi-1 <= j < m_sizeの場合のみサポート。
  // m_a[i]...m_a[j]をm_Tに関して計算する。
  inline T RightProd( const int& i , const int& j );
  // m_a[j]...m_a[i]をm_Tに関して計算する。
  inline T LeftProd( const int& i , const int& j );

private:
  inline int Parent( const int& i );
  inline int LCA( const int& i , const int& j );

};


template <typename T , T m_T(const T&,const T&) , T i_T(const T&) , int size_max> inline CumulativeProd_Body<T,m_T,i_T,size_max>::CumulativeProd_Body( const int& size ) : m_size( size ) , m_a() , m_a_reverse() { assert( size <= size_max ); }

template <typename T , T m_T(const T&,const T&) , const T& e_T() , T i_T(const T&) , int size_max> inline CumulativeProd<T,m_T,e_T,i_T,size_max>::CumulativeProd( const T ( &a )[size_max] , const int& size ) : CumulativeProd_Body<T,m_T,i_T,size_max>( size )
{

  using base = CumulativeProd_Body<T,m_T,i_T,size_max>;
  T temp , temp_reverse;
  base::m_a[0] = base::m_a_reverse[0] = temp = temp_reverse = a[0];

  for( int i = 1 ; i < size ; i++ ){

    base::m_a[i] = temp = m_T( temp , a[i] );
    base::m_a_reverse[i] = temp_reverse = m_T( a[i] , temp_reverse );

  }

}

template <typename T , T m_T(const T&,const T&) , T i_T(const T&) , int size_max> inline  T CumulativeProd_Body<T,m_T,i_T,size_max>::PathProd( const int& i , const int& j ) { const int k = LCA( i , j ); return m_T( m_T( m_a_reverse[i] , i_T( m_a_reverse[k] ) ) , k == 0 ? m_a[j] : m_T( i_T( m_a[Parent( k ) ] ) , m_a[j] )); }


template <typename T , T m_T(const T&,const T&) , const T& e_T() , T i_T(const T&) , int size_max> inline T CumulativeProd<T,m_T,e_T,i_T,size_max>::RightProd( const int& i , const int& j )
{
  
  assert( i - 1 <= j );
  using base = CumulativeProd_Body<T,m_T,i_T,size_max>;
  return i <= j ? i == 0 ? base::m_a[j] : m_T( i_T( base::m_a[i-1] ) , base::m_a[j] ) : e_T();

}

template <typename T , T m_T(const T&,const T&) , const T& e_T() , T i_T(const T&) , int size_max> inline T CumulativeProd<T,m_T,e_T,i_T,size_max>::LeftProd( const int& i , const int& j )
{
  
  assert( i - 1 <= j );
  using base = CumulativeProd_Body<T,m_T,i_T,size_max>;
  return i <= j ? i == 0 ? base::m_a_reverse[j] : m_T( base::m_a_reverse[j] , i_T( base::m_a_reverse[i - 1] ) ) : e_T();

}

template <typename T , T m_T(const T&,const T&) , const T& e_T() , T i_T(const T&) , int size_max> inline int CumulativeProd<T,m_T,e_T,i_T,size_max>::Parent( const int& i ) { return i - 1; }


template <typename T , T m_T(const T&,const T&) , const T& e_T() , T i_T(const T&) , int size_max> inline int CumulativeProd<T,m_T,e_T,i_T,size_max>::LCA( const int& i , const int& j ) { return min( i , j ); }

#define OO first.first
#define OI first.second
#define IO second.first
#define II second.second

ll B;
using Matrix = pair<pair<ll,ll>,pair<ll,ll> >;
inline Matrix m( const Matrix& M , const Matrix& N )
{
  return
    {
      { ( M.OO * N.OO + M.OI * N.IO ) % B , ( M.OO * N.OI + M.OI * N.II ) % B } ,
	{ ( M.IO * N.OO + M.II * N.IO ) % B , ( M.IO * N.OI + M.II * N.II ) % B }
    };
}
inline const Matrix& e() { static const Matrix one{ { 1 , 0 } , { 0 , 1 } }; return one; }
inline Matrix i( const Matrix& M ) { return { { M.II , -M.OI } , { -M.IO , M.OO } }; }

int MAIN()
{
  UNTIE;
  DEXPR( int , bound_N , 100000 , 100 ); // 0が5個
  CIN_ASSERT( N , 1 , bound_N );
  CEXPR( ll , bound_ABx , 1000000000 ); // 0が9個
  SET_ASSERT( B , 1 , bound_ABx );
  DEXPR( int , bound_Q , 100000 , 100 ); // 0が5個
  CIN_ASSERT( Q , 1 , bound_Q );
  Matrix temp = e();
  Matrix A[bound_N + 1] = { temp };
  FOREQ( n , 1 , N ){
    CIN_ASSERT( AOO , -bound_ABx , bound_ABx );
    CIN_ASSERT( AOI , -bound_ABx , bound_ABx );
    CIN_ASSERT( AIO , -bound_ABx , bound_ABx );
    CIN_ASSERT( AII , -bound_ABx , bound_ABx );
    assert( AOO * AII - AOI * AIO == 1 );
    A[n] = { { AOO , AOI } , { AIO , AII } };
  }
  CumulativeProd<Matrix,m,e,i,bound_N+1> cp{ A , N + 1 };
  REPEAT( Q ){
    CIN_ASSERT( Lq , 0 , N );
    CIN_ASSERT( Rq , Lq , N );
    CIN_ASSERT( x , -bound_ABx , bound_ABx );
    CIN_ASSERT( y , -bound_ABx , bound_ABx );
    Matrix temp = Lq < Rq ? cp.PathProd( Rq , Lq + 1 ) : A[0];
    // Matrix temp = cp.LeftProd( Lq + 1 , Rq );
    ll z = Residue( temp.OO * x + temp.OI * y , B );
    ll w = Residue( temp.IO * x + temp.II * y , B );
    COUT( z << " " << w );
  }
  QUIT;
}
0