Latar Belakang

Saya ingin membeli sebidang tanah dan membangun rumah saya di atasnya. Rumah saya harus persegi panjang, dan sebesar mungkin; namun, plot yang tersedia memiliki banyak area berbatu yang tidak dapat saya bangun, dan saya mengalami kesulitan untuk memasang rumah potensial di plot tersebut. Saya ingin Anda menulis sebuah program yang menganalisis plot untuk saya.

Masukan dan keluaran

Input Anda adalah array 2D persegi panjang dari bit, dengan ukuran setidaknya 1 × 1, dalam format apa pun yang masuk akal. Array mewakili sebidang tanah; 1s adalah area "baik" di mana saya bisa membangun rumah saya, dan 0s "area berbatu" di mana rumah tidak bisa dibangun.

Output Anda akan menjadi area maksimal dari persegi panjang solid 1s dalam array input. Itu mewakili area rumah terbesar yang bisa saya bangun di atas plot. Perhatikan bahwa jika tidak ada 1input, maka outputnya adalah 0.

Contoh

Pertimbangkan inputnya

101
011
111

S persegi terbesar adalah persegi panjang 12 × 2 di sudut kanan bawah. Ini berarti bahwa output yang benar adalah 4.

Aturan dan penilaian

Anda dapat menulis program atau fungsi lengkap. Hitungan byte terendah menang, dan celah standar tidak diizinkan.

Uji kasus

0
-> 0

1
-> 1

00
00
-> 0

01
10
-> 1

01
11
-> 2

111
010
111
-> 3

101
011
111
-> 4

0111
1110
1100
-> 4

1111111
1110111
1011101
-> 7

111011000
110111100
001111110
011111111
001111110
000111100
000011000
-> 20

000110000
110110010
110111110
110011100
010011111
111111111
111101110
-> 12

Jelly , 21 20 18 17 byte

ṡṂ€€×"
‘×¥\ç"Ụ€FṀ

Cobalah online! atau verifikasi semua kasus uji .

Latar Belakang

Biarkan M menjadi matriks bit seperti

0 0 0 1 1 0 0 0 0
1 1 0 1 1 0 0 1 0
1 1 0 1 1 1 1 1 0
1 1 0 0 1 1 1 0 0
0 1 0 0 1 1 1 1 1
1 1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1 0

Kami mulai dengan menghitung jumlah 1 bit di setiap kolom M , mengatur ulang jumlah setiap kali kami menemukan 0 bit.

Sebagai contoh matriks kita, ini memberi

0 0 0 1 1 0 0 0 0
1 1 0 2 2 0 0 1 0
2 2 0 3 3 1 1 2 0
3 3 0 0 4 2 2 0 0
0 4 0 0 5 3 3 1 1
1 5 1 1 6 4 4 2 2
2 6 2 2 0 5 5 3 0

Selanjutnya, kami menghitung semua daftar yang berdekatan dari setiap baris. Kami mencapai ini dengan menghasilkan semua irisan panjang k , di mana k bervariasi antara 1 dan jumlah entri di setiap baris.

Untuk baris kedua dari belakang, ini memberi

[1], [5], [1], [1], [6], [4], [4], [2], [2]
[1, 5], [5, 1], [1, 1], [1, 6], [6, 4], [4, 4], [4, 2], [2, 2]
[1, 5, 1], [5, 1, 1], [1, 1, 6], [1, 6, 4], [6, 4, 4], [4, 4, 2], [4, 2, 2]
[1, 5, 1, 1], [5, 1, 1, 6], [1, 1, 6, 4], [1, 6, 4, 4], [6, 4, 4, 2], [4, 4, 2, 2]
[1, 5, 1, 1, 6], [5, 1, 1, 6, 4], [1, 1, 6, 4, 4], [1, 6, 4, 4, 2], [6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4], [5, 1, 1, 6, 4, 4], [1, 1, 6, 4, 4, 2], [1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4], [5, 1, 1, 6, 4, 4, 2], [1, 1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4, 2], [5, 1, 1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4, 2, 2]

Selanjutnya, kami memetakan setiap potongan ke produk minimum dan panjangnya. Untuk setiap irisan, ini menghitung luas persegi panjang dari 1 bit dari ketinggian maksimum yang memiliki irisan yang diberikan sebagai baris bawah.

Untuk irisan panjang 3 dari baris kedua dari belakang dari contoh matriks kita, ini memberi

3 3 3 3 12 6 6

