Question

我有一个计算空间哈希的函数如下：

int generateHash(int x, int y, int bucketWidth, int bucketsPerSide)
{
    return static_cast<int>(floor(x / bucketWidth) + floor(y / bucketWidth) * bucketsPerSide);
}

我有一个定义为x，y，width，height的边界框，我想为它检索所有哈希值。我该怎么做？问题似乎微不足道，但我花了一整天时间试图解决这个问题，而我却找不到解决方案。这让我感到绝望。

请注意，该框可能太大，以至于分配了超过4个哈希（角点）。我需要生成所有哈希，包括里面的哈希。

愚蠢的解决方案是从x和y开始，并在嵌套循环中将它们增加1并添加到std :: set以确保每个哈希仅出现一次，但这是非常低效的。我知道必须有更好的方法来做到这一点。我尝试通过bucketWidth递增，但在某些情况下它不会为最右边生成哈希值。

我最接近的是：

std::vector<int> getOccupiedBucketIds(const cv::Rect& rect)
{
    std::vector<int> occupiedBucketIds;
    auto xIncrement = rect.width < bucketWidth  ? rect.width : bucketWidth ;
    auto yIncrement = rect.height < bucketWidth ? rect.height : bucketWidth ;

    for (auto x = rect.x; x <= rect.x + rect.width; x += xIncrement)
    {
        for (auto y = rect.y; y <= rect.y + rect.width; y += yIncrement)
        {
            occupiedBucketIds.push_back(generateHash(x, y, bucketWidth , cellsPerSide));
        }
    }
    return occupiedBucketIds;
}

然而，当rect.width％bucketWidth＆gt;时，这会留下以下案例： 0：

Answer 1

你想要这样的东西：

def miniMaxScore(self,isComp,alpha=None,beta=None):
    """Get score of current game"""
    if self.isFinished(): #if game is complete, score it and return
      return self.score()
    if alpha==None:
      alpha=float('-inf')
    if beta==None:
      beta=float('+inf')
    if isComp:
      bestValue=float('-inf')
      for move in self.empty():
        new=self.fillIn(*move,2)
        currValue=new.miniMaxScore(False,alpha,beta)
        alpha=max(alpha,currValue)
        bestValue=max(currValue,bestValue)
#        if beta<=alpha:
#          break
      return bestValue
    else:
      bestValue=float('+inf')
      for move in self.empty():
        new=self.fillIn(*move,2)
        currValue=new.miniMaxScore(True,alpha,beta)
        beta=min(currValue,beta)
        bestValue=min(currValue,bestValue)
#        if beta<=alpha:
#          break
      return bestValue
def getAIMove(self):
  """Return the x and y positions of the optimal AI move"""
  scores=[]
  for possibleMove in self.empty():
    possibleNext=self.fillIn(*possibleMove,2)
    scores.append((possibleMove,possibleNext.miniMaxScore(False)))
  return max(scores,key=lambda x:x[1])[0] #best move

由于您使用的是浮点数学，因此您无法获得最右边的优势。也就是说，当您计算靠近单元格边缘的数字时，它们可能比您预期的要小一些，或略大一些。

解决方案是改为计算远离边缘的细胞中心的位置。

Answer 2

我的一位朋友帮助我解决了这个问题。就像我说的那样，这有点微不足道......

    var http = require("http");
    module.exports = {
      "Check Response Code" : function (client) {
          var request = http.request({
            host: "www.google.com",
            port: 80,
            path: "/images/srpr/logo11w.png",
            method: "HEAD"
          }, function (response) {
            client
            .assert.equal(response.statusCode, 200, 'Check status');
            client.end();
          }).on("error", function (err) {
            console.log(err);
            client.end();
          }).end();
         }
       };

边界框

2 个答案: