Динамический массив,двумерный с плавающей точкой(коммент кода)

@Fox007 · Регистрация: 11.01.2013

Author24 — интернет-сервис помощи студентам

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

C++

#include <iostream>
#include <locale.h>
#include <string>
#include <stdlib.h>
#include <fstream>
#include <iomanip>
 
int n = 0, m = 0;
int i = 0, j = 0, k = 0, imax = 0, jmax = 0;
 
// Копирует элементы матрицы parr, не меньшие k, в обнулённую матрицу parr1
void CopyMatrixNumber(double** parr, double** parr1, int const k)
{
    for(i = 0; i < n + 1; ++i)
        for(j = 0; j < m + 1; ++j)
        {
            if(parr[i][j] >= k)
                parr1[i][j] = k;
            else
                parr1[i][j] = 0;
        }
}
 
// Поиск максимума в матрице n x m
int MaxElement(double** pmatrix)
{
    int max = 0;
    for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
            if(pmatrix[i][j] > max)
            {
                max = pmatrix[i][j];
                imax = i;
                jmax = j;
            }
    return max;
}
 
// Вывод матрицы n x m
void DisplayMatrix(double** pmatrix)
{
    for(i = 0; i < n; ++i)
    {
        for(j = 0; j < m; ++j)
            std::cout << std::setw(10) << std::left << pmatrix[i][j];
        std::cout << "\n\n";
    }
}
 
// Освобождает память из-под матрицы
template<typename T>
void FreeMemory(T** pmatrix, int const rows)
{
    for(int i = 0; i < rows; ++i)
    {
        delete[] pmatrix[i];
        pmatrix[i] = 0;
    }
    delete[] pmatrix;
    pmatrix = 0;
}
 
// Выделение памяти под матрицу
template<typename T>
T**& GetMemory(T**& pmatrix, int const rows, int const columns)
{
    int i = 0;
    try
    {
        pmatrix = new T*[rows];
        for(i = 0; i < rows; ++i)
            pmatrix[i] = 0;
        for(i = 0; i < rows; ++i)
            pmatrix[i] = new T[columns];
    }
    catch(std::bad_alloc const& exc)
    {
        std::cerr << "GetMemory: Exception: Неуспешное выделение памяти\n\n";
        FreeMemory(pmatrix, rows);
        throw;
    }
    return pmatrix;
 
 
 
}
 
// Заполняет матрицу с клавиатуры
double** FillFromCin(double**& pmatrix, int& rows, int& columns)
{
    try
    {
        if(pmatrix)
            throw "FillFromCin: pmatrix != 0";
        std::cout << "Число строк: ";
        std::cin >> rows;
        std::cout << "Число столбцов: ";
        std::cin >> columns;
        std::cout << '\n';
        GetMemory(pmatrix, rows, columns);
        for(int i = 0; i < rows; ++i)
        {
            for(int j = 0; j < columns; ++j)
            {
                std::cout << "pmatrix[" << i << "][" << j << "] = ";
                std::cin >> pmatrix[i][j];
            }
            std::cout << '\n';
        }
    }
    catch(char const* const exc)
    {
        std::cerr << "FillFromCin: Exception: " << exc << "\n\n";
        throw;
    }
    return pmatrix;
}
 
// Сортировка совместно последней строки и последнего столбца по убыванию
double** SortPrintLastColumnRow(double** pmatrix)
{
    double* parr = new double[n + m - 1];
    int arrsize = 0;
    for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
            if(j == m - 1 || i == n - 1)
            {
                parr[arrsize] = pmatrix[i][j];
                ++arrsize;
            }
    // Сортировка простыми вставками по убыванию
    for(i = 0; i < arrsize; ++i)
    {
        double tmp = parr[i];
        for(j = i - 1; j >= 0 && parr[j] < tmp; --j)
            parr[j + 1] = parr[j];
        parr[j + 1] = tmp;
    }
 
    /*for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
            if(j == m - 1 || i == n - 1)
            {
                --arrsize;
                pmatrix[i][j] = parr[arrsize];
            }
    */
    for(i = 0; i < arrsize; ++i)
        std::cout << std::setw(8) << std::left << parr[i];
    std::cout << "\n\n";
    delete[] parr;
    return pmatrix;
}
 
