pengantar

Ada sebuah desa kecil dengan hanya beberapa rumah dan ladang kosong. Para birokrat lokal ingin membagi desa menjadi banyak sehingga setiap lot mengandung tepat satu rumah, dan batas-batas tanah membentuk garis lurus yang bagus. Tugas Anda adalah menentukan apakah ini mungkin.

Tugas

Input Anda adalah array 2D persegi panjang dari bit; 1 mewakili rumah dan 0 bidang kosong. Ukurannya akan minimal 1 × 1 , dan itu akan mengandung setidaknya satu 1. Anda dapat mengambil input dalam format yang masuk akal (daftar bilangan bulat bersarang, daftar string, string multiline, dll.).

Program Anda harus menentukan apakah array dapat dibagi menjadi sel-sel kisi menggunakan garis lurus dan vertikal lurus sehingga setiap sel kisi mengandung tepat satu 1. Sel-sel kisi mungkin memiliki ukuran dan bentuk yang berbeda, meskipun mereka selalu berbentuk persegi panjang. Garis harus berjalan dari satu tepi array ke tepi yang berlawanan.

Misalnya, berikut ini adalah pembagian array yang valid:

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

sedangkan pembagian berikut ini tidak valid, karena ada sel-sel jaringan tanpa 1s atau lebih dari satu 1:

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

Jika ada pembagian yang valid, Anda harus menampilkan nilai kebenaran, dan jika tidak, nilai palsu.

Aturan dan penilaian

Anda dapat menulis program atau fungsi lengkap. Hitungan byte terendah menang.

Uji kasus

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

Cobalah online.

Saya yakin ini akan menjadi lebih pendek. Ini adalah O (2 ^mn ) , di mana m dan n adalah lebar dan tinggi array, tetapi menyelesaikan dua test case terakhir dalam 45 detik pada laptop saya dengan baterai (i5-5200U dengan kinerja terbatas).

Menghasilkan jumlah solusi.

Penjelasan

Array lima dimensi benar-benar menyenangkan untuk dikerjakan. _^</sarcasm> Anda tidak seharusnya memahami bagaimana ini bekerja bahkan dengan penjelasannya.

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

Jeli , 22 byte

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

Cobalah online!

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

Cobalah online!

Jelly , 20 byte

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

Ini masih merupakan solusi brute-force, tapi ini sedikit lebih cepat daripada jawaban saya yang lain - yang tidak dapat mengatasi dua kasus uji terakhir pada TIO - dan menangani semua kasus uji dalam ~ 4 detik.

Cobalah online!

Bagaimana itu bekerja

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