您的解决方案是什么；逃离扎尔格“；C#字谜？

找到这个谜题。。。我做了一个暴力解决方案，我想知道你将如何解决它

巴兹、伍迪、雷克斯和哈姆必须逃离扎尔格（a），他们只需要穿越 他们自由前的最后一座桥。然而，这座桥很脆弱，最多只能支撑 他们两个同时在一起。此外，过桥需要手电筒照明 避免陷阱和损坏的零件。问题是我们的朋友只有一个手电筒 一个电池只能使用60分钟（这不是打字错误：60分钟）。玩具需要 跨越桥梁的不同时间（两个方向）：

因为桥上同时只能有两个玩具，所以它们不能过桥 一次架桥。因为他们需要手电筒才能过桥，只要有两个人 过了桥，总得有人回去把手电筒带到玩具上 另一边仍然要过桥。 现在的问题是：这四个玩具能按什么顺序及时过桥 是否在60分钟后）从Zurg那里被救出来

//(a) These are characters from the animation movie “Toy Story 2”.

以下是我的解决方案：

public Form1()
{
    InitializeComponent();
    List<toy> toys = new List<toy>(){
        new toy { name = "buzz", time = 5 } ,
        new toy { name = "woody", time = 10 } ,
        new toy { name = "rex", time = 20 } ,
        new toy { name = "ham", time = 25 } ,
        };
    var posibles = Combinaciones(toys, 4).ToList(); //all permutations
    List<Tuple<string, int>> solutions = new List<Tuple<string, int>>();

    foreach (var pointA in posibles)
    {
        string order = "";
        int flashlight = 60;
        List<toy> pointB = new List<toy>();
        do
        {
            var fastestInA = pointA.Take(2).ToList();
            flashlight -= fastestInA.Max(t => t.time);
            order += "go " + String.Join(",", fastestInA.Select(t => t.name)) + "\n";
            fastestInA.ForEach(t => pointA.Remove(t));
            pointB.AddRange(fastestInA);
            if (pointB.Count < 4)
            {
                var fastestInB = pointB.Take(1).ToList();
                flashlight -= fastestInB.Max(t => t.time);
                order += "return " + String.Join(",", fastestInB.Select(t => t.name).ToArray()) + "\n";
                fastestInB.ForEach(t => pointB.Remove(t));
                pointA.AddRange(fastestInB);
            }
        } while (pointB.Count != 4);

        solutions.Add(new Tuple<string, int>(order, flashlight));
    }

    var optimal = solutions.Where(s => s.Item2 == solutions.Max(t => t.Item2)).ToList();
    optimal.ForEach(s => Console.Write("Order:\n" + s.Item1 + "TimeLeft:" + s.Item2 + "\n\n"));
}

public class toy
{
    public int time { get; set; }
    public string name { get; set; }
}

// this is to do permutations
public static List<List<toy>> Combinaciones(List<toy> list, int take)
{
    List<List<toy>> combs = new List<List<toy>>();
    foreach (var item in list)
    {
        var newlist = list.Where(i => !i.Equals(item)).ToList();
        var returnlist = take <= 1 ? new List<List<toy>> { new List<toy>() } : Combinaciones(newlist, take - 1);
        foreach (var l in returnlist)
        {
            l.Add(item);
        }
        combs.AddRange(returnlist);
    }

    return combs.ToList();
}
}

