Question

I need help modifying this program. How would I make sure that the methods is being called and checked in my main method?

Here is what the program needs to run as:

 GDVEGTA GVCEKST
The LCS has length 4
The LCS is GVET

This is the error that I'm getting:

The LCS has length 4 // I got this right

The LCS is   //the backtrace is not being called for some reason

c++ code:

the cpp class:

/**
* calculate the optimum edit distance between two strings
* @author Jerry Lin
* @version 13 April 2017
*/
#include <climits>
#include <iomanip>
#include <iostream>
#include <vector>
#include <string>
#include "matrix.h"
using namespace std;
typedef unsigned int uint;

// set infinity to one less than the maximum so we can add one to
// infinity and not overflow around to zero
const uint INFTY = UINT_MAX - 1;

/**
* find the minimum of three values
* @param a one of the three values
* @param b one of the three values
* @param c one of the three values
* @return the smallest value
*/

uint max3(uint a, uint b, uint c)
{
   uint result = a > b ? a:b;
   return result > c ? result : c;
}

/**
* the recursive, memoized optimum function for computing the edit distance
* between two strings
* @param s the first string
* @param i the index of the first string
* @param t the second string
* @param j the index of the second string
* @param memo the memo table
*/

uint opt( const string & s, uint i, const string & t, uint j,
          Matrix< uint > & memo )
{
   if(i==0 || j==0)
   {
      memo.at(i,j)=0;
   }
// base cases are built into the memo table with entries of INFTY
if( memo.at(i, j) == INFTY )
{
    if( s.at(i) == t.at(j) )
      memo.at(i, j) = opt( s, i - 1, t, j - 1, memo )+1;
    else
      memo.at(i, j) = max3( opt( s, i - 1, t, j, memo ) ,
                            opt( s, i, t, j - 1, memo ) ,
                            opt( s, i - 1, t, j - 1, memo ) );
}
return memo.at(i, j);
}

/**
* this is the backtrace method
*/

string backtrace(const string & s, const string & t, Matrix<uint> & memo,uint i, uint j)
{
    string longstring;

cout<<"hw"<<endl; //
while(i!=0 && j!=0)
{
    if(s.at(i) == t.at(j))
    {

       longstring.append(s,i,1);
       i--;
       j--;
    }

    else if(s.at(i) > t.at(j))
    {
       i--;
   
    }
    else
    {
       j--;
     
    }
  
}

//return the string for backtrack
//it returns the characters of the longest common sequence
//everyone of the characters of i and j are = so add that character to a string
//create a string then add characters to string
return longstring;

  
}

/**
* get the two strings from the command line
* set up the memo table
* print the results
*/
int main( int argc, char * argv [] )
{
if( argc != 3 )
{
    cerr << "Usage: " << argv[0] << " s1 s2 where s1 and s2 are the strings"
         << endl;
    return 1;
}

// add a space to the beginning of each string so the string indices
// will match the memo indices
string s = argv[1];
s = ' ' + s;
string t = argv[2];
t = ' ' + t;

// fill the memo table with infinities
Matrix< uint > memo( s.size() + 1, t.size() + 1 );
for( uint row = 1; row <= s.size(); row++ )
    for( uint col = 1; col <= t.size(); col++ )
      memo.at( row, col ) = INFTY;

// hard-code the base cases
for( uint row = 0; row <= s.size(); row++ )
    memo.at( row, 0 ) = row;
for( uint col = 0; col <= t.size(); col++ )
    memo.at( 0, col ) = col;

//uint result = opt( s, s.size() - 1, t, t.size() - 1, memo );
cout << "The LCS has length " << opt( s, s.size() - 1, t, t.size() - 1, memo ) <<endl;
cout << "The LCS is " << backtrace(s,t,memo,s.size()-1,t.size()-1) << endl;
string longstring = backtrace(s,t,memo,s.size()-1,t.size()-1);
cout<<longstring<<endl;
return 0;
}

matrix class-matrix.h:

/**
* A generic 2-dimensional array class
* @author Jon Beck
* @version 4 April 2017
*/
#ifndef MATRIX_H
#define MATRIX_H

#include <cassert>
typedef unsigned int uint;

template <class Object>
class Matrix
{
public:
Matrix( uint rows, uint cols );
Object & at( uint row, uint col );
const Object & at( uint row, uint col ) const;
~Matrix();
Matrix( const Matrix<Object> & m ); // Copy constructor
Matrix & operator= ( const Matrix<Object> & m ); // Assignment operator
uint numrows() const;
uint numcols() const;

private:
uint rows;
uint cols;
Object* data;
};

template <class Object>
Matrix<Object>::Matrix( uint rows, uint cols )
: rows( rows ), cols( cols )
{
data = new Object[ rows * cols ];
}

template <class Object>
Matrix<Object>::~Matrix()
{
delete[] data;
}

template <class Object>
Object & Matrix<Object>::at( uint row, uint col )
{
assert( row < rows && col < cols );
return data[ cols * row + col ];
}

template <class Object>
const Object & Matrix<Object>::at( uint row, uint col ) const
{
assert( row < rows && col < cols );
return data[ cols * row + col ];
}

template <class Object>
uint Matrix<Object>::numrows() const
{
return rows;
}

template <class Object>
uint Matrix<Object>::numcols() const
{
return cols;
}
#endif

Answer 1

HI, I have fixed all the issue.

Program is working correctly.

/**
* calculate the optimum edit distance between two strings
* @author Jerry Lin
* @version 13 April 2017
*/
#include <climits>
#include <iomanip>
#include <iostream>
#include <vector>
#include <string>
#include "matrix.h"
using namespace std;
typedef unsigned int uint;
// set infinity to one less than the maximum so we can add one to
// infinity and not overflow around to zero
const uint INFTY = UINT_MAX - 1;
/**
* find the minimum of three values
* @param a one of the three values
* @param b one of the three values
* @param c one of the three values
* @return the smallest value
*/
uint max3(uint a, uint b, uint c)
{
uint result = a > b ? a:b;
return result > c ? result : c;
}

// Function to reverse a string
void reverseStr(string &str)
{
int n = str.length();

// Swap character starting from two
// corners
for (int i=0; i<n/2; i++)
swap(str[i], str[n-i-1]);
}

/**
* the recursive, memoized optimum function for computing the edit distance
* between two strings
* @param s the first string
* @param i the index of the first string
* @param t the second string
* @param j the index of the second string
* @param memo the memo table
*/
uint opt( const string & s, uint i, const string & t, uint j,
Matrix< uint > & memo )
{
if(i==0 || j==0)
{
memo.at(i,j)=0;
}
// base cases are built into the memo table with entries of INFTY
if( memo.at(i, j) == INFTY )
{
if( s.at(i) == t.at(j) )
memo.at(i, j) = opt( s, i - 1, t, j - 1, memo )+1;
else
memo.at(i, j) = max3( opt( s, i - 1, t, j, memo ) ,
opt( s, i, t, j - 1, memo ) ,
opt( s, i - 1, t, j - 1, memo ) );
}
return memo.at(i, j);
}

/**
* this is the backtrace method
*/
string backtrace(const string & s, const string & t, Matrix<uint> & memo,uint i, uint j)
{
string longstring;
//cout<<"hw"<<endl; //
while(i!=0 && j!=0)
{
if(s.at(i) == t.at(j))
{
  
//cout<<s[i];
longstring.append(s,i,1);
i--;
j--;
}

else if(memo.at(i-1, j) > memo.at(i, j-1))
{
i--;

}
else
{
j--;

}
  
}

// reversing string to
reverseStr(longstring);

//return the string for backtrack
//it returns the characters of the longest common sequence
//everyone of the characters of i and j are = so add that character to a string
//create a string then add characters to string
return longstring;

  
}
/**
* get the two strings from the command line
* set up the memo table
* print the results
*/
int main( int argc, char * argv [] )
{
if( argc != 3 )
{
cerr << "Usage: " << argv[0] << " s1 s2 where s1 and s2 are the strings"
<< endl;
return 1;
}
// add a space to the beginning of each string so the string indices
// will match the memo indices
string s = argv[1];
s = ' ' + s;
string t = argv[2];
t = ' ' + t;
// fill the memo table with infinities
Matrix< uint > memo( s.size() + 1, t.size() + 1 );
for( uint row = 1; row <= s.size(); row++ )
for( uint col = 1; col <= t.size(); col++ )
memo.at( row, col ) = INFTY;
// hard-code the base cases
for( uint row = 0; row <= s.size(); row++ )
memo.at( row, 0 ) = row;
for( uint col = 0; col <= t.size(); col++ )
memo.at( 0, col ) = col;
//uint result = opt( s, s.size() - 1, t, t.size() - 1, memo );
cout << "The LCS has length " << opt( s, s.size() - 1, t, t.size() - 1, memo ) <<endl;
cout << "The LCS is " << backtrace(s,t,memo,s.size()-1,t.size()-1) << endl;
return 0;
}