最少拦截系统（杭电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

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

 

Input

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

 

Output

对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统.

 

Sample Input

  
  

   
   8 389 207 155 300 299 170 158 65
  
  

 

Sample Output

  
  

   
   2
  
  
  
  

   
   
/*与求最长上升子序列代码相同。
参考别人的思路，具体详解： 
最长递增子序列，Longest Increasing Subsequence 下面我们简记为 LIS。
排序+LCS算法 以及 DP算法就忽略了，这两个太容易理解了。
假设存在一个序列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已经没用了，很容易理解吧。这时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，这样很容易推知，长度为2的LIS最小末尾是3，
于是可以把5淘汰掉，这时候B[1..2] = 1, 3，Len = 2
继续，d[5] = 6，它在3后面，因为B[2] = 3, 而6在3后面，于是很容易可以推知B[3] = 6,
 这时B[1..3] = 1, 3, 6，还是很容易理解吧？ 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\n",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\n",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\n",sum);
	}
	return 0;
}