Trova se esiste diagonalmente, orizzontalmente o verticalmente in 2D - valori uno dopo l'altro

Question

Quindi sto facendo un gioco da tavolo che è 19 per 19. Fondamentalmente è connesso 5, chiamato Gomoku.

Voglio fare un algoritmo efficiente per trovare se ci sono "n" pezzi di fila. I dati vengono archiviati come array 2D di 19x19. Ma nell'interesse della domanda, diciamo che è 6x6.

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

Questi sono due esempi di '5' di 1 in una fila. Come posso testare per ORIZZONTALE, VERTICALE ed entrambi i DIAGONALI?

Ecco il mio codice inefficiente:

private boolean firstDiagonalCheck(int x, int y, int num) { 
    int count = 1; 
    int check = 0; 
    boolean rflag = true; 
    boolean lflag = true; 
    int pos = 1; 

    check = turnHuman + 1; 

    while (rflag) { 
     if (x + pos >= 19 || y + pos >= 19) { 
      rflag = false; 
      break; 
     } 
     if (gb.getBoard()[x + pos][y + pos] == check) { 
      count++; 
      pos++; 
     } else { 
      rflag = false; 
     } 
    } 

    pos = 1; 

    while (lflag) { 
     if (x - pos < 0 || y - pos < 0) { 
      lflag = false; 
      break; 
     } 
     if (gb.getBoard()[x - pos][y - pos] == check) { 
      count++; 
      pos++; 
     } else { 
      lflag = false; 
     } 
    } 

    if (count == num) { 
     return true; 
    } 
    return false; 
} 

Questo è solo un metodo per la prima diagonale. Ce ne sono altri 3.

Come posso renderlo più efficiente e controllare tutte e 4 le direzioni?

EDIT ##################

Che il mio codice fa è: - Get 'la posizione del pezzo (x, y) - Controllare sia lati (su e giù se verticale) e contare quanti di fila ci sono - Se il numero di conteggi corrisponde a desiderato, ("num"), quindi restituisce true, altrimenti restituisce false.

Sarebbe più efficiente controllare ogni volta la scheda WHOLE per vedere se ci sono pezzi di fila?

Answer 1

int count=0; 
 
boolean Check(int x,int y) 
 
{ 
 
    int p1; 
 
    int p2; 
 
if(elementat[x+1][y+1]==1) 
 
    {p1=1; p2=1;} 
 
else if(elementat[x+1][y]==1) 
 
    {p1=1; p2=0;} 
 
else. if(elementat[x+1][y-1]==1) 
 
    {p1=1; p2=-1;} 
 
else. if(elementat[x][y-1]==1) 
 
    {p1=0;p2=-1;} 
 
else. if(elementat[x-1][y-1]==1) 
 
    {p1=-1; p2=-1;} 
 
else. if(elementat[x-1][y]==1) 
 
    {p1=-1; p2=0;} 
 
else. if(elementat[x-1][y+1]==1) 
 
    {p1=-1; p2=1;} 
 
else. if(elementat[x][y+1]==1) 
 
    {p1=0; p2=1;} 
 

 
Checknext(x,y); 
 
Checknextinv(x,y); 
 
If(count==5) // 5 means no. of elements to form line 
 
{return true} 
 
else 
 
    {return false;} 
 
} 
 

 

 
Checknext(x,y) //19 represents the 19x19 matrix 
 
{ if((x+p1)<=19 && (x+p1)>=0 && (y+p2)<=19 && (y+p2)>=0) 
 
     {  if(element[x+p1][y+p2]==1) 
 
      { count++; 
 
       checknext[x+p1][y+p2]; 
 
     } 
 
} 
 
Checknextinv(x,y) 
 
{ if((x+(-1*p1))<=19 && (x+(-1*p1))>=0 && (y+(-1*p2))<=19 && (y+(-1*p2))>=0)) 
 
    { 
 
     if(element[x+(-1*p1)][y+(-1*p2)]==1) 
 
     { 
 
       count++; 
 
       checknextinv[x+(-1*p1)][y+(-1*p2)]; 
 
     } 
 
}