Question

我正在试图弄清楚以下问题的最佳方法。

我需要在地图上绘制路线。我有一个有序的颜色池我想从中挑选。如果第一种颜色可用（尚未使用），我想使用该颜色。如果使用第一种颜色，我想使用第二种颜色，依此类推。此外，我绘制的路线可以分组。因此，如果组相同，它们可以共享相同的颜色。

以下是一个例子：

颜色列表（订单很重要）：蓝色，红色，绿色，黄色......

第一条路线是A组。蓝色可用：BLUE
第二条路线是B组。蓝色不可用。红色可用：RED
第三条路线是A组.A组已经在使用Blue，所以请使用：BLUE
删除第二条路线
第四条路线是C组。蓝色不可用。红色可用：RED
第五条路线是D组。蓝色和红色不可用。绿色可用：绿色

我正在讨论这类系统的最佳数据结构。我需要保持颜色和顺序，哪些组“检出”了一种颜色，当我可以“释放”一种颜色回到可用选择池中时。

有什么建议吗？

修改

我目前的策略是使用两个数据结构。首先是一个字典，其中键是组名，值是使用的颜色，所以我知道谁正在使用什么颜色。第二个结构是一个堆栈，用于维护可用颜色的顺序。

因此，当我想添加新路由时，我首先去字典检查我的组名是否存在。如果是的话，我将使用指定的颜色。如果没有，我将从堆栈中提取下一个可用颜色，然后将我的组合添加到字典中。

问题是，它不能保持使用颜色计算每组中路线数量的计数。因此，假设我使用Blue在A组中有两条路线。我删除了一条路线。我如何知道是否还有其他A组路线仍在使用蓝色？我不知道我是否可以把蓝色放回堆栈。

Answer 1

我很相似。我应该把它清理干净......

    class ColorAssigner
{
    public Dictionary<string, ColorGroupDetails> ColorAssignments { get; private set; }
    public SortedList<double, Color> Colors { get; private set; }

    public ColorAssigner()
    {
        ColorAssignments = new Dictionary<string, ColorGroupDetails>();
        Colors = new SortedList<double, Color>()  { { 1, Color.Blue}, {2, Color.Red}, {3,Color.Green}, {4,Color.Yellow} };
    }

    public Color RequestColor(string groupName)
    {
        if (ColorAssignments.ContainsKey(groupName)) 
        {
            ColorAssignments[groupName].Count++;
            return ColorAssignments[groupName].AssignedColor;
        }

        var assignedColor = GetNextAvailableColor();

        ColorAssignments.Add(groupName, new ColorGroupDetails() { Count = 1, AssignedColor = assignedColor });

        return assignedColor;
    }

    private Color GetNextAvailableColor()
    {
        var assignedColors = ColorAssignments.Select(a => a.Value.AssignedColor).ToList();

        return Colors.Values.Except(assignedColors).First();
    }

    public void ReleaseColor(string groupName)
    {
        if (ColorAssignments.ContainsKey(groupName))
        {
            var count = ColorAssignments[groupName].Count -= 1;

            if (count < 1) ColorAssignments.Remove(groupName);
        }
    }
}


    class ColorGroupDetails
    {
        public int Count { get; set; }
        public Color AssignedColor { get; set; }
    }
}

Answer 2

我可以使用Dictionary和SortedList

来实现这一目标

internal class ColorUseCounter
{
    public ColorUseCounter(int ColorID, Color Color)
    {
        this.ColorID = ColorID;
        this.Color = Color;
        Count++;
    }

    public int ColorID { get; set; }
    public Color Color { get; set; }
    public int Count { get; set; }
}

private static Dictionary<double, ColorUseCounter> UsedColors = new Dictionary<double, ColorUseCounter>();
private static SortedList<int, Color> AvailableColors = new SortedList<int, Color>()
{
    { 1, Color.FromArgb(74, 117, 175) },
    { 2, Color.FromArgb(226, 134, 48) },
    { 3, Color.FromArgb(94, 158, 64) },
    { 4, Color.FromArgb(185, 58, 46) },
    ...
    ...
};

Dictionary在GroupID上键入，在我的情况下是一个双倍。因此，当我有绘制路线时，我首先检查我的GroupID是否在Dictionary。如果是，我将该颜色用于我的路线，并将Count增加1，以便我知道有多少路线正在使用Color。

如果我的GroupID不在Dictionary，我会转到使用SortedList的优先级作为密钥的Colors。因此，我抓住SortedList中的第一项，并将其与我的GroupID一起添加到Dictionary。然后，我从Color中移除SortedList，因为它已不再可用。

当我删除路线时，我只需检查Dictionary以查看Count是否已归零。如果是，请删除Dictionary条目，然后将Color重新插入SortedList。

工作得很好。

＆＃34;签出＆＃34;的数据结构资源？

2 个答案: