Как найти элементы матрицы под главной диагональю

Нужно найти сумму элементов под главной диагонали матрицы.
К примеру,дана матрица

1 2 3 4
5 6 7 8
2 4 3 2
5 6 7 8

Нужна сумма цифр 5,2,4,5,6,7.
Я написал программу для вычисления главной диагонали.
Вот код:

int main()
{
    int sizeN,sizeM;
    cin >> sizeN;
    sizeM = sizeN;
    
    int array[sizeN][sizeM] = {};
    int total = 0;
    
    for (int i = 0; i < sizeN; i++) {
        for (int j = 0; j < sizeM; j++) {
            cin >> array[i][j];
        }
    }
    
    for (int i=0;i<sizeN;i++)
      for (int j=0;j<sizeM;j++)
          if (i==j){
              total+=array[i][j];
          } 
          
    cout << total;

    return 0;
}

Как вычислить сумму цифр под диагональю?

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

// main_secondary_diagonal.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
#include <iomanip>
using namespace std;

int main(int argc, char* argv[])
{
    srand(time(NULL));
    int size_array; // размер квадратной матрицы
    setlocale(LC_ALL, "rus");

    cout << "Введите размер квадратной матрицы: ";
    cin >> size_array;

    // динамическое создание двумерного массива
    int **arrayPtr = new int* [size_array];
    for (int count = 0; count < size_array; count++)
        arrayPtr[count] = new int [size_array];

    for (int counter_rows = 0; counter_rows < size_array; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < size_array; counter_columns++)
        {
            arrayPtr[counter_rows][counter_columns] = rand() % 100; // заполнение массива случайными числами
            cout << setw(2) << arrayPtr[counter_rows][counter_columns] << "  "; // вывод на экран двумерного массива
        }
        cout << endl;
    }
    cout << endl;

    int min = arrayPtr[1][0], // минимальный елемент массива, ниже главной диагонали
        row_min = 1,          // номер строки минимального элемента
        column_min = 0;       // номер столбца минимального элемента

    // поиск минимального элемента в массиве, ниже главной диагонали
    for (int counter_rows = 1; counter_rows < size_array; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < counter_rows ; counter_columns++)
        {
            if ( arrayPtr[counter_rows][counter_columns] < min )
            {
                min = arrayPtr[counter_rows][counter_columns];
                row_min = counter_rows;
                column_min = counter_columns;
            }
        }
    }

    cout << "min" << "[" << (row_min + 1) << "][" << (column_min + 1) << "]"  << " = " << min << endl; 

    int max = arrayPtr[0][0], // максимальный элемнет массива, выше побочной диагонали
        row_max = 0,              // номер строки максимального элемента
        column_max = 0;           // номер столбца максимального элемента

    for (int counter_rows = 0; counter_rows < size_array - 1; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < (size_array - counter_rows - 1); counter_columns++)
        {
            if ( arrayPtr[counter_rows][counter_columns] > max )
            {
                max = arrayPtr[counter_rows][counter_columns];
                row_max = counter_rows;
                column_max = counter_columns;
            }
        }
    }

    cout << "max" << "[" << (row_max + 1) << "][" << (column_max + 1) << "]"  << " = " << max << endl; 

    //////////////////перестановка элементов////////////////////////////////////////////////

    arrayPtr[row_min][column_min] = max;
    arrayPtr[row_max][column_max] = min;

    ////////////////////////////////////////////////////////////////////////////////////////

    cout << "nМассив после перестановки максимального и минимального элементов:n";

    for (int counter_rows = 0; counter_rows < size_array; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < size_array; counter_columns++)
        {
          cout << setw(2) << arrayPtr[counter_rows][counter_columns] << "  "; // вывод на экран двумерного массива
        }
        cout << endl;
    }
    cout << endl;

    cout << "min" << "[" << (row_max + 1) << "][" << (column_max + 1) << "]"  << " = " << min << endl; 
    cout << "max" << "[" << (row_min + 1) << "][" << (column_min + 1) << "]"  << " = " << max << endl; 

    // удаление двумерного динамического массива
    for (int count = 0; count < size_array; count++)
        delete []arrayPtr[count];

    system("pause");
    return 0;
}

Частным
случаем матрицы является квадратная
матрица,
т.е.
матрица, имеющая одинаковое количество
строк и столбцов (рис.43).

X[1,1]	X[1,2]	X[1,3]
X[2,1]	X[2,2]	X[2,3]
X[3,1]	X[3,2]	X[3,3]

Рис.43

