一道面试题(关于面向对象的)

Question

下图，用程序或者伪代码，求从起点到终点，有几条路能走通？
面试的那位仁兄说这个考的是面向对象。我想很久,依然没有头绪,怎么用面向对象来解决.

Answer 1

做个，Point类， 
可以在里面容纳n个Point。
这个关系就类似一条线了。
Point类包含一个属性， 是不是起点。
包含一个属性， 是不是终点。然后， 写方法， 叫：
走到终点。做法就是：
访问所有自己包含的点（也就是走可以走的所有线）
然后调用那个点的“走到终点”方法。
如果自己是终点， 那么， 找个计数器记下， 这是一个结果。
自己包含的点都跑完了就可以看结果了。注意判断有绕圈路线。。 不过我估计他既然这么出题， 应该向你保证了没有绕圈绕回来的路线。并不是说这题目用面向对象会简单， 
人家只是考考你能不能建立起模型， 建立到什么程度。

Answer 2

思路大概如下
节点定义
   Struct Node
   {
     List<Node> NextNodes;
     NodeData   Data;
     bool       ISOver = false;
     bool       CanOver = false;
   }算法：
Find（Node start，Node end）
{
  if（start.NextNodes.count == 0）
  {
    start.Isover = true；
     return;
  }
  foreach(Node node in start.NextNodes)
  {
      if (node.CanOver == true)
      {
        计数;
        continue; 
      }
      if(node.Data == end.Data)
      {
         计数
          node.CanOver = true;
          continue；
      }
      else
      {
        Find（node，end）
      }
  }
  if (start.CanOver == false)start.Isover = true；
}

Answer 3

谢谢各位的关注。
cjcgy 兄，我觉得你说的很有道理。面向对象这个用了这么就，其实很多人都还是门外汉。
telent 兄，谢谢你的代码实现，受教了。
给分。

Answer 4

    public class NetNodeBase
    {
        public string NodeName { get; set; }
        public List< NetNodeBase> NextNodes;
        public void AddChild(NetNodeBase node)
        {
            NextNodes.Add(node);
        }
        public bool Go(Stack<NetNodeBase>nodeStack )
        {
            nodeStack.Push(this);
            if (this is EndNode)
            {
                PrintPath(nodeStack);
                return true;
            }
            if (NextNodes==null||NextNodes.Count==0)
            {
                return false;
            }
            foreach (var node in NextNodes)
            {
                if (node.Go(nodeStack)) return true;
                nodeStack.Pop();
            }
            return false;
        }        private void PrintPath(Stack<NetNodeBase> stack)
        {
            foreach (var node in stack)
            {
                Console.Write(node.NodeName);
                if (!(node is StartNode)) Console.Write(",");
            }
        }
    }    public class NetNode:NetNodeBase
    {
        public NetNode(string name)
        {
            NodeName = name;
            NextNodes = new List<NetNodeBase>();
        }        public NetNode(NetNodeBase parent, string name)
        {
            NodeName = name;
            NextNodes = new List<NetNodeBase>();
            if (parent != null) parent.NextNodes.Add(this);
        }
    }    public class StartNode:NetNode
    {
        public StartNode(string name) : base(null, name)
        {
        }
    }    public class EndNode:NetNode{
        public EndNode(string name) : base(name)
        {
        }
    }    class Program
    {
        static void Main(string[] args)
        {
            var startNode = new StartNode("startNode");
            var node1 = new NetNode(startNode, "Node1");
            new NetNode(node1, "Node2");
            var node3 = new NetNode(node1, "Node3");
            var node4 = new NetNode(node1, "Node4");
            node3.AddChild(node4);
            var node5 = new NetNode("Node5");
            node4.AddChild(new EndNode("EndNode"));
            startNode.Go(new Stack<NetNodeBase>());
            Console.ReadKey();
        }
    }