Trouver des éléments parlallel à la diagonale principale dans une matrice

Question

Je dois faire un programme qui trouve la somme des éléments de la matrice qui sont situés parallèlement à la diagonale principale. Je n'ai aucune idée de comment trouver les éléments qui sont parallèles à la diagonale principale. Le i == j ne fonctionne que pour la diagonale principale seulement. Disons que nous avons une matrice comme ceci:

22 5 6 4 
32 45 7 9 
1 21 43 6 
7 5 9 11 

Je dois trouver les sommes séparément: 4; 6 + 9; 5 + 7 + 6; 22 + 45 + 43 + 11; 32 + 21 + 9; 1 + 5; 7

After the changes the code become like this: 
#include <stdio.h> 
#include <cmath> 
#include <cstdlib> 
#define N 50 
void enter_matrix (float m[N][N],int n){ 
    int i,j; 
    for(i=0;i<n;i++){ 
     for(j=0;j<n;j++){ 
      printf("Enter %d %d element of the matrix: ",i+1,j+1); 
      scanf("%f",&m[i][j]); 
     } 
    } 
} 
void show_matrix(float m[N][N],int n){ 
    int i,j; 
    for(i=0;i<n;i++){ 
     for(j=0;j<n;j++){ 
      printf("%.2f\t",m[i][j]); 
     } 
     printf("\n"); 
    } 
} 

int find_sums(float m[N][N],float sum[100],int n){ 
    int j=0; 
    for(int offset = -n+1; offset < n; ++offset) { 
    float sum1 = 0; 
    for(int i = 0; i < n-fabs(offset); ++i) { 
     if(offset <= 0) { 
      sum1 += m[i][i-offset]; 
     } 
     else { 
      sum1 += m[i+offset][i]; 
     } 
     sum[j]=sum1;j++;printf("%.2f \n",sum1); 
    } 
    } 
    return j; 
} 

int find_max(float sum, int j){ 
    int i,maxn;float *s,max=0;s=&sum; 
    for(i=0;i<j;i++){ 
     if(*(s+1)>max){ 
      max=*(s+1); 
      maxn=i; 
     } 
    } 
    return maxn; 
} 

int find_min(float sum, int j){ 
    int i,minn; 
    float *s; 
    s=&sum;float min=*(s+0); 
    for(i=0;i<j;i++){ 
     if(*(s+1)<min){ 
      min=*(s+1); 
      minn=i; 
     } 
    } 
    return minn; 
} 

void main(){ 
    float matrix [N][N], sum[100],*s; 
    int n,j,maxn,minn; 
    s=sum; 

    do{ 
     printf("Enter matrix dimension (between 1 and 50):"); 
     scanf("%d",&n); 
    } 
    while(n<=0||n>50); 
    enter_matrix(matrix,n); 
    show_matrix(matrix,n); 
    j=find_sums(matrix,sum,n); 
    maxn=find_max(sum[100],j); 
    minn=find_min(sum[100],j); 
    printf("Maximum sum is equal to %.2f, at line %d\n",sum[maxn],maxn+1); 
    printf("Minimum sum is equal to %.2f, at line %d\n",sum[minn],minn+1); 
} 

Et la sortie est comme ceci:

Enter matrix dimension (between 1 and 50):3 
Enter 1 1 element of the matrix: 1 
Enter 1 2 element of the matrix: 2 
Enter 1 3 element of the matrix: 3 
Enter 2 1 element of the matrix: 4 
Enter 2 2 element of the matrix: 5 
Enter 2 3 element of the matrix: 6 
Enter 3 1 element of the matrix: 7 
Enter 3 2 element of the matrix: 8 
Enter 3 3 element of the matrix: 9 
1.00 2.00 3.00 
4.00 5.00 6.00 
7.00 8.00 9.00 
3.00 
2.00 
8.00 
1.00 
6.00 
15.00 
4.00 
12.00 
7.00 
Maximum sum is equal to 3.00, at line 1 
Minimum sum is equal to 3.00, at line 1 
Press any key to continue 

Il fait des sommes supplémentaires non seulement les lignes complètes. Aucune suggestion?

Answer 1

et non testé à partir du haut de ma tête:

int n; 
double A[n][n] 

for(int offset = -n+1; offset < n; ++offset) { 
    double sum = 0; 
    for(int i = 0; i < n-std::abs(offset); ++i) { 
     if(offset <= 0) { 
      sum += A[i][i-offset]; 
     else { 
      sum += A[i+offset][i]; 
     } 
    } 
    std::cout << sum << std::endl; 
} 

Pour ce décalage négatif imprime la somme des diagonales parallèles supérieures et pour compenser les sommes positifs des parallèles inférieurs diagonales. La première boucle peut trivialement être parallélisée, l'instruction print est la seule partie critique.

Answer 2

Pour ces diagonales, on considère que j = i + z pour z dépend de la diagonale, allant de - (hauteur-1) à (largeur-1).

Il en résulte l'algorithme suivant (avec le réseau de solution étant capable de gérer les indices négatifs - vous devez modifier que par un décalage):

Array<R> diagonalSums (Matrix<R> m) 

    initialize Array<R> solution in according size with all entries initialized to zero 

    for each cell i,j in m: 
     find z so that j = i + z (z = j - i) 
     solution[z] += m(i,j) 

    return solution 

Je pense que vous faites quelque chose comme ça avec votre décalage , mais vous essayez de trouver un moyen de passer de z à la somme qui appartient à ce z, ce qui n'est que source de confusion inutile, du moins quand vous voulez calculer toutes les sommes de toute façon (il vaut mieux qu'une seule somme). Mon approche va simplement au-dessus de toutes les cellules et l'ajoute ensuite à l'endroit correspondant.

J'ai utilisé un tableau qui a des index négatifs et afin d'augmenter la lisibilité, je vous conseille de le faire aussi, c'est-à-dire de créer une classe qui peut le faire.