Задача о порядке перемножения матриц

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

Подробное описание задачи

Произведение матриц — ассоциативная операция, которая принимает на вход две матрицы размером k×m и m×n и возвращает матрицу размером k×n, потратив на это kmn операций умножения[1].

Когда матрицы велики по одному измерению и малы по другому, количество скалярных операций может серьёзно зависеть от порядка перемножений матриц. Допустим, нам даны 3 матрицы размерами соответственно 10×100, 100×5 и 5×50. Существует 2 способа их перемножения (расстановки скобок): и . В первом случае нам потребуется 10·100·5 + 10·5·50 = 7500 скалярных умножений, а во втором случае 100·5·50 + 10·100·50 = 75000 умножений — разница налицо. Поэтому может быть выгоднее потратить некоторое время на предобработку, решив, в каком порядке лучше всего умножать, чем умножать сразу в лоб.

Таким образом, даны n матриц: , , …, . Требуется определить, в каком порядке перемножать их, чтобы количество операций умножения было минимальным.

Решение задачи

Разберём 2 способа решения задачи, чтобы показать, насколько выгодно динамическое программирование в данном случае.

Перебор всех вариантов расстановки скобок

Оценим, сколько же нужно перебрать вариантов расстановки. Обозначим через количество способов расстановки скобок в последовательности, состоящей из n матриц. Когда матрица одна, то расставлять нечего, вариант один. Если , то количество вариантов, которым можно расставить скобки является произведением количества вариантов, которым можно расставить скобки в составляющих результирующую матрицу произведениях (т.е. если , то количество вариантов, которым мы можем получить матрицу равно произведению количества способов получить матрицу на количество способов получить ). Разбиение на матрицы, и может производиться на границе k-й и (k + 1)-й матриц для . Получаем рекуррентное соотношение:

Решением аналогичного рекуррентного соотношения является последовательность чисел Каталана, возрастающая как . Зависимость получается экспоненциальная, непригодная для практического применения в программах. Разберём более перспективный способ.

Динамическое программирование

Сведение задачи к подзадачам

Обозначим результат перемножения матриц через , где i<=j. Если i<j, то существует такое k, которое разбивает между матрицами и , i<=k<j. То есть для вычисления надо сначала вычислить , потом и затем их перемножить. Выбор k является аналогом расстановки скобок между матрицами. Выбрав некоторое k мы свели задачу к двум аналогичным подзадачам для матриц и .

Рекурсивное решение

Обозначим через m[i, j] минимальное количество скалярных умножений для вычисления матрицы . Получаем следующее рекуррентное соотношение:

Объясняется оно просто: для того, чтобы найти произведение матриц при i=j не нужно ничего делать — это и есть сама матрица . При нетривиальном случае мы перебираем все точки разбиения матрицы на матрицы и , ищем кол-во операций, необходимое чтобы их получить и затем перемножаем для получения матрицы .(Оно будет равно кол-ву операций, потраченное на решение подзадач + стоимость умножения матриц ). Считаем, что размеры матриц заданы в массиве и размер матрицы равен . Как обычно рекурсивный метод нельзя использовать напрямую — он будет экспоненциальным из-за большого кол-ва перекрывающихся подзадач.

Динамическое программирование

Будем запоминать в двумерном массиве m результаты вычислений для подзадач, чтобы избежать пересчета для уже вычислявшихся подзадач. После вычислений ответ будет в m[1,n](Сколько перемножений требуется для последовательности матриц от 1 до n — то есть ответ на поставленную задачу).Сложность алгоритма будет O, так как у нас вариантов выбора i, j : и точек разделения для каждого варианта. Детали станут понятны из реализации.

Реализация

Java

В методе main – пример из начала статьи. Если запустить, выведет 7500, как и ожидается.

public class MatrixChain {
     /*
	 * Возвращает ответ на задачу об оптимальном перемножении матриц, используя
     * динамическое программирование.
	 * Асимптотика решения - O(N^3) время и O(N^2) память.
	 * 
	 * @param p массив размеров матриц, см.статью 
	 * @return минимальное количество скалярных умножений, необходимое для решения задачи
	 */	
    public static int multiplyOrder(int[] p) {
		int n = p.length - 1;
		int[][] dp = new int[n][n];
		
		for (int i = 0; i < n; ++i) {
			dp[i][i] = 0;
		}
		
		for (int l = 1; l < n; ++l) {
			for (int i = 0; i < n - l; ++i) {
				int j = i + l;
				dp[i][j] = Integer.MAX_VALUE;
				for (int k = i; k < j; ++k) {
					dp[i][j] = Math.min(dp[i][j],
                                        dp[i][k] + dp[k + 1][j] + p[i] * p[k + 1] * p[j + 1]);
				}
			}
		}
		return dp[0][n - 1]; 
	}
	
