結果

問題 No.3225 2×2行列相似判定 〜easy〜
ユーザー ジュ・ビオレ・グレイス
提出日時 2025-07-23 22:54:52
言語 D
(dmd 2.109.1)
結果
WA  
(最新)
AC  
(最初)
実行時間 -
コード長 4,013 bytes
コンパイル時間 682 ms
コンパイル使用メモリ 89,276 KB
実行使用メモリ 7,716 KB
最終ジャッジ日時 2025-07-27 20:10:25
合計ジャッジ時間 35,512 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge6
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2 WA * 1
other AC * 21 WA * 12
権限があれば一括ダウンロードができます

ソースコード

diff # 

import std.stdio, std.algorithm, std.array, std.conv, std.typecons;

immutable p = 109;
alias F = FiniteField!p;

void main() {
	Matrix A, B;
	{
		auto tmp = readln.split.to!(int[]);
		A[0][0] = F(tmp[0]), A[0][1] = F(tmp[1]);
	}
	{
		auto tmp = readln.split.to!(int[]);
		A[1][0] = F(tmp[0]), A[1][1] = F(tmp[1]);
	}
	{
		auto tmp = readln.split.to!(int[]);
		B[0][0] = F(tmp[0]), B[0][1] = F(tmp[1]);
	}
	{
		auto tmp = readln.split.to!(int[]);
		B[1][0] = F(tmp[0]), B[1][1] = F(tmp[1]);
	}
	
	writeln(is_similar(A, B) ? "Yes" : "No");
}

bool is_similar(Matrix A, Matrix B) {
	// a != 0 case
	foreach (b; 0 .. p) foreach (c; 0 .. p) foreach (d; 0 .. p) if (F(d - b*c) != F(0)) {
		auto det_inv = F(1)/F(d - b*c);
		Matrix P;
		P[0][0] = F(1), P[0][1] = F(b),
		P[1][0] = F(c), P[1][1] = F(d);
		
		Matrix Q;
		Q[0][0] = F(d)*det_inv,  Q[0][1] = -F(c)*det_inv,
		Q[1][0] = -F(b)*det_inv, Q[1][1] = F(1)*det_inv;
		
		auto A2 = multiply(multiply(P, A), Q);
		if (A2[0][0] == B[0][0] && A2[1][0] == B[1][0] && A2[0][1] == B[0][1] && A2[1][1] == B[1][1]) { return true; }
	}
	foreach (b; 0 .. p) foreach (c; 0 .. p) foreach (d; 0 .. p) if (F(b*c) != F(0)) {
		auto det_inv = F(1) / F(b*c);
		Matrix P;
		P[0][0] = F(0), P[0][1] = F(b),
		P[1][0] = F(c), P[1][1] = F(d);
		
		Matrix Q;
		Q[0][0] = F(d) * det_inv,  Q[0][1] = -F(c) * det_inv,
		Q[1][0] = -F(b) * det_inv, Q[1][1] = F(0);
		
		auto A2 = multiply(multiply(P, A), Q);
		if (A2[0][0] == B[0][0] && A2[1][0] == B[1][0] && A2[0][1] == B[0][1] && A2[1][1] == B[1][1]) return true;
	}
	
	return false;
}

alias Matrix = F[2][2];

Matrix multiply(Matrix a, Matrix b) {
	Matrix c;
	c[0][0] = a[0][0]*b[0][0] + a[0][1]*b[1][0], c[0][1] = a[0][0]*b[0][1] + a[0][1]*b[1][1],
	c[1][0] = a[1][0]*b[0][0] + a[1][1]*b[1][0], c[1][1] = a[1][0]*b[0][1] + a[1][1]*b[1][1];
	return c;
}

// the struct of finite fields with p elements
// p must be a prime number
struct FiniteField(long p)
    if (p > 1)
{
    ulong n;
    
    this(long n) {
        if (n < 0) this.n = n%p + p;
        else this.n = n%p;
    }
    
    FiniteField!p opUnary(string op: "+")() {
        return this;
    }
    
    FiniteField!p opUnary(string op: "-")() {
        return FiniteField!p(-n);
    }
    
    FiniteField!p opBinary(string op)(long rhs) {
        static if (op == "^^") {
            if (rhs < 0) { return this.inv() ^^ rhs; }
            
            auto result = FiniteField!p(1);
            auto i = 0, pow_2_i = this; // pow_2_i = n^{2^i}
            rhs %= (p-1);
            while (rhs > 0) {
                 if (rhs % 2 == 1) {
                     result = result * pow_2_i;
                 }
                 rhs >>= 1;
                 i++;
                 pow_2_i = pow_2_i * pow_2_i;
            }
            return result;
        }
        else {
            return this.opBinary!op(FiniteField!p(rhs));
        }
    }
    
    FiniteField!p opBinary(string op)(FiniteField!p rhs) {
        auto result = this;
        
        static if (op == "+") {
            result.n = (result.n + rhs.n) % p;
        }
        else if (op == "-") {
            result.n = (result.n + p - rhs.n) % p;
        }
        else if (op == "*") {
        	result.n = (result.n * rhs.n) % p;
        }
        else if (op == "/") {
            assert (rhs.n != 0);
        	result.n = (result.n * rhs.inv().n) % p;
        }
        else assert(0);
        
        return result;
    }
    
    FiniteField!p opOpAssign(string op)(long rhs) {
        return this = this.opBinary!op(rhs);
    }
    FiniteField!p opOpAssign(string op)(FiniteField!p rhs) {
        return this = this.opBinary!op(rhs);
    }
    
    bool opEquals(FiniteField!p rhs) {
    	return (this.n + p - rhs.n) % p == 0;
    }
    bool opEquals(long rhs) {
    	return (this.n + p - rhs) % p == 0;
    }
    
    FiniteField!p inv() {
        assert (this.n != 0);
        return this ^^ (p-2);
    }
    
    string toString() {
        import std.conv: to;
        return n.to!string;
    }
}
0