动态规划_百炼4120 硬币

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include <stdio.h>
 3 #include <math.h>
 4 #include <algorithm>
 5 #include <stdlib.h>
 6 #include <vector>
 7 #include <map>
 8 #include <queue>
 9 #include <string>
10 #include <iostream>
11 #include <ctype.h>
12 #include <string.h>
13 #include <set>
14 #include <stack>
15 #include<functional>
16 using namespace std;
17 #define size 100001
18 #define maxn  1<<30
19 int dp[size];
20 int dpn[size];
21 int a[205], ans[205];
22 /*
23 dp是一个滚动数组dp[j]表示j块钱可以用钱币组成的数目
24 dpn也是一个滚动数组表示不用第i种钱可以组成j块钱的数目
25 dp[j]=dp[j]+dp[j-a[i]]
26 有两种可能性,一种是不用第i个钱币,那么他的数目就等于dp[i-1][j] 也就是dp[j]
27 意思是使用第i个钱币,那么他的数目就等于dp[j-a[i]];
28 dp[0]=1;  其他初始化为0;
29
30
31 当可以选第i件钱币时
32 dpn[j]=dp[j]-dpn[j-a[i]]
33 当j-a[i]<0
34 那本来就不能选择第i个钱币
35 dpn[j]=dp[j]
36
37 出口dpn[0]=1    当j==a[i]时会出现也就是说,把单独这一个情况排除就好,也就是减去1种只有这一个钱币组成的情况
38
39
40 注意两次更新的内层循环的顺序
41 */
42 int main(){
43
44     int n, x;
45     cin >> n >> x;
46     for (int i = 1; i <= n; i++){
47         scanf("%d", &a[i]);
48     }
49     dp[0] = dpn[0] = 1;
50     for (int i = 1; i <= n; i++)
51         for (int j = x; j >= a[i]; j--){
52             dp[j] = dp[j] + dp[j - a[i]];//因为实际上需要的是dp[i-1][j] 那么内层循环要倒序更新
53         }
54     int pos = 0;
55     for (int i = 1; i <= n; i++)
56     {
57         for (int j = 0; j <=x; j++){
58             if (j - a[i] >= 0)
59                 dpn[j] = dp[j] - dpn[j - a[i]];//因为不是滚动数组没有倒序更新的必要了
60             else
61                 dpn[j] = dp[j];//而且应该是先填充dpn[j]较小的部分,要是倒序更新,第一遍dpn[j-a[i]]等于1,0,0,0 并不是我们所需要的dpn[j]
62         }
63         if (dpn[x] == 0) ans[pos++] = a[i];
64     }
65     cout << pos << endl;
66     if(pos) cout << ans[0];
67     else cout <<endl;
68     for (int i = 1; i < pos; i++)
69         cout << " "<<ans[i];
70     cout << endl;
71     system("pause");
72     return 0;
73 }

原文地址:https://www.cnblogs.com/MapReduce/p/8366246.html

时间: 2024-07-31 05:14:10

动态规划_百炼4120 硬币的相关文章

动态规划_百炼 4121 股票买卖

1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <math.h> 4 #include <algorithm> 5 #include <stdlib.h> 6 #include <vector> 7 #include <map> 8 #include <queue> 9 #include <string> 10 #include

动态规划_百炼4122 切割回文

1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <math.h> 4 #include <algorithm> 5 #include <stdlib.h> 6 #include <vector> 7 #include <map> 8 #include <queue> 9 #include <string> 10 #include

动态规划_百炼 1088 滑雪

1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <math.h> 4 #include <algorithm> 5 #include <stdlib.h> 6 #include <vector> 7 #include <map> 8 #include <queue> 9 #include <string> 10 #include

动态规划_百炼1664 放苹果

1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <math.h> 4 #include <algorithm> 5 #include <stdlib.h> 6 #include <vector> 7 #include <map> 8 #include <queue> 9 #include <string> 10 #include

动态规划_百炼 4117 简单的整数划分问题

1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <math.h> 4 #include <algorithm> 5 #include <stdlib.h> 6 #include <vector> 7 #include <map> 8 #include <queue> 9 #include <string> 10 #include

动态规划_拦截导弹

被拦截的导弹应该依照飞来的高度组成一个非递增序列.求最长非递增序列的长度. #include <iostream> using namespace std; int main() { int h[2000], d[2000], c; //h表示 高度值, d表示最优值, c是能拦截的最多导弹数 int count = 0; //统计飞来的导弹数 while (cin >> h[count++] && h[count-1]); //输入高度 d[count-1] =

算法导论_动态规划_最长公共子序列

一.动态规划的概念 动态规划(Dynamic Programming)是通过组合子问题的解而解决整个问题的.分治是指将问题划分成一些独立的子问题,递归地求解各子问题,然后合并子问题的解而得到原始问题的解,与此不同,动态规划适用于子问题不是独立的情况,也就是各个子问题包含公共的子问题.在这种情况下,采用分治法会做许多不必要的工作,即重复地求解公共地子问题.动态规划算法对每个子问题只求解一次,将其结果保存在一张表中,从而避免每次遇到各个子问题时重新计算答案. 动态规划通常应用于最优化问题.此类问题可

动态规划_二项式系数

动态规划之二项式系数 @(算法学习) (nk)=n!(n?k)!k! 计算二项式系数的问题在于,系数本身在int表示范围内,但是计算用到的分子是阶乘,这个是很大的数,会导致溢出的问题. 所以,比较好的计算方法是运用帕斯卡三角形总结的规律求解. 第一行表达的是:(00)=1 第二行表达的是:(10)=1,(11)=1 第三行表达的是:(20)=1,(21)=2,(22)=1 - 更有趣的是,每一个数是肩头两个数字之和. 运用的规律是:(nk)=(n?1k?1)+(n?1k) ,这个翻译成中文很好理

动态规划_连续子数组的最大和

题目描述 HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学.今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决.但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止).给一个数组,返回它的最大连续子序列的和,你会不会被他忽悠住?(子向量的长度至少是1) 解答 就是在一个一维数组里找出一段,使其和最大.