¡Por favor, ayuda de un experto en programación en C! ¿Qué hay de malo en la lógica de esta pregunta? ¡He estado buscando durante horas y no puedo entenderlo!
El código es un poco confuso y no puedo ver la idea con claridad. Hay algunos casos de acceso fuera de límites a la matriz. No se sabe si el algoritmo es efectivo, así que lo reescribí. referencia.
La idea es la siguiente:
Este problema es en realidad generar todas las permutaciones del 0 al 9 y luego juzgar si cada permutación cumple con los requisitos en función de la posición de cada número. en la grilla. Baidu realizó una ligera modificación en un algoritmo de permutación completo y obtuvo el siguiente código. El número de soluciones de salida efectivas es 1580. En mi caso, la salida es de aproximadamente 70 ms a 100 ms. El diseño del código de Baidu es extremadamente basura. Si lo copia en VS, quedará completamente desordenado y ya no se reorganizará.
Además, después de generar el número de permutación, este problema de cuadrícula debería convertirse en un algoritmo matemático puro para juzgar. No es necesario completar ninguna tabla. Soy demasiado vago para pensar demasiado. sobre el código para completar la tabla y juzgar las partes. Un poco divertido por naturaleza.
#include?
//#include?
//# include ?
const?int?ROW?=?5;?//?Agregue dos líneas para reducir el juicio de límites, en realidad use las 3 filas del medio
const?int?COL?=?6;?//?Agregue dos columnas para reducir el juicio de límites, en realidad use las 4 columnas del medio
const? BORDER?=?-11;?//?Marca de límite de tabla
const?int?NON?=?-9;?//?Marca la posición inicial y final del contenido efectivo de la tabla int ?grid[ROW ][COL];?//?Matriz de tabla
int?count;//?Recuento válido de soluciones
void?InitGrid(void);?//? Inicialice la tabla, establezca los bordes y marque las posiciones inicial y final del contenido efectivo de la tabla
void?PrintGrid(void);?//?Imprimir soluciones válidas de salida
void ?Perm(int?list[],?int ?k,?int?m);?//?Genere recursivamente el número de permutaciones, envíe el número generado de permutaciones a la tabla y luego determine si imprimir y contar
void?Swap(int?&a,?int ?&b);//?Funciones de referencia e intercambio, utilizadas para generar recursivamente funciones de permutación
void?PermOutput(int?list[] );//?Relleno, juicio, impresión y conteo de tablas de permutaciones void?main(void)
{
//long?start_time,?end_time;//?Variable que registra el inicio y el final del tiempo de ejecución de la prueba
int?num [10]?=?{?0,1,2,3,4,5,6,7,8,9?};? //0~9?Secuencia numérica
//start_time ?=?GetTickCount();//?Obtener el tiempo de ejecución inicial de este segmento de programa
count?=?0 ;
InitGrid();
Perm( num,?0,?10);
//end_time?=?GetTickCount();//Obtener la hora de finalización de la ejecución de este segmento del programa
//printf("\nCount? =?%d?in?%ld?ms\n",?count,?end_time?-?start_time);? //Imprimir el tiempo de ejecución del programa
getchar();
}//?Inicializa la tabla, establece los límites y marca las posiciones inicial y final del contenido efectivo de la tabla.
void?InitGrid(void)
{
int?i,?j;
for?(i?=?0 ;?i?
{
para?(j ?=?0;?j?
{
grid[i][j]?=?BORDER;?//?Establecer bordes
}
}
//?Establecer las posiciones inicial y final del contenido válido
grid[1][1]?=?NON;
grid[ROW?-?2][COL? -?2]?=?NON;
}//?Imprimir soluciones válidas
void? PrintGrid(void)
{
int?i,?j;
printf("?-?-?-?-?-?-?- ?-?-?-?-\n");
¿para?(yo?
=?1;?i?
para?(j?=?1;?j?
{
if?(grid[i][j]?!=?NON)
printf("%5d" ,?grid[i][j]);?/?/?valores válidos
else
printf("%5s",?"");//?valores válidos Posición inicial y final
}
printf("\n");
}
}//? Generar recursivamente la número de permutaciones, generado Muestra el número de permutaciones en la tabla y luego determina si imprimir y contar
void?Perm(int?list[],?int?k,?int?m)? //?k representa la posición del prefijo, m es el número a ordenar.
{
int?i;
if?(k?==?m?-?1)?//?El prefijo es el última posición, Indica que se ha generado el número de permutación de m dígitos. Determine si la solución es válida e imprima y cuente.
{
PermOutput(list);
}
else//? De lo contrario, ingrese recursividad para generar el siguiente dígito de permutación
{
for?(i?=?k;?i { //Intercambiar prefijos para generar el siguiente prefijo. Swap(list[k],?list[i]); Perm(list,?k?+?1,?m) ; //Cambie el prefijo nuevamente y continúe con la disposición del prefijo anterior. Swap(list[k],?list[i]); } } }//?Funciones de referencia e intercambio, utilizadas para generar recursivamente funciones de permutación void?Swap(int?&a,?int?&b ) { int?temp?=?a;?a?=?b;?b?=?temp; } //?Relleno, evaluación, impresión y conteo de números de permutación void?PermOutput(int?list[]) { int? ,?j,?n;?//?n se utiliza para hacer referencia al valor de grid[i][j] para mejorar la eficiencia bool?ok;?//?Scheme valid mark //?Complete el número de permutaciones en la tabla n?=?0; for?(i?=?1;?i? { para?(j?=?1;?j? { si?(cuadrícula[i][j]?!=?NO) { cuadrícula[i][j]? =?lista [n]; n++; } } } //? En la forma de juicio ¿Hay números adyacentes? ok?=?true; for?(i?=?1;?i? { para?(j?=?1;?j? { n?=?grid[i][j]; si?((grid[i?-?1][j?-?1]?==?n?- ?1) ?||?((grid[i?-?1][j?-?1]?==?n?+?1))?||?//?Arriba izquierda (cuadrícula[ i?-?1][j?+?1]?==?n?-?1)?||?((cuadrícula[i?-?1][j?+?1]?= =?n? +?1))?||?//?Arriba derecha (cuadrícula[i?-?1][j]?==?n?-?1)?|| ?((cuadrícula[ i?-?1][j]?==?n?+?1))?||//?上 (cuadrícula[i][j?-?1 ]?==? n?-?1)?||?((cuadrícula[i][j?-?1]?==?n?+?1))?||//?izquierda (cuadrícula [i][j?+?1]?==?n?-?1)?||?((cuadrícula[i][j?+?1]?==?n?+? 1))?|//?right (grid[i?+?1][j]?==?n?-?1)?||?((grid[i?+ ?1][j ]?==?n?+?1))?||//?下 (grid[i?+?1][j?-?1]?== ?n?-? 1)?||?((grid[i?+?1][j?-?1]?==?n?+?1))?||?//?Abajo izquierda ( grid[i?+?1][j?+?1]?==?n?-?1)?||?((grid[i?+?1][j?+? 1]?==? n?+?1))//?Abajo a la derecha ) { ok?=?false;?//?Cualquier número adyacente, establezca la marca de fallo y saltar fuera del ciclo break; } } if?(!ok)// ? Si se marca como fallido, salte del bucle externo break; } //?Si se marca como exitoso, el plan es válido y se imprime el resultado if?(ok) { //PrintGrid();?//?Imprimir soluciones válidas count++; } }