C# 计算两段字符串相似度比率

引用中提到了计算轨迹相似度的方法，可以归结为计算轨迹序列间的公共子序列占原始序列的比率。在代码示例中，通过计算两个轨迹序列的交集，然后将交集的数量除以轨迹序列的长度，得到了两个轨迹的相似度比率。具体代码如下：

var intersect = array<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
-  *1* *2* *3* [基于公共子序列的轨迹聚类(c#)](https://blog.csdn.net/weixin_44627014/article/details/102528991)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 100%"]
[ .reference_list ]

相关问题

C# 如何 判断两个字符串相似度

在 C# 中可以使用 Levenshtein 距离算法来计算两个字符串之间的相似度。

Levenshtein 距离是指将一个字符串转换成另一个字符串所需的最少编辑次数，其中每个编辑操作可以是插入、删除或替换一个字符。可以通过计算两个字符串之间的 Levenshtein 距离来衡量它们之间的相似度。

下面是一个计算 Levenshtein 距离的 C# 函数：

public static int LevenshteinDistance(string s, string t)
{
    int n = s.Length;
    int m = t.Length;
    int[,] d = new int[n + 1, m + 1];

    if (n == 0)
    {
        return m;
    }

    if (m == 0)
    {
        return n;
    }

    for (int i = 0; i <= n; i++)
    {
        d[i, 0] = i;
    }

    for (int j = 0; j <= m; j++)
    {
        d[0, j] = j;
    }

    for (int j = 1; j <= m; j++)
    {
        for (int i = 1; i <= n; i++)
        {
            if (s[i - 1] == t[j - 1])
            {
                d[i, j] = d[i - 1, j - 1];
            }
            else
            {
                d[i, j] = Math.Min(Math.Min(d[i - 1, j], d[i, j - 1]), d[i - 1, j - 1]) + 1;
            }
        }
    }

    return d[n, m];
}

使用此函数，可以计算两个字符串之间的 Levenshtein 距离，然后通过一些转换得出它们之间的相似度。

例如，可以使用以下公式计算相似度：

similarity = 1 - (distance / max(len(s), len(t)))

其中，`distance` 是 Levenshtein 距离，`len(s)` 和 `len(t)` 分别是两个字符串的长度。`similarity` 的取值范围是 [0, 1]，值越大表示相似度越高。

使用 C# 代码实现这个公式可以是：

public static double StringSimilarity(string s, string t)
{
    int distance = LevenshteinDistance(s, t);
    int maxLength = Math.Max(s.Length, t.Length);
    return 1.0 - (double)distance / maxLength;
}

这个函数返回两个字符串之间的相似度。

c# 字符串相似度比较代码

你可以使用C#的字符串比较方法来计算两个字符串之间的相似度。常用的算法有Levenshtein距离和Jaro-Winkler距离。下面是使用这两种算法计算字符串相似度的示例代码：

using System;

class Program
{
    static void Main(string[] args)
    {
        string str1 = "hello";
        string str2 = "hallo";

        double levenshteinDistance = LevenshteinDistance(str1, str2);
        double jaroWinklerDistance = JaroWinklerDistance(str1, str2);

        Console.WriteLine("Levenshtein Distance: " + levenshteinDistance);
        Console.WriteLine("Jaro-Winkler Distance: " + jaroWinklerDistance);
    }

    static double LevenshteinDistance(string s, string t)
    {
        int n = s.Length;
        int m = t.Length;
        int[,] d = new int[n + 1, m + 1];

        if (n == 0)
        {
            return m;
        }

        if (m == 0)
        {
            return n;
        }

        for (int i = 0; i <= n; i++)
        {
            d[i, 0] = i;
        }

        for (int j = 0; j <= m; j++)
        {
            d[0, j] = j;
        }

        for (int j = 1; j <= m; j++)
        {
            for (int i = 1; i <= n; i++)
            {
                int cost = (s[i - 1] == t[j - 1]) ? 0 : 1;

                d[i, j] = Math.Min(Math.Min(
                    d[i - 1, j] + 1,
                    d[i, j - 1] + 1),
                    d[i - 1, j - 1] + cost);
            }
        }

        return 1.0 - (double)d[n, m] / Math.Max(n, m);
    }

    static double JaroWinklerDistance(string s, string t)
    {
        int sLen = s.Length;
        int tLen = t.Length;

        if (sLen == 0 && tLen == 0)
        {
            return 1.0;
        }

        int matchDistance = Math.Max(sLen, tLen) / 2 - 1;

        bool[] sMatches = new bool[sLen];
        bool[] tMatches = new bool[tLen];

        int matches = 0;
        for (int i = 0; i < sLen; i++)
        {
            int start = Math.Max(0, i - matchDistance);
            int end = Math.Min(i + matchDistance + 1, tLen);

            for (int j = start; j < end; j++)
            {
                if (tMatches[j])
                {
                    continue;
                }

                if (s[i] != t[j])
                {
                    continue;
                }

                sMatches[i] = true;
                tMatches[j] = true;
                matches++;
                break;
            }
        }

        if (matches == 0)
        {
            return 0.0;
        }

        int tPrefix = 0;
        for (int i = 0; i < tLen && tMatches[i]; i++)
        {
            tPrefix++;
        }

        double jaro = ((double)matches / sLen + (double)matches / tLen + (double)(matches - tPrefix) / matches) / 3;

        int j = 0;
        while (j < Math.Min(sLen, 4) && s[j] == t[j])
        {
            j++;
        }

        if (j == 0)
        {
            return jaro;
        }

        double jaroWinkler = jaro + Math.Min(0.1, 1.0 / Math.Max(sLen, tLen) * j * (1.0 - jaro));

        return jaroWinkler;
    }
}

在上面的示例中，`LevenshteinDistance`方法使用Levenshtein距离算法计算字符串相似度，并返回一个介于0和1之间的值。这个值越接近1，表示两个字符串越相似。

`JaroWinklerDistance`方法使用Jaro-Winkler距离算法计算字符串相似度，并返回一个介于0和1之间的值。这个值越接近1，表示两个字符串越相似。Jaro-Winkler距离算法还考虑了字符串的前缀匹配，因此对于具有相同前缀的字符串，它的结果会更准确。