pare bine... dar de ce citesti numerele cu %ld cand ele sunt inturi?

Am reusit in sfarsit sa iau 100 dar cu citire cu streamuri ( cu citire in c imi crapa)... si testele par ciudate: imi crapa mozilla cand intru in ele

LE: gata... am scos 100 si cu citire in c (si 428 de ms pe cel mai mare test) cu bellman ford cu coada

http://infoarena.ro/job_detail/185953

si se pare ca sunt singurul cu c care a luat 100


deci se poate si in c

[editat de moderator: nu posta de mai multe ori consecutiv, foloseste edit]

pai depinde eu pe un array de 1 000 000 de elemente cu maximul 1 000 000 am scos asa:

qsort	1.54
sort	1.23
heapsort	1.67
bucketsort	0.97
shell	1.45

Noi astia din buc plecam cu acc de la 13 45

si te lauzi cu asta?

cum e cu iteratorii

@wefgef
nu prea stiu c++ si chestii cu push si iteratori

@amadaeus

dap. asta pt ca se foloseste evalul . campion care merge doar pe gcc vers 3.

Nup nu e de la asta. cu chestia ta iau doar 10 puncte pe testul 8. Eu bag un nod in coada de mai multe ori doar daca costul obtinut pana atunci este mai mic decat costul obtinut mai devreme, si atunci trebuie sa reactualizez si toti vecinii lui.

am implementat cu Bellman-Ford cu coada dar iau doar 30 (ok pe 1 2 si 8 , 5 wa si 2 TLE <astea se rezolva cu parsarea citirii>) si nu-mi dau seama unde crapa... ma poate ajuta cineva?

http://infoarena.ro/job_detail/183901?action=view-source

imi buseste pe testul 1... e ceva mai special?

Gata: nu mai e nevoie... am aflat. cine e interesat sa-mi dea un pm

2.
Cod:

int main() {
    ...........
}

Se intoarce implicit 0, nu e necesar sa dati voi return.

nu intoarce neaparat 0... daca esti in c++ da, dar daca esti in c iti da non-zero-exit-status

de fapt in system ("  ") poti baga orice comanda de ms dos

de ex pt clrscr :

Cod:

system ("cls");

sau pt copiere

Cod:

system("copy a.exe x.exe");

sau pt stergere

Cod:

system("del *.cpp");

pai :

un program de generator de teste random:

dai afisezi numerele random in fisierul .in (sa zicem ca gen este numit gen.exe)

sursa: (sa zicem ca este sursa.exe) care afiseaza raspunsul in nume.out

brute-force-ul care afiseaza in .ok si se numeste bf.exe (il poti baga chiar in generatorul de teste random)

si verificator care compara ok-ul generat de brute-force cu out-ul generat de sursa ta.

si daca esti pe windows(e mai simplu de cat pe linux) faci asa:

creezi un fisier .bat in care scrii asta:

Cod:

@echo off
call gen.exe
call bf.exe
call sursa.exe
call verif.exe
pause

 si il rulezi de cate ori vrei tu

mie mi-a intrat cu qsort in 204 ms deci nu cred ca e problema asta... singura smecherie e sa nu interschimbi structurile ci doar indicii (merge mai repede)

pentru inceput de ce nu le declari pe toate int ? int-ul pe gcc e la fel ca long-ul dar e posibil sa rezulte probleme de aici

cu cat ai initializat vectorul la inceput?

dar astea sunt de la ONI deci probabil s-au pastrat testele

La ONI ai evaluare pe linux (cu gcc / g++) sau pe windows cu borland

pe linux se foloseste acelasi compilator ca cel de pe ia (nu stiu exact daca aceeasi versiune dar e la fel)

pe windows e BC 3.1 care e aproximativ la fel cu TC


Incearca ca si compilatoare:

Dev C++ (e foarte bun pentru windows dar nu il ai la olimpiada) http://www.bloodshed.net/devcpp.html

sau

DJGPP http://infoarena.ro/djgpp-instalarea-de-la-a-la-z (asta e la ONI)

si incearca problemele date anul trecut de la ONI (sunt in arhiva infoarena)


spor 

e BF cu heapuri?

eu cu Bellman Ford iau doar 40 (3 TLE si 3 SIGSEGV) se poate implementa BF pt 100 ?

gigel poate da un raspuns gresit de mai multe ori?

cam asa arata implementat qsortul din stdlib

Cod:

#include <stdlib.h>
#include <memory.h>

void _RTL_FUNC quicksort(const void *base, int lo, int hi, size_t width,
						int (*compare)(const void *elem1, const void *elem2), char *buf)
{

    if (hi > lo) {
        int i=lo, j=hi;
	    char * celem = buf + width;
        memcpy(celem,((char *)base) + width * ((lo + hi) / 2),width) ;

        while (i <= j)
        {
            while (i <= hi && (*compare)((char *)base + i * width, celem) <0) i++; 
            while (j >= lo && (*compare)((char *)base + j * width, celem) >0) j--; 
            if (i<=j)
            {
			    memcpy(buf, (char *)base + i * width, width) ;
			    memcpy((char *)base + i * width, (char *)base + j * width, width) ;
			    memcpy((char *)base + j * width, buf, width) ;
                i++; j--;
            }
        }
        if (lo<j) quicksort(base, lo, j,width,compare,buf);
        if (i<hi) quicksort(base, i, hi,width,compare,buf);
    } 

}
void _RTL_FUNC qsort(const void *base, size_t num, size_t width,
						int (*compare)(const void *elem1, const void *elem2))
{
    char data[512];
	char *buf ;

    if (width <= sizeof(data)/2)
        buf = data;
    else {
        buf = malloc(width) ;
	    if (!buf)
		    return ;
    }
    
	quicksort(base,0,num-1,width, compare,buf) ;

    if (buf != data)
    	free(buf) ;
}

cam cum ar arata un quicksort cu pivot random (dau pivot=rand()%n )?

da... ai dreptate si la OJI presupun ca merge si qsortu ca n-o fi asa rau

n-ar trebui sa fie ora forumului 9 55 ? si aici zice ca e 8 55...

poi da... sortul din STL e un hibrid intre quicksort si heapsort (care daca se intampla nuj ce trece de pe quicksort pe heapsort) dar faza e ca STL-ul nu il ai la toate concursurile (doar la ONI)