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

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

Восстановить пароль Регистрация
Другие темы раздела
C++ Интеграция кода c++ в java http://www.cyberforum.ru/cpp-beginners/thread866200.html
Вот решил переписать пример с одной книги где показано как в код java вставить код c++. Но почему-то много ошибок, не подскажете почему? #include <iostream> #include "A.h" #include "jni.h" JNIEXPORT void JNICALL Java_A_show(JNIEnv *env, jobject obj) { jclass cls; jfieldID fid; jint i;
C++ Помощь с фиксом ошибок Код: // ConsoleApplication2.cpp: определяет точку входа для консольного приложения. // #include "stdafx.h" #include <stdio.h> #define OS_TYPE 0xF0 //0xF0 - Windows, 0x0F - Linux #if OS_TYPE & 0xF0 // Windows http://www.cyberforum.ru/cpp-beginners/thread866188.html
C++ Как контролировать правильность ввода?
В переменные типов unsigned и double нужно записать численное значение. Какие есть способы контроля ввода для избежания ввода символов, слов и строк при этом?
Поиск из считываемого файла C++
# include <iostream> #define N 100 using namespace std; struct avia { char surname; char initials; // group char city ; // name int number; // price
C++ Сортировать из считываемого файла http://www.cyberforum.ru/cpp-beginners/thread866175.html
Как отсортировать из считываемого файла? # include <iostream> #define N 100 using namespace std; struct avia { char surname; char initials; // group char city ; // name
C++ Оформить в виде функции на С/С++ решение задачи Помогите пожалуйста подробнее

Показать сообщение отдельно
cyberbrain1000
 Аватар для cyberbrain1000
23 / 23 / 3
Регистрация: 15.04.2013
Сообщений: 62
16.05.2013, 11:06     Динамический массив,двумерный с плавающей точкой(коммент кода)
здесь общий смысл в том что для нахождения подматрицы максимального размера сначала идет накопление сумм элементов по строкам матрицы, а потом накопление сумм по столбцам, и из найденных сумм по столбцам берётся наибольшая (это и есть кол-во элементов искомой подматрицы). Можете погуглить, это известный алгоритм.
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;
}
 
Текущее время: 16:19. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru