Mensajes

Venía así definida.
Muchas gracias ya me han ayudado 

Hola!
Estoy atascada en la realización de un ejercicio de Haskell.
Se trata de una operación que obtiene una lista con todos los elementos que NO son adyacentes a un nodo dado.
Luego hay que hacer otra función que añada un arco entre dicho nodo y cada uno de sus no adyacentes.

Esto es lo que yo he intentado hacer para la lista de no adyacentes, no sé si estará bien, ¿me lo podéis revisar?:

Código [Seleccionar] Expandir

data Grafo a = GVacio | Nodo a (Grafo a) | Arco a a (Grafo a) deriving (Show, Eq)

adyacentes :: (Eq a) => a -> a -> Grafo a -> Bool
adyacentes x y (Arco u v g) = x==u && y==v || x==v && y==u || adyacentes x y g
adyacentes _ _ _ = False

noadylista :: (Eq a) => Grafo a -> a -> [a]
noadylista GVacio _ = []
noadylista (Arco x y g) a = if ((adyacentes a x g))
                                       then (noadylista (Nodo y g) a)
                                      else x:(noadylista (Nodo y g) a)

La parte de poner el arco sí que no sé como hacerla...
¿Alguien me puede dar la idea?
Muchas gracias de antemano

Alguien me ayuda?

De acuerdo. Aquí está lo que he hecho hasta ahora. Obviamente, está mal, seguro que es una catástrofe.
He ido añadiendo y quitando cosas y ya no sé por donde cogerlo.
Como está tan mal, por eso pedía el código, no creo que el mío tenga arreglo fácil...

Código [Seleccionar] Expandir


#include <stdio.h>
#include <math.h>
#define length(x) (sizeof(x)/sizeof(x[0]))


static int V[]={1,2,3,4},aux[]={0,0,0,0},ex[]={}; //ex: vector que contiene al ultimo elemento expandido
//aux: deberia contener los elementos del subconjunto al que se le debe aplicar la funcion suma

int factorial(int M){
   int num=M;
   int factor = 1;
   while (num > 0){
       factor = num * factor;
       num--;
   }
   return factor;
}
int suma(){
 
   int sum=0,j=0;
   
   while (j<length(aux)){
       sum=sum+aux[j];
       j++;      
   }
   return sum;
}

int main() {
   
   int S=5,i=0,T=0,cont=0,j,b=0,ncomb=0,k,v;
   int nc[]={0,0,0,0}; //vector que contiene el numero de combinaciones para subconjuntos de 1,2,3 y 4 elementos
   
    for (k=1;k<=length(V);k++){
       ncomb=factorial(length(V))/(factorial(k)*factorial(length(V)-k));
       printf("Numero de combinaciones con %d elementos: %d\n",k,ncomb);
       nc[k-1]=ncomb;
     }
   
   do{
       
       v=length(V);
  if(T>v || suma()>S){ //Nodo fracaso
     
      aux[i]=0;
      i--;
      T--;
      nc[k]=nc[k-1];
  }
  else if(suma()==S){ // nodo solución
     
      cont++;
      aux[i]=0;
      i--;
      T--;
      nc[k]=nc[k-1];
  }
       
       if(suma()<S) //nodo problema
       {
           T++;
           i++;
       }
 
  if(i==1 && aux[0]==V[length(V)-1]){ //Nodo solucion
      printf("Nº de soluciones %d\n",cont);
      b=1;
      exit(1);
  }
     
      ex[i]=V[i];
 
   for(j=0;j<i;j++){
       aux[j]=V[j];
       aux[i-1]=ex[i+1]++;
   }
   
   }while(b==0);
   
}







El árbol que había pensado sería el siguiente, pero si se os ocurre otro más fácil agradezco todo lo que me digáis:




Es el árbol de ejemplo que me he hecho para aclararme, pero el programa debe valer para cualquier vector de n enteros positivos.


Edito: No me he dado cuenta que falta la línea de 3 a 3,4 en el árbol.

Perdona, no sabía que había un subforo.
Lo de haber hecho pruebas ya lo he puesto en la explicación de mi problema. He estado haciendo pruebas y no lo he podido conseguir, por eso acudo al foro.
Saludos a ti también.

Buenas tardes.
Tengo que implementar en lenguaje C un programa que haga lo siguiente:

Dado un conjunto de N números enteros positivos ordenados de menor a mayor y un número S también entero positivo, dar el número de subconjuntos cuya suma sea S, usando la técnica de Vuelta Atrás (Backtracking).

Le estoy dando muchas vueltas y no consigo dar con la solución, también he buscado por internet y he encontrado muchas soluciones, pero están en C++, Pascal, etc. y no sé pasar de un lenguaje a otro.

Por favor, ¿alguien podría implementar este programa por mi y darme el código, de la forma más sencilla posible?
Se lo agradecería muchísimo...

Sí, a mi se me ocurrió la misma forma, pero no sé cómo implementarla, por eso lo pregunté aquí

Hola! Necesito ayuda... tengo que hacer un programa, y lo primero de todo es ordenar un array, pero no tengo idea de cómo hacerlo...

Me dan un array N con números enteros ordenados de menor a mayor, y un número M.
Se trata de reordenar el array de manera que queden ordenados del más cercano a M hasta el más alejado.


Por ejemplo:

Tengo un array N[]={0,2,3,5,7,10}
Y un número M=3;
Al final quedaría de esta forma: N[]={3,2,5,0,7,10}

Gracias de antemano!!