Segmentation fault in 2-d Array - c++

Question

I was working on this problem:
Coding Problem
Problem Statement: Edit Distance
Problem Level: MEDIUM
Problem Description:
You are given two strings S and T of lengths M and N, respectively. Find the 'Edit Distance' between the strings.
Edit Distance of two strings is the minimum number of steps required to make one string equal to the other. In order to do so, you can perform the following three operations:
1. Delete a character
2. Replace a character with another one
3. Insert a character
Note :
Strings don't contain spaces in between.
Input format :
The first line of input contains the string S of length M.
The second line of the input contains the String T of length N.
Output format :
Print the minimum 'Edit Distance' between the strings.
Constraints :
0 <= M <= 10 ^ 3
0 <= N <= 10 ^ 3
Time Limit: 1 sec
Sample Input 1 :
abc
dc
Sample Output 1 :
2
Explanation to the Sample Input 1 :
In 2 operations we can make string T to look like string S.
First, insert character 'a' to string T, which makes it "adc".
And secondly, replace the character 'd' of string T with 'b' from the string S. This would make string T as "abc" which is also string S.
Hence, the minimum distance.
Sample Input 2 :
whgtdwhgtdg
aswcfg
Sample Output 2 :
9
I wrote the following code for this:
#include <iostream>
using namespace std;
int EditDistance(string s, string t, int **arr)
{
int i = s.size();
int j = t.size();
//Base Case
if (t.size() == 0 || s.size()==0)
{
return max (s.size(),t.size());
}
int x, y, z, min_num;
if (arr[i][j] != (-1))
{
return arr[i][j];
}
//Recursive Case
if (s[0] == t[0])
{
arr[i][j] = EditDistance(s.substr(1), t.substr(1), arr);
return arr[i][j];
}
else
{
x = 1 + EditDistance(s.substr(1), t, arr);
y = 1 + EditDistance(s, t.substr(1), arr);
z = 1 + EditDistance(s.substr(1), t.substr(1), arr);
min_num = min(x, min(y, z));
arr[i][j] = min_num;
}
return min_num;
}
int EditDistance(string s, string t)
{
int a = s.size() + 1; //rows
int b = t.size() + 1; //columns
int **arr = new int *[b];
for (int i = 0; i < b; i++)
{
arr[i] = new int[a];
}
for (int i = 0; i < a; i++)
{
for (int j = 0; j < b; j++)
{ cout << "Value of i is " << i <<endl;
cout << "Value of j is " << j <<endl;
arr[i][j] = (-1);
cout << "Value of array is " << arr[i][j] <<endl;
}
}
return EditDistance(s, t, arr);
delete[]arr;
}
int main()
{
string s1, s2;
cout << "Enter the two strings" << endl;
cin >> s1 >> s2;
cout << EditDistance(s1, s2) << endl;
return 0;
}
However, when I tried to enter "abc" and "ab" as the strings, it gives segmentation fault at i=3 and j=0 at the line arr[i][j] = (-1) in the function int EditDistance(string s, string t). However, what I really couldn't get was that why am I receving a segmentation fault, when I have created a 2-d array of size 4*3, then accessing the element arr[3][0] shouldn't give me a segmentation fault. Can anyone help?

Answer 1

OK, the Levenshtein distance . . .
There is one semantic error. Otherwise the program is OK.
Then you do many style erros. And you are using new and raw pointers for owned memory. In C++ such raw pointers are considered as evil and should not be used. Under no circumstances.
Additionally you forgot the release the owned memory. Your delete statement is an unreachable code area. And it only deletes one dimension.
If you would use meaningful variable names, then you would see immediately your problem. See here.
int numberOfRows = s.size() + 1; //rows
int numberOfColumns = t.size() + 1; //columns
int **arr = new int *[numberOfColumns];
for (int columnIndex = 0; columnIndex < numberOfColumns; columnIndex++)
{
arr[columnIndex] = new int[numberOfRows];
}
for (int rowIndex = 0; rowIndex < numberOfRows; rowIndex++)
{
for (int columnIndex = 0; columnIndex < numberOfColumns; columnIndex++)
{ cout << "Value of i is " << rowIndex << endl;
cout << "Value of j is " << columnIndex << endl;
arr[rowIndex][j] = (-1);
cout << "Value of array is " << arr[rowIndex][columnIndex] <<endl;
}
}
You are simply mixing up rows and columns. The indices are twisted.
Correcting that and switching the language to C++, will give you the following, basically identical code:
#include <iostream>
#include <string>
#include <algorithm>
int EditDistanceRecursive(const std::string& stringLeft, const std::string& stringRight, int** arr)
{
size_t sizeOfStringLeft = stringLeft.size();
size_t sizeOfStringRight = stringRight.size();
//Base Case
if (stringLeft.empty() || stringRight.empty())
{
return std::max(stringLeft.size(), stringRight.size());
}
int x, y, z, min_num;
if (arr[sizeOfStringLeft][sizeOfStringRight] != (-1))
{
return arr[sizeOfStringLeft][sizeOfStringRight];
}
//Recursive Case
if (stringLeft[0] == stringRight[0])
{
arr[sizeOfStringLeft][sizeOfStringRight] = EditDistanceRecursive(stringLeft.substr(1), stringRight.substr(1), arr);
return arr[sizeOfStringLeft][sizeOfStringRight];
}
else
{
x = 1 + EditDistanceRecursive(stringLeft.substr(1), stringRight, arr);
y = 1 + EditDistanceRecursive(stringLeft, stringRight.substr(1), arr);
z = 1 + EditDistanceRecursive(stringLeft.substr(1), stringRight.substr(1), arr);
min_num = std::min(x, std::min(y, z));
arr[sizeOfStringLeft][sizeOfStringRight] = min_num;
}
return min_num;
}
int EditDistance(const std::string& stringLeft, const std::string& stringRight)
{
// Get the dimensions of the dp table
size_t numberOfRows = stringLeft.size() + 1; //rows
size_t numberOfColumns = stringRight.size() + 1; //columns
// Dynamically allocate 2d-array in old C-Style
int** arr = new int* [numberOfRows];
for (size_t rowIndex = 0; rowIndex < numberOfRows; rowIndex++)
{
arr[rowIndex] = new int[numberOfColumns];
}
// Initialize memory and show debug output
for (size_t rowIndex = 0; rowIndex < numberOfRows; rowIndex++)
{
for (size_t columnIndex = 0; columnIndex < numberOfColumns; columnIndex++)
{
std::cout << "Value of row is " << rowIndex << '\n';
std::cout << "Value of column is " << columnIndex << '\n';
arr[rowIndex][columnIndex] = (-1);
std::cout << "Value of array at row/column is " << arr[rowIndex][columnIndex] << '\n';
}
}
// Caluclate result
int result = EditDistanceRecursive(stringLeft, stringRight, arr);
// Release dynamic allocated memory
for (int rowIndex = 0; rowIndex < numberOfRows; rowIndex++)
delete [] arr[rowIndex];
delete [] arr;
// Inform Result to upper function
return result;
}
int main()
{
// Tell user what to do
std::cout << "Enter the two strings:\n";
// Get 2 strings
std::string stringLeft, stringRight;
std::cin >> stringLeft >> stringRight;
// Calculate and output distance
int result = EditDistance(stringLeft, stringRight);
std::cout << "\n\nResult. Distance is: " << result << '\n';
return 0;
}
I used meaningful variable names
Fixed minor semantic bugs
Made some minor style optimizations
Use fully qualified names everywhere
And if we get rid of C-Style, not at all recommended new and raw pointers, we get the following C++ code:
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using Columns = std::vector<int>;
using Arr = std::vector<Columns>;
int EditDistanceRecursive(const std::string& stringLeft, const std::string& stringRight, Arr& arr)
{
size_t sizeOfStringLeft = stringLeft.size();
size_t sizeOfStringRight = stringRight.size();
//Base Case
if (stringLeft.empty() || stringRight.empty())
{
return std::max(stringLeft.size(), stringRight.size());
}
int x, y, z, min_num;
if (arr[sizeOfStringLeft][sizeOfStringRight] != (-1))
{
return arr[sizeOfStringLeft][sizeOfStringRight];
}
//Recursive Case
if (stringLeft[0] == stringRight[0])
{
arr[sizeOfStringLeft][sizeOfStringRight] = EditDistanceRecursive(stringLeft.substr(1), stringRight.substr(1), arr);
return arr[sizeOfStringLeft][sizeOfStringRight];
}
else
{
x = 1 + EditDistanceRecursive(stringLeft.substr(1), stringRight, arr);
y = 1 + EditDistanceRecursive(stringLeft, stringRight.substr(1), arr);
z = 1 + EditDistanceRecursive(stringLeft.substr(1), stringRight.substr(1), arr);
min_num = std::min(x, std::min(y, z));
arr[sizeOfStringLeft][sizeOfStringRight] = min_num;
}
return min_num;
}
int EditDistance(const std::string& stringLeft, const std::string& stringRight)
{
// Get the dimensions of the dp table
size_t numberOfRows = stringLeft.size() + 1; //rows
size_t numberOfColumns = stringRight.size() + 1; //columns
// Create and initialize 2d vector
Arr arr(numberOfRows, Columns(numberOfColumns, -1));
// Caluclate result
return EditDistanceRecursive(stringLeft, stringRight, arr);
}
int main()
{
// Tell user what to do
std::cout << "Enter the two strings:\n";
// Get 2 strings
std::string stringLeft, stringRight;
std::cin >> stringLeft >> stringRight;
// Calculate and output distance
int result = EditDistance(stringLeft, stringRight);
std::cout << "\n\nResult. Distance is: " << result << '\n';
return 0;
}
What a pity that nobody will read that . . .

Answer 2

I think you inverted the indices of the array subscripts. You create the array like [b][a], but then use it like it's [a][b].