CodeForces - 236D. Devu and his Brother

D. Devu and his Brother

time limit per test: 1 second
memory limit per test: 256 megabytes
input: standard input
output: standard output

Devu and his brother love each other a lot. As they are super geeks, they only like to play with arrays. They are given two arrays a and b by their father. The array a is given to Devu and b to his brother.

As Devu is really a naughty kid, he wants the minimum value of his array a should be at least as much as the maximum value of his brother’s array b.

Now you have to help Devu in achieving this condition. You can perform multiple operations on the arrays. In a single operation, you are allowed to decrease or increase any element of any of the arrays by 1. Note that you are allowed to apply the operation on any index of the array multiple times.

You need to find minimum number of operations required to satisfy Devu’s condition so that the brothers can play peacefully without fighting.

Input

The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105). The second line will contain n space-separated integers representing content of the array a (1 ≤ ai ≤ 109). The third line will contain m space-separated integers representing content of the array b (1 ≤ bi ≤ 109).

Output

You need to output a single integer representing the minimum number of operations needed to satisfy Devu’s condition.

Examples

input
2 2
2 3
3 5
output
3
input
3 2
1 2 3
3 4
output
4
input
3 2
4 5 6
1 2
output
0

Note

In example 1, you can increase a1 by 1 and decrease b2 by 1 and then again decrease b2 by 1. Now array a will be [3; 3] and array b will also be [3; 3]. Here minimum element of a is at least as large as maximum element of b. So minimum number of operations needed to satisfy Devu’s condition are 3.

In example 3, you don’t need to do any operation, Devu’s condition is already satisfied.

Tips

题意：
给定两个序列 $a[1..n]$ 和 $b[1..m]$ ，现在你可以做两种操作：把其中一个序列的某一个数值增加或者减少 $1$ ，重复若干次，使得序列 $a$ 中的任意一个数都不比序列 $b$ 中任意一个数字小。问操作数的最小值。

题解：
依题意，取 $a$ 中的最小值 $a_i$ 和 $b$ 中的最大值 $b_j$ ，如果满足 $a_i<b_j$ ，则需要做一些调整，使得 $a_i^{\prime }⩾b_j^{\prime }$ 。由于要操作数最少，显然有 $a_i^{\prime }=b_j^{\prime }$ 。此时所需的操作数为 $(a_i^{\prime }-a_i)+(b_j-b_j^{\prime })=b_j-a_i$ 。然后重复刚才的操作，直到满足 $a_{\min }⩾b_{\max }$ 为止。

在实际操作的时候，只需将 $a$ 升序排列， $b$ 降序排列，从头遍历，遇见 $a_i<b_i$ 则累计差值，否则停止遍历，输出结果。

Reference Code

#include <cstdio>
#include <algorithm>
#include <functional>
using std::sort;
using std::greater;
typedef long long ll;
const int MAXN=1e5+10;
int n,m;
int a[MAXN],b[MAXN];
ll solve(){
	sort(a,a+n);
	sort(b,b+m,greater<int>());
	ll res=0;
	for (int i=0;i<n&&i<m;++i){
		if (b[i]<=a[i]) break;
		res+=b[i]-a[i];
	}
	return res;
}
int main(){
	scanf("%d%d",&n,&m);
	for (int i=0;i<n;++i)
		scanf("%d",&a[i]);
	for (int i=0;i<m;++i)
		scanf("%d",&b[i]);
	printf("%lld\n",solve());
	return 0;
}