NOIP1999 拦截导弹

这是一道很经典的动态规划问题，对于我这种还没系统学算法的人，还是需要多加练习，有很多人写过这题的解题报告，我还是决定自己在写一篇，帮助自己加深理解，感觉对DP没有什么感觉，拿到题目思路有点难拓开，怎么找到动态转移方程，这对我来说是个问题。

题目链接:http://www.rqnoj.cn/Problem_217.html

RQNOJ据说是个高中NOIP选手创的OJ,被广大高中NOIP竞赛选手使用,上面试题都是中文,可以按算法分类搜索题目, 提交程序后有分数,并不是单纯WA,或者AC,测试点过了给分,没过,会给测试数据及应该有的正确答案,这点比较好,练算法可以尝试这个OJ.

想了好久,还在别人提示之下才找到了动态转方程:

我们考虑以a[k]为最后一位的最长不增子序列,作为一种状态,那么总共有n个(最后一个为a[n-1]), 对于n+1时,我们找到末尾比a[n]小的,最长的不增子序列即可,计算一次即可得到最长子序列的值,即第一个询问的对象,对于第二的问题,我们需要再考虑一下,我们希望在原来序列上把已经找到的最长子序列去掉,再继续寻找最长的序列,但是有时会遇到一点问题,当最长子序列可以有多种选择,怎么办?例如有如下情况:

8

1 16 3 6 18 9 14 12

第一步找最长子序列:可以是16 14 12, 或者18 14 12

首先这种纠结的问题只会出现在子序列的首位上, (自己考虑为什么),这时候应该去掉这两者中的那个序列呢?

可以知道首数字后面的总比前面的大,(18>16),(例如18改为15)不然我们可以取前面的数做第一位再加上后面的所有子序列,得到一个更长的子序列,(16 15 14 12)

因此我们知道后面的首数字更大,

这时候我们应该取小的那个首数字,16,因为如果取18, 16留下,18后面可能有不能和16组成不增子序列的数字如16,但是如果保留18,而取走16不会有这个问题,18之后的如果能插队到某个子序列中,现在仍然可以,而介于16 18之间的数一定是比18小的(否则不会有以上讨论,后者子序列可以长度加以1变更长了)所以他们本来不能插队到某个18开头的子序列中,现在仍然不能.所以我们得出取前面的能更有利于下一步取最长子序列,所以取最前面的那个;

代码如下:

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
using namespace std;
struct re
{
		int len, ak, res[1000];
};

int count(int *a, re *b, int n, int *m)
{
		int max = 1, maxi = 1, i, j, k;

		b[0].ak = a[0];
		b[0].len = 1;
		b[0].res[0] = a[0];
		for (i = 1; i < n; ++i)
		{
				b[i].ak = a[i];
				b[i].len = 1;
				b[i].res[0] = a[i];
				for (j = 0; j < i; ++j)
				{
						if (b[j].ak >= b[i].ak)
						{
								if (b[i].len < b[j].len + 1)
								{
										b[i].len = b[j].len + 1;		
										for (k = 0; k < b[j].len; ++k)
												b[i].res[k] = b[j].res[k];
										b[i].res[b[j].len] = a[i];
								}
						}
				}
		}
		for (i = 0; i < n; ++i)
		{
				if (b[i].len > max)
				{
						max = b[i].len;
						maxi = i;
				}
		}
		*m = maxi;

		return max;
}

int main()
{
		int i, j, k, n, *a = NULL, *c = NULL, max, maxi, num;		
		re *b = NULL;

		while (cin >> n)
		{
				i = 0;
				max = -1;
				maxi = -1;
				num = 1;
				a = (int *) malloc (n * sizeof(int));
				c = (int *) malloc (n * sizeof(int));
				b = (re *) malloc (n * sizeof(re));
				memset(b, 0, sizeof(b[0]) * n);
				while (i < n)
						cin >> a[i++];		
				max = count(a, b, n, &maxi);					
				cout << max << ' ';
				while (max != n)
				{
						for (i = 0, j = 0, k = 0; i < n; ++i)
						{
								if (a[i] == b[maxi].res[j])
										j++;
								else
										c[k++] = a[i];
						}
						n = n - max;
						for (i = 0; i < n; ++i)
								a[i] = c[i];
						memset(b, 0, sizeof(b[0]) * n);
						max = count(a, b, n, &maxi); 
						num++;
				}
				cout << num << endl;
		}

		return 0;
}

一些说明:

不断去掉最长子序列,继续在剩下的序列中找最长子序列,即可解决第二问,有类似贪心的思想.

结构体b[i]保存了a[0]到a[i]的最长子序列的长度len, 最长子序列最后一个数字ak, 以及这个序列res[1000];