动态规划（一）----找零问题

 

有数组penny，penny中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim(小于等于1000)代表要找的钱数，求换钱有多少种方法。

给定数组penny及它的大小(小于等于50)，同时给定一个整数aim，请返回有多少种方法可以凑成aim。

测试样例：

[1,2,4],3,3

返回：2

方法一（暴力搜索法）

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        if (penny.empty() || aim == 0)  return 0;
        return foo(penny, 0, aim);
    }
    int foo(const vector<int>& arr, int index, int aim)
    {
        if (aim == 0)   return 1;
        if (index == arr.size())    return 0;
        int ret = 0;
        for (int i = 0; arr[index] * i <= aim; i++)
        {
            ret += foo(arr, index + 1, aim - arr[index] * i);
        }
        return ret;
    }
};

方法二（记忆化搜索方法）

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        int dp[50][1000];
        for(int i=0;i<50;i++)
            for(int j=0;j<1000;j++)
            {
                dp[i][j]=0;
            }
        if (penny.empty() || aim == 0)  return 0;
        return foo(penny, 0, n,aim,dp);
    }
    int foo(const vector<int>& arr, int index, int n,int aim,int (*dp)[1000])
    {
        int res=0;
        if(index==n)
        {
            res=(aim==0)?1:0;
        }
        else
        {
            for(int i=0;arr[index]*i<=aim;i++)
            {
                int value=dp[index+1][aim-arr[index]*i];
                if(value!=0)
                {
                    res+=(value==-1)?0:value;
                }
                else
                {
                    res+=foo(arr,index+1,n,aim-arr[index]*i,dp);
                }
            }
        }
        dp[index][aim]=(res==0)?-1:res;
        return res;
   }
};

方法三（动态规划方法）

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        // write code here
        if(n==0&&aim==0) return 0;
        int dp[n][aim+1];
        for(int i=0;i<n;i++) dp[i][0]=1;
        for(int j=1;j<=aim;j++) 
        {
            if(j%penny[0]==0)
            {
                dp[0][j]=1;
            }
            else
            {
                dp[0][j]=0;
            }
        }
        for(int i=1;i<n;i++)
        {
            for(int j=1;j<=aim;j++)
            {
                int count=0;
                for(int k=0;penny[i]*k<=j;k++)
                {
                    count+=dp[i-1][j-penny[i]*k];
                }
                dp[i][j]=count;
            }
        }
        return dp[n-1][aim];
    }
};

方法四（经优化之后的动态规划算法）

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        // write code here
        if(n==0&&aim==0) return 0;
        int dp[n][aim+1];
        for(int i=0;i<n;i++) dp[i][0]=1;
        for(int j=1;j<=aim;j++) 
        {
            if(j%penny[0]==0)
            {
                dp[0][j]=1;
            }
            else
            {
                dp[0][j]=0;
            }
        }
        for(int i=1;i<n;i++)
        {
            for(int j=1;j<=aim;j++)
            {
                if(j<penny[i]) dp[i][j]=dp[i-1][j];
                else dp[i][j]=dp[i-1][j]+dp[i][j-penny[i]];
            }
        }
        return dp[n-1][aim];
    }
};