Question

我的程序有几条待观察的路径，例如
    C：\ XML
    C：\ MYPROG \原始
    C：\ MYPROG \子集\ MTSAT
    C：\ MYPROG \子集\ GOESW
    d：\数据集\复合
    d：\数据集\全球
    E：\数据集\马赛克

我想在我的CFolderWatch类实例中添加4个路径，即C：\ XML，C：\ MyProg，D：\ Dataset和E：\ Dataset，以便查看所有7个上述路径的文件夹内容只要其“Include Subdirectory”开关设置为TRUE即可。假设所有正在观看的路径都已添加到矢量容器中。

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

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

Answer 1

两步算法：

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

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

Answer 2

正如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);*/
        }               
    }
}
}

这是一个非常简单的程序，假设您在路径中包含路径并检查重复项。如果对于大量的路径，您必须采用更有效的解决方案。

Answer 3

没有算法;你使用的是不一致的逻辑。

只考虑集合

C：\ XML
C：\ MYPROG \原始
C：\ MyProg \ Subset \ MTSAT
C：\ MYPROG \子集\ GOESW

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

C：\
C：\ XML和C：\ MyProg \
C：\ XML，C：\ MyProg \ Raw和C：\ MyProg \ Subset
C：\ XML，C：\ MyProg \ Raw，C：\ MyProg \ Subset \ MTSAT和C：\ MyProg \ Subset \ GOESW

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

如何在同一逻辑驱动器上的路径中找到“最不常见的部分”？

3 个答案: