Algorithm 动态规划求解算法

使用动态规划方法计算函数H的值H（7） 定义为：对于所有整数i>2，我们有： H（i）=H（i-2）-H（i-1）+2.

我查了一下，看了一些视频，读了一些关于动态编程的文章。但仍在为上述问题苦苦挣扎。我知道你通过事先解决小问题来解决主要问题。这样你就有更多的机会解决主要问题，因为你可以参考你以前的创始。你们发现的这些先前的结果被传递到一个结果中，但这是我不能解决这个问题的地方

H（1）=H（1-2）-H（1-1）+2.
H（2）=H（2-2）-H（2-1）+2.
H（3）=H（3-2）-H（3-1）+2.
H（4）=H（4-2）-H（4-1）+2.
H（5）=H（5-2）-H（5-1）+2.
H（6）=H（6-2）-H（6-1）+2.

我假设这些的简单计算应该放在一个表中，然后我应该以某种方式使用这些信息，然后计算出H（7）

我的想法是完全错误的还是做得正确，我不知道=[这也是期末考试的复习。

给了你

H(1)=2
H(2)=3

根据这些信息和H（i）的公式，可以计算H（3），如下所示

H(3) = H(3-2) - H(3-1) + 2 = H(1) - H(2) + 2 = 2 - 3 + 2 = 1

冲洗并重复。

给你的

H(1)=2
H(2)=3

根据这些信息和H（i）的公式，可以计算H（3），如下所示

H(3) = H(3-2) - H(3-1) + 2 = H(1) - H(2) + 2 = 2 - 3 + 2 = 1

冲洗并重复。

H（1）=2
H（2）=3
H（3）=H（1）-H（2）+2=2-3+2=1
H（4）=H（2）-H（3）+2=3-1+2=4
H（5）=H（3）-H（4）+2=1-4+2=-1
H（6）=H（4）-H（5）+2=4-（-1）+2=7
H（7）=H（5）-H（6）+2=-1-7+2=-6
所以H（7）是-6H（1）=2
H（2）=3
H（3）=H（1）-H（2）+2=2-3+2=1
H（4）=H（2）-H（3）+2=3-1+2=4
H（5）=H（3）-H（4）+2=1-4+2=-1
H（6）=H（4）-H（5）+2=4-（-1）+2=7
H（7）=H（5）-H（6）+2=-1-7+2=-6

---

因此H（7）是-6

打开浏览器中的JavaScript控制台，键入：

function H(i) { return i==1 ? 2 : i==2 ? 3 : H(i-2)-H(i-1)+2 }

然后

返回

-6

---

在浏览器中打开JavaScript控制台，然后键入：

function H(i) { return i==1 ? 2 : i==2 ? 3 : H(i-2)-H(i-1)+2 }

然后

返回

-6

---

您的任务与fibonnaci类似：） 首先我会向你解释斐波那契

F（1）=1
F（2）=1
F（N）=F（N-1）+F（N-2），每N>2

前几个斐波那契数：
F（1）=1
F（2）=1
F（3）=F（2）+F（1）=2
F（4）=F（3）+F（2）=3
F（5）=F（4）+F（3）=5

您可以在以下网站上查看更多信息：

斐波那契数的斐波那契序列是由递推关系定义的，斐波那契序列是递归序列

每个递归必须有：
1） 基本情况
2） 递推关系

对于斐波那契，基本情况是：F（1），它等于1，F（2），它也等于1。递归关系是“连接”同一问题的较小实例的关系。对于斐波那契数，如果你想知道F（N），你必须知道F（N-1）和F（N-2），对于所有N>2，就是这样。对于斐波那契，递归关系是F（N）=F（N-1）+F（N-2）

以下是代码：

#include <cstdio>
#include <cstdlib>

using namespace std;

int f(int n) {

    //printf("n = %d\n", n);
    if(n == 1 || n == 2) // base case
        return 1;
    return f(n - 1) + f(n - 2); // recurrence relation

}

int main() {

    int n; scanf("%d", &n);
    printf("%d\n", f(n));

    return 0;
}

#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;
const int N = 50;

long long memo[N];

long long f(int n) {
    if(memo[n] != -1) // if we already computed the value of f(N), then return that value
        return memo[n];
    return memo[n] = f(n - 1) + f(n - 2); // else compute the value, and save it into the table
}

int main() {

    memset(memo, -1, sizeof(memo));

    memo[1] = memo[2] = 1; // add answer for base case to the table

    int n; scanf("%d", &n);
    printf("%lld\n", f(n));

    return 0;
}

#包括
#包括
使用名称空间std；
int f（int n）{
//printf（“n=%d\n”，n）；
if（n==1 | | n==2）//基本情况
返回1；
返回f（n-1）+f（n-2）；//递归关系
}
int main（）{
int n；scanf（“%d”&n）；
printf（“%d\n”，f（n））；
返回0；
}

如果删除注释的printf，您将看到许多斐波那契值被反复计算，这是非常低效的。请尝试为F（45）运行此代码，您将看到为什么它非常低效

这就是动态规划的用武之地。正如您所见，许多斐波那契值都是反复计算的，我们可以使用记忆将它们保存在表中，如果需要，我们可以从表中返回它们。下面是代码：

#include <cstdio>
#include <cstdlib>

using namespace std;

int f(int n) {

    //printf("n = %d\n", n);
    if(n == 1 || n == 2) // base case
        return 1;
    return f(n - 1) + f(n - 2); // recurrence relation

}

int main() {

    int n; scanf("%d", &n);
    printf("%d\n", f(n));

    return 0;
}

#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;
const int N = 50;

long long memo[N];

long long f(int n) {
    if(memo[n] != -1) // if we already computed the value of f(N), then return that value
        return memo[n];
    return memo[n] = f(n - 1) + f(n - 2); // else compute the value, and save it into the table
}

int main() {

    memset(memo, -1, sizeof(memo));

    memo[1] = memo[2] = 1; // add answer for base case to the table

    int n; scanf("%d", &n);
    printf("%lld\n", f(n));

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
常数int N=50；
长备忘录；
长f（整数n）{
if（memo[n]！=-1）//如果我们已经计算了f（n）的值，那么返回该值
返回备忘录[n]；
returnmemo[n]=f（n-1）+f（n-2）；//否则计算该值，并将其保存到表中
}
int main（）{
memset（memo，-1，sizeof（memo））；
备注[1]=备注[2]=1；//将基本情况的答案添加到表中
int n；scanf（“%d”&n）；
printf（“%lld\n”，f（n））；
返回0；
}

最后，你的问题

作为Fibonacci，您可以保存h（N）的计算值。以下是代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;
const int N = 25;

int check, memo[N];

int f(int x) {
    if(memo[x] != check) // if f(n) was already computed
        return memo[x]; // return computed value
    return memo[x] = f(x - 2) - f(x - 1) + 2; // else compte given value and add it to a table
}

int main() {

    memset(memo, 63, sizeof(memo)); // very big number, if the value of h(n) is different then that very big number, then we know we have computed the value for h(n)
    check = memo[0];

    memo[1] = 2; // base case
    memo[2] = 3; // base case

    int n; scanf("%d", &n);
    printf("%d\n", f(n));

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
常数int N=25；
内部检查，备忘[N]；
整数f（整数x）{
if（memo[x]！=check）//如果已经计算了f（n）
返回备忘录[x]；//返回计算值
return memo[x]=f（x-2）-f（x-1）+2；//否则，完成给定值并将其添加到表中
}
int main（）{
memset（memo，63，sizeof（memo））；//非常大的数字，如果h（n）的值与非常大的数字不同，那么我们知道我们已经计算了h（n）的值
检查=备忘录[0]；
备注[1]=2；//基本情况
备注[2]=3；//基本情况
int n；scanf（“%d”&n）；
printf（“%d\n”，f（n））；
返回0；
}

您的任务类似于fibonnaci:） 首先我会向你解释斐波那契

F（1）=1
F（2）=1
F（N）=F（N-1）+F（N-2），每N>2

前几个斐波那契数：
F（1）=1
F（2）=1
F（3）=F（2）+F（1）=2
F（4）=F（3）+F（2）=3
F（5）=F（4）+F（3）=5

您可以在以下网站上查看更多信息：

斐波那契数的斐波那契序列是由递推关系定义的，斐波那契序列是递归序列

每个递归必须有：
1） 基本情况
2） 递推关系