Überprüft, ob es T aufeinanderfolgende Blöcke mit Nullen in der gegebenen Binärmatrix gibt

Einführung

Binäre Matrizen werden in der Informatik und verschiedenen Bereichen häufig verwendet, um Daten effektiv darzustellen oder komplexe Probleme zu lösen. In manchen Fällen ist es wichtig zu ermitteln, ob eine bestimmte binäre Matrix aufeinanderfolgende Nullenblöcke enthält. In diesem Artikel werden wir eine elegante Lösung mit C++-Code untersuchen, die es uns ermöglicht, das Vorhandensein von T aufeinanderfolgenden Nullblöcken in einer gegebenen Binärmatrix zu erkennen. Dieser Ansatz ist sowohl intuitiv als auch effizient und eignet sich daher für die praktische Umsetzung.

Überprüfen Sie, ob es T aufeinanderfolgende 0-Blöcke gibt

Angesichts einer zweidimensionalen binären Matrix der Dimension N x M und einer ganzen Zahl T müssen wir bestimmen, ob es T aufeinanderfolgende Blöcke von Nullen in der Matrix gibt (wobei „angrenzend“ horizontal oder vertikal benachbart bedeutet). Um dies zu erreichen, zerlegen wir den Prozess Schritt für Schritt mithilfe logischer und algorithmischer Methoden.

Eingabeüberprüfung

Bevor wir uns mit der Untersuchung von Mustern in binären Matrizen befassen, ist es wichtig, die entsprechenden Dimensionen und relevanten Merkmale der Benutzereingabe zu überprüfen. Wir müssen sicherstellen, dass T innerhalb eines akzeptablen Bereichs liegt, um brauchbare Ergebnisse zu liefern und gleichzeitig die Recheneffizienz aufrechtzuerhalten

Zeilen und Spalten durchlaufen

Um aufeinanderfolgende Nullenblöcke effizient zu bestimmen, müssen wir Zeilen und Spalten getrennt analysieren. Beginnend mit der ersten Zeile (ganz oben) durchlaufen wir beispielsweise alle Elemente spaltenweise bis zur Zeile N (ganz unten). Das gleichzeitige Durchqueren von Spalten hilft dabei, horizontale und vertikale Sequenzen auf natürliche Weise zu erfassen, ohne mögliche Kombinationen zu verpassen

Aufeinanderfolgende Blöcke erkennen

Die Identifizierung aufeinanderfolgender Nullen bildet den Grundstein für die Erkennung von Blöcken aufeinanderfolgender Nullen, während wir jede Spalte jeder Zeile durchlaufen.

Eine binäre Matrix ist ein Array, das nur aus Nullen und Einsen besteht, wobei jedes Element einen „Aus“- bzw. „Ein“-Zustand darstellt. Durch die Analyse dieser beiden Zustände können wir einzigartige Muster identifizieren, die Korrelationen oder einzigartige Anordnungen zwischen benachbarten Elementen ermöglichen können.

Beispiel

Binärmatrix wird betrachtet als:

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

Wir müssen die Anzahl aufeinanderfolgender Nullblöcke in der Matrix ermitteln. Der Wert von T beträgt 3.

Wir können Depth First Search (DFS) verwenden, um aufeinanderfolgende Nullenblöcke in einer Matrix zu finden. Wir iterieren zunächst zeilen- und spaltenweise über die Matrix. Wenn wir auf ein Nullelement stoßen, auf das zuvor noch nicht zugegriffen wurde, verschieben wir es auf den Stapel und starten DFS von diesem Element aus.

Während des DFS-Prozesses prüfen wir die vier Nachbarzellen (oben, unten, links, rechts) der aktuellen Zelle. Wenn eine dieser Zellen Null ist und zuvor noch nicht darauf zugegriffen wurde, verschieben wir sie auf den Stapel und setzen DFS von dieser Zelle aus fort.

Wir verfolgen auch die Anzahl der bisher aufgetretenen aufeinanderfolgenden Nullblöcke. Wenn dieser Wert größer oder gleich T ist, geben wir „Ja“ zurück. Andernfalls setzen wir DFS fort, bis alle Zellen besucht wurden

In diesem Fall führen wir eine Tiefensuche (DFS) beginnend bei Zelle (0,1) durch. Wir stoßen bei (0,2) und (0,3) auf zwei weitere Nullelemente und fügen sie unserem aktuellen Pfad hinzu. Wir kehren dann zur Zelle (0,1) zurück und überprüfen die Nachbarzellen. Wir stoßen bei (1,1) auf ein weiteres Nullelement und fügen es unserem aktuellen Pfad hinzu. Dann kehren wir erneut zur Zelle (0,1) zurück und überprüfen die Nachbarzellen. Wir haben keine Nullelemente gefunden, die noch nicht besucht wurden