	public static void main(String[] args) {
		int[] test = { 10, 100, 5, 50 };
		System.out.println(MatrixChain.multiplyOrder(test));
	}
}


C#

Приведены только методы, которые непосредственно выполняют необходимые расчеты

dataStore — объект класса, который хранит все данные

Его атрибуты:

public List<List<int>> m;		            //матрица m
public List<List<int>> s;				    //матрица s
public List<List<int>> result;			    //результат всех перемножений
public List<List<List<int>>> source;	    //массив из 2-мерных матриц (A0,A1,...,An) которые нужно перемножить
public List<int> sizes = new List<int>();	//размеры матриц (записаны таким образом - 12,10,7,4 => значит 3 матрицы размерами 12x10,10x7,7x4)
public string order = new string('a', 0);	//правильное расположение скобок

Функциональные участки кода:

//© Paulskit 27.03.2010
//метод который находит матрицу m и s (там же под них и выделяется память)
private void matrixChainOrder(){
	int n = dataStore.sizes.Count - 1;

	//выделяем память под матрицы m и s
	dataStore.m = new List<List<int>>();
	dataStore.s = new List<List<int>>();
	for (int i = 0; i < n; i++){
	    dataStore.m.Add(new List<int>());
	    dataStore.s.Add(new List<int>());
	    //заполняем нулевыми элементами
	    for (int a = 0; a < n; a++) {
	        dataStore.m[i].Add(0);
	        dataStore.s[i].Add(0);
	    }
	}
	//выполняем итерационный алгоритм
	int j;
	for (int l = 1; l < n; l++) {
	    for (int i = 0; i < n - l; i++) {
	        j = i + l;
	        dataStore.m[i][j] = int.MaxValue;
	        for (int k = i; k < j; k++) {
                int q = dataStore.m[i][k] + dataStore.m[k + 1][j] +
	                    dataStore.sizes[i] * dataStore.sizes[k + 1] * dataStore.sizes[j + 1];
	            if (q < dataStore.m[i][j]) {
	                dataStore.m[i][j] = q;
	                dataStore.s[i][j] = k;
	            }
	        }
	    }
    }
}
//метод - простое перемножение 2-х матриц
private List<List<int>> matrixMultiply(List<List<int>> A, List<List<int>> B) {
    int rowsA = A.Count;
    int columnsB = B[0].Count;
    //column count of A == rows count of B
    int columnsA = B.Count;

    //memory alloc for "c"
    List<List<int>> c = new List<List<int>>();
    for (int i = 0; i < rowsA; i++) {
        c.Add(new List<int>());
        for (int a = 0; a < columnsB; a++) {
            c[i].Add(0);
        }
    }

    //do multiplying
    for (int i = 0; i < rowsA; i++) {
        for (int j = 0; j < columnsB; j++) {
            for (int k = 0; k < columnsA; k++) { 
                c[i][j] += A[i][k] * B[k][j];
            }
        }
    }

    //return value
    return c;
}

//метод, который непосредственно выполняет перемножение в правильном порядке
//первоначально вызывается таким образом
//dataStore.result = matrixChainMultiply(0, dataStore.sizes.Count - 2); 
private List<List<int>> matrixChainMultiply(int i, int j) {
	if (j > i) {
        List<List<int>> x = matrixChainMultiply(i, dataStore.s[i][j]);
        List<List<int>> y = matrixChainMultiply(dataStore.s[i][j] + 1, j);
        return matrixMultiply(x, y);
    }
    else return dataStore.source[i];
}

//метод печатающий строку с правильной расстановкой скобок

private void printOrder(int i, int j){
    if (i == j) {
        order += "A" + i.ToString();
    } else {
        order += "(";
        printOrder(i, dataStore.s[i][j]);
        order += "*";
        printOrder(dataStore.s[i][j] + 1, j);
        order += ")";
    }
}

Примечания

К данной задаче сводится задача оптимизации свободной энергии молекулы РНК в биоинформатике (здесь пара скобок в строке мономеров РНК определяет их спаривание). Подобное динамическое программирование реализовано в алгоритмах Nussinov или Zucker.

  1. Существуют и более быстрые, чем kmn, алгоритмы умножения заполненных матриц, но они применяются крайне редко — прирост скорости наблюдается только на матрицах 100×100 и крупнее. Разреженные же матрицы умножают особыми алгоритмами, оптимизированными под ту или иную форму матрицы.

Литература

  • Томас Х. Кормен и др. Алгоритмы: построение и анализ = INTRODUCTION TO ALGORITHMS. — 2-е изд. М.: «Вильямс», 2006. — С. 1296. — ISBN 0-07-013151-1.
  • Sanjoy Dasgupta , Christos H. Papadimitriou, Umesh Vazirani. Algorithms = Algorithms. — 1-е изд. — McGraw-Hill Science/Engineering/Math, 2006. — С. 336. — ISBN 0073523402.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.