public class Markov {
    // Verificando a regra do Skeleton (desconsiderando o direcionamento da rede)
    private static int[][] skeletonRule(int[][] matrix, int n) {
        int[][] matrixCopy = matrix;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 1) {
                    matrixCopy[j][i] = 1;
                }
            }
        }

        return matrixCopy;
    }

    // Verificando se duas matrizes são as mesmas (iguais)
    private static boolean isSameMatrix(int[][] A, int[][] B, int n) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (A[i][j] != B[i][j]) {
                    return false;
                }
            }
        }

        return true;
    }

    // Verificando a regra Immorality
    private static boolean isImmoralityRuleValid(int[][] A, int[][] B, int n) {
        boolean immoralityRule = true;

        // Verrificando a "IDA"
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    if (i != j) {
                        boolean hasImmoralityInMatrixA = A[i][k] == 1 && A[j][k] == 1 && A[i][j] == 0;
                        if (hasImmoralityInMatrixA) {
                            boolean hasImmoralityInMatrixB = B[i][k] == 1 && B[j][k] == 1 && B[i][j] == 0;
                            if (!hasImmoralityInMatrixB) {
                                immoralityRule = false;
                            }
                        }
                    }
                }
            }
        }

        // Verificando a "VOLTA"
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    if (i != j) {
                        boolean hasImmoralityInMatrixB = B[i][k] == 1 && B[j][k] == 1 && B[i][j] == 0;
                        if (hasImmoralityInMatrixB) {
                            boolean hasImmoralityInMatrixA = A[i][k] == 1 && A[j][k] == 1 && A[i][j] == 0;
                            if (!hasImmoralityInMatrixA) {
                                immoralityRule = false;
                            }
                        }
                    }
                }
            }
        }

        return immoralityRule;
    }

    // Preenchendo os valores da Matriz A e B com os valores da questão 4
    private static void fillMatrixes(int[][] A, int[][] B) {
        A[0][0] = 0; A[0][1] = 0; A[0][2] = 1; A[0][3] = 1; A[0][4] = 0; A[0][5] = 1; A[0][6] = 0; A[0][7] = 0; A[0][8] = 0;
        A[1][0] = 0; A[1][1] = 0; A[1][2] = 1; A[1][3] = 0; A[1][4] = 1; A[1][5] = 0; A[1][6] = 0; A[1][7] = 0; A[1][8] = 0;
        A[2][0] = 0; A[2][1] = 0; A[2][2] = 0; A[2][3] = 0; A[2][4] = 0; A[2][5] = 0; A[2][6] = 1; A[2][7] = 0; A[2][8] = 0;
        A[3][0] = 0; A[3][1] = 0; A[3][2] = 0; A[3][3] = 0; A[3][4] = 0; A[3][5] = 0; A[3][6] = 0; A[3][7] = 1; A[3][8] = 1;
        A[4][0] = 0; A[4][1] = 0; A[4][2] = 1; A[4][3] = 0; A[4][4] = 0; A[4][5] = 0; A[4][6] = 1; A[4][7] = 0; A[4][8] = 0;
        A[5][0] = 0; A[5][1] = 0; A[5][2] = 0; A[5][3] = 1; A[5][4] = 0; A[5][5] = 0; A[5][6] = 0; A[5][7] = 1; A[5][8] = 0;
        A[6][0] = 0; A[6][1] = 0; A[6][2] = 0; A[6][3] = 0; A[6][4] = 0; A[6][5] = 0; A[6][6] = 0; A[6][7] = 0; A[6][8] = 1;
        A[7][0] = 0; A[7][1] = 0; A[7][2] = 0; A[7][3] = 0; A[7][4] = 0; A[7][5] = 0; A[7][6] = 0; A[7][7] = 0; A[7][8] = 0;
        A[8][0] = 0; A[8][1] = 0; A[8][2] = 0; A[8][3] = 0; A[8][4] = 0; A[8][5] = 0; A[8][6] = 0; A[8][7] = 0; A[8][8] = 0;

        B[0][0] = 0; B[0][1] = 0; B[0][2] = 1; B[0][3] = 1; B[0][4] = 0; B[0][5] = 0; B[0][6] = 0; B[0][7] = 0; B[0][8] = 0;
        B[1][0] = 0; B[1][1] = 0; B[1][2] = 1; B[1][3] = 0; B[1][4] = 0; B[1][5] = 0; B[1][6] = 0; B[1][7] = 0; B[1][8] = 0;
        B[2][0] = 0; B[2][1] = 0; B[2][2] = 0; B[2][3] = 0; B[2][4] = 0; B[2][5] = 0; B[2][6] = 1; B[2][7] = 0; B[2][8] = 0;
        B[3][0] = 0; B[3][1] = 0; B[3][2] = 0; B[3][3] = 0; B[3][4] = 0; B[3][5] = 0; B[3][6] = 0; B[3][7] = 1; B[3][8] = 1;
        B[4][0] = 0; B[4][1] = 1; B[4][2] = 1; B[4][3] = 0; B[4][4] = 0; B[4][5] = 0; B[4][6] = 1; B[4][7] = 0; B[4][8] = 0;
        B[5][0] = 1; B[5][1] = 0; B[5][2] = 0; B[5][3] = 1; B[5][4] = 0; B[5][5] = 0; B[5][6] = 0; B[5][7] = 1; B[5][8] = 0;
        B[6][0] = 0; B[6][1] = 0; B[6][2] = 0; B[6][3] = 0; B[6][4] = 0; B[6][5] = 0; B[6][6] = 0; B[6][7] = 0; B[6][8] = 1;
        B[7][0] = 0; B[7][1] = 0; B[7][2] = 0; B[7][3] = 0; B[7][4] = 0; B[7][5] = 0; B[7][6] = 0; B[7][7] = 0; B[7][8] = 0;
        B[8][0] = 0; B[8][1] = 0; B[8][2] = 0; B[8][3] = 0; B[8][4] = 0; B[8][5] = 0; B[8][6] = 0; B[8][7] = 0; B[8][8] = 0;
    }

    private static boolean verifyMarkov(int[][]A, int [][] B, int n) {
        boolean isMarkovEquivalent;

        skeletonRule(A, n);
        skeletonRule(B, n);

        if (isSameMatrix(A, B, n)) {
            if (isImmoralityRuleValid(A, B, n)) {
                isMarkovEquivalent = true;
            } else {
                isMarkovEquivalent = false;
            }
        } else {
            isMarkovEquivalent = false;
        }

        return isMarkovEquivalent;
    }

    public static void main(String[] args) {
        int n = 9;

        int[][] A = new int[n][n];
        int[][] B = new int[n][n];

        fillMatrixes(A, B);

        System.out.println("The matrixes are equivalent by Markov's rule? " + verifyMarkov(A, B, n));
    }
}