最少拦截系统（杭电1257）（DP）+（贪心）

最少拦截系统

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 19432 Accepted Submission(s): 7719

Problem Description

某国为了防御敌国的导弹突击,发展出一种导弹拦截系统.可是这样的导弹拦截系统有一个缺陷:尽管它的第一发炮弹可以到达随意的高度,可是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.因为该系统还在试用阶段,所以仅仅有一套系统,因此有可能不能拦截全部的导弹.
怎么办呢?多搞几套系统呗!你说说倒蛮easy,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少须要多少套拦截系统.

Input

输入若干组数据.每组数据包含:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔)

Output

相应每组数据输出拦截全部导弹最少要配备多少套这样的导弹拦截系统.

Sample Input

8 389 207 155 300 299 170 158 65

Sample Output

2
/*与求最长上升子序列代码同样。
參考别人的思路。具体具体解释： 
最长递增子序列。Longest Increasing Subsequence 以下我们简记为 LIS。

排序+LCS算法 以及 DP算法就忽略了。这两个太easy理解了。
假设存在一个序列d[1..9] = 2 1 5 3 6 4 8 9 7。能够看出来它的LIS长度为5。
n
以下一步一步试着找出它。
我们定义一个序列B，然后令 i = 1 to 9 逐个考察这个序列。
此外。我们用一个变量Len来记录如今最长算到多少了
首先。把d[1]有序地放到B里，令B[1] = 2，就是说当仅仅有1一个数字2的时候，
长度为1的LIS的最小末尾是2。
这时Len=1
然后。把d[2]有序地放到B里。令B[1] = 1，就是说长度为1的LIS的最小末尾是1，
d[1]=2已经没用了。非常easy理解吧。这时Len=1
接着，d[3] = 5。d[3]>B[1]，所以令B[1+1]=B[2]=d[3]=5。就是说长度为2的LIS的最小末尾是5，
这时候B[1..2] = 1, 5，Len＝2
再来，d[4] = 3，它正好加在1,5之间，放在1的位置显然不合适。由于1小于3，
长度为1的LIS最小末尾应该是1，这样非常easy推知，长度为2的LIS最小末尾是3，
于是能够把5淘汰掉，这时候B[1..2] = 1, 3，Len = 2
继续，d[5] = 6。它在3后面，由于B[2] = 3, 而6在3后面。于是非常easy能够推知B[3] = 6,
 这时B[1..3] = 1, 3, 6。还是非常easy理解吧？ Len = 3 了噢。

第6个, d[6] = 4。你看它在3和6之间，于是我们就能够把6替换掉，
得到B[3] = 4。
B[1..3] = 1, 3, 4。 Len继续等于3
第7个, d[7] = 8，它非常大，比4大。嗯。于是B[4] = 8。Len变成4了
第8个, d[8] = 9，得到B[5] = 9，嗯。Len继续增大。到5了。
最后一个, d[9] = 7，它在B[3] = 4和B[4] = 8之间，所以我们知道。
最新的B[4] =7。B[1..5] = 1, 3, 4, 7, 9，Len = 5。
于是我们知道了LIS的长度为5。
注意。这个1,3,4,7,9不是LIS。它仅仅是存储的相应长度LIS的最小末尾。
有了这个末尾，
我们就能够一个一个地插入数据。
尽管最后一个d[9] = 7更新进去对于这组数据没有什么意义。
可是假设后面再出现两个数字 8 和 9，那么就能够把8更新到d[5], 9更新到d[6]，得出LIS的长度为6。
然后应该发现一件事情了：在B中插入数据是有序的。并且是进行替换而不须要挪动——
我们能够使用二分查找，将每个数字的插入时间优化到O(logN)
*/
//代码例如以下：
#include<stdio.h>
int a[10010],b[10010],i,len;
int search(int i)  //二分查找。 
{
	int left=0,right=len;
	while(left<right)
	{
		int mid=(left+right)/2;
		if(a[i]<b[mid])
		   right=mid;
		else
		   left=mid+1;
	}
	return left; 
}
int main()
{
	int n,j;
	while(scanf("%d",&n)!=EOF)
	{
		for(i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
		}
		len=1;
		b[len]=a[1];
		for(i=2;i<=n;i++)
		{
			if(a[i]>b[len])
			{
				len++;
				b[len]=a[i];
			}
			else
			{
				j=search(i);
				b[j]=a[i];
			}
		}
		printf("%d
",len);
	}
	return 0;
}
//方法2：网上比較简单的代码，表示不太懂，假设谁理解的能够告诉我。谢谢。 
/*
#include<stdio.h>
#include<math.h>
int a[30001],b[30001];
int main()
{
   int n,i,j,k;
   while(scanf("%d",&n)!=EOF)
   {
       b[0]=0;k=0;
       for(i=0;i<n;i++)
       {
           scanf("%d",&a[i]);
           for(j=0;j<=k;j++)
           {
               if(a[i]<b[j])
               {
                   b[j]=a[i];
                   break;
               }
               else if(j==k)
               {
                   k++;
                   b[k]=a[i];
                   break;
               }
           }
       }
       printf("%d
",k);
   }
   return 0;
}
*/ 
//准确说是贪心比較好理解：#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int a[100000];
int main()	
{
	int i,j,t,n,sum;
	while(scanf("%d",&n)!=EOF)
	{
		memset(a,0,sizeof(a));
		for(i=0;i<n;i++)
		scanf("%d",&a[i]);
		for(i=0,sum=0;i<n;i++)
		{
			if(a[i]!=0)
			{
				sum++;
				t=a[i];
				for(j=i+1;j<n;j++)
				{
					if(a[j]<=t&&a[j])
					{
						t=a[j];
						a[j]=0;
					}
				}
			}
		}
		printf("%d
",sum);
	}
	return 0;
}