标签: upperbound

我试图了解MCTS算法的工作原理以及如何在纸牌游戏中实现它以改进AI引擎.

我已经阅读了mcts.ai/网站和许多关于它的论文,其中一篇展示了一些关于在智能卡游戏的AI中应用蒙特卡洛搜索与UCB成功的结果,这或多或少是我需要做的但是,我在尝试理解某些要点以及如何应用它时遇到了一些麻烦,以便解决我的需求.我在数学方面也没那么多经验,所以当论文用复杂的公式解释所有这些东西时我会迷失方向.

这是我到目前为止所提出的:

1. 给定一个游戏状态(游戏中的用户手),确定哪些是可以进行的所有可能的合法游戏,然后我将创建一个节点列表(一个代表每个游戏)作为MCTSTree的根节点中的属性,每个节点的结果(得分值？)

2. 使用随机播放器模拟每个合法游戏的完整(直到结束)游戏玩法,并将结果记录在每个节点中,无论玩家是赢还是输,以获得完整的图片.

这里是"我认为"应该应用蒙特卡洛+ UCB的地方:

1. 使用UCB递归地选择更有前途的游戏(节点),并且在其叶子的情况下,从其gameState扩展具有所有可能游戏的节点.

2. 模拟所选节点的n个播出,直到达到一定的时间.

   • 在这个阶段我有一些疑问...说我尝试随机播放给出一个可能的播出列表...为了继续模拟,我该如何处理第一个结果？我应该让树长大吗？

3. 我如何反向传播结果？

然后,

• 记住,因为这是一个复杂的纸牌游戏,我有这么多可能的动作......它是否有足够好的性能在任何节点中拥有这么多的孩子？

• 如果每个模拟都基于游戏状态,并且每次玩家应用移动时游戏都会改变状态,那么我怎么知道树是否真的有用？

我真的很感激任何帮助.

非常感谢你!

在 Java 中还有其他替代方法可以实现相同的目标吗？在 C++ 中，我可以使用这些美妙的方法，让我的生活更轻松。在 Java 中也有可能吗？我唯一的目标是编写简单干净且不易出错的代码。

使用PostgreSQL 9.4:

SELECT x, lower(x), upper(x) FROM (SELECT '[1,2]'::numrange x) q;
> [1,2] | 1 | 2      -- looks OK

SELECT x, lower(x), upper(x) FROM (SELECT '[1,2]'::int4range x) q;
> [1,3) | 1 | >>3<<  -- this is unexpected

让我们进一步检查:

SELECT x, lower(x), upper(x) FROM (SELECT '[1,3)'::numrange x) q1;
> [1,3) | 1 | 3      -- looks OK

SELECT x, lower(x), upper(x) FROM (SELECT '[1,3]'::numrange x) q1;
> [1,3] | 1 | 3      -- looks OK

来自pg文档:

upper(anyrange)| 范围的元素类型| 范围的上限| …

我看到了std :: lower_bound()和std :: upper_bound()语法中的不一致(好吧,类型转换,真的),并且想知道是否有人可以解释一下吗？根据评论,第2行尽管与第1行明显相似,但不会编译; 你需要使用第3行显示的表格(至少在gcc 4.7.3/ubuntu 64位上 - 这就是我必须要玩的)

#include <set>
#include <algorithm>

using namespace std;

class MyInt {
  private:
    int val;
  public:
    MyInt(int _val): val(_val) {}
    bool operator<(const MyInt& other) const {return val < other.val;}
};

int main() {
    set<MyInt> s;
    s.insert(1);  // demonstrate implicit conversion works
    s.insert(MyInt(2));
    s.insert(3); // one last one for the road
    set<MyInt>::iterator itL = lower_bound(s.begin(), s.end(), 2); //LINE 1
    // the line below will NOT compile
    set<MyInt>::iterator itU = upper_bound(s.begin(), s.end(), 2); //LINE …

我看到几篇文章将上限描述为最佳案例,将下限描述为最坏情况.同时,一些文章对最坏情况的上下限进行了解释.

所以基本上这让我问了三个问题:

1. 什么是上/下界？
2. 如何在最坏情况场景中单独定义它们？
3. 是否可以为其他案例(最佳,平均)定义界限？

我想知道是否有可能创建一个泛型类，它接受一个 type 的实例T，它仅限于（例如） 的实例String或 的实例List<String>。以如下伪代码为例：

data class Wrapper<T : String | List<String>>(val wrapped: T)

这非常类似于UnionKotlin 中不存在的构造（按设计）。我很好奇这是否可以在编译时检查中实现。上面提供的伪代码类将用于提供 的单个对象实例String，如果提供了多个实例，则它应该是一个List<String>.

解决此问题的其他选项包括：

1. 每个“变体”的单独类，即：

   data class Wrapper<T : String>(val wrapped: T)
   data class ListWrapper<T : List<String>>(val wrapped: T)
   

   Run Code Online (Sandbox Code Playgroud) 这里的缺点显然是它是部分重复的代码。
2. 删除上限，并使用init块进行实例类型检查。这里的缺点是检查移动到运行时。

编辑：我知道使用关键字有多个上限where，但是，这会导致对符合两个上限的接受类型的限制（因此，它是一个AND构造）

我有一个向量events，它由事件向量组成，例如：

events = [[1,3,2],[2,4,3],[4,5,2],[10,20,8]]

其中events[i]是格式[startTime_i, endTime_i, value_i]（含）。所有事件都按这样的方式排序，即jth 事件出现在ith 之后，if startTime_j > startTime_i。

由于事件已排序，我想使用二分搜索 ( lower_bound()) 来找出当前事件之后我可以参加的下一个非重叠事件。

有朋友建议使用：

vector<int> v={events[i][1]+1,INT_MIN,INT_MIN};
auto nextOne=lower_bound(begin(events),end(events),v);

我不遵循将第二个和第三个值设置为INT_MIN上面的直觉。有人可以解释一下吗？如果我必须获得一个upper_bound()，我是否必须使用INT_MAX它？

谢谢你！

例如，我有一个元素为 1,7,9,23,34,47,67,89,123,234,345,567 的数组。我需要知道123的位置。

这是代码.结果我得到"4 4".不明白为什么它不是"2 4"(根据下限和上限的'defenitions).

#include <bits/stdc++.h>
using namespace std;
int main()
{
    vector<int> v = {1, 2, 4, 5};
    vector<int>::iterator s , f;
    s = lower_bound(v.begin(), v.end(), 3);
    f = upper_bound(v.begin(), v.end(), 3);
    cout << (*s) << " " << (*f);
    return 0;
}

在典型的 Scala 上限示例中

abstract class Animal {
  def name: String
}

abstract class Pet extends Animal {}

class Cat extends Pet {
  override def name: String = "Cat"
}

class Dog extends Pet {
  override def name: String = "Dog"
}

class Lion extends Animal {
  override def name: String = "Lion"
}

这有什么区别

class PetContainer[P <: Pet](p: P) {
      def pet: P = p
    }

val dogContainer = new PetContainer[Dog](new Dog)
val catContainer = new PetContainer[Cat](new Cat)

和这个？

class …