ZOJ 1108 FatMouse's Speed 动态规划

题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=108

题目大意:证明老鼠重量越重,速度越慢,给你一组老鼠的数据(包括重量和速度),要求输出满足前面条件的最长的子序列的老鼠编号

首先,按照老鼠的重量进行升序和速度的降序排列;

然后,根据动态方程求解

len[0]=1;len[i]=max{len[j]}+1 (0<=j<i)

最后,输出老鼠的编号顺序,为了能够输出顺序的编号,所以要给老鼠一个index和preIndex,最后输出时最好的方法是采用递归的方式

注意:

1.题目的结束是以文件结尾为结束符,在C和C++中是 EOF,但是在Java里文件结束是null,用Scanner和 BufferedReader 都可以,接着判断
(str = br.readLine()).equals("")就可以了;
或者是 !(str = sin.nextLine()).equals("")
2.使用BufferedReader每次读取的都是一行数据,这里我要得到的是以空格隔开来的两个数字,可以使用StringTokenizer,也可以使用Scanner,当然
这道题目其实使用String的各种操作也是可以实现的。

  

int w2=Integer.parseInt(str.substring(0, str.indexOf(" ")));//区别在这里

  int s2=Integer.parseInt(str.substring(str.indexOf(" ")+1));

我的Java代码:【注意:结果是TLE,我实在是没有办法】

