commit

Author: 1367356

.metadata/.plugins/org.eclipse.core.resources/.history/43/30ff69ca2ca40017131c82ab4c885138

@@ -0,0 +1,123 @@
+package dynamicProgramming;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DynamicProgramming {
+	
+	
+	
+	/**
+	 * 打印输出最优解路径
+	 * @param p  长度对应的价格
+	 * @param n  长度
+	 */
+	public void printCutRodSolution(int[] p,int n){
+		List list=extendedBottomUpCutRod(p, n);
+		int[] s=(int[]) list.get(1);
+/*		for (int i = 0; i < s.length; i++) {
+			System.out.println(s[i]);
+		}*/
+
+		while(n>0){
+		if(s[n-1]==0)
+			break;
+		System.out.println(s[n-1]);
+		n=n-s[n-1];
+		}
+	}
+	/**
+	 * 重构解，保存最优解路径，而不只是打印最优解值
+	 * @param p 长度对应的价格数组
+	 * @param n 长度
+	 * @return	一个数组列表，里面存放的是两个数组，数组1为一个最优值，数组2为最有路径。
+	 */
+	public List extendedBottomUpCutRod(int[] p,int n){
+		List list=new ArrayList<int[]>();
+		int[] r=new int[n];
+		int[] s=new int[n];
+		r[0]=0;
+		
+		for (int j = 0; j < r.length; j++) {
+			int q=Integer.MIN_VALUE;
+			for (int i = 0; i < j; i++) {
+				if(q>p[i]+r[j-i]){
+					q=q;
+				}else{
+					q=p[i]+r[j-i];
+					s[j]=i;
+				}
+			}
+			r[j]=q;
+		}		
+		list.add(r[n-1]);
+		list.add(s);
+		return list;
+	}
+	
+	
+         /**
+          * 自底向上使用动态规划求解最优值
+          * @param p 输入的长度对应的价格数组
+          * @param n 长度
+          * @return 最高价格
+          */
+	      public int bottomUpCutRod(int[] p,int n){
+				int[] r=new int[n];
+				r[0]=0;
+				for (int j = 0; j < r.length; j++) {
+					int q=Integer.MIN_VALUE;
+					for (int i = 0; i < j; i++) {
+						if(q>p[i]+r[j-i]){
+							q=q;
+						}else{
+							q=p[i]+r[j-i];
+						}
+					}
+					r[j]=q;
+				}
+				return r[n-1];
+	      }
+	
+			/**
+			 * 使用带备忘录的动态规划求解最优值
+			 * @param p长度对应的价格的数组
+			 * @param n 长度
+			 * @return	最优值
+			 */
+			public int memoizedCutRod(int[] p,int n){
+				int[] r=new int[n];
+				for (int i = 0; i < r.length; i++) {
+					r[i]=Integer.MIN_VALUE;
+				}
+				return memoizedCutRodAux(p,n,r);
+			}
+			/**
+			 * 带备忘录的动态规划算法的辅助函数
+			 * @param p 长度对应的价格的数组
+			 * @param n 长度
+			 * @param r  新数组，作为备忘录，存放以前阶段的最优值
+			 * @return
+			 */
+			private int memoizedCutRodAux(int[] p, int n, int[] r) {
+				// TODO Auto-generated method stub
+				int q;
+				if(r[n-1]>=0){
+					return r[n-1];
+				}
+				if(n-1==0){
+					q=0;
+				}else{
+					q=Integer.MIN_VALUE;
+					for (int i = 1; i <n; i++) {
+						if(p[i]+memoizedCutRodAux(p, n-i, r)>q){
+							q=p[i]+memoizedCutRodAux(p, n-i, r);
+						}else{
+							q=q;
+						}
+					}
+				}
+				r[n-1]=q;
+				return q;
+			}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/c/e082d1cf2ca40017131c82ab4c885138

@@ -0,0 +1,123 @@
+package dynamicProgramming;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DynamicProgramming {
+	
+	
+	
+	/**
+	 * 打印输出最优解路径
+	 * @param p  长度对应的价格
+	 * @param n  长度
+	 */
+	public void printCutRodSolution(int[] p,int n){
+		List list=extendedBottomUpCutRod(p, n);
+		int[] s=(int[]) list.get(1);
+/*		for (int i = 0; i < s.length; i++) {
+			System.out.println(s[i]);
+		}*/
+
+		while(n>0){
+		if(s[n-1]==0)
+			break;
+		System.out.println(s[n-1]);
+		n=n-s[n-1];
+		}
+	}
+	/**
+	 * 重构解，保存最优解路径，而不只是打印最优解值
+	 * @param p 长度对应的价格数组
+	 * @param n 长度
+	 * @return	一个数组列表，里面存放的是两个数组，数组1为一个最优值，数组2为最有路径。
+	 */
+	public List extendedBottomUpCutRod(int[] p,int n){
+		List list=new ArrayList<int[]>();
+		int[] r=new int[n];
+		int[] s=new int[n];
+		r[0]=0;
+		
+		for (int j = 0; j < r.length; j++) {
+			int q=Integer.MIN_VALUE;
+			for (int i = 0; i < j; i++) {
+				if(q>p[i]+r[j-i]){
+					q=q;
+				}else{
+					q=p[i]+r[j-i];
+					s[j]=i;
+				}
+			}
+			r[j]=q;
+		}		
+		list.add(r[n-1]);
+		list.add(s);
+		return list;
+	}
+	
+	
+         /**
+          * 自底向上使用动态规划求解最优值,自底向上主要用一个数组标记着较小问题的解，从小到大依次求解
+          * @param p 输入的长度对应的价格数组
+          * @param n 长度
+          * @return 最高价格
+          */
+	      public int bottomUpCutRod(int[] p,int n){
+				int[] r=new int[n];
+				r[0]=0;
+				for (int j = 0; j < r.length; j++) {
+					int q=Integer.MIN_VALUE;
+					for (int i = 0; i < j; i++) {
+						if(q>p[i]+r[j-i]){
+							q=q;
+						}else{
+							q=p[i]+r[j-i];
+						}
+					}
+					r[j]=q;
+				}
+				return r[n-1];
+	      }
+	
+			/**
+			 * 使用带备忘录的动态规划求解最优值，带有备忘录的算法使用递归算法，但是较小问题的解用备忘录记录下来了
+			 * @param p长度对应的价格的数组
+			 * @param n 长度
+			 * @return	最优值
+			 */
+			public int memoizedCutRod(int[] p,int n){
+				int[] r=new int[n];
+				for (int i = 0; i < r.length; i++) {
+					r[i]=Integer.MIN_VALUE;
+				}
+				return memoizedCutRodAux(p,n,r);
+			}
+			/**
+			 * 带备忘录的动态规划算法的辅助函数
+			 * @param p 长度对应的价格的数组
+			 * @param n 长度
+			 * @param r  新数组，作为备忘录，存放以前阶段的最优值
+			 * @return
+			 */
+			private int memoizedCutRodAux(int[] p, int n, int[] r) {
+				// TODO Auto-generated method stub
+				int q;
+				if(r[n-1]>=0){
+					return r[n-1];
+				}
+				if(n-1==0){
+					q=0;
+				}else{
+					q=Integer.MIN_VALUE;
+					for (int i = 1; i <n; i++) {
+						if(p[i]+memoizedCutRodAux(p, n-i, r)>q){
+							q=p[i]+memoizedCutRodAux(p, n-i, r);
+						}else{
+							q=q;
+						}
+					}
+				}
+				r[n-1]=q;
+				return q;
+			}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/c1/1003aeed2ca40017131c82ab4c885138

@@ -0,0 +1,20 @@
+package dynamicProgramming;
+
+public class TestDynamicProgramming {
+	/**
+	 * 动态规划可以用来求带有重复子问题的最优解等问题。
+	 * 测试动态规划的java类
+	 * int[] p  长度对应的价格数组
+	 * n   钢条长度，这个长度和真正的类中的长度不相同，因为java数组的角标从0开始等。
+	 * @param args
+	 */
+			public static void main(String[] args) {
+				int[] p={0,1,5,8,9,10,17,17,20,24,30};
+				int n=9;  //输入的n，实际为n-1 ;  因为java角标是从0开始的
+				DynamicProgramming dp=new DynamicProgramming();
+//				int maxProce=dp.memoizedCutRod(p, n+1);
+//				int maxPrice=dp.bottomUpCutRod(p, n+2);   //两个for循环嵌套
+//				System.out.println(maxPrice);
+				dp.printCutRodSolution(p, n+2);
+			}
+}