int algoritmo(int nivel){
int i;
for(i=letrasUsadas[2][nivel];i<10;i++){
if(valoresUsados[i]==0){
valoresUsados[i]=1;
letras[letrasUsadas[0][nivel]]=i;
if(letrasUsadas[1][nivel]==0){
algoritmo(nivel+1);
}
else{
if(verificaSolucao(letrasUsadas[1][nivel])==1){
//printf("nivel: %d nletras: %d\n",nivel,nLetras-1);
if(nivel==nLetras-1){
existeSolucao=1;
trataSolucao();
}
else{
algoritmo(nivel+1);
}
}
}
valoresUsados[i]=0;
}
}
return 0;
}
int algoritmo(int inicio){
nodeptr aux;
visitados[inicio]=1;
aux=listaAdj[inicio];
char temp[10];
sprintf(temp,"%d",inicio);
strcat(sol,temp);
strcat(sol," ");
printf("SOL:%s\n",sol);
if(strlen(sol)>sols[actual]){
sols[actual]=strlen(sol);
if(strlen(sol)>max){
free(auxiliar);
auxiliar=(char*)malloc(sizeof(char)*strlen(sol));
strcpy(auxiliar,sol);
max=strlen(sol);
}
}
while(aux!=NULL){
if(visitados[aux->num]==0){
algoritmo(aux->num);
}
aux=aux->next;
}
int i;
for(i=0;i<strlen(temp);i++){
sol[strlen(sol)-i-2]='\0';
}
return 0;
}
/*baseado em http://www.ugrad.cs.ubc.ca/~cs490/sec202/notes/flow/Flow%20Intro.pdf*/
int algoritmo(int actual, int fluxoActual){
if(actual==noFinal-1){
return fluxoActual;
}
vistos[actual]=1;
int i;
for(i=0;i<noFinal;i++){
if(vistos[i]!=1 && capacidade[actual][i]>0){
printf("[%d][%d]\n",actual,i);
int amt;
if(fluxoActual>capacidade[actual][i]){
amt=capacidade[actual][i];
}
else{
amt=fluxoActual;
}
int fluxo=algoritmo(i,amt);
if(fluxo>0){
capacidade[actual][i]-=fluxo;
capacidade[i][actual]+=fluxo;
return fluxo;
}
}
}
return 0;
}
void algoritmo(int soma, int metade, int tamanho, List* partition1, List* partition2, List* listaDeNumeros, int index)
{
if (soma > metade)
return;
if (soma == metade)
{
qtdResult++;
printf("---------------------------------------------\n");
print(partition1);
print(partition2);
printf("---------------------------------------------\n");
return;
}
int i;
int val;
List copySet1;
List copySet2;
for (i = index; i < tamanho; i++)
{
copySet1 = copy(partition1);
copySet2 = copy(partition2);
val = getVal(listaDeNumeros, i);
copySet1.head = addToList(©Set1, val, true);
del(©Set2, val);
algoritmo(soma + val, metade, tamanho, ©Set1, ©Set2, listaDeNumeros, i + 1);
destroy(©Set1);
destroy(©Set2);
}
}
int algoritmo(int nivel){
int i;
/*o for comeca na mascara de cada letra(ou seja ou em 1 ou 0 conforme essa letra tenha sido uma primeira letra de uma palavra ou nao)*/
//i= valor que se vai dar a letra desse nivel
for(i=letrasUsadas[2][nivel];i<10;i++){
/*se o valor escolhido ainda nao tiver sido usado*/
if(valoresUsados[i]==0){
/*marca-se o valor como usado*/
valoresUsados[i]=1;
/*a letra recebe o valor escolhido no array que contem todo o alfabeto*/
letras[letrasUsadas[0][nivel]]=i;
/*se ate esta letra nao se conseguir fazer nenhum somatorio de uma coluna, entao continuar a recursao*/
if(letrasUsadas[1][nivel]==0){
algoritmo(nivel+1);
}
/*se ja se conseguir fazer a soma de colunas, então irei testar*/
else{
/*se se verificar o somatorio das colunas*/
if(verificaSolucao(letrasUsadas[1][nivel])==1){
/*verificar se é o ultimo nivel. como verificou todas as colunas, entao é uma solucao e vai tratar dessa solucao*/
if(nivel==nLetras-1){
existeSolucao=1;
trataSolucao();
contador++;
}
/*se nao for o ultimo nivel(letra diferente),entao continua a recursao*/
else{
algoritmo(nivel+1);
}
}
/*se nao verificar solucao da coluna, entao vou desmarcar(por a 0) o valor usado para esta letra e retorno 0
á recursao anterior que irá testar outro valor para este nivel*/
}
valoresUsados[i]=0;
}
}
return 0;
}
int main(){
FILE *stdin=fopen("input.txt","r");
int i;
while(fscanf(stdin, "%d %d %d", &n,&rapazes,&raparigas)!=-1){
noFinal=rapazes+raparigas+2;
noInicial=0;
fscanf(stdin,"%d %d",&nDancasIndiv,&nDancasPar);
capacidade=(int**)malloc(noFinal*sizeof(int*));
for(i=0;i<noFinal;i++){
capacidade[i]=(int*)calloc(noFinal,sizeof(int));
}
int rapaz,rapariga;
for(i=0;i<n;i++){
fscanf(stdin,"%d %d",&rapaz,&rapariga);
capacidade[rapaz][rapariga+rapazes]=nDancasPar;
}
for(i=1;i<rapazes+1;i++) capacidade[0][i]=nDancasIndiv;
for(i=rapazes+1;i<noFinal-1;i++)capacidade[i][noFinal-1]=nDancasIndiv;
int j;
for(i=0;i<noFinal;i++){
for(j=0;j<noFinal;j++){
printf(" %d",capacidade[i][j]);
}
puts("");
}
int maxFluxo=0,fluxo=1;
while(fluxo>0){
vistos=(int*)calloc(noFinal,sizeof(int));
fluxo=algoritmo(noInicial,99999999);
maxFluxo+=fluxo;
free(vistos);
}
for(i=0;i<noFinal;i++){
for(j=0;j<noFinal;j++){
printf(" %d",capacidade[i][j]);
}
puts("");
}
printf("%d\n",maxFluxo);
}
return 0;
}
int main(int argc, const char *argv[])
{
int i;
int soma = 0;
int tamanho = argc - 1;
List list;
initializeList(&list);
for (i = 1; i < argc; i++)
{
list.head = addToList(&list, atoi(argv[i]), true);
soma += atoi(argv[i]);
}
printf("Conjunto: ");
print(&list);
if (soma%2 == 0)
{
int metade = soma / 2;
if (max(&list) <= metade)
{
List partition1;
initializeList(&partition1);
int val = getVal(&list, 0);
partition1.head = addToList(&partition1, val, true);
List partition2;
partition2 = copy(&list);
del(&partition2, val);
algoritmo(0 + val, metade, tamanho, &partition1, &partition2, &list, 1);
destroy(&list);
destroy(&partition1);
destroy(&partition2);
printf("Quantidade de resultados: %d\n", qtdResult);
}
else
{
printf("Não foi encontrado\n");
destroy(&list);
}
}
else
{
printf("Não foi encontrado\n");
destroy(&list);
}
return 0;
}
int main(){
FILE *stdin=fopen("input.txt","r");
fscanf(stdin, "%d", &n);
listaAdj=(nodeptr*)malloc((n+1)*sizeof(nodeptr));
visitados=(int*)calloc((n+1),sizeof(int));
int i;
int a,b;
for(i=0;i<=n;i++){
listaAdj[i]=NULL;
}
/*construir a lista de adjancencia*/
while(fscanf(stdin,"%d %d\n",&a,&b)!=-1){
nodeptr input,aux;
input=(nodeptr)malloc(sizeof(struct node));
input->num=b;
aux=listaAdj[a];
if(aux==NULL)
listaAdj[a]=input;
else
{
while(aux->next!=NULL)
aux=aux->next;
aux->next=input;
}
input=(nodeptr)malloc(sizeof(struct node));
input->num=a;
aux=listaAdj[b];
if(aux==NULL)
listaAdj[b]=input;
else
{
while(aux->next!=NULL)
aux=aux->next;
aux->next=input;
}
}
nodeptr temp;
/*
for (i = 1; i <=n; i++){
printf("Head[%d]->",i);
temp = listaAdj[i];
while(temp != NULL){
printf("%d ",temp->num);
temp = temp->next;
}
printf("\n");
}
*/
sol=(char*)malloc(sizeof(char)*1000);
sols=(int*)calloc((n+1),sizeof(int));
int j;
for(i=1;i<=n;i++){
actual=i;
solucoesLinha=1;
algoritmo(i);
for(j=0;j<=n;j++)visitados[j]=0;
}
if(strlen(auxiliar)%2==0){
printf("Shortest: %c %c",auxiliar[(strlen(auxiliar)/2)-2],auxiliar[(strlen(auxiliar)/2)]);
}
else{
printf("Shortest: %c",auxiliar[(strlen(auxiliar)/2)]);
}
printf("\n");
printf("Tallest:");
for(i=0;i<=n+1;i++){
if(sols[i]==max){
printf(" %d",i);
}
}
puts("");
return 0;
}
int main(){
FILE *stdin=fopen("input.txt","r");
int ultimoInput=0;
while(fscanf(stdin, "%d %d", &a,&b)!=-1){
if(ultimoInput==1){
printf("\n");
}
char aux;
fscanf(stdin,"%c",&aux);
int i,j;
nLetras=0;
existeSolucao=0;
contador=0;
palavras=(char**)malloc(sizeof(char*)*a);
letras=(int*)malloc(sizeof(int)*26);
for(i=0;i<26;i++){
letras[i]=-1;
}
for(i=0;i<a;i++){
palavras[i]=(char*)malloc(sizeof(char)*b);
}
int ascii;
//construcao
for(i=0;i<a;i++){
for(j=0;j<b;j++){
fscanf(stdin,"%c",&palavras[i][j]);
//valor da letra no abcedario
ascii=palavras[i][j]-65;
//se nao for um espaço vou marcar a letra como já usada
if(palavras[i][j]!=' '){
if(letras[ascii]==-1){
nLetras++;
letras[ascii]=0;
}
}
}
fscanf(stdin,"%c",&aux);
}
letrasUsadas=(int**)malloc(sizeof(int*)*3);
for(i=0;i<3;i++){
letrasUsadas[i]=(int*)malloc(sizeof(int)*nLetras);
}
printf("nLetras: %d\n",nLetras);
for(i=0;i<nLetras;i++){
//num letra no abc
letrasUsadas[0][i]=-1;
//num de colunas que se conseguem somar ate aquela letra
letrasUsadas[1][i]=0;
//mascara para verificar se a letra é uma primeira letra de uma palavra pois esta nao pode ser zero
letrasUsadas[2][i]=0;
}
int k;
int totalLetrasDiferentes=0;
int colunas=0;
/*letras usadas*/
/*permite saber quantas colunas é possivel somar com n letras diferentes*/
//percorrer todas as colunas desde o fim
for(i=b-1;i>=0;i--){
//linha a linha de cada coluna
for(j=0;j<a;j++){
//ate a letra ser diferente do espaço
if(palavras[j][i]!=' '){
//ver se a letra a verificar já se encontra nas usadas
for(k=0;k<nLetras;k++){
//se ja tiver sido usada break
if(letrasUsadas[0][k]==palavras[j][i]-65){
break;
}
//se nao, adiciona-se e incrementa-se o valor de letras diferentes.
else if(letrasUsadas[0][k]==-1){
letrasUsadas[0][k]=palavras[j][i]-65;
totalLetrasDiferentes++;
break;
}
}
}
}
colunas++;
/*numero de colunas que se conseguem somar com n letrasDiferentes*/
letrasUsadas[1][totalLetrasDiferentes-1]=colunas;
printf("com %d letras diferentes é possivel somar %d colunas\n",totalLetrasDiferentes,colunas);
}
printf("letrasDiferentes: %d\n",totalLetrasDiferentes);
/*primeira letra de cada palavra vai ser preenchida a 1*/
//tem de se fazer o duplo for para encontrar até deixar de ser um espaço
//isto e feito porque a primeira letra de cada palavra nao pode ser zero!!!
for(i=0;i<a;i++){
for(j=0;j<b;j++){
if(palavras[i][j]!=' '){
for(k=0;k<nLetras;k++){
if(letrasUsadas[0][k]==palavras[i][j]-65){
letrasUsadas[2][k]=1;
break;
}
}
break;
}
}
}
/*array que vai manter o tracking de que valores estão a ser usados à medida que se vai fazendo a recursão, isto pois uma letra nao pode ter valor
igual a outra letra*/
//valores usados para dar às letras entre 0 e 10
valoresUsados=(int*)calloc(10,sizeof(int));
/*strings que vao guardar os resultados*/
arrayResultados=(char**)malloc(sizeof(char*)*1000);
for(i=0;i<1000;i++){
arrayResultados[i]=(char*)malloc(sizeof(char)*nLetras);
}
algoritmo(0);
qsort(arrayResultados, contador, sizeof(char*), cstring_cmp);
char *letrasUsadasOrdenadas;
letrasUsadasOrdenadas=(char*)malloc(sizeof(char)*nLetras);
for(i=0;i<26;i++){
if(letras[i]!=-1){
letrasUsadasOrdenadas[j]=i+65;
j++;
}
}
if(existeSolucao==0){
printf("No solution!\n");
}
else{
for(i=0;i<contador;i++){
for(j=0;j<nLetras;j++){
if(j!=nLetras-1)printf("%c=%c ",letrasUsadasOrdenadas[j],arrayResultados[i][j]);
else printf("%c=%c",letrasUsadasOrdenadas[j],arrayResultados[i][j]);
}
printf("\n");
}
}
ultimoInput=1;
free(palavras);
free(letrasUsadas);
free(letras);
free(valoresUsados);
free(arrayResultados);
}
return 0;
}
int main (int argc, char* argv[]){
//Primero se debe definir un parser que lee desde la linea de comandos o un archivo
eoParser parser(argc, argv);
//Se definen los parametros, se leen desde el parser y le asigna el valor
//Datos necesarios del escenario de prueba
double _min = parser.createParam((double)(0.0), "ValorMinimo", "Delimitacion area de trabajo",'M',"Parametros Escenario").value();
double _max = parser.createParam((double)(20.0), "ValorMaximo", "Delimitacion area de trabajo",'S',"Parametros Escenario").value();
unsigned int NoAnclas = parser.createParam((unsigned int)(10), "Anclas", "Numero de nodos anclas",'A',"Parametros Escenario").value();
unsigned int nodos = parser.createParam((unsigned int)(100), "Nodos", "Total de nodos",'N',"Parametros Escenario").value();
double radio = parser.createParam((double)(5), "Radio", "Radio de comunicacion",'R',"Parametros Escenario").value();
double DisReal[200][200];
double vecAnclas[NoAnclas*2];
//Configuracion parametros algoritmo
unsigned int POP_SIZE = parser.createParam((unsigned int)(100), "PopSize", "Tamano de la poblacion",'P',"Parametros Algoritmo").value();
unsigned int numberGeneration = parser.createParam((unsigned int)(1000), "MaxGen", "Criterio de parada, Numero maximo de generaciones",'G',"Parametros Algoritmo").value();
unsigned int Nc = parser.createParam((unsigned int)(2), "Nc", "Constante del operador SBX",'C',"Parametros Algoritmo").value();
double Pcruza = parser.createParam((double)(0.87), "Pcruza", "Probabilidad de cruzamiento SBX",'X',"Parametros Algoritmo").value();
double Pmutation = parser.createParam((double)(0.85), "Pmutacion", "Probabilidad de mutacion de la encapsulacion de SVN y Swap",'Y',"Parametros Algoritmo").value();
double Pmutation1 = parser.createParam((double)(0.85), "Pmutacion1", "Probabilidad de mutacion de SVN",'Z',"Parametros Algoritmo").value();
double Pmutation2 = parser.createParam((double)(0.5), "Pmutacion2", "Probabilidad de mutacion de Swap",'W',"Parametros Algoritmo").value();
double sizeTorneo = parser.createParam((double)(8), "SizeTorneo", "Tamano del torneo para seleccion de individuos",'L',"Parametros Algoritmo").value();
double sizeElist = parser.createParam((double)(2), "SizeElist", "Cantidad de individuos que se conservan",'B',"Parametros Algoritmo").value();
double sizeTorneo1 = parser.createParam((double)(2), "SizeTorneo1", "Tamano del torneo para seleccion de individuos del elitismo",'Q',"Parametros Algoritmo").value();
//Parametros de guardado
unsigned int setGeneracion = parser.createParam((unsigned int)(100), "setGeneracion", "Cada cuantas generaciones se guarda la poblacion",'T',"Guardar Datos").value();
unsigned int setTime = parser.createParam((unsigned int)(0), "setTime", "Cada cuantos segundos se guarda la configuracion",'I',"Guardar Datos").value();
//Grafica
std::string InPut = parser.createParam(std::string("Estadistica.txt"), "Input", "Archivo que contiene el Fitness, Media, DevStand",'o',"Salida - Grafica").value();
bool graficaGnuplot = parser.createParam((bool)(0), "Gnuplot", "Grafica el Fitness y Media, 0 desactivado y 1 activado",'g',"Salida - Grafica").value();
//Termina la ejecucion al consultar la ayuda
if (parser.userNeedsHelp())
{
parser.printHelp(std::cout);
exit(1);
}
//Verifica el ingreso de las probabilidades
if ( (Pcruza < 0) || (Pcruza > 1) ) throw std::runtime_error("Pcruza Invalido");
if ( (Pmutation < 0) || (Pmutation > 1) ) throw std::runtime_error("Pmutation encapsulación Invalido");
if ( (Pmutation1 < 0) || (Pmutation1 > 1) ) throw std::runtime_error("Pmutation de SVN Invalido");
if ( (Pmutation2 < 0) || (Pmutation2 > 1) ) throw std::runtime_error("Pmutation de Swap Invalido");
//Parametro de tiempo
struct timeval ti, tf;
double tiempo;
/**CARGAR EL ESCENARIO**/
//Escenario
//Lee desde archivo
escenario *pEscenario = new escenario(nodos, NoAnclas);
//Matriz de distancia
for (int i=0; i<nodos ; i++)
{for (int j=0; j<nodos; j++)DisReal[i][j] = pEscenario->obtenerDisRSSI(i,j);}
//Posicion Nodos anclas
for (int i=0 ; i<NoAnclas*2 ; i++)vecAnclas[i] = pEscenario->obtenerAnclas(i);
/**--------------------------------------------------------------**/
//Define la representación (Individuo)
Individuo cromosoma;
//Para la inicialización del cromosoma, primero se debe definir como se generaran los genes
//Se utilizara un generador uniforme, (valor min, valor max)
eoUniformGenerator<double> uGen(_min, _max);
//Crear el inicializador para los cromosomas, llamado random
IndiInit random(nodos*2,uGen);
//Generar una subclase de la clase de la función de evaluación
localizacionEvalPenal Fitness;
//Criterio de parada
eoGenContinue<Individuo> parada(numberGeneration);
//Es otro criterio de parada en el cual se define el minimo de generaciones y cuantas generaciones sin mejoras
//eoSteadyFitContinue<Individuo> parada(10,2);
/** CRUZA **/
// Generar los limites para cada gen
std::vector<double> min_b;
std::vector<double> max_b;
for(int i=0; i<nodos*2; i++) {
min_b.push_back(_min);
max_b.push_back(_max);
}
eoRealVectorBounds bounds(min_b, max_b);
//Inicializar operador de cruce SBX
individuoCruza crossover(bounds, Nc);
//Cargar cantidad nodos anclas al operador
crossover.setNoAnclas(NoAnclas);
/** MUTACION **/
//Subclase de mutacion paper IEEE
individuoMutacion mutationA(NoAnclas,numberGeneration,nodos,_min,_max);
//Mutacion incluida en EO, permite llegar mas rapido a un fitness de 600
individuoMutacion0 mutationB;
//Combina operadores de mutacion con su respectivo peso
eoPropCombinedMonOp<Individuo> mutation(mutationA,Pmutation1);
mutation.add(mutationB, Pmutation2);
//Define un objeto de encapsulación (it contains, the crossover, the crossover rate, the mutation and the mutation rate) -> 1 line
eoSGATransform<Individuo> encapsulacion(crossover, Pcruza, mutation, Pmutation); //0.87
//Define el método de selección, selecciona un individuo por cada torneo (en el parentesis se define el tamaño del torneo)
eoDetTournamentSelect<Individuo> torneo(sizeTorneo);
//Define un "eoSelectPerc" con el torneo como parametro por defecto (permite seleccionar el mejor individuo)
eoSelectPerc<Individuo> seleccion(torneo);
//Define una estrategia de reemplazo por cada generación
//eoGenerationalReplacement<Individuo> reemplazo;
////Otra estrategia de reemplazo con elitismo
eoElitism<Individuo> reemplazo(sizeElist,false); //antes 0.6
//Para utilizar eoElitism se define un eoDetTournamentTruncate para seleccionar los individuos para el elitismo
eoDetTournamentTruncate<Individuo> Trunca(sizeTorneo1);// antes 2
//Define una poblacion de Individuos
eoPop<Individuo> poblacion;
//Cargar la matriz de distancias, cantidad nodos anclas y total de nodos
Fitness.guardarDisReal(DisReal, NoAnclas, nodos, radio);
//Cargar posiciones nodos anclas
Fitness.guardarAnclas(vecAnclas);
//Llena la población y evalua cada cromosoma
for(int i=0 ; i<POP_SIZE ; i++)
{
random(cromosoma);
Fitness(cromosoma);
poblacion.push_back(cromosoma);
}
//Imprime la población
//poblacion.printOn(std::cout);
//Imprime un salto de linea
std::cout<< std::endl;
//Contenedor de clases
eoCheckPoint<Individuo> PuntoChequeo(parada);
//Cargar el valor de la generacion actual al operador de mutación
//Se inicializa el contador de generaciones
eoIncrementorParam<unsigned> generationCounter("Gen.");
//Se carga el contador de generaciones al operador de mutación
mutationA.setGen(& generationCounter);
//Se carga el contador de generaciones al objeto eoCheckpoint para contar el número de generaciones
PuntoChequeo.add(generationCounter);
/** Guardar datos de la población en archivos **/
//Genera un archivo para guardar parametros
eoState estado;
//Guardar todo lo que necesites a la clase hija estado
estado.registerObject(poblacion);
//estado.registerObject(parser);
//Guarda el tiempo de ejecucion desde la primera generacion
eoTimeCounter time;
PuntoChequeo.add(time);
//Define cada cuantas generaciones se guarda la poblacion
eoCountedStateSaver GuardarEstado(setGeneracion,estado,"generacion");
//Siempre se debe agregar a la clase hija de eoCheckPoint para que se ejecute en cada generacion
PuntoChequeo.add(GuardarEstado);
//Guardar algunas estadisticas de la poblacion
//Muestra el mejor fitness de cada generación
eoBestFitnessStat<Individuo> Elmejor("Mejor Fitness");
//La media y stdev
eoSecondMomentStats<Individuo> SegundoStat;
//Se agrega al eoCheckPoint
PuntoChequeo.add(Elmejor);
PuntoChequeo.add(SegundoStat);
// Guarda los parametros a un archivo
eoFileMonitor fileMonitor("stats.xg", " ");
PuntoChequeo.add(fileMonitor);
fileMonitor.add(generationCounter); //Numero de generaciones
fileMonitor.add(time); //Tiempo total de ejecucion desde la primera generacion
fileMonitor.add(Elmejor); //Mejor fitness
fileMonitor.add(SegundoStat); //Media y desviacion estandar
///** Grafica **/
// eoFileMonitor fileMonitor1(InPut, " ");
// fileMonitor1.add(Elmejor); //Mejor fitness
// fileMonitor1.add(SegundoStat); //Media y desviacion estandar
// PuntoChequeo.add(fileMonitor1); //Agrega al checkpoint
// GnuplotMonitor grafica(InPut,graficaGnuplot); //Grafica el fitness y la media
// grafica.setGen(& generationCounter); //Carga la generacion
// PuntoChequeo.add(grafica);
///**------------------------------------------**/
// Incializa el algoritmo genetico secuencial
eoEasyEA<Individuo> algoritmo(PuntoChequeo, Fitness, seleccion, encapsulacion, reemplazo, Trunca);
//Tiempo inicial
gettimeofday(&ti, NULL);
//Corre el algoritmo en la poblacion inicializada
algoritmo(poblacion);
//Tiempo Final
gettimeofday(&tf, NULL);
std::cout << std::endl;
//Imprime el mejor cromosoma
poblacion.best_element().printOn(std::cout);
std::cout << std::endl;
std::cout << std::endl;
//Imprime el tiempo de ejecución del algoritmo
tiempo = (tf.tv_sec - ti.tv_sec)*1000 + (tf.tv_usec - ti.tv_usec)/1000.0;
std::cout <<"Tiempo de ejecucion en milisegundos: " << tiempo << std::endl;
std::cout << std::endl;
//Se grafica el error y todos los nodos
std::string filename="generacion";
graphError error(filename, setGeneracion, numberGeneration, nodos, NoAnclas, _max);
std::cout << std::endl;
return EXIT_SUCCESS;
}
int main(){
FILE *stdin=fopen("input.txt","r");
while(fscanf(stdin, "%d %d", &a,&b)!=-1){
char aux;
fscanf(stdin,"%c",&aux);
int i,j;
nLetras=0;
existeSolucao=0;
palavras=(char**)malloc(sizeof(char*)*a);
letras=(int*)malloc(sizeof(int)*26);
for(i=0;i<26;i++){
letras[i]=-1;
}
for(i=0;i<a;i++){
palavras[i]=(char*)malloc(sizeof(char)*b);
}
int ascii;
for(i=0;i<a;i++){
for(j=0;j<b;j++){
fscanf(stdin,"%c",&palavras[i][j]);
ascii=palavras[i][j]-65;
if(palavras[i][j]!=' '){
if(letras[ascii]==-1){
nLetras++;
letras[ascii]=0;
}
}
}
fscanf(stdin,"%c",&aux);
}
letrasUsadas=(int**)malloc(sizeof(int*)*3);
for(i=0;i<3;i++){
letrasUsadas[i]=(int*)malloc(sizeof(int)*nLetras);
}
for(i=0;i<nLetras;i++){
letrasUsadas[0][i]=-1;
letrasUsadas[1][i]=0;
letrasUsadas[2][i]=0;
}
int k;
int totalLetrasDiferentes=0;
int colunas=0;
/*letras usadas*/
for(i=b-1;i>=0;i--){
for(j=0;j<a;j++){
if(palavras[j][i]!=' '){
for(k=0;k<nLetras;k++){
if(letrasUsadas[0][k]==palavras[j][i]-65){
break;
}
else if(letrasUsadas[0][k]==-1){
letrasUsadas[0][k]=palavras[j][i]-65;
totalLetrasDiferentes++;
break;
}
}
}
}
colunas++;
letrasUsadas[1][totalLetrasDiferentes-1]=colunas;
}
/*mascara*/
for(i=0;i<a;i++){
for(j=0;j<b;j++){
if(palavras[i][j]!=' '){
for(k=0;k<nLetras;k++){
if(letrasUsadas[0][k]==palavras[i][j]-65){
letrasUsadas[2][k]=1;
break;
}
}
break;
}
}
}
valoresUsados=(int*)calloc(10,sizeof(int));
/*printStuff();*/
head=NULL;
algoritmo(0);
if(existeSolucao==0){
printf("No solution!\n\n");
}
}
return 0;
}