Элементы
матрицы, выделенные на рис.43, называются
главной
диагональю.
Отличительной
особенностью этих
элементов является то, что они имеют
одинаковые
номера строки и столбца.
Поэтому в i-ой
строке индексы элемента
главной диагонали
матрицы Х будут X[i,i].
Для обработки
элементов главной
диагонали
требуется изменять только одну
переменную,
поэтому необходимо всего один
цикл, а не два,
как при обработке
всей матрицы.
На рис.44 показан алгоритм
нахождения суммы положительных
элементов главной диагонали. Ниже
приведён фрагмент
программы к этому алгоритму.

•

• •

S:=0;

for
i:=1
to
N
do

if
X[i,i]>0 then

S:=S+X[i,i];

writeln(‘S=’
, S);

• • •

Рис.44

3.2.6. Обработка элементов побочной диагонали

Побочная
диагональ
(рис.45)
существует только в квадратной
матрице.

X[1,1]	X[1,2]	X[1,3]
X[2,1]	X[2,2]	X[2,3]
X[3,1]	X[3,2]	X[3,3]

Рис.45

Н
етрудно
заметить, что элемент побочной диагонали
матрицы Х в первой строке имеет индексы
Х[1,N],
во второй строке – Х[2, N-1], в третьей –
Х[3, N-2].
Отсюда можно заключить, что в i-ой
строке элемент побочной диагонали будет
иметь индексы Х[I,
N-I+1].

На
рис.46 показан алгоритм нахождения
количества равных
нулю элементов побочной диагонали. Ниже
представлен фрагмент
программы к этому алгоритму.

Рис.46

• • •

К:=0;

for
i:=1
to
N
do

if
X[i,N-i+1] = 0 then

K:=K+1

writeln(
‘K=’ , K) ;

• • •

3.2.7. Обработка элементов квадратных матриц, расположенных над и под главными и побочными диагоналями

На
рис. 47 приведена схема расположения
элементов относительно главной диагонали.

Г


лавная
диагональ (ГД) Элементы,
расположенные над ГД

гд
	Гд
		ГД
			гд

Элементы,
расположенные под ГД

Рис.
47

Рассмотрим
элементы, расположенные над главной
диагональю матрицы. Для матрицы А
размером 4х4 эти элементы будут иметь
следующие индексы:

в
первой строке: A[1,2],
A[1,3],
A[1,4];

во
второй строке: A[2,3],
A[2,4];

в
третьей строке: A[3,4];

в
четвертой строке элементов нет.

Проанализировав
полученные индексы, можно определить,
что для элементов, расположенных выше
главной диагонали, номер столбца всегда
больше номера строки. Поэтому при
организации циклов для обработки этих
элементов нужно учитывать, что в первой
строке нужно рассматривать элементы,
начиная со второго столбца, во второй
строке – начиная с третьего столбца, в
третьей строке – начиная с четвертого
столбца. В общем случае элементы i-ой
строки нужно обрабатывать, начиная с
элемента из i+1
столбца и заканчивая элементом последнего
(N-го)
столбца.

Для
примера рассмотрим алгоритм нахождения
суммы положительных элементов,
расположенных над главной диагональю
(рис.
48).

S:=0;

For
i :=1 to N-1 do

For
j:= I +1 to N do

If
A[I,j]>0 then

S:=S+A[I,j];

Рис.
48

Рассмотрим
элементы, расположенные под главной
диагональю матрицы. Для матрицы А
размером 4х4 эти элементы будут иметь
следующие индексы:

в
первой строке элементов нет;

во
второй строке: A[2,1],

в
третьей строке: A[3,1],
А[3,2];

в
четвертой строке: A[4,1],
A[4,2],
A[4,3].

Проанализировав
полученные индексы, можно определить,
что для элементов, расположенных ниже
главной диагонали, номер столбца всегда
меньше номера строки. Поэтому при
организации циклов для обработки этих
элементов нужно учитывать, что во второй
строке нужно рассматривать элементы
строки, заканчивая элементами из первого
столбца, в третьей строке – заканчивая
элементами из второго столбца, в четвертой
строке – заканчивая элементами из
третьего столбца. В общем случае элементы
i-ой
строки нужно обрабатывать, начиная с
элемента из первого столбца и заканчивая
рассмотрение элементами из i-1
столбца.

Для
примера рассмотрим алгоритм нахождения
произведения отрицательных элементов,
расположенных под главной диагональю
(рис.
49).

P:=1;

For
i :=2 to N do

For
j:= 1 to I-1 do

If
A[I,j]<0 then

P:=P+A[I,j];

Рис.
49

На
рис. 50 приведена схема расположения
элементов относительно побочной
диагонали.

Э
лементы,
Побочная диагональ(ПД)

р