Yang tersisa untuk dilakukan adalah mengambil maksimum di semua irisan semua baris.

Sebagai contoh matriks kita, ini memberi 12 .

Bagaimana itu bekerja

‘×¥\ç"Ụ€FṀ  Main link. Argument: M (2D list of bits)

   \        Reduce the columns of M by the link to the left.
  ¥           Combine the two atoms to the left into a dyadic chain.
‘               Increment the left argument.
 ×              Multiply the result with the right argument.
      Ụ€    Grade up each; yield the indices of each row of M, sorted by their
            values. The order is not important here; we just need the indices.
    ç"      Apply the helper link to each element of the result to the left and
            the corresponding element of the result to the right.
        F   Flatten the resulting, nested list.
         Ṁ  Extract the maximum.


ṡṂ€€×"      Helper link. Arguments: R (row), X (indices of R)

ṡ           For each k in X, split R into overlapping slices of length k.
 Ṁ€€        Compute the minimum of each individual slice.
    ×"      Multiply the minima of all slices of length k by k.

MATL, 32 31 27 byte

n:"@:"@1M2$ltntG4$bZ+=a*vX>

Ini menggunakan pendekatan berbasis konvolusi 2D yang brutal. Semua ukuran persegi panjang yang mungkin dibuat dan dipadukan dengan medan. Hasil maksimum dari semua konvolusi adalah area persegi panjang maksimal.

Ini adalah solusi yang sangat tidak efisien karena untuk menghemat byte, saya membuat kernel untuk semua persegi panjang di antaranya [1, 1] dan [numel(input) numel(input)]bukannya benar-benar menentukan jumlah baris / kolom dalam input untuk menentukan rentang dimensi persegi panjang yang tepat.

Terima kasih kepada @Luis karena menyarankan penggunaan Mdan menghilangkan]] .

Cobalah secara Online!

Penjelasan

        % Implicitly grab input as a 2D numeric array
n       % Compute the number of elements in the input (over estimation of max kernel size)
:       % Create array 1:n
"       % For each value
  @     % Current loop index
  :     % Create an array from 1:(current_index)
  "     % For each of these values   
    @   % Push the current index onto the stack
    1M  % Grab the input to the previous function call (the outer index)
    2$l % Create an array of 1's whose dimensions are specified by top two stack elements
    tn  % Duplicate this array and compute number of elements
    t   % Duplicate this number
    G   % Explicitly grab input
    4$b % Bubble up the 4th element from the stack (the kernel)
    Z+  % Perform 2D convolution of this kernel and the input
    =a  % Determine if any convolution result (in each column) is equal to the area of the kernel.
        % This yields a row vector
    *   % Multiply the logical result by the area
    v   % Vertically concatenate all results (forces the row vectors above to be column vectors)
    X>  % Compute the maximum yielding the largest area
        % Implicitly display the result.

Julia, 83 60 57 53 byte

!M=M⊆1?sum(M):maximum(t->!rotr90(M,t)[2:end,:],0:3)

Cobalah online!Kasing uji terakhir melebihi batas waktu TIO, tetapi saya telah memverifikasi secara lokal.

Bagaimana itu bekerja

Pertama ,! memeriksa apakah argumen matriksnya M seluruhnya terdiri dari 1 's.

• Jika ya ,! mengembalikan jumlah entri M , yang sama dengan luasnya.

• Jika tidak ,! melakukan hal berikut:

  1. Putar M dengan 0 ° , 90 ° , 180 ° dan 270 ° searah jarum jam.

  2. Hapus baris pertama dari masing-masing empat rotasi, efektif menghilangkan salah satu dari baris, baris bawah, kolom paling kiri dan kolom paling kanan dari M .

  3. Sebut sendiri secara rekursif pada setiap submatrices.

  4. Kembalikan nilai pengembalian maksimum dari panggilan rekursif.

JavaScript (ES6), 97 byte

a=>a.map((b,i)=>a.slice(i).map((c,j)=>c.map((d,k)=>(n=(b[k]&=d)&&n+j+1)>r?r=n:0,n=0),c=[]),r=0)|r

Ternyata sedikit twiddling masih menang. Menerima array array integer. Tidak Disatukan:

function rect(array) {
    var max = 0;
    for (var i = 0; i < array.length; i++) {
        var bits = array[i];
        for (var j = 0; i + j < array.length;) {
            var row = array[i + j];
            j++;
            var size = 0;
            for (var k = 0; k < row.length; k++) {
                if (!row[k]) bits[k] = 0;
                size = ones[k] ? size + j : 0;
                if (size > max) max = size;
            }
        }
    }
    return max;
}

