소개

집이없고 빈 들판 만있는 작은 마을이 있습니다. 지방 관료들은 마을을 여러 개의 구획으로 나누고 싶어서 각 구획에는 정확히 하나의 집이 포함되어 있으며, 구획의 경계는 멋진 직선 격자를 형성합니다. 당신의 임무는 이것이 가능한지를 결정하는 것입니다.

작업

입력은 사각형의 2D 비트 배열입니다. 1은 집을 나타내고 0은 빈 필드를 나타냅니다. 크기는 1x1 이상 이며 1 이상 을 포함합니다. 적절한 형식 (정수 목록, 문자열 목록, 여러 줄 문자열 등)으로 입력을 취할 수 있습니다.

프로그램은 각각의 격자 셀이 정확히 1을 포함하도록 직선 수평 및 수직선을 사용하여 배열을 격자 셀로 분할 할 수 있는지 여부를 결정해야합니다. 선은 배열의 한쪽 가장자리에서 반대쪽 가장자리까지 이어져야합니다.

예를 들어, 다음은 유효한 배열 분할입니다.

00|0010|01|1
01|0000|00|0
--+----+--+-
00|0000|00|1
01|0010|01|0
--+----+--+-
01|1000|10|1

1 또는 1을 초과하지 않는 그리드 셀이 있으므로 다음 구분은 유효하지 않습니다.

00|0010|01|1
--+----+--+-
01|0000|00|0
00|0000|00|1
01|0010|01|0
--+----+--+-
00|1000|10|1

유효한 눈금이 존재하면 진실한 값을, 그렇지 않으면 거짓 값을 출력해야합니다.

규칙과 득점

전체 프로그램이나 함수를 작성할 수 있습니다. 가장 낮은 바이트 수가 이깁니다.

테스트 사례

[[1]] -> True
[[0,1],[1,0]] -> True
[[1,1],[1,0]] -> False
[[1,0,1],[0,1,0]] -> True
[[1,0],[0,1],[0,1]] -> True
[[1,0,0],[0,0,1],[0,1,1]] -> True
[[1,1,1],[1,1,1],[1,1,1]] -> True
[[1,0,1],[0,1,0],[1,0,0]] -> True
[[1,0,0],[1,0,0],[0,1,1]] -> False
[[0,0,0,0,1],[1,0,0,1,0],[0,0,0,1,0]] -> False
[[0,0,1,0,1],[0,0,0,1,0],[0,0,0,0,0]] -> True
[[1,1,0,0,0],[0,0,0,0,0],[1,0,1,0,0]] -> True
[[1,1,0,1,1],[0,1,0,1,1],[1,0,0,0,0]] -> True
[[0,0,0,0,0,0,0],[0,1,1,1,0,1,0],[0,1,0,0,1,0,0],[0,0,0,0,0,0,1],[0,0,1,0,0,0,1],[1,1,0,1,1,0,0]] -> False
[[1,1,0,0,0,0,0],[1,0,1,1,0,1,0],[0,0,0,0,1,0,0],[0,1,0,1,1,0,0],[1,0,0,0,1,1,0],[0,0,0,0,0,1,0]] -> False
[[0,1,0,1,1,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,0],[1,0,0,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,1]] -> True
[[0,1,0,0,1,0,1],[1,0,0,0,1,0,1],[0,0,1,0,1,0,1],[1,0,0,0,1,1,0],[0,0,0,1,1,1,0],[0,1,0,0,1,0,1]] -> True
[[0,1,0,0,1,0,0,1,0],[0,0,0,0,1,1,0,1,0],[1,1,0,0,1,0,0,0,0],[0,0,1,0,1,0,1,0,0],[0,0,1,0,1,0,1,0,0],[0,1,0,0,0,1,0,0,1],[0,1,0,0,0,0,1,0,0]] -> False
[[1,0,1,0,0,1,1,0,1],[0,1,1,0,0,1,1,0,1],[1,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,1,1],[0,1,1,0,1,0,1,0,1],[1,0,1,0,0,1,1,0,1]] -> True

Pyth, 30 29 26 24 23 바이트

