careercup-递归和动态规划 9.8

9.8 给定数量不限的硬币,币值为25分、10分、5分和1分,编写代码就是n分有几种表示法。

解法:

使用回溯法进行解决,实际上就是一个类似枚举的过程,主要是在搜索尝试过程中寻找问题的解,当发现已不满足求解条件时,就“回溯”返回,尝试别的路径。

C++实现代码:

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

void helper(vector<int> &denom,int target,vector<int> &path,vector<vector<int> > &res)
{
    if(target<0)
        return;
    if(target==0)
    {
        res.push_back(path);
        return;
    }
    int i;
    for(i=0;i<(int)denom.size();i++)
    {
        path.push_back(denom[i]);
        helper(denom,target-denom[i],path,res);
        path.pop_back();
    }
}

vector<vector<int> > makeChange(vector<int> &denom,int target)
{
    if(denom.empty())
        return vector<vector<int> >();
    vector<vector<int> > res;
    vector<int> path;
    helper(denom,target,path,res);
    return res;
}

int main()
{
    vector<int> vec={1,2,3};
    vector<vector<int> > res=makeChange(vec,5);
    for(auto a:res)
    {
        for(auto t:a)
            cout<<t<<" ";
        cout<<endl;
    }
}

运行结果:

其中存在重复的,譬如:1 1 2 1 和 2 1 1 1。虽然顺序不一样,但是表示的同样的划分。

需要去重。

#include<iostream>
using namespace std;

int makeChange(int n,int denom)
{
    int next_denom=0;
    switch(denom)
    {
    case 25:
        next_denom=10;
        break;
    case 10:
        next_denom=5;
        break;
    case 5:
        next_denom=1;
        break;
    case 1:
        return 1;
    }
    int i;
    int way=0;
    for(i=0;n-i*denom>=0;i++)
    {
        way+=makeChange(n-i*denom,next_denom);
    }
    return way;
}

int main()
{
    cout<<makeChange(100,25)<<endl;
}
时间: 2024-07-29 00:13:00

careercup-递归和动态规划 9.8的相关文章

70. Climbing Stairs【leetcode】递归,动态规划,java,算法

You are climbing a stair case. It takes n steps to reach to the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top? Note: Given n will be a positive integer. 题目分析:每次只能走1或2步,问n步的话有多少中走法???? 可以用动态规划和递归解

斐波那契数列的实现(简单递归和动态规划)

斐波那契数列的实现(简单递归和动态规划) 一.简单递归的实现 1 #include "stdafx.h" 2 #include <string> 3 using namespace std; 4 int f(int n) 5 { 6 if (n == 0) 7 { 8 return 0; 9 } 10 if (n == 1) 11 { 12 return 1; 13 } 14 return f(n - 1) + f(n - 2); 15 } 16 int _tmain(in

利用递归和动态规划来求解组合数

组合数定义:从m个不同元素中,任取n(n≤m)个元素并成一组,叫做从m个不同元素中取出n个元素的一个组合:从m个不同元素中取出n(n≤m)个元素的所有组合的个数,叫做从m个不同元素中取出n个元素的组合数. 下面是一种比较通俗的计算公式: 其递归公式为: c(n,m)=c(n-1,m-1)+c(n-1,m) 下面是c++实现该递归算法: #include <iostream> #include <stdlib.h> #define EXIT -1 using namespace st

算法初级面试题08——递归和动态规划的精髓、阶乘、汉诺塔、子序列和全排列、母牛问题、逆序栈、最小的路径和、数组累加成指定整数、背包问题

第八课主要介绍递归和动态规划 介绍递归和动态规划 暴力递归: 1,把问题转化为规模缩小了的同类问题的子问题 2,有明确的不需要继续进行递归的条件(base case) 3,有当得到了子问题的结果之后的决策过程 4,不记录每一个子问题的解 动态规划 1,从暴力递归中来 2,将每一个子问题的解记录下来,避免重复计算 3,把暴力递归的过程,抽象成了状态表达 4,并且存在化简状态表达,使其更加简洁的可能 图灵引入的是:我不知道怎么算,但是我知道怎么试.知道怎么暴力破解出来. 要学会,练习懂得怎么尝试.