Array diiris oleh baris sesuai jawaban lainnya, sehingga setiap rentang baris yang mungkin dilingkarkan. Diberikan berbagai baris, langkah selanjutnya adalah mengukur persegi panjang yang tersedia. Ini dicapai dengan ANDing baris bersama-sama sedikit demi sedikit; hasilnya adalah daftar bit yang ditetapkan di seluruh jajaran baris. Kemudian tetap menemukan panjang maksimal bit yang ditetapkan di baris dan kalikan dengan tinggi rentang. Tes dicuri tanpa malu-malu dari @ ed65:

f=
a=>a.map((b,i)=>a.slice(i).map((c,j)=>c.map((d,k)=>(n=(b[k]&=d)&&n+j+1)>r?r=n:0,n=0),c=[]),r=0)|r

// test cases as strings, converted to 2d arrays
result.textContent = [
  ['0', 0],
  ['1', 1], 
  ['00 00', 0],
  ['01 10', 1],
  ['01 11', 2],
  ['111 010 111', 3],
  ['101 011 111', 4],
  ['0111 1110 1100', 4],
  ['1111111 1110111 1011101', 7],
  ['111011000 110111100 001111110 011111111 001111110 000111100 000011000', 20],
  ['000110000 110110010 110111110 110011100 010011111 111111111 111101110', 12]
].map(t => t[0].replace(/ /g, '\n') + '\n' + t[1] + '\n' + f(t[0].split` `.map(r => [...r]))).join`\n\n`

<pre id=result></pre>

Python 2.7, 93 91 89 81 79 byte

f=lambda M,t=1:max(f(M[1:]),f(zip(*M)[::-1],t+1))if`t/3`in`M`else`M`.count(`t`)

Input adalah daftar tupel. Verifikasi kasing yang lebih kecil di sini dan kasing yang lebih besar di sini .

Tanpa memoisasi, dua uji kasus terakhir melebihi batas waktu Ideone, karena mereka memerlukan, resp., 1.530.831.935 dan 2.848.806.121 panggilan ke f , yang membutuhkan 39 dan 72 menit pada mesin saya.

Algoritma

Untuk matriks M yang diberikan , ide umum adalah untuk mengulangi semua submatrices M dengan menghapus baris atas dan memutar seperempat putaran berlawanan arah jarum jam, melacak ukuran submatrians yang ditemui yang seluruhnya terdiri dari 1 bit.

Bermain golf implementasi rekursif langsung dari ide di atas mengarah ke fungsi f (M) yang melakukan hal berikut.

1. Jika M tidak mengandung 0 bit, kembalikan jumlahnya 1 bit.

2. Jika kita sudah memutar M dua kali dan tidak mengandung 1 bit, kembalikan 0 .

3. Jika kita sudah memutar M lima kali, kembalikan 0 .

4. Secara rekursif panggil f pada M tanpa baris atasnya.

5. Secara rekursif panggilan f pada M diputar seperempat putaran berlawanan arah jarum jam.

6. Kembalikan nilai pengembalian maksimum dari panggilan rekursif.

Kode

Dalam implementasi, kami menggunakan argumen fungsi tambahan t yang default ke 1 untuk melacak berapa kali kami telah memutar matriks khusus ini. Ini memungkinkan langkah kondensasi 1 ke 3 menjadi satu langkah dengan menguji ​`t/3`in`M`​dan mengembalikan ​`M`.count(`t`)​jika tes gagal.

1. Jika t = 1 , kami belum memutar submatrix khusus ini sebelumnya di cabang ini.

   t / 3 = 0 , jadi ​`t/3`in`M`​akan mengembalikan True jika representasi string M berisi karakter 0 .

   Jika tidak, kita kembali ​`M`.count(`t`)​, berapa kali karakter 1 muncul dalam representasi string M .

   Perhatikan bahwa matriks tanpa 0 bit hanya dapat terjadi jika t = 1 , karena kita tidak berulang dalam kasus ini.

2. Jika 3 ≤ t ≤ 5 , kami sebelumnya telah memutar submatrix khusus ini setidaknya dua kali di cabang ini.

   t / 3 = 1 , jadi ​`t/3`in`M`​akan mengembalikan True jika representasi string M berisi karakter 1 .

   Jika tidak, kita kembali 0 dihitung sebagai ​`M`.count(`t`)​, jumlah kali string representasi dari t (yaitu, karakter 3 , 4 atau 5 ) muncul di representasi string M .

