# Hammered distance between N points in a 2-D plane

Given n number of point in 2-d plane followed by Xi, Yi describing n points. The task is to calculate the hammered distance of n points.
Note: Hammered distance is the sum of the square of the shortest distance between every pair of the point.

Examples:

Input: n = 3
0 1
0 0
1 0
Output: 4

Input: n = 4
1 0
2 0
3 0
4 0

Output: 20


## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Basic Approach:As we have to find out sum of square of shortest distance among all the pairs.So, we can take every possible pair and calculate the sum of square of distance.

// Pseudo code to find hammered-distance using above approach.
//this will store hammered distance
Distance=0
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
//shortest distance between point i and j.
Distance+=(x[i]-x[j])^2+(y[i]-y[j])^2
}
}


Its time complexity will be O(n^2).

Efficient Approach: This problem can be solved in time complexity of O(N). Below is the implementation of above approach:

## C++

 // C++ implementation of above approach  #include  #define ll long long int  using namespace std;     // Function calculate cummalative sum  // of x, y, x^2, y^2 coordinates.  ll cumm(vector& x, vector& y,          vector& cummx, vector& cummy,          vector& cummx2, vector& cummy2, ll n)  {      for (int i = 1; i <= n; i++) {          cummx[i] = cummx[i - 1] + x[i];          cummy[i] = cummy[i - 1] + y[i];          cummx2[i] = cummx2[i - 1] + x[i] * x[i];          cummy2[i] = cummy2[i - 1] + y[i] * y[i];      }  }     // Function ot calculate the hammered distance  int calHammeredDistance(int n, vector& x, vector& y)  {      // cummx conatins cummulative sum of x      // cummy conatins cummulative sum of y      vector cummx(n + 1, 0), cummy(n + 1, 0);         // cummx2 conatins cummulative sum of x^2      // cummy2 conatins cummulative sum of y^2      vector cummx2(n + 1, 0), cummy2(n + 1, 0);         // calculate cummalative of x      //, y, x^2, y^2, because these terms      // required in formula to reduce complexity.         // this function calculate all required terms.      cumm(x, y, cummx, cummy, cummx2, cummy2, n);         // hdx calculate hammer distance for x coordinate      // hdy calculate hammer distance for y coordinate      ll hdx = 0, hdy = 0;         for (int i = 1; i <= n; i++) {             // came from formula describe in explanation          hdx += (i - 1) * x[i] * x[i] + cummx2[i - 1]                 - 2 * x[i] * cummx[i - 1];             // came from formula describe in explanation          hdy += (i - 1) * y[i] * y[i] + cummy2[i - 1]                 - 2 * y[i] * cummy[i - 1];      }         // total is the sum of both x and y.      ll total = hdx + hdy;      return total;  }     // Driver code  int main()  {      // number of points      int n = 3;         // x contains the x coordinates      // y conatins the y coordinates      vector x(n + 1), y(n + 1);      x = { 0, 0, 1 };      y = { 1, 0, 0 };         cout << calHammeredDistance(n, x, y);         return 0;  }

## Java

 // Java implementation of above approach        class GFG{      // Function calculate cummalative sum  // of x, y, x^2, y^2 coordinates.  static void cumm(int [] x, int [] y,          int [] cummx, int [] cummy,          int [] cummx2, int [] cummy2, int n)  {      for (int i = 1; i <= n; i++) {          cummx[i] = cummx[i - 1] + x[i];          cummy[i] = cummy[i - 1] + y[i];          cummx2[i] = cummx2[i - 1] + x[i] * x[i];          cummy2[i] = cummy2[i - 1] + y[i] * y[i];      }  }      // Function ot calculate the hammered distance  static int calHammeredDistance(int n, int [] x, int [] y)  {      // cummx conatins cummulative sum of x      // cummy conatins cummulative sum of y      int []cummx = new int[n + 1];      int []cummy = new int[n + 1];          // cummx2 conatins cummulative sum of x^2      // cummy2 conatins cummulative sum of y^2      int []cummx2 = new int[n + 1];      int []cummy2 = new int[n + 1];          // calculate cummalative of x      //, y, x^2, y^2, because these terms      // required in formula to reduce complexity.          // this function calculate all required terms.      cumm(x, y, cummx, cummy, cummx2, cummy2, n);          // hdx calculate hammer distance for x coordinate      // hdy calculate hammer distance for y coordinate      int hdx = 0, hdy = 0;          for (int i = 1; i <= n; i++) {              // came from formula describe in explanation          hdx += (i - 1) * x[i] * x[i] + cummx2[i - 1]                 - 2 * x[i] * cummx[i - 1];              // came from formula describe in explanation          hdy += (i - 1) * y[i] * y[i] + cummy2[i - 1]                 - 2 * y[i] * cummy[i - 1];      }          // total is the sum of both x and y.      int total = hdx + hdy;      return total;  }      // Driver code  public static void main(String[] args)  {      // number of points      int n = 3;          // x contains the x coordinates      // y conatins the y coordinates      int []x = new int[n + 1];      int []y = new int[n + 1];      x = 1;      y = 1;          System.out.print(calHammeredDistance(n, x, y));      }  }     // This code contributed by Rajput-Ji

