📜  最长的交替子序列和最大和|套装2

📅  最后修改于: 2021-05-13 23:58:55             🧑  作者: Mango

给定大小为N的数组arr [] ,该数组由正整数和负整数组成,任务是从给定数组中找到最长的交替子序列(即,每个元素的符号与其前一个元素的符号相反)和。
例子:

使用多余空间的线性方法:
有关使用额外空间的线性方法,请参阅最长交替子序列,该子序列具有最大的元素总和。
时间复杂度: O(N)
辅助空间: O(N)
节省空间的方法:
为了解决该问题,我们可以观察以下内容:

  • 为了最大程度地增加交替子序列的长度,我们需要考虑序列中每个连续数的元素
  • 为了最大化子序列的总和,我们需要从相同符号的元素的每个连续子序列中选择最大值。

请按照以下步骤有效地解决问题:

  • 使用两个指针迭代数组。
  • 设置i = 0 ,并设置j = i
  • 遍历数组,直到j指向一个索引,该索引由与arr [i]相对正负号元素组成。每次遍历时,更新[i,j]之间遇到的最大元素。
  • 找到相反符号的元素后,将序列[i,j)中的最大值加到maxsum
  • 设置i = j ,并重复上述两个步骤,直到遍历整个数组。
  • 打印maxsum的最终值作为答案。

下面是上述方法的实现:

C++
// C++ Program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to check the
// sign of the element
int sign(int x)
{
    if (x > 0)
        return 1;
    else
        return -1;
}
 
// Function to calculate and
// return the maximum sum of
// longest alternating subsequence
int findMaxSum(int arr[], int size)
{
    int max_sum = 0, pres, i, j;
 
    // Iterate through the array
    for (i = 0; i < size; i++) {
 
        // Stores the first element of
        // a sequence of same sign
        pres = arr[i];
        j = i;
 
        // Traverse until an element with
        // opposite sign is encountered
        while (j < size
               && sign(arr[i])
                      == sign(arr[j])) {
 
            // Update the maximum
            pres = max(pres, arr[j]);
            j++;
        }
 
        // Update the maximum sum
        max_sum = max_sum + pres;
 
        // Update i
        i = j - 1;
    }
 
    // Return the maximum sum
    return max_sum;
}
 
// Driver Code
int main()
{
    int arr[] = { -2, 8, 3, 8, -4,
                  -15, 5, -2, -3, 1 };
 
    int size = sizeof(arr)
/ sizeof(arr[0]);
 
    cout << findMaxSum(arr, size);
 
    return 0;
}


Java
// Java Program to implement
// the above approach
import java.util.*;
class GFG{
 
    // Function to check the
    // sign of the element
    static int sign(int x)
    {
        if (x > 0)
            return 1;
        else
            return -1;
    }
 
    // Function to calculate and
    // return the maximum sum of
    // longest alternating subsequence
    static int findMaxSum(int arr[], int size)
    {
        int max_sum = 0, pres, i, j;
 
        // Iterate through the array
        for (i = 0; i < size; i++)
        {
 
            // Stores the first element of
            // a sequence of same sign
            pres = arr[i];
            j = i;
 
            // Traverse until an element with
            // opposite sign is encountered
            while (j < size &&
                   sign(arr[i]) == sign(arr[j]))
            {
 
                // Update the maximum
                pres = Math.max(pres, arr[j]);
                j++;
            }
 
            // Update the maximum sum
            max_sum = max_sum + pres;
 
            // Update i
            i = j - 1;
        }
 
        // Return the maximum sum
        return max_sum;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { -2, 8, 3, 8, -4, -15, 5, -2, -3, 1 };
 
        int size = arr.length;
 
        System.out.println(findMaxSum(arr, size));
    }
}
 
// This code is contributed by sapnasingh4991


Python
# Python3 program to implement
# the above approach
 
# Function to check the
# sign of the element
def sign(x):
 
    if (x > 0):
        return 1
    else:
        return -1
 
# Function to calculate and
# return the maximum sum of
# longest alternating subsequence
def findMaxSum(arr, size):
     
    max_sum = 0
 
    # Iterate through the array
    i = 0
    while i < size:
 
        # Stores the first element of
        # a sequence of same sign
        pres = arr[i]
        j = i
 
        # Traverse until an element with
        # opposite sign is encountered
        while (j < size and
              (sign(arr[i]) == sign(arr[j]))):
 
            # Update the maximum
            pres = max(pres, arr[j])
            j += 1
 
        # Update the maximum sum
        max_sum = max_sum + pres
 
        # Update i
        i = j - 1
        i += 1
 
    # Return the maximum sum
    return max_sum
 
# Driver Code
if __name__ == "__main__":
     
    arr = [ -2, 8, 3, 8, -4,
            -15, 5, -2, -3, 1 ]
 
    size = len(arr)
 
    print(findMaxSum(arr, size))
 
# This code is contributed by chitranayal


C#
// C# Program to implement
// the above approach
using System;
class GFG{
 
    // Function to check the
    // sign of the element
    static int sign(int x)
    {
        if (x > 0)
            return 1;
        else
            return -1;
    }
 
    // Function to calculate and
    // return the maximum sum of
    // longest alternating subsequence
    static int findMaxSum(int []arr, int size)
    {
        int max_sum = 0, pres, i, j;
 
        // Iterate through the array
        for (i = 0; i < size; i++)
        {
 
            // Stores the first element of
            // a sequence of same sign
            pres = arr[i];
            j = i;
 
            // Traverse until an element with
            // opposite sign is encountered
            while (j < size &&
                   sign(arr[i]) == sign(arr[j]))
            {
 
                // Update the maximum
                pres = Math.Max(pres, arr[j]);
                j++;
            }
 
            // Update the maximum sum
            max_sum = max_sum + pres;
 
            // Update i
            i = j - 1;
        }
 
        // Return the maximum sum
        return max_sum;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int []arr = { -2, 8, 3, 8, -4,
                     -15, 5, -2, -3, 1 };
 
        int size = arr.Length;
 
        Console.WriteLine(findMaxSum(arr, size));
    }
}
 
// This code is contributed by gauravrajput1


输出:
6






时间复杂度: O(N)
辅助空间: O(1)