蓝桥杯-贪吃的大嘴-动态规划-java

问题描述

　　有一只特别贪吃的大嘴,她很喜欢吃一种小蛋糕,而每一个小蛋糕有一个美味度,而大嘴是很傲娇的,一定要吃美味度和刚好为m的小蛋糕,而且大嘴还特别懒,她希望通过吃数量最少的小蛋糕达到这个目的.所以她希望你能设计一个程序帮她决定要吃哪些小蛋糕.

输入格式

　　先输入一行包含2个整数m、n,表示大嘴需要吃美味度和为m的小蛋糕,而小蛋糕一共有n种,下面输入n行,每行2个整数,第一个表示该种小蛋糕的美味度,第二个表示蛋糕店中该种小蛋糕的总数

输出格式

　　输出一行包含一个整数表示大嘴最少需要吃的小蛋糕数量,若大嘴无法通过吃小蛋糕达到m的美味度和,则输出"><“.

样例输入

10 2
4 1
2 10

样例输出

4

样例输入

10 2
4 1
7 3

样例输出

><

数据规模和约定

　　m ≤ 20000,小蛋糕总数量≤50.

  

      解题思路：

            这种问题是01背包变种问题让咱们来一步一步的分析

            根据题意我先把所有的蛋糕列出来

            4 2 2 2 2 2 2 2 2 2 2

            动态规划嘛先要简化状态

            每个蛋糕对于我们就两种状态

             1.吃了

             2.没吃

            既然是动态规划就要找到每步的最优值

            那么每步的最优值是由什么决定的呢？

            刚开始我是这么做的：

             竖行代表美味度横行代表吃几个

             最后搜索一下最后一行只要美味度符合题中要求就输出横坐标

             然而这么做是错的！为什么呢？

             因为这种建立的状态有后效性

             什么是后效性呢？仔细想想

             因为他的前一个状态让后面产生了不确定因素

            所以我们要想一个无后效性能够准确表达每一步最优值的框架

            很庆幸我想到了一个：

               建立一个三维数组ijz

               i表示这一行蛋糕前i个

               j表示前i个蛋糕吃了j个

               z表示这j个蛋糕的美味度不超过z的最大美味度

               咱们来看看为什么这种想法没有后效性呢!

                 前1个..

                 前2个..

                 前3个..

                 前3个..

                 前4个..

             比如说我数到前4个我不管前3个怎么吃的我只关心第四个蛋糕我吃不吃

             如果我吃了能不能在z的限制下达到最大美味度

                所以状态就可以这么表示为：

                  前四个我要吃3个i=4j=3

                  1.我不吃第四个蛋糕 本轮状态=前三个吃三个的最优值

                  2.我吃第四个蛋糕 本轮状态 = 前三个吃两个的最优值+第四个蛋糕的美味度

             还要考虑z我就不细说了在代码里看吧！

package 刷题;


import java.util.Scanner;


public class Main {


public static void main(String[] args) {
// TODO 自动生成的方法存根
         Scanner scanner = new Scanner(System.in);
         while (scanner.hasNext()) {
int m = scanner.nextInt();
int n = scanner.nextInt();
int [] arr = new int [60];int v = 1;
for (int i = 0; i < n; i++) {
int a = scanner.nextInt();
int b = scanner.nextInt();
for (int j = 0; j < b; j++) {arr[v] = a;v++;}
}
   int [] [] [] shuzu = new int [v][v][m+1];
   for (int i = 0; i < v; i++) {
for (int j = 0; j < v; j++) {
for (int j2 = 0; j2 <= m; j2++) {
shuzu[i][j][j2] = 0;}}}
// 初始化
for (int i = 1; i < v; i++) {
for (int j = 1; j <=m; j++) {
if (arr[i]<=j&&arr[i]>shuzu[i][1][j]) {
shuzu[i][1][j] = arr[i];
}else {
shuzu[i][1][j] = shuzu[i-1][1][j];
}
}
}
for (int i = 2; i < v; i++) {
for (int j = 2; j <=i ; j++) {
for (int j2 =1 ; j2 <=m; j2++) {
int a = 0;int b = shuzu[i-1][j][j2];
if (j2-arr[i]>=0) {
a= shuzu[i-1][j-1][j2-arr[i]]+arr[i];
}
if (a>b) {
shuzu[i][j][j2] = a;
}else {
shuzu[i][j][j2] = b;
}
}

}
}
int o = 0;
h:for (int i = 1; i < v; i++) {
for (int j = 1; j < v; j++) {
if (shuzu[j][i][m]==m) {
System.out.println(i);
o= 1;
break h;
}

}

}
if (o==0) {
System.out.println("><");
}



}
}


}