int main()
{
    try
    {
        setlocale(LC_ALL, "rus");
        std::string const filepath = "matrix.txt";
        double** pmatrix = 0;
        FillFromCin(pmatrix, n, m);
 
        // Выделение памяти для двух вспомогательных матриц
        double** parr = 0, **parr1 = 0;
        GetMemory(parr, n + 1, m + 1);
        GetMemory(parr1, n + 1, m + 1);
 
        // Обнуляем вспомогательные матрицы
        for(i = 0; i < n + 1; ++i)
            for(j = 0; j < m + 1; ++j)
            {
                parr[i][j] = 0;
                parr1[i][j] = 0;
            }
 
        //Инициируем матрицу parr
        for(i = 0; i < n; ++i)
            for(j = 0; j < m; ++j)
            if(pmatrix[i][j] >= 0)
                parr[i][j] = 1;
 
        std::cout << "Исходная матрица\n";
        //DisplayMatrix(parr);
        DisplayMatrix(pmatrix);
 
        // Нахождение суммы по столбцам методом Кадане
        for(i = n - 1; i >= 0; --i)
            for(j = m - 1; j >= 0; --j)
            {
                if(parr[i][j])
                    parr[i][j] += parr[i][j + 1];
            }
 
        //std::cout << "\n1. Сумма по столбцам\n";
        //DisplayMatrix(parr);
 
        // Поиск максимума в матрице
        int maxrows = MaxElement(parr);
 
        // Сумма по строкам
        int maxcol = 0;
        int imaxcol = 0, jmaxcol = 0, kmax = 0;
        for(k = 1; k <= maxrows; ++k)
        {
            CopyMatrixNumber(parr, parr1, k);
            //std::cout << "\ncopied: k:" << k << "\n";
            //DisplayMatrix(parr1);
            // Сумма по строкам
            for(j = m - 1; j >= 0; --j)
            {
                for(i = n - 1; i >= 0; --i)
                {
                    if(parr1[i][j])
                        parr1[i][j] += parr1[i + 1][j];
                }
 
            }
            int tmpmax =  MaxElement(parr1);
            //std::cout << "\n\nk: " << k << ", tmpmax: " << tmpmax << "\n\n";
            //DisplayMatrix(parr1);
            if(maxcol < tmpmax)
            {
                maxcol = tmpmax;
                imaxcol = imax;
                jmaxcol = jmax;
                kmax = k;
            }
        }
        //std::cout << "\n\nЧисло элементов в подматрице: " << maxcol << "\n";
        std::cout << "Найденная подматрица:\n";
        std::cout << "Размер подматрицы: " << maxcol / kmax << " x " << kmax << '\n';
        std::cout << "Координаты левого верхнего элемента подматрицы: ";
        std::cout << "[ " << imaxcol << " , " << jmaxcol << " ]\n\n";
 
        double** pmatrixres = new double*[maxcol / kmax];
        for(i = 0; i < maxcol / kmax; ++i)
            pmatrixres[i] = new double[kmax];
 
        for(i = imaxcol; i < imaxcol + maxcol / kmax; ++i)
        {
            for(j = jmaxcol; j < jmaxcol + kmax; ++j)
            {
                pmatrixres[i - imaxcol][j - jmaxcol] = pmatrix[i][j];
                std::cout << std::setw(10) << std::left << pmatrixres[i - imaxcol][j - jmaxcol];
            }
            std::cout << "\n\n";
        }
        std::cout << "\nОтсортированные совместно по убыванию последние столбец и строка\n";
        SortPrintLastColumnRow(pmatrix);
 
        // Освобождение памяти
        FreeMemory(pmatrix, n);
        FreeMemory(parr, n + 1);
        FreeMemory(parr1, n + 1);
        FreeMemory(pmatrixres, maxcol / kmax);
    }
    catch(...){}
    system("pause");
    return 0;
}

