java中的游戏，解决方案不适用于n> 3

Question

此遥控器包含 12 个键和 2 个非功能键。每个功能键都被赋予了一个唯一的标签，如上所示。 此控制台的计算机游戏有 N 个级别。游戏中的某些动作是使用遥控器控制的。每个动作的按键随着关卡的数量而变化，即操作的按键数量取决于游戏关卡，例如对于第三关，单步需要三个键[您必须依次按三个键才能进入第三关等级]。玩家只能按当前键的左、右、上或下键，不允许按底行角键。

假设玩家处于 2 级。根据规则，他必须按 2 个键才能移动（键的数量等于级别）。可能的移动键将是“HH”、“HI”、“HG”、“HE”、“HJ”、“IF”等

1. 如果移动从“J”开始，可能的键是“JJ”、“JH”（计数 2）

2. 如果移动从“H”开始，可能的键是“HH”、“HI”、“HG”、“HE”、“HJ”（计数 5）

3. 如果移动从“I”开始，可能的键是“II”、“IH”、“IF”（计数 3）

---

---

所以对于第 2 级，可能的移动数为 36。

如果玩家处于 N 级，您必须找到该级别的可能移动总数。

输入/输出规格

输入规范：

输入为整数N，表示游戏等级

输出规格：

输出是一个整数 M，它是可能的移动总数

示例

输入：2

输出：36

说明：

1) 不要写main函数。

2) 您可以在代码的任何步骤打印和调试您的代码。

3) 您需要从给定函数返回所需的输出。

4) 不要更改编辑器代码中给出的函数和参数名称。

5) 返回类型必须与问题陈述中提到的相同。

6) 提交代码时，后台会执行 10 个不同复杂程度的测试用例，并根据通过的测试用例数打分。

7) 如果您不打算一次性完成代码，那么请将您的工作保存在本地机器上。代码只有在使用提交按钮提交后才会保存。

8 ) 只允许提交两次。

使用系统；

public class CandidateCode {

    public static int combinationCounts(int input1) {

        //Write code here

    }

}

嗯，所以我遇到了这个问题，我得到了解决方案

    public static int combinationCounts(int input1)
    {
     final int TOT_KEYS=12;
     final int WORKING_KEYS=10;
     int moves=input1;
     return(TOT_KEYS*moves+moves+WORKING_KEYS);
    }

  public static void main(String[] args) throws IOException{
        Scanner in = new Scanner(System.in);
        int output = 0;
        int ip1 = Integer.parseInt(in.nextLine().trim());
        output = combinationCounts(ip1);
        System.out.println(String.valueOf(output));
    }
}

此代码仅适用于 n=2，但不适用于 3 以上， 任何人都可以为此提供最佳解决方案。 请帮助我

Answer 1

这需要使用图表来解决。您应该定义一个 Node 类，其中包含 Neighbours 变量数组。然后对于每个键，您需要定义一个 Node 实例，其中包含邻居。邻居数组的大小是可能的下一步动作。您需要为密钥本身的大小加一。

计数组合意味着计数路径。所以这里的 N 表示深度。当您看到深度时，这意味着 combinationCounts 方法将是一个递归方法。每次尝试使用 n-1 从自身调用combinationCounts，直到N 等于0。

方法应该是这样的；

public static int combinationCounts(int input1) {
        if(input1 == 0){
          return 0;
        }
        int totalPaths =0;
        for(Node key : keys){
            totalPaths = (key.neighbours.size() + 1) + combinationCounts(input1 -1);
        }
        return totalPaths;
  }

Answer 2

#include<bits/stdc++.h>
using namespace std;

int main() 
{ 
    // your code goes here 
    //ios_base::sync_with_stdio(false);
    //cin.tie(NULL);
    int n;
    cin>>n;
    int dp[10][16];
    vector<int> neighbours[10];
    neighbours[0]={0, 1, 3};
    neighbours[1]={0, 1, 2, 4};
    neighbours[2]={1, 2, 5};
    neighbours[3]={0, 3, 4, 6};
    neighbours[4]={1, 3, 4, 5, 7};
    neighbours[5]={2, 4, 5, 8};
    neighbours[6]={3, 6, 7};
    neighbours[7]={4, 6, 7, 8, 9};
    neighbours[8]={5, 7, 8};
    neighbours[9]={7, 9};
    
    for(int i=0; i<10; i++)
    {
        dp[i][1]=1;
    }
    for(int lv=2; lv<=n; lv++)
    {
        for(int i=0; i<10; i++)
        {
            dp[i][lv]=0;
            for(int j=0; j<neighbours[i].size(); j++)
            {
                dp[i][lv]+=dp[neighbours[i][j]][lv-1];
            }
        }
    }
    int ans=0;
    for(int i=0; i<10; i++)
    {
        //cout<<i<<"->"<<dp[i][n]<<"\n";
        ans+=dp[i][n];
    }
    cout<<ans;
} 

使用 dp 解决了它。因为 0 表示 A，1 表示 B .........，9 表示 J。

从级别“lv”中给定键“i”开始的可能序列数=从级别“lv-1”中 i 的所有邻居开始的所有可能序列。