Atur setiap sel dalam matriks ke 0 jika baris atau kolom itu berisi 0

Diberi matriks NxN dengan 0s dan 1s. Atur setiap baris yang berisi a 0untuk semua 0dan atur setiap kolom yang berisi a 0untuk semua 0.

Sebagai contoh

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

hasil dalam

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

Seorang Insinyur Microsoft mengatakan kepada saya bahwa ada solusi yang tidak melibatkan memori tambahan, hanya dua variabel boolean dan satu pass, jadi saya mencari jawaban itu.

BTW, bayangkan itu adalah matriks bit, oleh karena itu hanya 1s dan 0s yang diizinkan berada dalam matriks.

Ok, jadi saya lelah karena ini jam 3 pagi di sini, tapi saya punya percobaan pertama dengan tepat 2 melewati setiap angka dalam matriks, jadi di O (NxN) dan linear dalam ukuran matriks.

Saya menggunakan kolom pertama dan baris pertama sebagai penanda untuk mengetahui di mana baris / cols hanya dengan 1's. Lalu, ada 2 variabel l dan c yang perlu diingat jika baris / kolom pertama adalah semua 1 juga. Jadi pass pertama mengatur marker dan me-reset sisanya ke 0's.

Lewat kedua menetapkan 1 di tempat baris dan col mana ditandai 1, dan me-reset baris 1 / col tergantung pada l dan c.

Saya sangat ragu bahwa saya dapat dilakukan dalam 1 pass karena kotak pada awalnya tergantung pada kotak pada akhirnya. Mungkin pass kedua saya dapat dibuat lebih efisien ...

import pprint

m = [[1, 0, 1, 1, 0],
     [0, 1, 1, 1, 0],
     [1, 1, 1, 1, 1],
     [1, 0, 1, 1, 1],
     [1, 1, 1, 1, 1]]



N = len(m)

### pass 1

# 1 rst line/column
c = 1
for i in range(N):
    c &= m[i][0]

l = 1
for i in range(1,N):
    l &= m[0][i]


# other line/cols
# use line1, col1 to keep only those with 1
for i in range(1,N):
    for j in range(1,N):
        if m[i][j] == 0:
            m[0][j] = 0
            m[i][0] = 0
        else:
            m[i][j] = 0

### pass 2

# if line1 and col1 are ones: it is 1
for i in range(1,N):
    for j in range(1,N):
        if m[i][0] & m[0][j]:
            m[i][j] = 1

# 1rst row and col: reset if 0
if l == 0:
    for i in range(N):
        m [i][0] = 0

if c == 0:
    for j in range(1,N):
        m [0][j] = 0


pprint.pprint(m)

Ini tidak dapat dilakukan dalam satu pass karena bit tunggal memiliki efek pada bit sebelum dan sesudahnya dalam pemesanan apa pun. TKI Apa pun perintah yang Anda lewati array, Anda mungkin akan menemukan 0 yang berarti Anda harus kembali dan mengubah 1 sebelumnya ke 0.

Memperbarui

Orang-orang tampaknya berpikir bahwa dengan membatasi N pada nilai tetap (katakanlah 8) Anda dapat menyelesaikan ini dengan satu pass. Ya itu a) melewatkan poin dan b) bukan pertanyaan awal. Saya tidak akan memposting pertanyaan tentang pengurutan dan mengharapkan jawaban yang dimulai "dengan asumsi Anda hanya ingin mengurutkan 8 hal ...".

Yang mengatakan, itu adalah pendekatan yang masuk akal jika Anda tahu bahwa N sebenarnya terbatas pada 8. Jawaban saya di atas menjawab pertanyaan awal yang tidak memiliki batasan seperti itu.

Jadi ide saya adalah menggunakan nilai-nilai di baris / kolom terakhir sebagai bendera untuk menunjukkan apakah semua nilai di kolom / baris yang sesuai adalah 1s.

Menggunakan pemindaian Zig Zag melalui seluruh matriks KECUALI baris / kolom terakhir. Di setiap elemen, Anda menetapkan nilai di baris / kolom terakhir ke logika AND dari dirinya sendiri dengan nilai di elemen saat ini. Dengan kata lain, jika Anda menekan 0, baris / kolom terakhir akan diatur ke 0. Jika Anda menjadi 1, nilai di baris / kolom terakhir akan menjadi 1 hanya jika sudah 1. Bagaimanapun mengatur elemen saat ini ke 0.

Setelah selesai, baris / kolom akhir Anda harus memiliki 1s jika kolom / baris terkait diisi dengan 1s.

Lakukan pemindaian linear melalui baris dan kolom terakhir dan cari 1s. Tetapkan 1s dalam elemen yang sesuai dalam tubuh matriks di mana baris terakhir dan kolom keduanya 1s.

Pengkodean akan sulit untuk menghindari kesalahan satu per satu dll, tetapi itu harus bekerja dalam satu pass.

Saya punya solusi di sini, ini berjalan dalam sekali jalan, dan melakukan semua pemrosesan "di tempat" tanpa memori tambahan (simpan untuk menumbuhkan tumpukan).

Ini menggunakan rekursi untuk menunda penulisan nol yang tentu saja akan menghancurkan matriks untuk baris dan cols lainnya:

#include <iostream>

/**
* The idea with my algorithm is to delay the writing of zeros
* till all rows and cols can be processed. I do this using
* recursion:
* 1) Enter Recursive Function:
* 2) Check the row and col of this "corner" for zeros and store the results in bools
* 3) Send recursive function to the next corner
* 4) When the recursive function returns, use the data we stored in step 2
*       to zero the the row and col conditionally
*
* The corners I talk about are just how I ensure I hit all the row's a cols,
* I progress through the matrix from (0,0) to (1,1) to (2,2) and on to (n,n).
*
* For simplicities sake, I use ints instead of individual bits. But I never store
* anything but 0 or 1 so it's still fair ;)
*/

// ================================
// Using globals just to keep function
// call syntax as straight forward as possible
int n = 5;
int m[5][5] = {
                { 1, 0, 1, 1, 0 },
                { 0, 1, 1, 1, 0 },
                { 1, 1, 1, 1, 1 },
                { 1, 0, 1, 1, 1 },
                { 1, 1, 1, 1, 1 }
            };
// ================================

// Just declaring the function prototypes
void processMatrix();
void processCorner( int cornerIndex );
bool checkRow( int rowIndex );
bool checkCol( int colIndex );
void zeroRow( int rowIndex );
void zeroCol( int colIndex );
void printMatrix();

// This function primes the pump
void processMatrix() {
    processCorner( 0 );
}

// Step 1) This is the heart of my recursive algorithm
void processCorner( int cornerIndex ) {
    // Step 2) Do the logic processing here and store the results
    bool rowZero = checkRow( cornerIndex );
    bool colZero = checkCol( cornerIndex );

    // Step 3) Now progress through the matrix
    int nextCorner = cornerIndex + 1;
    if( nextCorner < n )
        processCorner( nextCorner );

    // Step 4) Finially apply the changes determined earlier
    if( colZero )
        zeroCol( cornerIndex );
    if( rowZero )
        zeroRow( cornerIndex );
}