@Ded_Vasilij · 15.05.2013, 19:21

C++

#include <iostream>
#include <locale.h>
#include <string>
#include <stdlib.h>
#include <fstream>
#include <iomanip>
 
int n = 0, m = 0;
int i = 0, j = 0, k = 0, imax = 0, jmax = 0;
 
// Копирует элементы матрицы parr, не меньшие k, в обнулённую матрицу parr1
void CopyMatrixNumber(double** parr, double** parr1, int const k)
{
    for(i = 0; i < n + 1; ++i)//идем по строкам
        for(j = 0; j < m + 1; ++j)//идем по столбцам
        {
            if(parr[i][j] >= k)//если элемент первого массива больше входной константы
                parr1[i][j] = k;//записывем на его место во втором массиве константу
            else
                parr1[i][j] = 0;//иначе пишем 0
        }
}
 
// Поиск максимума в матрице n x m
int MaxElement(double** pmatrix)
{//странная функция - матрица вещественная - возвращает int
    int max = 0;// за max я бы взял pmatrix[0][0] - вдруг все элементы отрицательные
    for(i = 0; i < n; ++i)//бежим по матрице
        for(j = 0; j < m; ++j)
            if(pmatrix[i][j] > max)// сравниваем текущий элемент с максимальным
            {
                max = pmatrix[i][j];//если он (текущий) больше, в max пишем текущий элемент
                imax = i;// запоминаем координаты максимального элемента
                jmax = j;
            }
    return max;//возвращаем максимальный элемент
}
 
// Вывод матрицы n x m
void DisplayMatrix(double** pmatrix)
{// думаю тут все понятно
    for(i = 0; i < n; ++i)
    {
        for(j = 0; j < m; ++j)
            std::cout << std::setw(10) << std::left << pmatrix[i][j];
        std::cout << "\n\n";
    }
}
 
// Освобождает память из-под матрицы
template<typename T>
void FreeMemory(T** pmatrix, int const rows)
{
    for(int i = 0; i < rows; ++i)
    {
        delete[] pmatrix[i];
        pmatrix[i] = 0;
    }
    delete[] pmatrix;
    pmatrix = 0;
}
 
// Выделение памяти под матрицу
template<typename T>
T**& GetMemory(T**& pmatrix, int const rows, int const columns)
{
    int i = 0;
    try
    {
        pmatrix = new T*[rows];
        for(i = 0; i < rows; ++i)
            pmatrix[i] = 0;
        for(i = 0; i < rows; ++i)
            pmatrix[i] = new T[columns];
    }
    catch(std::bad_alloc const& exc)
    {
        std::cerr << "GetMemory: Exception: Неуспешное выделение памяти\n\n";
        FreeMemory(pmatrix, rows);
        throw;
    }
    return pmatrix;
 
 
 
}
 
// Заполняет матрицу с клавиатуры
double** FillFromCin(double**& pmatrix, int& rows, int& columns)
{
    try
    {
        if(pmatrix)
            throw "FillFromCin: pmatrix != 0";
        std::cout << "Число строк: ";
        std::cin >> rows;
        std::cout << "Число столбцов: ";
        std::cin >> columns;
        std::cout << '\n';
        GetMemory(pmatrix, rows, columns);
        for(int i = 0; i < rows; ++i)
        {
            for(int j = 0; j < columns; ++j)
            {
                std::cout << "pmatrix[" << i << "][" << j << "] = ";
                std::cin >> pmatrix[i][j];
            }
            std::cout << '\n';
        }
    }
    catch(char const* const exc)
    {
        std::cerr << "FillFromCin: Exception: " << exc << "\n\n";
        throw;
    }
    return pmatrix;
}
 
