LIS+输出路径模板(1160)

FatMouse's Speed

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 13102    Accepted Submission(s): 5765
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
7
  
  

DP方程不难想到，简单的LIS。关键在于路径的输出，首先每个结构体需要标记一些其它东西，下标index和前一个结点pre，前者为了排序后仍能找到下标，因为原题需要输出下标，后者为了后续能够从最优解的最终结点能找回路径。程序最后新开了一个数组来寻找路径。/其实可以开个数组path[1000]，记录每个状态的取值，path[i]的含义是此状态最优解时的前驱状态是什么，默认值是i。要注意如果想做一些另外的操作时，DP方程不可直接用max函数，因为每次dp值更新都需要记录，不更新不能记录。

/*------------------Header Files------------------*/
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <ctype.h>
#include <cmath>
#include <stack>
#include <queue>
#include <map>
#include <vector>
#include <limits.h>
using namespace std;
/*------------------Definitions-------------------*/
#define LL long long
#define PI acos(-1.0)
#define INF 0x3F3F3F3F
#define MOD 10000
/*---------------------Work-----------------------*/
struct node
{
	int w,s;
	int index,length; //index记录下标，不然排序后下标就找不到了 
	int pre; 
}mice[1050];
bool cmp(node a,node b)
{
	if(a.w==b.w) return a.s>b.s;
	else return a.w<b.w;
}
void work()
{
	int cnt=1,weight,speed;
	while(cin>>mice[cnt].w>>mice[cnt].s)
	{
		mice[cnt].index=cnt;
		mice[cnt].length=1;
		mice[cnt].pre=0;
		cnt++;
	}
	cnt--;
	sort(mice+1,mice+cnt+1,cmp);
	for(int i=2;i<=cnt;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(mice[i].w!=mice[j].w&&mice[i].s<mice[j].s&&mice[i].length-1<mice[j].length)
			{
				mice[i].length=mice[j].length+1; //DP过程 
				mice[i].pre=j; //为了能够标记，不能写max函数
			}
		}
	}
	int max_length=1,max_end=1; //后者记录最大值的最后一个元素
	for(int i=2;i<=cnt;i++)
	{
		if(max_length<mice[i].length)
		{
			max_length=mice[i].length;
			max_end=i;
		}
	}
	printf("%d\n",max_length);
	int max_path[1050]={0}; //记录路径，从end点开始找
	max_path[max_length]=max_end;
	for(int i=max_length-1;i>0;i--)
	{
		max_path[i]=mice[max_path[i+1]].pre;
	}
	for(int i=1;i<=max_length;i++)
		printf("%d\n",mice[max_path[i]].index);
}
/*------------------Main Function------------------*/
int main()
{
	//freopen("test.txt","r",stdin);
	//freopen("cowtour.out","w",stdout);
	//freopen("cowtour.in","r",stdin);
	work();
	return 0;
}