// This function returns whether or not the row contains a zero
bool checkRow( int rowIndex ) {
    bool zero = false;
    for( int i=0; i<n && !zero; ++i ) {
        if( m[ rowIndex ][ i ] == 0 )
            zero = true;
    }
    return zero;
}

// This is just a helper function for zeroing a row
void zeroRow( int rowIndex ) {
    for( int i=0; i<n; ++i ) {
        m[ rowIndex ][ i ] = 0;
    }
}

// This function returns whether or not the col contains a zero
bool checkCol( int colIndex ) {
    bool zero = false;
    for( int i=0; i<n && !zero; ++i ) {
        if( m[ i ][ colIndex ] == 0 )
            zero = true;
    }

    return zero;
}

// This is just a helper function for zeroing a col
void zeroCol( int colIndex ) {
    for( int i=0; i<n; ++i ) {
        m[ i ][ colIndex ] = 0;
    }
}

// Just a helper function for printing our matrix to std::out
void printMatrix() {
    std::cout << std::endl;
    for( int y=0; y<n; ++y ) {
        for( int x=0; x<n; ++x ) {
            std::cout << m[y][x] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

// Execute!
int main() {
    printMatrix();
    processMatrix();
    printMatrix();
}

Saya tidak berpikir itu bisa dilakukan. Saat Anda berada di kotak pertama dan nilainya 1, Anda tidak memiliki cara untuk mengetahui apa nilai kotak lainnya di baris dan kolom yang sama. Jadi, Anda harus memeriksa dan jika ada nol, kembali ke kuadrat pertama dan ubah nilainya menjadi nol. Saya akan merekomendasikan melakukannya dalam dua lintasan - lintasan pertama mengumpulkan informasi tentang baris dan kolom mana yang harus di-nolkan (informasi disimpan dalam sebuah array, jadi kami menggunakan memori tambahan). Lewat kedua mengubah nilai. Saya tahu itu bukan solusi yang Anda cari, tetapi saya pikir itu solusi yang praktis. Batasan yang diberikan oleh Anda membuat masalah tidak dapat dipecahkan.

Saya bisa melakukannya dengan dua variabel integer dan dua lintasan (hingga 32 baris dan kolom ...)

bool matrix[5][5] = 
{ 
    {1, 0, 1, 1, 0},
    {0, 1, 1, 1, 0},
    {1, 1, 1, 1, 1},
    {1, 0, 1, 1, 1},
    {1, 1, 1, 1, 1}
};

int CompleteRows = ~0;
int CompleteCols = ~0;

// Find the first 0
for (int row = 0; row < 5; ++row)
{
    for (int col = 0; col < 5; ++col)
    {
        CompleteRows &= ~(!matrix[row][col] << row);
        CompleteCols &= ~(!matrix[row][col] << col);
    }
}

for (int row = 0; row < 5; ++row)
    for (int col = 0; col < 5; ++col)
        matrix[row][col] = (CompleteRows & (1 << row)) && (CompleteCols & (1 << col));

masalahnya bisa diselesaikan dalam satu pass

menyimpan matriks dalam array i X j.

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

one each pass save the values of i and j for an element which is 0 in arrays a and b
when first row is scanned a= 1 b = 2,5
when second row is scanned a=1,2 b= 1,2,5
when third row is scanned no change
when fourth row is scanned a= 1,2,4 and b= 1,2,5
when fifth row is scanned no change .

sekarang cetak semua nilai sebagai 0 untuk nilai i dan j yang disimpan dalam a dan b sisanya dari nilai tersebut yaitu 1 yaitu (3,3) (3,4) (5,3) dan (5,4)

Solusi lain yang membutuhkan dua lintasan, adalah mengakumulasi AND secara horizontal dan vertikal:

1 0 1 1 0 | 0
0 1 1 1 0 | 0
1 1 1 1 1 | 1
1 0 1 1 1 | 0
1 1 1 1 1 | 1
----------+
0 0 1 1 0    

Saya pikir saya bisa merancang algoritma seperti itu menggunakan bit paritas , kode Hamming atau pemrograman dinamis , mungkin menggunakan dua boolean sebagai angka 2-bit, tapi saya belum berhasil.

Bisakah Anda memeriksa kembali pernyataan masalah dengan insinyur Anda dan beri tahu kami? Jika ada yang memang solusi, aku ingin terus chipping jauh di masalah.

Simpan satu variabel untuk melacak semua baris ANDed bersama.

Jika satu baris adalah -1 (semua 1s), maka buat baris berikutnya sebagai referensi ke variabel itu

Jika satu baris adalah sesuatu tetapi, itu adalah 0. Anda dapat melakukan semuanya dalam satu pass. Kode psuedo:

foreach (my $row) rows {
     $andproduct = $andproduct & $row;
     if($row != -1) {
        zero out the row
     }  else {
        replace row with a reference to andproduct
     }
}

Itu harus melakukannya, dalam sekali lulus - tetapi ada asumsi di sini bahwa N cukup kecil untuk CPU untuk melakukan aritmatika pada satu baris, jika tidak, Anda akan perlu untuk mengulang setiap baris untuk menentukan apakah itu semua 1s atau tidak, saya percaya. Tetapi mengingat Anda bertanya tentang algos dan tidak membatasi perangkat keras saya, saya hanya akan memulai jawaban saya dengan "Bangun CPU yang mendukung aritmatika N-bit ..."

Inilah salah satu contoh bagaimana hal itu dapat dilakukan dalam C. Catatan saya berpendapat bahwa nilai dan arr yang diambil bersama-sama mewakili array, dan p dan numproduct adalah iterator saya dan variabel produk AND digunakan untuk mengimplementasikan masalah. (Saya bisa mengulangi arr dengan pointer aritmatika untuk memvalidasi pekerjaan saya, tetapi sekali sudah cukup!)

int main() {
    int values[] = { -10, 14, -1, -9, -1 }; /* From the problem spec, converted to decimal for my sanity */
    int *arr[5] = { values, values+1, values+2, values+3, values+4 };
    int **p;
    int numproduct = 127;

    for(p = arr; p < arr+5; ++p) {
        numproduct = numproduct & **p;
        if(**p != -1) {
            **p = 0;
        } else {
            *p = &numproduct;
        }
    }

    /* Print our array, this loop is just for show */
    int i;
    for(i = 0; i < 5; ++i) {
        printf("%x\n",*arr[i]);
    }
    return 0;
}

Ini menghasilkan 0, 0, 6, 0, 6, yang merupakan hasil untuk input yang diberikan.

Atau di PHP, jika orang berpikir bahwa permainan tumpukan saya di C curang (saya sarankan Anda tidak melakukannya, karena saya harus dapat menyimpan matriks mana pun yang saya inginkan):

<?php

$values = array(-10, 14, -1, -9, -1);
$numproduct = 127;

for($i = 0; $i < 5; ++$i) {
    $numproduct = $numproduct & $values[$i];
    if($values[$i] != -1) {
        $values[$i] = 0;
    } else {
        $values[$i] = &$numproduct;
    }
}

print_r($values);

Apakah saya melewatkan sesuatu?

Tantangan yang bagus. Solusi ini menggunakan hanya dua boolean yang dibuat di stack, tetapi boolean dibuat beberapa kali di stack karena fungsinya bersifat rekursif.

typedef unsigned short     WORD;
typedef unsigned char      BOOL;
#define true  1
#define false 0
BYTE buffer[5][5] = {
1, 0, 1, 1, 0,
0, 1, 1, 1, 0,
1, 1, 1, 1, 1,
1, 0, 1, 1, 1,
1, 1, 1, 1, 1
};
int scan_to_end(BOOL *h,BOOL *w,WORD N,WORD pos_N)
{
    WORD i;
    for(i=0;i<N;i++)
    {
        if(!buffer[i][pos_N])
            *h=false;
        if(!buffer[pos_N][i])
            *w=false;
    }
    return 0;
}
int set_line(BOOL h,BOOL w,WORD N,WORD pos_N)
{
    WORD i;
    if(!h)
        for(i=0;i<N;i++)
            buffer[i][pos_N] = false;
    if(!w)
        for(i=0;i<N;i++)
            buffer[pos_N][i] = false;
    return 0;
}
int scan(int N,int pos_N)
{
    BOOL h = true;
    BOOL w = true;
    if(pos_N == N)
        return 0;
    // Do single scan
    scan_to_end(&h,&w,N,pos_N);
    // Scan all recursive before changeing data
    scan(N,pos_N+1);
    // Set the result of the scan
    set_line(h,w,N,pos_N);
    return 0;
}
int main(void)
{
    printf("Old matrix\n");
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[0][0],(WORD)buffer[0][1],(WORD)buffer[0][2],(WORD)buffer[0][3],(WORD)buffer[0][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[1][0],(WORD)buffer[1][1],(WORD)buffer[1][2],(WORD)buffer[1][3],(WORD)buffer[1][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[2][0],(WORD)buffer[2][1],(WORD)buffer[2][2],(WORD)buffer[2][3],(WORD)buffer[2][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[3][0],(WORD)buffer[3][1],(WORD)buffer[3][2],(WORD)buffer[3][3],(WORD)buffer[3][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[4][0],(WORD)buffer[4][1],(WORD)buffer[4][2],(WORD)buffer[4][3],(WORD)buffer[4][4]);
    scan(5,0);
    printf("New matrix\n");
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[0][0],(WORD)buffer[0][1],(WORD)buffer[0][2],(WORD)buffer[0][3],(WORD)buffer[0][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[1][0],(WORD)buffer[1][1],(WORD)buffer[1][2],(WORD)buffer[1][3],(WORD)buffer[1][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[2][0],(WORD)buffer[2][1],(WORD)buffer[2][2],(WORD)buffer[2][3],(WORD)buffer[2][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[3][0],(WORD)buffer[3][1],(WORD)buffer[3][2],(WORD)buffer[3][3],(WORD)buffer[3][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[4][0],(WORD)buffer[4][1],(WORD)buffer[4][2],(WORD)buffer[4][3],(WORD)buffer[4][4]);
    system( "pause" );
    return 0;
}

Ini memindai dalam pola seperti:

s,s,s,s,s
s,0,0,0,0
s,0,0,0,0
s,0,0,0,0
s,0,0,0,0

0,s,0,0,0
s,s,s,s,s
0,s,0,0,0
0,s,0,0,0
0,s,0,0,0

dan seterusnya

Dan kemudian mengubah nilai-nilai dalam pola ini setelah kembali pada masing-masing fungsi pemindaian. (Bawah ke atas):

0,0,0,0,c
0,0,0,0,c
0,0,0,0,c
0,0,0,0,c
c,c,c,c,c

0,0,0,c,0
0,0,0,c,0
0,0,0,c,0
c,c,c,c,c
0,0,0,c,0

dan seterusnya

Oke ini solusinya

• hanya menggunakan satu nilai ekstra panjang untuk penyimpanan yang berfungsi.
• tidak menggunakan rekursi.
• satu pass hanya N, bahkan N * N.
• akan bekerja untuk nilai N lainnya tetapi akan membutuhkan #defines baru.

#include <stdio.h>
#define BIT30 (1<<24)
#define COLMASK 0x108421L
#define ROWMASK 0x1fL

unsigned long long STARTGRID = 
((0x10 | 0x0 | 0x4 | 0x2 | 0x0) << 20) |
((0x00 | 0x8 | 0x4 | 0x2 | 0x0) << 15) |
((0x10 | 0x8 | 0x4 | 0x2 | 0x1) << 10) |
((0x10 | 0x0 | 0x4 | 0x2 | 0x1) << 5) |
((0x10 | 0x8 | 0x4 | 0x2 | 0x1) << 0);


void dumpGrid (char* comment, unsigned long long theGrid) {
    char buffer[1000];
    buffer[0]='\0';
    printf ("\n\n%s\n",comment);
    for (int j=1;j<31; j++) {
        if (j%5!=1)
            printf( "%s%s", ((theGrid & BIT30)==BIT30)? "1" : "0",(((j%5)==0)?"\n" : ",") );    
        theGrid = theGrid << 1;
    }
}

int main (int argc, const char * argv[]) {
    unsigned long long rowgrid = STARTGRID;
    unsigned long long colGrid = rowgrid;

    unsigned long long rowmask = ROWMASK;
    unsigned long long colmask = COLMASK;

    dumpGrid("Initial Grid", rowgrid);
    for (int i=0; i<5; i++) {
        if ((rowgrid & rowmask)== rowmask) rowgrid |= rowmask;
        else rowgrid &= ~rowmask;
        if ((colGrid & colmask) == colmask) colmask |= colmask;
        else colGrid &=  ~colmask;
        rowmask <<= 5;
        colmask <<= 1;
    }
    colGrid &= rowgrid;
    dumpGrid("RESULT Grid", colGrid);
    return 0;
    }

Sebenarnya. Jika Anda hanya ingin menjalankan algoritme dan mencetak hasilnya (yaitu tidak mengembalikannya, maka ini dapat dengan mudah dilakukan dalam satu langkah. Masalahnya muncul ketika Anda mencoba memodifikasi array saat Anda menjalankan algoritma.

Inilah solusi saya. Ini hanya melibatkan ANDing nilai baris / kolom untuk elemen givein (i, j) dan mencetaknya.

#include <iostream>
#include "stdlib.h"

void process();

int dim = 5;
bool m[5][5]{{1,0,1,1,1},{0,1,1,0,1},{1,1,1,1,1},{1,1,1,1,1},{0,0,1,1,1}};


int main() {
    process();
    return 0;
}

void process() {
    for(int j = 0; j < dim; j++) {
        for(int i = 0; i < dim; i++) {
            std::cout << (
                          (m[0][j] & m[1][j] & m[2][j] & m[3][j] & m[4][j]) &
                          (m[i][0] & m[i][1] & m[i][2] & m[i][3] & m[i][4])
                          );
        }
        std::cout << std::endl;
    }
}

Saya mencoba menyelesaikan masalah ini dalam C #.

Saya telah menggunakan dua variabel loop (i dan j) selain dari matriks aktual dan n yang mewakili dimensinya

Logika yang saya coba adalah:

1. Hitung DAN untuk baris dan kolom yang terlibat dalam setiap kotak konsentris dari matriks
2. Simpan di sel-sel sudutnya (Saya telah menyimpannya dalam urutan anti-jarum jam)
3. Dua variabel bool digunakan untuk mempertahankan nilai dua sudut saat mengevaluasi kuadrat tertentu.
4. Proses ini akan berakhir ketika loop luar (i) berada di tengah jalan.
5. Mengevaluasi hasil sel lain berdasarkan sel sudut (untuk sisa i). Lewati sel sudut selama proses ini.
6. Ketika saya mencapai n, semua sel akan memiliki hasilnya kecuali untuk sel sudut.
7. Perbarui sel sudut. Ini adalah iterasi tambahan untuk panjang n / 2 selain batasan single pass yang disebutkan dalam masalah.

Kode:

void Evaluate(bool [,] matrix, int n)
{
    bool tempvar1, tempvar2;

    for (var i = 0; i < n; i++)
    {
        tempvar1 = matrix[i, i];
        tempvar2 = matrix[n - i - 1, n - i - 1];

        var j = 0;

        for (j = 0; j < n; j++)
        {
            if ((i < n/2) || (((n % 2) == 1) && (i == n/2) && (j <= i)))
            {
                // store the row and col & results in corner cells of concentric squares
                tempvar1 &= matrix[j, i];
                matrix[i, i] &= matrix[i, j];
                tempvar2 &= matrix[n - j - 1, n - i - 1];
                matrix[n - i - 1, n - i - 1] &= matrix[n - i - 1, n - j - 1];
            }
            else
            {
                // skip corner cells of concentric squares
                if ((j == i) || (j == n - i - 1)) continue;

                // calculate the & values for rest of them
                matrix[i, j] = matrix[i, i] & matrix[n - j - 1, j];
                matrix[n - i - 1, j] = matrix[n - i - 1, n - i - 1] & matrix[n - j - 1, j];

                if ((i == n/2) && ((n % 2) == 1))
                {
                    // if n is odd
                    matrix[i, n - j - 1] = matrix[i, i] & matrix[j, n - j - 1];
                }
            }
        }

        if ((i < n/2) || (((n % 2) == 1) && (i <= n/2)))
        {
            // transfer the values from temp variables to appropriate corner cells of its corresponding square
            matrix[n - i - 1, i] = tempvar1;
            matrix[i, n - i - 1] = tempvar2;
        }
        else if (i == n - 1)
        {
            // update the values of corner cells of each concentric square
            for (j = n/2; j < n; j++)
            {
                tempvar1 = matrix[j, j];
                tempvar2 = matrix[n - j - 1, n - j - 1];

                matrix[j, j] &= matrix[n - j - 1, j];
                matrix[n - j - 1, j] &= tempvar2;

                matrix[n - j - 1, n - j - 1] &= matrix[j, n - j - 1];
                matrix[j, n - j - 1] &= tempvar1;
            }
        }
    }
}

One Pass - Saya telah melewati input hanya sekali tetapi menggunakan array baru dan hanya dua variabel Boolean tambahan.

public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();

        boolean rowDel = false, colDel = false;
        int arr[][] = new int[n][n];
        int res[][] = new int[n][n];
        int i, j;
        for (i = 0; i < n; i++) {

            for (j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
                res[i][j] = arr[i][j];  
            }
        }

        for (i = 0; i < n; i++) {

            for (j = 0; j < n; j++) {
                if (arr[i][j] == 0)
                    colDel = rowDel = true; //See if we have to delete the
                                            //current row and column
                if (rowDel == true){
                    res[i] = new int[n];
                    rowDel = false;
                }
                if(colDel == true){
                    for (int k = 0; k < n; k++) {
                        res[k][j] = 0;
                    }
                    colDel = false;
                }

            }

        }

        for (i = 0; i < n; i++) {

            for (j = 0; j < n; j++) {
                System.out.print(res[i][j]);
            }
            System.out.println();
        }
        sc.close();

    }

Meskipun tidak mungkin mengingat kendala, cara paling efisien ruang untuk melakukannya adalah dengan melintasi matriks dengan cara baris / kolom bergantian yang tumpang tindih, yang akan membuat pola yang mirip dengan meletakkan batu bata dalam mode zig-zag:

-----
|----
||---
|||--
||||-

Dengan menggunakan ini, Anda akan pergi di setiap baris / kolom, seperti yang ditunjukkan, dan jika Anda menemukan 0 setiap saat, atur variabel boolean, dan berjalan kembali baris / kolom itu, atur entri ke 0 saat Anda pergi.

Ini tidak memerlukan memori tambahan, dan hanya akan menggunakan satu variabel boolean. Sayangnya, jika tepi "jauh" diatur ke semua menjadi 0, itu adalah kasus terburuk dan Anda berjalan di seluruh array dua kali.

buat matriks hasil dan atur semua nilai ke 1. pergi melalui matriks data segera setelah 0 ditemui, atur kolom baris matriks hasil ke 0

Pada akhir pass pertama, matriks hasil akan memiliki jawaban yang benar.

Terlihat sangat sederhana. Apakah ada trik yang saya lewatkan? Apakah Anda tidak diizinkan menggunakan set hasil?

EDIT:

Tampak seperti fungsi F #, tetapi itu sedikit curang karena meskipun Anda melakukan satu lintasan, fungsi tersebut dapat bersifat rekursif.

Sepertinya pewawancara sedang mencoba mencari tahu apakah Anda tahu pemrograman fungsional.

Yah, saya datang dengan solusi single-pass, in-place (non-rekursif) menggunakan 4 bools dan 2 loop counter. Saya belum berhasil menguranginya menjadi 2 bools dan 2 int, tapi saya tidak akan terkejut jika itu mungkin. Itu sekitar 3 membaca dan 3 menulis dari setiap sel, dan itu harus O (N ^ 2) yaitu. linear dalam ukuran array.

Butuh waktu beberapa jam untuk memecahkan teka-teki ini - saya tidak mau harus membuatnya di bawah tekanan wawancara! Jika saya membuat booboo saya terlalu lelah untuk menemukannya ...

Um ... Saya memilih untuk mendefinisikan "single-pass" sebagai membuat satu sapuan melalui matriks, daripada menyentuh setiap nilai sekali! :-)

#include <stdio.h>
#include <memory.h>

#define SIZE    5

typedef unsigned char u8;

u8 g_Array[ SIZE ][ SIZE ];

void Dump()
{
    for ( int nRow = 0; nRow < SIZE; ++nRow )
    {
        for ( int nColumn = 0; nColumn < SIZE; ++nColumn )
        {
            printf( "%d ", g_Array[ nRow ][ nColumn ] );
        }
        printf( "\n" );
    }
}

void Process()
{
    u8 fCarriedAlpha = true;
    u8 fCarriedBeta = true;
    for ( int nStep = 0; nStep < SIZE; ++nStep )
    {
        u8 fAlpha = (nStep > 0) ? g_Array[ nStep-1 ][ nStep ] : true;
        u8 fBeta = (nStep > 0) ? g_Array[ nStep ][ nStep - 1 ] : true;
        fAlpha &= g_Array[ nStep ][ nStep ];
        fBeta &= g_Array[ nStep ][ nStep ];
        g_Array[ nStep-1 ][ nStep ] = fCarriedBeta;
        g_Array[ nStep ][ nStep-1 ] = fCarriedAlpha;
        for ( int nScan = nStep + 1; nScan < SIZE; ++nScan )
        {
            fBeta &= g_Array[ nStep ][ nScan ];
            if ( nStep > 0 )
            {
                g_Array[ nStep ][ nScan ] &= g_Array[ nStep-1 ][ nScan ];
                g_Array[ nStep-1][ nScan ] = fCarriedBeta;
            }

            fAlpha &= g_Array[ nScan ][ nStep ];
            if ( nStep > 0 )
            {
                g_Array[ nScan ][ nStep ] &= g_Array[ nScan ][ nStep-1 ];
                g_Array[ nScan ][ nStep-1] = fCarriedAlpha;
            }
        }

        g_Array[ nStep ][ nStep ] = fAlpha & fBeta;

        for ( int nScan = nStep - 1; nScan >= 0; --nScan )
        {
            g_Array[ nScan ][ nStep ] &= fAlpha;
            g_Array[ nStep ][ nScan ] &= fBeta;
        }
        fCarriedAlpha = fAlpha;
        fCarriedBeta = fBeta;
    }
}

int main()
{
    memset( g_Array, 1, sizeof(g_Array) );
    g_Array[0][1] = 0;
    g_Array[0][4] = 0;
    g_Array[1][0] = 0;
    g_Array[1][4] = 0;
    g_Array[3][1] = 0;

    printf( "Input:\n" );
    Dump();
    Process();
    printf( "\nOutput:\n" );
    Dump();

    return 0;
}

saya harap Anda menikmati solusi 1-pass c # saya

Anda dapat mengambil elemen dengan O (1) dan hanya membutuhkan ruang satu baris dan satu kolom dari matriks

bool[][] matrix =
{
    new[] { true, false, true, true, false }, // 10110
    new[] { false, true, true, true, false }, // 01110
    new[] { true, true, true, true, true },   // 11111
    new[] { true, false, true, true, true },  // 10111
    new[] { true, true, true, true, true }    // 11111
};

int n = matrix.Length;
bool[] enabledRows = new bool[n];
bool[] enabledColumns = new bool[n];

for (int i = 0; i < n; i++)
{
    enabledRows[i] = true;
    enabledColumns[i] = true;
}

for (int rowIndex = 0; rowIndex < n; rowIndex++)
{
    for (int columnIndex = 0; columnIndex < n; columnIndex++)
    {
        bool element = matrix[rowIndex][columnIndex];
        enabledRows[rowIndex] &= element;
        enabledColumns[columnIndex] &= element;
    }
}

for (int rowIndex = 0; rowIndex < n; rowIndex++)
{
    for (int columnIndex = 0; columnIndex < n; columnIndex++)
    {
        bool element = enabledRows[rowIndex] & enabledColumns[columnIndex];
        Console.Write(Convert.ToInt32(element));
    }
    Console.WriteLine();
}

/*
    00000
    00000
    00110
    00000
    00110
*/

1 lulus, 2 boolean. Saya hanya harus mengasumsikan indeks integer di iterasi tidak masuk hitungan.

Ini bukan solusi lengkap tapi saya tidak bisa melewati titik ini.

Jika saya hanya bisa menentukan apakah 0 adalah asli 0 atau 1 yang dikonversi menjadi 0 maka saya tidak perlu menggunakan -1 dan ini akan berhasil.

Output saya seperti ini:

-1  0 -1 -1  0
 0 -1 -1 -1  0
-1 -1  1  1 -1
-1  0 -1 -1 -1
-1 -1  1  1 -1

Orisinalitas pendekatan saya menggunakan paruh pertama pemeriksaan baris atau kolom untuk menentukan apakah mengandung 0 dan setengah terakhir untuk menetapkan nilai - ini dilakukan dengan melihat x dan lebar-x dan kemudian y dan tinggi -Y di setiap iterasi. Berdasarkan hasil paruh pertama iterasi, jika 0 di baris atau kolom ditemukan, saya menggunakan paruh terakhir iterasi untuk mengubah 1 ke -1.

Saya baru menyadari ini bisa dilakukan dengan hanya 1 boolean menyisakan 1 untuk ...?

Saya memposting ini berharap seseorang mungkin berkata, "Ah, lakukan saja ini ..." (Dan saya menghabiskan terlalu banyak waktu untuk tidak memposting.)

Berikut kode di VB:

Dim D(,) As Integer = {{1, 0, 1, 1, 1}, {0, 1, 1, 0, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {0, 0, 1, 1, 1}}

Dim B1, B2 As Boolean

For y As Integer = 0 To UBound(D)

    B1 = True : B2 = True

    For x As Integer = 0 To UBound(D)

        // Scan row for 0's at x and width - x positions. Halfway through I'll konw if there's a 0 in this row.
        //If a 0 is found set my first boolean to false.
        If x <= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
            If D(x, y) = 0 Or D(UBound(D) - x, y) = 0 Then B1 = False
        End If

        //If the boolean is false then a 0 in this row was found. Spend the last half of this loop
        //updating the values. This is where I'm stuck. If I change a 1 to a 0 it will cause the column
        //scan to fail. So for now I change to a -1. If there was a way to change to 0 yet later tell if
        //the value had changed this would work.
        If Not B1 Then
            If x >= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
                If D(x, y) = 1 Then D(x, y) = -1
                If D(UBound(D) - x, y) = 1 Then D(UBound(D) - x, y) = -1
            End If
        End If

        //These 2 block do the same as the first 2 blocks but I switch x and y to do the column.
        If x <= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
            If D(y, x) = 0 Or D(y, UBound(D) - x) = 0 Then B2 = False
        End If

        If Not B2 Then
            If x >= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
                If D(y, x) = 1 Then D(y, x) = -1
                If D(y, UBound(D) - x) = 1 Then D(y, UBound(D) - x) = -1
            End If
        End If

    Next
Next

Tidak ada yang menggunakan bentuk biner? karena hanya 1 dan 0. Kita bisa menggunakan vektor biner.

def set1(M, N):
    '''Set 1/0s on M according to the rules.

    M is a list of N integers. Each integer represents a binary array, e.g.,
    000100'''
    ruler = 2**N-1
    for i,v in enumerate(M):
        ruler = ruler & M[i]
        M[i] = M[i] if M[i]==2**N-1 else 0  # set i-th row to all-0 if not all-1s
    for i,v in enumerate(M):
        if M[i]: M[i] = ruler
    return M

Inilah tesnya:

M = [ 0b10110,
      0b01110,
      0b11111,
      0b10111,
      0b11111 ]

print "Before..."
for i in M: print "{:0=5b}".format(i)

M = set1(M, len(M))
print "After..."
for i in M: print "{:0=5b}".format(i)

Dan hasilnya:

Before...
10110
01110
11111
10111
11111
After...
00000
00000
00110
00000
00110

Anda dapat melakukan sesuatu seperti ini untuk menggunakan satu pass tetapi input dan output matrix:

output(x,y) = col(xy) & row(xy) == 2^n

di mana col(xy)bit dalam kolom berisi titik xy; row(xy)adalah bit di baris yang mengandung titik xy.nadalah ukuran dari matriks.

Kemudian cukup lewati input. Mungkin dapat diperluas agar lebih hemat ruang?

Satu pemindaian matriks, dua boolean, tanpa rekursi.

Bagaimana cara menghindari lulus kedua? Pass kedua diperlukan untuk menghapus baris atau kolom ketika nol muncul di akhir mereka.

Namun masalah ini dapat diselesaikan, karena ketika kita memindai baris # i kita sudah tahu status baris untuk baris # i-1. Jadi, ketika kita memindai baris # i, kita dapat menghapus baris # i-1 secara bersamaan jika diperlukan.

Solusi yang sama berfungsi untuk kolom, tetapi kita perlu memindai baris dan kolom secara bersamaan sementara data tidak diubah oleh iterasi berikutnya.

Diperlukan dua boolean untuk menyimpan status baris pertama dan kolom pertama, karena nilainya akan berubah selama eksekusi bagian utama dari algoritma.

Untuk menghindari menambahkan lebih banyak boolean, kami menyimpan flag "clear" untuk baris dan kolom di baris dan kolom pertama dari matriks.

public void Run()
{
    const int N = 5;

    int[,] m = new int[N, N] 
                {{ 1, 0, 1, 1, 0 },
                { 1, 1, 1, 1, 0 },
                { 1, 1, 1, 1, 1 },
                { 1, 0, 1, 1, 1 },
                { 1, 1, 1, 1, 1 }};

    bool keepFirstRow = (m[0, 0] == 1);
    bool keepFirstColumn = keepFirstRow;

    for (int i = 1; i < N; i++)
    {
        keepFirstRow = keepFirstRow && (m[0, i] == 1);
        keepFirstColumn = keepFirstColumn && (m[i, 0] == 1);
    }

    Print(m); // show initial setup

    m[0, 0] = 1; // to protect first row from clearing by "second pass"

    // "second pass" is performed over i-1 row/column, 
    // so we use one more index just to complete "second pass" over the 
    // last row/column
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= N; j++)
        {
            // "first pass" - searcing for zeroes in row/column #i
            // when i = N || j == N it is additional pass for clearing 
            // the previous row/column
            // j >= i because cells with j < i may be already modified 
            // by "second pass" part
            if (i < N && j < N && j >= i) 
            {
                m[i, 0] &= m[i, j];
                m[0, j] &= m[i, j];

                m[0, i] &= m[j, i];
                m[j, 0] &= m[j, i];
            }

            // "second pass" - clearing the row/column scanned 
            // in the previous iteration
            if (m[i - 1, 0] == 0 && j < N)
            {
                m[i - 1, j] = 0;
            }

            if (m[0, i - 1] == 0 && j < N)
            {
                m[j, i - 1] = 0;
            }
        }

        Print(m);
    }

    // Clear first row/column if needed
    if (!keepFirstRow || !keepFirstColumn)
    {
        for (int i = 0; i < N; i++)
        {
            if (!keepFirstRow)
            {
                m[0, i] = 0;
            }
            if (!keepFirstColumn)
            {
                m[i, 0] = 0;
            }
        }
    }

    Print(m);

    Console.ReadLine();
}

private static void Print(int[,] m)
{
    for (int i = 0; i < m.GetLength(0); i++)
    {
        for (int j = 0; j < m.GetLength(1); j++)
        {
            Console.Write(" " + m[i, j]);
        }
        Console.WriteLine();
    }
    Console.WriteLine();
}

Sepertinya karya-karya berikut tanpa persyaratan ruang tambahan:

pertama-tama perhatikan bahwa mengalikan elemen-elemen dari baris kali dengan elemen-elemen dari baris di mana sebuah elemen, memberikan nilai yang diinginkan.

Agar tidak menggunakan ruang tambahan apa pun (tidak membuat matriks baru dan mengisinya, tetapi langsung menerapkan perubahan pada matriks), mulailah dari kiri atas matriks dan lakukan perhitungan untuk matriks ixi apa pun (yang "dimulai" pada (0) , 0)) sebelum mempertimbangkan elemen apa pun dengan indeks apa pun> i.

Semoga ini berhasil (havent testet)

Ini DIUJI untuk N berbeda dalam C ++, dan adalah:
SATU LULUS , DUA BULU , TANPA PEREKAMAN , TANPA MEMORI EKSTRA , TERLENGKAPNYA UNTUK BESARNYA SECARA ARBITRAR
(Sejauh ini tidak ada solusi di sini yang melakukan SEMUA ini.)

Lebih khusus, saya lucu dua loop counter tidak apa-apa. Saya memiliki dua const unsigned, yang hanya ada daripada dihitung setiap kali untuk dibaca. Interval loop luar adalah [0, N], dan interval loop dalam adalah [1, n - 1]. Pernyataan switch dalam loop sebagian besar ada untuk menunjukkan dengan sangat jelas bahwa itu hanya satu pass.

Strategi Algoritma:

Trik pertama adalah bagi kita satu baris dan kolom dari matriks itu sendiri untuk mengakumulasi konten matriks, memori ini menjadi tersedia dengan melepas semua yang benar-benar perlu kita ketahui dari baris pertama dan kolom menjadi dua boolean. Trik kedua adalah untuk mendapatkan dua pass dari satu, dengan menggunakan simetri dari sub-matriks dan indeksnya.

Sinopsis Algoritma:

• Pindai baris pertama dan simpan jika semuanya berada dalam boolean, lakukan hal yang sama untuk kolom pertama yang menyimpan hasilnya dalam boolean kedua.
• Untuk sub-matriks tidak termasuk baris pertama dan kolom pertama: iterate through, kiri ke kanan, atas ke bawah, karena orang akan membaca paragraf. Setelah mengunjungi setiap elemen, kunjungi juga elemen terkait yang akan dikunjungi jika mengunjungi sub-matriks secara terbalik. Untuk setiap elemen dikunjungi DAN nilainya ke tempat barisnya melintasi kolom pertama, dan juga DAN nilainya ke tempat kolomnya melintasi baris pertama.
• Setelah pusat sub-matriks tercapai, terus mengunjungi dua elemen secara bersamaan seperti di atas. Namun sekarang setel nilai elemen yang dikunjungi ke DAN di tempat barisnya melintasi kolom pertama, dan di mana kolomnya melintasi baris pertama. Setelah ini, sub-matriks selesai.
• Gunakan dua variabel boolean yang dihitung pada permintaan untuk mengatur baris pertama, dan kolom pertama ke nilai yang benar.

Implementasi Templatized C ++:

template<unsigned n>
void SidewaysAndRowColumn(int((&m)[n])[n]) {
    bool fcol = m[0][0] ? true : false;
    bool frow = m[0][0] ? true : false;
    for (unsigned d = 0; d <= n; ++d) {
        for (unsigned i = 1; i < n; ++i) {
            switch (d) {
                case 0:
                    frow    = frow && m[d][i];
                    fcol    = fcol && m[i][d];
                    break;
                default:
                {
                    unsigned const rd = n - d;
                    unsigned const ri = n - i;
                    if (d * n + i < rd * n + ri)
                    {
                        m[ d][ 0] &= m[ d][ i];
                        m[ 0][ d] &= m[ i][ d];
                        m[ 0][ i] &= m[ d][ i];
                        m[ i][ 0] &= m[ i][ d];
                        m[rd][ 0] &= m[rd][ri];
                        m[ 0][rd] &= m[ri][rd];
                        m[ 0][ri] &= m[rd][ri];
                        m[ri][ 0] &= m[ri][rd];
                    }
                    else
                    {
                        m[ d][ i] = m[ d][0] & m[0][ i];
                        m[rd][ri] = m[rd][0] & m[0][ri];
                    }
                    break;
                }
                case n:
                    if (!frow)
                        m[0][i] = 0;
                    if (!fcol)
                        m[i][0] = 0;
            };
        }
    }
    m[0][0] = (frow && fcol) ? 1 : 0;
}

Ok, saya menyadari bahwa itu tidak cocok, tapi saya mendapatkannya dalam satu pass menggunakan bool dan byte alih-alih dua bools ... tutup. Saya juga tidak akan menjamin efisiensi, tetapi jenis pertanyaan ini sering membutuhkan solusi yang kurang optimal.

private static void doIt(byte[,] matrix)
{
    byte zeroCols = 0;
    bool zeroRow = false;

    for (int row = 0; row <= matrix.GetUpperBound(0); row++)
    {
        zeroRow = false;
        for (int col = 0; col <= matrix.GetUpperBound(1); col++)
        {
            if (matrix[row, col] == 0)
            {

                zeroRow = true;
                zeroCols |= (byte)(Math.Pow(2, col));

                // reset this column in previous rows
                for (int innerRow = 0; innerRow < row; innerRow++)
                {
                    matrix[innerRow, col] = 0;
                }

                // reset the previous columns in this row
                for (int innerCol = 0; innerCol < col; innerCol++)
                {
                    matrix[row, innerCol] = 0;
                }
            }
            else if ((int)(zeroCols & ((byte)Math.Pow(2, col))) > 0)
            {
                matrix[row, col] = 0;
            }

            // Force the row to zero
            if (zeroRow) { matrix[row, col] = 0; }
        }
    }
}

Anda dapat mengurutkannya dalam satu pass - jika Anda tidak menghitung mengakses matriks dalam urutan akses acak, yang menghilangkan manfaat melakukannya dengan single-pass di tempat pertama (cache-coherence / memory-bandwidth).

[edit: solusi sederhana, tetapi salah dihapus]

Anda harus mendapatkan kinerja yang lebih baik daripada metode single-pass dengan melakukannya dalam dua lintasan: satu untuk mengumpulkan informasi baris / kolom, dan satu untuk menerapkannya. Array (dalam urutan baris-utama) diakses secara koheren; untuk array yang melebihi ukuran cache (tetapi baris yang dapat ditampung dalam cache), data harus dibaca dari memori dua kali, dan disimpan satu kali:

void fixmatrix2(int M[][], int rows, int cols) {
    bool clearZeroRow= false;
    bool clearZeroCol= false;
    for(int j=0; j < cols; ++j) {
        if( ! M[0][j] ) {
            clearZeroRow= true;
        }
    }
    for(int i=1; i < rows; ++i) { // scan/accumulate pass
        if( ! M[i][0] ) {
            clearZeroCol= true;
        }
        for(int j=1; j < cols; ++j) {
            if( ! M[i][j] ) {
                M[0][j]= 0;
                M[i][0]= 0;
            }
        }
    }
    for(int i=1; i < rows; ++i) { // update pass
        if( M[i][0] ) {
            for(int j=0; j < cols; ++j) {
                if( ! M[j][0] ) {
                    M[i][j]= 0;
                }
            }
        } else {
            for(int j=0; j < cols; ++j) {
                M[i][j]= 0;
            }
        }
        if(clearZeroCol) {
            M[i][0]= 0;
        }
    }
    if(clearZeroRow) {
        for(int j=0; j < cols; ++j) {
            M[0][j]= 0;
        }
    }
}

Solusi paling sederhana yang dapat saya pikirkan adalah ditempelkan di bawah ini. Logikanya adalah untuk merekam baris dan kolom mana yang akan disetel nol saat iterasi.

import java.util.HashSet;
import java.util.Set;

public class MatrixExamples {
    public static void zeroOut(int[][] myArray) {
        Set<Integer> rowsToZero = new HashSet<>();
        Set<Integer> columnsToZero = new HashSet<>();

        for (int i = 0; i < myArray.length; i++) { 
            for (int j = 0; j < myArray.length; j++) {
                if (myArray[i][j] == 0) {
                    rowsToZero.add(i);
                    columnsToZero.add(j);
                }
            }
        }

        for (int i : rowsToZero) {
            for (int j = 0; j < myArray.length; j++) {
                myArray[i][j] = 0;
            }
        }

        for (int i : columnsToZero) {
            for (int j = 0; j < myArray.length; j++) {
                myArray[j][i] = 0;
            }
        }

        for (int i = 0; i < myArray.length; i++) { // record which rows and                                             // columns will be zeroed
            for (int j = 0; j < myArray.length; j++) {
                System.out.print(myArray[i][j] + ",");
            if(j == myArray.length-1)
                System.out.println();
            }
        }

    }

    public static void main(String[] args) {
        int[][] a = { { 1, 0, 1, 1, 0 }, { 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 1 },
                { 1, 0, 1, 1, 1 }, { 1, 1, 1, 1, 1 } };
        zeroOut(a);
    }
}

Berikut ini adalah implementasi Ruby saya dengan tes yang disertakan, Ini akan mengambil ruang O (MN). Jika kita menginginkan pembaruan waktu nyata (ingin menunjukkan hasil ketika kita menemukan nol daripada menunggu loop pertama untuk menemukan nol) kita bisa membuat variabel kelas lain seperti @outputdan setiap kali kita menemukan nol kita memperbarui @outputdan tidak @input.

require "spec_helper"


class Matrix
    def initialize(input)
        @input  = input
        @zeros  = []
    end

    def solve
        @input.each_with_index do |row, i|          
            row.each_with_index do |element, j|                             
                @zeros << [i,j] if element == 0
            end
        end

        @zeros.each do |x,y|
            set_h_zero(x)
            set_v_zero(y)
        end

        @input
    end


    private 

    def set_h_zero(row)     
        @input[row].map!{0}     
    end

    def set_v_zero(col)
        @input.size.times do |r|
            @input[r][col] = 0
        end
    end
end


describe "Matrix" do
  it "Should set the row and column of Zero to Zeros" do
    input =  [[1, 3, 4, 9, 0], 
              [0, 3, 5, 0, 8], 
              [1, 9, 6, 1, 9], 
              [8, 3, 2, 0, 3]]

    expected = [[0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0],
                [0, 9, 6, 0, 0],
                [0, 0, 0, 0, 0]]

    matrix = Matrix.new(input)

    expect(matrix.solve).to eq(expected)
  end
end

Kode di bawah ini membuat matriks ukuran m, n. Pertama-tama tentukan dimensi matriks. Saya ingin mengisi matriks [m] [n] dengan secara acak dengan angka antara 0..10. Kemudian buat matriks lain dari dimensi yang sama dan isi dengan -1s (final matrix). Kemudian beralih melalui matriks awal untuk melihat apakah Anda akan menekan 0. Ketika Anda menekan pada lokasi (x, y), pergi ke matriks akhir dan isi baris x dengan 0s dan kolom y dengan 0s. Pada akhir membaca matriks akhir, jika nilainya -1 (nilai asli) salin nilai di lokasi yang sama dari matriks awal ke final.

public static void main(String[] args) {
    int m = 5;
    int n = 4;
    int[][] matrixInitial = initMatrix(m, n); // 5x4 matrix init randomly
    int[][] matrixFinal = matrixNull(matrixInitial, m, n); 
    for (int i = 0; i < m; i++) {
        System.out.println(Arrays.toString(matrixFinal[i]));
    }
}

public static int[][] matrixNull(int[][] matrixInitial, int m, int n) {
    int[][] matrixFinal = initFinal(m, n); // create a matrix with mxn and init it with all -1
    for (int i = 0; i < m; i++) { // iterate in initial matrix
        for (int j = 0; j < n; j++) {
            if(matrixInitial[i][j] == 0){ // if a value is 0 make rows and columns 0
                makeZeroX(matrixFinal, i, j, m, n); 
            }
        }
    }

    for (int i = 0; i < m; i++) { // if value is -1 (original) copy from initial
        for (int j = 0; j < n; j++) {
            if(matrixFinal[i][j] == -1) {
                matrixFinal[i][j] = matrixInitial[i][j];
            }
        }
    }
    return matrixFinal;
}

private static void makeZeroX(int[][] matrixFinal, int x, int y, int m, int n) {
        for (int j = 0; j < n; j++) { // make all row 0
            matrixFinal[x][j] = 0;
        }
        for(int i = 0; i < m; i++) { // make all column 0
            matrixFinal[i][y] = 0; 
        }
}

private static int[][] initMatrix(int m, int n) {

    int[][] matrix = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            Random rn = new Random();
            int random = rn.nextInt(10);
            matrix[i][j] = random;
        }
    }

    for (int i = 0; i < m; i++) {
        System.out.println(Arrays.toString(matrix[i]));
    }
    System.out.println("******");
    return matrix;
}

private static int[][] initFinal(int m, int n) {

    int[][] matrix = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            matrix[i][j] = -1;
        }
    }
    return matrix;
}

// another approach
/**
 * @param matrixInitial
 * @param m
 * @param n
 * @return
 */
private static int[][] matrixNullNew(int[][] matrixInitial, int m, int n) {
    List<Integer> zeroRowList = new ArrayList<>(); // Store rows with 0
    List<Integer> zeroColumnList = new ArrayList<>(); // Store columns with 0
    for (int i = 0; i < m; i++) { // read through the matrix when you hit 0 add the column to zeroColumnList and add
                                  // the row to zeroRowList
        for (int j = 0; j < n; j++) {
            if (matrixInitial[i][j] == 0) {
                if (!zeroRowList.contains(i)) {
                    zeroRowList.add(i);
                }
                if (!zeroColumnList.contains(j)) {
                    zeroColumnList.add(j);
                }
            }
        }
    }

    for (int a = 0; a < m; a++) {
        if (zeroRowList.contains(a)) { // if the row has 0
            for (int b = 0; b < n; b++) {
                matrixInitial[a][b] = 0; // replace all row with zero
            }
        }
    }

    for (int b = 0; b < n; b++) {
        if (zeroColumnList.contains(b)) { // if the column has 0
            for (int a = 0; a < m; a++) {
                matrixInitial[a][b] = 0; // replace all column with zero
            }
        }
    }
    return matrixInitial;
}

ini solusinya. Seperti yang dapat Anda lihat dari kode, diberikan matriks M * N, ia menetapkan seluruh baris menjadi nol setelah memeriksa nol di baris itu. Kompleksitas waktu dari solusi saya adalah O (M * N). Saya berbagi seluruh kelas yang memiliki larik statis yang dihuni untuk pengujian dan metode larik tampilan untuk melihat hasilnya di konsol.

public class EntireRowSetToZero {
    static int arr[][] = new int[3][4];
    static {

    arr[0][0] = 1;
    arr[0][1] = 9;
    arr[0][2] = 2;
    arr[0][3] = 2;

    arr[1][0] = 1;
    arr[1][1] = 5;
    arr[1][2] = 88;
    arr[1][3] = 7;

    arr[2][0] = 0;
    arr[2][1] = 8;
    arr[2][2] = 4;
    arr[2][3] = 4;
}

public static void main(String[] args) {
    displayArr(EntireRowSetToZero.arr, 3, 4);
    setRowToZero(EntireRowSetToZero.arr);
    System.out.println("--------------");
    displayArr(EntireRowSetToZero.arr, 3, 4);


}

static int[][] setRowToZero(int[][] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            if(arr[i][j]==0){
                arr[i]=new int[arr[i].length];
            }
        }

    }
    return arr;
}

static void displayArr(int[][] arr, int n, int k) {

    for (int i = 0; i < n; i++) {

        for (int j = 0; j < k; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println("");
    }

}

}