асположенные
над ПД

			пд
		Пд
	Пд
пд

Элементы,
расположенные под ПД

Рис.
50

Рассмотрим
элементы, расположенные над побочной
диагональю матрицы. Для матрицы А
размером 4х4 эти элементы будут иметь
следующие индексы:

в
первой строке: A[1,1],
A[1,2],
A[1,3];

во
второй строке: A[2,1],
A[2,2];

в
третьей строке: A[3,1];

в
четвертой строке элементов нет.

В
общем случае элементы i-ой
строки нужно обрабатывать, начиная с
элемента первого столбца и заканчивая
элементом из N-i
столбца.

Для
примера рассмотрим алгоритм нахождения
количества нулевых элементов, расположенных
над побочной диагональю (рис.
51).

K:=0;

For
i :=1 to N-1 do

For
j:= 1 to N-i do

If
A[I,j]=0 then

K:=K+1;

Рис.51

Теперь
рассмотрим элементы, расположенные под
побочной диагональю матрицы. Для матрицы
А размером 4х4 эти элементы будут иметь
следующие индексы:

в
первой строке элементов нет;

во
второй строке: A[2,4],

в
третьей строке: A[3,3],
А[3,4];

в
четвертой строке: A[4,2],
A[4,3],
A[4,4].

В
общем случае элементы i-ой
строки нужно обрабатывать, начиная с
элемента из столбца под номером N+2-I
и заканчивая элементом из последнего
(N-го
столбца).

Для
примера рассмотрим алгоритм нахождения
максимального среди элементов,
расположенных под побочной диагональю
(рис. 52).

M
AX:=A[2,N];
{за начальное значения максимума берем
любой элемент, расположенный под побочной
диагональю}

For i :=2 to N do

For
j:= N+2-i to N do

If
A[I,j]>MAX then

MAX:=A[I,j];

Рис. 52

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

Содержание:

• Вычисления определителей второго порядка
• Методы вычисления определителей третьего порядка
• Приведение определителя к треугольному виду
• Правило треугольника
• Правило Саррюса
• Разложение определителя по строке или столбцу
• Разложение определителя по элементам строки или столбца
• Теорема Лапласа

В общем случае правило вычисления определителей
$n$-го порядка
является довольно громоздким. Для определителей второго и третьего порядка существуют рациональные способы их вычислений.

Вычисления определителей второго порядка

Чтобы вычислить определитель матрицы второго порядка, надо от произведения
элементов главной диагонали отнять произведение
элементов побочной диагонали:

$$left| begin{array}{ll}{a_{11}} & {a_{12}} \ {a_{21}} & {a_{22}}end{array}right|=a_{11} cdot a_{22}-a_{12} cdot a_{21}$$

Методы вычисления определителей третьего порядка

Для вычисления определителей третьего порядка существует такие правила.

Правило треугольника

Схематически это правило можно изобразить следующим образом:

Произведение элементов в первом определителе, которые соединены прямыми,
берется со знаком «плюс»; аналогично, для второго определителя — соответствующие произведения берутся со знаком «минус», т.е.

$$left| begin{array}{ccc}{a_{11}} & {a_{12}} & {a_{13}} \ {a_{21}} & {a_{22}} & {a_{23}} \ {a_{31}} & {a_{32}} & {a_{33}}end{array}right|=a_{11} a_{22} a_{33}+a_{12} a_{23} a_{31}+a_{13} a_{21} a_{32}-$$

$$-a_{11} a_{23} a_{32}-a_{12} a_{21} a_{33}-a_{13} a_{22} a_{31}$$

Правило Саррюса

Справа от определителя дописывают первых два столбца и произведения элементов на главной диагонали и на диагоналях, ей
параллельных, берут со знаком «плюс»; а произведения элементов побочной диагонали и диагоналей, ей параллельных,
со знаком «минус»:

$$-a_{13} a_{22} a_{31}-a_{11} a_{23} a_{32}-a_{12} a_{21} a_{33}$$

Разложение определителя по строке или столбцу

Определитель равен сумме произведений элементов строки определителя на их
алгебраические дополнения. Обычно выбирают
ту строку/столбец, в которой/ом есть нули. Строку или столбец, по которой/ому ведется разложение, будет обозначать стрелкой.

Этот метод позволяет вычисление определителя свести к вычислению определителя более низкого порядка.

Для вычисления определителей четвертого порядка и выше применяется либо разложение по строке/столбцу, либо приведение
к треугольному виду, либо с помощью теоремы Лапласа.

Разложение определителя по элементам строки или столбца

Приведение определителя к треугольному виду

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

Теорема Лапласа

Читать дальше: обратная матрица.