Изменения

'''Задача о порядке перемножения матриц''' — классическая задача, которая может быть решена с помощью динамического программирования. В этой задаче нам дана последовательность матриц, в которой мы хотим найти самый эффективный способ перемножения их. На самом деле задача заключается не в нахождении результата перемножения, а просто нужно найти порядокв нахождении нужного порядока, в котором нам надо их перемножитьмы будем перемножать.

У нас есть много способов, потому что перемножение ассоциативнооперация перемножения ассоциативна. Другими словами, нет разницы как мы расставим скобки между множителями, результат будет один и тот же. Например, если у нас есть четыре матрицы ''A'', ''B'', ''C'' и ''D'', то у нас есть следующие варианты:

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

Как это сделать? Мы можем перебрать все расстановки скобок (brute force), но время выполнение этого алгоритма будет эксапаненциально рости от ''n'' количества матриц. Решение данной проблемы, как мы увидим — это разбить нашу задачу на подзадачи. С Так же мы увидим, что с помощю решения подзадач по одному разу однократного решения подзадачи и повторного использования решенияответа, мы сможем заметно сократить асимптотику. Эта задача входит в классические задачи

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

Для примерНапример, если у нас есть четыре матрицы ''ABCD'', мы посчитаем для (''A'')(''BCD''), (''AB'')(''CD''), и (''ABC'')(''D''), делая рекурсивные вызовы, чтобы найти минимальную стоимость на ''ABC'', ''AB'', ''CD'', и ''BCD''. Потом среди них мы выбираем лучший вариант. Так же, этот алгоритм дает не только минимальную стоимость, но и показывает наилучший способ перемножить матрицыперемножения матриц: нужно только сгрупировать тем же образом, каким дается нам минимальная стоимость и сделать тоже самое для каждого множителяперемножить их между собой.

Внезапно, если мы применим этот алгоритм, то мы обнаружим, что это так же медленно, как и наивный способ перебирания всех скобочных последовательностей! Что пошло не так? Ответом на этот вопрос является тофакт, что мы делаем много ненужной работы. Например, в выше описанном алгоритме, мы сделали рекурсивный вызов, чтобы найти наилучшую стоимость для подсчета ''ABC'' и ''AB''. Но нахождение лучшей наилучшей стоимости для подсчета ''ABC'' так же требует нахождения лучшей стоимости для ''AB''. Так как рекурсия растет вглбь все больше и больше, то и число ненужных повторений увеличивается.

Псевдокод Одно из простых решений — это меморизация. Каждый раз, когда мы считаем минимальную стоимость перемножения определенной подпоследовательности, давайте мы будем запоминать ответ. Если мы когда либо ещё раз захотим посчитать это ещё раз, то мы уже будет иметь ответ и не будем пересчитывать. Поскольку существует всего около <math>n^2/2</math>, где ''n'' — это количество матриц, то память занимаемая программой будет не так велика. Можно сказать, что с помощью этого простого трюка мы уменьшили асимптотику алгоритма с O(<math>2n</math>) до O(без меморизации<math>n^3</math>), что является достаточно эффективным для реальных приложений. Псевдокод:

 int dp[1000][1000];vector<pair<int, int> > v;// Matrix Ai has dimension pv[i].first — размер i-1той матрицы по горизонтали // v[i] x p.second — размер i-той матрицы по вертикали// dp[i] for [j] — меморизация на отрезке [i = 1..n, j)Matrix-Chain-Orderint matrixChainMultiplication(int p[]l, int r)

// length[p] = n + 1 n = p.length - 1;l — включая в отрезок // m[i,j] = Minimum number of scalar multiplications (i.e., cost)r — исключая из отрезка // needed to compute the matrix A if dp[il]A[i+1]...A[jr] = A[i..j]= -1 // cost is zero when multiplying one matrix for (i if l == r - 1; i <= n; i++) m dp[i,il][r] = 0; else for (L dp[l][r] =21000 * 1000 * 1000; L<=n; L++) { // L is chain length for (int i=l + 1; i<=n-L+1r; i++) { j = i+L-1; m dp[l][i,jr] = MAXINT; for min(k=i; k<=j-1; k++) { // q = cost/scalar multiplications q = mdp[i,kl] + m[k+1r],j] + pv[i-1l].first *pv[ki].first *pv[jr - 1]; if .second + matrixChainMultiplication(q < m[l, i,j]) { m[+ matrixChainMultiplication(i,j] = qr)); // s return dp[i,jl] = Second auxiliary table that stores k // k = Index that achieved optimal cost s[i,jr] = k; } } } }