Нахождение элементов параллельной главной диагонали в матрице

Question

Нахождение элементов параллельной главной диагонали в матрице

Я должен сделать программу, которая находит суммы элементов матрицы, которые расположены параллельно главной диагонали. Я понятия не имею, как найти элементы, которые параллельны главной диагонали. I == j работает только для главной диагонали. Допустим, у нас есть такая матрица:

Я должен найти суммы отдельно: 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);
}

И вывод такой:

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

Это делает некоторые дополнительные суммы не только полными строками. Какие-либо предложения?

-1

c++elements matrix parallel-processing

Решение

Другие решения

Для этих диагоналей считается, что j = i + z для z в зависимости от диагонали, достигающей от — (высота-1) до (ширина-1).

Это приводит к следующему алгоритму (с массивом решений, способным обрабатывать отрицательные индексы — вы должны изменить это с некоторым смещением):

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

Я думаю, что вы делаете что-то подобное со своим смещением, но вы пытаетесь найти способ перейти от z к сумме, которая принадлежит этому z, что только излишне запутанно, по крайней мере, когда вы хотите вычислить все суммы в любом случае (ваш путь лучше, если нужна только одна сумма). Мой подход просто перебирает все ячейки, а затем добавляет его в соответствующем месте.

Я использовал массив с отрицательными индексами, и для повышения читабельности я бы посоветовал вам сделать это, то есть создать класс, который может это делать.

0

Источник

Accepted Answer

Не проверено и от макушки головы:

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;
}

Для отрицательного смещения это печатает суммы верхних параллельных диагоналей и для положительного смещения суммы нижних параллельных диагоналей. Первый цикл можно легко распараллелить, оператор print является единственной критической частью.

0