Giới thiệu

Có một ngôi làng nhỏ không có gì ngoài vài ngôi nhà và những cánh đồng trống trải. Các quan chức địa phương muốn chia làng thành nhiều lô để mỗi lô chứa chính xác một ngôi nhà, và đường viền của các lô tạo thành một mạng lưới đường thẳng đẹp. Nhiệm vụ của bạn là xác định xem điều này là có thể.

Nhiệm vụ

Đầu vào của bạn là một mảng 2D hình chữ nhật của các bit; 1 đại diện cho một ngôi nhà và 0 một trường trống. Kích thước của nó sẽ có ít nhất 1 × 1 và nó sẽ chứa ít nhất một 1. Bạn có thể lấy đầu vào ở bất kỳ định dạng hợp lý nào (danh sách các số nguyên lồng nhau, danh sách các chuỗi, chuỗi nhiều dòng, v.v.).

Chương trình của bạn sẽ xác định xem mảng có thể được chia thành các ô lưới bằng cách sử dụng các đường thẳng và ngang thẳng để mỗi ô lưới chứa chính xác một 1. Các ô lưới có thể có kích thước và hình dạng khác nhau, mặc dù chúng sẽ luôn có hình chữ nhật. Các dòng phải chạy từ một cạnh của mảng đến cạnh đối diện.

Ví dụ, sau đây là một phân chia hợp lệ của một mảng:

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

trong khi cách chia sau không hợp lệ, vì có các ô lưới không có 1 hoặc nhiều hơn 1:

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

Nếu một phân chia hợp lệ tồn tại, bạn sẽ đưa ra một giá trị trung thực và nếu không thì là một giá trị giả.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng.

Các trường hợp thử nghiệm

[[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 byte

sm.Asmmq1ssbCkds./MC./M

Hãy thử trực tuyến.

Tôi chắc chắn rằng điều này sẽ ngắn hơn. Đây là O (2 ^mn ) , trong đó m và n là chiều rộng và chiều cao của mảng, nhưng hoàn thành hai trường hợp thử nghiệm cuối cùng trong 45 giây trên máy tính xách tay của tôi bằng pin (i5-5200U với hiệu suất hạn chế).

Xuất ra số lượng giải pháp.

Giải trình

Mảng năm chiều thực sự thú vị để làm việc với. _{^{</ mỉa mai>}} Bạn không cần phải hiểu cách thức hoạt động của nó ngay cả với lời giải thích.

                    ./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.

Thạch , 22 byte

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

Hãy thử trực tuyến!

Haskell , 116 byte

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

Hãy thử trực tuyến!

Thạch , 20 byte

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

Đây vẫn là một giải pháp vũ phu, nhưng nó nhanh hơn một chút so với câu trả lời khác của tôi - không thể đối phó với hai trường hợp thử nghiệm cuối cùng trên TIO - và xử lý tất cả các trường hợp thử nghiệm trong ~ 4 giây.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ŒṖ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.