HDU 1160 FatMouse's Speed 最优方案

原题： http://acm.hdu.edu.cn/showproblem.php?pid=1160

题目：

FatMouse’s Speed

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 12056 Accepted Submission(s): 5276
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
6008 1300
6000 2100
500 2000
1000 4000
1100 3000
6000 2000
8000 1400
6000 1200
2000 1900

Sample Output
4
4
5
9

思路：

把老鼠按肥胖值的严格升序排列，求速度的最大下降子序列。并输出这组最优方案。

需要把体重、速度、序号绑定在一起，所以我们用结构体。
求最大下降子序列从后往前就是求的最大上升子序列。而求解的方法有很多种，其中的dp值有很多种意思，虽然都能输出最长的值，但是这里还要求输出最优解的组成，所以有的方法不一定能良好的表达出来。
这里浅谈一下输出最优方案的原理。

这里的dp值代表所处最长上升子序列的最大值。
maxn代表比加入元素小的最大的dp值，加入的元素只需要接在最大的dp值后面，就能成为原来最长的尾端，也是让长度加了1，如此循环，就能求得每个值所处的最大位置。
遍历一遍便可知道最长的长度了。

for(int j=t-2; j>=0; j--)
{
    int maxn=0;
    for(int k=j+1; k<t; k++)
    {
        if(m[k].weight>m[j].weight&&m[k].speed<m[j].speed&&dp[k]>maxn)
        {
            maxn=dp[k];
        }
    }
    dp[j]=maxn+1;
}

而在输出的时候，如下面代码，因为我们能找到最大的dp值的位置，所以以它为输出方案的第一个，因为它前面总存在一个比它小1的数（因为它本身就是由那个数+1得到的），所以我们再以它为起点继续搜索就是，知道需要搜索的dp值变成0。

for(int i=temp;i<t;i++)
    {
        if(dp[i]==maxi)
        {
            printf("%d\n",m[i].key);
            maxi--;
        }
        if(maxi==0)
        {
            break;
        }
    }

代码：

#include"iostream"
#include"string.h"
#include"stdlib.h"
#include"cstdio"
#include"algorithm"
using namespace std;

struct mouse
{
    int weight;
    int speed;
    int key;
};

bool cmp(mouse a,mouse b)
{
    if(a.weight==b.weight)
        return a.speed>b.speed;
    else
        return a.weight<b.weight;
}

mouse m[1005];
int dp[1005];

int main()
{
    int t=1;
    while(scanf("%d %d",&m[t].weight,&m[t].speed)!=EOF)
    {
        m[t].key=t;
        t++;
    }
    sort(m+1,m+t,cmp);
    for(int j=t-2;j>=0;j--)
    {
        int maxn=0;
        for(int k=j+1;k<t;k++)
        {
            if(m[k].weight>m[j].weight&&m[k].speed<m[j].speed&&dp[k]>maxn)
            {
                maxn=dp[k];
            }
        }
        dp[j]=maxn+1;
    }
    int maxi=0;
    int temp=0;
    for(int i=1;i<t;i++)
    {
        if(dp[i]>maxi)
        {
            temp=i;
            maxi=dp[i];
        }
    }
    printf("%d\n",maxi);
    for(int i=temp;i<t;i++)
    {
        if(dp[i]==maxi)
        {
            printf("%d\n",m[i].key);
            maxi--;
        }
        if(maxi==0)
        {
            break;
        }
    }
    return 0;
}