编程练习-动态规划（矩阵乘法）

动态规划中的矩阵乘法问题是一个非常典型的题目，熟悉了这个问题，将有利与解决如下几个相关问题，其实这些问题都是同一类问题：

1、最优二叉查找树问题，算法导论P212 15.5章节

2、求数组中最长递增子序列 编程之美P194 2.16章节

下面是实例程序：

#include <stdio.h>
#include <vector>
#include <boost/scoped_ptr.hpp>
template<typename T>
class ArrayInternal {
 public:
  ArrayInternal(T* array_data, int row_length) : data_(array_data), row_length_(row_length) {}
  T& operator[] (size_t y) {
    if (x_ > row_length_ || y > row_length_) {
      printf("out of bound\n");
      exit(0);
    } else {
      return data_[(x_ - 1) * row_length_ + y -1];      
    }
  }
  void SetX(size_t x) {
    x_ = x;
  }
 private:
  size_t x_;
  T* data_;
  size_t row_length_;
};
template<typename T>
class TwoDimensionArray {
 public:
  TwoDimensionArray(T* array_data, int row_length) : internal_(array_data, row_length) { }
  ArrayInternal<T>& operator[] (size_t x) {
    internal_.SetX(x);
    return internal_;
  }
 private:
  ArrayInternal<T> internal_;
};
void PrintMultiplicationResult(TwoDimensionArray<unsigned int>& memo, size_t i, size_t j) {
  if (i == j) {
    printf("A%zd", i);
  } else {
    printf("(");
    PrintMultiplicationResult(memo, i, memo[i][j]);
    PrintMultiplicationResult(memo, memo[i][j] + 1, j);
    printf(")");
  }
}

void MatrixMultiplication(const std::vector<unsigned int>& matrixs) {
  if (matrixs.size() <= 1) {
    return;
  }
  size_t matrixs_num = matrixs.size() - 1;
  boost::scoped_ptr<unsigned int> cost(new unsigned int[matrixs_num * matrixs_num]);
  TwoDimensionArray<unsigned int> cost_array(cost.get(), matrixs_num); //this array start from 1 end to n
  boost::scoped_ptr<unsigned int> memo(new unsigned int[matrixs_num * matrixs_num]);
  TwoDimensionArray<unsigned int> memo_array(memo.get(), matrixs_num);
  for (int i = 1; i <= matrixs_num; ++i) {
    cost_array[i][i] = 0;
  }
  int j = 0;
  unsigned int tmp_cost;
  for (int length = 2; length <= matrixs_num; ++length) {
    for ( int i = 1; i <= matrixs_num - length + 1; ++i) {
      j = i + length - 1;
      cost_array[i][j] = 0xFFFFFFFF;
      for (unsigned int k = i; k <= j - 1; ++k) {
        tmp_cost = cost_array[i][k] + cost_array[k + 1][j] + matrixs[i - 1] * matrixs[k] * matrixs[j];
        if ( tmp_cost < cost_array[i][j]) {
          cost_array[i][j] = tmp_cost;
          memo_array[i][j] = k;
          printf("--i = %d, j = %d cost = %d\n", i, j, tmp_cost);
        }
      }
    }
  }
  PrintMultiplicationResult(memo_array, 1, matrixs_num);
  printf("\n");
}
    
void TwoDimensionArrayTest() {
  unsigned int array_buffer[100] = {};
  TwoDimensionArray<unsigned int> array(array_buffer, 10);
  array[1][2] = 3;
  for (int i = 1; i <= 10; ++i) {
    for(int j = 1; j <= 10; ++j) {
      printf("%d ", array[i][j]);
    }
    printf("\n");
  }
  array[1][2] = 0;
}
int main(int argc, char** argv) {
  int matrix_dimension_array[] = {30, 35, 15, 5, 10, 20, 25};
  std::vector<unsigned int> matrixs(matrix_dimension_array, matrix_dimension_array + sizeof(matrix_dimension_array) / sizeof(int));
  MatrixMultiplication(matrixs);
}

程序中为了二元数组坐标计算的方便，编写了一个二维数组类，坐标的访问清晰了不少，这个二位数组类完成坐标内部的变换与封装工作，有利于程序的清晰。

参考文献：

算法导论 P197