2016. Maximum Difference Between Increasing Elements增量元素之间的最大差值

Given a 0-indexed integer array nums of size n, find the maximum difference between nums[i] and nums[j] (i.e., nums[j] - nums[i]), such that 0 <= i < j < n and nums[i] < nums[j].

Return the maximum differenceIf no such i and j exists, return -1.

Example 1:

Input: nums = [7,1,5,4]
Output: 4
Explanation:
The maximum difference occurs with i = 1 and j = 2, nums[j] - nums[i] = 5 - 1 = 4.
Note that with i = 1 and j = 0, the difference nums[j] - nums[i] = 7 - 1 = 6, but i > j, so it is not valid.

Example 2:

Input: nums = [9,4,3,2]
Output: -1
Explanation:
There is no i and j such that i < j and nums[i] < nums[j].

Example 3:

Input: nums = [1,5,2,10]
Output: 9
Explanation:
The maximum difference occurs with i = 0 and j = 3, nums[j] - nums[i] = 10 - 1 = 9.

Constraints:

  • n == nums.length
  • 2 <= n <= 1000
  • 1 <= nums[i] <= 109
/**
 * @param {number[]} nums
 * @return {number}
 */
var maximumDifference = function(nums) {
    let maxNum=0
    const len=nums.length
    for(let i=1;i<len;i++){
        for(let j=0;j<i;j++){
            let diff=nums[i]-nums[j]
            if(diff>maxNum){
                maxNum=diff
            }
        }
    }
    if(maxNum===0){
        return -1
    }else{
        return maxNum
    }
};

看了答案,原来还有更好的做法

/**
 * @param {number[]} nums
 * @return {number}
 */
var maximumDifference = function(nums) {
    let len=nums.length
    let tempMin=nums[0]
    let ans=0
    for(let i=0;i<len;i++){
        if((nums[i]-tempMin)>ans){
            ans=nums[i]-tempMin
        }
        if(nums[i]<tempMin){
            tempMin=nums[i]
        }
        
    }
    if(ans===0){
        return -1
    }else{
        
    return ans
    }
};

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Maximum Sum Increasing Subsequence (最大上升子序列和)问题可以使用动态规划来解决,以下是使用C语言实现的代码: ```c #include <stdio.h> int max(int a, int b) { return a > b ? a : b; } int maxSumIncreasingSubsequence(int arr[], int n) { int i, j, maxSum = 0; int dp[n]; // 初始化dp数组为每个元素自身 for(i = 0; i < n; i++) { dp[i] = arr[i]; } // 动态规划计算最大上升子序列和 for(i = 1; i < n; i++) { for(j = 0; j < i; j++) { if(arr[j] < arr[i]) { dp[i] = max(dp[i], dp[j] + arr[i]); } } } // 找到dp数组中的最大值 for(i = 0; i < n; i++) { if(maxSum < dp[i]) { maxSum = dp[i]; } } return maxSum; } int main() { int arr[] = {1, 101, 2, 3, 100, 4, 5}; int n = sizeof(arr) / sizeof(arr[0]); printf("最大上升子序列和为 %d", maxSumIncreasingSubsequence(arr, n)); return 0; } ``` 输出结果为: ``` 最大上升子序列和为 106 ``` 上述代码中,首先定义了一个 `max` 函数,用于比较两个数中的较大值。然后定义了一个 `maxSumIncreasingSubsequence` 函数,用于计算最大上升子序列和。该函数使用一个一维数组 `dp` 来记录从第一个元素到当前元素最大上升子序列和。在初始化 `dp` 数组时,将每个元素的值初始化为自身;然后使用两层循环遍历数组,如果当前元素大于前面的元素,则将 `dp[i]` 更新为 `dp[j] + arr[i]` 的较大值;最后在 `dp` 数组中找到最大值即为最大上升子序列和。最后在 `main` 函数中定义一个整型数组 `arr`,并计算其最大上升子序列和并输出。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值