动态规划

最新推荐文章于 2022-10-18 14:05:46 发布

qfht

最新推荐文章于 2022-10-18 14:05:46 发布

阅读量752

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/u010211389/article/details/9945587

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一节动态规划基本概念

一、三要素：阶段、状态、决策。

二、适用范围

一般在题目中出现求最优解的问题就要考虑动态规划了，但是否可以用还要满足两个条件：最优子结构（最优化原理）、无后效性。

三、解决问题的思路

（1）模型匹配法：

最先考虑的就是这个方法了。挖掘问题的本质，如果发现问题是自己熟悉的某个基本的模型，就直接套用，但要小心其中的一些小的变动，现在考题办都是基本模型的变形套用时要小心条件，三思而后行。

（2）三要素法

仔细分析问题尝试着确定动态规划的三要素，不同问题的却定方向不同：

先确定阶段的问题：数塔问题，和走路问题。

先确定状态的问题：大多数都是先确定状态的。

先确定决策的问题：背包问题。

（3）寻找规律法：

耐心推几组数据后，看他们的规律，总结规律间的共性，有点贪心的意思。

（4）边界条件法

找到问题的边界条件，然后考虑边界条件与它的领接状态之间的关系。

（5）放宽约束和增加约束

具体内容就是给问题增加一些条件或删除一些条件使问题变的清晰。

第二节动态规划分类讨论

用状态维数对动态规划进行了分类：

1.状态是一维的

1．1下降/非降子序列问题：

例题1 拦截导弹 （nyoj--79）

描述

某国为了防御敌国的导弹袭击，发展中一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于等于前一发的高度。某天，雷达捕捉到敌国导弹来袭。由于该系统还在试用阶段，所以只用一套系统，因此有可能不能拦截所有的导弹。

输入

第一行输入测试数据组数N（1<=N<=10）
接下来一行输入这组测试数据共有多少个导弹m（1<=m<=20）
接下来行输入导弹依次飞来的高度，所有高度值均是大于0的正整数。

输出

输出最多能拦截的导弹数目

样例输入

2
8
389 207 155 300 299 170 158 65
3
88 34 65

样例输出

6
2

【问题分析】

不难看出这是一个求最长非升子序列问题，显然标准算法是动态规划。

以导弹依次飞来的顺序为阶段，设计状态opt[i]表示前i个导弹中拦截了导弹i可以拦截最多能拦截到的导弹的个数。

状态转移方程：

opt[i]=max(opt[j])+1 (h[i]>=h[j],0=<j<i) {h[i]存，第i个导弹的高度}

最大的opt[i]就是最终的解。

【源代码】

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input=new Scanner(System.in);
		int N=input.nextInt();
		while(N-->0){
			int m=input.nextInt();
			int[] a=new int[m+1];
			for(int i=1;i<=m;i++)
				a[i]=input.nextInt();
			int temp=F(a,m);
			System.out.println(temp);
		}
	}

	private static int F(int[] a, int m) {
		// TODO Auto-generated method stub
		int[] b=new int[m+1];
		Arrays.fill(b, 1);
		int max=1;
		for(int i=1;i<=m;i++){
			for(int j=1;j<i;j++){
				if(a[j]>a[i])
					b[i]=Math.max(b[i], b[j]+1);//中心，找到所在位置之前最长的子序列
			}
			//无后效性
			if(b[i]>max)
				max=b[i];
		}
		return max;
	}
}

例题二合唱队形来源：点吧

题目1131：合唱队形

题目描述：

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学不交换位置就能排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1, 2, …, K，他们的身高分别为T1, T2, …, TK，
则他们的身高满足T1 < T2 < … < Ti , Ti > Ti+1 > … > TK (1 <= i <= K)。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

输入：

输入的第一行是一个整数N（2 <= N <= 100），表示同学的总数。
第一行有n个整数，用空格分隔，第i个整数Ti（130 <= Ti <= 230）是第i位同学的身高（厘米）。