/**
* 修改排序方法,使用Collections.sort
* 修改设置preIndex的方法和输出方式
* 结果:TLE
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class ZOJ1108_4 {

public static int n;// 记录老鼠的数目
public static int[] len;// 记录以原序列中第i个老鼠结尾的最长的子序列
public static int maxlen, maxIndex;// 分别表示最大长度和最后的老鼠的index
public static ArrayList<Mouse> mice = new ArrayList<Mouse>();// 记住要new,不然会报空指针

public static void main(String[] args) throws Exception {
BufferedReader br
= new BufferedReader(new InputStreamReader(System.in));
n
= 0;
String str;
while (!(str = br.readLine()).equals("")) {
Scanner sin
= new Scanner(str);
int w = sin.nextInt();
int s = sin.nextInt();
Mouse m
= new Mouse(n + 1, w, s);
n
++;
mice.add(m);
}
Collections.sort(mice,
new Comparator<Mouse>() {
public int compare(Mouse o1, Mouse o2) {
if (o1.weight > o2.weight) {
return 1;
}
else if (o1.weight == o2.weight && o1.speed < o2.speed) {
return 1;
}
else {
return -1;
}
}
});
dpSpeed();
System.out.println(maxlen);
output(maxIndex);
}

//根据老鼠的速度进行dp
private static void dpSpeed() {
len
= new int[n];
int i, j, k;
maxlen
= 0;
maxIndex
= 0;
len[
0] = 1;
mice.get(
0).preIndex = 0;
for (i = 1; i < n; i++) {
len[i]
= 1;
for (j = 0; j < i; j++) {
if (mice.get(i).speed < mice.get(j).speed
&& mice.get(i).weight > mice.get(j).weight) {
if (len[j] >= len[i]) {// 注意这里可以等于,也许刚好满足条件的那个就是长度为1[可以调试]
len[i] = len[j] + 1;
mice.get(i).preIndex
= j;
}
}
}
}
for (k = 0; k < n; k++) {
if (len[k] > maxlen) {
maxlen
= len[k];
maxIndex
= k;
}
}
}

//用递归的方式输出
private static void output(int index) {
if(len[index]==1){
System.out.println(mice.get(index).index);
}
else{
output(mice.get(index).preIndex);
System.out.println(mice.get(index).index);
}
}
}

class Mouse {
int index;// 记录该老鼠是原序列的第几位
int weight;// 记录重量和速度
int speed;
int preIndex;// 记录该老鼠在得到的序列中的上一个老鼠的index

public Mouse() {

}

public Mouse(int index, int weight, int speed) {
this.index = index;
this.weight = weight;
this.speed = speed;
}
}

换了一种方式,结果是RE,不知道哪里出错了

/**
* 修改排序方法,使用Collections.sort
* 修改设置preIndex的方法和输出方式
* 修改了得到输入数据的方法
* 结果:RE
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Main{

public static int n;// 记录老鼠的数目
public static int[] len;// 记录以原序列中第i个老鼠结尾的最长的子序列的长度
public static int maxlen, maxIndex;// 分别表示最大长度和最后的老鼠的index
public static ArrayList<Mouse> mice = new ArrayList<Mouse>();// 记住要new,不然会报空指针

public static void main(String[] args){
Scanner sin
=new Scanner(System.in);
n
= 0;
String str;
while (!(str = sin.nextLine()).equals("")) {//利用nextLine方法也是可以的!
int w2=Integer.parseInt(str.substring(0, str.indexOf(" ")));//区别在这里
int s2=Integer.parseInt(str.substring(str.indexOf(" ")+1));
Mouse m
= new Mouse(n + 1, w2, s2);
n
++;
mice.add(m);
}
Collections.sort(mice,
new Comparator<Mouse>() {
public int compare(Mouse o1, Mouse o2) {
if (o1.weight > o2.weight) {
return 1;
}
else if (o1.weight == o2.weight && o1.speed < o2.speed) {
return 1;
}
else {
return -1;
}
}
});
dpSpeed();
System.out.println(maxlen);
output(maxIndex);
}

//根据老鼠的速度进行dp
private static void dpSpeed() {
len
= new int[n];
int i, j, k;
maxlen
= 0;
maxIndex
= 0;
len[
0] = 1;
mice.get(
0).preIndex = 0;
for (i = 1; i < n; i++) {
len[i]
= 1;
mice.get(i).preIndex
=i;
for (j = 0; j < i; j++) {
if (mice.get(i).speed < mice.get(j).speed
&& mice.get(i).weight > mice.get(j).weight) {
if (len[j] >= len[i]) {// 注意这里可以等于,也许刚好满足条件的那个就是长度为1[可以调试]
len[i] = len[j] + 1;
mice.get(i).preIndex
= j;
}
}
}
}
for (k = 0; k < n; k++) {
if (len[k] > maxlen) {
maxlen
= len[k];
maxIndex
= k;
}
}
}

//用递归的方式输出
private static void output(int index) {
if(len[index]==1){//巧妙之处:最后的那个的len[]==1
System.out.println(mice.get(index).index);
}
else{
output(mice.get(index).preIndex);
System.out.println(mice.get(index).index);
}
}
}

class Mouse {
int index;// 记录该老鼠是原序列的第几位
int weight;// 记录重量和速度
int speed;
int preIndex;// 记录该老鼠在得到的序列中的上一个老鼠的index

public Mouse() {

}

public Mouse(int index, int weight, int speed) {
this.index = index;
this.weight = weight;
this.speed = speed;
}
}

  

解题时我参考了网上一位同学的方法,很是不错啊,和我的差不多,不过输出我是参考他的

他用的是C++,顺利 AC ,我们的算法时间复杂度都是 O(n^2)。。。【详情可见我的博客中的另外一篇博文】

虽说还有一种更好的算法 O(nlog(n)),但是我怎么都没写出来,因为那个比较的方式太复杂了点

#include <iostream>
#include
<algorithm>
#define MAX 1005
using namespace std;

struct Mice
{
int id;
int weight;
int speed;
int pre;
};


bool cmp(const Mice& a, const Mice& b)
{
if (a.weight < b.weight)
return true;
else if (a.weight == b.weight)
return a.speed > b.speed;
else
return false;
}

int num[MAX];
Mice mice[MAX];

void output(int);

int main()
{
int count = 0;

while (cin >> mice[count].weight >> mice[count].speed)
{
mice[count].id
= count+1;
count
++;
}


sort(mice, mice
+count, cmp);

num[
0] = 1;
mice[
0].pre = 0;

for (int i = 1; i < count; i++)
{
num[i]
= 1;
mice[i].pre
= i;

for (int j = 0; j < i; j++)
{
if (mice[i].weight > mice[j].weight && mice[i].speed < mice[j].speed)
{
if (num[i] < num[j]+1)
{
num[i]
= num[j]+1;
mice[i].pre
= j;
}
}
}

}

int max_index = 0;
for (int i = 1; i < count; i++)
if (num[i] > num[max_index])
max_index
= i;

cout
<< num[max_index] << endl;

output(max_index);
return 0;
}


void output(int index)
{
if (num[index] == 1)
cout
<< mice[index].id << endl;
else
{
output(mice[index].pre);
cout
<< mice[index].id << endl;
}
}

  

你可能感兴趣的:(动态规划)