Question

我需要设计一个算法来找到我可以在预定义（步长）沿着int []获得的最大值（步进）。

输入是我们可以＆＃34;使用＆＃34;的次数。每一步长度;由n2，n5和n10给出。 n2表示我们在阵列中移动2个点，n5表示5个点，n10表示10个点。我们只能前进（从左到右）。

int []包含值1..5，数组的大小为（n2 * 2 + n5 * 5 + n10 * 10）。起点是int [0]。

示例：我们从int [0]开始。从这里我们可以移动到int [0 + 2] == 3，int [0 + 5] == 4或int [0 + 10] == 1.让它移动到int [5]，因为它有最高价值。从int [5]我们可以移到int [5 + 2]，int [5 + 5]或int [5 + 10]等。

我们应该沿着阵列以2,5或10的步长移动（并且我们只能使用每个步长n2-，n5-和n10-次），这样我们就可以进入数组来收集尽可能高的金额。

输出是可能的最大值。

public class Main {

private static int n2 = 5;
private static int n5 = 3;
private static int n10 = 2;
private static final int[] pokestops = new int[n2 * 2 + n5 * 5 + n10 * 10];

public static void main(String[] args) {

    Random rand = new Random();
    for (int i = 0; i < pokestops.length; i++) {
        pokestops[i] = Math.abs(rand.nextInt() % 5) + 1;
    }
    System.out.println(Arrays.toString(pokestops));
    //TODO: return the maximum value possible
}
}

Answer 1

这是伪代码的答案（我没有运行它，但它应该有用）。

fill dp with -1.

dp(int id, int 2stepcount, int 5stepcount, int 10stepcount) {
  if(id > array_length - 1) return 0;
  if(dp[id][2stepcount][5stepcount][10stepcount] != -1) return dp[id][2stepcount][5stepcount][10stepcount];
  else dp[id][2stepcount][5stepcount][10stepcount] = 0;
  int 2step = 2stepcount < max2stepcount? dp(id + 2, 2stepcount + 1, 5stepcount, 10stepcount) : 0;
  int 5step = 5stepcount < max5stepcount? dp(id + 5, 2stepcount, 5stepcount + 1, 10stepcount) : 0;
  int 10step = 10stepcount < max10stepcount? dp(id + 10, 2stepcount, 5stepcount, 10stepcount + 1) : 0;
  dp[id][2stepcount][5stepcount][10stepcount] += array[id] + max(2step, 5step, 10step);
  return dp[id][2stepcount][5stepcount][10stepcount];
}

调用dp（0,0,0,0），答案在dp [0] [0] [0] [0]中。

如果你想倒退，那么你这样做：

fill dp with -1.

dp(int id, int 2stepcount, int 5stepcount, int 10stepcount) {
  if(id > array_length - 1 || id < 0) return 0;

  if(dp[id][2stepcount][5stepcount][10stepcount] != -1) return dp[id][2stepcount][5stepcount][10stepcount];
  else dp[id][2stepcount][5stepcount][10stepcount] = 0;

  int 2stepForward = 2stepcount < max2stepcount? dp(id + 2, 2stepcount + 1, 5stepcount, 10stepcount) : 0;
  int 5stepForward = 5stepcount < max5stepcount? dp(id + 5, 2stepcount, 5stepcount + 1, 10stepcount) : 0;
  int 10stepForward = 10stepcount < max10stepcount? dp(id + 10, 2stepcount, 5stepcount, 10stepcount + 1) : 0;

  int 2stepBackward = 2stepcount < max2stepcount? dp(id - 2, 2stepcount + 1, 5stepcount, 10stepcount) : 0;
  int 5stepBackward = 5stepcount < max5stepcount? dp(id - 5, 2stepcount, 5stepcount + 1, 10stepcount) : 0;
  int 10stepBackward = 10stepcount < max10stepcount? dp(id - 10, 2stepcount, 5stepcount, 10stepcount + 1) : 0;

  dp[id][2stepcount][5stepcount][10stepcount] += array[id] + max(2stepForward, 5stepForward, 10stepForward, 2stepBackward, 5backForward, 10backForward);
  return dp[id][2stepcount][5stepcount][10stepcount];
}

但是你的路径没有被探索过，因为如果索引为负数或大于数组大小，我们就会停止 - 1，你可以添加环绕功能。

