Определить количество способов укладки паркета

import java.math.BigInteger;
 
public class Main {
 
    //Временная, для вычислений
    static BigInteger[][] B = new BigInteger[256][21];
    //Результирующая таблица
    static BigInteger[][] A = new BigInteger[9][21];
 
    //Вычисляет k - ю степень 2
    public static long St2(int k) {
        if (k <= 0) {
            return 1;
        } else {
            return (long) Math.pow(2, k);
        }
    }
 
    //{k,l -номера сечений, pi - количество анализируемых разрядов сечений}
    public static boolean Can(int k, int l, int pi) {
        int i;
        long d;
        boolean b, res;
        res = false;
        b = false;
        for (i = 1; i <= pi; i++) {
            d = St2(i);
            if ((k & d) == 0) //{определяется значение разряда с номером d для сечения k}
            {
                if ((l & d) == 0) {
                    b = !b;
                } else {
                    if (b) {
                        return false;
                    }
                }
            } else if (((l & d) != 0) || b) {
                return false;
            }
        }
        ;
        res = !b;
        return res;
    }
 
    //Основная логика
    public static void Solve() {
        int i, j, k, l;
        long max;
        //Цикл по значению длины комнаты
        for (i = 1; i <= 8; i++) {
            max = St2(i) - 1;
            B[0][0] = BigInteger.ONE;
            //Цикл по значению ширины комнаты
            for (j = 1; j <= 20; j++) {
                //Сечение с номером k
                for (k = 0; k <= max; k++) {
                    //Сечение с номером l
                    for (l = 0; l <= max; l++) //if (Can(k,l,i))
                    {
                        //Проверка совместимости сечений
                        boolean r = Can(k, l, i);
                        if (r) {
                            B[k][j] = B[k][j].add(B[l][j - 1]);
                        }
                    }
                }
                A[i][j] = B[0][j];
            }
        }
    }
 
    public static void main(String[] args) {
        //забиваем нулями таблицы
        for (int m = 0; m <= 20; m++) {
            for (int n = 0; n <= 8; n++) {
                A[n][m] = BigInteger.ZERO;
            }
        }
        for (int m = 0; m <= 20; m++) {
            for (int n = 0; n <= 255; n++) {
                B[n][m] = BigInteger.ZERO;
            }
        }
        //производим расчет
        Solve();
 
        //выводим результаты
        for (int m = 1; m <= 20; m++) {
            for (int n = 1; n <= 8; n++) {
 
                if (n * m % 2 != 0) {
                    String val="*";
                    for(int p=0;p<25;p++)
                        val+=" ";
                    System.out.print(val);
                } else
                if (m == 1 && n % 2 == 0) {
                    String val="1";
                    for(int p=0;p<25;p++)
                        val+=" ";
                    System.out.print(val);
                } else {
                    String val=A[n][m].toString();
                    int v=val.length();
                    for(int p=0;p<26-v;p++)
                        val+=" ";
                    System.out.print(val);
                }
            }
            System.out.println();
        }
    }
}

               //Проверка совместимости сечений
                        boolean r = Can(k, l, i);
                        if (r) {
                            B[k][j] = B[k][j].add(B[l][j - 1]);
                        }

import java.util.ArrayList;
 
public class Parquet{
 
    // метод для сопоставления сечений
    public static boolean acceptCut(int firstCut, int secondCut, int digitsCount){
        int countSecond = 0;// переменная для хранения кол-ва 0 во втором сечении
 
        for(int i=0;i<digitsCount;i++){//цикл по каждому разряду сечения
            int digit = (1<<i);// маска
            if((firstCut&digit)==0) {//если i-ый разряд 1-го сечения =0
                    if ((secondCut & digit) == 0) {//если i-ый разряд 2-го сечения =0
                        countSecond++;
                        } else {//если i-ый разряд 2-го сечения !=0
                            if(countSecond%2!=0) return false;// и кол-во 0 во втором сечении - нечетно
                        }
                } else {//если i-ый разряд 1-го сечения !=0
                    if ((secondCut & digit)!=0) return false; // (countSecond%2!=0)|| и кол-во 0 во втором сечении - нечетно
                }
            }
            if((countSecond%2!=0)) return false;//(countFirst%2!=0)||
        return true;
    }
 
    //метод для нахождения решений для заданных m n
    public static String countValues(int digitsCount, int roomWidth){
    ArrayList resArray = new ArrayList();
    ArrayList resArray2 = new ArrayList();
        String res ="0", res2="";
    long resNumber = 0;
    int maxi = 1<<digitsCount;
    int maxy= 1<<digitsCount;
 
    if(digitsCount*roomWidth%2!=0) return "*";
 
    //устанавливаем первоначальные значания для resArray
    resArray.add(0);
    //используем значения из resArray перебираем подходящие
  outer: for(int i=0; i<roomWidth;i++) {
         for (int x = 0; x < maxy; x++) {//resArray.size()     res.length()  тут использую лист для сохранения подходящих значений
 
             if (i == (roomWidth - 1)) maxi = 1;
 
             for (int z = 0; z < maxi; z++) {
                 if (acceptCut(x, z, digitsCount)) {//(Integer) resArray.get(x) |||| acceptCut(Integer.parseInt(Character.toString(res.charAt(x)))
                     System.out.println(x + "|" + fullString(x, digitsCount)
                      + "|" + z + "|" + fullString(z, digitsCount) );
                    /**
                     resArray2.add(z);
                     res2 += z;
                      */
                     if (i == (roomWidth - 1)) {
                         resNumber++;
                     }
                 }
             }
             if(i==0) continue outer;
         }
         /**
          resArray.clear();
          for (int x = 0; x < resArray2.size(); x++) {
          resArray.add(resArray2.get(x));
          }
          resArray2.clear();
 
 
         res = res2;
         res2 = "";
        */
     }
    return Long.toString(resNumber);
    }
 
 
 
    public static void main(String[] args) {
     // System.out.println(fullString(3,4));
        /**
        for(int i = 1; i<=20; i++) {
            System.out.println(countValues(i, 2) + "|" + countValues(2, i) + "|");
        }
*/
     // System.out.println(countValues(3,2));
        System.out.println(acceptCut(2,0,3));
        System.out.println(acceptCut(0,2,3));
    }
}