Question

我正在编写一个小程序，试图计算在5,10和20秒内有多少机器人可以逃到一个洞，机器人以10米/秒的速度行进。

机器人和孔有两个浮点数作为坐标，并计算出我使用毕达哥拉斯定理的孔和机器人之间的距离。

为了跟踪哪个机器人最靠近一个洞，我用一个字典来装备每个洞，其中机器人id为关键字，并且它们与洞的距离为值。

也可能有不同的场景，maxium 10，具有不同的数字和洞。

输入看起来像这样，其中第一个数字N是字段中的机器人数，后跟N行X / Y坐标。第二个是数字M，它是M个X / Y坐标后面的孔数。

输入以0结尾。

3
0.0 0.0
10.0 0.0
0.0 10.0
3
99.0 0.0
0.0 1000.0
1000.0 1000.0
3
0.0 0.0
100.0 0.0
200.0 0.0
2
95.0 50.0
105.0 50.0
0

Theese是我的课程

    class Robot
{
    public int Id { get; private set; }
    public double PosX { get; private set; }
    public double PosY { get; private set; }
    public bool isHiding { get; set; }

    public Robot(double posX, double posY, int id)
    {
        PosX = posX;
        PosY = PosY;
        Id = id;
    }
}

class Hole
{
    public Dictionary<int, double> Candidates { get; set; }        
    public double PosX { get; private set; }
    public double PosY { get; private set; }
    public bool isOccupied { get; set; }
    public Hole(double posX, double posY)
    {
        PosX = posX;
        PosY = posY;
    }
}

class Scenario
{
    public int Id { get; private set; }
    public List<Duration> Durations { get; set; }

    public Scenario(int id)
    {
        Id = id;
    }
}

class Duration
{
    public int Time { get; private set; }
    public int Survivors { get; set; }
    public List<Robot> Robots { get; set; }
    public List<Hole> Holes { get; set; }

    public Duration(int time)
    {
        Time = time;
    }

}

我收集这样的输入，这是我相信可能是问题的地方。虽然对我而言，似乎所有物体都能正确地实现。

void CollectInputs()
{
    for (int i = 0; i < 10; i++)
    {
        Scenario scenario = new Scenario(i + 1);
        List<Duration>  durations = new List<Duration>();

        List<Robot> robots = new List<Robot>();
        List<Hole> holes = new List<Hole>();

        int newRobots = int.Parse(Console.ReadLine());
        if (newRobots == 0)
        {
            break;
        }

        for (int iii = 0; iii < newRobots; iii++)
        {
            string[] inputCoordsRobot = Console.ReadLine().Split(' ');
            Robot robot = new Robot(double.Parse(inputCoordsRobot[0], CultureInfo.InvariantCulture), double.Parse(inputCoordsRobot[1], CultureInfo.InvariantCulture), iii + 1);
            robots.Add(robot);
        }

        int newHoles = int.Parse(Console.ReadLine());
        for (int iii = 0; iii < newHoles; iii++)
        {
            string[] inputCoordsHole = Console.ReadLine().Split(' ');
            Hole hole = new Hole(double.Parse(inputCoordsHole[0], CultureInfo.InvariantCulture), double.Parse(inputCoordsHole[1], CultureInfo.InvariantCulture));
            holes.Add(hole);             
        }

        for (int ii = 5; ii <= 20; ii = ii + ii)
        {

            Duration duration = new Duration(ii);

            duration.Robots = new List<Robot>(robots);
            duration.Holes = new List<Hole>(holes);

            durations.Add(duration);

            scenario.Durations = new List<Duration>(durations);

        }
        _scenarios.Add(scenario);
    }

}

这是距离计算。

void UnleashStorm()
        {
            foreach (var scenario in _scenarios)
            {
                foreach (var duration in scenario.Durations)
                {
                    double movementCapacity = duration.Time * 10.0f;

                    foreach (var hole in duration.Holes)
                    {
                        Dictionary<int,double> robotsInRange = new Dictionary<int, double>();

                        foreach (var robot in duration.Robots)
                        {
                            double distanceToX = robot.PosX > hole.PosX ? robot.PosX - hole.PosX : hole.PosX - robot.PosX;
                            double distanceToY = robot.PosY > hole.PosY ? robot.PosY - hole.PosY : hole.PosY - robot.PosY;

                            double distanceToHole = Math.Sqrt(Math.Pow(distanceToX, 2) + Math.Pow(distanceToY, 2));

                            if (distanceToHole <= movementCapacity)
                            {
                                robotsInRange.Add(robot.Id, distanceToHole);
                            }

                        }

                        hole.Candidates = new Dictionary<int, double>(robotsInRange);
                    }
                }
            }
        }

我在调试器中注意到，对于每个持续时间，如果某个特定的洞被添加到特定的洞中，那么在所有持续时间计算中，键和值似乎在同一个洞之间共享。

我认为这是一个问题，我在输入集合方法或计算距离方法中以不好的方式抛出指针，但我似乎无法想出这个。

任何帮助解决这个问题都将非常感激。

Answer 1

问题不是来自词典，而是来自browser/index.html中的参考副本，其中所有duration.Holes = new List<Hole>(holes);分享您在durations.Holes

中创建的holes列表的引用

为避免这种情况，您需要将CollectInputs的值指定为holes。一种选择是使duration.Holes类可克隆

Hole

您可能在其他地方使用参考，请检查它。

列表中的对象似乎共享字典键和vaules

1 个答案: