硬币问题——记忆化搜索与递推的转换

一、问题描述

有n种硬币，面值分别为V1,V2,V3,...,Vn,每种都有无限多。给定非负整数S,可以选用多少硬币，使得面值之和恰好为S?输出硬币数目的最小值和最大值。1≤n≤100,0≤S≤10000,1≤Vi≤S.

二、解题思路

将每种面值看作一个点，表示“还需凑足的面值”，则初始状态为S，目标状态为0。对于状态i,如果存在硬币j,i ≥ Vj,则说可从状态 i 转到

i - Vj，即存在 i--> i-Vj 的有向边。之前矩形嵌套没有固定起点、终点，直接求图上的最长路。这题由于硬币数量无限，图是无限大的，所以必须固定起点和终点（其实就是将图的大小固定）。然后求起点S到终点0的最长路和最短路。

三、代码实现

代码一：对最长路、最短路分别使用dp

#include<stdio.h>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 100 + 10;
const int maxs = 10000 + 10;
int n,V[maxn];
int dmin[maxs],dmax[maxs];    //d[i]表示从节点i出发到节点0的最长路径的长度
int S;

int dp(int s)
{
    int& ans = dmax[s];
    if (ans != -1)  return ans;
    ans = -INF;
    for (int i = 0; i < n; i++)
    {
        if(s >= V[i])
            ans = max(ans, dp(s - V[i]) + 1);
    }
    return ans;
}

int dp2(int s)
{
    int& ans = dmin[s];
    if (ans != -1)  return ans;
    ans = INF;
    for (int i = 0; i < n; i++)
    {
        if (s >= V[i])
            ans = min(ans, dp2(s - V[i]) + 1);
    }
    return ans;
}

void slove()
{
    memset(dmin, -1, sizeof(dmin));
    memset(dmax, -1, sizeof(dmax));        //注意初始化，-1表示未访问
    dmin[0] = dmax[0] = 0;

    int res1 = 0,res2 = 0;
    res1 = dp(S);
    res2 = dp2(S);
    if (res1 < 0)  printf("impossible
");        //此时res1是一个略大于 -INF 的数
    else printf("%d
", res1);
    if (res2 == INF)  printf("impossible
");
    else  printf("%d
", res2);
}

int main()
{
    while (scanf("%d",&n) == 1 && n)
    {
        scanf("%d", &S);
        for (int i = 0; i < n; i++)
            scanf("%d", &V[i]);
        slove();
    }
    return 0;
}

代码二：使用两次dp有点繁琐，使用递推式，就能够合二为一了。

//dmin[i]表示从节点i出发到节点0的最短路径的长度
//dmax[i]表示从节点i出发到节点0的最长路径的长度
int dmin[maxs], dmax[maxs];    
void slove()
{
    for (int i = 1; i <= S; i++)
    {
        dmin[i] = INF;
        dmax[i] = -INF;
    }
    dmin[0] = dmax[0] = 0;

    for(int i = 0;i <= S;i++)        //注意循环的顺序，由小到大
        for (int j = 0; j < n; j++)
        {
            if (i >= V[j])
            {
                dmin[i] = min(dmin[i], dmin[i - V[j]] + 1);
                dmax[i] = max(dmax[i], dmax[i- V[j]] + 1);
            }
        }

    int res1 = dmax[S], res2 = dmin[S];
    if (res1 < 0)  printf("impossible
");        //此时res1是一个略大于 -INF 的数
    else printf("%d
", res1);
    if (res2 == INF)  printf("impossible
");
    else  printf("%d
", res2);
}

这也再一次告诉我们，递归和循环，记忆化搜索和递推可以转化。

记忆化搜索和递推对每个状态值都只计算一次，前者需要递归实现，后者当前状态只与之前状态有关，由于是从最初始的出发，计算当前状态时，保证了之前的状态值已经被求出。