// Сортировка совместно последней строки и последнего столбца по убыванию
double** SortPrintLastColumnRow(double** pmatrix)
{
    double* parr = new double[n + m - 1];
    int arrsize = 0;
    for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
            if(j == m - 1 || i == n - 1)
            {
                parr[arrsize] = pmatrix[i][j];
                ++arrsize;
            }
    // Сортировка простыми вставками по убыванию
    for(i = 0; i < arrsize; ++i)
    {
        double tmp = parr[i];
        for(j = i - 1; j >= 0 && parr[j] < tmp; --j)
            parr[j + 1] = parr[j];
        parr[j + 1] = tmp;
    }
 
    /*for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
            if(j == m - 1 || i == n - 1)
            {
                --arrsize;
                pmatrix[i][j] = parr[arrsize];
            }
    */
    for(i = 0; i < arrsize; ++i)
        std::cout << std::setw(8) << std::left << parr[i];
    std::cout << "\n\n";
    delete[] parr;
    return pmatrix;
}
 
int main()
{
    try
    {
        setlocale(LC_ALL, "rus");
        std::string const filepath = "matrix.txt";
        double** pmatrix = 0;
        FillFromCin(pmatrix, n, m);
 
        // Выделение памяти для двух вспомогательных матриц
        double** parr = 0, **parr1 = 0;
        GetMemory(parr, n + 1, m + 1);
        GetMemory(parr1, n + 1, m + 1);
 
        // Обнуляем вспомогательные матрицы
        for(i = 0; i < n + 1; ++i)
            for(j = 0; j < m + 1; ++j)
            {
                parr[i][j] = 0;
                parr1[i][j] = 0;
            }
 
        //Инициируем матрицу parr
        for(i = 0; i < n; ++i)
            for(j = 0; j < m; ++j)
            if(pmatrix[i][j] >= 0)
                parr[i][j] = 1;
 
        std::cout << "Исходная матрица\n";
        //DisplayMatrix(parr);
        DisplayMatrix(pmatrix);
 
        // Нахождение суммы по столбцам методом Кадане
        for(i = n - 1; i >= 0; --i)
            for(j = m - 1; j >= 0; --j)
            {
                if(parr[i][j])
                    parr[i][j] += parr[i][j + 1];
            }
 
        //std::cout << "\n1. Сумма по столбцам\n";
        //DisplayMatrix(parr);
 
        // Поиск максимума в матрице
        int maxrows = MaxElement(parr);
 
        // Сумма по строкам
        int maxcol = 0;
        int imaxcol = 0, jmaxcol = 0, kmax = 0;
        for(k = 1; k <= maxrows; ++k)
        {
            CopyMatrixNumber(parr, parr1, k);
            //std::cout << "\ncopied: k:" << k << "\n";
            //DisplayMatrix(parr1);
            // Сумма по строкам
            for(j = m - 1; j >= 0; --j)
            {
                for(i = n - 1; i >= 0; --i)
                {
                    if(parr1[i][j])
                        parr1[i][j] += parr1[i + 1][j];
                }
 
            }
            int tmpmax =  MaxElement(parr1);
            //std::cout << "\n\nk: " << k << ", tmpmax: " << tmpmax << "\n\n";
            //DisplayMatrix(parr1);
            if(maxcol < tmpmax)
            {
                maxcol = tmpmax;
                imaxcol = imax;
                jmaxcol = jmax;
                kmax = k;
            }
        }
        //std::cout << "\n\nЧисло элементов в подматрице: " << maxcol << "\n";
        std::cout << "Найденная подматрица:\n";
        std::cout << "Размер подматрицы: " << maxcol / kmax << " x " << kmax << '\n';
        std::cout << "Координаты левого верхнего элемента подматрицы: ";
        std::cout << "[ " << imaxcol << " , " << jmaxcol << " ]\n\n";
 
        double** pmatrixres = new double*[maxcol / kmax];
        for(i = 0; i < maxcol / kmax; ++i)
            pmatrixres[i] = new double[kmax];
 
        for(i = imaxcol; i < imaxcol + maxcol / kmax; ++i)
        {
            for(j = jmaxcol; j < jmaxcol + kmax; ++j)
            {
                pmatrixres[i - imaxcol][j - jmaxcol] = pmatrix[i][j];
                std::cout << std::setw(10) << std::left << pmatrixres[i - imaxcol][j - jmaxcol];
            }
            std::cout << "\n\n";
        }
        std::cout << "\nОтсортированные совместно по убыванию последние столбец и строка\n";
        SortPrintLastColumnRow(pmatrix);
 
        // Освобождение памяти
        FreeMemory(pmatrix, n);
        FreeMemory(parr, n + 1);
        FreeMemory(parr1, n + 1);
        FreeMemory(pmatrixres, maxcol / kmax);
    }
    catch(...){}
    system("pause");
    return 0;
}

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

