Implementado en C ++: el acceso serpenteante

Descripción del problema

　　El acceso es en forma de meandro a lo largo del acceso del lado de la matriz, si la dirección de la corriente tiene numerosas deseable o despegar, luego 90 grados a la izquierda. Un comienzo esquina izquierda de la matriz, la dirección hacia abajo.

Formato de entrada

　　La primera línea de entrada es un número entero positivo de no más de dos de m 200, n, denota la matriz de filas y columnas. A continuación, cada fila de la fila n m es un número entero, denota la matriz.

Formato de salida

　　Sólo la línea de salida, un total de número mn, tomada como una matriz de entrada meandros número de resultados obtenidos. Entre el número separado por un espacio, final de la línea no tienen espacios adicionales.

entrada de la muestra

3 3
1 2 3
4 5 6
7 8 9

Ejemplo de salida

1 4 7 8 9 6 3 2 5

entrada de la muestra

3 2
1 2
3 4
5 6

Ejemplo de salida

1 3 5 6 4 2

 

Ideas: De acuerdo con la parte posterior ley para el tipo de número, cada cuatro acciones para un gran lazo, que es el primero en bajar, a continuación, ir a la derecha, ir hacia arriba, y finalmente dejaron ir. Por lo que un gran conjunto de cuatro pequeños circuito de circulación que puede ser resuelto.

1 #include <iostream>
 2  usando  espacio de nombres std;
3  int principal ( void )
 4  {
 5      int m, n;
6      int a, b, c, d, i, j, k, t, h, v, l, u;
7      i = 0 ;
8      k = 0 ;
9      h = 0 ;
10      v = 1 ;
11      l = 0 ;
12      u = 0 ;
13      cin >> m >> n;
14     J = m * n-;
 15      int ARR [m] [n-];
 16      int BRR [J];
 . 17      para ( int X = 0 ; X <m; X ++ )
 18 es      {
 . 19          para ( int Y = 0 ; Y <n- ; Y ++ )
 20 es          {
 21 es              CIN >> ARR [X] [Y];
 22 es          }
 23 es      }
 24      para (T = 0 ; T <J;)    // recuento, un total de m * n número, para atravesar m * n veces 
25      {
 26          para(A = H; A <m; A ++)   // primero a bajar esta nota un <mm, de hecho, cada uno es diferente porque no cada vez que llegan a la parte inferior de la 
27          {
 28              BRR [t] = arr [ a] [I];
 29              T ++ ;
 30              IF (T == J)   // Tenga en cuenta que el tiempo para alcanzar el punto crítico en el tiempo de todo el bucle 
31 es              {
 32                  PAUSA ;
 33 es              }
 34 es          }
 35          para (B = V; B <n-; ++ B)   // y luego pasar a la derecha Nota que b <nn no es en realidad el mismo cada vez porque no siempre es posible ir a la derecha 
36          {
 37 [              BRR [T] = ARR [m - 1. ] [B];
 38 es              t ++;
 39              IF (T == J)
 40              {
 41 es                  PAUSA ;
 42 es              }
 43 es          }
 44 es          para (m = C - 2 ; C> = L; C--)   // ir hacia arriba en lugar de escribir c> = 0 no es redujo de la primera fila de cada 
45          {
 46 es              BRR [T] = ARR [C] [n-- 1. ];
 47              T ++ ;
 48              IF (T == J)
 49              {
 50                  PAUSA ;
 51 es              }
 52 es          }
 53 es          para(N-D = - 2 ; D> U; D -)   // luego ir a la izquierda en lugar de escribir d> 0 no siempre reducida de la primera columna 
54 es          {
 55              BRR [T] = ARR [K] [ ] D;
 56 es              T ++ ;
 57 es              SI (T == J)
 58              {
 59                  PAUSA ;
 60              }
 61 es          }
 62 es          M-- ;
 63 es          N-- ;
 64          I ++ ;
 65          K ++ ;
 66          H ++ ;
 67          V ++ ;
68          l ++ ;
69          u ++ ;
70      }
 71      para ( int q = 0 ; q <j - 1 ; q ++ )
 72      {
 73          cout << BRR [q] << "  " ;
74      }
 75      cout << BRR [j - 1 ];
76      de retorno  0 ;
77 }

Nota: (1) el código que utilizo una gran cantidad de variables, no hay que confundir la relación entre el individuo y el papel de las variables

          (2) cuando t = m * n debe ser rápidamente fuera del bucle, de lo contrario causará límites de matriz

          (3) determinar las condiciones de cada nota de un extremo pequeño bucle, porque no después de un gran ciclo, determinar las condiciones cambiará

 

Una mirada a un código relativamente simple he encontrado en Internet:

1 #include <iostream>
 2  usando  espacio de nombres std;
3  int main ()
 4  {
 5      int m = 0 , n = 0 ;
6      cin >> m >> n;
7      int a [m] [n];
8      para ( int i = 0 ; i <m; i ++ )
 9          para ( int j = 0 ; j <n; j ++ )
 10              cin >> a [i] [j];
11      int círculo = 0 , count =0 ; // número de ciclos de inicialización, la salida del contador 
12 es      el tiempo (COUNT <m * n-)
 13 es      {
 14          para ( int i = Circle; I <m - Circle && COUNT <n-m *; i ++) // primer borde ( izquierda) 
15          {
 16              COUT << a [I] [Círculo] << "  " ;
 . 17              COUNT = + 1. ;
 18 es          }
 . 19          para ( int J = Círculo + 1. ; J <n-- Circle && COUNT <n-m *; ++ J) // segundo borde (inferior) 
20          {
 21             cout << a [m - 1 - círculo] [j] << "  " ;
22              count + = 1 ;
23          }
 24          para ( int k = m - 2 - círculo; k> = círculo && recuento <m * n; k--) // 第三条边(右) 
25          {
 26              cout << un [k] [n - 1 - círculo] << "  " ;
27              count + = 1 ;
28          }
 29          para ( int h = n - 2 - círculo;. 1 + Círculo && COUNT <n-m *; h -) // cuarto lado (a) 
30          {
 31 es              COUT << A [Círculo] [H] << "  " ;
 32              COUNT = + . 1 ;
 33 es          }
 34 es          = + Círculo . 1 ;     // ciclos más 1. 
35      }
 36      de retorno  0 ;
 37 [ }

fuente original: https: //blog.csdn.net/wjinjie/article/details/104954349