sm.Asmmq1ssbCkds./MC./M

온라인으로 사용해보십시오.

나는 이것이 더 짧아 질 것이라고 확신한다. 이것은 O (2 ^mn )입니다 . 여기서 m 과 n 은 어레이의 너비와 높이이지만 배터리가 장착 된 랩탑에서 45 초만에 마지막 두 테스트 사례를 완료합니다 (제한된 성능의 i5-5200U).

솔루션 수를 출력합니다.

설명

5 차원 배열은 정말 재미 있습니다. _{^{</ sarcasm>}} 귀하는 설명이 있어도 이것이 어떻게 작동하는지 이해하지 않아야합니다.

                    ./M    Find all partitions of each row. Now we have a list of rows,
                           each containing the ways to split the row, each containing
                           the parts of the split (3D).
                   C       Transpose. Now we have a list of ways to split the columns,
                           each containing the rows, each containing the parts of the
                           row (3D).
                ./M        Find all partitions of each row list. Now we have a list of
                           ways to split the columns, each containing the ways to split
                           the rows, each containing the bunch of rows, each containing 
                           the rows in the bunch, each containing the parts of the row
                           (6D).
               s           Combine the ways to split rows & columns into one array (5D).
 m            d            Do the following for each way to split rows & columns (4D):
     m       k                 Do the following for each bunch of rows (3D):
            C                      Transpose the array. We now have a list of column
                                   groups, each containing the row parts (3D).
      m    b                       Do the following for each column group (2D):
          s                            Combine the row parts in the column group. We now
                                       have the list of cells in this row/column group
                                       (1D).
         s                             Sum the cells.
       q1                              Check if the sum is one.
                                   We now have the list of booleans that tell if each
                                   row/column group is valid (1D).
                               We now have the 2D list of booleans that tell if each
                               row/column group in each bunch of rows is valid. (2D)
    s                          Combine the 2D list of booleans to 1D.
  .A                           Check if all values are truthy; if the split is valid.
                           We now have the validity of each split.
s                          Sum the list to get the number of valid solutions.

젤리 , 22 바이트

ŒṖḅ1S€€=1Ȧ€
SŒṖ⁸ṁþÇ€FS

온라인으로 사용해보십시오!

하스켈 , 116 바이트

import Data.List
m(a:b)=[a:e|e<-m b]++[zipWith(+)a d:e|d:e<-m b];m e=[e]
d=(any$any$all$all(==1)).map(m.transpose).m

온라인으로 사용해보십시오!

젤리 , 20 바이트

ŒṖS€€ỊȦ$ÐfZ€µ⁺€Ȧ€€FS

이것은 여전히 ​​무차별 대입 솔루션이지만 TIO의 마지막 두 테스트 사례에 대처할 수없는 다른 답변보다 훨씬 빠르며 모든 테스트 사례를 ~ 4 초 안에 처리합니다.

온라인으로 사용해보십시오!

작동 원리

ŒṖS€€ỊȦ$ÐfZ€µ⁺€Ȧ€€FS  Main link. Argument: M (matrix, array of rows)

ŒṖ                    Compute all partitions, i.e., all groupings of M's rows.
  S€€                 Map sum over all individual groupings, collapsing the grouped
                      rows into a single row.
        Ðf            Filter; keep only those partially collapsed matrices for
                      which the link to the left returns a truthy value.
       $                Group the two links to the left into a monadic chain.
     Ị                    Insignificant; map 0 and 1 to 1, greater integers to 0.
      Ȧ                   All; return 1 iff the matrix contains no zeroes.
          Z€          Zip/transpose all kept matrices,
            µ         Combine all links to the left into a monadic chain.
             ⁺€       Duplicate the chain and map it over the individual results
                      from the first call. We now have all possible combinations
                      of row and column groupings (represented by the corresponding
                      matrices of collapsed rows and columns) that do not have a
                      2 anywhere. However, they still may contain zeroes.
               Ȧ€€    Map the all atom over the matrices, returning 1 only for
                      matrices that consist entirely of ones.
                  FS  Flatten and sum, counting the number of valid divisions.