C# 分布式深度优先搜索

我曾尝试在c#中实现深度优先搜索，但我不确定如何以分布式计算的方式实现。如果你们能在这方面帮助我，我将非常感激：）你们可以在下面找到我的DFS代码

public class DFS
{ 
static List<string> traversedList = new List<string>();
static List<string> parentList = new List<string>();

public static void Main(string[] args)
{

    int N = 100;
    int M = N * 4;
    int P = N * 16;

    Stack newstack = new Stack();

    List<string> global_list=new List<string>();

    StreamReader file = new StreamReader("my input file");

    string text = file.ReadToEnd();

    string[] lines = text.Split('\n');

    string[][] array1 = new string[lines.Length][];

    for (int i = 0; i < lines.Length; i++)
    {
        lines[i] = lines[i].Trim();
        string[] words = lines[i].Split(' ');

        array1[i] = new string[words.Length];

        for (int j = 0; j < words.Length; j++)
        {
            array1[i][j] = words[j];
        }
    }

    StreamWriter sr = new StreamWriter(args[0]);

    for (int i = 0; i < array1.Length; i++)
    {
        for (int j = 0; j < array1[i].Length; j++)
        {
            if (j != 0 )
            {
                sr.Write(array1[i][0] + ":" + array1[i][j]);
                Console.WriteLine(array1[i][0] + ":" + array1[i][j]);
                sr.Write(sr.NewLine);
            }
        }

    }

    int start_no = Convert.ToInt32(args[args.Length-1]);

    traversedList.Add(start_no.ToString());
    parentList.Add("root");
    dfs(array1, start_no);

    for (int z = 0; z < traversedList.Count; z++)
    {
            Console.WriteLine(traversedList.ElementAt(z) + " "+parentList.ElementAt(z)+" "+(z+1));
     }
    Console.ReadLine();
}

private static void dfs(string[][] array, int point)
{
    for (int z = 1; z < array[point].Length; z++)
        {
            if ((!traversedList.Contains(array[point][z])))
            {
                traversedList.Add(array[point][z]);
                parentList.Add(point.ToString());
                dfs(array, int.Parse(array[point][z]));
            }
        }
        return;
}   

公共类DFS
{ 
静态列表遍历列表=新列表（）；
静态列表parentList=新列表（）；
公共静态void Main（字符串[]args）
{
int N=100；
int M=N*4；
int P=N*16；
Stack newstack=新堆栈（）；
列表全局_List=新列表（）；
StreamReader文件=新的StreamReader（“我的输入文件”）；
string text=file.ReadToEnd（）；
字符串[]行=text.Split（'\n'）；
字符串[][]数组1=新字符串[lines.Length][]；
对于（int i=0；i

---

}

你应该阅读电脑国际象棋（现在演变成世界冠军电脑游戏玩家）世界的文献。他们做分布式深度优先搜索已经有30年了，并且有很多想法。这很难做到正确，因为您必须在不知道特定分支可能包含多少工作的情况下平均分配工作

看看麦吉尔大学吧，大约10年前它似乎是这方面的温床

当然，GIYF：“分布式深度优先搜索”引用了本文：。我猜它包含了很多来自计算机象棋界的想法

---

共享内存的问题“DFS的难度稍微小一些；您不必向分布式助手发送消息，只需传递一个指针即可：-}有一种语言可以为您提供并行性，并管理如果您的程序在每个分支上分叉时可能发生的爆炸性并行增长。我提供了我设计的内置并行编程语言。（这个例子是我最早的SO帖子之一！）

你能澄清一下你的确切意思吗？“分布式计算”通常意味着将一个计算分散到几个不同的计算机上。你是说“并行计算”吗？还有，你试过什么？怎么会失败？没错！！实现DFS的并行方式…我不知道从哪里开始…你能给我一些关于这个问题的提示吗？