## Python3

 # Python3 implementation of the   # above approach      # Function calculate cummalative sum   # of x, y, x^2, y^2 coordinates.   def cumm(x, y, cummx, cummy,                  cummx2, cummy2, n):          for i in range(1, n+1):           cummx[i] = cummx[i - 1] + x[i]           cummy[i] = cummy[i - 1] + y[i]           cummx2[i] = cummx2[i - 1] + x[i] * x[i]           cummy2[i] = cummy2[i - 1] + y[i] * y[i]      # Function ot calculate the   # hammered distance   def calHammeredDistance(n, x, y):          # cummx conatins cummulative sum of x       # cummy conatins cummulative sum of y       cummx =  * (n + 1)      cummy =  * (n + 1)          # cummx2 conatins cummulative sum of x^2       # cummy2 conatins cummulative sum of y^2       cummx2 =  * (n + 1)      cummy2 =  * (n + 1)          # calculate cumulative of x , y, x^2, y^2,       # because these terms are required in the      # formula to reduce complexity.          # This function calculate all required terms.       cumm(x, y, cummx, cummy, cummx2, cummy2, n)          # hdx calculate hammer distance for x coordinate       # hdy calculate hammer distance for y coordinate       hdx, hdy = 0, 0        for i in range(1, n + 1):              # came from formula describe in explanation           hdx += ((i - 1) * x[i] * x[i] + cummx2[i - 1] -                              2 * x[i] * cummx[i - 1])             # came from formula describe in explanation           hdy += ((i - 1) * y[i] * y[i] + cummy2[i - 1] -                               2 * y[i] * cummy[i - 1])             # total is the sum of both x and y.       total = hdx + hdy       return total      # Driver Code  if __name__ == "__main__":         # number of points       n = 3        # x contains the x coordinates       # y conatins the y coordinates       x = [0, 0, 1, 0]       y = [1, 0, 0, 0]          print(calHammeredDistance(n, x, y))      # This code is contributed by Rituraj Jain

## C#

 // C# implementation of above approach  using System;     class GFG{       // Function calculate cummalative sum  // of x, y, x^2, y^2 coordinates.  static void cumm(int [] x, int [] y,          int [] cummx, int [] cummy,          int [] cummx2, int [] cummy2, int n)  {      for (int i = 1; i <= n; i++) {          cummx[i] = cummx[i - 1] + x[i];          cummy[i] = cummy[i - 1] + y[i];          cummx2[i] = cummx2[i - 1] + x[i] * x[i];          cummy2[i] = cummy2[i - 1] + y[i] * y[i];      }  }       // Function ot calculate the hammered distance  static int calHammeredDistance(int n, int [] x, int [] y)  {      // cummx conatins cummulative sum of x      // cummy conatins cummulative sum of y      int []cummx = new int[n + 1];      int []cummy = new int[n + 1];           // cummx2 conatins cummulative sum of x^2      // cummy2 conatins cummulative sum of y^2      int []cummx2 = new int[n + 1];      int []cummy2 = new int[n + 1];           // calculate cummalative of x      //, y, x^2, y^2, because these terms      // required in formula to reduce complexity.           // this function calculate all required terms.      cumm(x, y, cummx, cummy, cummx2, cummy2, n);           // hdx calculate hammer distance for x coordinate      // hdy calculate hammer distance for y coordinate      int hdx = 0, hdy = 0;           for (int i = 1; i <= n; i++) {               // came from formula describe in explanation          hdx += (i - 1) * x[i] * x[i] + cummx2[i - 1]                 - 2 * x[i] * cummx[i - 1];               // came from formula describe in explanation          hdy += (i - 1) * y[i] * y[i] + cummy2[i - 1]                 - 2 * y[i] * cummy[i - 1];      }           // total is the sum of both x and y.      int total = hdx + hdy;      return total;  }       // Driver code  public static void Main(String[] args)  {      // number of points      int n = 3;           // x contains the x coordinates      // y conatins the y coordinates      int []x = new int[n + 1];      int []y = new int[n + 1];      x = 1;      y = 1;           Console.Write(calHammeredDistance(n, x, y));    }  }     // This code is contributed by PrinciRaj1992

Output:

2


GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.