3. Jika t = 6 , kami sebelumnya telah memutar submatrix khusus ini lima kali di cabang ini.

   t / 3 = 2 , jadi ​`t/3`in`M`​akan mengembalikan False , karena representasi string M tidak mengandung karakter 2 .

   Kami kembali 0 dihitung sebagai ​`M`.count(`t`)​, berapa kali karakter 6 muncul dalam representasi string M .

Jika f belum kembali, langkah selanjutnya dijalankan.

4. f(M[1:])memanggil f pada M tanpa baris atasnya. Karena t tidak ditentukan, defaultnya adalah 1 , menandakan bahwa ini adalah pertama kalinya f menjumpai submatrix khusus ini di cabang ini.

5. f(zip(*M)[::-1],t+1)panggilan f pada M diputar seperempat putaran berlawanan arah jarum jam, menambah t untuk melacak waktu kita memutar submatrix khusus ini di cabang ini.

   Kuartal gilirannya diperoleh dengan zipping deretan M dengan satu sama lain, kembali tupel dari unsur-unsur yang sesuai dari M baris 's, dengan demikian transposing M , kemudian membalikkan urutan baris (yaitu, menempatkan baris atas di bagian bawah dan sebaliknya ).

6. Akhirnya maxmengembalikan nilai pengembalian maksimum dari panggilan rekursif.

JavaScript (ES6), 154 176

Sunting mencoba mempersingkat sedikit, tetapi tidak dapat bersaing dengan solusi @ Neil

Coba setiap kotak yang mungkin, kembalikan ukuran maksimal. Mungkin algoritma yang sama dari jawaban Matl, hanya 6 kali lebih lama.
Input sebagai array bilangan bulat 2d

g=>g.map((r,i)=>r.map((x,j)=>v=s(r,j,(_,l)=>s(g,i,(_,k)=>!s(g,k,r=>s(r,l,x=>!x,l+j+1),k+i+1)))&(t=-~i*-~j)>v?t:v),s=(a,i,l,j)=>a.slice(i,j).some(l),v=0)|v

Kurang golf

Ini adalah algoritma asli, versi golf menyalahgunakan banyak fungsi array traversing untuk loop

g=>{
  v = 0
  for(i = h = g.length; i; i--)
    for(j = w = g[0].length; j; j--)
    {
      p = true
      for(k=0; p && k <= h-i; k++)
        for(l=0; p && l <= w-j; j++)
          p = g.slice(k, k+i).some(r=>r.slice(l, l+j).some(x=>!x));
      if (!p && i*j<v)
        v = i*j
    }
  return v
}

Uji

f=g=>g.map((r,i)=>r.map((x,j)=>v=s(r,j,(_,l)=>s(g,i,(_,k)=>!s(g,k,r=>s(r,l,x=>!x,l+j+1),k+i+1)))&(t=-~i*-~j)>v?t:v),s=(a,i,l,j)=>a.slice(i,j).some(l),v=0)|v

console.log=(...x)=>O.textContent+=x+'\n'

// test cases as strings, converted to 2d arrays
;[
  ['0',0],['1',1],['00 00',0],['01 10',1],['01 11',2],
  ['111 010 111',3],['101 011 111',4],
  ['0111 1110 1100',4],['1111111 1110111 1011101',7],
  ['111011000 110111100 001111110 011111111 001111110 000111100 000011000',20],
  ['000110000 110110010 110111110 110011100 010011111 111111111 111101110',12]
].forEach(t=>{
  var k=t[1]
  var p=t[0].split` `.map(r=>[...r].map(x=>+x))
  var r=f(p)
  console.log((r==k?'OK':'KO')+' '+r+(r==k?'':' expected '+k)+'\n'+p.join`\n`+'\n')
  })

<pre id=O></pre>

APL (Dyalog Extended) , 27 23 20 byte

-3 byte oleh Adám dan ngn

{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}

Cobalah online!

