Question

我想实现一个包含最多20个解决方案的容器。如果容器包含20个解决方案，则只有

时才会接受添加的任何解决方案

1）new_value＆lt;容器中的最差值

2）如果new_value已经在容器中（并且1）成立，那么memcmp（new_assignment，assigment，assignment_size）！= 0

然后删除最糟糕的解决方案。（包括int数组） assignment_size适用于所有解决方案。

struct Solution {
  double value;
  int *assignment;
  int assigment_size;
};

实现此结构的最简单方法是什么？你能用一些STL的容器吗？

Answer 1

注意：我认为您的解决方案是由您发布的Solution结构描述的。

最简单的解决方案是std::array<Solution, 20>，包装在自定义容器包装器中。

你应该有这样的东西：

class SolutionsSequence
{
public:
    // in a function to add a solution to the sequence, you should
    // implement the criteria to decide which solution is worse
private:
    std::array<Solution, 20> solutions_;
};

除此之外，你不应该在C ++中使用memcpy。请考虑使用std::copy或std::copy_n代替。

还可以考虑使用std::vector进行分配，然后就可以摆脱assignment_size。

Answer 2

好的，谢谢。我希望这是正确的。它试图保持列表插入排序，这样更容易检查，然后你可以删除最后一个元素。

struct Solution {
  double power_peak;
  int *assignment;
  int size;
  ~Solution() { delete[] assignment; }
};


class Container {
  list<Solution> Solutions;
  uint max_size;
  double worst_solution;
public:
  Container (uint size)
  {
    max_size = size;
  }
  void addSolution(Solution s)
  {
    list<Solution>::iterator insert_position = Solutions.begin();
    while (insert_position != Solutions.end() && (*insert_position).power_peak < s.power_peak)
    {
      if ((*insert_position).power_peak == s.power_peak && memcmp((*insert_position).assignment, s.assignment, s.size) == 0)
      {
        return;
      }
      ++insert_position;
    }
    Solutions.insert(insert_position, s);
    if (Solutions.size() > max_size)
    {
      Solutions.pop_back();
    }
    worst_solution = (*(--(Solutions.end())))->power_peak;
  }
  double getWorst()
  {
    return worst_solution;
  }
};

用c ++实现Container

2 个答案: