编程练习-动态规划（最长公共子序列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的实现允许用户定义的访问函数，通过函数模板参数实现