0

我的程序有几个路径可以看，比如
C:\XML
C:\MyProg\Raw
C:\MyProg\Subset\MTSAT
C:\MyProg\Subset\GOESW
D:\Dataset\Composite
D:\Dataset\Global
E :\数据集\马赛克

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

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

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

4

3 回答 3

0

两步算法：

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

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

于 2011-09-22T14:52:00.907 回答
0

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

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

于 2011-09-22T15:09:55.680 回答
0

没有算法；您正在使用不一致的逻辑。

只考虑集合

  1. C:\XML
  2. C:\MyProg\Raw
  3. C:\MyProg\子集\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) 处停下来。

于 2011-09-22T15:15:33.637 回答