package i495;

import java.util.Arrays;

public class I495 {

    public static int getCount(int x, int y, boolean[][] points) {
        int count = 0;
        boolean k = true;
        for (boolean[] b1 : points) {//megnézi, hogy van-e még szabad pont
            for (boolean b2 : b1) {
                k = b2 && k;//akkor lesz igaz a végén, ha a 'b' minden eleme igaz -> minden pont volt -> önálló kombináció
            }
        }
        if (k) {//nincs szabad pont            
            return 1;//mivel count=0, ezért azt nem kell hozzáadni
        }
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (!((x == i || x == 0 && i == 2 || x == 2 && i == 0) && (j == y || j == 0 && y == 2 || y == 0 && j == 2)) && !points[i][j]) {
                    /*Akkor meg át a vonal menet közben egy ponton, ha nagyátló vagy teljes soron/oszlopon átmegy, de a másik 'koordinátája' nem változik (függőleges vagy vízszintes). 
                    Ezek egyesítve: ha a kiindulási és érkezési sor száma azonos, vagy a 0-2 páros (a két vége), és ez teljesül az oszlopra is, akkor a vonal átmegy egy 3. ponton, vagy azonos a kiindulási és érkezési helye. 
                    Mivel ez sem megengedhető, ezért ez nem okoz problémát.
                    Ha ez nem teljesül és az adott pont még nem volt érintve, akkor a pont lehet a következő kiválasztott.
                     */
                    boolean[][] b = new boolean[][]{points[0].clone(), points[1].clone(), points[2].clone()};//így van másolva, mert különben az adott indexen megtalálható tömbök hivatkozsát máásolná
                    b[i][j] = true;
                    count += getCount(i, j, b);//rekurzió
                }
            }
        }
        return count;
    }

    public static void main(String[] args) {
        boolean[][] points = new boolean[3][3];//igaz ha a ponton már ment át vonal
        int count = 0;
        points[0][0] = true;//a kiindulási pont szerepel
        count += 4 * getCount(0, 0, points); //csúcsból indul ki, és minden csúcsból ugyanannyi kombináció van (forgatással egymásba vihetők), és 4 csúcs van, ezért négyszeres az összeg 
        points = new boolean[3][3];
        points[1][0] = true;
        count += 4 * getCount(1, 0, points);//hasonlóan mint az előbb, csak csúcs helyett az oldalak közepére
        points = new boolean[3][3];
        points[1][1] = true;
        count += getCount(1, 1, points);// a középső pontból csak 1 van, ezért csak egyszer van hozzáadva
        //így minden kiindulási helyről megszámoltuk a lehetséges kombinációkat
        System.out.println(count);
    }

}