我赞成每场比赛多打几场比赛。制作50款游戏只是抛硬币。我需要做1000个游戏，才能在测试算法之间找到合理的区别。

下载无畏1.2。

策略:

keep track of all possible positions for ships that have >0 hits. The list never gets bigger than ~30K so it can be kept exactly, unlike the list of all possible positions for all ships (which is very large). The GetShot algorithm has two parts, one which generates random shots and the other which tries to finish sinking an already hit ship. We do random shots if there is a possible position (from the list above) in which all hit ships are sunk. Otherwise, we try to finish sinking a ship by picking a location to shoot at which eliminates the most possible positions (weighted). For random shots, compute best location to shoot based on the likelihood of one of the unsunk ships overlapping the location. adaptive algorithm which places ships in locations where the opponent is statistically less likely to shoot. adaptive algorithm which prefers to shoot at locations where the opponent is statistically more likely to place his ships. place ships mostly not touching each other.

一秒钟的游戏时间是机器特定的。与比赛机器相比，我的机器上每秒的CPU操作将是不同的。如果我优化Battle Ship算法，让它在1秒内利用最多CPU时间，那么它就会运行在可能较慢的比赛机器上，它总是会输。

我不确定如何绕过框架的这一限制，但它应该得到解决。

...

一个想法是做在这个比赛http://www.bcsstudentcontest.com/

每个回合有最大时间，而不是最大总游戏时间。这样我可以限制算法以适应已知的转弯时间。一款游戏可能会持续50到600多个回合，如果我的算法管理它的总游戏时间，它可能没有足够的时间来发挥最佳效果，或者它可能会花费太多时间而失败。在战舰算法中管理游戏总时间是非常困难的。

我建议修改规则，限制回合时间，而不是总游戏时间。

Edit

如果我写了一个算法，枚举所有可能的镜头，然后对它们进行排名，然后选择排名最高的镜头。生成所有可能的镜头需要很长时间，所以我会让算法运行一段时间，然后停止它。

如果有基于回合的限制，我可以让算法运行0.9秒并返回排名最高的镜头，并且在回合时间限制内很好。

如果我的游戏总时间被限制在1秒，那么就很难确定算法在每个回合中应该运行多长时间。我想要最大化我的CPU时间。如果游戏持续500轮，我可以将每个回合限制在0.002秒，但如果游戏持续100轮，我可以给每个回合0.01秒的CPU时间。

对于一个算法来说，使用半穷举搜索镜头空间来找到当前限制的最佳镜头是不切实际的。

1秒的游戏总时间限制了可以有效用于游戏竞争的算法类型。

如果你强迫自己进行分析，那么你可能会发现随机对手的机制非常低效。它允许自己重新选择已经目标的位置，并让框架强制它重复，直到它击中它还没有触及的位置，或者每次移动的时间限制到期。

这个对手有类似的行为(有效的位置分布是相同的)，它只是自己进行完整性检查，每次调用只消耗一个随机数生成(平摊)。

这使用了我的扩展/库答案中的类，我只提供关键方法/状态。

Shuffle源自Jon Skeet的回答

class WellBehavedRandomOpponent : IBattleShipOpponent
{
    Rand rand = new Rand();
    List<Point> guesses;
    int nextGuess = 0;

    public void PlaceShips(IEnumerable<Ship> ships)
    {
        BoardView<bool> board = new BoardView<bool>(BoardSize);
        var AllOrientations = new[] {
            ShipOrientation.Horizontal,
            ShipOrientation.Vertical };

        foreach (var ship in ships)
        {
            while (!ship.IsPlaced)
            {
                var l = rand.Pick(board.Select(c => c.Location));
                var o = rand.Pick(AllOrientations);
                if (ship.IsLegal(ships, BoardSize, l, o))
                    ship.Place(l, o);
            }
        }
    }

    public void NewGame(Size size, TimeSpan timeSpan)
    {
        var board = new BoardView<bool>(size);
        this.guesses = new List<Point>(
            board.Select(x => x.Location).Shuffle(rand));
        nextGuess = 0;
    }

    public System.Drawing.Point GetShot()
    {
        return guesses[nextGuess++];
    }

    // empty methods left out 
}

实际上，我认为这个谜题最大的问题在于它本质上是两个步骤。一个步骤是放置你的船只，另一个步骤是找到敌人的船只(不管第二部分是如何分割的，除了尝试用随机因素打败时间外，它只是“运行你的算法”)。游戏中不存在决定并反击敌人策略的机制，这也是基于连续回合的“石头剪刀布”的类似竞争非常有趣的原因。

此外，我认为如果你将游戏指定为网络协议，然后提供框架以c#实现该协议，而不是规定所有解决方案都应该是c#，这将更酷，但这只是我的观点。

编辑:我取消我最初的观点，因为我没有足够仔细地阅读比赛规则。

我在这里没有放入实际的代码，但我将冒险进行一些一般性的观察:

因为所有的飞船都至少有2个细胞大小，你可以使用我在《太空探索V》中看到的一个优化——当它“寻找”一个目标时，只向菱形图案的交替细胞开火。这将消除一半的方格，同时仍然保证你最终会找到所有船只。 在许多游戏中，寻找目标时的随机射击模式从统计上来说会产生最好的结果。

这是一个供人们玩的对手:

http://natekohl.net/files/FarnsworthOpponent.cs

与其使用固定的几何启发策略，我认为尝试估计任何特定的未探索空间拥有一艘船的潜在概率会很有趣。

为了做到这一点，你需要探索所有符合你当前世界观的船的可能配置，然后基于这些配置计算概率。你可以把它想象成探索一棵树:

扩大可能的战列舰国家http://natekohl.net/media/battleship-tree.png

在考虑了所有与你所了解的世界相冲突的树叶后(游戏邦注:例如，船只不能重叠，所有被击中的方块都必须是船只等)，你可以计算船只在每个未探索位置出现的频率，从而估算船只位于那里的可能性。

这可以可视化为热图，其中热点更有可能包含船只:

每个未开发位置的概率热图http://natekohl.net/media/battleship-probs.png

我喜欢这个战列舰比赛的一个原因是上面的树几乎小到可以强制使用这种算法。如果这5艘船每艘都有150个可能的位置，那就是1505 = 750亿种可能性。这个数字只会越来越小，特别是如果你可以排除整艘船。

我上面链接的对手并没有探索整棵树;750亿美元仍然太大，无法在一秒钟内进入。不过，在一些启发式的帮助下，它确实试图估计这些概率。