Leetcode[马戏团人塔]-最长递增子序列

Leetcode[马戏团人塔]-最长递增子序列

题目0：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

1 <= nums.length <= 2500
-104 <= nums[i] <= 104

进阶：

你可以设计时间复杂度为 O(n2) 的解决方案吗？
你能将算法的时间复杂度降低到 O(n log(n)) 吗?

题目1：

有个马戏团正在设计叠罗汉的表演节目，一个人要站在另一人的肩膀上。出于实际和美观的考虑，在上面的人要比下面的人矮一点且轻一点。已知马戏团每个人的身高和体重，请编写代码计算叠罗汉最多能叠几个人。

示例：

输入：height = [65,70,56,75,60,68] weight = [100,150,90,190,95,110]
输出：6
解释：从上往下数，叠罗汉最多能叠 6 层：(56,90), (60,95), (65,100), (68,110), (70,150), (75,190)
提示：

height.length == weight.length <= 10000

题目0解答：

动态规划：
定义数组dp,dp[i]表示考虑前i个元素且以nums[i]为结尾的最长子序列的长度。
则状态转移方程为：dp[i]=max(dp[j])+1, 0<=j<i 且nums[i]>nums[j]
序列的长度至少为1,所以将dp[]初始化为1
最后，整个数组的最长上升子序列即 dp[i] 中的最大值。

int max(int a,int b)
{
    return (a>b)?a:b;
}
int lengthOfLIS(int* nums, int numsSize)
{
    int dp[numsSize];
    for(int i=0;i<numsSize;i++)dp[i]=1;
    for(int i=1;i<numsSize;i++)
        for(int j=0;j<i;j++)
            if(nums[i]>nums[j])dp[i]=max(dp[i],dp[j]+1);
    int max=0,idex=0;
    for(int i=0;i<numsSize;i++)
        if(dp[i]>max)
        {
            idex=i;
            max=dp[i];
        }
    //for(int i=0;i<numsSize;i++)printf("%d" ,dp[i]);
    return dp[idex];
}

题目1解答：

可以先根据身高生序排列，在排序的过程中体重的顺序随之改变，之后，只要求得体重的最大递增子序列即可。

int max(int a,int b)
{
    return (a>b)?a:b;
}
int lengthOfLIS(int* nums, int numsSize)
{
    int dp[numsSize];
    for(int i=0;i<numsSize;i++)dp[i]=1;
    for(int i=1;i<numsSize;i++)
        for(int j=0;j<i;j++)
            if(nums[i]>nums[j])dp[i]=max(dp[i],dp[j]+1);
    int max=0,idex=0;
    for(int i=0;i<numsSize;i++)
        if(dp[i]>max)
        {
            idex=i;
            max=dp[i];
        }
    //for(int i=0;i<numsSize;i++)printf("%d" ,dp[i]);
    return dp[idex];
}
int bestSeqAtIndex(int* height, int heightSize, int* weight, int weightSize)
{
    typedef struct 
    {
        int*h;
        int*w;
    }bsort;
    bsort S;

    S.h=height;
    S.w=weight;

    int i,j,temp;
    for(i=0;i<=heightSize-1;i++)
        for(j=0;j<=heightSize-i-1;j++)
        {
            if((S.h[j]>S.h[j+1])||((S.h[j]==S.h[j+1])&&(S.w[j]>S.w[j+1])))
            {
                temp=S.h[j];
                S.h[j]=S.h[j+1];
                S.h[j+1]=temp;
                temp=S.w[j];
                S.w[j]=S.w[j+1];
                S.w[j+1]=temp;
            }    
        }
        return lengthOfLIS(S.w,weightSize);
}