[C++] array multidimensionale: come ragionare..

[mistergks]

Questo è parte dell'esercizio su cui ho problemi:
si implementi una funzione booleana che restituisca true se la condizione è verificata, false altrimenti.
La funzione riceve come parametro una matrice di numeri interi di dimensione n*m; si attende in essa una striscia di demarcazione che la separa in due parti. Questa striscia risulta costituita da elementi vicini pari a "0"; essa consente di individuare una regione superiore e una inferiore, nella matrice stessa. Si noti che per elementi vicini si intendono due elementi presenti in due colonne consecutive e su righe che differiscono al piu di uno(quindi sulla stessa riga o su due righe consecutive). La funzione richiesta deve restituire true se la differenza tra l'elemento minimo e quello massimo della regione superiore è pari al valore medio tra gli elementi della regione inferiore. NOTA: sia la parte superiore che quella inferiore contengono almeno un elemento per ciascuna colonna(questo vuol dire che gli zeri non possono mai trovarsi sulla prima riga o sull'ultima). Inoltre, si può considerare la media degli elementi nella regione inferiore approssimata all'intero inferiore.
ESEMPIO:
matrice:

5 7 3 2 2 7 8 5 8
0 3 5 4 6 0 0 5 4
6 0 0 7 0 9 9 0 6
7 4 5 0 4 2 5 7 0
3 4 8 7 5 9 4 9 9

nella matrice riportata sopra la differenza tra gli elemetni massimo e minimo della parte superiore è pari a 8-2=6. la media dei valori nella regione inferiore è pari a 116/19=6,1 che approssimato all'intero inferiore fa 6. La funzione dovrà restituire "true".


Il mio problema generale è: come devo ragionare con questo tipo di esercizi?
In particolare con questo: come faccio a fare la somma solo sulla regione inferiore? cioè che condizione devo usare per dividere le due regioni in base agli zeri? Non riesco proprio a metterlo giu' sto esercizio...qualcuno mi dà l'input giusto per iniziare a fare qualcosa? Non chiedo di svolgerlo per intero...

[mistergks]

nessuno sa aiutarmi?

[AngeL)]

Se gli unici elementi pari a 0 sono quelli del separatore, puoi leggere la matrice dall'alto verso il basso e da sinistra verso destra, e considerare, per ogni colonna, gli elementi trovati prima di uno 0 come facenti parte della regione superiore e gli altri della regione inferiore; a questo punto di quelli sopra cerchi massimo e minimo, di quelli sotto fai la somma e il conto e poi calcoli la media. Puoi anche leggere tutta la matrice in una botta sola:

for(int i = 0; i < m; i++) {
    int j = 0;
    while(mat[i][j] != 0) {
        if(mat[i][j] > max_upper)
            max_upper = mat[i][j];
        else if(mat[i][j] < min_upper)
            min_upper = mat[i][j];
        j++;
    }
    //ora sei nella parte inferiore
    j++; // scarti lo 0
    while(j < n) {
        tot_lower += mat[i][j];
        count_lower++;
        j++;
    }
}

[wingman87]

Secondo me la cosa migliore è ragionare colonna per colonna: se vuoi fare calcoli sulla zona inferiore parti dal basso e ti fermi quando trovi lo zero, viceversa se vuoi fare calcoli sulla zona superiore parti dall'alto.
L'unico dubbio è: c'è un solo 0 per ogni colonna? Dalla traccia non l'ho capito, anche se suppongo di sì perché altrimenti l'esercizio sarebbe molto più complicato.

[salvo19881]

Originariamente inviato da wingman87

Secondo me la cosa migliore è ragionare colonna per colonna: se vuoi fare calcoli sulla zona inferiore parti dal basso e ti fermi quando trovi lo zero, viceversa se vuoi fare calcoli sulla zona superiore parti dall'alto.
L'unico dubbio è: c'è un solo 0 per ogni colonna? Dalla traccia non l'ho capito, anche se suppongo di sì perché altrimenti l'esercizio sarebbe molto più complicato.

il testo non specifica se sono o meno presenti quindi dobbiamo supporre che ci possano essere degli 0 che non fanno parte della linea di demarcazione.
io procederei nel seguente modo.
mi creerei un vetttore (chiamiamolo POSIZIONE) di n elementi(matrice m*n) in cui vado a salvare l'indice corrispondente allo zero(separatore)di ogni colonna.
Per trovare questo scorriamo la matrice da sinistra a destra e dall'alto al basso
quindi partendo dall'elemento [0,0] vado a cercare il valore 0 supponiamo sia in [0,i], salvo i in Posizione[0]
allora vado a vedere se in [1,i-1],[1,i],[1,i+1] c'è uno 0 se si aggiorno la i a i-1,i,i+1 (in base a dove ho trovato lo 0, e salvo la i in posizione[1] e così via.

Ora supponiamo di essere arrivati all'elemento [n.i] in cui vi è uno 0.
se alla colonna n+1 non ci sono 0 compatibili, bisogna tornare alla colonna n e vedere se oltre allo 0 in [n,i] vi siano altri 0 compatibili con la colonna [n-1].

e si procede a ritroso fino a trovare una colonna che abbia altri 0 compatibili(se arriviamo alla prima colonna ovviamente non controlliamo più a ritroso ma scendiamo a cercare altri 0).

Scusa se sono mooolto poco esaudiente nella spiegazione, ma non per niente non sono un prof.
Cmq spero hai capito cosa voglia dire, in caso contrario stasera(quando finisco i miei studi giornalieri) vedo di imprementare un algoritmo x trovarti gli elementi separatori

PS
come non detto mi sono accarto di essere completamente perso su diversi argomenti, quindi considerando che ho l'esame giovedì, mi devo mettere a fare le nottate.
se non hai premura provo a scrivere qualcosa venerdi.