小编Ola*_*oja的帖子

我遇到了这个非常有趣的问题,我们有一个4x4的迷宫和一个机器人试图进入目标.问题是,您必须找到一系列预定义命令,这些命令将始终导致机器人到达目标.

假设我们有一个像这样的迷宫:

x . . .
. # # .
. # # .
. . . g

这种特殊的迷宫可以用例如命令序列来解决,DDDRRR或者RRRDDD,其中R =右,L =左,U =上,D =下(duh).

然而,这些序列都不会解决这个迷宫:

x . # .
. . . .
# . . .
. . . g

机器人总是从左上角开始,目标总是在右下方,迷宫始终是2D 4x4矩阵.

我已经实现了一个算法,让我获得了78个命令的获胜序列.我确信至少存在29个命令的解决方案(其他人完成了这个).

这个问题实际上已经有几年了,所以我丢失了当时使用的算法,但基本的想法是在我生成的所有迷宫中搜索,并始终选择导致解决最多的路线迷宫.这实际上让我得到了一个略长于78的序列; 我手动减少了一些命令,我​​发现这些命令是多余的.

是的,暴力迫使需要几年的时间.

如果我的记忆服务,可能的迷宫少于4000(可能的迷宫是左上角和右下角之间的路径存在).

哦!机器人在执行命令期间至少一次访问目标就足够了.也就是说,在最后一个命令之后,它不必坐在目标上.

我有没有抓住任何人的兴趣？我应该如何处理这个问题以获得更有效的答案？谢谢你考虑:)

好玩的东西:Pastebin

这是一个(非常)匆忙拼凑的Java片段.它应该编译运行:)程序有点同时播放~4000个迷宫.程序对UP,LEFT,DOWN和RIGHT进行输入(w,a,s,d),然后模拟移动,显示一些统计数据.如果你尝试的话,你可以在屏幕上看到的是每个位置的每个迷宫中的障碍物总量,以及每个迷宫的当前位置总量.这很难解释:)问我是否有问题.

再说一遍......不要介意可怕的代码.它是在20分钟内写成的

进展

我从这个用户的答案中间接得到了这个想法(之后由于某种原因被删除),并在聊天中进一步用Mooing Duck建模.我们的想法是找到一个解决迷宫右侧的序列.也就是说,解决所有迷宫中至少一半的解决方案,并且从一开始就镜像并再次运行解决剩余的迷宫.

插图:

首先找到一个序列,其第一个命令是RIGHT,它解决了这个迷宫:

0 1 0 0
0 1 0 …

我正在尝试解决以下问题:

给定一个3x3网格,数字为1-9,例如:

2 8 3
1 4 5
7 9 6

我必须通过顺时针或逆时针旋转2x2子网格来对网格进行排序.上面的例子可以像这样解决:

顺时针旋转左上角:

2 8 3        1 2 3
1 4 5   =>   4 8 5
7 9 6        7 9 6

逆时针旋转右下方:

1 2 3        1 2 3
4 8 5   =>   4 5 6
7 9 6        7 8 9

网格现在已经"排序"了.

这是一个功课,但我只是没有得到这个.暴力强迫不起作用; 我必须能够在<= 2000ms内解决所有给定的网格.我试过的一件事是尝试计算所有8个可能的下一个动作的值(在两个方向上旋转所有4个),然后旋转具有最佳值的棋子.通过将所有数字的所有距离与其正确位置相加来计算该值.

这适用于上面的例子,但更难的是不行.

谁能指出我正确的方向？我应该从哪里开始？这个问题有名字吗？

所有网格均为3x3,旋转部分始终为2x2.

提前致谢.

编辑:忘了提到最重要的事情:我必须找到对网格进行分类的最小可能的转弯量.

EDIT2:

我实施了一个工作算法,其中包含了我收到的所有建议中的一些建议.令人讨厌的是,在我的机器上它以1.5s运行最坏情况(987654321),但在测试程序的服务器上运行> 2s,这意味着我仍然需要优化.我现在的工作代码

