Java 拆分递归可以手工完成吗？

我有一个工作表问题要解决，我就是不知道怎么用手来解决。每个方法调用2个以上的方法来运行，因此每个方法将调用2个以上的方法。我不知道如何记录这些。我不知道除了把它放到Eclipse中，人们还能怎样找到答案

static int fun(int x) {
    if(x < 1) {
        return 1;
    } else {
        return x + fun(x-1) + fun(x-2);
    }
}

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

static int fun（int x）{
if（x<1）{
返回1；
}否则{
返回x+fun（x-1）+fun（x-2）；
}
}
公共静态void main（字符串[]args）{
系统输出println（fun（4））；
}

首先，“拆分递归”不是我以前遇到过的术语。谷歌认为我在问如何使用递归实现一个

split

函数；e、 g.将字符串拆分为单词

如果您询问是否可以手动执行该计算（即计算

n

的某个值的

n

），那么答案显然是肯定的。你只需要一张足够大的纸和一些耐心

如果你想知道是否有可能为

fun（n）

找到一个“封闭形式”的方程式。。。我怀疑答案是肯定的。然而，这是一个数学问题，而不是一个编程问题。（基本上，你将

fun

的声明映射到一个递归关系…并解决它。在这种情况下，它可能需要一年级的大学数学技能。一旦你有了封闭形式，就很容易通过归纳证明它是正确的。）

如果您询问是否有更快的程序来计算

fun（n）

，那么答案是肯定的：

• 如果你使用记忆，有一个

  O（N）

  解决方案
• 如果可以导出封闭形式，则有一个

  O（1）

  解

（我假设您可以使用

int

或

long

算术。）

---

1-实际上，对于足够大的N值，你应该能够用铅笔和纸（以及智能）比运行该程序更快地计算

fun（N）

。该程序具有复杂性

（2^N）

。。。如前所述

首先，“拆分递归”不是我以前遇到过的术语。谷歌认为我在问如何使用递归实现一个

split

函数；e、 g.将字符串拆分为单词

如果您询问是否可以手动执行该计算（即计算

n

的某个值的

n

），那么答案显然是肯定的。你只需要一张足够大的纸和一些耐心

如果你想知道是否有可能为

fun（n）

找到一个“封闭形式”的方程式。。。我怀疑答案是肯定的。然而，这是一个数学问题，而不是一个编程问题。（基本上，你将

fun

的声明映射到一个递归关系…并解决它。在这种情况下，它可能需要一年级的大学数学技能。一旦你有了封闭形式，就很容易通过归纳证明它是正确的。）

如果您询问是否有更快的程序来计算

fun（n）

，那么答案是肯定的：

• 如果你使用记忆，有一个

  O（N）

  解决方案
• 如果可以导出封闭形式，则有一个

  O（1）

  解

（我假设您可以使用

int

或

long

算术。）

---

---

1-实际上，对于足够大的N值，你应该能够用铅笔和纸（以及智能）比运行该程序更快地计算

fun（N）

。该程序具有复杂性

（2^N）

。。。如前所述

更简单的解决方案：声明一个数组，其大小足以容纳

fun（）

的值。当需要

fun（4）

时，您需要一个

int[5]

。填写前两个元素的硬编码值，然后在循环中使用公式填写其余条目。现在，您的结果位于最后一个元素中

---

一个可能的空间需求优化：在整个循环中，您始终只需要最后两个值和当前值，因此您不需要将所有值存储在大小为

x+1

的数组中。更简单的解决方案是：声明一个足够大的数组，以便将

fun（）

的值保存到所需的值。当需要

fun（4）

时，您需要一个

int[5]

。填写前两个元素的硬编码值，然后在循环中使用公式填写其余条目。现在，您的结果位于最后一个元素中

---

一个可能的空间需求优化：在整个循环过程中，您只需要最后两个值和当前值，因此您不需要将所有值存储在大小为

x+1

的数组中，如果您指的是多次调用自身的函数，则是

基本情况：

x<1==>1

，因此

fun（-1）

以及

fun（0）

替代

1

fun(1)              ; == [substitute default case with result]
1 + fun(0) + fun(-1); == [substitute base cases]
1 + 1 + 1           ; ==> 3