输出：

可能包括多组测试数据，对于每组数据，
输出包括一行，这一行只包含一个整数，就是最少需要几位同学出列。

样例输入：

8
186 186 150 200 160 130 197 220

样例输出：

来源：

2008年北京大学方正实验室计算机研究生机试真题

【问题分析】

出列人数最少，也就是说留的人最多，也就是序列最长。

这样分析就是典型的最长下降子序列问题。只要枚举每一个人站中间时可以的到的最优解。显然它就等于，包括他在内向左求最长上升子序列，向右求最长下降子序列。

我们看一下复杂度：

计算最长下降子序列的复杂度是O（N2），一共求N次，总复杂度是O（N3）。这样的复杂度对于这个题的数据范围来说是可以AC的。但有没有更好的方法呢？

其实最长子序列只要一次就可以了。因为最长下降（上升）子序列不受中间人的影响。

只要用OPT1求一次最长上升子序列，OPT2求一次最长下降子序列。这样答案就是N-max(opt1[i]+opt2[i]-1).

复杂度由O（N3）降到了O（N2）。

【源代码】

import java.util.Arrays;
import java.util.Scanner;

public class MM {

	/**
	 * @param args
	 */
	static int m;
	static int[] a;
	static int[] b;
	static int[] c;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input=new Scanner(System.in);

                  while(true){
			m=input.nextInt();
			a=new int[m+1];
			b=new int[m+1];
			Arrays.fill(b, 1);
			c=new int[m+1];
			Arrays.fill(c, 1);
			for(int i=1;i<=m;i++)
				a[i]=input.nextInt();
			F1();//int[] b,记录从i=1时求最长的上升子序列
			F2();//int[] c,记录从i=m时最长的下降子序列
			int max=1;
			for(int i=1;i<=m;i++){
				int temp=b[i]+c[i]-1;
				if(temp>max)
					max=temp;
			}
			System.out.println(m-max);

                 }
	}
	private static void F2() {
		// TODO Auto-generated method stub
		for(int i=m-1;i>=1;i--)
			for(int j=m;j>i;j--){
				if(a[j]<a[i])
					c[i]=Math.max(c[i], c[j]+1);
			}
	}
	private static void F1() {
		// TODO Auto-generated method stub
		for(int i=2;i<=m;i++)
			for(int j=1;j<i;j++){
				if(a[j]<a[i])
					b[i]=Math.max(b[i], b[j]+1);
			}
	}

	
}

例题3 Buy Low Buy Lower 来源: poj-1952

Description

The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also

follow this problems' advice:

                    "Buy low; buy lower"
Each time you buy a stock, you must purchase it at a lower price than the previous time you bought it. The more times you buy at a

lower price than before, the better! Your goal is to see how many times you can continue purchasing at ever lower prices.

You will be given the daily selling prices of a stock (positive 16-bit integers) over a period of time. You can choose to buy stock on any of the days. Each time you choose to buy, the price must be strictly lower than the previous time you bought stock. Write a program which identifies which days you should buy stock in order to maximize the number of times you buy.

Here is a list of stock prices:

 Day   1  2  3  4  5  6  7  8  9 10 11 12

Price 68 69 54 64 68 64 70 67 78 62 98 87

The best investor (by this problem, anyway) can buy at most four times if each purchase is lower then the previous purchase. One four day sequence (there might be others) of acceptable buys is:

Day    2  5  6 10

Price 69 68 64 62

Input

* Line 1: N (1 <= N <= 5000), the number of days for which stock prices are given

* Lines 2..etc: A series of N space-separated integers, ten per line except the final line which might have fewer integers.

Output

Two integers on a single line:
* The length of the longest sequence of decreasing prices
* The number of sequences that have this length (guaranteed to fit in 31 bits)

In counting the number of solutions, two potential solutions are considered the same (and would only count as one solution) if they repeat the same string of decreasing prices, that is, if they "look the same" when the successive prices are compared. Thus, two different sequence of "buy" days could produce the same string of decreasing prices and be counted as only a single solution.

Sample Input

12
68 69 54 64 68 64 70 67 78 62
98 87

Sample Output

4 2

Source

USACO 2002 February

【问题分析】

从题目描述就可以看出这是最长下降子序列问题，于是求解第一问不是难事，以天数为阶段，设计状态opt[i] 表示前i天中要买第i天的股票所能得到的最大购买次数。

状态转移方程：

opt[i]=max(opt[j])+1 (a[i]>=a[j],0=<j<i) {a[i]存第i天股价}

最大的opt[i]就是最终的解。

第二问呢，稍麻烦一点。

从问题的边界出发考虑问题，当第一问求得一个最优解opt[i]=X时，

在1到N中如果还有另外一个opt[j]=x那么选取J的这个方案肯定是成立的。

是不是统计所有的opt[j]=x 的个数就是解了呢？

显然没那么简单，因为选取Ｊ这天的股票构成的方案不见得＝１，看下面一个例子：

５　6 4　3　１ 2

方案一：５４３１

方案二：５４３２

方案三：６４３１

方案四：６４３２

x=4

也就是所虽然opt[5]=X 和opt[6]=X但个数只有两个，而实际上应该有四个方案，但在仔细观察发现，构成opt[5]=x 的这个方案中 opt[j]=x-1的方案数有两个,opt[j]=x-2的有一个，opt[j]=x-3 的有一个……

显然这是满足低归定义的设计函数F（i）表示前I张中用到第i张股票的方案数。

递推式：

1 (i=0)

F(i)=

Sum(F(j)) (0<=j<=n,a[j]>a[i],opt[j]=opt[i]-1) {sum 代表求和}

答案=sum(F(j)) {0<j<=n,opt[j]=x}

复杂度：

求解第一问时间复杂度是O(N2),求解第二问如果用递推或递归+记忆化时间复杂度仍为O（N2）但要是用赤裸裸的递归那就复杂多了……，因为那样造成了好多不必要的计算。

你认为这样做就解决了这道题目了么？还没有，还要注意一些东西：

（1）如果有两个方案中出现序列一样，视为一个方案，要需要加一个数组next用next[i] 记录和第i个数情况一样（即：opt[i]=opt[j] 且 a[i]=a[j]）可看做一个方案的最近的位置。

递推时j只要走到next[i]即可。

（2）为了方便操作可以将a[n+1]赋值为-maxlongint这样可以认为第n+1个一定可以买，答案就是sum(F(n+1))。

（3）看数据规模显然要用高精度。

例题4 船 (ships.pas/c/cpp) 来源：《奥赛经典》（提高篇）

【问题描述】

PALMIA国家被一条河流分成南北两岸，南北两岸上各有N个村庄。北岸的每一个村庄有一个唯一的朋友在南岸，且他们的朋友村庄彼此不同。

每一对朋友村庄想要一条船来连接他们，他们向政府提出申请以获得批准。由于河面上常常有雾，政府决定禁止船只航线相交（如果相交，则很可能导致碰船）。

你的任务是编写一个程序，帮助政府官员决定批准哪些船只航线，使得不相交的航线数目最大。

【输入文件】ships.in

输入文件由几组数据组成。每组数据的第一行有2个整数X，Y，中间有一个空格隔开，X代表PALMIA河的长度（10<=X<=6000），Y代表河的宽度（10<=Y<=100）。第二行包含整数N，表示分别坐落在南北两岸上的村庄的数目（1<=N<=5000）。在接下来的N行中，每一行有两个非负整数C，D，由一个空格隔开，分别表示这一对朋友村庄沿河岸与PALMIA河最西边界的距离（C代表北岸的村庄，D代表南岸的村庄），不存在同岸又同位置的村庄。最后一组数据的下面仅有一行，是两个0，也被一空格隔开。