[c]vettore

[mikael2]

SE ho un grafo rappresentato da una matrice di adiacenza m[j]
es: vertice 1: 1 0 0
vertice2: 0 0 1
vertice 3; 1 0 1
come si può scrive un vettore che mi tiene traccia del vertice 1 o 2 ecc?

[vict85]

Sai non capisco esattamente cosa tu intenda esattamente per vettore che tiene traccia per vertice $i$.

Insomma, intendi $(1,0,0)$ per $0$[nota]In C gli indici partono da 0 quindi conviene usare questa convenzione[/nota]? Insomma questo rappresenta i vertici uscenti. Mentre $((1),(0),(1))$ sono quelli che entrano.

Oppure vuoi qualcosa del tipo $(0,2)$ per il vertice $2$ (gli altri hanno un solo vertice quindi sono meno ovvi quello che intendo scrivere)?


P.S.: Il forum permette l'inserimento di formule matematica. Per esempio una matrice la inserisci come

$((1,0,0),(0,0,1),(1,0,1))$

ad esempio $((1,0,0),(0,0,1),(1,0,1))$

[mikael2]

mi interessa tenere traccia del vertice 0 tipo che ha $((1,0,0))$.
ho implementato un codice che mi dice qual è il grado minore in uscita del grafo, però non so come inserire in un vettore la posizione del vertice che ha grado minimo.(ovvero dovrei scrivere un vettore che è costituito da tutti quei vertici con grado in uscita minore)

void trovaOutdegreeMinore(){   
int min=nAdj[0],i,pos=0;

  
 for(i=0;i<n;i++)
 {                
     if(nAdj[i]<min)
     {            
      min=nAdj[i];
      pos=i;
       
     }
    
 }  
   printf ("\n\nValore Minimo:%d posizione:%d, ",min, pos);
}   
      

[vict85]

Sono perplesso. Quello è un codice che stampa a video la posizione e il valore minimo di un array. Sarebbe meglio se non comunicasse con l'esterno solo con variabili globali e scritte sul terminale ma è accettabile.

Da quel che mi sembra è che tu vuoi partire da una matrice m[n][n] e arrivare ad una matrice nAdj[n] che contenga il numero di 1 sulle righe della prima matrice.

Siccome il numero di 1 è uguale alla somma degli elementi della riga direi che dovresti fare qualcosa di questo tipo:

void somma_righe_colonne(int const * const mat,
                         int * const sr,
                         int * const sc,
                         int const n )
{
    for(size_t i = 0; i != n; ++i)
        sc[i] = 0;
    
    size_t t = 0;
    for(size_t i = 0; i != n; ++i)
    {
        sr[i] = 0;
        for(size_t j = 0; j != n; ++j)
        {
            int const temp = m[t];
            sr[i] += temp;
            sc[j] += temp;
        }
    }
}

Che va chiamato in questo modo:

somma_righe_colonne(m, nAdj_out, nAdj_in, n )

dove m è la tua matrice, nAdj_out e nAdj_in è il grado del vertice in uscita ed in entrata e n è il numero di vertici.

Il codice sfrutta il fatto che la matrice, in memoria, è strutturato come un lungo array di dimensione \(\displaystyle n^2 \)

[mikael2]

diciamo che la variabile nAdj[] già la tengo e rappresenta il grado in uscita è può essere diverso da 1, trovare il minore mi serve per vedere qual'è il grado in uscita minore e in base a questo mettere in un vettore il vertice che ha grado minore
es: vettore[vertice1] tutto in c nel modo più semplice possibile perchè non ho molta conoscenza del c.

comunque io genero la matrice nel mio codice nel seguente modo e dovrei adattare il codice a questo(Adj diciamo che rappresenta la lista di adicenza ):

for(i = 0;  i < n; i++) 
   {for(j=0;j<n;j++)
     if(j!=i)
      if(((float)rand()/RAND_MAX)< p)
       {m[i][j]=1;
        Na++;
        Adj[i][nAdj[i]]=j;
        nAdj[i]++;
        Adj1[j][nAdj1[j]]=i;
        nAdj1[j]++;
       }
      else
       m[i][j]=0;                
   }