通过交换相同索引处的元素来最小化给定数组的平方和

给定两个数组arrA[]和arrB[] ，每个数组包含N个整数。执行以下操作任意次数（可能为零）：

• 选择任何索引 i (0 <= i <= N-1) 和
• 交换arrA[i]和arrB[i] 。

任务是找到数组和的平方和的最小和，即如果Sa和Sb是交换后arrA[]和arrB []的数组和，则找到(Sa) ² + (Sb) ²的最小可能值.

例子：

Input : N = 4, arrA[ ] = { 3, 6, 6, 6 }, arrB[ ] = { 2, 7, 4, 1 }
Output: 613
Explanation : 
If we perform the operation for i = 0 and i = 2, we get the resultant arrays as arrA[] = { 2, 6, 4, 6 } and arrB[] = { 3, 7, 6, 1 }. 
Thus Sa = 18 and Sb = 17. 
So, sum of there squares is (18)² + (17)² = 613, which is the minimum possible.

Input : N = 4, arrA[ ] = { 6, 7, 2, 4 }, arrB[ ] = { 2, 5, 3, 5 }
Output: 578

天真的方法：天真的方法是检查所有可能的情况。对于每个索引：

• 要么交换该索引的那些元素，要么不交换。
  • 计算数组的总和。
  • 求数组和的平方和的值。
• 值的最小值就是答案。

时间复杂度： O(2 ^N * N)
辅助空间： O(1)

高效方法：高效方法基于以下思想：

Use memoization to store the already calculated result up to an index and some array sum which will prevent repeated calculation and reduce the overall time.

按照下面提到的步骤来实现上述想法：

• 创建一个 dp[] 数组来存储计算得出的数组 sum 的平方和，直到某个索引i和数组总和Sa和Sb 。
• 对于每个索引，有两种选择：交换元素或不交换元素。
• 递归执行此交换操作，并且：
  • 如果对于任何索引，该值已经计算，则返回该值。
  • 否则，计算总和并存储该索引可能的最小值。
• 返回所有人中的最小总和作为答案。

下面是上述方法的实现。

C++

// C++ code to implement the above approach
 
#include 
using namespace std;
 
// Using map of vector and int in place of
// multidimensional array to store calculated
// values to prevent memory limitexceed error
map, int> dp;
 
// Function to find min total square of sum
// from both arrays
int min_total_square_sum(int arrA[], int arrB[],
                         int i, int Sa,
                         int Sb, int n)
{
    // Base case
    if (i >= n) {
        int temp = Sa * Sa + Sb * Sb;
 
        return temp;
    }
 
    vector v = { i, Sa, Sb };
 
    // If already calculated directly
    // return the stored value
    if (dp.count(v)) {
        return dp[v];
    }
 
    // Case-1: when we don't swap the elements
    int t1 = min_total_square_sum(
        arrA, arrB, i + 1, Sa + arrA[i],
        Sb + arrB[i], n);
 
    // Case-2: when we swap the elements
    int t2 = min_total_square_sum(
        arrA, arrB, i + 1, Sa + arrB[i],
        Sb + arrA[i], n);
 
    // Returning minimum of the two cases
    return dp[v] = min(t1, t2);
}
 
// Driver code
int main()
{
    int N = 4;
    int arrA[] = { 6, 7, 2, 4 };
    int arrB[] = { 2, 5, 3, 5 };
 
    int Sa{ 0 }, Sb{ 0 };
 
    // Function call
    cout << min_total_square_sum(arrA, arrB,
                                 0, Sa, Sb, N);
    return 0;
}

Python3

# Python3 code to implement the above approach
 
# Using map of vector and int in place of
# multidimensional array to store calculated
# values to prevent memory limitexceed error
dp = {}
 
# Function to find min total square of sum
# from both arrays
def min_total_square_sum(arrA, arrB, i, Sa, Sb, n):
 
        # Base case
    if (i >= n):
        temp = Sa * Sa + Sb * Sb
        return temp
 
    v = (i, Sa, Sb)
 
    # If already calculated directly
    # return the stored value
    if (v in dp):
        return dp[v]
 
        # Case-1: when we don't swap the elements
    t1 = min_total_square_sum(arrA, arrB, i + 1, Sa + arrA[i],
                              Sb + arrB[i], n)
 
    # Case-2: when we swap the elements
    t2 = min_total_square_sum(arrA, arrB, i + 1, Sa + arrB[i],
                              Sb + arrA[i], n)
 
    # Returning minimum of the two cases
    dp[v] = min(t1, t2)
    return dp[v]
 
# Driver code
if __name__ == "__main__":
 
    N = 4
    arrA = [6, 7, 2, 4]
    arrB = [2, 5, 3, 5]
 
    Sa, Sb = 0, 0
 
    # Function call
    print(min_total_square_sum(arrA, arrB, 0, Sa, Sb, N))
 
    # This code is contributed by rakeshsahni

Javascript

     // JavaScript code for the above approach
 
     // Using map of vector and int in place of
     // multidimensional array to store calculated
     // values to prevent memory limitexceed error
     let dp = new Map();
 
     // Function to find min total square of sum
     // from both arrays
     function min_total_square_sum(arrA, arrB,
         i, Sa, Sb, n)
     {
      
         // Base case
         if (i >= n) {
             let temp = Sa * Sa + Sb * Sb;
 
             return temp;
         }
 
         let v = [i, Sa, Sb];
 
         // If already calculated directly
         // return the stored value
         if (dp.has(v)) {
             return dp.get(vs);
         }
 
         // Case-1: when we don't swap the elements
         let t1 = min_total_square_sum(
             arrA, arrB, i + 1, Sa + arrA[i],
             Sb + arrB[i], n);
 
         // Case-2: when we swap the elements
         let t2 = min_total_square_sum(
             arrA, arrB, i + 1, Sa + arrB[i],
             Sb + arrA[i], n);
 
         // Returning minimum of the two cases
         dp.set(v, Math.min(t1, t2))
         return dp.get(v);
     }
 
     // Driver code
     let N = 4;
     let arrA = [6, 7, 2, 4];
     let arrB = [2, 5, 3, 5];
 
     let Sa = 0, Sb = 0;
 
     // Function call
     document.write(min_total_square_sum(arrA, arrB,
         0, Sa, Sb, N));
 
// This code is contributed by Potta Lokesh
 
 

输出

578

时间复杂度： O(N ³ )
辅助空间： O(N ³ )