Question

有人可以帮助我定义这两个C函数的渐近复杂度吗？

1）输出两个给定字符串的levenshtein距离的简单函数

int levenshtein_distance( char *s1 , char *s2 ,matrix_t  matrix )
{
    int options[3];
    int len_s1 = strlen(s1);
    int len_s2 = strlen(s2);
    int res;
    int i;
    int j;
    int k;

    for(i = 1 ; i < len_s1 ; i++ )
    {
        for(j = 1 ; j < len_s2 ; j++)
        {
            options[MATCH]  = matrix[i-1][j-1].cost + match(s1[i],s2[j]);
            options[INSERT] = matrix[i][j-1].cost + 1;
            options[DELETE] = matrix[i-1][j].cost + 1;

            matrix[i][j].cost = options[MATCH];
            matrix[i][j].parent = MATCH;

            for (k=INSERT; k<=DELETE; k++)
                if (options[k] < matrix[i][j].cost)
                {
                    matrix[i][j].cost = options[k];
                    matrix[i][j].parent = k;
                }
        }

    }

    res = matrix[(len_s1-1)][(len_s2 -1)].cost;
    return res;
}

2）重建编辑操作路径的递归方法

void reconstruct_path(char *s1, char *s2 , int i, int j , matrix_t matrix)
{
    if(matrix[i][j].parent == -1) return;


    if (matrix[i][j].parent == MATCH)
    {
        reconstruct_path(s1,s2,i-1,j-1,matrix);
        match_out(s1, s2, i, j);
        return;
    }

    if (matrix[i][j].parent == INSERT)
    {
        reconstruct_path(s1,s2,i,j-1,matrix);
        insert_out(s2, j);
        return;
    }

    if (matrix[i][j].parent == DELETE)
    {
        reconstruct_path(s1,s2,i-1,j,matrix);
        delete_out(s1 , i);
        return;
    }
}

匹配

int match(char a , char b)
{
    if(a == b) return 0;
    else return 1;
}

match_out，insert_out和delete_out仅为每次调用执行printf

Answer 1

第一个函数显然是O（m * n），其中m = strlen（s1），n = strlen（s2）。具有if条件的最内层循环执行3 * m * n次，因此O（m * n）。

第二个函数是O（i + j）（根据提供的定义，不清楚i，j和strlen（s1）和strlen（s2）之间的关系。请注意，在每次递归调用时，我们可能在所提供的条件之一上匹配，并且i或j或两者都递减。当i或j低于0时，这会导致错误，或者在此之前终止。另请注意，对于特定的递归调用，它只执行其中一个路径。在最坏的情况下，我下降到0匹配DELETE i次，然后j下降到0匹配INSERT j次然后你终止。

具有路径重构渐近复杂度的levenshtein距离实现

1 个答案: