Sum of absolute difference of all pairs raised to power K
Last Updated :
02 Nov, 2023
Given an array arr[] of N integers and a number K, the task is to find the sum of absolute difference of all pairs raised to the power K in a given array i.e., .
Examples:
Input: arr[] = {1, 2, 3}, K = 1
Output: 8
Explanation:
Sum of |1-1|+|1-2|+|1-3|+|2-1|+|2-2|+|2-3|+|3-1|+|3-2|+|3-3| = 8
Input: arr[] = {1, 2, 3}, K = 3
Output: 20
Explanation:
Sum of |1 – 1| 3 + |1 – 2| 3 + |1 – 3| 3 + |2 – 1| 3 + |2 – 2| 3 + |2 – 3| 3 + |3 – 1| 3 + |3 – 2| 3 + |3 – 3| 3 = 20
Naive Approach: The idea is to generate all the possible pairs and find the absolute difference of each pair raised to the power K and sum up them together.
Time Complexity: O((log K)*N2)
Auxiliary Space: O(1)
Efficient Approach: We can improve the time complexity of the naive approach with the below calculations:
For all possible pair, we have to find the value of
Since for pairs (arr[i], arr[j]) the value of is being calculated twice. So the above equation can also be written as:
Writing in terms of Binomial Equation:
(Equation 1)
Let Pre[i][a] = (Equation 2)
From Equation 1 and Equation 2, we have
The value of Pre[i][a] can be calculated as:
Pre[i][a] = {(-arr[1])K – a + (-arr[2])K – a … . . +(-arr[i – 1])K – a}.
So, Pre[i+1][a] = Pre[i][a]+(-arr[i])K – a
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#define ll long long
using namespace std;
class Solution {
public :
ll ncr[101][101];
int n, k;
vector<ll> A;
Solution( int N, int K, vector<ll> B)
{
memset (ncr, -1, sizeof (ncr));
n = N;
k = K;
A = B;
A.insert(A.begin(), 0);
}
ll f( int N, int K);
ll pairsPower();
};
ll Solution::f( int n, int k)
{
if (k == 0)
return 1LL;
if (n == k)
return 1LL;
if (n < k)
return 0;
if (ncr[n][k] != -1)
return ncr[n][k];
return ncr[n][k] = f(n - 1, k)
+ f(n - 1, k - 1);
}
ll Solution::pairsPower()
{
ll pre[n + 1][k + 1];
ll ans = 0;
sort(A.begin() + 1, A.end());
for ( int i = 1; i <= n; ++i) {
pre[i][0] = 1LL;
for ( int j = 1; j <= k; j++) {
pre[i][j] = A[i]
* pre[i][j - 1];
}
if (i != 1) {
for ( int j = 0; j <= k; ++j)
pre[i][j] = pre[i][j]
+ pre[i - 1][j];
}
}
for ( int i = n; i >= 2; --i) {
for ( int j = 0; j <= k; j++) {
ll val = f(k, j);
ll val1 = pow (A[i], k - j)
* pre[i - 1][j];
val = val * val1;
if (j % 2 == 0)
ans = (ans + val);
else
ans = (ans - val);
}
}
ans = 2LL * ans;
return ans;
}
int main()
{
int N = 3;
int K = 3;
vector<ll> arr = { 1, 2, 3 };
Solution obj(N, K, arr);
cout << obj.pairsPower() << endl;
return 0;
}
|
Java
import java.util.*;
public class GFG{
static long [][] ncr = new long [ 101 ][];
static int n, k;
static long A[];
static long f( int n, int k)
{
if (k == 0 )
return ( long ) 1 ;
if (n == k)
return ( long ) 1 ;
if (n < k)
return 0 ;
if (ncr[n][k] != - 1 )
return ncr[n][k];
ncr[n][k] = f(n - 1 , k) + f(n - 1 , k - 1 );
return ncr[n][k];
}
static long pairsPower()
{
long [][] pre = new long [n + 1 ][];
long ans = 0 ;
for ( int i = 0 ; i <= n ; i++){
pre[i] = new long [k + 1 ];
}
Arrays.sort(A, 1 ,A.length);
for ( int i = 1 ; i <= n ; ++i) {
pre[i][ 0 ] = ( long ) 1 ;
for ( int j = 1 ; j <= k ; j++) {
pre[i][j] = A[i] * pre[i][j - 1 ];
}
if (i != 1 ) {
for ( int j = 0 ; j <= k ; ++j){
pre[i][j] = pre[i][j] + pre[i - 1 ][j];
}
}
}
for ( int i = n ; i >= 2 ; --i) {
for ( int j = 0 ; j <= k ; j++) {
long val = f(k, j);
long val1 = ( long )(Math.pow(A[i], k - j)) * pre[i - 1 ][j];
val = val * val1;
if (j % 2 == 0 )
ans = (ans + val);
else
ans = (ans - val);
}
}
ans = ( long )( 2 ) * ans;
return ans;
}
public static void main(String[] args){
n = 3 ;
k = 3 ;
for ( int i = 0 ; i <= 100 ; i++){
ncr[i] = new long [ 101 ];
for ( int j = 0 ; j <= 100 ; j++){
ncr[i][j] = - 1 ;
}
}
A = new long []{ 0 , 1 , 2 , 3 };
System.out.println(pairsPower());
}
}
|
Python3
class Solution:
def __init__( self , N, K, B):
self .ncr = []
for i in range ( 101 ):
temp = []
for j in range ( 101 ):
temp.append( - 1 )
self .ncr.append(temp)
self .n = N
self .k = K
self .A = [ 0 ] + B
def f( self , n, k):
if k = = 0 :
return 1
if n = = k:
return 1
if n < k:
return 0
if self .ncr[n][k] ! = - 1 :
return self .ncr[n][k]
self .ncr[n][k] = ( self .f(n - 1 , k) +
self .f(n - 1 , k - 1 ))
return self .ncr[n][k]
def pairsPower( self ):
pre = []
for i in range ( self .n + 1 ):
temp = []
for j in range ( self .k + 1 ):
temp.append( 0 )
pre.append(temp)
ans = 0
self .A.sort()
for i in range ( 1 , self .n + 1 ):
pre[i][ 0 ] = 1
for j in range ( 1 , self .k + 1 ):
pre[i][j] = ( self .A[i] *
pre[i][j - 1 ])
if i ! = 1 :
for j in range ( self .k + 1 ):
pre[i][j] = (pre[i][j] +
pre[i - 1 ][j])
for i in range ( self .n, 1 , - 1 ):
for j in range ( self .k + 1 ):
val = self .f( self .k, j)
val1 = ( pow ( self .A[i],
self .k - j) *
pre[i - 1 ][j])
val = val * val1
if j % 2 = = 0 :
ans = ans + val
else :
ans = ans - val
ans = 2 * ans
return ans
if __name__ = = '__main__' :
N = 3
K = 3
arr = [ 1 , 2 , 3 ]
obj = Solution(N, K, arr)
print (obj.pairsPower())
|
C#
using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{
static long [][] ncr = new long [101][];
static int n, k;
static List< long > A;
static long f( int n, int k)
{
if (k == 0)
return ( long )1;
if (n == k)
return ( long )1;
if (n < k)
return 0;
if (ncr[n][k] != -1)
return ncr[n][k];
ncr[n][k] = f(n - 1, k) + f(n - 1, k - 1);
return ncr[n][k];
}
static long pairsPower()
{
long [][] pre = new long [n + 1][];
long ans = 0;
for ( int i = 0 ; i <= n ; i++){
pre[i] = new long [k + 1];
}
A.Sort(1, A.Count - 1, Comparer< long >.Default);
for ( int i = 1 ; i <= n ; ++i) {
pre[i][0] = ( long )1;
for ( int j = 1 ; j <= k ; j++) {
pre[i][j] = A[i] * pre[i][j - 1];
}
if (i != 1) {
for ( int j = 0 ; j <= k ; ++j){
pre[i][j] = pre[i][j] + pre[i - 1][j];
}
}
}
for ( int i = n ; i >= 2 ; --i) {
for ( int j = 0 ; j <= k ; j++) {
long val = f(k, j);
long val1 = ( long )(Math.Pow(A[i], k - j)) * pre[i - 1][j];
val = val * val1;
if (j % 2 == 0)
ans = (ans + val);
else
ans = (ans - val);
}
}
ans = ( long )(2) * ans;
return ans;
}
public static void Main( string [] args){
n = 3;
k = 3;
for ( int i = 0 ; i <= 100 ; i++){
ncr[i] = new long [101];
for ( int j = 0 ; j <= 100 ; j++){
ncr[i][j] = -1;
}
}
A = new List< long >{ 0, 1, 2, 3 };
Console.WriteLine(pairsPower());
}
}
|
Javascript
function f(n, k)
{
if (k == 0)
return 1;
if (n == k)
return 1;
if (n < k)
return 0;
if (ncr[n][k] != -1)
return ncr[n][k];
ncr[n][k] = f(n - 1, k) + f(n - 1, k - 1);
return ncr[n][k];
}
function pairsPower()
{
let pre=[];
let ans=0;
for (let i = 0 ; i <= n ; i++){
let temp=[];
for (let j = 0 ; j <= k; j++){
temp.push(0);
}
pre.push(temp);
}
A.sort();
for (let i = 1 ; i <= n ; ++i) {
pre[i][0] = 1;
for (let j = 1 ; j <= k ; j++) {
pre[i][j] = A[i] * pre[i][j - 1];
}
if (i != 1) {
for (let j = 0 ; j <= k ; ++j){
pre[i][j] = pre[i][j] + pre[i - 1][j];
}
}
}
for (let i = n ; i >= 2 ; --i) {
for (let j = 0 ; j <= k ; j++) {
let val = f(k, j);
let val1 = (Math.pow(A[i], k - j)) * pre[i - 1][j];
val = val * val1;
if (j % 2 == 0)
ans = (ans + val);
else
ans = (ans - val);
}
}
ans = (2) * ans;
return ans;
}
let n = 3;
let k = 3;
let ncr = [];
for (let i = 0 ; i <= 100 ; i++){
let temp=[];
for (let j = 0 ; j <= 100 ; j++){
temp.push(-1);
}
ncr.push(temp);
}
A = [0, 1, 2, 3];
console.log(pairsPower());
|
Time Complexity: O(N*K)
Auxiliary Space: O(N*K)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...