通过执行给定的运算，可以从给定的矩阵获得最大和

给定尺寸为2 * N的矩阵arr [] [] ，任务是通过从每一列中选择最多一个元素，以使从同一行中不选择两个连续的元素，来使可能的总和最大化。

例子：

Input: arr[][] = {{1, 50, 21, 5}, {2, 10, 10, 5}}
Output: 67
Explanation: Elements arr[1][0]( = 2), arr[0][1]( = 50), arr[0][2]( = 10) and arr[0][3]( = 5) can be chosen. Therefore, sum = 2 + 50 + 10 + 5 = 67.

Input: arr[][] = {{9, 5, 3, 7, 3}, {50, 8, 1, 50, 5}}
Output: 108
Explanation: Elements arr[1][0]( = 50), arr[0][1]( = 5), arr[1][3]( = 50) and arr[0][4]( = 3) can be chosen. Therefore, sum = 50 + 5 + 50 + 3 = 108.

动态编程方法：使用动态编程可以解决该问题。请按照以下步骤解决问题：

• 初始化数组dp [] []以存储以下转换状态：

dp[0][i] = max(dp[1][i+1], dp[0][i+2]) + arr[0][i] 
dp[1][i] = max(dp[0][i+1], dp[1][i+2]) + arr[1][i] 
where, dp[j][i] stores the maximum possible sum to reach cell arr[j][i] starting from the last column where 0 <= i < N and 0 <= j < 2.

Base case: 
dp[0][N-1] = arr[0][N-1] 
dp[1][N-1] = arr[1][N-1]

• 从(N – 2)横移^列到^第0列和每行，更新DP [j]的[I]作为DP [j]的[I] = MAX(DP [(j ^ 1)] [i + 1的]，dp [j] [i + 2])+ arr [j] [i] ，其中^表示按位XOR。
• 完成遍历后，将max(dp [0] [0]，dp [1] [0])打印为最大可能和。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
#include 
using namespace std;
 
// Function to print the maximum sum
void maxSum(vector > arr,
            int n, int m)
{
 
    // Dp table
    vector > dp(n);
 
    // Intializing dp array with 0s
    for (int i = 0; i < 2; i++) {
        dp[i] = vector(m);
        for (int j = 0; j < m; j++) {
            dp[i][j] = 0;
        }
    }
 
    // Base case
    dp[0][m - 1] = arr[0][m - 1];
    dp[1][m - 1] = arr[1][m - 1];
 
    // Traverse each column
    for (int j = m - 2; j >= 0; j--) {
 
        // Update answer for both rows
        for (int i = 0; i < 2; i++) {
            if (i == 1) {
                dp[i][j] = max(
                    arr[i][j] + dp[0][j + 1],
                    arr[i][j] + dp[0][j + 2]);
            }
            else {
                dp[i][j] = max(
                    arr[i][j] + dp[1][j + 1],
                    arr[i][j] + dp[1][j + 2]);
            }
        }
    }
 
    // Print the maximum sum
    cout << max(dp[0][0], dp[1][0]);
}
 