public Form1（）
{
初始化组件（）；
列表玩具=新列表（）{
新玩具{name=“buzz”，time=5}，
新玩具{name=“woody”，time=10}，
新玩具{name=“rex”，time=20}，
新玩具{name=“ham”，time=25}，
};
var posibles=Combinaciones（toys，4）.ToList（）；//所有置换
列表解决方案=新列表（）；
foreach（posibles中的变量pointA）
{
字符串顺序=”；
int手电筒=60；
列表点B=新列表（）；
做
{
var fastestInA=pointA.Take（2.ToList（）；
手电筒-=最快时间（t=>t.time）；
order+=“go”+String.Join（“，”，FastTestina.Select（t=>t.name））+“\n”；
fastestInA.ForEach（t=>pointA.Remove（t））；
点B.添加范围（快速测试）；
如果（B点计数<4）
{
var fastestInB=pointB.Take（1.ToList（）；
手电筒-=最快最大值（t=>t.time）；
order+=“return”+String.Join（“，”，fastestInB.Select（t=>t.name.ToArray（））+“\n”；
fastestInB.ForEach（t=>pointB.Remove（t））；
pointA.AddRange（fastestInB）；
}
}while（pointB.Count！=4）；
添加（新元组（顺序、手电筒））；
}
var optimal=solutions.Where（s=>s.Item2==solutions.Max（t=>t.Item2））.ToList（）；
optimal.ForEach（s=>Console.Write（“顺序：\n”+s.Item1+“TimeLeft:+s.Item2+”\n\n”）；
}
公营玩具
{
公共整数时间{get；set；}
公共字符串名称{get；set；}
}
//这是做排列
公共静态列表组合（列表列表，int-take）
{
列表梳=新列表（）；
foreach（列表中的变量项）
{
var newlist=list.Where（i=>！i.Equals（item））.ToList（）；
var returnlist=take使用LINQ的递归解决方案：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Zurg
{
  class Program
  {
    static readonly Toy[] toys = new Toy[]{
        new Toy("Buzz", 5),
        new Toy("Woody", 10),
        new Toy("Rex", 20),
        new Toy("Ham", 25),
        };
    static readonly int totalTorch = 60;

    static void Main()
    {
      Console.WriteLine(Go(new State(toys, new Toy[0], totalTorch, "")).Message);
    }

    static State Go(State original)
    {
      var final = (from first in original.Start
                   from second in original.Start
                   where first != second
                   let pair = new Toy[]
                   {
                     first,
                     second
                   }
                   let flashlight = original.Flashlight - pair.Max(t => t.Time)
                   select Return(new State(
                     original.Start.Except(pair),
                     original.Finish.Concat(pair),
                     flashlight,
                     original.Message + string.Format(
                      "Go {0}. {1} min remaining.\n",
                      string.Join(", ", pair.Select(t => t.Name)),
                      flashlight)))
                   ).Aggregate((oldmax, cur) => cur.Flashlight > oldmax.Flashlight ? cur : oldmax);

      return final;
    }

    static State Return(State original)
    {
      if (!original.Start.Any())
        return original;

      var final = (from toy in original.Finish
                   let flashlight = original.Flashlight - toy.Time
                   let toyColl = new Toy[] { toy }
                   select Go(new State(
                     original.Start.Concat(toyColl),
                     original.Finish.Except(toyColl),
                     flashlight,
                     original.Message + string.Format(
                      "Return {0}. {1} min remaining.\n",
                      toy.Name,
                      flashlight)))
                   ).Aggregate((oldmax, cur) => cur.Flashlight > oldmax.Flashlight ? cur : oldmax);

      return final;
    }
  }

  public class Toy
  {
    public string Name { get; set; }
    public int Time { get; set; }
    public Toy(string name, int time)
    {
      Name = name;
      Time = time;
    }
  }

  public class State
  {
    public Toy[] Start { get; private set; }
    public Toy[] Finish { get; private set; }
    public int Flashlight { get; private set; }
    public string Message { get; private set; }
    public State(IEnumerable<Toy> start, IEnumerable<Toy> finish, int flashlight, string message)
    {
      Start = start.ToArray();
      Finish = finish.ToArray();
      Flashlight = flashlight;
      Message = message;
    }
  }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
名称空间Zurg
{
班级计划
{
静态只读玩具[]玩具=新玩具[]{
新玩具（“Buzz”，5），
新玩具（“Woody”，10岁），
新玩具（“雷克斯”，20岁），
新玩具（“火腿”，25岁），
};
静态只读int totalTorch=60；
静态void Main（）
{
Console.WriteLine（Go（新状态（玩具，新玩具[0]，totalTorch，”））。消息）；
}
静态Go（原始状态）
{
var final=（从原始.Start中的第一个开始）
从原来的第二个开始
第一名在哪里！=第二名
let pair=新玩具[]
{
第一，
第二
}
让flashlight=original.flashlight-pair.Max（t=>t.Time）
选择返回（新状态）(
原始。开始。除（对）外，
原始表面处理混凝土（双），
手电筒，
原始.消息+字符串.格式(
“转到{0}.{1}分钟剩余。\n”，
string.Join（“，”，pair.Select（t=>t.Name）），
（手电筒）
).Aggregate（（oldmax，cur）=>cur.Flashlight>oldmax.Flashlight？cur:oldmax）；
返回最终结果；
}
静态返回（原始状态）
{
如果（！original.Start.Any（））
归还原件；
var final=（从原始的玩具。完成）
让手电筒=原创。手电筒-玩具。时间
让toyColl=新玩具[]{Toy}
选择Go（新状态）(
原始.Start.Concat（toyColl），
原始表面处理。除（toyColl）外，
手电筒，
原始.消息+字符串.格式(
“返回{0}.{1}分钟剩余时间。\n”，
玩具，名字，
（手电筒）
).Aggregate（（oldmax，cur）=>cur.Flashlight>oldmax.Flashlight？cur:oldmax）；
返回最终结果；
}
}
公营玩具
{
公共字符串名称{get；set；}
公共整数时间{get；set；}
公共玩具（字符串名称，整数时间）
{
名称=名称；
时间=时间；
}
}
公共阶级国家
{
公共玩具[]开始{get；私有集；}
公共玩具[]完成{get；private set；}
公共int手电筒{get；私有集；}
公共字符串消息{get；private set；}
公共状态（IEnumerable开始、IEnumerable结束、int-flashlight、字符串消息）
{
Start=Start.ToArray（）；
Finish=Finish.ToArray（）；
手电筒=手电筒；
消息=消息；
}
}
}
你刚刚让我发现我在使用人工智能算法时有多么不正常：(

我总是带着最快的家伙回来…有点作弊，但我现在太累了，无法让它适用于所有组合。这是我的解决方案
using System;
using System.Collections.Generic;
using System.Linq;

namespace Zurg
{
  class Program
  {
    static readonly Toy[] toys = new Toy[]{
        new Toy("Buzz", 5),
        new Toy("Woody", 10),
        new Toy("Rex", 20),
        new Toy("Ham", 25),
        };
    static readonly int totalTorch = 60;

    static void Main()
    {
      Console.WriteLine(Go(new State(toys, new Toy[0], totalTorch, "")).Message);
    }

    static State Go(State original)
    {
      var final = (from first in original.Start
                   from second in original.Start
                   where first != second
                   let pair = new Toy[]
                   {
                     first,
                     second
                   }
                   let flashlight = original.Flashlight - pair.Max(t => t.Time)
                   select Return(new State(
                     original.Start.Except(pair),
                     original.Finish.Concat(pair),
                     flashlight,
                     original.Message + string.Format(
                      "Go {0}. {1} min remaining.\n",
                      string.Join(", ", pair.Select(t => t.Name)),
                      flashlight)))
                   ).Aggregate((oldmax, cur) => cur.Flashlight > oldmax.Flashlight ? cur : oldmax);

      return final;
    }

    static State Return(State original)
    {
      if (!original.Start.Any())
        return original;

      var final = (from toy in original.Finish
                   let flashlight = original.Flashlight - toy.Time
                   let toyColl = new Toy[] { toy }
                   select Go(new State(
                     original.Start.Concat(toyColl),
                     original.Finish.Except(toyColl),
                     flashlight,
                     original.Message + string.Format(
                      "Return {0}. {1} min remaining.\n",
                      toy.Name,
                      flashlight)))
                   ).Aggregate((oldmax, cur) => cur.Flashlight > oldmax.Flashlight ? cur : oldmax);

      return final;
    }
  }

  public class Toy
  {
    public string Name { get; set; }
    public int Time { get; set; }
    public Toy(string name, int time)
    {
      Name = name;
      Time = time;
    }
  }

  public class State
  {
    public Toy[] Start { get; private set; }
    public Toy[] Finish { get; private set; }
    public int Flashlight { get; private set; }
    public string Message { get; private set; }
    public State(IEnumerable<Toy> start, IEnumerable<Toy> finish, int flashlight, string message)
    {
      Start = start.ToArray();
      Finish = finish.ToArray();
      Flashlight = flashlight;
      Message = message;
    }
  }
}

class Program
{
    private class Toy
    {
        public string Name { get; set; }
        public int Time { get; set; }
    }

    private class Node : IEquatable<Node>
    {
        public Node()
        {
            Start = new List<Toy>();
            End = new List<Toy>();
        }

        public Node Clone()
        {
            return new Node
            {
                Start = new List<Toy>(Start),
                End = new List<Toy>(End),
                Time = Time,
                Previous = this
            };
        }

        public int Time { get; set; }
        public List<Toy> Start { get; set; }
        public List<Toy> End { get; set; }
        public Node Previous { get; set; }

        public Toy Go1 { get; set; }
        public Toy Go2 { get; set; }
        public Toy Return { get; set; }

        public bool Equals(Node other)
        {
            return Start.TrueForAll(t => other.Start.Contains(t)) &&
                   End.TrueForAll(t => other.End.Contains(t)) &&
                   Time == other.Time;
        }
    }

    private static void GenerateNodes(Node node, Queue<Node> open, List<Node> closed)
    {
        foreach(var toy1 in node.Start)
        {
            foreach(var toy2 in node.Start.Where(t => t != toy1))
            {
                var newNode = node.Clone();
                newNode.Start.Remove(toy1);
                newNode.Start.Remove(toy2);
                newNode.End.Add(toy1);
                newNode.End.Add(toy2);
                newNode.Go1 = toy1;
                newNode.Go2 = toy2;
                newNode.Time += Math.Max(toy1.Time, toy2.Time);

                if(newNode.Time <= 60 && !closed.Contains(newNode) && !open.Contains(newNode))
                {
                    open.Enqueue(newNode);
                }
            }
        }
    }

    static void Main(string[] args)
    {
        var open = new Queue<Node>();
        var closed = new List<Node>();

        var initial = new Node
                        {
                            Start = new List<Toy>
                                        {
                                            new Toy {Name = "Buzz", Time = 5},
                                            new Toy {Name = "Woody", Time = 10},
                                            new Toy {Name = "Rex", Time = 20},
                                            new Toy {Name = "Ham", Time = 25}
                                        }
                        };

        open.Enqueue(initial);

        var resultNodes = new List<Node>();

        while(open.Count != 0)
        {
            var current = open.Dequeue();
            closed.Add(current);

            if(current.End.Count == 4)
            {
                resultNodes.Add(current);
                continue;
            }

            if(current.End.Count != 0)
            {
                var fastest = current.End.OrderBy(t => t.Time).First();
                current.End.Remove(fastest);
                current.Start.Add(fastest);
                current.Time += fastest.Time;
                current.Return = fastest;
            }

            GenerateNodes(current, open, closed);
        }

        foreach(var result in resultNodes)
        {
            var path = new List<Node>();
            var node = result;
            while(true)
            {
                if(node.Previous == null) break;

                path.Insert(0, node);
                node = node.Previous;
            }

            path.ForEach(n => Console.WriteLine("Went: {0} {1}, Came back: {2}, Time: {3}", n.Go1.Name, n.Go2.Name, n.Return != null ? n.Return.Name : "nobody", n.Time));
            Console.WriteLine(Environment.NewLine);
        }

        Console.ReadLine();
    }
}

P-Q 1            P-Q 2
    Buzz
    Woody
    Rex
    Hamm
Buzz + Woody go = 10 min
    P-Q 1            P-Q 2
    Rex              Buzz
    Hamm             Woody
Buzz goes back = 5 min
    P-Q 1            P-Q 2
    Hamm             Woody
    Rex              
    * Buzz
Hamm + Rex go = 25 min
    P-Q 1            P-Q 2
    * Buzz           Woody
                     Hamm
                     Rex
Woody comes back = 10 min
    P-Q 1            P-Q 2
    * Buzz           Hamm
    * Woody          Rex
Woddy + Buzz go = 10 min
---------------------------
Total: 60 mins
1 - fastest
2 - after fastest
3 - you got it
4
5
6 - slowest

1 + 2 go
1 goes back
3 + 4 go
2 goes back
5 + 6 go
3 goes back
1 + 2 go
1 goes back
1 + 3 go
* Buzz and Woody go right
* Buzz goes left
* Hamm and Rex go right
* Woody goes left
* Woody and Buzz go right

* Buzz and Woody go right
* Woody goes left
* Hamm and Rex go right
* Buzz goes left
* Woody and Buzz go right