编程练习-动态规划（最长公共子序列LCS)

程序代码如下：

#include <stdio.h>#include <vector>#include <boost/scoped_ptr.hpp>template<typename T>class DualArrayInternal { public:  DualArrayInternal(T* array_data, size_t column_num) : array_data_(array_data), column_num_(column_num) {  }  T& operator[](size_t y) {    return array_data_[x_ * column_num_ + y];  }  const T& operator[](size_t y) const {    return array_data_[x_ * column_num_ + y];  }  void SetX(size_t x) {    x_ = x;  } private:  size_t x_;  T* array_data_;  size_t column_num_;};template<typename T>class DualArray { public:  DualArray(T* array_data, size_t column_num) : internal_(array_data, column_num) {}  DualArrayInternal<T>& operator[](size_t x) {    internal_.SetX(x);    return internal_;  }  const DualArrayInternal<T>& operator[](size_t x) const{    const_cast<DualArray*>(this)->internal_.SetX(x);    return internal_;  } private:  DualArrayInternal<T> internal_;};void Print(int value) {  printf("%c", value);}template<typename T, typename PrintFun>void PrintSequence(const std::vector<T>& array1,  const DualArray<char>& path_direction, const size_t i, const size_t j, PrintFun print_fun) {  if (i == 0 || j == 0) {    return;  }  if (path_direction[i][j] == 'S') {    PrintSequence(array1, path_direction, i - 1, j - 1, print_fun);    print_fun(array1[i - 1]);  } else if(path_direction[i][j] == 'U') {    PrintSequence(array1, path_direction, i - 1, j, print_fun);  } else {    PrintSequence(array1, path_direction, i, j - 1, print_fun);  }}template<typename T>void LongestCommonSubsequence(std::vector<T>& array1, const std::vector<T>&array2) {  boost::scoped_ptr<size_t> subsequence_length_buffer(new size_t[(array1.size() + 1) * (array2.size() + 1)]);  DualArray<size_t> subsequence_length(subsequence_length_buffer.get(), array2.size() + 1);  boost::scoped_ptr<T> path_direction_buffer(new char[(array1.size() + 1) * (array2.size() + 1)]);  DualArray<char> path_direction(path_direction_buffer.get(), array2.size() + 1 );  for (size_t i = 0; i <= array1.size(); ++i) {    subsequence_length[i][0] = 0;  }  for (size_t j = 0; j <= array2.size(); ++j) {    subsequence_length[0][j] = 0;  }  for (size_t i = 1; i <= array1.size(); ++i) {    for (size_t j = 1; j <= array2.size(); ++j) {      if (array1[i - 1] == array2[j - 1]) {          subsequence_length[i][j] = subsequence_length[i - 1][j - 1] + 1;          path_direction[i][j] = 'S';        } else if (subsequence_length[i - 1][j] >= subsequence_length[i][j - 1]) {          subsequence_length[i][j] = subsequence_length[i - 1][j];          path_direction[i][j] = 'U';        } else {          subsequence_length[i][j] = subsequence_length[i][j - 1];          path_direction[i][j] = 'L';        }              }  }  for (int i = 0; i <= array1.size(); ++i) {    for(int j = 0; j <= array2.size(); ++j) {      printf("%zd ", subsequence_length[i][j]);    }    printf("\n");  }       PrintSequence(array1, path_direction, array1.size(), array2.size(),Print);  printf("\n");}class Test{};int main(int argc, char** argv) {  char array1[] = {'B', 'D', 'C', 'A', 'B', 'A'};  std::vector<char> array_vector1(array1, array1 + sizeof(array1) / sizeof(char));  char array2[] = {'A', 'B', 'C', 'B', 'D', 'A', 'B'};  std::vector<char> array_vector2(array2, array2 + sizeof(array2) / sizeof(char));  LongestCommonSubsequence<char>(array_vector2, array_vector1);}

关键是下标的处理问题，容易出现错误的几点是：

1）保存矩阵的行列数量要计算清楚，矩阵多出1行和1列用于存储初始值，这样初始时i-1和j-1的位置不会溢出

2）由于矩阵的下标从1开始，而传入的向量下标从0开始，因此访问向量时下标要-1，对于Print函数也是如此

3）注意DualArray的常量成员函数实现，为了满足常量参数调用的需要，内部需要转型操作

4）Print的实现允许用户定义的访问函数，通过函数模板参数实现