// Driver Code
int main()
{
 
    // Given array
    vector > arr
        = { { 1, 50, 21, 5 },
            { 2, 10, 10, 5 } };
 
    // Number of Columns
    int N = arr[0].size();
 
    // Function calls
    maxSum(arr, 2, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function to print the maximum sum
static void maxSum(int[][] arr, int n, int m)
{
     
    // Dp table
    int[][] dp = new int[n][m + 1];
 
    // Intializing dp array with 0s
    for(int i = 0; i < 2; i++)
    {
        for(int j = 0; j <= m; j++)
        {
            dp[i][j] = 0;
        }
    }
 
    // Base case
    dp[0][m - 1] = arr[0][m - 1];
    dp[1][m - 1] = arr[1][m - 1];
 
    // Traverse each column
    for(int j = m - 2; j >= 0; j--)
    {
 
        // Update answer for both rows
        for (int i = 0; i < 2; i++)
        {
            if (i == 1)
            {
                dp[i][j] = Math.max(
                    arr[i][j] + dp[0][j + 1],
                    arr[i][j] + dp[0][j + 2]);
            }
            else
            {
                dp[i][j] = Math.max(
                    arr[i][j] + dp[1][j + 1],
                    arr[i][j] + dp[1][j + 2]);
            }
        }
    }
 
    // Print the maximum sum
    System.out.println(Math.max(dp[0][0],
                                dp[1][0]));
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    int[][] arr = { { 1, 50, 21, 5 },
                    { 2, 10, 10, 5 } };
 
    // Number of Columns
    int N = arr[0].length;
 
    // Function calls
    maxSum(arr, 2, N);
}
}
 
// This code is contributed by akhilsaini

Python3

# Python3 program for the above approach
 
# Function to prthe maximum sum
def maxSum(arr, n, m):
 
    # Dp table
    dp = [[0 for i in range(m + 1)]
             for i in range(2)]
 
    # Intializing dp array with 0s
    # for (i = 0 i < 2 i++) {
    #     dp[i] = vector(m)
    #     for (j = 0 j < m j++) {
    #         dp[i][j] = 0
    #     }
    # }
 
    # Base case
    dp[0][m - 1] = arr[0][m - 1]
    dp[1][m - 1] = arr[1][m - 1]
 
    # Traverse each column
    for j in range(m - 2, -1, -1):
 
        # Update answer for both rows
        for i in range(2):
            if (i == 1):
                dp[i][j] = max(arr[i][j] + dp[0][j + 1],
                               arr[i][j] + dp[0][j + 2])
            else:
                dp[i][j] = max(arr[i][j] + dp[1][j + 1],
                               arr[i][j] + dp[1][j + 2])
 
    # Print the maximum sum
    print(max(dp[0][0], dp[1][0]))
 
# Driver Code
if __name__ == '__main__':
 
    # Given array
    arr = [ [ 1, 50, 21, 5 ],
            [ 2, 10, 10, 5 ] ]
 
    # Number of Columns
    N = len(arr[0])
 
    # Function calls
    maxSum(arr, 2, N)
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to print the maximum sum
static void maxSum(int[, ] arr, int n, int m)
{
     
    // Dp table
    int[, ] dp = new int[n, m + 1];
 
    // Intializing dp array with 0s
    for(int i = 0; i < 2; i++)
    {
        for(int j = 0; j <= m; j++)
        {
            dp[i, j] = 0;
        }
    }
 
    // Base case
    dp[0, m - 1] = arr[0, m - 1];
    dp[1, m - 1] = arr[1, m - 1];
 
    // Traverse each column
    for(int j = m - 2; j >= 0; j--)
    {
         
        // Update answer for both rows
        for(int i = 0; i < 2; i++)
        {
            if (i == 1)
            {
                dp[i, j] = Math.Max(
                    arr[i, j] + dp[0, j + 1],
                    arr[i, j] + dp[0, j + 2]);
            }
            else
            {
                dp[i, j] = Math.Max(
                    arr[i, j] + dp[1, j + 1],
                    arr[i, j] + dp[1, j + 2]);
            }
        }
    }
 
    // Print the maximum sum
    Console.WriteLine(Math.Max(dp[0, 0],
                               dp[1, 0]));
}
 
// Driver Code
public static void Main()
{
     
    // Given array
    int[, ] arr = { { 1, 50, 21, 5 },
                    { 2, 10, 10, 5 } };
 
    // Number of Columns
    int N = arr.GetLength(1);
     
    // Function calls
    maxSum(arr, 2, N);
}
}
 
// This code is contributed by akhilsaini

输出：

67

时间复杂度： O(N)，其中N是列数。
辅助空间： O(N)

高效方法：按照以下步骤优化上述方法

