杭电oj1257java实现各种方法

附上题目链接：杭电oj1257

这个题目有动态规划和贪心两种解决方式。

贪心法1：

对于导弹我们知道只可以从大到小的反导，一个系统必须从大到小排列。那么我们就可以选择从最高的那个导弹入手，往右找仅次于最高的那个导弹，标记（可使用boolean），一直找到最后一个导弹形成系统1。在重复找未被标记的最大往右找，形成系统二，一直到全被标记为止。代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/*
* 贪心算法
* 思路：将导弹从大到小排序，另计数组标记原始数据。循环查找导弹右侧的第一个比导弹低的是否在右侧；如果右侧，继续后面比较第二个导弹
* 如果不在右侧，继续往下找到最大的在右侧的那个导弹。找过的导弹全部标记。形成一个系统
* 循环从下一个系统开始找未标记的导弹。
*/
public class 杭电1257 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int n = sc.nextInt();
int a[] = new int
;// 原始数据
int b[] = new int
;// 原始数据对应的序号。方便排序后知道原来排序
boolean c[] = new boolean
;
int count = 0;

for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
b[i] = i;

}
for (int i = 0; i < n; i++)// 将导弹从大到小排序
{
for (int j = i; j < n; j++) {
if (a[i] < a[j]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
t = b[i];
b[i] = b[j];
b[j] = t;
}
}
}
for (int i = 0; i < n; i++) {
if (c[i] == false) {

int s = b[i];// 序号
for (int j = i; j < n; j++) {
if (b[j] >= s && c[j] == false) {
c[j] = true;
s = b[j];
}
}
count++;
}
}
System.out.println(count);
}
}
}

贪心法二：学习恶狼干爹方法

算法思想：

建立足够大的系统数，导弹从左到右一个一个来。

第一个形成系统1.

第二个看看是否比第一个小，如果小，则进入系统1.如果比第一个大，则新建系统二。

若完成拦截，则此拦截系统的最大拦截变为这个高度

若未拦截成功，则新建系统，最高拦截度为这个数

核心是使用数组储存数据。

import java.util.*;

class 杭电1257{
public static void main(String[] args){
int n,i,x,numb,m,k;
int[] system=new int[100000];//记录所有系统中能截的最大高度
Scanner sc=new Scanner(System.in);
boolean haveSystem;//记录在已有的系统只是否找到能截的系统
while(sc.hasNext()){
numb=0;//表示系统的个数
n=sc.nextInt();
for(i=0;i<n;i++){
m=sc.nextInt();
haveSystem=false;
for(k=0;k<=numb;k++){//先找再已有的系统只是否有能截的系统
if(m<=system[k]){
system[k]=m;
haveSystem=true;
break;
}
}
if(!haveSystem){//若没有能截的系统，则重新配一套系统
system[++numb]=m;
}
}
System.out.println(numb);
}
}
}

动态规划法：

求最大递增子序列

import java.util.Scanner;

public class 杭电1257 {
public static void main(String[] args)
{

Scanner sc=new Scanner(System.in);
while(sc.hasNext())
{
int max=0;//最大数列长度
int n=sc.nextInt();
int dp[]=new int
;//以第i个元素结尾的最大子数列。（最后一个一定是a[i]的）
int a[]=new int
;
for(int i=0;i<n;i++)
{
a[i]=sc.nextInt();
}
dp[0]=1;//第一元素构成1

for(int i=1;i<n;i++)
{//计算dp[i];
int m=0;//每次都要初始化计算;m的实际意义为临时变量，为了找比自己小的元素的最大数列，然后拼凑成为第i个最大。
for(int j=0;j<i;j++)//从0到当前元素循环
{
if(dp[j]>m&&a[j]<a[i])
{
m=dp[j];    //这样做为了找到最大的那个dp【j】，并且那个a[j]<a[i];则j的那串加上i就构成以i结尾的最大递增数列
}
dp[i]=m+1;//相当于最大的第J串后面接了一个元素。
if(max<dp[i])
{
max=dp[i];
}

}
}
System.out.println(max);

}
}

}