Matematické Fórum

Jen doplním, že tento naivní přístup se nazývá čtyřsouvislý flood-fill.

EDIT: Zastavit je třeba také tehdy, když (v daném patře stromu) není doplněn ani jeden nový list. Může se totiž stát, že cesta z uzlu S do uzlu E vůbec neexistuje. A má se vůbec najít cesta minimální délky?

Já bych takovouto "problematiku" řešil dynamicky přes 2 rozměrné pole. (ale to je složité pro začátečníky. Ještě je taky důležité, v jakém prog. jazyku to děláš).
Budeš mít pole i*j velké. Randomem nebo jakýmkoliv způsobem se Ti nagenerují ty překážky start a cíl... Ty přesně budeš vědět, na které pozici A[i][j] se ti nachází start a kde A[i][j] cíl... Známými algoritmy budeš procházet od startu k cíli, dokud (while) nenarazíš na cíl. Potom je průchod správný. Takže v tom whilu budeš mít ještě if (který Ti bude kontrolovat jestliže si nenašel překážku) tak inkrementuj průchody. Potom můžeš mít třeba pomocí struktury všechny cesty...

Cesta. kde[0] = 6;
Cesta. kde[1] = 5;

Vím, zní to složitě, ale jednou jsem se o něco podobného pokoušel a šlapalo to... Jinak řešení, co napsal Dargorar není těžké a je to základní algoritmus pro tvůj problém. Logicky by jsi na něj přišel i ty sám.

↑ musixx:

Neumím psát a vyjadřovat se. Nikdy jsem nepotřeboval zkoušet známé algoritmy. :-)) Na každou problematiku si přijdu sám, logicky. ;-)

Pokud si myslíš, že by to takto řešit nešlo, tak jsi na špatné adrese. :-))

diky vam vsem za rady ale bohuzel musim priznat ze stejne porad netusim mam tu sepsany naky kody ale stejne moc nevim co s nima ale ukazu vam je aspon jestli du spravnou cestou

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define radek 6

int main(int argc, char** argv) {
    int vyska = 0, sirka = 0, maxsirka = 0, i, j;
    char c, **pole;
    printf("Zadejte bludiste:\n");
    do {
        /*pohyb ve sloupci smerem dolu - pridavani radku*/
        if (vyska != 0) {
            /*jiny nez prvni pruchod*/
            pole = (char **) realloc(pole, (vyska + 1) * sizeof (char *));
            pole[vyska] = (char *) malloc(1 * sizeof (char));

        }
        sirka = 0;
        do {
            /*pohyb v radku - pridavani sloupcu*/
            if (sirka == 0 && vyska == 0) {
                /*prvni bunka v prvnim radku*/
                pole = (char **) malloc(1 * sizeof (char *));
                pole[0] = (char *) malloc(1 * sizeof (char));
            } else {
                /*vsechny ostatni bunky (radky)*/
                if (sirka != 0) {
                    /*jina nez prvni bunka v radku*/
                    pole[vyska] = (char *) realloc(pole, (sirka + 1) * sizeof (char));
                }
            }
            if (scanf("%c", &c) == 1) {
                pole[vyska][sirka] = c;

            } else {
                /*osetreni nespravneho vstupu co do hodnoty znaku*/

            }
            if (sirka > maxsirka) {
                /*nalezeni nejdelsiho radku*/
                maxsirka = sirka;
            }
            sirka++;
        } while (c != '\n');
        vyska++;
    } while (vyska != radek);
    /*podminka ^^^ define radek musi byt o jednu vetsi nez  max index vysky*/

    /*
        for (i = 0; i < vyska; i++) {
            for (j = 0; j <= maxsirka; j++) {
                printf("%c", pole[i][j]);
                if (pole[i][j] == '\n') {
                    break;
                }
            }
        }
     */
        printf("\n");
    return (EXIT_SUCCESS);
}


a tady mam jeste neco od kamose

#include <stdlib.h>
#include <stdio.h>

/* Nacte data ze standardniho vstupu, alokuje pamet a zmeni pointer data tak, aby na ne ukazoval.
* Neoddeluje radky, vsechno nasype do jednoho retezce - znaky '\n' cte jako normalni znak.
* Pokud dojde pamet, vrati -1 a data=NULL
* pouziti:
*   int pocet_znaku;
*   char* data;
*   pocet_znaku=nacti_data(&data);
*   printf("nactena data: %s",data);
*/
int nacti_data(char** data) {
    int cislo_bloku=1;
    size_t nactenych_bytu;
    size_t nactenych_bytu_celk=0;
    *data=(char*)malloc(12*sizeof(char));
    if(*data==NULL) {
        return(-1);
    }
    while(1) {
        *data=(char*)realloc(*data,10*cislo_bloku*sizeof(char)+2);
        if(*data==NULL) {
            return(-1);
        }
        nactenych_bytu=fread((*data+nactenych_bytu_celk),sizeof(char),10,stdin);
        nactenych_bytu_celk+=nactenych_bytu;
        if(nactenych_bytu!=10) {//    dosazeno konce souboru
            *(*data+(cislo_bloku-1)*10+nactenych_bytu)='\0';
            break;
        }
        cislo_bloku++;
    }
    return(nactenych_bytu_celk);
}



/* rozseka data nacteny funkci nacti_data na pole retezcu pole[radek]
*
* vstup: char* p_data, int pocet_znaku
* vystup: pocet_radku, navratova hodnota char** pole.....pole[radek][znak]
*
* pocet_radek...posledni index=pocet_radek-1
*
* za poslednim radkem musi byt '\n' jinak to blbne - vynechava posledni radku, priklady z progtestu by to mely splnovat
*/
char** rozsekej_data_na_radky(char* data,int pocet_znaku,int* pocet_radku) {
    char** pole=NULL;
    int i,zacatek_radku=0;
    int radek=1;

   
    pole=(char**)malloc(sizeof(char*));
    if(pole==NULL) return(NULL);
   
    for(i=0;i<pocet_znaku;i++) {
        if( *(data+i)=='\n' || *(data+i)=='\0'  ) {
           
            pole=(char**)realloc(pole,radek*sizeof(char*)+1);
            if(pole==NULL) return(NULL);
           
           
            pole[radek-1]=data+zacatek_radku;
            zacatek_radku=i+1;
           
            //if( *(data+i+1)=='\0' ) break;
           
           
            if( *(data+i)=='\0') break;
            radek++;
            *(data+i)='\0';
   
        }
    }
    *pocet_radku=radek-1;
    return(pole);
}


int main(void) {
    char* data;
    int pocet_znaku;
    pocet_znaku=nacti_data(&data);
   
    printf("\n");
    printf("Nactena data: \n%s",data);
    printf("\nNacteno %d bytu.\n",pocet_znaku);
   
    printf("\n--------data---rozsekana---na--radky-----------\n");
   
    int pocet_radek;
    char** pole;
    int i;
    pole=rozsekej_data_na_radky(data,pocet_znaku,&pocet_radek);
    printf("\nPocet radek je: %d.",pocet_radek);
    for(i=0;i<pocet_radek;i++) {
        printf("\nRadek \t%d \t:%s",i,pole[i]);
    }
   
    printf("\nToto je 3. pismeno z 1. radku: %c \n",pole[0][2]);
    printf("\nToto je 5. pismeno z 2. radku: %c \n",pole[1][4]);
   
    // -----uvolneni pameti -------
    free(data);
    free(pole);
   
    return(0);
   
}