int find(int[][] grid) {

    Queue q = new ArrayDeque<String>();
    Map<String, Boolean> visited = new HashMap<String, Boolean>(); …

我的教授倾向于做以下事情来从用户那里得到一个数字:

Scanner scanner = new Scanner(System.in);
Integer.parseInt(scanner.nextLine());

与简单的做法相比,有什么好处scanner.nextInt()？

java.util.Scanner.java 有以下内容:

public int nextInt() {
    return nextInt(defaultRadix);
}

public int nextInt(int radix) {
    // Check cached result
    if ((typeCache != null) && (typeCache instanceof Integer)
        && this.radix == radix) {
        int val = ((Integer)typeCache).intValue();
        useTypeCache();
        return val;
    }
    setRadix(radix);
    clearCaches();
    // Search for next int
    try {
        String s = next(integerPattern());
        if (matcher.group(SIMPLE_GROUP_INDEX) == null)
            s = processIntegerToken(s);
        return Integer.parseInt(s, radix);
    } catch (NumberFormatException nfe) {
        position = matcher.start(); …

如果我有一个乘法表大小,例如,3x5:

1  2  3  4  5
2  4  6  8 10
3  6  9 12 15

我把所有这些数字按顺序排列:

1 2 2 3 3 4 4 5 6 6 8 9 10 12 15

中间的数字是多少？在这种情况下,它是5.

N并且M总是很奇怪,所以只能有一个答案.

对此有快速解决方案吗？我正在寻找各种各样的东西O(N log NM)

这是各种各样的功课,但我真的迷失了这个.我想出了一些想法,但它们都有一些缺点:

public class Table {

    public static void main(String[] ar) {
        Scanner scanner = new Scanner(System.in);
        int w = scanner.nextInt();
        int h = scanner.nextInt();

        int[] s = new int[w * h + 1];
        for (int i = 1; i …

我必须打印代表给定数字的方式,因为它是素数部分.

让我澄清一下:让我说我得到了这个数字7.现在,首先,我必须找到所有小于7的素数,即2,3和5.现在,我可以用多少种方法总结这些数字(我可以使用我想要的一个数字),以便结果等于7？例如,数字7有五种方式:

2 + 2 + 3
2 + 3 + 2
2 + 5
3 + 2 + 2
5 + 2

我完全迷失了这项任务.首先,我想我会制作一系列可用的元素,如:{2,2,2,3,3,5}(7/2 = 3,所以2必须出现三次.同样是3,得到两个出现次数).之后,循环遍历数组并选择一个'leader'来确定我们在数组中的距离.我知道解释很可怕,所以这里是代码:

#include <iostream>
#include <vector>

int primes_all[25] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};

int main()
{
    int number;
    std::cin >> number;

    std::vector<int> primes_used;

    for(int i = 0; i < 25; i++) {
        if(primes_all[i] < number …

可能重复:
一个数字,因为它是素数部分

我有我的这个家庭作业,很难得,我必须得到给定数字的所有不同的主要分区.例如,数字7有五个不同的主要分区(或者表示它具有的2个主要分区的五种不同方式):

• 5 + 2
• 2 + 5
• 3 + 2 + 2
• 2 + 3 + 2
• 2 + 2 + 3

正如您所看到的,数字本身被排除在它是素数的情况下.我不必打印所有不同的分区,只打印它们的数量.

所以我有点迷失了.我完全无法生成任何代码,但我认为我应该从动态编程视图中解决这个问题.我只想要一些提示.有没有人有想法？提前致谢.

最高输入数为100.此外,程序的运行时间不能超过1秒,内存限制为128 MB.

正如标题所说,给定0-9的整数,在我用完一些整数之前,我能写出的最后一个数字是多少？

因此,如果我给出了一个库存,比如从0到9的每个数字为10,那么在我用完一些数字之前,我可以写的最后一个数字是多少.例如,股票为2我可以写数字1 ... 10:

1 2 3 4 5 6 7 8 9 10

在这一点上我的股票是0,我不能写11.还要注意,如果给我一个3的股票,我仍然只能编写1 ... 10的数字,因为11将花费我2个,这将将我的股票留给-1.

到目前为止我所得到的:

public class Numbers {

public static int numbers(int stock) {
    int[] t = new int[10];
    for (int k = 1; ; k++) {

        int x = k;
        while (x > 0) {

            if (t[x % 10] == stock) return k-1;
            t[x % 10]++;
            x /= 10;

        }

    }
}

public static void main(String[] args) {
    System.out.println(numbers(4));

}

}

有了这个,我可以得到相当大的股票大小的正确答案.库存大小为10 ^ 6时,代码在~2秒内完成,并且库存为10 ^ …

关于标签

我将其标记为Java 和 C ++问题。这意味着我不是在寻找特定于语言的答案。我只标记了C ++和Java，因为我精通它们，并且如果用这些（或类似）语言编写代码示例，则很可能会理解您的代码示例。

我在找什么

指针和洞察力的安全性措施，发展软件时，主要是我应该考虑到游戏，如描述的下方。安全是指检查并再次检查用户是否采取了非故意的行为。这可能意味着一些行为，例如将他/她存在的最新恶意病毒更新集发送到服务器/其他客户端，或者通过黑客攻击等方式损害其他玩家的用户体验。

预期的评论和答案

您是否在问如何阻止人们入侵您的游戏？

这是不以任何方式，我的问题，因为它的方式过于广泛，这个线程。但是，如果您确实找到了一种简单的方法（通过作弊）来赢得每场比赛，请告诉我。

这个问题更适合X

我已经在CodeReview和程序员中提出了这个问题。在这两个网络中，该职位均受到好评。为了公平起见，这里也很不受欢迎（请参阅ADTC的评论），因此赏金很高。悬赏后，我重写了这篇文章，以更好地满足SO的标准。但是，如果您仍然认为此帖子不太适合此处，请告诉我原因。我很难确定这是否真的更适合SO或Programmers，所以不要以为这只是我一秒钟不考虑之后在这里发布的转储。

要在两台计算机之间创建连接，应使用套接字。去谷歌上查询。

我不是在寻找这种技术帮助。我知道如何实现该软件，这不是我第一次这样做。请看看我问的实际问题。

我为什么要问这个？

有问题的软件

我正在开发类似蛇的多人游戏，玩家可以使用自己的算法来确定蛇的下一步行动。播放器通过客户端-服务器连接彼此连接，即，一个播放器将充当主机。您可以假设服务器代码将等到所有玩家轮到自己，直到更新所有客户端之间的游戏状态为止。

关于游戏

我的游戏在文件夹中搜索任何兼容的.jar文件，这些文件的主类扩展了特定的抽象类。然后，玩家可以通过直接连接到其他玩家或通过在大厅搜索游戏来通过网络连接到其他玩家。

在玩游戏时，每个玩家将使用自己的算法来确定其蛇的下一步动作。每个游戏的持续时间可能会有所不同，具体取决于为游戏指定的更新速率，但是大多数情况下它们的速度很快，并且很可能会在不到30秒的时间内结束。

我还没有实现实际的网络多人游戏。

逻辑的模板源文件如下：

package template

import snake.*;

public class TemplateLogic extends SnakeLogic {

    @Override
    public void onLaunch() {
    }

    @Override
    public String getMove() {
        return "UP";
    }

}

因此，从主机播放器的角度来看，我打算做的是以String格式（“上”，“下”，“左”，“右”）通过网络获取播放器的下一个动作，因此在这方面不会有任何安全问题。每个客户用来确定其下一步行动的实际程序只能在相应客户的计算机上运行。

我希望你到目前为止一直在关注我。无论如何，我现在担心的是我可能忽略的任何其他坑洼。确定所有这些坑洼可能是一件繁琐的工作，因此，我主要不会问这个。我对这件事的见解是我所期望的。理想情况下，我可以从不同的人的多个答案中得到更大的了解。

浮现在其他问题之上的问题是，我可以阻止任何客户端在其程序上使用会损害其他播放器用户体验的方法吗？例如，这样的方法Thread.sleep()：如果玩家让他的算法在每次移动之间等待10分钟，那将很烦人。对于这个特殊的问题，我认为应该为每个动作设置一个时间限制，在此之后，落后的/恶意的玩家将被踢出或被分配一个默认的动作，以便游戏可以正常继续。

音符：

@Darinth的回答让我想起了游戏的一个非常重要的方面：允许用户输入，这意味着蛇的下一步可以由人类玩家决定-也就是说，可以使用键盘正常玩游戏。此外，没有任何限制会限制您在纯AI和仅键盘解决方案之间进行选择：您可以将它们混合在一起，例如，自己控制蛇，并在发现自己将自己陷入陷阱时让AI接管。

总结一下

我忽略了大事吗？我已经计划将这作为我和我的朋友一起度过的一个小项目，与他们共度时光，但是我有点发烧友。

无论您的想法有多小，请不要犹豫。如果您想到更多的兴趣点，以后可以编辑答案以更全面。我会定期检查所有答案以进行修改。

感谢您的时间。 …

我有一个单例服务器实例,我很好奇我的代码是否是线程安全的.我已经阅读了不同的单例模式,我认为通常的方法是double-checked locking模式,如下所示:

public static Singleton getInstance() {
    if(singleton == null) {
        synchronized(Singleton.class) {
            if(singleton == null) {
                singleton = new Singleton();
            }
        }
    }
    return singleton;
}

这被认为是设置/获取单身的有效线程安全方式.我读过,获取和设置单例的最简单方法是lazy instantiation,看起来像这样:

public static ClassicSingleton getInstance() {
    if(instance == null) {
        instance = new ClassicSingleton();
     }
     return instance;
}

现在我想知道的是我的变体是否是线程安全的.我的代码:

public static void startServer(int listeningPortNumber) throws IOException {
    if (server != null) {
        throw new IOException("Connection exists");
    }

    server = new Server(listeningPortNumber);
}

我的代码与上面的惰性实例化模式非常相似,但我看不出我的代码是如何不是线程安全的.有没有我没看到的东西,或者这是真正有效的代码？

参考: …

我的程序中有一个计划任务,在给定的一段时间后关闭一个帧.但是,在执行任务后,程序将继续运行,就好像它ScheduledExecutorService仍在另一个线程上运行一样.

这是我的代码的相关部分:

int delay = 1000;

ScheduledExecutorService ex = Executors.newSingleThreadScheduledExecutor();
ex.schedule(() -> {

    System.out.println("executed");
    getWindow().closeWindow();
    // ex.shutdown();

}, delay, TimeUnit.MILLISECONDS);

这里任务在1秒延迟后执行,"执行"打印一次,帧关闭,程序即使在此代码之后也继续运行.如果我取消注释ex.shutdownNow();,程序将按预期成功结束.但是,我无法弄清楚为什么会这样.我也没能从互联网的其他部分找到任何东西.

MCVE:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {

    public static void main(String[] args) {
        int delay = 1000;

        ScheduledExecutorService ex = Executors.newSingleThreadScheduledExecutor();
        ex.schedule(() -> {

            System.out.println("executed");
            // ex.shutdown();

        }, delay, TimeUnit.MILLISECONDS);
    }

}

lambdas可能已经放弃了,但这确实是Java 8.

为什么程序在任务执行后没有停止？