zoukankan      html  css  js  c++  java
  • HDU 1160 FatMouse's Speed 简单DP

                     FatMouse's Speed

    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
     
    一组数据,处理到文件结束
    给你一些牛的体重,和速度
    现在从这些牛中挑出尽量多的牛组成一个序列,使得满足:
    体重从小到大严格递减,速度从大到小严格递增
    输出最多能找出多少只牛,还要输出牛的序号
     
    其实类似最大上升子序列一样,只不过有2个条件,一个增大,一个减少而已。
    再另外记录下原来输入的牛的编号,
    这样排序后照样可以知道他原来的序号。
     
    按原来的序号输出
     
     1 #include<iostream>
     2 #include<cstring>
     3 #include<algorithm>
     4 #include<cstdio>
     5 
     6 using namespace std;
     7 
     8 const int maxn=1005;
     9 
    10 int dp[maxn];                    //以第i个为结束元素的序列的最大值
    11 int pre[maxn];                   //记录序列
    12 
    13 struct Node
    14 {
    15     int w,s,num;                 //num记录输入的顺序
    16 }node[maxn];
    17 
    18 bool cmp(Node a,Node b)
    19 {
    20     if(a.w==b.w)
    21         return a.s>b.s;
    22     return a.w<b.w;
    23 }
    24 
    25 //输出路径
    26 void output(int cur)
    27 {
    28     if(pre[cur]!=-1)
    29         output(pre[cur]);
    30     cout<<node[cur].num<<endl;
    31 }
    32 
    33 int main()
    34 {
    35     //freopen("in.txt","r",stdin);          //记住要注释掉
    36 
    37     int u,v;
    38     int tot=1;
    39 
    40     while(cin>>u>>v)
    41     {
    42         node[tot].w=u;
    43         node[tot].s=v;
    44         node[tot].num=tot++;
    45     }
    46 
    47     sort(node+1,node+tot,cmp);
    48 
    49     memset(pre,-1,sizeof(pre));
    50 
    51     for(int i=1;i<tot;i++)
    52         dp[i]=1;
    53 
    54     for(int i=1;i<tot;i++)
    55     {
    56         for(int j=1;j<i;j++)
    57             if(node[j].w<node[i].w&&node[j].s>node[i].s)
    58                 if(dp[j]+1>dp[i])
    59                 {
    60                     dp[i]=dp[j]+1;
    61                     pre[i]=j;
    62                 }
    63     }
    64 
    65     int ans=0;
    66     int cur;
    67     for(int i=1;i<tot;i++)
    68         if(dp[i]>ans)
    69         {
    70             ans=dp[i];
    71             cur=i;
    72         }
    73 
    74     cout<<ans<<endl;
    75 
    76     output(cur);
    77 
    78     return 0;
    79 }
    View Code
     
     
     
     
     
     
     
     
     
     
     

     

  • 相关阅读:
    Spark 内核架构+宽依赖与窄依赖+基于Yarn的两种提交模式
    Spark RDD高级编程:基于排序机制的wordcount程序+二次排序+topn
    Spark RDD持久化原理+共享变量原理(Broadcast Variable和Accumulator)
    Spark RDD工作原理详解+RDD JAVA API编程
    Spark 程序设计详解
    剑指offer 39.知识迁移能力 平衡二叉树
    剑指offer 38.知识迁移能力 二叉树的深度
    ElasticSearch 倒排索引原理+document写入流程+数据恢复
    剑指offer 37.知识迁移能力 数字在排序数组中出现的次数
    剑指offer 36.时间空间效率的平衡 两个链表的第一个公共结点
  • 原文地址:https://www.cnblogs.com/-maybe/p/4448317.html
Copyright © 2011-2022 走看看