[C]problema ricorsione

[blu1988]

ciao a tutti,
sono abbastanza disperato perchè non riesco a fare questo programma...

allora...come dati iniziali mi vengono forniti due file

file uno:
2
dsp253 1
am2901 2

in questo file il primo numero indica il numero di tipi di processore ,la stringa è il TIPO di processore e intero seguente la stringa è il numero di processori che ho di quel tipo

file due:
7
aaaa 60 am2901
yyyy 40 dsp253
zzzz 10 dsp253
xxxx 20 am2901
kkkk 40 am2901
ffff 70 am2901
hhhh 30 dsp253

in questo file il primo numero indica il numero di operazioni,la stringa(es.aaaa) indica in nome del processo,il numero indica il tempo di esecuzione e la stringa indica il tipo di processore che fa quella det operazione...

mi viene richiesto di trovare l'associazione ottima tra operazioni e processori,in maniera da minimizzare il tempo di esecuzione totale.

ad esempio devo stampare su un file

aaaa am2901 1
yyyy dsp253 1
zzzz dsp253 1
xxxx am2901 1
kkkk am2901 2
ffff am2901 2
hhhh dsp253 1

nome processo,processore che se ne occupa,quale processore se ne occupa.

questa non è la soluzione ottima infatti il tempo di esecuzione maggiore è di am2901 ed è di 110 sec..mi potete aiutare???

vi copio il mio listato per struttura dati e inserimento

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#define TIPO 20+1
#define PRO 30+1
#define MAX 255


typedef struct cpu
{
char tipo[TIPO];
int num;
int *id;
int tempo;
}cpu_t;

typedef struct process
{
char nome[PRO];
int time;
char tipo[TIPO];
}process_t;

typedef struct ass
{
char nome_p[PRO];
char tipo_p[TIPO];
int id;
}ass_t;

cpu_t* leggifile_uno(cpu_t*v,int*np);//passo anche il puntatore a numero processori
process_t* leggifile_due(process_t*vett,int *no);//e numero operazioni
int count_time(cpu_t*v,process_t*vett,int *no,int *np);
void quicksort ( process_t* vettore, int p, int no );
int partition ( process_t* vettore, int p, int r );
ass_t* cerca_soluzione(cpu_t*v , process_t*vett , int no,int np ,int passo,int max_time );





int main(int argc,char*argv[])
{
cpu_t*v=NULL;
process_t *vett=NULL;
int time_tot,np,no,i;
ass_t*sequenza;

v=leggifile_uno(v,&np);
vett=leggifile_due(vett,&no);
time_tot=count_time(v,vett,&no,&np);
printf("\n%d\n",time_tot);
quicksort(vett, 0, no-1);

for(i=0;i<no;i++)
{
printf("%s %s\n",vett[i].nome,vett[i].tipo);
}

sequenza=cerca_soluzione(v,vett,no,np,0,0);
return 0;
}

cpu_t* leggifile_uno(cpu_t*v,int *np)
{
FILE *fp;
char stringa[MAX];
int i,j;

printf("Inserisci nome file uno--> \n");
scanf("%s",stringa);
fp=fopen(stringa,"r");
if (fp==NULL)
{
printf("ERRORE apertura file 1\n");
exit(EXIT_FAILURE);
}

fscanf(fp,"%d",np);

v=(cpu_t*)malloc((*np)*sizeof(cpu_t));
if(v==NULL)
{
printf("ERRORE allocazione vettore cpu_t\n");
exit(EXIT_FAILURE);
}
for(i=0;i<(*np);i++)
{
fscanf(fp,"%s %d",v[i].tipo,&v[i].num);
v[i].id=(int*)malloc(v[i].num*sizeof(int));
if(v[i].id==NULL)
{
printf("ERRORE allocazione cpu_t id\n");
exit(EXIT_FAILURE);
}
for(j=0;j<v[i].num;j++)
{
v[i].id[j]=0;
}

}
fclose(fp);
return(v);
}

process_t* leggifile_due(process_t*vett,int *no)
{
FILE *fp;
char stringa[MAX];
int i;

printf("Inserisci nome file due--> \n");
scanf("%s",stringa);

fp=fopen(stringa,"r");
if(fp==NULL)
{
printf("ERRORE apertura file due\n");
exit(EXIT_FAILURE);
}

fscanf(fp,"%d",no);

vett=(process_t*)malloc((*no)*sizeof(process_t));
if(vett==NULL)
{
printf("ERRORE allocazione vettore process_t\n");
exit(EXIT_FAILURE);
}
for(i=0;i<(*no);i++)
{
fscanf(fp,"%s %d %s",vett[i].nome,&vett[i].time,vett[i].tipo);
}
fclose(fp);
return(vett);
}


int count_time(cpu_t*v,process_t*vett,int *no,int *np)
{
FILE *fp;
char stringa[MAX];
ass_t temp;
int i,j,t=0;

printf("Inserire nome file tre--> \n");
scanf("%s",stringa);

fp=fopen(stringa,"r");
if(fp==NULL)
{
printf("ERRORE apertura file 3\n");
exit(EXIT_FAILURE);
}

while(fscanf(fp,"%s %s %d",temp.nome_p,temp.tipo_p,&temp.id)!=EOF)
{
for(i=0;i<(*no);i++)
{
if(strcmp(vett[i].nome,temp.nome_p)==0)
{
for(j=0;j<(*np);j++)
{
if(strcmp(v[j].tipo,vett[i].tipo)==0)
v[j].id[temp.id-1]+=vett[i].time;
}
}
}
}

for(i=0;i<(*np);i++)
{
for(j=0;j<(v[i].num);j++)
{
if(v[i].id[j]>t)
t=v[i].id[j];
}
}
fclose(fp);
return(t);

}

void quicksort ( process_t* vettore, int p, int no )
{
int q;
if (p < no)
{
q = partition(vettore, p, no);
quicksort(vettore, p, q);
quicksort(vettore, q+1, no);
}
return;
}

int partition ( process_t*vettore, int p, int r )
{
int i, j;
char *x;
process_t temp;
x =strdup(vettore[p].tipo); i=p-1; j=r+1;
while (i < j)
{
while(strcmp(vettore[--j].tipo, x)>0);
while(strcmp(vettore[++i].tipo, x)<0);
if (i<j)
{
temp = vettore[i];
vettore[i] = vettore[j];
vettore[j] = temp;
}
}
return(j);
}