@cyberbrain1000 · 16.05.2013, 11:06

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

C++

#include <iostream>
#include <locale.h>
#include <string>
#include <stdlib.h>
#include <fstream>
#include <iomanip>
 
int n = 0, m = 0;// число строк и столбцов
int i = 0, j = 0, k = 0, imax = 0, jmax = 0;// вспомогательные переменные
 
// Копирует элементы матрицы parr, не меньшие k, в обнулённую матрицу parr1
void CopyMatrixNumber(double** parr, double** parr1, int const k)// parr и parr1 имеют размеры n+1 на m+1
{
    for(i = 0; i < n + 1; ++i)// цикл по строкам
        for(j = 0; j < m + 1; ++j)// цикл по столбцам
        {
            if(parr[i][j] >= k)// если элемент не меньше k то
                parr1[i][j] = k;// то копируем k в матрицу parr1
            else
                parr1[i][j] = 0;// иначе копируем туда 0
        }
}
 
// Поиск максимума в матрице n x m
int MaxElement(double** pmatrix)// pmatrix имеет размер n на m
{
    int max = 0;
    for(i = 0; i < n; ++i)// цикл по строкам
        for(j = 0; j < m; ++j)// цикл по столбцам
            if(pmatrix[i][j] > max)// если элемент больше max то перезаписываем max и запоминаем номер строки и столбца
            {
                max = pmatrix[i][j];
                imax = i;
                jmax = j;
            }
    return max;
}
 
// Вывод матрицы n x m
void DisplayMatrix(double** pmatrix)
{
    for(i = 0; i < n; ++i)// цикл по строкам
    {
        for(j = 0; j < m; ++j)// цикл по столбцам
            std::cout << std::setw(10) << std::left << pmatrix[i][j]; // вывод элемента на экран
        std::cout << "\n\n";
    }
}
 
// Освобождает память из-под матрицы
template<typename T>
void FreeMemory(T** pmatrix, int const rows)
{
    for(int i = 0; i < rows; ++i)// цикл по строкам
    {
        delete[] pmatrix[i];// освобождение каждой строки
        pmatrix[i] = 0;
    }
    delete[] pmatrix;// освобождение массива указателей
    pmatrix = 0;
}
 
// Выделение памяти под матрицу
template<typename T>
T**& GetMemory(T**& pmatrix, int const rows, int const columns)
{
    int i = 0;
    try// new может бросить исключение
    {
 
        pmatrix = new T*[rows];// выделяем память под массив указателей на строки
        for(i = 0; i < rows; ++i)// обнуляем массив указателей на строки (чтобы в случае броска bad_alloc корректно освободить память)
            pmatrix[i] = 0;
        for(i = 0; i < rows; ++i)// выделяем память под строки
            pmatrix[i] = new T[columns];
    }
    catch(std::bad_alloc const& exc)// если new бросил исключение
    {
        std::cerr << "GetMemory: Exception: Неуспешное выделение памяти\n\n";
        FreeMemory(pmatrix, rows);
        throw;// бросаем то же самое исключение повторно (чтобы выйти из программы)
    }
    return pmatrix;
 
 
 
}
 
