算法效率的时间空间效率完全没有考虑(大鸟无喷)，但是可能是最直观的，最白痴的思路。没有运用网上大部分的贪心法算法思想，就是保证没读过算法相关书籍的任何人都能读懂。

题目出处：

http://www.programfan.com/acm/show.asp?qid=5

题目如下：

防御导弹

Problem

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。

但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够达到任意的高度，但是以后每一发炮弹都不能高于前一发的高度。

某天，雷达捕捉到敌国的导弹来袭。由于该系统还在使用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

Input

最多20个整数，分别表示导弹依次飞来的高度（雷达给出高度数据是不大于30000的正整数）

Output

两个整数M和N。表示：这套系统最多能拦截 M 枚导弹，如果要拦截所有导弹最少要配备 N 套这种导弹系统。

Sample Input

300 250 275 252 200 138 245

Sample Output

5 2

看到问题，首先要从实际问题抽相出数学模型——

问题翻译：

1.求M本问题就是要求解某个随机序列的最长降序序列2.求N就是每次从序列中选取最长降序序列，直到原序列中所有元素都被选出，得到的降序序列的个数就是所求N

例如：

300 250 275 252 200 138 245

每次选取最大降序序列，第一次选300,275,252,200,138第二次选250,245,现在所有的元素都被选完了，所以M为5，N为2。假设还有700,100两个元素，100会被加入第一次选出的序列，700独立成为一个序列，则M为6，N为3

思考：

对于目标序列S，分成两段，其中S1为已经遍历过的，S2为未遍历过的。

运用某种数据结构，存储S1中所有可能的降序序列段，然后每次把S2中的第一个元素加入S1，并修改S1所有的降序序列段，保证新生成的降序序列段为新的S1的降序序列段。

通过这个思路，可以想到用AOV网（拓扑排序）来存储所有的降序序列段，每次从S2获得新的元素添加进S1就相当于遍历树的所有节点，如果已存储的节点的值大于等于新节点的值，则把该新节点的副本加入该节点的子序列。

所求的最长序列M就是AOV网的最大深度，所求的需要多少个系统N就是所有拓扑序列中，每次去除最长路径上的所有节点，N次可以去除完所有节点。换句话说，每次拓扑排序，得到最多节点后把其全部摘除，生成的新图再按照拓扑排序，得到最长的序列，再摘除，如此循环往复N次。

语言转为代码：

建立数据结构：分析到我们需要建立AOV网，运用递归可以很好的简化代码，因为生成的AOV网是一个有向无环图，所以每次遍历所有节点，如果遍历到的当前节点大于新加入的节点，则生成一条原节点到新节点的路径。为了编码方便，我们可以引入头结点，头结点的最大值就是其最大高度，保证有头结点到剩余所有节点的路径，对于之后的编码可以方便很多。

求出最长序列长度M：根据求树的高度的代码，我们可以很轻松的得出有向无环图的代码，运用递归完成。

求N：这不是一个轻松的事，但是通过求M，我们可以得到每个节点的高度（节点的高度定义为：令最低终端节点为距离根节点最远的节点，则节点高度为该节点距离最低终端节点的距离）。同时设置一个访问位，用已经访问来代表摘除该节点，又因为我们已经设置了一个头结点，有到所有节点的访问路劲，这就导致我们不会遗漏任何一个节点。

//代码分析：为了保证代码的通用性（不仅仅局限于int类型），使用泛型编程。
//	    为了保证内存管理的方便性，使用智能指针。
//          之所以选用set，而不用其他的容器，是因为set能保证插入的唯一性

#include <memory>
#include <algorithm>
#include <iostream>
#include <set>


#define MAXALTITUDE 30000			//导弹最高高度
#define GETARRAYSIZE(A) (sizeof(A)/sizeof(*A))	//得到数组中元素的个数

static int count = 0;//核心语句计数量

template<class T>
class DescendAov
{
private:
	bool isVisited;						        //是否访问过
	T value;							//存储当前节点的值
	std::set<std::shared_ptr<DescendAov> > minSet;			//存储比该节点值小的集合
	int maxAltitude;					        //存储每个节点的最大高度
public:
	DescendAov(const T v) :value(v), isVisited(false), maxAltitude(0){};//通过值建AOV网
	DescendAov(T* sequence, int length) :DescendAov(MAXALTITUDE)
	{//通过序列建AOV网
		for (int i = 0; i < length; ++i)
		{//创建目标数据结构
			Insert(sequence[i]);
		} 
	};
	int GetTheLengthOfTheLongestDescendSequence(int i = 0)
	{//遍历AOV网，得到AOV网的高度，就是所要求的最大降序序列长度

		int high = i;
		for (auto itr : minSet)
		{
			high = std::max(itr->GetTheLengthOfTheLongestDescendSequence(i + 1), high);
		}
		maxAltitude = high;
		return high;
	}

	int GetLongestTopoSequenceNumber()
	{//得到最长拓扑序列的数量
		int num = 0;
		GetTheLengthOfTheLongestDescendSequence();//保证已经得出每个节点的高度
		for (unsigned int i = 0; i < minSet.size(); ++i)
		{
			if (FindTheHighestNode())
				num++;
			else
				break;
		}
		return num;
	}
private:
	void Insert(const std::shared_ptr<DescendAov> d)
	{//插入后继
		++count;
		if (d->value <= value && this != d.get())
		{//如果节点值value大于等于新加入的节点值d->value，则添加进比他小的集合，this!=d.get()是为了防止自身重复插入自身。
			for (auto itr : minSet)
			{
				itr->Insert(d);
			}
			minSet.insert(d);
		}
	}
	void Insert(const T &t)
	{
		auto ptr = std::shared_ptr<DescendAov<T>>(new DescendAov<T>(t));
		Insert(ptr);
	}
	
	bool FindTheHighestNode()
	{//找到与该节点相连接的最高且未被访问过的节点
		std::shared_ptr<DescendAov<T>> Highest = NULL;
		for (auto itr : minSet)
		{
			if (!itr->isVisited)
			{//未被访问过
				if (!Highest || Highest->maxAltitude <= itr->maxAltitude)//如果当前节点为空或者当前节点更高
					Highest = itr;
			}
		}
		if (!Highest)//找不到合适的节点有两种情况：1.所有节点被放过问;2.当前节点为最后一个节点
			return false;
		Highest->isVisited = true;
		Highest->FindTheHighestNode();
		return true;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	int missile[] = { 300, 250, 275, 252, 200, 138, 245,700,100};
	DescendAov<int> root(missile, GETARRAYSIZE(missile));
	std::cout <<"最多拦截的导弹数：" << root.GetTheLengthOfTheLongestDescendSequence() << std::endl;
	std::cout << "需要多少套系统：" << root.GetLongestTopoSequenceNumber() << std::endl;
	std::cout << "核心代码循环次数:" << count << std::endl;
	return 0;
}

防御导弹算法