FatMouse's Speed

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 21117 Accepted Submission(s): 9367
Special Judge
Problem Description

FatMouse believes that the fatter a mouse is, the faster it runs. To disprove this, you want to take the data on a collection of mice and put as large a subset of this data as possible into a sequence so that the weights are increasing, but the speeds are decreasing.

Input

Input contains data for a bunch of mice, one mouse per line, terminated by end of file.

The data for a particular mouse will consist of a pair of integers: the first representing its size in grams and the second representing its speed in centimeters per second. Both integers are between 1 and 10000. The data in each test case will contain information for at most 1000 mice.

Two mice may have the same weight, the same speed, or even the same weight and speed.

Output

Your program should output a sequence of lines of data; the first line should contain a number n; the remaining n lines should each contain a single positive integer (each one representing a mouse). If these n integers are m[1], m[2],..., m[n] then it must be the case that

W[m[1]] < W[m[2]] < ... < W[m[n]]

and

S[m[1]] > S[m[2]] > ... > S[m[n]]

In order for the answer to be correct, n should be as large as possible.
All inequalities are strict: weights must be strictly increasing, and speeds must be strictly decreasing. There may be many correct outputs for a given input, your program only needs to find one.

Sample Input

Sample Output

4
4
5
9
7

解题思路：

结构体内先以weight为基准排序，再排speed，排完序后weight可能有相等的情况，再找符合条件的speed的最长递减子序列

（最长递减子序列求解的方法参见https://blog.csdn.net/Cassie_zkq/article/details/82900389，思路相同）

如何解决输出的序号的问题呢？

1）last记录最长递减子序列最后一个元素的排序后的序号；

2）pre[i]数组记录dp[i]对应的子序列的倒数第二个元素，最后就可以找到dp[m]（假设dp[m]是最大的）中所以元素的排完序的序号了;

3）out[]数组记录输出；

举个栗子：

输出4个元素，这4个元素在sort之后的顺序依次是 4 ，5，7，9

此时last=9，

且已经记录：pre[9]=7, pre[7]=5 , pre[5]=4, pre[4]=0;

则输出为out[0]=9，out[1]=7，out[2]=5，out[3]=4;（用while即可实现，详见代码）

最后再倒序输出

ac代码：

#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#define maxn 100005
using namespace std;
struct node{
    int weight;
    int speed;
    int order;//记录最初输入的顺序
}mice[maxn];
int dp[maxn],pre[maxn],out[maxn];
bool cmp(node a,node b)
{
    if(a.weight==b.weight) return a.speed>b.speed;
    else return a.weight<b.weight;//先以weight为标准排序
}
int main()
{
    int num=1,count=0,last=1;//num记录总的mouse的个数,count记录有多少只符合条件的mouse
    int i,j;
    while(scanf("%d %d",&mice[num].weight,&mice[num].speed)!=EOF)
    {
        dp[num]=1;
        pre[num]=0;
        mice[num].order=num;
        num++;
    }
    num--;
    sort(mice+1,mice+1+num,cmp);//注意下标从1开始要从1开始比较，mice+1
    for(i=1;i<=num;i++)
    {
        for(j=1;j<i;j++)//寻找speed的最大递减子序列，pd[i]记录以mice[i]结尾的最大递减子序列的长度
        {
            if(mice[i].weight>mice[j].weight && mice[i].speed<mice[j].speed && dp[i]<(dp[j]+1))
            {//有可能出现weight相同的情况，且要求weight一定要递增！！
                pre[i]=j;//记录当前子序列的倒数第二个元素
                dp[i]=dp[j]+1;
            }
        }
        if(dp[i]>count)
        {
            last=i;//last记录最长递减子序列的最后一个下标（从1开始）
            count=dp[i];
        }
    }
    int t=0;
    while(last!=0)
    {
        out[t++]=last;
        last=pre[last];
    }
    printf("%d\n",count);
    for(i=t-1;i>=0;i--)//倒序输出
    {
        printf("%d\n",mice[out[i]].order);
    }
    return 0;
}

hdoj1160：FatMouse's Speed（dp+最长递减子序列思想+数组巧妙记录输出）

FatMouse's Speed

解题思路：

ac代码：