// Заполняет матрицу с клавиатуры
double** FillFromCin(double**& pmatrix, int& rows, int& columns)
{
    try
    {
        if(pmatrix)// если под матрицу уже выделена память то
            throw "FillFromCin: pmatrix != 0";// то выход из программы
        std::cout << "Число строк: ";
        std::cin >> rows;
        std::cout << "Число столбцов: ";
        std::cin >> columns;
        std::cout << '\n';
        GetMemory(pmatrix, rows, columns);
        for(int i = 0; i < rows; ++i)// цикл по строкам
        {
            for(int j = 0; j < columns; ++j)// цикл по столбцам
            {
                std::cout << "pmatrix[" << i << "][" << j << "] = ";
                std::cin >> pmatrix[i][j];// ввод элемента
            }
            std::cout << '\n';
        }
    }
    catch(char const* const exc)
    {
        std::cerr << "FillFromCin: Exception: " << exc << "\n\n";
        throw;// бросаем исключение ещё раз для выхода из программы
    }
    return pmatrix;
}
 
// Сортировка совместно последней строки и последнего столбца по убыванию
double** SortPrintLastColumnRow(double** pmatrix)
{
    double* parr = new double[n + m - 1];// выделение памяти под массив содержащий послед. строку и последний столбец
    int arrsize = 0;// размер массива
    for(i = 0; i < n; ++i)// цикл по строкам матрицы
        for(j = 0; j < m; ++j)// цикл по столбцам матрицы
            if(j == m - 1 || i == n - 1)// если это послед. строка или последний столбец то
            {
                parr[arrsize] = pmatrix[i][j];// то копируем элемент в массив
                ++arrsize;
            }
    // Сортировка массива "Простыми вставками" по убыванию
    for(i = 0; i < arrsize; ++i)
    {
        double tmp = parr[i];
        for(j = i - 1; j >= 0 && parr[j] < tmp; --j)
            parr[j + 1] = parr[j];
        parr[j + 1] = tmp;
    }
    for(i = 0; i < arrsize; ++i)// вывод массива на экран
        std::cout << std::setw(8) << std::left << parr[i];
    std::cout << "\n\n";
    delete[] parr;// удаление массива
    return pmatrix;
}
 
