如何解决我的动态规划问题？

Question

这是我的代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
#define M 1000000007
#define INF 1000000007
typedef pair<lli,lli> ll;
#define mem(a,x) memset(a,x,sizeof(a))
lli n,k,m;
lli dist[507][507];
lli path1[207][207];
vector<int> v2(1005,1);
vector<double> v;
lli x,y,c,z,t,q,u,d,a1,b;
struct edge
{
    lli a,b,cost;
};
/*void djkstra(int x,vector<ll> v[])
{
    mem(vis,0);
    dist[x]=0;
    s2.insert({0,x});
    while(!s2.empty())
    {
        ll p=*s2.begin();
        s2.erase(s2.begin());
        x=p.second;
        if(vis[x])
        continue;
        vis[x]=1;
        for(int j=0;j<v[x].size();j++)
        {
            if(dist[v[x][j].second]>dist[x]+v[x][j].first)
            {
                dist[v[x][j].second]=dist[x]+v[x][j].first;
                s2.insert({dist[v[x][j].second],v[x][j].second});
                a[v[x][j].second]=x;
            }
        }
    }
}*/
lli parent[100007];
lli find(lli a)
{
    return a==parent[a]?a:parent[a]=find(parent[a]);
}
void dset(lli n)
{
    for(int j=0;j<=n;j++)
    parent[j]=j;
}
void unio(lli a,lli b,lli rank[])
{
    if(rank[find(a)]>rank[find(b)])
    parent[find(b)]=find(a);
    else if(rank[find(b)]>rank[find(a)])
    parent[find(a)]=find(b);
    else
    {
        parent[find(a)]=find(b);
        rank[find(b)]++;
    }
}
bool check(lli a)
{
    if((a1*a*m+b*(a-1)+d)>=x)
    return true;
    return false;
}
/*bool valid(int i,int x)
{
    for(int j=1;j<x;j++)
    {
        if((abs(b[j-1]-i)==abs(j-x))||(i==b[j-1])||(j==x))
        return false;
    }
    return true;
}*/
lli p[10007];
lli dp[301][301][301];
map<ll,ll> pat;
map<ll,lli> p2;
lli pr[200007],we[200007];
lli a[100005];
map<lli,lli> m4;
vector<int> v4;
int f=0;
lli tot=1;
lli vis[1001][1001];
lli p1;
lli s[10001];
lli n1;
lli solve(lli n,lli i,lli c)
{
//cout<<n<<" "<<i<<" "<<a[i]<<" "<<dp[n][i]<<endl;
if(i>n1)
return 0;
if(c==0&&n>0)
return 0;
if(c==0&&n==0)
return 1;
if(n<0)
return 0;
if(dp[n][i][c]!=-1)
return dp[n][i][c];
dp[n][i][c]=solve(n-i,i,c-1);
dp[n][i][c]+=solve(n,i+1,c);
return dp[n][i][c];
}
int main()
{
    while(1)
    {
        string s="\0";
        getline(cin,s);
        if(s.size()==0)
        return 0;
        string d[3];
        d[0]="\0";
        d[1]="\0";
        d[2]="\0";
        int c=0;
        for(int i=0;i<=300;i++)
        {
            for(int j=1;j<=300;j++)
            {
            for(int k=1;k<=300;k++)
            dp[i][j][k]=-1;
            }
        }
        for(int j=0;j<s.length();j++)
        {
            if(s[j]!=' ')
            d[c]+=s[j];
            else
            c++;
        }
        int f;
        stringstream ss(d[0]);
        ss>>f;
        n1=f;
        lli d1=0;
        for(int i=1;i<=f;i++)
        d1+=solve(f,1,i);
        for(int i=0;i<=300;i++)
        {
            for(int j=0;j<=300;j++)
            dp[0][i][j]=1;
        }
        lli sum[f+1];
        mem(sum,0);
        sum[0]=1;
        for(int i=1;i<=f;i++)
        {
            if(i==1)
            sum[i]=dp[f][1][i];
            else
            sum[i]=sum[i-1]+dp[f][1][i];
        }
        if(c==0)
        {
            if(f!=0)
            cout<<d1<<endl;
            else
            cout<<1<<endl;
        }
        else if(c==1)
        {
            int f1;
            stringstream ss1(d[1]);
            ss1>>f1;
            if(f1>f)
            f1=f;
            cout<<sum[f1]<<endl;
        }
        else
        {
            int f1,f2;
            stringstream ss1(d[1]);
            ss1>>f1;

            stringstream ss2(d[2]);
            ss2>>f2;
            if(f1>f)
            cout<<0<<endl;
            else
            {
            if(f2>f)
            f2=f;
            cout<<sum[f2]-sum[f1]+dp[f][1][f1]<<endl;
            }
        }
    }
}

在以下函数中：

lli solve(lli n,lli i,lli c)

我的解决方案是 O(N^3)，它应该通过测试用例（N=300），但仍然超过了它的时间限制。

我怎么解决这个问题？

这是问题链接。

Answer 1

好的，动态编程的重点是能够重用已经完成的工作。

那么如何重用你的代码呢？

这是我的想法：

假设总金额为 6 美元，我们知道我们总共有 3 件，总计该金额。 你可以开始尝试，首先找到总共赚 1 美元的方法，而不是 2 美元、3 美元……总是重复使用你以前所做的。 例子

总共 1 美元

唯一的方式 1x1$（将其保留在内存中）

共 2 美元

- 分解所有可能的 2 部分，您可以添加：1+1, 2 - 找到其他可能性，重复使用您在递归之前所做的事情（此级别的递归仅在第一次迭代后停止，因为 1$ 是最小美元价值）-把它留在记忆中

...（继续这样，总共 3 美元，总共 4 美元，总共 5 美元......）

总共 6 美元

- 分解所有可能的 2 件，您可以添加：6, 1+5, 2+4 3+3（总是 (n intDiv 2) +1 种可能性）可能性 - 要找到其他可能性，重复使用您在递归之前所做的工作：例如：对于 3+3 的可能性，请查看在 3$ 处找到的所有可能性以找到所有可能性。 - 删除所有使用过多碎片的可能性。 你找到了所有的可能性作为答案：1+1+4、1+2+3、3+3 和 2+2+2。

希望能帮助到你 ：）