Answer 2

这是一个解决方案，但我不确定它是多么优化！

我做了一些优化，但我认为可以做得更多

我发布了有问题的例子

import java.util.Arrays;
import java.util.Random;

public class FindMax {


private static int n2 = 5;
private static int n5 = 3;
private static int n10 = 2;
private static final int[] pokestops = new int[n2 * 2 + n5 * 5 + n10 * 10];


public static int findMaxValue(int n2, int n5, int n10, int pos, int[] pokestops) {
    System.out.print("|");
    if (n2 <= 0 || n5 <= 0 || n10 <= 0) {
        return 0;
    }
    int first;
    int second;
    int third;
    if (pokestops[pos] == 5 || ((first = findMaxValue(n2 - 1, n5, n10, pos + 2, pokestops)) == 5) || ((second = findMaxValue(n2, n5 - 1, n10, pos + 5, pokestops)) == 5) || ((third = findMaxValue(n2, n5, n10 - 1, pos + 10, pokestops)) == 5)) {
        return 5;
    }
    return Math.max(Math.max(Math.max(first, second), third), pokestops[pos]);
}

public static void main(String[] args) {

    Random rand = new Random();
    for (int i = 0; i < pokestops.length; i++) {
        pokestops[i] = Math.abs(rand.nextInt() % 5) + 1;
    }
    System.out.println(Arrays.toString(pokestops));
    //TODO: return the maximum value possible
    int max = findMaxValue(n2, n5, n10, 0, pokestops);
    System.out.println("");
    System.out.println("Max is :" + max);
}

}

Answer 3

你需要计算以下动态编程dp [c2] [c5] [c10] [id] - 其中c2是你步数2的次数，c5 - 乘5，c10 - 乘10和id - 其中是你现在的位置。我将只为c2和c5编写示例，它可以很容易地扩展。

int[][][][] dp = new int[n2 + 1][n5 + 1][pokestops.length + 1];
for (int[][][] dp2 : dp) for (int[][] dp3 : dp2) Arrays.fill(dp3, Integer.MAX_VALUE);
dp[0][0][0] = pokestops[0];
for (int c2 = 0; c2 <= n2; c2++) {
  for (int c5 = 0; c5 <= n5; c5++) {
    for (int i = 0; i < pokestops.length; i++) {
      if (c2 < n2 && dp[c2 + 1][c5][i + 2] < dp[c2][c5][i] + pokestops[i + 2]) {
        dp[c2 + 1][c5][i + 2] = dp[c2][c5][i] + pokestops[i + 2];
      }  
      if (c5 < n5 && dp[c2][c5 + 1][i + 5] < dp[c2][c5][i] + pokestops[i + 5]) {
        dp[c2][c5 + 1][i + 5] = dp[c2][c5][i] + pokestops[i + 5];
      }  
    }   
  }
}

Answer 4

我知道目标语言是java，但我喜欢pyhton并且转换不会很复杂。您可以定义一个4维数组 dp ，其中 dp [i] [a] [b] [c] 是您可以使用的最大值当你已经一个长度为 2 ， b 5 的步骤时，从我开始和 c 的长度的 10 即可。我使用memoization来获得更清晰的代码。

import random

values = []
memo = {}

def dp(pos, n2, n5, n10):
    state = (pos, n2, n5, n10)
    if state in memo:
        return memo[state]
    res = values[pos]
    if pos + 2 < len(values) and n2 > 0:
        res = max(res, values[pos] + dp(pos + 2, n2 - 1, n5, n10))
    if pos + 5 < len(values) and n5 > 0:
        res = max(res, values[pos] + dp(pos + 5, n2, n5 - 1, n10))
    if pos + 10 < len(values) and n10 > 0:
        res = max(res, values[pos] + dp(pos + 10, n2, n5, n10 - 1))
    memo[state] = res
    return res

n2, n5, n10 = 5, 3, 2

values = [random.randint(1, 5) for _ in range(n2*2 + n5*5 + n10*10)]

print dp(0, n2, n5, n10)

Answer 5

可疑地喜欢做作业。未经测试：

image(test, xlim = c(90, 110), ylim = c(180, 220))

有一条线可以取消注释以允许前进和后退（我确定有人在允许的评论中说过，但现在我在你的帖子中看到它只是向前说...）< / p>

求最大值的最优算法

5 个答案: