Qué tal si primero realizas el programa que simplemente realice las permutaciones (sin maximizar) y cuando las haga correctamente y sin repeticiones, ya maximizas el resultado?

Backtracking suele hacerse fácil si vas poco a poco, si lo intentas todo de golpe, se complica demasiado. Y te lo digo por pura experiencia.

Por otro lado, plantéate primero desarrollarlo como algo recursivo, que es lo más cercano a la definición natural de backtracking que te va a facilitar el asunto, y una vez funcione, traducirlo a iterativo.

Te han dicho que el programa al final sea de X forma, pero no que desde un principio empiece así,e intentar backtraking iterativo me parece un suicidio de buenas a primeras.

PD: si no tienes recursividad, usa una pila, es lo que se consigue implícitamente con la recursividad.

Esos pings de 4ms son:
Usar ethernet y nada de wifi, que tu compañia use fibra optica y seguramente tener el nodo cerca de casa xD A parte, que siendo Barcelona, estará lanzando el pingtest contra el server de Barcelona.

Desde Valencia yo pillo 15ms de ping al server de speedtest.net de Barcelona.

Bueno, ya que estamos:

Si y no, * implica lo apuntado por, entonces *a es lo apuntado por a. si haces *a=b, lo apuntado por a, es igual a b, y dado que a es un puntero al tipo de b, a apunta a b.

La otra forma es a=&b, es decir, en a almacenas la dirección de memoria de b, y lo mismo, como a es un puntero al tipo de b, apunta a b,

Que tu código intenta igualar un entero y un puntero a entero, lo cual no es correcto porque no son tipos que se puedan convertir de uno a otro directamente,

Otra opción sería:

a=&b

En cualquier caso, y de una forma u otra, "a" debe recibir la dirección de memoria de "b".

dimitrix, en entornos académicos, en velocidades se usan bits, mientras que almacenamiento suele ser byte, dicho esto, el resto del mundo ya opera a su propio rtmo como los GigaBytes = 1000 MegaBytes de la mayoría de fabricantes de discos duros.

LAacuestión es:

El aviso te va a salir mientras NO uses chrome. Lo tengas instalado o no, simplemente detecta que lo uses.

Tu problema está en que si haces lo primero, el puntero apunta a dios sabe donde (en el mejor caso, si tu compilador inicializa las variables a 0, a NULL).

Entonces, la violación de segmento se produce por el hecho de que el trabajo que haga la función lo hace sobre un puntero que está señalando a la dirección de memoria NULL o a una zona que no es tuya.

En ese caso, el Sistema Operativo, te mata.

En el segundo caso no ocurre por tratarse de obtener la dirección de memoria del entero "a".

Para que el primer caso funcionase, debería ser algo así:

int *a;
int b;
 
*a=b;
 
funcion(a);
 

Fallo mío, no me había leído el código completo y tienes un typedef que "rompe" las referencias.

void mostrar_producto(NODOSIG* cola,int arti)
{
 int i;
NODOSIG actual=*cola;
 for(i=0;i<arti;i++)
 {
 
  printf("\n\t nombre del producto: %s\n\t cantidad del producto: %d\n\t precio del producto: %d",
               actual->produ,actual->prod,actual->preci);
actual=actual->siguiente;
 }
}

Porque jdownloader mide en Bytes (almacenamiento) y los tests de velocidad en bits (velocidades)

1 byte 8 bits. Lo cual según tu 1.22 implicaría que tienes alrededor de 9.6 Mbps no los 5,8 que te marca ese test de velocidad.

Tu problema es que no avanzas el puntero que recorre la cola y por otro lado, aprecio problemas con punteros.

Tu código:

void mostrar_producto(NODOSIG* cola,int arti)
{
 int i; 
 for(i=0;i<arti;i++)
 {
  NODOSIG actual=*cola;
  printf("\n\t nombre del producto: %s\n\t cantidad del producto: %d\n\t precio del producto: %d",
               actual->produ,actual->prod,actual->preci);
 }
}

Una aproximación que mantiene la mayor parte de tu código:

void mostrar_producto(NODOSIG* cola,int arti)
{
 int i; 
NODOSIG *actual=cola;
 for(i=0;i<arti;i++)
 {
  printf("\n\t nombre del producto: %s\n\t cantidad del producto: %d\n\t precio del producto: %d",
               actual->produ,actual->prod,actual->preci);
actual=actual->siguiente;
 }
}

Cambiar el tipo de "actual" de NODOSIG a NODOSIG* evita que tengas que cambiar todo "actual->" por "actual." (actual punto) para acceder a los campos, ya que NO sería un puntero.