Visualizzazione dei risultati da 1 a 7 su 7
  1. #1
    Utente di HTML.it
    Registrato dal
    Jun 2012
    Messaggi
    3

    [C] Algoritmo di Clustering

    Salve, devo fare un progetto per un esame all' università, ma sono rimasto un po con le spalle al muro.
    In pratica devo Scrivere una funzione in C alla quale passo una matrice 15 x 10 composta da numeri che possono essere: 0,1,2 o 3.
    Devo trovare il gruppo più grande possibile di 1, 2 o 3 che devono essere connessi solo tramite le direzioni cardinali.
    Ad esempio passo alla funzione:
    012333323
    011233000
    011230000

    Lui dovrebbe trovarmi quel gruppo di tre che sono connessi e passarmeli a zero.

    Ho scritto questa funzione per trovare il gruppo più grande e segnarmi gli indici dell elemento più in basso a destra del gruppo più grande, solo che mi trova roba assurda e non funziona:

    codice:
    int ricerca(int matrice[15][10] )
    {
        int c,d,i,u,j,x,c1,c2,k,indo=0,indv=0;
        int *p;
        c1=1;
        p=&matrice[0][0];
        for(i=0; i<15; i++)
        {
            for (j=0; j<10; j++)
            {
                if(matrice[i][j]!=0)
                {
                    x=matrice[i][j];
                    if(x==matrice[i][j+1] || x==matrice[i+1][j] )
                    {
                        c1=c1+1;
                        if(x!=matrice[i][j+1])
                        {
                            c1=c1;
                        }
                        if(x!=matrice[i+1][j])
                        {
                            c1=c1;
                        }
                        if(c1>k)
                        {
                            k=c1;
                            indo=i;
                            indv=j;
                            p=&matrice[i][j];
                        }
                        if(x!=matrice[i][j+1] && x!=matrice[i+1][j])
                        {
                            c1=0;
                        }
                    }
                }
            }
        }
        printf("%d \n %d \n %d \n",k,indo,indv);
    
    
    }

  2. #2
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,461

    Re: [C] Algoritmo di Clustering

    Originariamente inviato da med90
    Ad esempio passo alla funzione:
    012333323
    011233000
    011230000

    Lui dovrebbe trovarmi quel gruppo di tre che sono connessi e passarmeli a zero.
    Scusa ... che vuoi dire ? Nell'esempio che hai fatto, di quale gruppo parli? E che significa "passarmeli a zero" ?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  3. #3
    Utente di HTML.it
    Registrato dal
    Jun 2012
    Messaggi
    3
    Chiedo venia mi sono spiegato male in effetti

    012333323
    011233000
    011230000

    Allora in questo esempio la funzione dovrebbe essere in grado di trovare quel gruppo di 3 evidenziati in rosso.

    Passarmeli a zero lasciatelo perdere quello è lo step successivo che ancora non ho implementato

  4. #4
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,461
    Quale regola lega questi valori

    Originariamente inviato da med90
    012333323
    011233000
    011230000
    da questi altri

    Originariamente inviato da med90
    012333323
    011233000
    011230000
    o anche da questi

    Originariamente inviato da med90
    012333323
    011233000
    011230000
    ?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  5. #5
    Utente di HTML.it L'avatar di rsdpzed
    Registrato dal
    Aug 2001
    Messaggi
    764
    la funzione di ricerca potrebbe essere ricorsiva che partendo da una posizione i,j cerca un suo simile prima ad est poi a sud poi a ovest ed infine a nord. Durante l ricerca deve memorizzare gli indici degli elementi simili in una struttura dati a parte. Durante la ricerca non devi considerare gli elementi gia presenti nella struttura dati.
    Cosi a naso dovrebbe funzionare.

  6. #6
    Utente di HTML.it
    Registrato dal
    Jun 2012
    Messaggi
    3
    Grazie per il consiglio credo di aver applicato l idea tuttavia non capisco perchè non funzioni il contatore

    codice:
     struct salva_elementi
    {
        int counter;
        int counter2;
    } struttura;
    
    typedef struct indic1
    {
        int primoi;
        struct indicei *next;
    } indicei;
    
    typedef struct indic2
    {
        int primoj;
        struct indicej *next;
    } indicej;
    
    indicei *trova_indicii(indicei **p, int i)
    {
        indicei *a = (indicei*) malloc(sizeof(indicei));
        a->next = *p;
        *p = a;
        a->primoi= i;
        return a;
    }
    indicej *trova_indicij(indicej **p, int j)
    {
        indicej *a = (indicej*) malloc(sizeof(indicej));
        a->next = *p;
        *p = a;
        a->primoj= j;
        return a;
    }
    
    indicei **scorrilistai(indicei **n, int i)
    {
        while (*n != NULL)
        {
            if ((*n)->primoi==i)
            {
                return n;
            }
            n= &(*n) ->next;
        }
        return NULL;
    }
    
    indicej **scorrilistaj(indicej **n, int j)
    {
        while (*n != NULL)
        {
            if ((*n)->primoj==j)
            {
                return n;
            }
            n= &(*n) ->next;
        }
        return NULL;
    }
    
    int cerca_elementiovest (int x, int i, int j, int matrice[15][10],int c1, int c2)
    {
    
        int l,k=0;
        indicei *p=NULL;
        indicej *q=NULL;
        indicei(&p,i);
        indicej(&q,j);
        k=scorrilistai(&p,i);
        l=k=scorrilistai(&q,i);
        if(x==matrice[i][j-1] && k!=i && l!=1)
        {
            struttura.counter=struttura.counter+1;;
        }
    }
    
    int cerca_elementiest (int x, int i, int j, int matrice[15][10],int c1, int c2)
    {
        int l,k=0;
        indicei *p=NULL;
        indicej *q=NULL;
        indicei(&p,i);
        indicej(&q,j);
        k=scorrilistai(&p,i);
        l=k=scorrilistai(&q,i);
        if(x==matrice[i][j+1] && k!=i && l!=1)
        {
            struttura.counter=struttura.counter+1;
        }
    }
    int cerca_elementinord (int x, int i, int j, int matrice[15][10],int c1, int c2)
    {
        int l,k=0;
        indicei *p=NULL;
        indicej *q=NULL;
        indicei(&p,i);
        indicej(&q,j);
        k=scorrilistai(&p,i);
        l=k=scorrilistai(&q,i);
        if(x==matrice[i-1][j] && k!=i && l!=1)
        {
            struttura.counter=struttura.counter+1;
        }
    }
    
    int cerca_elementisud (int x, int i, int j, int matrice[15][10],int c1, int c2)
    {
        int l,k=0;
        indicei *p=NULL;
        indicej *q=NULL;
        indicei(&p,i);
        indicej(&q,j);
        k=scorrilistai(&p,i);
        l=k=scorrilistai(&q,i);
        if(x==matrice[i+1][j] && k!=i && l!=1 )
        {
            struttura.counter=struttura.counter+1;
        }
    }
    
    int repeat (int matrice[15][10])
    {
        int i,j,x,k=0;
        int c1=0, c2=0;
        for(i=0; i<15; i++)
        {
            for(j=0; j<10; j++)
            {
                x=matrice[i][j];
                if(j!=0 && x!=0)
                {
                    cerca_elementiovest(x,i,j,matrice,c1,c2);
                }
                if(j!=9 && x!=0)
                {
                    cerca_elementiest(x,i,j,matrice,c1,c2);
                }
                if(i!=0 && x!=0)
                {
                    cerca_elementinord(x,i,j,matrice,c1,c2);
                }
                if(i!=14 && x!=0)
                {
                    cerca_elementisud(x,i,j,matrice,c1,c2);
                }
    
                if(j!=0 && j!=9 && i!=0 && i!=14 && x!=matrice[i+1][j] && x!=matrice[i-1][j] && x!=matrice[i][j-1] && x!=matrice[i][j+1])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(j==0 && i!=0 && i!=14 && x!=matrice[i][j+1] && x!=matrice[i+1][j] && x!=matrice[i][j-1])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(j==9 && i!=0 && i!=14 && x!=matrice[i+1][j] && x!=matrice[i-1][j] && x!=matrice[i][j-1])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(i==0 && j!=0 && j!=9 && x!=matrice[i+1][j] && x!=matrice[i][j+1] && x!=matrice[i][j-1])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(i==14 && j!=0 && j!=9 && x!=matrice[i+1][j] && x!=matrice[i][j+1] && x!=matrice[i][j-1])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(i==0 && j==0 && x!=matrice[i][j+1] && x!=matrice[i-1][j])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(i==0 && j==9 && x!=matrice[i+1][j] && x!=matrice[i][j-1])
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(j==0 && i==14 && x!=matrice[i][j+1] && x!=matrice[i-1][j] )
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
                if(j==9 && i==14 && x!=matrice[i-1][j] && x!=matrice[i][j-1] )
                {
                    c2=struttura.counter;
                    struttura.counter=0;
                }
            }
        }
        printf("%d \n \n %d \n ", k,struttura.counter);
    }

  7. #7
    Utente di HTML.it L'avatar di rsdpzed
    Registrato dal
    Aug 2001
    Messaggi
    764
    in pseudocodice la funzione ricorsiva che avevo in mente è più o meno questa:

    codice:
    void Cerca(int i, int j, *cluster)
    {
      SalvaIndiciNelCluster(i, j, cluster)
      SalvaIndiciProcessati(i, j);
      if (j+1 != limite_matrice) &&  CheckIndiciNonProcessati(i, j+1) && (v[i, j] == v[i, j+1])
        Cerca(i, j+1, cluster); //vado a est
      else
        if (v[i,j] == v[i+1,j]) // da qui e per i successivi controlli non riscrivo tutte le condizioni, è chiaro però che va sempre controllato sia che non siamo al limite sia che l'elemento successivo non sia gia stato considerato.
          Cerca(i+1, j, cluster); //sud
        else
          if (v[i, j] == v[i, j-1]
            Cerca(i, j-1, cluster) //ovest
          else
            if (v[i,j] == v[i-1, j])
              Cerca(i-1, j, cluster); //nord
    }
    il cliclo principale

    codice:
    InizializzaElencoIndiciProcessati;
    InizializzaListaCluster;
    for tutte le righe
      for tutte le colonne
        if CheckIndiciProcessati(i, j) //Considero un ipotetico cluster anche da un solo elemento solo se l'elemento in questione non è mai stato processato precedentemente
        {
           *cluster = InizializzaCluster;
           cerca(i, j, cluster)
           AggiungiAllaListaDeiCluster(cluster);
        }
    alla fine ti ritroveresti una lista di liste ognuna delle quali rappresenta un cluster.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.