{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}    Monadic function taking an argument ⍵:
                 ⍳⍴⍵     Indices: e.g. for a 3x7 array
                                       (1 1) (1 2) ...  (1 7)
                                       (2 1) (2 2)  ... (2 7)
                                       (3 1) (3 2)  ... (3 7)
    (×/×⍵⍷⍨⍴∘1)         Helper fn: Takes ⍵ and x (e.g. (2 2))
            ⍴∘1             Make an array of 1s of shape x. Call it a.
        ⍵⍷⍨                 All places where a exists in x
     ×/                      Product of x's dims (size of a)
       ×                 Size of a where a is in ⍵, and 0 elsewhere.
    (×/×⍵⍷⍨⍴∘1)¨        Call the helper function on x and each (¨) index.
                            We now have a nested list containing sizes of blocks in ⍵
                            and many 0s.
   ∊                        Flatten
 ⌈/                        Find the maximum value.

Brachylog , 20 17 15 byte

Terima kasih kepada Kroppeb untuk 2 byte

{s\sc≡ᵛ¹l}ᶠ⌉|hh

Cobalah online!

Penjelasan

{        }ᶠ      Find all possible outputs of the following predicate:
 s                Find a sublist of the array (i.e. remove 0 or more rows from the top
                  and/or bottom)
  \               Transpose the array
   s              Find a sublist again
                  The result is some sub-rectangle of the array
    c             Concatenate all the rows in that rectangle into one list
     ≡ᵛ¹          Verify that all the elements are 1
        l         Get the length (i.e. how many 1's make up the rectangle)
                 Now we have a list of the sizes of all possible 1-rectangles
           ⌉     Take the maximum

            |    If no 1-rectangles could be found:
             hh   Take the head of the head of the array (i.e. the top left element)
                 Since the array contains no 1's in this case, this will give 0

R , 129 122 byte

function(M,D=dim(M),L=`for`){L(i,1:D,L(j,1:D[2],L(r,0:(D-i),L(c,0:(D[2]-j),F<-max(F,i*j*(i*j==sum(M[r+1:i,c+1:j])))))))
F}

Cobalah online!

Pendekatan brute force sederhana dan sederhana.

Kode dan penjelasan yang belum dibuka:

function(M){                       # M is the matrix of 0/1
n = 0                              # n is the biggest rectangle found
R=nrow(M)
C=ncol(M)
for(i in 1:R)                      # for each possible num of rows of the rectangle
  for(j in 1:C)                    # for each possible num of cols of the rectangle
    for(r in 0:(R-i))              # for each possible position offset on the rows
      for(c in 0:(C-j){            # for each possible position offset on the cols

         subM = M[1:i+r,1:j+c]     # sub-set the matrix given the size of rectangle and offsets

         if(sum(subM)==i*j)        # if sub-matrix is full of 1's
            rec = i*j              # (i.e. nrow*ncol == sum of values in sub-matrix)
         else                      # store the rectangle area
            rec = 0                # otherwise store 0

         n = max(n,rec)            # keep the maximum rectangle found
      }
}

Stax , 14 byte

π└ÿ§L▓═J║φ§╦╢9

Jalankan dan debug itu

Matlab 106 byte

x=input('');[n,k]=size(x);r=0;for p=1:n;for m=1:k;r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);end;end;r

Tidak Disatukan:

x=input(''); %//Take input
[n,k]=size(x); %//Determine array size
r=0; %//Variable for output. Initially zero
for p=1:n; %// Loop through the columns
    for m=1:k; %// Loop through the rows
        r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);%//See explanation below
    end;
end;
r %//Display result

Operasi dalam loop dimulai dengan konvolusi 2D conv2()array input dengan p*marray yang. ==p*mmemeriksa apakah array yang dihasilkan mengandung elemen yang sama dengan p*m. Elemen yang sesuai diaktifkan 1, semua elemen lainnya diaktifkan 0. any()mengubah array menjadi vektor. Kolom yang berisi setidaknya satu entri bukan nol dihidupkan 1, jika tidak 0. p*m*()mengalikan vektor dengan p*mmengubah semua 1-s menjadi p*m. [__,r]kurung kotak menggabungkan hasil yang diperoleh dengan area maksimum sebelumnya disimpan di r. Akhirnya, max()temukan nilai maksimum dalam vektor yang dihasilkan.

Matlab (222)(209)

Sebenarnya, solusi ini membuat saya malu karena menjadi dua kali lipat solusi yang sama-bahasa yang sebenarnya tapi ... astaga, saya telah memikirkannya selama 6 jam! dan triknya sedikit berbeda dengan jawaban Dennis dan Neil.

    function p=g(x,a,u,i,j),i=i+~u;j=j+u;p=0;if(j*u+i*~u>=size(a,2-u))return;end,x=circshift(x,[0-u -1+u]),a=(x+a).*~~x.*~~a;for h=0+u:1,p=max([p,reshape(a(1:end-j,1:end-i),1,[]),g(~u*(a*h+x*~h)+u*x,a,h,i,j)]);end