1. 初始化两个变量r1和r2存储最大总和为1^次和^第2^点的行分别。
2. 遍历在该行的长度，即0到N – 1，对于每个元素ARR [I]，更新R1为r1 = MAX(R1，R2 + ARR [0] [1])和r2为r2 = MAX(R2 ，r1 + arr [1] [i]) 。
3. 遍历后，将max(r1，r2)打印为最大和。

下面是上述方法的实现：

C++

// C++ code for the above approach
#include 
using namespace std;
 
// Function to print the maximum sum
// possible by selecting at most one
// element from each column such that
// no consecutive pairs are selected
// from a single row
void maxSum(vector > arr, int n)
{
     
    // Initialize variables
    int r1 = 0, r2 = 0;
     
    // Traverse each column
    for(int i = 0; i < n; i++)
    {
         
        // r1, r2 = max(r1, r2 + arr[0][i]),
        // max(r2, r1 + arr[1][i])
        int temp = r1;
         
        r1 = max(r1, r2 + arr[0][i]);
        r2 = max(r2, temp + arr[1][i]);
    }
 
    // Print answer
    cout << max(r1, r2);
}
 
// Driver Code
int main()
{
    vector> arr = { { 1, 50, 21, 5 },
                                { 2, 10, 10, 5 } };
 
    // Numberof columns
    int n = arr[0].size();
 
    maxSum(arr, n);
 
    return 0;
}
 
// This code is contributed by akhilsaini

Java

// Java code for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function to print the maximum sum
// possible by selecting at most one
// element from each column such that
// no consecutive pairs are selected
// from a single row
static void maxSum(int[][] arr, int n)
{
     
    // Initialize variables
    int r1 = 0, r2 = 0;
 
    // Traverse each column
    for(int i = 0; i < n; i++)
    {
        int temp = r1;
         
        r1 = Math.max(r1, r2 + arr[0][i]);
        r2 = Math.max(r2, temp + arr[1][i]);
    }
 
    // Print answer
    System.out.println(Math.max(r1, r2));
}
 
// Driver Code
public static void main(String args[])
{
    int[][] arr = { { 1, 50, 21, 5 },
                    { 2, 10, 10, 5 } };
 
    // Numberof columns
    int n = arr[0].length;
 
    maxSum(arr, n);
}
}
 
// This code is contributed by akhilsaini

Python

# Python code for the above approach
 
# Function to print the maximum sum
# possible by selecting at most one
# element from each column such that
# no consecutive pairs are selected
# from a single row
 
def maxSum(arr, n):
 
    # Initialize variables
    r1 = r2 = 0
 
    # Traverse each column
    for i in range(n):
        r1, r2 = max(r1, r2 + arr[0][i]), max(r2, r1 + arr[1][i])
 
        # Print answer
    print(max(r1, r2))
 
 
# Driver Code
 
arr = [[1, 50, 21, 5], [2, 10, 10, 5]]
 
# Numberof columns
n = len(arr[0])
 
maxSum(arr, n)

C＃

// C# code for the above approach
using System;
 
class GFG{
 
// Function to print the maximum sum
// possible by selecting at most one
// element from each column such that
// no consecutive pairs are selected
// from a single row
static void maxSum(int[, ] arr, int n)
{
     
    // Initialize variables
    int r1 = 0, r2 = 0;
 
    // Traverse each column
    for(int i = 0; i < n; i++)
    {
        int temp = r1;
         
        r1 = Math.Max(r1, r2 + arr[0, i]);
        r2 = Math.Max(r2, temp + arr[1, i]);
    }
 
    // Print answer
    Console.WriteLine(Math.Max(r1, r2));
}
 
// Driver Code
public static void Main()
{
    int[, ] arr = { { 1, 50, 21, 5 },
                    { 2, 10, 10, 5 } };
 
    // Numberof columns
    int n = arr.GetLength(1);
 
    maxSum(arr, n);
}
}
 
// This code is contributed by akhilsaini

输出：

67

时间复杂度： O(N)，其中N是列数。
辅助空间： O(1)