左神算法第八节课:介绍递归和动态规划(汉诺塔问题;打印字符串的全部子序列含空;打印字符串的全排列,无重复排列;母牛数量;递归栈;数组的最小路径和;数组累加和问题,一定条件下最大值问题(01背包))

暴力递归: 1,把问题转化为规模缩小了的同类问题的子问题 2,有明确的不需要继续进行递归的条件(base case) 3,有当得到了子问题的结果之后的决策过程 4,不记录每一个子问题的解 动态规划 1,从暴力递归中来 2,将每一个子问题的解记录下来,避免重复计算 3,把暴力递归的过程,抽象成了状态表达 4,并且存在化简状态表达,使其更加简洁的可能 一:递归 1. 汉诺塔问题 汉诺塔问题(不能大压小,只能小压大),打印n层汉诺塔从最左边移动到最右边的全部过程. 左中右另称为 from.to.hel

【动态规划专题】1:斐波拉契数列问题的递归和动态规划

<程序员代码面试指南--IT名企算法与数据结构题目最优解> 左程云 著 斐波拉契数列问题的递归和动态规划 [题目]:给定整数N,返回斐波拉契数列的第N项.补充问题1:给定整数N,代表台阶数,一次可以跨2个或者1个台阶,返回有多少种走法.补充问题2:假设农场中成熟的母牛每年只会生产1头小母牛,并且永远不会死.第一年农场只有1只成熟的母牛,从第2年开始,母牛开始生产小母牛.每只小母牛3年后成熟又可以生产小母牛.给定整数N,求出N年后牛的数量. [举例]斐波拉契数列f(0)=0, f(1)=1,f(

背包问题---递归及动态规划

一.原题 如果有一组物品,各个物品的质量已知,现有一个背包,背包可以容纳的质量总和S已知,问是否能从这N个物品中取出若干个恰好装入这个背包中. 二.递归算法 本质思想:设法尝试全部组合,当部分组合已经无法满足条件时,马上停止当前组合的尝试:若出现第一个满足条件的组合,马上停止尝试.使用递归回溯法实现.(感觉这东西不是我这样的菜鸟可以说明确的,还得自己慢慢体会,最好的方法就是耐住性子跟踪调试). 上"酸菜" #include <stdio.h> #include <st

java——递归(动态规划,回溯)

最近刷面试题经常刷到递归方面的算法,一直以为都是递归,后来发现竟然都有具体的叫法,所以写了这篇博客来牢记以下 1. 五大常用算法 (1) 分治算法 把一个复杂的问题分成两个或多个相同或者相似的子问题,然后不断地细分,直到最后的子问题可以很简单地求解出来,原问题的解就是自问题的合并.比如常见的快速排序算法和归并算法 分治法的核心思想就是把大的难解的问题不断分割,分而治之. (2) 动态规划 类似于分治法,将带求解的问题分化成几个小问题,每个小问题的解会影响原问题的解. 先求每个子问题的局部解,然后

9.9递归和动态规划(一)——小孩上楼梯的方式的种类

/** * 功能:有个小孩正在上楼梯,楼梯有n阶台阶,小孩一次可以上1阶.2阶或3阶.计算小孩上楼梯的方式有多少种. */ 两种方法: 方法一: //递归法 /** * 思路:自上而下的方式. * 最后一步可能是从第n-1阶往上走1阶.从第n-2阶往上走2阶或从第n-3阶往上走3阶. * 因此,抵达最后一阶的走法,抵达这最后三阶的方式的综合. * @param n * @return */ public static int countWays(int n){ if(n<0) return 0;

爬楼问题—递归、动态规划

问题:假设你正在爬楼梯,需要n步你才能到达顶部.但每次你只能爬一步或者两步,你能有多少种不同的方法爬到楼顶部? code: 1 //动态规划解决爬楼问题 2 int dp_climbStairs(int n) { 3 if (n == 1) { 4 return 1; 5 } else if (n == 2) { 6 return 2; 7 } else { 8 int * M = new int[n]; 9 for (int i = 0; i < n; i++) { 10 M[i] = 0;