• Fungsi ini disebut sebagai

  y=[1 1 1 0 1 1 0 0 0;
  1 1 0 1 1 1 1 0 0;
  0 0 1 1 1 1 1 1 0;
  0 1 1 1 1 1 1 1 1;
  0 0 1 1 1 1 1 1 0;];
  t=g(y,y,[],0,0,0);t,
  

• Saya bisa menghemat lebih banyak byte jika memperkenalkan panjang matriks dalam dimensi fungsi, meskipun, lebih banyak golf sedang berlangsung.

• Bagaimana prosesnya?

  Algoritma ini menambahkan matriks aktual ke dirinya sendiri bergeser dari itu ke arah kiri, dengan sedikit memutar-mutar (&). dalam setiap tahap, matriks yang dihasilkan ditetapkan sebagai awal dan ditambahkan ke dirinya sendiri bergeser ke atas berulang kali, lalu reload dari awal dengan matriks baru. Semua sub-elemen dari semua matriks yang dihasilkan oleh operasi (original_matrix+shifted_matrix)&shifted_and_original_matrices)ini dimaksimalkan ke output.

contoh:

     1 1 1         1 1 0                      2 2 0                  0 2 0                        0 4 0
 M0= 0 1 1  M0<<1= 1 1 0  M1=(M0+M0<<1)&both= 0 2 0    shift(M1,up)= 2 0 0  M2=(M1+sh(M1,u)&both= 0 0 0  
     1 1 0         1 0 0                      2 0 0                  0 0 0                        0 0 0
                        2 0 0                               4 0 0
 M3=(M0<<1+M0<<2)&both= 2 0 0 , M4=(M3+shift(M3,up))&both=  0 0 0
                        0 0 0                               0 0 0

                3 0 0                             
 M5=(M1+M0<<2)= 0 0 0 , M6=(M5+shift(M5,up))&both=zeros(3,3).
                0 0 0

 Max_of_all_values=Max(0,1,2,3,4)=4

Japt , 30 byte

®åÏ*°X}ÃÕ®£ZãYÄÃm®rm *Zl}Ãc rw

Coba semua uji kasus

Sekitar satu port jawaban Dennis's Jelly. Kasus uji hanyalah array angka 2D, yang dikonversi dari format pertanyaan menggunakan ini .

Penjelasan:

®      Ã                          #For each row:
 å    }                           # Replace each number with this running total:
    °X                            #  Increment the previous total
  Ï*                              #  Multiply it by the current number
        Õ                         #Transpose rows and columns
         ®               Ã        #For each column:
          £    Ã                  # Iterate over the range [0..length) as Y:
           ZãYÄ                   #  Get the subsections of that column with length Y+1
                m®      }         # For each subsection:
                  rm              #  Get the minimum
                     *Zl          #  Multiply it by the length
                          c       #Flatten everything to a single list of possible rectangle sizes
                            rw    #Get the maximum

J , 38 byte

,"0/&(1+i.)/@$>./@,@:((#**/)@,;._3"$)]

Cobalah online!

bagaimana

,"0/&(1 + i.)/@$ >./@,@:((# * */)@,;._3"$) ]
              @$                             NB. pass the shape of
                                             NB. the input (rows, cols)
                                             NB. to...
,"0/&(1 + i.)/                               NB. this verb, which will
    &(1 + i.)/                               NB. will first create 2
                                             NB. lists: 1...num rows
                                             NB. and 1...num cols.
,"0/                                         NB. and then creat a cross
                                             NB. of every possible 
                                             NB. concatenation of the two,
                                             NB. giving us all possible 
                                             NB. rectangle sizes. pass 
                                             NB. that and...
                                           ] NB. the original input
                 >./@,@:((# * */)@,;._3"$)   NB. to this verb, which
                                   ;._3"$    NB. will take every 
                                             NB. possible rectangle of
                                             NB. every size,
                                 @,          NB. flatten it and...
                         (# * */)            NB. multiply the size of
                                             NB. the list by the list's 
                                             NB. product, yielding the
                                             NB. size of the list if it's
                                             NB. all ones, zero otherwise.
                     ,@:                     NB. Flatten all those results
                                             NB. into one big list
                 >./@                        NB. and take the max.