数组中的最大和，使得每个元素都恰好有一个与之相邻的元素

给定一个由N 个整数组成的数组arr[] ，您可以选择一些索引，使得每个选定的索引正好有一个与之相邻的其他选定索引，并且所选索引处的元素总和应该是最大的。
换句话说，任务是从数组中选择元素，这样就不会单独选择单个元素，也不会选择三个连续索引处的元素，并且所选元素的总和应该是最大的。
任务是打印最大化的总和。

例子：

Input: arr[] = {1, 2, 3, 1, 4} 
Output: 8 
arr[0] + arr[1] + arr[3] + arr[4] = 1 + 2 + 1 + 4 = 8
Input: arr[] = {1, 1, 1, 1} 
Output: 2  

方法：可以使用动态规划来解决这个问题。这个问题可以转化为选择相邻整数对，使得没有两对相邻或具有共同的元素
即如果(arr[i], arr[i + 1])是我们选择的一对，那么(arr[i + 2], arr[i + 3])和(arr[i + 1], arr[i + 2])可以选择。
让我们根据上面的语句来决定 dp 的状态。
对于每个索引i ，我们将选择索引i和i + 1即成对或不成对。如果我们创建一对，我们将无法选择索引i + 2 ，因为它将使 2 个元素与i + 1相邻。所以，接下来我们必须解决i + 3 。如果我们不配对，我们将简单地求解i + 1 。
所以递归关系将是。

dp[i] = max(arr[i] + arr[i + 1] + dp[i + 3], dp[i + 1]) 

总共有N个状态，每个状态需要 O(1) 时间来解决。因此，时间复杂度将为O(N) 。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
#define arrSize 51
using namespace std;
 
// To store the states of dp
int dp[arrSize];
bool v[arrSize];
 
// Function to return the maximized sum
int sumMax(int i, int arr[], int n)
{
    // Base case
    if (i >= n - 1)
        return 0;
 
    // Checks if a state is
    // already solved
    if (v[i])
        return dp[i];
    v[i] = true;
 
    // Recurrence relation
    dp[i] = max(arr[i] + arr[i + 1]
                    + sumMax(i + 3, arr, n),
                sumMax(i + 1, arr, n));
 
    // Return the result
    return dp[i];
}
 
// Driver code
int main()
{
    int arr[] = { 1, 1, 1, 1 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << sumMax(0, arr, n);
 
    return 0;
}

Java

// Java implementation of the approach
import java.io.*;
 
class GFG
{
 
static int arrSize = 51;
 
// To store the states of dp
static int dp[] = new int[arrSize];
static boolean v[] = new boolean[arrSize];
 
// Function to return the maximized sum
static int sumMax(int i, int arr[], int n)
{
    // Base case
    if (i >= n - 1)
        return 0;
 
    // Checks if a state is
    // already solved
    if (v[i])
        return dp[i];
    v[i] = true;
 
    // Recurrence relation
    dp[i] = Math.max(arr[i] + arr[i + 1]
                    + sumMax(i + 3, arr, n),
                sumMax(i + 1, arr, n));
 
    // Return the result
    return dp[i];
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = { 1, 1, 1, 1 };
    int n = arr.length;
 
    System.out.println(sumMax(0, arr, n));
}
}
 
// This code is contributed by anuj_67..

Python3

# Python 3 implementation of the approach
arrSize = 51
 
# To store the states of dp
dp = [0 for i in range(arrSize)]
v = [False for i in range(arrSize)]
 
# Function to return the maximized sum
def sumMax(i,arr,n):
    # Base case
    if (i >= n - 1):
        return 0
 
    # Checks if a state is
    # already solved
    if (v[i]):
        return dp[i]
    v[i] = True
    # Recurrence relation
    dp[i] = max(arr[i] + arr[i + 1] + sumMax(i + 3, arr, n),
                                        sumMax(i + 1, arr, n))
    # Return the result
    return dp[i]
 
# Driver code
if __name__ == '__main__':
    arr = [1, 1, 1, 1]
    n = len(arr)
    print(sumMax(0, arr, n))
 
# This code is contributed by
# Surendra_Gangwar

C#

// C# implementation of the approach
using System;
 
class GFG
{
 
static int arrSize = 51;
 
// To store the states of dp
static int []dp = new int[arrSize];
static bool []v = new bool[arrSize];
 
// Function to return the maximized sum
static int sumMax(int i, int []arr, int n)
{
    // Base case
    if (i >= n - 1)
        return 0;
 
    // Checks if a state is
    // already solved
    if (v[i])
        return dp[i];
    v[i] = true;
 
    // Recurrence relation
    dp[i] = Math.Max(arr[i] + arr[i + 1]
                    + sumMax(i + 3, arr, n),
                sumMax(i + 1, arr, n));
 
    // Return the result
    return dp[i];
}
 
// Driver code
public static void Main ()
{
    int []arr = { 1, 1, 1, 1 };
    int n = arr.Length;
 
    Console.WriteLine(sumMax(0, arr, n));
}
}
 
// This code is contributed by anuj_67..

Javascript

 
// Javascript implementation of the approach
var arrSize = 51;
 
// To store the states of dp
var dp = Array(arrSize);
var v = Array(arrSize);
 
// Function to return the maximized sum
function sumMax(i, arr, n)
{
    // Base case
    if (i >= n - 1)
        return 0;
 
    // Checks if a state is
    // already solved
    if (v[i])
        return dp[i];
    v[i] = true;
 
    // Recurrence relation
    dp[i] = Math.max(arr[i] + arr[i + 1]
                    + sumMax(i + 3, arr, n),
                sumMax(i + 1, arr, n));
 
    // Return the result
    return dp[i];
}
 
// Driver code
var arr = [1, 1, 1, 1];
var n = arr.length;
document.write( sumMax(0, arr, n));
 

输出：

2

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。