核心Java编程中的组无邻接递归问题

我有下面的问题，这一次我做了一些研发并得出了解决方案，但解决方案中也有一个小故障（一个场景）

Q:GroupNoAjacent递归问题：：给定一个整数数组，是否可以选择一组整数，以使该组与给定目标求和，并带有此附加约束：如果选择数组中的某个值作为组中的值，则不能选择数组中紧随其后的值。（不需要循环。）

我的解决方案如下。除了一个场景外，它适用于以下所有给定场景

---

代码： 我的代码不适用于粗体标记的代码。您是否有任何想法、输入或建议。我已尝试分析代码，但由于没有获得异常情况的解决方案，我将其发布在Stackoverflow中。

因为这一行：

i从0开始，j初始化为0+2=2，但是numbers.length是1，所以循环中的代码永远不会执行

       for (int j = i + 2; j<numbers.length; j++){

for（int j=i+2；j因为这一行：

i从0开始，j初始化为0+2=2，但是numbers.length是1，所以循环中的代码永远不会执行

       for (int j = i + 2; j<numbers.length; j++){

for（intj=i+2；j这是一个没有循环的递归版本（在Scala中，不是Java）

val案例=列表(
（0，列表（2，5，10，4），12），
（0，列表（2，5，10，4），14），
（0，列表（2，5，10，4），7），
（0，列表（2,5,10,4,2,7），
（0，列表（2，5，10，4），9），
（0，列表（10，2，2，3，3），15），
（0，列表（10，2，2，3，3），7），
（0，List[Int]（），0），
（0，列表（1），1），
（0，列表（9），1），
（0，列表（9），0），
（0，列表（5，10，4，1，11））
对于（（u，l，total），这里是一个没有循环的递归版本（在Scala中，不是Java）

val案例=列表(
（0，列表（2，5，10，4），12），
（0，列表（2，5，10，4），14），
（0，列表（2，5，10，4），7），
（0，列表（2,5,10,4,2,7），
（0，列表（2，5，10，4），9），
（0，列表（10，2，2，3，3），15），
（0，列表（10，2，2，3，3），7），
（0，List[Int]（），0），
（0，列表（1），1），
（0，列表（9），1），
（0，列表（9），0），
（0，列表（5，10，4，1，11））
对于（（u，l，total）
public boolean groupNoAdj（int start，int[]nums，int target）{
如果（目标==0）
返回true；
如果（开始
公共布尔组noadj（int start，int[]nums，int target）{
如果（目标==0）
返回true；
如果（开始
这是我的递归解决方案

public boolean groupNoAdj(int start, int[] nums, int target)
{
    if (start >= nums.length)
    {
        return target == 0;
    }  

    if (groupNoAdj(start+1, nums, target - nums[start])
     && groupNoAdj(start+2, nums, target - nums[start]))
    {
        return true; 
    }

    if (groupNoAdj(start+1, nums, target))
    {
        return true;
    }

    return false;
}

这是我的递归解决方案

public boolean groupNoAdj(int start, int[] nums, int target)
{
    if (start >= nums.length)
    {
        return target == 0;
    }  

    if (groupNoAdj(start+1, nums, target - nums[start])
     && groupNoAdj(start+2, nums, target - nums[start]))
    {
        return true; 
    }

    if (groupNoAdj(start+1, nums, target))
    {
        return true;
    }

    return false;
}

如果您想看到一个简短的递归解决方案，这是我的：

public boolean groupNoAdj(int start, int[] nums, int target) {
  
  if(target == 0) return true;
  
  if(target < 0 || start >= nums.length) return false;
  
  
  return groupNoAdj(start + 1, nums, target)
      || groupNoAdj(start + 2, nums, target - nums[start]);
  
  
}

public boolean groupNoAdj（int start，int[]nums，int target）{
if（target==0）返回true；
if（target<0 | | start>=nums.length）返回false；
返回组noadj（开始+1，nums，目标）
||groupNoAdj（start+2，nums，target-nums[start]）；
}
如果您想看到一个简短的递归解决方案，这是我的：

public boolean groupNoAdj(int start, int[] nums, int target) {
  
  if(target == 0) return true;
  
  if(target < 0 || start >= nums.length) return false;
  
  
  return groupNoAdj(start + 1, nums, target)
      || groupNoAdj(start + 2, nums, target - nums[start]);
  
  
}

public boolean groupNoAdj（int start，int[]nums，int target）{
if（target==0）返回true；
if（target<0 | | start>=nums.length）返回false；
返回组noadj（开始+1，nums，目标）
||groupNoAdj（start+2，nums，target-nums[start]）；
}
问题陈述提到了递归，并说“不需要循环”。您的解决方案有循环，不使用递归。如果这是一个赋值（闻起来像一个赋值）你的答案似乎不是他们想要的。@Paul，我首先尝试不使用递归的方法。这不是家庭作业问题，我只是从我之前遇到的一次面试中得到了这个问题。我想练习不使用递归的方法，理解逻辑，然后可能在递归OK的基础上构建一个。递归的方法要简单得多：）@Paul，如果你能发布递归调用的解决方案，那会很有帮助。问题陈述提到了递归，并说“不需要循环”。你的解决方案有循环，也不使用递归。如果这是一个赋值（闻起来像一个赋值）你的答案似乎不是他们想要的。@Paul，我首先尝试不使用递归的方法。这不是家庭作业问题，我只是从我之前遇到的一次面试中得到了这个问题。我想练习不使用递归的方法，理解逻辑，然后可能在递归OK的基础上构建一个。递归的方法要简单得多：）@Paul，如果你能发布递归调用的解决方案，那会很有帮助。如果我不必做一组显式的
reated[0]=true；
首先，如果你搜索groupNoAdj（0，{4}，0），它将不起作用。我不确定修复方法是什么。您可能希望先检查列表的大小，然后再处理小数组。我会考虑并进行编辑。当您执行布尔[]到达=新布尔[target+1]；groupNoAdj（0，{1}，1）时，创建大数组也会消耗大量内存→ true false X返回false，我必须对原始源代码做哪些修改如果我不必做一组显式的
reated[0]=true；
首先，如果搜索groupNoAdj（0，{4}，0），它将不起作用。我不确定修复方法是什么。您可能希望先检查列表的大小，然后再处理小数组。我会考虑并进行编辑。当您执行布尔[]到达=新布尔[target+1]；groupNoAdj（0，{1}，1）时，创建大数组也会消耗大量内存→ true false X返回false，我必须对原始源代码进行哪些修改谢谢biut，如果您使用java，这将非常有用返回一个删除了前n个元素的列表，“head”返回列表的第一个元素。for/println的第一个元素只是打印结果-makeTotal就是您所需要的
val cases = List(
(0, List(2, 5, 10, 4), 12),      
(0, List(2, 5, 10, 4), 14),     
(0, List(2, 5, 10, 4), 7),
(0, List(2, 5, 10, 4, 2), 7),
(0, List(2, 5, 10, 4), 9),
(0, List(10, 2, 2, 3, 3), 15),
(0, List(10, 2, 2, 3, 3), 7),
(0, List[Int](), 0),
(0, List(1), 1), 
(0, List(9), 1),
(0, List(9), 0),
(0, List(5, 10, 4, 1), 11))

for ((_,l, total) <- cases)
    println(l.mkString("(", ",",")") + " " + makeTotal(l, total))


def makeTotal(l:List[Int], total:Int):Boolean = {
if (l.isEmpty)
    total == 0 
else
    makeTotal(l.drop(1),total) || makeTotal(l.drop(2), total - l.head)
}

public boolean groupNoAdj(int start, int[] nums, int target) {
   if (target == 0)
   return true;
   if (start < nums.length)
   return groupNoAdj(start + 2,nums,target - nums[start]) || groupNoAdj(start + 1,nums,target);
   return false;
}

public boolean groupNoAdj(int start, int[] nums, int target)
{
    if (start >= nums.length)
    {
        return target == 0;
    }  

    if (groupNoAdj(start+1, nums, target - nums[start])
     && groupNoAdj(start+2, nums, target - nums[start]))
    {
        return true; 
    }

    if (groupNoAdj(start+1, nums, target))
    {
        return true;
    }

    return false;
}

public boolean groupNoAdj(int start, int[] nums, int target) {
  
  if(target == 0) return true;
  
  if(target < 0 || start >= nums.length) return false;
  
  
  return groupNoAdj(start + 1, nums, target)
      || groupNoAdj(start + 2, nums, target - nums[start]);
  
  
}