Algorithm 一个数组中的数的唯一组合数，其和等于目标（递归+；记忆）

动态规划问题：

考虑一个游戏，玩家可以在一个游戏中获得3分、5分或10分 移动

给定总分n，找出达到给定分数的不同组合的数量

我试图用递归+记忆来解决这个问题

我的仅递归方法：

long long int countrecur(long long int n, long long int min)
{   
    if (n==0)
        return 1;     
    
    else if(n<0)
        return 0;
    
    else 
    {
        long long int ans=0;

        if(min<=3)
            ans+=countrecur(n-3,3);

        if(min<=5)
            ans+=countrecur(n-5,5);

        if(min<=10)
            ans+=countrecur(n-10,10);
        
        return ans;
    }

}

long long int count(long long int n)
{
   return countrecur(n,0);
}

long long int countrecur（long long int n，long long int min）
{   
如果（n==0）
返回1；
否则，如果（n假设你想要一个得分为8的方法

因此，只有一种方法可以做出改变，即：

{3,5}

但是，上面的代码为其返回2，因为：

这是以不同的方式考虑（3,5）和（5,3）


那么，该怎么办？

递归应该遵循给定的持续值，或者根本不使用它

这意味着应保持值的使用顺序


伪代码：

#include<iostream>
#include<vector>
using namespace std;

long long int countrecur(long long int n, long long int min, vector<long long int> &dp)
{
    if (n < 3 && n!=0)
        return 0;
    
    if (n == 0||dp[n]!=0)
        return dp[n];

    else
    {
        long long int ans = 0;
        if (min <= 3)
            ans += countrecur(n - 3, 3,dp);
        
        if (min <= 5)
            ans += countrecur(n - 5, 5,dp);
        
        if (min <= 10)
            ans += countrecur(n - 10, 10,dp);

        dp[n] = ans;

        return ans;
    }

}

long long int count(long long int n, vector<long long int>& dp)
{
    return countrecur(n, 0,dp);
}

int main()
{
    int n;
    cin >> n;
    vector<long long int>dp(n+1, 0);
    dp[0] = 1;
    cout << count(n,dp) << endl;
}

Array = [3,5,10]
index = 0 
value = 20

ways = Recursion(Array,index,value)

function Recursion(Array,index,value)

    if(value == 0)
        return 1

    if(value < 0)
        return 0

    if(index == 3)
        return 0

    return Recursion(Array,index,value - Array[index]) + Recursion(Array,index+1,value)


递归：

#include<iostream>
#include<vector>
using namespace std;

long long int countrecur(long long int n, long long int min, vector<long long int> &dp)
{
    if (n < 3 && n!=0)
        return 0;
    
    if (n == 0||dp[n]!=0)
        return dp[n];

    else
    {
        long long int ans = 0;
        if (min <= 3)
            ans += countrecur(n - 3, 3,dp);
        
        if (min <= 5)
            ans += countrecur(n - 5, 5,dp);
        
        if (min <= 10)
            ans += countrecur(n - 10, 10,dp);

        dp[n] = ans;

        return ans;
    }

}

long long int count(long long int n, vector<long long int>& dp)
{
    return countrecur(n, 0,dp);
}

int main()
{
    int n;
    cin >> n;
    vector<long long int>dp(n+1, 0);
    dp[0] = 1;
    cout << count(n,dp) << endl;
}

Array = [3,5,10]
index = 0 
value = 20

ways = Recursion(Array,index,value)

function Recursion(Array,index,value)

    if(value == 0)
        return 1

    if(value < 0)
        return 0

    if(index == 3)
        return 0

    return Recursion(Array,index,value - Array[index]) + Recursion(Array,index+1,value)

min=='3'的方法是：

dp = [1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1]

当通过min==“5”时：

dp = [1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1]

但当min='10'和n==5进行递归时：

1 is returned but there is no way for the score of 10 to make a total of 5.

这就是为什么上面记忆的代码15次返回4，但正确的输出应该是3。
我相信我的递归+记忆方法是输入=8时输出1。我已经尝试使用这些条件子句来维持顺序。@Shubhashish现在我想我的答案可以解决你的问题了。