Форум программистов, компьютерный форум CyberForum.ru

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

Восстановить пароль Регистрация
 
Fox007
0 / 1 / 0
Регистрация: 11.01.2013
Сообщений: 148
15.05.2013, 19:01     Динамический массив,двумерный с плавающей точкой(коммент кода) #1
\\Динамический массив,двумерный с плавающей точкой, выделить из массива максимальный прямоугольный блок не содержащий отрицательных чисел, данные перенести в новый массив.Отсортировать элементы последней строки и последнего столбца совместно по убыванию.(Прокомментируйте пожалуйста каждую строчку)
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
#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;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
15.05.2013, 19:01     Динамический массив,двумерный с плавающей точкой(коммент кода)
Посмотрите здесь:

C++ Рандом с плавающей точкой, как?
C++ Определите одномерный массив из 10 чисел с плавающей точкой
Усечение числа с плавающей точкой C++
Не выводится число с плавающей точкой C++
C++ Динамический массив,двумерный с плавающей точкой
Создать двумерный массив чисел с плавающей точкой и вывести на экран все числа по диагонали с лева на право C++
C++ Непонятки с плавающей точкой
C++ Сравнение чисел с плавающей точкой

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Ded_Vasilij
 Аватар для Ded_Vasilij
229 / 211 / 15
Регистрация: 01.09.2012
Сообщений: 2,103
15.05.2013, 19:21     Динамический массив,двумерный с плавающей точкой(коммент кода) #2
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
#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
 Аватар для cyberbrain1000
23 / 23 / 3
Регистрация: 15.04.2013
Сообщений: 62
16.05.2013, 11:06     Динамический массив,двумерный с плавающей точкой(коммент кода) #3
здесь общий смысл в том что для нахождения подматрицы максимального размера сначала идет накопление сумм элементов по строкам матрицы, а потом накопление сумм по столбцам, и из найденных сумм по столбцам берётся наибольшая (это и есть кол-во элементов искомой подматрицы). Можете погуглить, это известный алгоритм.
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
#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;
}
Yandex
Объявления
16.05.2013, 11:06     Динамический массив,двумерный с плавающей точкой(коммент кода)
Ответ Создать тему
Опции темы

Текущее время: 07:39. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru