Edit Distance in C

// C Program to Solve Edit Distance Using Recursion

#include <stdio.h>
#include <string.h>

// Function to return the minimum of three integers
int min(int a, int b, int c)
{
    return (a < b) ? ((a < c) ? a : c) : ((b < c) ? b : c);
}

// Recursive function to find the edit distance between two
// strings
int editDistanceRecursive(char* X, char* Y, int m, int n)
{
    // If first string is empty, only option is to insert
    // all characters of second string
    if (m == 0)
        return n;

    // If second string is empty, only option is to remove
    // all characters of first string
    if (n == 0)
        return m;

    // If last characters are same, ignore last characters
    // and recur for remaining strings
    if (X[m - 1] == Y[n - 1])
        return editDistanceRecursive(X, Y, m - 1, n - 1);

    // If last characters are different, consider all three
    // operations on last character of first string,
    // recursively compute minimum cost for all three
    // operations and take minimum of three values.
    return 1
           + min(editDistanceRecursive(X, Y, m,
                                       n - 1), // Insert
                 editDistanceRecursive(X, Y, m - 1,
                                       n), // Remove
                 editDistanceRecursive(X, Y, m - 1,
                                       n - 1) // Replace
           );
}

int main()
{
    // Define the two strings to compare
    char X[] = "GEEXSFRGEEKKS";
    char Y[] = "GEEKSFORGEEKS";

    // Calculate the lengths of the strings
    int m = strlen(X);
    int n = strlen(Y);

    // Print the minimum edit distance between the two
    // strings
    printf("Minimum edit distance is %d\n",
           editDistanceRecursive(X, Y, m, n));

    return 0;
}

// C Program to Solve Edit Distance Using Dynamic
// Programming (Memoization)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Function to find the minimum of three integers
int min(int x, int y, int z)
{
    if (x < y && x < z)
        return x;
    else if (y < x && y < z)
        return y;
    else
        return z;
}

// Function to calculate the minimum edit distance using
// dynamic programming
int minDis(char* s1, char* s2, int n, int m)
{
    // Declare a 2D array to store the dynamic programming
    // table
    int dp[n + 1][m + 1];

    // Fill the dynamic programming table
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            // If the first string is empty, the only option
            // is to insert all characters of the second
            // string
            if (i == 0)
                dp[i][j] = j;
            // If the second string is empty, the only
            // option is to remove all characters of the
            // first string
            else if (j == 0)
                dp[i][j] = i;
            // If the last characters are the same, ignore
            // the last characters and recur for the
            // remaining strings
            else if (s1[i - 1] == s2[j - 1])
                dp[i][j] = dp[i - 1][j - 1];
            // If the last characters are different,
            // consider all three operations and find the
            // minimum
            else
                dp[i][j] = 1
                           + min(dp[i][j - 1], dp[i - 1][j],
                                 dp[i - 1][j - 1]);
        }
    }
    // Return the result from the dynamic programming table
    return dp[n][m];
}

int main()
{
    // Define the two strings to compare
    char* str1 = "GEEXSFRGEEKKS";
    char* str2 = "GEEKSFORGEEKS";

    // Calculate the lengths of the strings
    int n = strlen(str1), m = strlen(str2);

    // Print the minimum edit distance between the two
    // strings
    printf("%d\n", minDis(str1, str2, n, m));

    return 0;
}

// C Program to Solve Edit Distance Using Dynamic
// Programming (Bottom-Up)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Utility function to find the minimum of three numbers
int min(int x, int y, int z)
{
    if (x < y && x < z)
        return x;
    else if (y < x && y < z)
        return y;
    else
        return z;
}

// Function to calculate the minimum edit distance using
// bottom-up dynamic programming
int minDis(char* s1, char* s2, int n, int m)
{
    // Declare a 2D array to store the dynamic programming
    // table
    int dp[n + 1][m + 1];

    // Initialize the dp table
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            // If the first string is empty, the only option
            // is to insert all characters of the second
            // string
            if (i == 0) {
                dp[i][j] = j;
            }
            // If the second string is empty, the only
            // option is to remove all characters of the
            // first string
            else if (j == 0) {
                dp[i][j] = i;
            }
            // If the last characters are the same, ignore
            // the last characters and recur for the
            // remaining strings
            else if (s1[i - 1] == s2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1];
            }
            // If the last characters are different,
            // consider all three operations and find the
            // minimum
            else {
                dp[i][j] = 1
                           + min(dp[i - 1][j], dp[i][j - 1],
                                 dp[i - 1][j - 1]);
            }
        }
    }

    // Return the result from the dynamic programming table
    return dp[n][m];
}

int main()
{
    // Define the two strings to compare
    char s1[] = "GEEXSFRGEEKKS";
    char s2[] = "GEEKSFORGEEKS";

    // Calculate the lengths of the strings
    int n = strlen(s1);
    int m = strlen(s2);

    // Print the minimum edit distance between the two
    // strings
    printf("%d\n", minDis(s1, s2, n, m));

    return 0;
}

// C Program to Solve Edit Distance Using Dynamic
// Programming (Space-Optimized)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Utility function to find the minimum of three numbers
int min(int x, int y, int z)
{
    if (x < y && x < z)
        return x;
    else if (y < x && y < z)
        return y;
    else
        return z;
}

// Function to calculate the minimum edit distance using
// space-optimized dynamic programming
int minDis(char* s1, char* s2, int n, int m)
{
    // Declare two arrays to store the current and previous
    // rows of the dp table
    int prev[m + 1], curr[m + 1];

    // Initialize the prev array
    for (int j = 0; j <= m; j++) {
        prev[j] = j;
    }

    // Iterate over each character of the first string
    for (int i = 1; i <= n; i++) {
        // Initialize the first element of the current row
        curr[0] = i;
        // Iterate over each character of the second string
        for (int j = 1; j <= m; j++) {
            // If the characters are the same, take the
            // diagonal value
            if (s1[i - 1] == s2[j - 1]) {
                curr[j] = prev[j - 1];
            }
            // If the characters are different, take the
            // minimum of the three operations
            else {
                curr[j] = 1
                          + min(prev[j], curr[j - 1],
                                prev[j - 1]);
            }
        }
        // Copy the current row to the previous row for the
        // next iteration
        memcpy(prev, curr, (m + 1) * sizeof(int));
    }

    // Return the result from the previous row
    return prev[m];
}

int main()
{
    // Define the two strings to compare
    char s1[] = "GEEXSFRGEEKKS";
    char s2[] = "GEEKSFORGEEKS";

    // Calculate the lengths of the strings
    int n = strlen(s1);
    int m = strlen(s2);

    // Print the minimum edit distance between the two
    // strings
    printf("%d\n", minDis(s1, s2, n, m));

    return 0;
}