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

Определитель n-ого порядка (непорядок с рекурсией) - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Что за код ? http://www.cyberforum.ru/cpp-beginners/thread55659.html
Подскажите кто знает что выполняет данный код . #define CWS_FIRSTCMDNO 0xe0 typedef enum { MSG_CLIENT_2_SERVER_LOGIN = CWS_FIRSTCMDNO, MSG_CLIENT_2_SERVER_LOGIN_ACK, MSG_CLIENT_2_SERVER_LOGIN_NAK, MSG_CARD_DATA_REQ, MSG_CARD_DATA, MSG_SERVER_2_CLIENT_NAME,
C++ define И еще такой вопрос для чего служит #define ?? http://www.cyberforum.ru/cpp-beginners/thread55650.html
C++ Вывести цифры на экран
Помогите написать на C++ прогу.. На экране должно высветиться так... 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 n=9)
Вопрос по программе на тему: Массивы и указатели. Динамическое выделение памяти C++
народ, очень прошу! пожалуйста! Помогите решить задачку на тему: Массивы и указатели. Динамическое выделение памяти Вот задача. Объявить массив целых чисел и заполнить его случайными значениями. Размер массива и диапазон значений его элементов заданы ниже. № подзадачи - 1 Размерность массива -200 Диапазон значений -50 - 50 Что нужно сделать - Определить среднюю длину непрерывных...
C++ Массивы http://www.cyberforum.ru/cpp-beginners/thread55640.html
Задано несколько массивов меток . Удалить парные массивы.
C++ Используя стек ,переписать строку посимвольно в обратном порядке Используя стек ,переписать строку посимвольно в обратном порядке!!!!!!!!!!! подробнее

Показать сообщение отдельно
GennDALF
12 / 12 / 0
Регистрация: 24.09.2009
Сообщений: 61
02.11.2009, 06:45  [ТС]
Уфф! Наконец-то доделал!
Воистину глобальными переменными вымощена дорога в ад программирования! Вчера я это понял со всей отчетливостью.
Проблема была в том, что переменная det не обнулялась при каждом новом рекурсивном вызове. Поэтому надо в рекурсивной функции объявить внутреннюю переменную и каждый раз ее заново инициализировать.
Итак, код:
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
#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;
 
