Race - mi serve aiuto

non capisco perchè mi dà 0 punti quando il programma a me sembra funzionare e nei primi primi 2 testcase il risultato è corretto mentre negli altri no. sapetedirmi dove si trova l’errore?
grazie in anticipo.

    #include<iostream>
    #include<fstream>
    using namespace std;

    struct pilota{
        int a;
        int b;
        int tot;
        int pos;
    };
    void quickSort(pilota v[],int inf,int sup){
        int s,i,p;
        pilota t;
        if(inf<sup){
            i=inf;
            s=sup;
            p=v[sup].tot;
            do{
                while(i<s && v[i].tot>=p)
                    i++;
                while(s>i && v[s].tot<=p)
                    s--;
                if(i<s){
                    t=v[i];
                    v[i]=v[s];
                    v[s]=t;
                }
            }while(i<s);
            t=v[i];
            v[i]=v[sup];
            v[sup]=t;
            quickSort(v,inf,i-1);
            quickSort(v,i+1,sup);
        }
    }
    void riordina(pilota v[],int dim){
        if(v[dim/2-1].tot==v[dim/2].tot){
            bool uguali=true;
            int k=dim/2;
            while(uguali){
                if(v[dim/2-1].tot==v[k].tot){
                    if(v[dim/2-1].b<v[k].b){
                        pilota t=v[dim/2-1];
                        v[dim/2-1]=v[k];
                        v[k]=t;
                    }
                    else{
                        uguali=false;
                    }
                }
            }
        }
    }
    int main(){
        fstream input,output;
        int dim;
        input>>dim;
        pilota vet[dim];
        for(int i=0;i<dim;i++){
            input>>vet[i].a;
            input>>vet[i].b;
            vet[i].tot=vet[i].a+vet[i].b;
            vet[i].pos=i;
        }
        while(dim>1){
            quickSort(vet,0,dim-1);
            riordina(vet,dim);
            dim/=2;
            for(int i=0;i<dim;i++){
                vet[i].tot+=vet[i].b;
            }
        }
        output.open("output.txt",ios::out);
        output<<vet[0].pos;
        return 0;
    } input.open("race.input1.txt",ios::in);
        int dim;
        input>>dim;
        pilota vet[dim];
        for(int i=0;i<dim;i++){
            input>>vet[i].a;
            input>>vet[i].b;
            vet[i].tot=vet[i].a+vet[i].b;
            vet[i].pos=i;
        }
        while(dim>1){
            quickSort(vet,0,dim-1);
            riordina(vet,dim);
            dim/=2;
            for(int i=0;i<dim;i++){
                vet[i].tot+=vet[i].b;
            }
        }
        output.open("output.txt",ios::out);
        output<<vet[0].pos;
        return 0;
    }

Non capisco bene come quello possa essere il tuo codice, assumerò che sia questo:

    #include<iostream>
    #include<fstream>
    using namespace std;

    struct pilota{
        int a;
        int b;
        int tot;
        int pos;
    };
    void quickSort(pilota v[],int inf,int sup){
        int s,i,p;
        pilota t;
        if(inf<sup){
            i=inf;
            s=sup;
            p=v[sup].tot;
            do{
                while(i<s && v[i].tot>=p)
                    i++;
                while(s>i && v[s].tot<=p)
                    s--;
                if(i<s){
                    t=v[i];
                    v[i]=v[s];
                    v[s]=t;
                }
            }while(i<s);
            t=v[i];
            v[i]=v[sup];
            v[sup]=t;
            quickSort(v,inf,i-1);
            quickSort(v,i+1,sup);
        }
    }
    void riordina(pilota v[],int dim){
        if(v[dim/2-1].tot==v[dim/2].tot){
            bool uguali=true;
            int k=dim/2;
            while(uguali){
                if(v[dim/2-1].tot==v[k].tot){
                    if(v[dim/2-1].b<v[k].b){
                        pilota t=v[dim/2-1];
                        v[dim/2-1]=v[k];
                        v[k]=t;
                    }
                    else{
                        uguali=false;
                    }
                }
            }
        }
    }
    int main(){
        fstream input,output;
        input.open("input.txt",ios::in);
        int dim;
        input>>dim;
        pilota vet[dim];
        for(int i=0;i<dim;i++){
            input>>vet[i].a;
            input>>vet[i].b;
            vet[i].tot=vet[i].a+vet[i].b;
            vet[i].pos=i;
        }
        while(dim>1){
            quickSort(vet,0,dim-1);
            riordina(vet,dim);
            dim/=2;
            for(int i=0;i<dim;i++){
                vet[i].tot+=vet[i].b;
            }
        }
        output.open("output.txt",ios::out);
        output<<vet[0].pos;
        return 0;
    }

Detto ciò il codice credo sia giusto, il problema è che esce dal limite di tempo, questo è quasi sicuramente dovuto al fatto che un’implementazione del quicksort “fatta in casa” è di gran lunga più lenta del sort preimplementato nella libreria algoritm, se posso suggerire una modifica:

#include<iostream>
#include<fstream>
#include<algorithm>
using namespace std;

struct pilota{
    int a;
    int b;
    int tot;
    int pos;
    bool operator<(const pilota& a)const&{
        if(tot!=a.tot)return tot>a.tot;
        else return b>a.b;
    }
};

int main(){
    fstream input,output;
    input.open("input.txt",ios::in);
    int dim;
    input>>dim;
    pilota vet[dim];
    for(int i=0;i<dim;i++){
        input>>vet[i].a;
        input>>vet[i].b;
        vet[i].tot=vet[i].a+vet[i].b;
        vet[i].pos=i;
    }
    while(dim>1){
        sort(vet,vet+dim);
        dim/=2;
        for(int i=0;i<dim;i++){
            vet[i].tot+=vet[i].b;
        }
    }
    output.open("output.txt",ios::out);
    output<<vet[0].pos;
    return 0;
}    

Grazie del consiglio ma anche utilizzando il sort della libreria algoritm il codice fallisce tutti i testcase, tranne il primo, dando come risultato che l’output non è corretto. non riesco a capire dove sia l’errore nel codice.

1 Mi Piace

Potresti inviare di nuovo il codice? È un po’ difficile risolvere così :sweat_smile:

Il codice è questo,grazie al tuo consiglio di utilizzare il sort della libreria algorithm sono riuscito a risolvere il problema :slight_smile:.

#include<iostream>
#include<fstream>
#include<algorithm>
using namespace std;

struct pilota{
    int a;
    int b;
    int tot;
    int pos;
    bool operator<(const pilota& a)const&{
        if(tot!=a.tot)return tot>a.tot;
        else return pos>a.pos;
    }
};
int main(){
    fstream input,output;
    input.open("race.input0.txt",ios::in);
    int dim;
    input>>dim;
    pilota vet[dim];
    for(int i=0;i<dim;i++){
        input>>vet[i].a;
        input>>vet[i].b;
        vet[i].tot=vet[i].a+vet[i].b;
        vet[i].pos=i;
    }
    while(dim>1){
        sort(vet,vet+dim);
        dim/=2;
        for(int i=0;i<dim;i++){
            vet[i].tot+=vet[i].b;
        }
    }
    output.open("output.txt",ios::out);
    output<<vet[0].pos;
    return 0;
}
1 Mi Piace