Codeforces Round 775(Div.2) C. Weird Sum

C. Weird Sum

time limit per test

2 seconds

memory limit per test

256 megabytes

Egor has a table of size $ n \times m$, with lines numbered from $1$ to $n$ and columns numbered from $1 $to $m$. Each cell has a color that can be presented as an integer from$ 1 $to $10^5.$

Let us denote the cell that lies in the intersection of the r-th row and the c-th column as (r, c). We define the manhattan distance between two cells $(r_1,c_1)$ and $(r_2,c_2)$as the length of a shortest path between them where each consecutive cells in the path must have a common side. The path can go through cells of any color. For example, in the table $3\times 4$ the manhattan distance between$(1,2)$ and$(3,3)$is 3, one of the shortest paths is the following:$(1,2)\to (2,2)\to (2,3)\to (3,3)$.

Egor decided to calculate the sum of manhattan distances between each pair of cells of the same color. Help him to calculate this sum.

Input

The first line contains two integers n and m $(1\le n\le m,n\cdot m\le 100000)$ — number of rows and columns in the table.

Each of next n lines describes a row of the table. The i-th line contains m integers $c_{i1},c_{i2},\dots ,c_{im}(1\le c_{ij}\le 100000)$— colors of cells in the i-th row.

Output

Print one integer — the the sum of manhattan distances between each pair of cells of the same color.

Examples

input

2 3
1 2 3
3 2 1

output

7

input

3 4
1 1 2 2
2 1 1 2
2 2 1 1

output

Copy

76

input

4 4
1 1 2 3
2 1 1 2
3 1 2 1
1 1 2 1

output

129

Note

In the first sample there are three pairs of cells of same color: in cells $(1,1)$ and $(2,3)$, in cells $(1,2)$ and $(2,2)$, in cells $(1,3)$ and$ (2, 1)$. The manhattan distances between them are 3, 1 and 3, the sum is 7.

We note that the manhattan distance between cells$(r_1,c_1)$and $(r_2,c_2)$ is equal to$|r_1-r_2|+|c_1-c_2|$ For each color we will compose a list of all cells$(r_0,c_0)$, \ldots, $(r_{k-1},c_{k-1})$of this color, compute the target sum for this color, and sum up the answers for all colors. The sum is equal:

${\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}|r_i-r_j|+|c_i-c_j|=\left({\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}|r_i-r_j|\right)+\left({\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}|c_i-c_j|\right)$

r理解为x，c理解为y，可以分开求

We will compute the first sum, the second sum is analogous. Let an array $s$ be equal to r, but sorted in increasing order. Then:

对r数组排序，得到s，因为排序了所以绝对值$r_j-r_i$一定是正的，可以去掉绝对值，，接着拆开

${\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}|r_i-r_j|={\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}{s}_j-s_i=\left({\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}{s}_j\right)+\left({\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}-s_i\right)$

The value $s_j$ occurs in the first double sum exactly $j$ times, the value $-s_i$occurs in the second sum exactly $k-1-i$times. Then, the value is equal to:

前面部分，$\left({\sum }_{i=0}^{k-1}{\sum }_{j=i+1}^{k-1}{s}_j\right)$ 因为只有j没有i，

我们考虑化简，我们写出循环，可以化为${\sum }_{j=0}^{k-1}j{s}_j$

后面部分，只有i，所以j可以直接代进去,上面k-1，下面j=i+1，相减再加一， $k-1-i$个$s_i$

${\sum }_{j=0}^{k-1}j{s}_j+{\sum }_{i=0}^{k-1}-(k-1-i)s_i={\sum }_{i=0}^{k-1}(2i+1-k)s_i$

The last sum can be computed in O(k), the time complexity to sort an array is $O(k\log k)$. The overall complexity is O(nm\log(nm)). We can also sort arrays of coordinates by adding cells to lists in the right order. This yields an O(nm) solution.

所以就是算最后一条式子。

x,y遍历一遍就好

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
typedef unsigned long long ll;
using namespace std;
int x, y;
set<int >se;//存颜色
vector<pair<int, int > > a[1000003];//存xy

bool cmp(pair<int, int> a, pair<int, int > b) {
	return a.first < b.first;
}

bool cmp2(pair<int, int> a, pair<int, int > b) {
	return a.second < b.second;
}

int main() {
	cin >> x >> y;
	int tmp;
	for (int i = 1; i <= x; i++) {
		for (int j = 1; j <= y; j++) {
			cin >> tmp;
			se.insert(tmp);
			a[tmp].push_back({i, j});
		}
	}
	ll res = 0;
	int sum = se.size();
	//cout<<sum<<endl;
	for (auto c : se) {
		sort(a[c].begin(), a[c].end(), cmp);
		int len = a[c].size();
		for (int i = 0; i < len; i++) {
			res += (2 * i + 1 - len) * 1LL * a[c][i].first;
		}
		//cout<<res<<endl;
		sort(a[c].begin(), a[c].end(), cmp2);
		for (int i = 0; i < len; i++) {
			res += (2 * i + 1 - len) * 1LL * a[c][i].second;
		}
	}
	cout << res;

}