Dann starten wir DFS aus Zelle (3,1). Wir stoßen bei (3,2) und (3,3) auf zwei weitere Nullelemente und fügen sie unserem aktuellen Pfad hinzu. Anschließend gehen wir zurück zu Zelle (3,1) und überprüfen die Nachbarzellen. Wir werden nie auf ein Nullelement stoßen, das wir nicht schon einmal besucht haben.

Wir finden nun drei aufeinanderfolgende Nullblöcke in der Matrix. Da dieser Zähler größer oder gleich T=3 ist, lautet die Ausgabe „Ja“.

Methode 1: C++-Code prüft, ob T aufeinanderfolgende 0-Blöcke vorhanden sind

Um unser Ziel zu erreichen, können wir Graph-Traversal-Techniken auf einer binären Matrix anwenden und gleichzeitig die besuchten Zellen verfolgen. Wir werden den Depth First Search (DFS)-Algorithmus in Kombination mit dem Backtracking-Prinzip verwenden.

Algorithmus

Schritt 1: Initialisieren Sie die erforderlichen Variablen, z. B. die Definition der Konstanten „N“ und „M“, um die Größe der eingegebenen Binärmatrix darzustellen, und die Deklaration der zusätzlichen booleschen Arrays „visited“ und „inCurrentPath“ mit der Größe jedes Arrays ist N x M und setzt zunächst alle Elemente in beiden Arrays auf false

Schritt 2: Implementieren Sie die DFS-Funktion und binden Sie die Hauptfunktion ein

Schritt 3: Abhängig von der eingegebenen Binärmatrix wird die Ausgabe als Ja oder Nein gedruckt.

Beispiel

#include<iostream>
#include<stack>
#include<bitset>

#define N 100
#define M 100

struct Node {
   int i;
   int j;
};

bool DFS(bool matrix[], int rows, int cols, int T)
{
   if(matrix == nullptr || rows <= 0 || cols <= 0 || T <= 0) // check for invalid input
      return false;

   std::bitset<N*M> visited; // declare bitset to mark visited cells
   std::bitset<N*M> inCurrentPath; // declare bitset to mark cells in current path
   std::stack<Node> s; // declare stack to store nodes for DFS

   for(int i=0;i<rows;++i){
      for(int j=0;j<cols;++j){

         if(matrix[i*cols+j] == 0 && !visited[i*cols+j]){

            s.push({i,j});
            int count = 0; // initialize count to zero for each new search

            while(!s.empty()){

               Node node = s.top();
               s.pop();

               if(node.i < 0 || node.i >= rows || node.j < 0 || node.j >= cols || visited[node.i*cols+node.j])
                  continue;

               visited[node.i*cols+node.j] = true;

               if(matrix[node.i*cols+node.j] == 0 && !inCurrentPath[node.i*cols+node.j]){
                  inCurrentPath[node.i*cols+node.j] = true;
                  count++;
               }

               if(count >= T){
                  std::cout << "Yes, the path is: "; // print yes and the path
                  for(int k=0;k<N*M;++k){
                     if(inCurrentPath[k]){
                        std::cout << "(" << k/cols << "," << k%cols << ") "; // print the coordinates of the cells in the path
                     }
                  }
                  std::cout << "\n";
                  return true;
               }

               s.push({node.i+1,node.j});
               s.push({node.i-1,node.j});
               s.push({node.i,node.j+1});
               s.push({node.i,node.j-1});
            }

            inCurrentPath.reset(); // reset the path after each search
         }
      }
   }

   std::cout << "No\n"; // print no if no path is found
   return false;
}

int main()
{
   bool matrix[N*M] = {1,1,0,0,1,
                  1,0,0,0,1,
                  1,1,1,1,1,
                  1,1,0,0,1,
                  }; // Binary matrix

   int T = 3; // Number of continuous blocks to find

   DFS(matrix, N, M, T); // call DFS function

   return 0;
}

Ausgabe

Yes, the path is: (0,2) (1,0) (1,1)

Fazit

Durch die Nutzung des vorgeschlagenen C++-Codes, der eine Graph-Traversal-Technik mit Tiefensuche (DFS) verwendet, können wir bequem bestimmen, ob eine bestimmte Anzahl (T) aufeinanderfolgender Nullblöcke in einer Binärmatrix vorhanden ist. Diese Lösung bietet eine effiziente Möglichkeit zur Lösung von Problemen im Zusammenhang mit binären Matrizen und ermöglicht Forschern und Entwicklern die effiziente Erstellung leistungsstarker Algorithmen.

Das obige ist der detaillierte Inhalt vonÜberprüft, ob es T aufeinanderfolgende Blöcke mit Nullen in der gegebenen Binärmatrix gibt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!