HDOJ---1257 最少拦截系统[线性DP]+NYOJ---拦截导弹[输出最长单调子序列的长度]

 

最少拦截系统

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

Problem Description

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

 

 

Input

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

 

 

Output

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

 

 

Sample Input

8 389 207 155 300 299 170 158 65

 

 

Sample Output

2

 

 

Source

浙江工业大学第四届大学生程序设计竞赛

 

 

Recommend

JGShining

 

 

 

 

 

应该还有更好的方法

code:

 1 #include <iostream>   

 2 #include <iomanip>   

 3 #include <fstream>   

 4 #include <sstream>   

 5 #include <algorithm>   

 6 #include <string>   

 7 #include <set>   

 8 #include <utility>   

 9 #include <queue>   

10 #include <stack>   

11 #include <list>   

12 #include <vector>   

13 #include <cstdio>   

14 #include <cstdlib>   

15 #include <cstring>   

16 #include <cmath>   

17 #include <ctime>   

18 #include <ctype.h> 

19 using namespace std;

20 

21 int main()

22 {

23     int n;

24     int i,j;

25     int record[10002];

26     int temp;

27     int cnt;

28     while(~scanf("%d",&n))

29     {

30         cnt=0;

31         scanf("%d",&record[0]);

32         for(i=1;i<n;i++)

33         {

34             sort(record,record+cnt+1);

35             scanf("%d",&temp);

36             for(j=cnt;j>=0;j--)

37             {

38                 if(temp>record[j])

39                  {

40                     record[++cnt]=temp;

41                     break;

42                 }

43                 else if(j==0)

44                 {

45                     record[j]=temp;

46                 }

47                  else if(record[j]>=temp&&record[j-1]<=temp)

48                 {

49                     record[j]=temp;

50                     break;

51                 }

52             }

53         }

54         printf("%d\n",cnt+1);

55     }

56     return 0;

57 }

 

 

 

 

 

 

 http://blog.csdn.net/a_eagle/article/details/7237067

这哥们儿代码就写的好：

 1 #include<stdio.h>//**dp[i]表示第i个导弹飞过来时需要的最少拦截装置.**//

 2 int main()

 3 {

 4     int n,i,j,max,h[10001],dp[10001];

 5     while(~scanf("%d",&n))

 6     {

 7         max=-1;

 8         dp[0]=0;

 9         for(i=1;i<=n;i++)

10         {

11             scanf("%d",&h[i]);//**飞来的高度**//

12             dp[i]=1;//**初始化拦截装置都为1**//

13         }

14         for(i=1;i<=n;i++)

15         {

16             for(j=i-1;j>=0;j--)

17             {

18                 if(h[i]>h[j]&&dp[i]<dp[j]+1)//**如果在拦截中出现了非单调递减的**//

19                 {

20                     dp[i]=dp[j]+1;

21                 }

22             }

23         }

24         for(i=1;i<=n;i++)

25         {

26             if(dp[i]>max)

27             {

28                 max=dp[i];

29             }

30         }

31         printf("%d\n",max);

32     }

33     return 0;

34 }

 

 

 

 

 

 

 

这段代码有点看不懂：

 1 #include<iostream>

 2 using namespace std;

 3 int main()

 4 {

 5     int n;

 6     int str[1001];

 7     while(cin>>n)

 8     {

 9         int i,j;

10         for(i=0;i<n;i++)

11             cin>>str[i];

12         int count(0);

13         j=n;

14         int max;

15         while(j)

16         {

17             count++;

18             max=35000;

19             for(i=0;i<n;i++)

20             {

21                 if(str[i]!=-1&&str[i]<=max)

22                 {

23                     j--;

24                     max=str[i];

25                     str[i]=-1;

26                 }

27             }

28         }

29         cout<<count<<endl;

30     }

31     return 0;

32 }

 

 

 

 

 

---

 题目：http://acm.nyist.net/JudgeOnline/problem.php?pid=79

拦截导弹

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 3

 

描述

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

 

输入

第一行输入测试数据组数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

来源

[张洁烽]原创

上传者

张洁烽

 

 

 

 

 

code:

 1  

 2  

 3 #include<stdio.h>

 4 int main()

 5 {

 6     int s,n,i,j,max,h[101],dp[101];

 7     scanf("%d",&s);

 8     while(s--)

 9     {

10         max=-1;

11         dp[0]=0;

12         scanf("%d",&n);

13         for(i=0;i<=n-1;i++)

14         {

15             scanf("%d",&h[i]);

16             dp[i]=1;

17         }

18         for(i=1;i<=n-1;i++)

19         {

20             for(j=i-1;j>=0;j--)

21             {

22                 if(h[i]<h[j]&&dp[i]<dp[j]+1)

23                 {

24                     dp[i]=dp[j]+1;

25                 }

26             }

27         }

28         for(i=0;i<=n-1;i++)

29         {

30             if(dp[i]>max)

31             {

32                 max=dp[i];

33             }

34         }

35         printf("%d\n",max);

36     }

37     return 0;

38 }