// объявление прототипов функций
void check_zero(int ** MATRIX, int ORDER, int *LC_NUMBER, bool *LC_CHECK);
int ** matrix_cut(int ** MATRIX, int ORDER, int CUT_LINE_NUMBER, int CUT_COLUMN_NUMBER);
int body(int ** MATRIX, int ORDER, int *LC_NUMBER, bool *LC_CHECK);
void matrix_output(int ** MATRIX, int STRINGS, int COLUMNS);
 
 
// объявление глобальных переменных
int LC = 0;
bool LC_ch = false;
double det = 0;
 
 
int main()
{
      int ord;
      
      cout << "<=N-th ORDER DETERMINANT=>\n\nEnter the order of determinant: ";
      cin >> ord;
 
      int ** mat_det = new int * [ord];
      for (int c = 0; c < ord; c++)
            mat_det[c] = new int [ord];
 
      while (ord != -1)
      {
            int ** mat_det = new int * [ord];
            for (int c = 0; c < ord; c++)
                  mat_det[c] = new int [ord];
 
            cout << "\nEnter the matrix: \n\n";
            for (int i = 0; i < ord; i++) {
                  for (int j = 0; j < ord; j++) {
                        cout << "a" << i+1 << "_" << j+1 << " = ";
                        cin >> mat_det[i][j];
                  }
                  cout << endl;
            }
 
            {
            matrix_output(mat_det, ord, ord);         // вывод исходной матрицы на экран
            cout << endl;                             // красиво смотрится кстати
            //getch();
            }
            
            {                                         // старт расчета, запуск рекурсии
            det = body(mat_det, ord, &LC, &LC_ch);
            }
 
            cout << "Determinant = " << det;
            getch();
 
            {                                         // блок обнуления переменных
                  for (int c = 0; c < ord; c++)
                        delete [] mat_det[c];
                  delete [] mat_det;
                  LC = 0; LC_ch = false;
                  det = 0;
            }     
 
            cout << "\n\n\nEnter the order of determinant: ";
            cin >> ord;
      }
 
      return 0;
}
 
 
int body(int ** MATRIX, int ORDER, int *LC_NUMBER, bool *LC_CHECK)
{
      double DET = 0;
 
      if (ORDER == 1)                           // если наконец разложили до первого порядка, то возвращаем число
            return MATRIX[0][0];
      else 
      {
            check_zero(MATRIX, ORDER, &LC, &LC_ch);    
 
            if (*LC_CHECK)                      // если раскладываем по строке, то так
            {   
                  for (int i = 0; i < ORDER; i++) 
                  {
                        if (MATRIX[*LC_NUMBER][i] == 0)
                              continue;
                        else 
                        {
                              DET += pow(-1, *LC_NUMBER + i) * MATRIX[*LC_NUMBER][i] * 
                                    body( matrix_cut(MATRIX, ORDER, *LC_NUMBER, i), ORDER-1, &LC, &LC_ch);
                        }
                  }
            }
            else                                // если по столбцу, то так.. фишка здесь в смене индексов
            {
                  for (int i = 0; i < ORDER; i++) 
                  {
                        if (MATRIX[i][*LC_NUMBER] == 0)
                              continue;
                        else 
                        {
                              DET += pow(-1, i + *LC_NUMBER) * MATRIX[i][*LC_NUMBER] * 
                                    body( matrix_cut(MATRIX, ORDER, i, *LC_NUMBER), ORDER-1, &LC, &LC_ch);
                        }
                  }
            }
      }
      return DET;
}
 
 
void check_zero(int ** MATRIX, int ORDER, int *LC_NUMBER, bool *LC_CHECK)
{     // смотрим в какой строке или в каком столбце больше нулей
      // в глобальную переменную LC присваивается номер строки или столбца
      // а в такую же глобальную LC_ch присваивается true для строки и false для столбца
 
      int ch_L = 0, ch_C = 0, max_L = 0, max_C = 0, line_num = 0, col_num = 0;
 
      for (int i = 0; i < ORDER; i++)
      {
            for (int j = 0; j < ORDER; j++)
            {
                  if (MATRIX[i][j] == 0)
                  {
                        ch_L++;
                        if (j == ORDER-1 && max_L < ch_L) {
                              max_L = ch_L;
                              line_num = i;
                        }
                  }                       // фишка опять в смене индексов
                  if (MATRIX[j][i] == 0)
                  {
                        ch_C++;
                        if (j == ORDER-1 && max_C < ch_C) {
                              max_C = ch_C;
                              col_num = i;
                        }
                  }
            }
            ch_L = 0; ch_C = 0;
      }
      if (max_L >= max_C) {
            *LC_CHECK = true;
            *LC_NUMBER = line_num;
      }
      else {
            *LC_CHECK = false;
            *LC_NUMBER = col_num;
      }
}
 
 
int ** matrix_cut(int ** MATRIX, int ORDER, int CUT_LINE_NUMBER, int CUT_COLUMN_NUMBER)
{     // делает минор из матрицы n-ого порядка, 
      // т.е. создает матрицу (n-1)ого порядка с вырезанными строкой и столбцом
 
      int order_new = ORDER - 1;
      int **mat_new = new int *[order_new];
      for (int c = 0; c < ORDER-1; c++)
            mat_new[c] = new int [order_new];
 
      int m=0, n=0;
      for (int i = 0; i < ORDER; i++) {
            if (i != CUT_LINE_NUMBER) {
                  for (int j = 0; j < ORDER; j++) {
                        if (j != CUT_COLUMN_NUMBER) {
                              mat_new[m][n] = MATRIX[i][j];
                              n++;
                        }
                        else
                              continue;
                  }
                  m++;
                  n=0;
            }
            else
                  continue;
      }
 
      //check_zero(mat_new, order_new, &LC, &LC_ch);
      //matrix_output(mat_new, order_new, order_new);
      //cout << endl;
      //getch();
      return mat_new;
}
 
 
void matrix_output(int ** MATRIX, int STRINGS, int COLUMNS) {
      if (STRINGS == 1) {
            for (int c = 0; c < COLUMNS; c++)
                  cout << " " << MATRIX[0][c];
      }
      else {
            for (int c = 0; c < STRINGS; c++) {
                  if (c == 0) 
                        cout << '\x2f';
                  else if (c == STRINGS-1)
                        cout << '\x5c';
                  else
                        cout << '\x7c';
 
                  for (int d = 0; d < COLUMNS; d++)
                        cout << " " << MATRIX[c][d];
                  
                  if (c == 0) 
                        cout << " " << '\x5c';
                  else if (c == STRINGS-1)
                        cout << " " << '\x2f';
                  else
                        cout << " " << '\x7c';
 
                  cout << endl;
            }
            // cout << endl;
      }
}
Точно считает 10 порядков, дальше проверять было лень.
Один раз забил матрицу 22-ого порядка: программа крепко задумалась, съела 130 Мб памяти и вылетела
Впринципе, сколько я понимаю, можно попытаться расширить возможности, но я не очень ясно представляю, как это сделать.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru