Optimal BST realization

Author: kromberg

General/General.vcxproj

@@ -118,6 +118,7 @@
  <ClInclude Include="Knapsack.h" />
  <ClInclude Include="Matrix.h" />
  <ClInclude Include="MaxWIS.h" />
+ <ClInclude Include="OptimalBST.h" />
  <ClInclude Include="SequenceAlignment.h" />
  </ItemGroup>
  <ItemGroup>
@@ -126,6 +127,7 @@
  <FileType>CppCode</FileType>
  </ClInclude>
  <ClCompile Include="MaxWIS.cpp" />
+ <ClCompile Include="OptimalBST.cpp" />
  <ClCompile Include="SequenceAlignment.cpp" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

General/General.vcxproj.filters

@@ -27,6 +27,12 @@
  <ClInclude Include="Matrix.h">
  <Filter>Header Files</Filter>
  </ClInclude>
+ <ClInclude Include="Matrix.hpp">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="OptimalBST.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
  </ItemGroup>
  <ItemGroup>
  <ClCompile Include="MaxWIS.cpp">
@@ -38,8 +44,8 @@
  <ClCompile Include="SequenceAlignment.cpp">
  <Filter>Source Files</Filter>
  </ClCompile>
- <ClCompile Include="Matrix.hpp">
- <Filter>Header Files</Filter>
+ <ClCompile Include="OptimalBST.cpp">
+ <Filter>Source Files</Filter>
  </ClCompile>
  </ItemGroup>
 </Project>

General/Matrix.h

@@ -19,18 +19,21 @@ class Matrix
 
 public:
  Matrix();
- Matrix(uint64_t rowsCount, uint64_t colsCount) throw (std::bad_alloc);
- Matrix(const Matrix<ValueType>& matrix) throw (std::bad_alloc);
+ Matrix(uint64_t rowsCount, uint64_t colsCount);
+ Matrix(const Matrix<ValueType>& matrix);
  Matrix(Matrix<ValueType>&& matrix);
  ~Matrix();
 
  ValueType* operator[] (uint64_t i);
 
  void reset();
- void resize(uint64_t rowsCount, uint64_t colsCount) throw (std::bad_alloc);
+ void resize(uint64_t rowsCount, uint64_t colsCount);
 
  const uint64_t getRowsCount() const;
  const uint64_t getColsCount() const;
+
+ template <typename U>
+ friend std::ostream& operator << (std::ostream& out, Matrix<U>& matrix);
 };
 
 template<typename T>

General/Matrix.hpp

@@ -7,7 +7,7 @@ Matrix<T>::Matrix():
 }
 
 template<typename T>
-Matrix<T>::Matrix(uint64_t rowsCount, uint64_t colsCount) throw (std::bad_alloc) :
+Matrix<T>::Matrix(uint64_t rowsCount, uint64_t colsCount) :
  m_rowsCount(rowsCount),
  m_colsCount(colsCount),
  m_matrix()
@@ -16,7 +16,7 @@ Matrix<T>::Matrix(uint64_t rowsCount, uint64_t colsCount) throw (std::bad_alloc)
 }
 
 template<typename T>
-Matrix<T>::Matrix(const Matrix<T>& matrix) throw (std::bad_alloc) :
+Matrix<T>::Matrix(const Matrix<T>& matrix) :
  m_rowsCount(matrix.m_rowsCount),
  m_colsCount(matrix.m_colsCount),
  m_matrix()
@@ -56,7 +56,7 @@ void Matrix<T>::reset()
 }
 
 template<typename T>
-void Matrix<T>::resize(uint64_t rowsCount, uint64_t colsCount) throw (std::bad_alloc)
+void Matrix<T>::resize(uint64_t rowsCount, uint64_t colsCount)
 {
  std::unique_ptr<ValueType> matrix(new ValueType[rowsCount * colsCount]);
  uint64_t minColsCount = std::min(m_colsCount, colsCount);
@@ -69,4 +69,22 @@ void Matrix<T>::resize(uint64_t rowsCount, uint64_t colsCount) throw (std::bad_a
  m_rowsCount = rowsCount;
  m_colsCount = colsCount;
  m_matrix = std::move(matrix);
+}
+
+template <typename U>
+std::ostream& operator << (std::ostream& out, Matrix<U>& matrix)
+{
+ for (uint64_t i = 0; i < matrix.m_rowsCount; ++i)
+ {
+ for (uint64_t j = 0; j < matrix.m_colsCount; ++j)
+ {
+ if (j != 0)
+ {
+ out << ' ';
+ }
+ out << matrix[i][j];
+ }
+ out << std::endl;
+ }
+ return out;
 }

General/OptimalBST.cpp

@@ -0,0 +1,160 @@
+#include <algorithm>
+
+#include "OptimalBST.h"
+
+
+OptimalBST::Node::Node():
+ m_left(),
+ m_right(),
+ m_idx(0)
+{}
+
+OptimalBST::Node::~Node()
+{
+ m_left.reset();
+ m_right.reset();
+}
+
+OptimalBST::MatrixEntity::MatrixEntity() :
+ m_val(0),
+ m_rootPos(0)
+{}
+
+OptimalBST::MatrixEntity::MatrixEntity(MatrixEntity&& matrixEntity)
+{
+ m_val = matrixEntity.m_val;
+ m_rootPos = matrixEntity.m_rootPos;
+ matrixEntity.m_val = 0;
+ matrixEntity.m_rootPos = 0;
+}
+
+std::ostream& operator<< (std::ostream& out, OptimalBST::MatrixEntity& matrixEntity)
+{
+ out << "[rootPos : " << matrixEntity.m_rootPos << " ; val : " << matrixEntity.m_val << ']';
+ return out;
+}
+
+OptimalBST::OptimalBST():
+ m_probabilities()
+{
+}
+
+OptimalBST::~OptimalBST()
+{
+}
+
+void OptimalBST::clear()
+{
+ m_probabilities.clear();
+}
+
+bool OptimalBST::read(std::istream& in)
+{
+ clear();
+
+ uint32_t numElements = 0;
+ in >> numElements;
+ m_probabilities.resize(numElements);
+
+ for (auto& probability : m_probabilities)
+ {
+ in >> probability;
+ }
+
+ return true;
+}
+
+bool OptimalBST::run(double &c)
+{
+
+ uint32_t numProbabilities = static_cast<uint32_t>(m_probabilities.size());
+ m_matrix.resize(numProbabilities, numProbabilities);
+
+ // utility structures
+ MatrixEntity minVal;
+ double tmpVal = 0;
+ for (uint32_t s = 0; s < numProbabilities; ++s)
+ {
+ for (uint32_t i = 0; i < numProbabilities - s; ++i)
+ {
+ double probSum = 0;
+ for (uint32_t k = i; k <= i + s; ++k)
+ {
+ probSum += m_probabilities[k];
+ }
+
+ // r = i
+ minVal.m_rootPos = i;
+ minVal.m_val = ((i + 1) > (i + s)) ? 0 : m_matrix[i + 1][i + s].m_val;
+ for (uint32_t r = i + 1; r <= i + s; ++r)
+ {
+ tmpVal = ((i + 1 > r) ? 0 : m_matrix[i][r - 1].m_val) +
+ (((r + 1) > (i + s)) ? 0 : m_matrix[r + 1][i + s].m_val);
+ if (tmpVal < minVal.m_val)
+ {
+ minVal.m_val = tmpVal;
+ minVal.m_rootPos = r;
+ }
+ }
+ minVal.m_val += probSum;
+ m_matrix[i][i + s] = std::move(minVal);
+ }
+ }
+
+ c = m_matrix[0][numProbabilities - 1].m_val;
+
+ formTree(m_tree, m_matrix, 0, numProbabilities - 1);
+
+ return true;
+}
+
+void OptimalBST::formTree(
+ std::unique_ptr<Node>& tree,
+ Matrix<MatrixEntity>& matrix,
+ const uint32_t begin,
+ const uint32_t end)
+{
+ if (begin > end)
+ {
+ return;
+ }
+ else if (begin == end)
+ {
+ tree.reset(new Node);
+ tree->m_idx = begin;
+ return;
+ }
+ tree.reset(new Node);
+ tree->m_idx = matrix[begin][end].m_rootPos;
+ formTree(tree->m_left, matrix, begin, (matrix[begin][end].m_rootPos >= 1) ? (matrix[begin][end].m_rootPos - 1) : 0);
+ formTree(tree->m_right, matrix, matrix[begin][end].m_rootPos + 1, end);
+}
+
+void OptimalBST::writeTree(
+ const std::unique_ptr<Node>& tree,
+ std::ostream& out,
+ const std::string& indent)
+{
+ if (!tree)
+ {
+ return;
+ }
+ writeTree(tree->m_right, out, indent + " ");
+ out << indent << tree->m_idx << " : " << m_probabilities[tree->m_idx] << std::endl;
+ writeTree(tree->m_left, out, indent + " ");
+}
+
+bool OptimalBST::write(std::ostream& out)
+{
+ out << m_matrix;
+
+ uint32_t numProbabilities = static_cast<uint32_t> (m_probabilities.size());
+ for (uint32_t i = 0; i < numProbabilities; ++i)
+ {
+ out << i << " : " << m_probabilities[i] << std::endl;
+ }
+
+ // write tree
+ writeTree(m_tree, out);
+ return true;
+}

General/OptimalBST.h

@@ -0,0 +1,57 @@
+#ifndef OPTIMAL_BST_H
+#define OPTIMAL_BST_H
+
+#include <memory>
+#include <vector>
+#include <fstream>
+#include <string>
+#include <cstdint>
+
+#include "Matrix.h"
+
+class OptimalBST
+{
+private:
+ struct Node
+ {
+ std::unique_ptr<Node> m_left;
+ std::unique_ptr<Node> m_right;
+ uint32_t m_idx;
+ Node();
+ ~Node();
+ };
+ struct MatrixEntity
+ {
+ double m_val;
+ uint32_t m_rootPos;
+ MatrixEntity();
+ MatrixEntity(MatrixEntity&& matrixEntity);
+ };
+ friend std::ostream& operator<< (std::ostream& out, MatrixEntity& matrixEntity);
+
+ std::vector<double> m_probabilities;
+ Matrix<MatrixEntity> m_matrix;
+ std::unique_ptr<Node> m_tree;
+
+private:
+ void formTree(
+ std::unique_ptr<Node>& tree,
+ Matrix<MatrixEntity>& matrix,
+ const uint32_t begin,
+ const uint32_t end);
+ void writeTree(
+ const std::unique_ptr<Node>& tree,
+ std::ostream& out,
+ const std::string& indent = "");
+ void clear();
+
+public:
+ OptimalBST();
+ ~OptimalBST();
+
+ bool read(std::istream& in);
+ bool write(std::ostream& out);
+ bool run(double &c);
+};
+
+#endif // OPTIMAL_BST_H

General/SequenceAlignment.cpp

@@ -59,11 +59,11 @@ bool SequenceAlignment::run(
  Matrix<uint32_t> nwScore(size[0], size[1]);
  for (uint64_t i = 0; i < size[0]; ++i)
  {
- nwScore[i][0] = (i + 1) * m_gapScore;
+ nwScore[i][0] = static_cast<uint32_t>((i + 1) * m_gapScore);
  }
  for (uint64_t i = 0; i < size[1]; ++i)
  {
- nwScore[0][i] = (i + 1) * m_gapScore;
+ nwScore[0][i] = static_cast<uint32_t>((i + 1) * m_gapScore);
  }
 
  uint32_t tmpScore[3];

test/main.cpp

@@ -14,6 +14,7 @@
 #include "graphs/GraphMatrix.h"
 #include "General/Knapsack.h"
 #include "General/SequenceAlignment.h"
+#include "General/OptimalBST.h"
 
 void knapsackFunc()
 {
@@ -50,9 +51,27 @@ void sequenceAlignmentFunc()
  std::cin.get();
 }
 
+void optimalBSTFunc()
+{
+ OptimalBST optimalBST;
+ std::ifstream fin("optimal_bst.in");
+ if (!optimalBST.read(fin))
+ {
+ std::cout << "Cannot read OptimalBST" << std::endl;
+ exit(2);
+ }
+ double val = 0;
+ optimalBST.run(val);
+ std::cout << "Value : " << val << std::endl;
+ optimalBST.write(std::cout);
+
+ std::cin.get();
+}
+
+
 int main(int argc, const char * argv[])
 {
- sequenceAlignmentFunc();
+ optimalBSTFunc();
 #if 0
  // insert code here...
  std::cout << "Creating graph.\n";

test/optimal_bst.in

@@ -0,0 +1,2 @@
+7
+0.01 0.20 0.14 0.15 0.17 0.25 0.05