int main()
{
    try// некоторые ф-ции бросают исключения
    {
        setlocale(LC_ALL, "rus");
        std::string const filepath = "matrix.txt";// имя файла с матрицей
        double** pmatrix = 0;// матрица
        FillFromCin(pmatrix, n, m);// ввод матрицы с клавиатуры
 
        // Выделение памяти для двух вспомогательных матриц (они имеют размеры n+1 на m+1)
        double** parr = 0, **parr1 = 0;
        GetMemory(parr, n + 1, m + 1);
        GetMemory(parr1, n + 1, m + 1);
 
        // Обнуляем вспомогательные матрицы
        for(i = 0; i < n + 1; ++i)
            for(j = 0; j < m + 1; ++j)
            {
                parr[i][j] = 0;
                parr1[i][j] = 0;
            }
 
        //Инициируем матрицу parr (матрица содержит нули)
        for(i = 0; i < n; ++i)
            for(j = 0; j < m; ++j)
            if(pmatrix[i][j] >= 0)// если в матрице pmatrix найден неотрицательный элемент то на его место в матрице parr пишем 1
                parr[i][j] = 1;
 
        std::cout << "Исходная матрица\n";
        //DisplayMatrix(parr);
        DisplayMatrix(pmatrix);
 
        // Нахождение сумм по столбцам матрицы parr алгоритмом Кадане
        for(i = n - 1; i >= 0; --i)// цикл по строкам начиная с предпоследней стрки
            for(j = m - 1; j >= 0; --j)// цикл по столбцам начиная с предпоследнего столбца
            {
                if(parr[i][j])// если элемент строки равен 1 то
                    parr[i][j] += parr[i][j + 1];// то суммируем его с лежащим правее и перезаписываем (алгоритм Кадане)
            }
 
        //std::cout << "\n1. Сумма по столбцам\n";
        //DisplayMatrix(parr);
 
        // Поиск максимальнго элемента в матрице parr
        int maxrows = MaxElement(parr);
 
        // Сумма по строкам
        int maxcol = 0;// число элементов в найденной подматрице
        int imaxcol = 0, jmaxcol = 0, kmax = 0;// координаты левого верхнего угла найденной подматрицы и число столбцов в ней
        for(k = 1; k <= maxrows; ++k)// цикл по искомым подматрицам всех возможных размеров
        {
            CopyMatrixNumber(parr, parr1, k);// копируем элементы матрицы parr равные k в матрицу parr1
            //std::cout << "\ncopied: k:" << k << "\n";
            //DisplayMatrix(parr1);
 
            // Преобразуем матрицу parr1
            for(j = m - 1; j >= 0; --j)// цикл по столбцам матрицы parr1 начиная с предпоследнего столбца
            {
                for(i = n - 1; i >= 0; --i)// цикл по строкам матрицы parr1 начиная с предпоследней стрки
                {
                    if(parr1[i][j])// если элемент не нулевой то
                        parr1[i][j] += parr1[i + 1][j];// то суммируем его с нижележащим и перезаписываем
                }
 
            }
            int tmpmax =  MaxElement(parr1);// находим макс. число элементов подматрицы для подматриц текущего размера k
            //std::cout << "\n\nk: " << k << ", tmpmax: " << tmpmax << "\n\n";
            //DisplayMatrix(parr1);
            if(maxcol < tmpmax)// если найденный макс. элемент больше предыдущего то перезаписываем его и запоминаем  строку, столбец и число столбцов найденной подматрицы
            {
                maxcol = tmpmax;// перезапись числа элементов подматрицы
                imaxcol = imax;// перезапись координаты i подматрицы
                jmaxcol = jmax;// перезапись координаты j подматрицы
                kmax = k;// перезаписываем число столбцов найденной подматрицы
            }
        }
        //std::cout << "\n\nЧисло элементов в подматрице: " << maxcol << "\n";
        std::cout << "Найденная подматрица:\n";
        std::cout << "Размер подматрицы: " << maxcol / kmax << " x " << kmax << '\n';
        std::cout << "Координаты левого верхнего элемента подматрицы: ";
        std::cout << "[ " << imaxcol << " , " << jmaxcol << " ]\n\n";
 
        double** pmatrixres = new double*[maxcol / kmax];// выделение памяти для найденной подматрицы
        for(i = 0; i < maxcol / kmax; ++i)
            pmatrixres[i] = new double[kmax];// выделение памяти для найденной подматрицы
 
        //копирование найденной подматрицы в выделенную память и вывод на экран найденной подматрицы
        for(i = imaxcol; i < imaxcol + maxcol / kmax; ++i)
        {
            for(j = jmaxcol; j < jmaxcol + kmax; ++j)
            {
                pmatrixres[i - imaxcol][j - jmaxcol] = pmatrix[i][j];
                std::cout << std::setw(10) << std::left << pmatrixres[i - imaxcol][j - jmaxcol];
            }
            std::cout << "\n\n";
        }
        std::cout << "\nОтсортированные совместно по убыванию последние столбец и строка\n";
        SortPrintLastColumnRow(pmatrix);
 
        // Освобождение памяти
        FreeMemory(pmatrix, n);
        FreeMemory(parr, n + 1);
        FreeMemory(parr1, n + 1);
        FreeMemory(pmatrixres, maxcol / kmax);
    }
    catch(...){}
    system("pause");
    return 0;
}

	16.05.2013, 11:06