It makes sense that this is not bi-directional, because it’s for matching substrings. It should be bi-directional if both strings are of the same length, as you pointed out.

Most importantly: the original Levenshtein is bi-directional, meaning that Levenshtein(a,b) == Levenshtein(b,a)

However with your modification, this is no longer the case! In other words, FuzzyLevenshtein(a,b) != FuzzyLevenshtein(b,a)

From my experiments, it appears that FuzzyLevenshtein(a,b) can/will be a lower value when b (the target) has extra characters in its prefix/suffix.
When a (the source) has the extra characters, then the Fuzzy version is the same as the original.

Does this make sense to you? Do you agree? Thanks!

        public static float GetSubStringSimilarity(string string1, string string2)
        {
            float dis = fuzzy_substring(string1, string2);
            float minLen = string1.Length;
            if (minLen > string2.Length)
                minLen = string2.Length;
            if (minLen == 0.0F)
                return 1.0F;
            else
                return 1.0F - dis / minLen;
        }

http://codepad.org/GFfEVDHu

int fuzzy_substring(const string& needle,
                    const string& haystack) {
    const int nlen = needle.size(),
              hlen = haystack.size();
    if (hlen == 0) return -1;
    if (nlen == 1) return haystack.find(needle);
    vector<int> row1(hlen+1, 0);
    for (int i = 0; i < nlen; ++i) {
        vector<int> row2(1, i+1);
        for (int j = 0; j < hlen; ++j) {
            const int cost = needle[i] != haystack[j];
            row2.push_back(std::min(row1[j+1]+1,
                                    std::min(row2[j]+1,
                                             row1[j]+cost)));
        }
        row1.swap(row2);
    }
    return *std::min_element(row1.begin(), row1.end());
}

The intuition is that since we’re looking for a fuzzy substring, we don’t care what comes before or after the string we’re matching. So given the string “bbb aca bbb” and the substring candidate “aaa,” we can match the “aca” of the first string against the “aaa,” ignoring the “bbb” that comes before and after.

The top row is zeroed out to say that we don’t care what comes before the string we’re matching, and we take the lowest score on the bottom row to say that we don’t care what comes after.

However, you’re right that it’s hard to backtrack and find the exact path we took (e.g. in order to mark up the differences); there will often be ambiguity about the proper path.