我怎样才能找到“最不常见的部分”？在同一逻辑驱动器上的路径之间？

Question

我的节目有几个路径可以观看，比如
C:\XML
C:\MyProg\Raw
C:\MyProg\Subset\MTSAT
C:\MyProg\Subset\GOESW
D:\数据集\复合
D:\数据集\全局
E:\Dataset\Mosaic

我想向我的 CFolderWatch 类实例添加 4 个路径，即 C:\XML、C:\MyProg、D:\Dataset 和 E:\Dataset，以便监视 insetad 的文件夹只要其“包含子目录”开关设置为 TRUE，即可使用上述所有 7 个路径。假设所有被监视的路径都已添加到向量容器中。

因此，我的问题是：如何在同一逻辑驱动器上的路径中找到“最不常见的部分”？先感谢您！

我的问题的详细解释： 1.我得到了一些用户定义的目录。 2.我想要这些目录被观看。 3. 在观看之前，我想做一些准备工作，例如，找到同一逻辑驱动器上的路径之间的公共部分，以避免可能向我的观看类添加太多路径。例如，逻辑盘C:上有3条路径，如下： C:\test\Data\R1、C:\test\Data\R2、C:\test\Data\R3，常用路径为“C:\test\Data”。因此，我们应该将“C:\test\Data”添加到监视模块中，而不是这三个路径。我的意思是这里的公共路径是它至少有一层目录。如果一条路径与其他路径没有共同路径，则仅返回不变。 4. 首先，算法应该处理不同的逻辑驱动器。也就是说，所有路径都必须根据各自的驱动器号进行分类。然后，在同一逻辑盘符上的传递路径中找到公共路径。

Answer 1

没有算法；你使用了不一致的逻辑。

仅考虑集合

1. C:\XML
2. C:\MyProg\Raw
3. C:\MyProg\Subset\MTSAT
4. C:\MyProg\Subset\GOESW

至少有 4 种不同的解决方案：

1. C:\
2. C:\XML 和 C:\MyProg \
3. C:\XML 、 C:\MyProg\Raw 和 C:\MyProg\Subset
4. C:\XML 、 C:\MyProg\Raw, C:\MyProg\Subset\MTSAT 和 C:\MyProg\Subset\GOESW

您无法解释为什么 2. 是正确的解决方案。可以编写一个算法，在给定解 N 作为输入的情况下找到解 N-1，因此您可以通过三个步骤从输入 (4) 到 (1)。但我们不明白为什么我们应该停在（2）。

Answer 2

两步算法：

1. 按驱动器号和第一目录级别对目录进行分区。
2. 对于每个分区，保留最长的前缀。

通过计算每个目录与其下一个同级目录共有的前缀字符数并保持最小值，可以轻松获得每个分区的最长前缀。例如，使用 mismatch。

Answer 3

正如 JB 所说，我认为这是一个两步解决方案，我已经在 C# 中尝试了一些基本编码。如果你想在java中使用它，我想你一定知道如何使用它:)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace So_Try1
{
      class Program
{
    public static int nthOccurrence(String str, char c, int n)
    {
        int pos = str.IndexOf(c, 0);
        while (n-- > 0 && pos != -1)
            pos = str.IndexOf(c, pos + 1);
        return pos;
    }

    static void Main(string[] args)
    {
        List<String> pathString = new List<string>();
        pathString.Add("C:\\XML");
    pathString.Add("C:\\MyProg\\Raw");
    pathString.Add("C:\\MyProg\\Subset\\MTSAT");
    pathString.Add("C:\\MyProg\\Subset\\GOESW");
        pathString.Add("D:\\Folder2\\Mosaic");
        pathString.Add("D:\\Folder2\\Mosaic\\SubFolder");
        pathString.Add("D:\\Dataset\\Composite");
        pathString.Add("D:\\Dataset\\Global");
        pathString.Add("F:\\Folder1\\Mosaic");
        pathString.Add("H:\\Folder2\\Mosaic");
        pathString.Add("D:\\Folder2\\Mosaic");
        pathString.Add("D:\\Folder2\\Mosaic\\SubFolder");
        pathString.Add("E:\\Dataset\\Mosaic"); 
        Dictionary<String, int> PathDict = new Dictionary<string,int>();

        foreach (String str in pathString)
        {
            int count = 0;
            foreach (char c in str)
                if (c == '\\') count++;
            while (count > 0)
            {
                int index = nthOccurrence(str, '\\', count);
                String tempPath;
                if (index < 0)
                {
                    //Console.WriteLine(str);
                    tempPath = str;
                }
                else
                {
                    //Console.WriteLine(str.Substring(0,index));
                    tempPath = str.Substring(0, index);
                }

                if (PathDict.ContainsKey(tempPath))
                {
                    PathDict[tempPath]++;
                }
                else
                {
                    foreach (var keys in PathDict.Keys)
                    {
                        if (tempPath.IndexOf(keys) > 0)
                        {
                            PathDict[keys]++;
                        }
                    }
                    PathDict.Add(tempPath, 1);
                }
                count--;
            }
        }
        foreach(var keyValue in PathDict){
            if(keyValue.Value > 1)
                Console.WriteLine(keyValue.Key);
            /*Console.WriteLine(keyValue.Key + " - " + keyValue.Value);*/
        }               
    }
}
}

这是一个非常简单的程序，假设你的路径在字符串中并检查重复项。如果路径数量较多，则必须采用更有效的解决方案。