# Algorithms_in_C++: dynamic_programming/minimum_edit_distance.cpp File Reference

Loading...
Searching...
No Matches
minimum_edit_distance.cpp File Reference

Implementation of Minimum Edit Distance using Dynamic Programing. More...

`#include <cassert>`
`#include <iostream>`
`#include <vector>`
Include dependency graph for minimum_edit_distance.cpp:

## Namespaces

namespace | dynamic_programming
| Dynamic Programming algorithms.
namespace | Minimum
| Implementation of Minimum Edit Distance algorithm.

## Functions

uint64_t | dynamic_programming::minimum_edit_distance::min (uint64_t x, uint64_t y, uint64_t z)
| Takes input of the cost of three operations: Insert, Replace and Delete and return the minimum cost among them. More...
uint64_t | dynamic_programming::minimum_edit_distance::editDistDP (std::string str1, std::string str2, uint64_t m, uint64_t n)
| Calculates and stores the result of all the sub-problems, so that we don't have to recur to compute the minimum cost of a particular operation if it is already computed and stored in the `dp` vector. More...
static void | test ()
| Self-test implementations. More...
int | main (int argc, char *argv[])
| main function More...

## Detailed Description

Implementation of Minimum Edit Distance using Dynamic Programing.

Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.

### Algorithm

We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.

1. If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array.
2. Else, (If last characters are not the same), we will consider all three operations (Insert, Remove, Replace) on the last character of the first string and compute the minimum cost for all three operations and take the minimum of three values in the DP array. For Insert: Recur for m and n-1 For Remove: Recur for for m-1 and n For Replace: Recur for for m-1 and n-1

Author
  Nirjas Jakilim

## Function Documentation

## editDistDP()

uint64_t dynamic_programming::minimum_edit_distance::editDistDP | ( | std::string | str1,
|  | std::string | str2,
|  | uint64_t | m,
|  | uint64_t | n
| ) |  |

Calculates and stores the result of all the sub-problems, so that we don't have to recur to compute the minimum cost of a particular operation if it is already computed and stored in the `dp` vector.

Parameters

  dp | vector to store the computed minimum costs
  str1 | to pass the 1st string
  str2 | to pass the 2nd string
  m | the length of str1
  n | the length of str2

Returns
  dp[m][n] the minimum cost of operations needed to convert str1 to str2

Create a table to store results of subproblems

creasting 2D vector dp to store the results of subproblems

Fill d[][] in bottom up manner

If first string is empty, only option is to insert all characters of second string

Minimum operations = j

If second string is empty, only option is to remove all characters of second string

Minimum operations = i

If last characters are same, ignore last char and recur for remaining string

If the last character is different, consider all possibilities and find the minimum

returning the minimum cost of operations needed to convert str1 to str2

{
/// Create a table to store results of subproblems
std::vector<std::vector<uint64_t>>dp(m+1, std::vector<uint64_t>(n+1)); /// creasting 2D vector dp to store the results of subproblems
/// Fill d[][] in bottom up manner
for (uint64_t i = 0; i <= m; i++) {
for (uint64_t j = 0; j <= n; j++) {
/// If first string is empty, only option is to
/// insert all characters of second string
if (i == 0) {
dp[i][j] = j; /// Minimum operations = j
}
/// If second string is empty, only option is to
/// remove all characters of second string
else if (j == 0) {
dp[i][j] = i; /// Minimum operations = i
}
/// If last characters are same, ignore last char
/// and recur for remaining string
else if (str1[i - 1] == str2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
}
/// If the last character is different, consider all
/// possibilities and find the minimum
else {
dp[i][j] = 1 + min(dp[i][j - 1], // Insert
dp[i - 1][j], // Remove
dp[i - 1][j - 1]); // Replace
}
}
}
return dp[m][n]; /// returning the minimum cost of operations needed to convert str1 to str2
}
std::min
T min(T... args)
dp
for std::vector
Definition: partition_problem.cpp:39
std::vector

## main()

int main | ( | int | argc,
|  | char * | argv[]
| ) |  |

main function

Parameters

  argc | commandline argument count (ignored)
  argv | commandline array of arguments (ignored)

Returns
  0 on exit

{
test(); // run self-test implementations
return 0;
}
test
static void test()
Self-test implementations.
Definition: minimum_edit_distance.cpp:132
Here is the call graph for this function:

## min()

uint64_t dynamic_programming::minimum_edit_distance::min | ( | uint64_t | x,
|  | uint64_t | y,
|  | uint64_t | z
| ) |  |

Takes input of the cost of three operations: Insert, Replace and Delete and return the minimum cost among them.

Parameters

  x | used to pass minimum cost of Insert operations
  y | used to pass minimum cost of Replace operations
  z | used to pass minimum cost of Delete operations

Returns
  x if `x` is the minimum value
  y if `y` is the minimum value
  z if `z` is the minimum value

returns x, if x is the minimum value

returns y, if y is the minimum value

returns z if z is the minimum value

{
if (x <= y && x <= z) {
return x; /// returns x, if x is the minimum value
}
if (y <= x && y <= z) {
return y; /// returns y, if y is the minimum value
}
else {
return z; /// returns z if z is the minimum value
}
}

## test()

static void test | ( |  | ) |

static

Self-test implementations.

Returns
  void

{
// 1st test
std::string str1 = "INTENTION"; // Sample input of 1st string
std::string str2 = "EXECUTION"; // Sample input of 2nd string
uint64_t expected_output1 = 5; // Expected minimum cost
uint64_t output1 = dynamic_programming::minimum_edit_distance::editDistDP(
str1, str2, str1.length(), str2.length()); // calling the editDistDP function and storing the result on output1
assert(output1 == expected_output1); // comparing the output with the expected output
std::cout << "Minimum Number of Operations Required: " << output1
<< std::endl;
// 2nd test
std::string str3 = "SATURDAY";
std::string str4 = "SUNDAY";
uint64_t expected_output2 = 3;
uint64_t output2 = dynamic_programming::minimum_edit_distance::editDistDP(
str3, str4, str3.length(), str4.length());
assert(output2 == expected_output2);
std::cout << "Minimum Number of Operations Required: " << output2
<< std::endl;
}
std::cout
std::string
std::endl
T endl(T... args)
dynamic_programming::minimum_edit_distance::editDistDP
uint64_t editDistDP(std::string str1, std::string str2, uint64_t m, uint64_t n)
Calculates and stores the result of all the sub-problems, so that we don't have to recur to compute t...
Definition: minimum_edit_distance.cpp:88
std::string::length
T length(T... args)
Here is the call graph for this function: