要求输出方案：以01背包为例

我们可以知到，01背包用一维数组表示的状态转移方程是：

$$f[j]=max(f[j],f[j-vi]+wi)$$
那么，要求输出方案时应该怎么办呢？我们没有在决策过程中记录方案，按照动态规划的过程方案并非固定，因此我们需要通过动态规划的结果来得出其中之一的选择方案.
根据状态转移方程，若f[j]=f[j-v1]+wi,则说明这件物品是选择的.因此我们根据这一结论，通过对结果的不断相减的处理以及判断，便可以得到期中之一的方案.
代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,V,t=0;
int v[10000];
int w[10000];
int ans[1000];
int f[2000][2000];
int main()
{
    ios::sync_with_stdio(false); 
    cin>>n>>V;
    for (int i=1;i<=n;i++)
        cin>>v[i]>>w[i];
    for (int i=1;i<=n;i++)
        for (int j=0;j<=V;j++)
        {
            if (j<v[i]) f[i][j]=f[i-1][j];
            else f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
        }
    while (n>0&&V>0)
    {
        if (f[n][V]==f[n-1][V-v[n]]+w[n])
        {
            ans[++t]=n;
            V=V-v[n];
        }
        n--;
    }
    for (int i=t;i>=1;i--)
        cout<<ans[i]<<' ';
    return 0;
}

---

求字典序最小的方案数：以01背包为例

我们知道，按照上述程序的方法，一定无法保证字典序最小，即：
如果要保证字典序是最小的，必然要在从小到达枚举选择策略的时，若枚举到的物品可选可不选的时候，必然是要选的，例如枚举到了1-4，若一号物品可选可不选的时候，必然要选，毕竟以1开头无论如何字典序都是最大的;按上述策略，是从n-1枚举的，显然如果先选n便必然不能保证字典序的最小.因此，我们需要调换一下顺序，即读入的时候将for循环倒序读入，在输出n的时候再以输出n-i+1就能够保证序列顺序和答案的正确性.
代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,V,t=0,N;
int v[10000];
int w[10000];
int ans[1000];
int f[2000][2000];
int main()
{
    ios::sync_with_stdio(false); 
    cin>>N>>V;n=N;
    for (int i=n;i>=1;i--)
        cin>>v[i]>>w[i];
    for (int i=1;i<=n;i++)
        for (int j=0;j<=V;j++)
        {
            if (j<v[i]) f[i][j]=f[i-1][j];
            else f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
        }
    while (n>0&&V>0)
    {
        if (f[n][V]==f[n-1][V-v[n]]+w[n])
        {
            cout<<N-n+1<<' ';
            V=V-v[n];
        }
        n--;
    }
    return 0;
}

---

可行方案总数：以01背包为例

我们知道，若以价值而论，状态转移方程便是：

$$f[i][j]=max(f[i-1][j],f[i-1][j-vi]+wi)$$
其中的状态转移方程f[i][j]表示前i件物品与容量为j的背包物品的最大价值；那么我们在面对这个相同条件但所求结果不同的问题中，我们便可以设f[i][j]为前i件物品组合出来的容量为j的方案数，因此，我们同样可以分两种情况进行讨论来得出状态转移方程，即我们枚举i和j的时候：
取：方案数为f[i-1][j] 2.不取：方案数为f[i-1][j-vi] 故状态转移方程如下(sum表示累加)：
$$f[i][j]=sum(f[i-1][j],f[i-1][j-vi])$$
优化成一维，便是： $$f[j]=sum(f[j],f[j-vi])$$
代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,V,ans=0;
int v[100000];
int f[100000];
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>V;
    for (int i=1;i<=n;i++)
        cin>>v[i];
    f[0]=1;
    for (int i=1;i<=n;i++)
        for (int j=V;j>=v[i];j--)
            f[j]+=f[j-v[i]];
    for (int i=1;i<=V;i++)
        if (f[i]>=1) ans++;
    cout<<f[n]<<' '<<ans;//f[n]表示拼成大小n的方案总数；ans表示能拼成的数子总量
    return 0;
} 

---

最优方案总数:以01背包为例

设f[i][j]表示前i件物品容量为j的最大价值，g[i][j]为该f[i][j]状态最优方案的方案总数
根据状态转移方程：

$$f[i][j]=max(f[i-1][j],f[i-1][j-vi]+wi)$$
可以知道，g[i][j]的方案数同样是通过g[i][j]的决策情况来知道的.因此我们可以简单地退出g[i][j]的状态转移方程:
$$g[i][j]+ = \begin{cases} g[i-1][j-vi], & \text{f[i][j]=f[i-1][j-vi]+wi} \\ g[i-1][j], & \text{f[i][j]=f[i-1][j]} \end{cases}$$
如果我们优化成一维，g[i]的原先状态本来就累加在本身，则方程是：
$$g[j]= \begin{cases} g[j], & \text{f[j]>f[j-vi]+wi} \\ g[j-vi]+g[j], & \text{f[j]=f[j-vi]+wi}\\ g[j-vi], & \text{f[j]<f[j-vi]+wi}\\ \end{cases}$$
代码如下(请不要忽略注释的内容)：

#include<bits/stdc++.h>
using namespace std;
int n,V;
int f[100000];
int g[100000];
int v[100000];
int w[100000];
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>V;
    for (int i=1;i<=n;i++)
        cin>>v[i]>>w[i];
    g[0]=1;
    for (int i=1;i<=n;i++)
        for (int j=V;j>=v[i];j--)
        {
            //if (f[j]>f[j-v[i]]+w[i]) g[i]和f[i]的值都不变 
            if (f[j]==f[j-v[i]]+w[i]) g[j]+=g[j-v[i]];//f[j]的值保持不变 
            if (f[j]<f[j-v[i]]+w[i]) g[j]=g[j-v[i]],f[j]=f[j-v[i]]+w[i]; 
        }//以上3个if语句为3种注释的情况
    cout<<g[V];
    return 0;
} 

---

背包的第k优解