fun(2)              ; == [substitute default case with result]
2 + fun(1) + fun(0) ; == [substitute fun(1) with previously calculated result]
2 + 3 + fun(0)      ; == [substitute base cases]
2 + 3 + 1           ; ==> 6

fun(3)              ; == [substitute default case with result]
3 + fun(2) + fun(1) ; == [substitute with previously calculated result]
3 + 6 + 3           ; ==> 12

fun(4)              ; == [substitute default case with result]
4 + fun(3) + fun(2) ; == [substitute with previously calculated results]
4 + 12 + 6          ; ==> 22

你可以这样开始玩

fun（4）

：

fun(4) ; == [expand default cases]
4 + 
fun(3) + 
fun(2) ; == [expand default cases]
4 + 
3 + fun(2) + fun(1) +
2 + fun(1) + fun(0) ; == [expand fun(2) default case]

4 + 
3 + (2 + fun(1) + fun(0)) + fun(1) + 
2 + fun(1) + fun(0) ; == [group]

4 + 3 + 2*2 + 3*fun(1) + 2*fun(0) ; == [expand default cases]

4 + 3 + 2*2 + 2*fun(0) +
3*(1 + fun(0) + fun(-1)) ; == [group, group x<1 as b]

4 + 3+ 2*2 + 3*1 + 8*fun(b) ; == [expand base cases]
4 + 3+ 2*2 + 3*1 + 8*1      ; == [calculate]
; ==> 22

---

它似乎与序列一致，只是省略了第一个元素

如果您指的是多次调用自身的函数，那么是的

基本情况：

x<1==>1

，因此

fun（-1）

以及

fun（0）

替代

1

fun(1)              ; == [substitute default case with result]
1 + fun(0) + fun(-1); == [substitute base cases]
1 + 1 + 1           ; ==> 3

fun(2)              ; == [substitute default case with result]
2 + fun(1) + fun(0) ; == [substitute fun(1) with previously calculated result]
2 + 3 + fun(0)      ; == [substitute base cases]
2 + 3 + 1           ; ==> 6

fun(3)              ; == [substitute default case with result]
3 + fun(2) + fun(1) ; == [substitute with previously calculated result]
3 + 6 + 3           ; ==> 12

fun(4)              ; == [substitute default case with result]
4 + fun(3) + fun(2) ; == [substitute with previously calculated results]
4 + 12 + 6          ; ==> 22

你可以这样开始玩

fun（4）

：

fun(4) ; == [expand default cases]
4 + 
fun(3) + 
fun(2) ; == [expand default cases]
4 + 
3 + fun(2) + fun(1) +
2 + fun(1) + fun(0) ; == [expand fun(2) default case]

4 + 
3 + (2 + fun(1) + fun(0)) + fun(1) + 
2 + fun(1) + fun(0) ; == [group]

4 + 3 + 2*2 + 3*fun(1) + 2*fun(0) ; == [expand default cases]

4 + 3 + 2*2 + 2*fun(0) +
3*(1 + fun(0) + fun(-1)) ; == [group, group x<1 as b]

4 + 3+ 2*2 + 3*1 + 8*fun(b) ; == [expand base cases]
4 + 3+ 2*2 + 3*1 + 8*1      ; == [calculate]
; ==> 22

---

它似乎与序列一致，只是省略了第一个元素

所以你想要的是系列的第n项：Un=n+U（n-1）+U（n-2）

由于没有人提到它，下面是使用2个累加器的尾部递归版本，说明了您希望在OCaml中执行的操作：

let f x =
  let rec f' acc' acc'' i =
    if i = x then i+acc''
    else f' (i+acc'') (i+acc'+acc'') (i+1)
  in f' 1 1 0

如果您使用带有尾部调用优化的语言（比如哼哼……比如说OCaml），那么速度会非常快。既然你不是，这里有一个悲伤的、不雅的、命令式的Java版本：

public static int f (int x){
  int acc1 = 1 ,acc2 = 1;
  for (int i = 0; i<x; i++){
    int tmp = acc1;
    acc1 = i+acc2;
    acc2 = i+tmp+acc2;
  }
  return x+acc2;
}

公共静态int f（int x）{
int acc1=1，acc2=1；
对于（inti=0；i那么你想要的是级数的第n项：Un=n+U（n-1）+U（n-2）

因为没有人