text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int a[2000 + 7], o[2000 + 5], e[2000 + 5];
int main() {
long long n, x = 0, y = 0, s = 0, f = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2)
o[x++] = a[i];
else
e[y++] = a[i];
}
if (x == y || abs(x - y) == 1) {
cout << 0 << endl;
return 0;
}
sort(o, o + x);
sort(e, e + y);
int k = min(x, y);
for (int i = 0; i < x - k; i++) {
s += o[i];
}
for (int i = 0; i < y - k; i++) {
s += e[i];
}
if (x < y)
s -= e[y - k - 1];
else
s -= o[x - k - 1];
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238460;
const long long mod = 1e9 + 7;
void FAST() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.second);
}
void solve() {
int n;
cin >> n;
vector<int> even, odd, sol;
for (__typeof(n) i = (0) - (0 > n); i != (n) - (0 > n);
i += 1 - 2 * (0 > n)) {
int x;
cin >> x;
if (x & 1)
odd.push_back(x);
else
even.push_back(x);
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
int x = min(even.size(), odd.size());
while (x--) {
odd.pop_back();
even.pop_back();
}
if (odd.size() > even.size())
odd.pop_back();
else if (odd.size() < even.size())
even.pop_back();
int sum = 0;
for (auto x : even) sum += x;
for (auto x : odd) sum += x;
cout << sum << '\n';
}
int main() {
FAST();
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
priority_queue<int> num[2], num2[2];
int n, x;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
if (x % 2)
num[1].push(x), num2[1].push(x);
else
num[0].push(x), num2[0].push(x);
}
int cur = 1;
while (!num[cur].empty()) {
num[cur].pop();
cur ^= 1;
}
long long res = 0;
while (!num[cur].empty()) res += num[cur].top(), num[cur].pop();
cur ^= 1;
while (!num[cur].empty()) res += num[cur].top(), num[cur].pop();
long long ans = res;
res = 0, cur = 0;
while (!num2[cur].empty()) {
num2[cur].pop();
cur ^= 1;
}
while (!num2[cur].empty()) res += num2[cur].top(), num2[cur].pop();
cur ^= 1;
while (!num2[cur].empty()) res += num2[cur].top(), num2[cur].pop();
printf("%lld\n", min(ans, res));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = 0;
vector<long long> even;
vector<long long> odd;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
if (k % 2 != 0) {
odd.push_back(k);
} else {
even.push_back(k);
}
}
for (long long i = 0; i < even.size(); i++) {
sum += even[i];
}
sum = 0;
sort(odd.begin(), odd.end(), greater<long long>());
sort(even.begin(), even.end(), greater<long long>());
if (odd.size() > even.size()) {
for (long long i = even.size() + 1; i < odd.size(); i++) sum += odd[i];
}
if (even.size() > odd.size()) {
for (long long i = odd.size() + 1; i < even.size(); i++) {
sum += even[i];
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
int compare(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int main() {
int n;
scanf("%d", &n);
int even[n], odd[n];
memset(even, 0, n * sizeof(int));
memset(odd, 0, n * sizeof(int));
int number, i, j = 0, k = 0;
for (i = 0; i < n; i++) {
scanf("%d", &number);
if (number % 2)
odd[j++] = number;
else
even[k++] = number;
}
int diff = abs(j - k);
if (diff <= 1) {
printf("0\n");
} else {
int sum = 0;
if (j > k) {
qsort(odd, j, sizeof(int), compare);
for (i = 0; i < diff - 1; i++) sum += odd[i];
} else if (j < k) {
qsort(even, k, sizeof(int), compare);
for (i = 0; i < diff - 1; i++) sum += even[i];
}
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> even, odd;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0)
even.push_back(a[i]);
else
odd.push_back(a[i]);
}
int diff = abs((int)even.size() - (int)odd.size()) - 1;
ll res = 0;
if ((int)even.size() > (int)odd.size()) {
sort(even.begin(), even.end());
for (int i = 0; i < diff; i++) res += even[i];
} else {
sort(odd.begin(), odd.end());
for (int i = 0; i < diff; i++) res += odd[i];
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
vector<long long int> odd, even;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
even.push_back(a[i]);
} else {
odd.push_back(a[i]);
}
}
if (even.size() >= odd.size()) {
if (even.size() == odd.size() || even.size() - odd.size() == 1) {
cout << "0" << endl;
return 0;
} else {
long long int k = even.size() - odd.size() - 1;
sort(even.begin(), even.end());
long long int sum = 0;
for (long long int i = 0; i < k; i++) {
sum += even[i];
}
cout << sum << endl;
return 0;
}
} else {
if (odd.size() - even.size() == 1) {
cout << "0" << endl;
return 0;
} else {
long long int k = odd.size() - even.size() - 1;
sort(odd.begin(), odd.end());
long long int sum = 0;
for (long long int i = 0; i < k; i++) {
sum += odd[i];
}
cout << sum << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, num1, num2, a[2005], b[2005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
if (v & 1)
a[++num1] = v;
else
b[++num2] = v;
}
sort(a + 1, a + num1 + 1);
sort(b + 1, b + num2 + 1);
int ans = 0;
if (num1 < num2) {
for (int i = 1; i <= num2 - num1 - 1; i++) ans += b[i];
} else {
for (int i = 1; i <= num1 - num2 - 1; i++) ans += a[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6;
long long n, m, x, i, z, cnt, sum, rem, tre, ert, ans, used[N];
vector<long long> v, v1, v2, v3;
vector<pair<string, string> > p;
set<char> second;
string s, s1, s2, s3, s4;
map<string, long long> mp;
char g;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> x;
v.push_back(x);
if (x % 2 == 0)
cnt++;
else
ans++;
}
x = 0;
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
if (cnt >= ans) {
for (long long i = 0; i < v.size(); i++) {
for (long long j = 0; j < v.size(); j++) {
if (v[j] % 2 == 0 and x == 0 and v[j] != 0) {
v[j] = 0;
x = 1;
break;
}
if (v[j] % 2 != 0 and x == 1) {
v[j] = 0;
x = 0;
break;
}
}
}
for (long long i = 0; i < v.size(); i++) {
sum += v[i];
}
cout << sum;
}
if (cnt < ans) {
for (long long i = 0; i < v.size(); i++) {
for (long long j = 0; j < v.size(); j++) {
if (v[j] % 2 == 0 and x == 1 and v[j] != 0) {
v[j] = 0;
x = 0;
break;
}
if (v[j] % 2 != 0 and x == 0) {
v[j] = 0;
x = 1;
break;
}
}
}
for (long long i = 0; i < v.size(); i++) {
sum += v[i];
}
cout << sum;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> odd, even;
long long x, n, c = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (x % 2)
odd.push_back(x);
else
even.push_back(x);
}
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
n = max(even.size(), odd.size()) - min(even.size(), odd.size());
if (even.size() == odd.size())
return cout << 0, 0;
else if (even.size() > odd.size())
for (int i = 0; i < n - 1; i++) c += even[i];
else
for (int i = 0; i < n - 1; i++) c += odd[i];
cout << c;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ev = 0, od = 0, n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] % 2 == 0)
ev++;
else
od++;
}
sort(arr, arr + n);
long long c = abs(ev - od);
long long e = min(ev, od);
long long d = e + 1;
if (c < 2)
cout << 0 << endl;
else {
for (int i = n - 1; i >= 0; i--) {
if (ev > od) {
if (arr[i] % 2 == 0 && d > 0) {
arr[i] = 0;
d--;
} else if (arr[i] % 2 != 0 && e > 0) {
arr[i] = 0;
e--;
}
} else {
if (arr[i] % 2 != 0 && d > 0) {
arr[i] = 0;
d--;
} else if (arr[i] % 2 == 0 && e > 0) {
arr[i] = 0;
e--;
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) ans += arr[i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char c[10000];
int main() {
int n, o = 0, e = 0, x;
vector<int> even, odd;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (x & 1) {
o += 1;
odd.push_back(x);
} else {
e += 1;
even.push_back(x);
}
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
int d = abs(o - e);
int sum = 0;
if (d < 2)
cout << "0" << endl;
else {
if (o > e) {
for (int i = 0; i < d - 1; i++) sum += odd[i];
} else {
for (int i = 0; i < d - 1; i++) sum += even[i];
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
int main() {
long long int n, a, b, i, ci = 0, cp = 0, r = 0;
cin >> n;
vector<long long int> vp, vi;
for (long long int i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 0) {
vp.push_back(a);
} else {
vi.push_back(a);
}
}
ci = vi.size();
cp = vp.size();
sort(vp.begin(), vp.end());
sort(vi.begin(), vi.end());
if (ci > (cp + 1)) {
for (long long int i = 0; i < (ci - (cp + 1)); i++) {
r = r + vi[i];
}
} else if ((ci + 1) < cp) {
for (long long int i = 0; i < (cp - (ci + 1)); i++) {
r = r + vp[i];
}
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 1 * 1000 * 1000 * 1000 + 200;
const int MAXN = 5 * 100 * 1000 + 10;
const int MLOG = 30;
const int NMAX = 20;
int main() {
int n;
cin >> n;
int nm[2] = {0, 0}, a;
vector<int> vc[2];
for (int i = 0; i < n; i++) cin >> a, nm[a % 2]++, vc[a % 2].push_back(a);
int h = 1;
if (nm[0] > nm[1]) swap(nm[1], nm[0]), h = 0;
int all = max(0, nm[1] - nm[0] - 1), ans = 0;
sort(vc[h].begin(), vc[h].end());
for (int i = 0; i < all; i++) ans += vc[h][i];
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, a[2005], b[2005], x = 0, y = 0, n, m, sum = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> m;
if (m % 2 == 0) {
a[x] = m;
x++;
} else {
b[y] = m;
y++;
}
}
sort(a, a + x, greater<int>());
sort(b, b + y, greater<int>());
if (x == y || x + 1 == y || y + 1 == x) {
cout << "0" << endl;
} else {
if (x > y) {
for (i = y + 1; i < x; i++) {
sum += a[i];
}
}
if (x < y) {
for (i = x + 1; i < y; i++) {
sum += b[i];
}
}
cout << sum << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, l = 0, r = 0, define = 0, ans = 0, sum = 0, z = 0, i = 0,
suka = 0;
cin >> n;
long long a[n];
vector<int> v1;
vector<int> v2;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0)
v1.push_back(a[i]);
else
v2.push_back(a[i]);
define += a[i];
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
reverse(v1.begin(), v1.end());
reverse(v2.begin(), v2.end());
if (v1.size() > v2.size()) {
while (i < v2.size() || z < v1.size()) {
if (sum % 2 == 0 && z < v1.size()) {
ans += v1[z];
z++;
sum++;
} else if (i < v2.size()) {
ans += v2[i];
i++;
sum++;
}
suka++;
if (suka >= 1e5) {
cout << define - ans;
return 0;
}
}
} else {
while (i < v1.size() || z < v2.size()) {
if (sum % 2 == 0 && z < v2.size()) {
ans += v2[z];
z++;
sum++;
} else if (i < v1.size()) {
ans += v1[i];
i++;
sum++;
}
suka++;
if (suka >= 1e5) {
cout << define - ans;
return 0;
}
}
}
cout << define - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long>> odd;
priority_queue<long long, vector<long long>, greater<long long>> even;
long long solve() {
priority_queue<long long, vector<long long>, greater<long long>> first,
second;
long long sum = 0;
int dif;
if (odd.size() == even.size()) return 0;
if (odd.size() > even.size()) {
first = odd;
second = even;
} else {
first = even;
second = odd;
}
dif = first.size() - second.size() - 1;
for (int i = 0; i < dif; ++i) {
sum += first.top();
first.pop();
}
return sum;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
long long a;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> a;
if (a & 1)
odd.push(a);
else
even.push(a);
}
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long mod(long long x) {
if (x < 0) return -x;
return x;
}
long long expo(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y % 2 == 1) res = (res * x);
y = y >> 1;
x = x * x;
}
return res;
}
using namespace std;
const int MAXN = 500005;
vector<long long> v;
long long a[1000000], b[1000000];
int main() {
ios_base::sync_with_stdio(false);
long long n, t, m, k, x = 0, y = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> t;
a[i] = t;
if (t % 2 == 0) {
x++;
} else {
y++;
}
}
long long ans = 0;
sort(a, a + n);
if (x == y || x == y - 1 || x == y + 1) {
cout << "0";
return 0;
} else {
if (x > y) {
x = x - y - 1;
for (long long i = 0; i < n && x > 0; i++) {
if (a[i] % 2 == 0) {
ans += a[i];
x--;
}
}
} else {
y = y - x - 1;
for (long long i = 0; i < n && y > 0; i++) {
if (a[i] % 2 == 1) {
ans += a[i];
y--;
}
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, eve = 0, od = 0;
cin >> n;
long long int arr[n], even[n], odd[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; ++i) {
if (arr[i] % 2 == 0) {
if (eve == 0)
even[eve] = arr[i];
else
even[eve] = arr[i] + even[eve - 1];
++eve;
} else {
if (od == 0)
odd[od] = arr[i];
else
odd[od] = arr[i] + odd[od - 1];
++od;
}
}
if (eve == od + 1 || od == eve + 1 || eve == od)
cout << 0 << endl;
else if (eve == 0)
cout << odd[od - 2];
else if (od == 0)
cout << even[eve - 2];
else {
int k = abs(eve - od);
if (eve > od)
cout << even[k - 2];
else
cout << odd[k - 2];
}
}
|
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7ffffffffffffff;
const double eps = 1e-8;
unsigned int seed = 19260817;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const double &a,
const double &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch < 65 || ch > 122 || (ch > 90 && ch < 97)) ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while ((ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122))
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 2005;
int a[N];
std::vector<int> v1, v2;
__inline__ __attribute__((always_inline)) bool cmp(const int &A, const int &B) {
return A > B;
}
int main() {
int n;
read(n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
read(a[i]);
ans += a[i];
if (a[i] & 1) {
v1.push_back(a[i]);
} else {
v2.push_back(a[i]);
}
}
std::sort(v1.begin(), v1.end(), cmp);
std::sort(v2.begin(), v2.end(), cmp);
if (v1.size() == v2.size()) {
printf("0\n");
return 0;
}
if ((int)v1.size() < (int)v2.size()) {
for (int i = 0; i < (int)v1.size(); ++i) {
ans -= v2[i];
ans -= v1[i];
}
ans -= v2[v1.size()];
} else {
for (int i = 0; i < (int)v2.size(); ++i) {
ans -= v2[i];
ans -= v1[i];
}
ans -= v1[v2.size()];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, i;
cin >> n;
long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
long int o = 0;
long int e = 0;
for (i = 0; i < n; i++) {
if (a[i] % 2 == 0)
e++;
else
o++;
}
sort(a, a + n);
long int k;
if ((o == e) || (max(o, e) - min(o, e) == 1))
cout << "0";
else if (o == 0 || e == 0) {
long int sum = 0;
for (i = 0; i < n - 1; i++) {
sum = sum + a[i];
}
cout << sum;
} else {
if (o > e) {
long int sum = 0;
k = o - e - 1;
for (i = 0; k > 0; i++) {
if (a[i] % 2 != 0) {
sum = sum + a[i];
k--;
}
}
cout << sum;
} else {
long int sum = 0;
k = e - o - 1;
for (i = 0; k > 0; i++) {
if (a[i] % 2 == 0) {
sum = sum + a[i];
k--;
}
}
cout << sum;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void) {
cin.tie(0)->sync_with_stdio(false);
int n;
cin >> n;
ll arr[n];
vector<ll> o;
vector<ll> e;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] % 2)
o.push_back(arr[i]);
else
e.push_back(arr[i]);
}
sort(o.begin(), o.end());
sort(e.begin(), e.end());
int num = min(o.size(), e.size());
o.resize(o.size() - num);
e.resize(e.size() - num);
ll sum = 0;
if (o.size() == 0 && e.size() == 0) {
cout << 0 << '\n';
return 0;
}
if (o.size() == 0) {
for (int i = 0; i < e.size() - 1; i++) {
sum += e[i];
}
} else if (e.size() == 0) {
for (int i = 0; i < o.size() - 1; i++) {
sum += o[i];
}
}
cout << sum << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int maxn = 2e6 + 7;
int judge(vector<int> v1, vector<int> v2) {
int i = 0, j = 0;
for (int k = 0;; k++) {
if (k % 2 == 0) {
if (i >= v1.size()) break;
i++;
} else {
if (j >= v2.size()) break;
j++;
}
}
int ans = 0;
for (; i < v1.size(); i++) {
ans += v1[i];
}
for (; j < v2.size(); j++) {
ans += v2[j];
}
return ans;
}
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
while (cin >> n) {
vector<int> odd, even;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2)
odd.push_back(a);
else
even.push_back(a);
}
sort(odd.begin(), odd.end(), cmp);
sort(even.begin(), even.end(), cmp);
int ans = INF;
ans = min(judge(odd, even), judge(even, odd));
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
int odd = 0, even = 0;
vector<int> o, e;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] & 1) {
odd++;
o.push_back(a[i]);
} else {
even++;
e.push_back(a[i]);
}
}
if (abs(even - odd) <= 1) {
cout << 0 << endl;
return 0;
}
if (even > odd) {
int req = even - odd - 1;
sort(e.begin(), e.end());
int ans = 0;
for (int i = 0; i < req; i++) ans += e[i];
cout << ans << endl;
} else {
int req = odd - even - 1;
sort(o.begin(), o.end());
int ans = 0;
for (int i = 0; i < req; i++) ans += o[i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> e, o;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t & 1)
o.push_back(t);
else
e.push_back(t);
}
if (!o.empty()) sort((o).begin(), (o).end());
if (!e.empty()) sort((e).begin(), (e).end());
int d = o.size() - e.size(), os = 0, es = 0;
for (int i = 0; i < d - 1; i++) os += o[i];
for (int i = 0; i < -d - 1; i++) es += e[i];
cout << (d > 0 ? os : es);
}
signed main() {
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, x;
cin >> n;
vector<int> even, odd;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> x;
sum += x;
if (x & 1)
odd.push_back(x);
else
even.push_back(x);
}
sort(even.rbegin(), even.rend());
sort(odd.rbegin(), odd.rend());
int k = min(odd.size(), even.size());
int rem = sum;
rem -= accumulate(odd.begin(), odd.begin() + k, 0);
rem -= accumulate(even.begin(), even.begin() + k, 0);
if (odd.size() > k)
rem -= odd[k];
else
rem -= even[k];
cout << rem << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> m;
vector<int> m2;
int main() {
int ch = 0, neche = 0;
cin >> n;
int a;
for (int i = 0; i < n; ++i) {
cin >> a;
if (a % 2 == 0)
m2.push_back(a);
else
m.push_back(a);
}
ch = m2.size();
neche = m.size();
sort(m.begin(), m.end());
sort(m2.begin(), m2.end());
while (!m.empty() && !m2.empty()) {
m.pop_back();
m2.pop_back();
}
if (ch > neche && !m2.empty())
m2.pop_back();
else if (neche > ch && !m.empty())
m.pop_back();
int sum = 0;
for (int i = 0; i < m.size(); ++i) sum += m[i];
for (int i = 0; i < m2.size(); ++i) sum += m2[i];
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cmp(int a, int b) { return (a > b); }
int main() {
int n;
cin >> n;
int i;
int a[n];
int jishu[n];
int oushu[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, cmp);
int count = 0;
int count1 = 0;
int sum = 0;
int k = 0, j = 0;
for (i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
count++;
oushu[k++] = a[i];
} else {
count1++;
jishu[j++] = a[i];
}
}
if (count == count1 || count - count1 == 1 || count1 - count == 1) {
cout << "0";
} else if (count - count1 > 1) {
for (i = count1 + 1; i < count; i++) sum += oushu[i];
cout << sum;
} else {
for (i = count + 1; i < count1; i++) sum += jishu[i];
cout << sum;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[2001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string str;
int ne = 0, no = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] % 2 == 0)
ne++;
else
no++;
}
sort(arr, arr + n);
bool even;
int j = n - 1;
if (ne > no) {
even = 0;
} else
even = 1;
while (j >= 0) {
if (even) {
if (arr[j] % 2 == 1) {
arr[j] = -1;
even = 0;
j = n - 1;
continue;
}
} else {
if (arr[j] % 2 == 0) {
arr[j] = -1;
even = 1;
j = n - 1;
continue;
}
}
j--;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > 0) ans += arr[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(long long int a, long long int b) { return a > b; }
int main() {
vector<long long int> v, v_od, v_ev;
long long int n, t_sum = 0, sum = 0, input, sz_od, sz_ev;
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> input;
t_sum += input;
v.push_back(input);
if (input % 2)
v_od.push_back(input);
else
v_ev.push_back(input);
}
sort(v_ev.begin(), v_ev.end(), cmp);
sort(v_od.begin(), v_od.end(), cmp);
sz_od = v_od.size();
sz_ev = v_ev.size();
if (sz_od == sz_ev)
sum = t_sum;
else if (sz_od < sz_ev) {
for (long long int i = 0; i < sz_od; i++) sum += v_od[i];
for (long long int i = 0; i < sz_od + 1; i++) sum += v_ev[i];
} else {
for (long long int i = 0; i < sz_ev; i++) sum += v_ev[i];
for (long long int i = 0; i < sz_ev + 1; i++) sum += v_od[i];
}
cout << t_sum - sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename C, typename T = decay<decltype(*begin(declval<C>()))>,
typename enable_if<!is_same<C, string>::value>::type * = nullptr>
ostream &operator<<(ostream &os, const C &c) {
bool f = true;
os << "[";
for (const auto &x : c) {
if (!f) os << ", ";
f = false;
os << x;
}
return os << "]";
}
template <typename T>
void debug(string s, T x) {
cerr << s << " = " << x << "\n";
}
template <typename T, typename... Args>
void debug(string s, T x, Args... args) {
cerr << s.substr(0, s.find(',')) << " = " << x << " | ";
debug(s.substr(s.find(',') + 2), args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> odd, even;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2)
odd.push_back(a);
else
even.push_back(a);
}
if (abs((int)odd.size() - (int)even.size()) <= 1)
cout << "0\n";
else {
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
while (!odd.empty() && !even.empty()) {
odd.pop_back();
even.pop_back();
}
int ret = 0;
if (!odd.empty()) {
odd.pop_back();
for (int x : odd) ret += x;
} else {
even.pop_back();
for (int x : even) ret += x;
}
cout << ret << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int com(long long int n, long long int a) {
long long int result = 1;
if (n - a < a) a = n - a;
long long int cnt = 1;
for (long long int i = n - a + 1; i < n + 1; i++) {
result *= i;
result /= cnt;
cnt++;
}
return result;
}
void swap(int *xp, int *yp) {
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void bubbleSort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++)
for (j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1]) swap(&arr[j], &arr[j + 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int test = 1;
while (test > 0) {
long long int n;
cin >> n;
vector<int> o, e;
long long int a[n], j = 0, k = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
e.push_back(a[i]);
j++;
} else {
o.push_back(a[i]);
k++;
}
}
sort(o.begin(), o.end(), greater<int>());
sort(e.begin(), e.end(), greater<int>());
long long int mini = min(o.size(), e.size());
long long int sum1 = 0, sum2 = 0;
if (abs(k - j) <= 1) {
cout << "0";
} else {
if (j > k) {
for (long long int i = mini + 1; i < e.size(); i++) {
sum1 += e[i];
}
cout << sum1;
} else {
for (long long int i = mini + 1; i < o.size(); i++) {
sum2 += o[i];
}
cout << sum2;
}
}
test--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
int a[2003], b[2003], c[2003], d = 0, e = 0;
for (int i = 0; i < t; i++) {
scanf("%d", &a[i]);
if (a[i] % 2 == 1)
b[d++] = a[i];
else
c[e++] = a[i];
}
sort(b, b + d);
sort(c, c + e);
long long sum1 = 0, m;
if (d - e >= 2) {
m = d - e - 1;
for (int i = 0; i < m; i++) sum1 += b[i];
printf("%lld", sum1);
return 0;
} else if (e - d >= 2) {
m = e - d - 1;
for (int i = 0; i < m; i++) sum1 += c[i];
printf("%lld", sum1);
return 0;
} else
printf("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, odd = 0, even = 0, count = 0;
long long int sum = 0, temp = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
temp += arr[i];
if (arr[i] % 2 == 0)
even++;
else
odd++;
}
sort(arr, arr + n);
if (odd == even || odd - even == 1 || even - odd == 1)
cout << "0";
else {
if (odd > even && even != 0) {
for (int i = 0; i < n; i++) {
if ((arr[i] % 2) != 0) {
sum = sum + arr[i];
count++;
}
if (count == (odd - even - 1)) break;
}
}
if (even == 0)
sum = temp - arr[n - 1];
else if (odd < even && odd != 0) {
for (int i = 0; i < n; i++) {
if ((arr[i] % 2) == 0) {
sum = sum + arr[i];
count++;
}
if (count == (even - odd - 1)) break;
}
}
if (odd == 0) sum = temp - arr[n - 1];
cout << sum;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<long long> e, o;
for (long long i = (0); i < (n); i++) {
long long a;
cin >> a;
if (a % 2)
o.push_back(a);
else
e.push_back(a);
}
sort(e.begin(), e.end());
sort(o.begin(), o.end());
if (e.size() > o.size()) {
long long ans = 0;
for (long long i = (0); i < (e.size() - (o.size() + 1)); i++) ans += e[i];
cout << ans << endl;
} else {
long long ans = 0;
for (long long i = (0); i < ((long long)o.size() - (e.size() + 1)); i++)
ans += o[i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
while (cin >> n) {
vector<long long> v;
long long c = 0, d = 0;
for (int i = 0; i < n; i++) {
long long p;
cin >> p;
v.push_back(p);
if (p % 2 == 0)
c++;
else
d++;
}
sort(v.begin(), v.end());
if (c == d || (c + 1 == d) || (d + 1 == c)) {
cout << 0 << endl;
} else {
long long sum = 0, x = 0, y = 0;
if (d == 0 || c == 0) {
for (int i = 0; i < n - 1; i++) {
sum += v[i];
}
cout << sum << endl;
} else if (c > d && d != 0) {
for (int i = n - 1; i >= 0; i--) {
if (v[i] % 2 != 0) {
v[i] = -1;
}
}
for (int i = n - 1; i >= 0; i--) {
if (v[i] % 2 == 0) {
v[i] = -1;
x++;
}
if (x == d + 1) break;
}
for (int i = 0; i < n; i++) {
if (v[i] != -1) sum += v[i];
}
cout << sum << endl;
} else if (d > c && c != 0) {
for (int i = n - 1; i >= 0; i--) {
if (v[i] % 2 == 0) {
v[i] = -1;
}
}
for (int i = n - 1; i >= 0; i--) {
if (v[i] % 2 != 0 && v[i] != -1) {
v[i] = -1;
y++;
}
if (c + 1 == y) break;
}
for (int i = 0; i < n; i++) {
if (v[i] != -1) sum += v[i];
}
cout << sum << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int n;
priority_queue<int> q, q_, Q, Q_;
int a[2005];
int sum, sum_;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
sum_ += a[i];
if (a[i] & 1 == 1)
q.push(a[i]), Q.push(a[i]);
else
q_.push(a[i]), Q_.push(a[i]);
}
while (!q.empty()) {
int now = q.top();
q.pop();
sum -= now;
if (q_.empty()) break;
now = q_.top();
q_.pop();
sum -= now;
}
while (!Q_.empty()) {
int now = Q_.top();
Q_.pop();
sum_ -= now;
if (Q.empty()) break;
now = Q.top();
Q.pop();
sum_ -= now;
}
printf("%d\n", min(sum, sum_));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, x;
cin >> n;
vector<int> even, odd;
for (int i = 0; i < n; i++) {
cin >> x;
if (x % 2 == 0) {
even.push_back(x);
} else {
odd.push_back(x);
}
}
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
n = even.size();
int m = odd.size();
if (abs(m - n) <= 1) {
cout << 0;
return 0;
}
int i = 0;
while ((n > 0) && (m > 0)) {
even.pop_back();
n--;
odd.pop_back();
m--;
}
if ((even.size() == 0) && (odd.size() == 0)) {
cout << "0";
return 0;
}
if ((even.size() == 0) && (odd.size() != 0)) {
odd.pop_back();
for (int i = 0; i < odd.size(); i++) {
sum += odd[i];
}
cout << sum;
return 0;
}
if ((even.size() != 0) && (odd.size() == 0)) {
even.pop_back();
for (int i = 0; i < even.size(); i++) {
sum += even[i];
}
cout << sum;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
void quick_sort(int[], int, int);
int partition(int[], int, int);
void quick_sort(int a[], int l, int u) {
int j;
if (l < u) {
j = partition(a, l, u);
quick_sort(a, l, j - 1);
quick_sort(a, j + 1, u);
}
}
int partition(int a[], int l, int u) {
int v, i, j, temp;
v = a[l];
i = l;
j = u + 1;
do {
do i++;
while (a[i] < v && i <= u);
do j--;
while (v < a[j]);
if (i < j) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
} while (i < j);
a[l] = a[j];
a[j] = v;
return (j);
}
int main() {
int c1, c2, n, i, k1 = 0, k2 = 0;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int save = 0;
int x[n], y[n];
for (i = 0; i < n; i++) {
if (a[i] % 2 == 1)
x[k1++] = a[i];
else
y[k2++] = a[i];
}
int min;
min = k1;
if (k2 < k1) min = k2;
quick_sort(x, 0, k1 - 1);
quick_sort(y, 0, k2 - 1);
if (min != 0) {
for (i = 0; i < min; i++) {
x[k1 - 1 - i] = 0;
y[k2 - 1 - i] = 0;
}
if (k1 > k2) {
x[k1 - min - 1] = 0;
} else
y[k2 - min - 1] = 0;
int sum1 = 0;
int sum2 = 0;
for (i = 0; i < k1; i++) sum1 += x[i];
for (i = 0; i < k2; i++) sum2 += y[i];
int ans = sum1 + sum2;
printf("%d", ans);
} else {
if (k1 == 0)
for (i = 0; i < k2 - 1; i++) save += y[i];
else
for (i = 0; i < k1 - 1; i++) save += x[i];
printf("%d", save);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int z[5], num1[2005], num2[2005];
int main() {
int n, m, t;
while (cin >> n) {
int d1 = 0, d2 = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x % 2 == 0) {
num1[d1] = x;
d1++;
} else {
num2[d2] = x;
d2++;
}
}
sort(num1, num1 + d1);
sort(num2, num2 + d2);
if (d1 - d2 == 1 || d2 - d1 == 1 || d2 == d1) {
cout << 0 << endl;
} else {
int sum = 0;
if (d1 > d2) {
for (int i = 0; i < d1 - d2 - 1; i++) {
sum += num1[i];
}
cout << sum << endl;
} else {
for (int i = 0; i < d2 - d1 - 1; i++) {
sum += num2[i];
}
cout << sum << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> all(n);
int odd, even;
odd = 0;
even = 0;
for (int i = 0; i < n; i++) {
cin >> all[i];
if (all[i] % 2 == 0)
even++;
else
odd++;
}
if (abs(odd - even) == 1)
cout << 0;
else {
int k = odd - even;
unsigned long long out = 0;
if (k > 0) {
sort(all.begin(), all.end());
for (int i = 0; i < n; i++) {
if (all[i] % 2 == 1) {
out += all[i];
k--;
if (k == 1) break;
}
}
} else if (k < 0) {
k *= -1;
sort(all.begin(), all.end());
for (int i = 0; i < n; i++) {
if (all[i] % 2 == 0) {
out += all[i];
k--;
if (k == 1) break;
}
}
}
cout << out;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, temp;
int l1 = 0, l2 = 0;
vector<int> ji;
vector<int> ou;
cin >> n;
while (n--) {
cin >> temp;
if (temp % 2 == 0)
ou.push_back(temp);
else
ji.push_back(temp);
}
l1 = ji.size();
l2 = ou.size();
if (l1 == l2) {
cout << 0;
return 0;
}
sort(ji.begin(), ji.end());
sort(ou.begin(), ou.end());
int s = 0;
if (l1 > l2) {
for (int i = 0; i < l1 - l2 - 1; ++i) s += ji[i];
} else
for (int i = 0; i < l2 - l1 - 1; ++i) s += ou[i];
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
cin >> n;
long int var;
vector<long int> even, odd, even1, odd1;
while (n--) {
cin >> var;
if (var % 2 == 0)
even.push_back(var);
else
odd.push_back(var);
}
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
even1 = even;
odd1 = odd;
while (1) {
if (even.empty())
break;
else
even.pop_back();
if (odd.empty())
break;
else
odd.pop_back();
}
while (1) {
if (odd1.empty())
break;
else
odd1.pop_back();
if (even1.empty())
break;
else
even1.pop_back();
}
long int ans1, ans2;
ans1 = ans2 = 0;
for (long int i = 0; i < even.size(); i++) ans1 += even[i];
for (long int i = 0; i < odd.size(); i++) ans1 += odd[i];
for (long int i = 0; i < even1.size(); i++) ans2 += even1[i];
for (long int i = 0; i < odd1.size(); i++) ans2 += odd1[i];
cout << min(ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
using namespace std;
bool cmp(int a, int b) { return a >= b; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
vector<int> even, odd;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sum += x;
if (x & 1)
odd.push_back(x);
else
even.push_back(x);
}
sort(even.begin(), even.end(), cmp);
sort(odd.begin(), odd.end(), cmp);
int ne = even.size(), no = odd.size();
if (abs(ne - no) <= 1) {
cout << 0 << endl;
} else {
long long int ans1 = 0, ans2 = 0;
int i = 0, j = 0, k = 0;
while (i < even.size() && j < odd.size()) {
if (k % 2 == 0) {
ans1 += even[i];
i++;
k++;
} else {
ans1 += odd[j];
j++;
k++;
}
}
if (k % 2 == 0) {
if (i < even.size()) ans1 += even[i];
} else {
if (j < odd.size()) ans1 += odd[j];
}
i = 0, j = 0, k = 0;
while (i < even.size() && j < odd.size()) {
if (k % 2 == 1) {
ans2 += even[i];
i++;
k++;
} else {
ans2 += odd[j];
j++;
k++;
}
}
if (k % 2 == 1) {
if (i < even.size()) ans2 += even[i];
} else {
if (j < odd.size()) ans2 += odd[j];
}
long long int ans = min(sum - ans1, sum - ans2);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[2005];
long long b[2005];
long long c[2005];
int main() {
long long i, j, k, n, ji = 0, ou = 0, word = 0, sum1 = 0, sum2 = 0, s = 0,
cha;
scanf("%lld", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
if (a[i] % 2 == 0) {
b[ou] = a[i];
ou++;
} else {
c[ji] = a[i];
ji++;
}
}
if (ou >= ji)
cha = ou - ji - 1;
else
cha = ji - ou - 1;
sort(b, b + ou);
sort(c, c + ji);
if (ou >= ji) {
for (i = 0; i < cha; i++) sum1 += b[i];
} else {
for (i = 0; i < cha; i++) sum1 += c[i];
}
printf("%lld", sum1);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
vector<int> even, odd;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
sum += x;
if (x & 1)
odd.push_back(x);
else
even.push_back(x);
}
sort(odd.rbegin(), odd.rend());
sort(even.rbegin(), even.rend());
int k = min(odd.size(), even.size());
int rem = sum;
rem -= accumulate(odd.begin(), odd.begin() + k, 0);
rem -= accumulate(even.begin(), even.begin() + k, 0);
if (int(odd.size()) > k) {
rem -= odd[k];
}
if (int(even.size()) > k) {
rem -= even[k];
}
cout << rem << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2020], b[2020];
int t1, t2;
int main() {
int n;
scanf("%d", &n);
while (n--) {
int x;
scanf("%d", &x);
if (x % 2)
a[t1++] = x;
else
b[t2++] = x;
}
if (abs(t1 - t2) <= 1)
printf("0");
else {
sort(a, a + t1);
sort(b, b + t2);
if (t1 < t2) {
int ans = 0;
for (int i = 0; i < t2 - t1 - 1; i++) {
ans += b[i];
}
printf("%d", ans);
} else {
int ans = 0;
for (int i = 0; i < t1 - t2 - 1; i++) {
ans += a[i];
}
printf("%d", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, o = 0, e = 0, sum = 0;
cin >> n;
int ara[n];
for (i = 0; i < n; i++) {
cin >> ara[i];
if (ara[i] % 2 == 0)
e++;
else
o++;
}
sort(ara, ara + n);
if (o > e) {
o = o - e - 1;
for (i = 0; i < n; i++) {
if (ara[i] % 2 == 1) {
if (o == 0) break;
sum += ara[i];
o--;
}
}
} else if (e > o) {
e = e - o - 1;
for (i = 0; i < n; i++) {
if (ara[i] % 2 == 0) {
if (e == 0) break;
sum += ara[i];
e--;
}
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long int n;
cin >> n;
long long int a[n];
long long int e, o;
e = o = 0;
vector<long long int> even, odd;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
e++;
even.push_back(a[i]);
} else {
odd.push_back(a[i]);
o++;
}
}
long long int x = max(e, o);
long long int bt = -1;
if (x == e) bt = 0;
if (x == o) bt = 1;
if (x == e && x == o) bt = 2;
x -= min(e, o);
x -= 1;
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
long long int ans = 0;
if (bt == 0)
for (long long int i = 0; i < x; i++) {
ans += even[i];
}
if (bt == 1)
for (long long int i = 0; i < x; i++) {
ans += odd[i];
}
if (bt == 2) {
long long int ans1, ans2;
ans1 = ans2 = 0;
for (long long int i = 0; i < x; i++) {
ans1 += odd[i];
ans2 += even[i];
}
ans = min(ans1, ans2);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long res = binpow(a, b / 2) % 1000000007;
if (b % 2)
return (((res * res) % 1000000007) * a) % 1000000007;
else
return (res * res) % 1000000007;
}
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long fact(long long n) {
long long res = 1;
for (long long i = 2; i <= n; i++) res = (res * i) % 1000000007;
return (res) % 1000000007;
}
bool isPrime(long long n) {
if (n == 1) return false;
if (n == 2) return true;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long ceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
} else {
return ((a / b) + 1);
}
}
long long min(long long a, long long b) {
if (a > b) {
return b;
}
return a;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long dif(long long a, long long b) {
if (a > b) return a - b;
return b - a;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long k = gcd(a, b);
return (a * b) / k;
}
void read(long long arr[], long long n) {
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
}
void addedge(vector<vector<long long>>& v, long long p1, long long p2) {
v[p1].push_back({p2});
v[p2].push_back({p1});
}
bool mycmp(pair<long long, float> p1, pair<long long, float> p2) {
return p1.first < p2.first;
}
void print(long long arr[], long long n) {
for (long long i = 0; i < n; ++i) {
cout << arr[i] << " ";
}
cout << "\n";
}
bool mycmp2(pair<long long, pair<long long, long long>>& p1,
pair<long long, pair<long long, long long>>& p2) {
if (p1.second.first == p2.second.first) {
return p1.first > p2.first;
} else {
return p1.second.first < p2.second.first;
}
}
vector<long long> prime;
void sieveOferatosthenes(long long MAX) {
bool pri[MAX + 1];
memset(pri, true, sizeof(pri));
pri[1] = false;
for (long long p = 2; p * p <= MAX; p++) {
if (pri[p]) {
for (long long i = p * 2; i <= MAX; i += p) pri[i] = false;
}
}
for (long long i = 1; i <= MAX; i++) {
if (pri[i]) {
prime.push_back(i);
}
}
}
bool mycmp3(pair<long long, long long>& p1, pair<long long, long long>& p2) {
if (p1.first == p2.first) {
return p1.second < p2.second;
}
return p1.first < p2.first;
}
void solve() {
int n;
cin >> n;
long long arr[n];
read(arr, n);
vector<long long> odd, even;
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 1) {
odd.push_back(arr[i]);
} else {
even.push_back(arr[i]);
}
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
int len = min(odd.size(), even.size());
long long res = 0;
if (len == odd.size()) {
len++;
int k = even.size() - len;
for (int i = 0; i < (k); i++) {
res += (even[i]);
}
} else {
len++;
int k = odd.size() - len;
for (int i = 0; i < (k); i++) {
res += (odd[i]);
}
}
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0, r = 0, f, cnt = 0;
cin >> n;
int a[n], ev[n], od[n];
for (int k = 0; k < n; k++) {
cin >> a[k];
}
for (int k = 0; k < n; k++) {
if (a[k] % 2 == 0) {
ev[r] = a[k];
r++;
} else {
od[c] = a[k];
c++;
}
}
sort(ev, ev + r);
sort(od, od + c);
f = max(c, r) - min(c, r) - 1;
if (r > c) {
for (int k = 0; k < f; k++) {
cnt = cnt + ev[k];
}
} else
for (int k = 0; k < f; k++) {
cnt = cnt + od[k];
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void init() {
ios::sync_with_stdio(0);
cin.tie(0);
}
void solve();
int main() {
init();
solve();
return 0;
}
bool isprime(long long n) {
for (long long i = 2; i < sqrt(n) + 1 && i < n; i++) {
if (n % i == 0) return false;
}
return true;
}
void solve() {
int n;
cin >> n;
vector<long long> odd;
vector<long long> even;
long long in;
for (int i = 0; i < n; i++) {
cin >> in;
(in % 2 == 0) ? even.push_back(in) : odd.push_back(in);
}
if (!even.empty()) sort(even.begin(), even.end());
if (!odd.empty()) sort(odd.begin(), odd.end());
int countodd;
int counteven;
(!odd.empty()) ? countodd = odd.size() : countodd = 0;
(!even.empty()) ? counteven = even.size() : counteven = 0;
long long suma = 0;
long long sumb = 0;
if (countodd - counteven > 1) {
for (int i = 0; i < countodd - counteven - 1; i++) {
suma += odd[i];
}
}
if (counteven - countodd > 1) {
for (int i = 0; i < counteven - countodd - 1; i++) {
sumb += even[i];
}
}
cout << max(suma, sumb) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, ans;
vector<int> v1, v2;
inline int read() {
int x = 0;
bool sign = false;
char alpha = 0;
while (!isdigit(alpha)) sign |= alpha == '-', alpha = getchar();
while (isdigit(alpha))
x = (x << 1) + (x << 3) + (alpha ^ 48), alpha = getchar();
return sign ? -x : x;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
x = read();
x & 1 ? v1.push_back(x) : v2.push_back(x);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (v1.size() == 0)
for (int i = 0; i < v2.size() - 1; i++) ans += v2[i];
else if (v2.size() == 0)
for (int i = 0; i < v1.size() - 1; i++) ans += v1[i];
else if (v1.size() - 1 > v2.size())
for (int i = 0; i < v1.size() - v2.size() - 1; i++) ans += v1[i];
else if (v1.size() < v2.size() - 1)
for (int i = 0; i < v2.size() - v1.size() - 1; i++) ans += v2[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long p = 1;
while (b) {
if (b % 2) {
p = p * a;
}
b >>= 1;
a = a * a;
}
return p;
}
bool prime(long long n) {
if (n <= 3) {
return true;
}
for (long long i = 2; i <= sqrt(n); ++i) {
if (n % i == 0) {
return true;
}
}
return false;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
void solve() {
long long n;
cin >> n;
long long a[n];
vector<long long> even, odd;
long long ans = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
ans += a[i];
if (a[i] % 2) {
odd.push_back(a[i]);
} else
even.push_back(a[i]);
}
if (odd.size() == 0) {
sort(even.begin(), even.end());
cout << ans - even[even.size() - 1] << "\n";
return;
}
if (even.size() == 0) {
sort(odd.begin(), odd.end());
cout << ans - odd[odd.size() - 1] << "\n";
return;
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
long long i = odd.size() - 1, j = even.size() - 1;
if (abs(i - j) <= 1) {
cout << 0 << "\n";
return;
}
if (i > j) {
ans -= odd[i];
i--;
} else {
ans -= even[j];
j--;
}
long long x = min(i, j) + 1;
long long y = x;
while (y > 0) {
ans -= odd[i];
i--;
y--;
}
while (x > 0) {
ans -= even[j];
j--;
x--;
}
cout << ans << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
vector<long long int> a, b;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (x % 2)
a.push_back(x);
else
b.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a.size() < b.size()) {
long long int sum = 0;
for (long long int i = 0; i < b.size() - (a.size() + 1); i++) sum += b[i];
cout << sum;
} else if (a.size() > b.size()) {
long long int sum = 0;
for (long long int i = 0; i < a.size() - (b.size() + 1); i++) sum += a[i];
cout << sum;
} else {
cout << 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Int(T &n) {
n = 0;
int f = 1;
register int ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T>
T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <typename T>
inline void umin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void umax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T, typename W>
inline void Int(T &x, W &y) {
Int(x), Int(y);
}
template <typename T, typename W, typename Q>
void Int(T &x, W &y, Q &z) {
Int(x, y), Int(z);
}
const int N = 1e5 + 7;
const int inf = 1e9 + 7;
int n, a[N];
int process(int foo, int tot) {
multiset<int> st[2];
for (int i = 1; i <= n; ++i) {
st[a[i] % 2].insert(a[i]);
}
for (int i = 1; i <= n; ++i) {
if (st[foo].empty()) {
return tot;
}
tot -= *st[foo].rbegin();
st[foo].erase(st[foo].find(*st[foo].rbegin()));
foo ^= 1;
}
return tot;
}
int solve() {
Int(n);
for (int i = 1; i <= n; ++i) Int(a[i]);
int tot = 0;
for (int i = 1; i <= n; ++i) {
tot += a[i];
}
printf("%d\n", min(process(0, tot), process(1, tot)));
return 0;
}
int main() {
int tests = 1, CaseNo = 0;
while (tests--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, z;
cin >> n;
long long int ans = 0;
vector<long long int> o, e;
vector<long long int>::iterator itr;
for (i = 0; i < n; i++) {
cin >> z;
if (z % 2 == 0) {
e.push_back(z);
} else {
o.push_back(z);
}
}
if (e.size() == o.size()) {
cout << "0" << endl;
return 0;
}
sort(e.begin(), e.end(), greater<long long int>());
sort(o.begin(), o.end(), greater<long long int>());
if (e.size() > o.size()) {
for (itr = e.begin() + o.size() + 1; itr != e.end(); itr++)
ans = ans + (*itr);
} else if (e.size() < o.size()) {
for (itr = o.begin() + e.size() + 1; itr != o.end(); itr++)
ans = ans + (*itr);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int go(vector<int>& v, int state) {
int sum = 0;
priority_queue<int> odd, even;
for (int i = 0; i < v.size(); i++) {
if (v[i] % 2 == 1) {
odd.push(v[i]);
} else {
even.push(v[i]);
}
}
bool turn = false;
if (state) {
if (!odd.empty()) {
odd.pop();
turn = !turn;
} else {
return INT_MAX;
}
while (!odd.empty() && !even.empty()) {
if (turn) {
even.pop();
} else {
odd.pop();
}
turn = !turn;
}
if (turn && !even.empty()) {
even.pop();
}
if (!turn && !odd.empty()) {
odd.pop();
}
while (!even.empty()) {
sum += even.top();
even.pop();
}
while (!odd.empty()) {
sum += odd.top();
odd.pop();
}
} else {
if (!even.empty()) {
even.pop();
turn = !turn;
} else {
return INT_MAX;
}
while (!even.empty() && !odd.empty()) {
if (turn) {
odd.pop();
} else {
even.pop();
}
turn = !turn;
}
if (!turn && !even.empty()) {
even.pop();
}
if (turn && !odd.empty()) {
odd.pop();
}
while (!even.empty()) {
sum += even.top();
even.pop();
}
while (!odd.empty()) {
sum += odd.top();
odd.pop();
}
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int x = go(v, 0);
int y = go(v, 1);
cout << min(x, y) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
void solve() {
cin >> n;
long long ocount = 0, ecount = 0;
long long mineve = LONG_LONG_MAX, minodd = LONG_LONG_MAX;
vector<long long> oarr, earr;
for (long long i = 0; i <= n - 1; i++) {
long long temp;
cin >> temp;
if (temp % 2 == 0) {
earr.push_back(temp);
}
if (temp % 2 == 1) {
oarr.push_back(temp);
}
}
sort(oarr.begin(), oarr.end());
sort(earr.begin(), earr.end());
if (oarr.size() == earr.size() + 1 || earr.size() == oarr.size() + 1 ||
oarr.size() == earr.size()) {
cout << 0 << '\n';
return;
}
long long ans = 0;
if (oarr.size() > earr.size()) {
for (long long i = 1; i <= oarr.size() - earr.size() - 1; i++) {
ans += oarr[i - 1];
}
} else {
for (long long i = 1; i <= earr.size() - oarr.size() - 1; i++) {
ans += earr[i - 1];
}
}
cout << max(ans, ans);
}
int main() {
ios::sync_with_stdio(false);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2010];
int main() {
int n, odd = 0, even = 0, flag;
long long sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] & 1)
odd++;
else
even++;
}
sort(a, a + n);
if (odd == even || abs(odd - even) == 1)
cout << '0' << endl;
else {
if (odd > even) {
flag = odd - even - 1;
sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] & 1) {
sum += a[i];
flag--;
}
if (flag == 0) break;
}
} else {
flag = even - odd - 1;
sum = 0;
for (int i = 0; i < n; i++) {
if ((a[i] & 1) != 1) {
sum += a[i];
flag--;
}
if (flag == 0) break;
}
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
int arr[2005];
int main() {
scanf(" %d", &n);
vector<int> odd, even;
ll tot = 0LL;
for (int i = 1; i <= n; ++i) {
scanf(" %d", &arr[i]);
tot += arr[i];
if (arr[i] % 2) {
odd.push_back(arr[i]);
} else {
even.push_back(arr[i]);
}
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
reverse(odd.begin(), odd.end());
reverse(even.begin(), even.end());
if (even.size() < odd.size()) swap(even, odd);
for (int x : odd) {
tot -= x;
}
for (int i = 0; i < min((int)even.size(), (int)odd.size() + 1); ++i) {
tot -= even[i];
}
printf("%lld\n", tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i, j, k, h = 0;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
;
vector<long long int> e, o;
for (i = 0; i < n; ++i) {
if (a[i] % 2)
o.push_back(a[i]);
else
e.push_back(a[i]);
}
sort(o.begin(), o.end());
sort(e.begin(), e.end());
if (o.size() == e.size() || o.size() == e.size() - 1 ||
o.size() == e.size() + 1)
cout << 0;
else {
if (o.size() > e.size()) {
j = e.size() + 1;
j = o.size() - j;
for (i = 0; i < o.size(); ++i) {
if (i == j) {
break;
}
h += o[i];
}
} else {
j = o.size() + 1;
j = e.size() - j;
for (i = 0; i < e.size(); ++i) {
if (i == j) {
break;
}
h += e[i];
}
}
cout << h;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
vector<int> even, odd;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x % 2 == 0)
even.push_back(x);
else
odd.push_back(x);
}
int a = even.size();
int b = odd.size();
if (a == b)
cout << "0\n";
else if (a < b) {
sort(odd.begin(), odd.end());
reverse(odd.begin(), odd.end());
long long sum = 0;
for (int i = a + 1; i < b; i++) {
sum += odd[i];
}
cout << sum << '\n';
} else {
sort(even.begin(), even.end());
reverse(even.begin(), even.end());
long long sum = 0;
for (int i = b + 1; i < a; i++) {
sum += even[i];
}
cout << sum << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ip;
vector<int> e, o;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> ip;
ans += ip;
if (ip % 2 == 0) {
e.push_back(ip);
} else {
o.push_back(ip);
}
}
sort(e.rbegin(), e.rend());
sort(o.rbegin(), o.rend());
int l1 = e.size(), l2 = o.size();
if (l1 == 0)
ans -= o[0];
else if (l2 == 0)
ans -= e[0];
else {
int turn;
int i1 = 0, i2 = 0;
if (e[0] > o[0])
turn = 0;
else
turn = 1;
for (int i = 1; i <= 2 * min(l1, l2); i++) {
if (turn % 2 == 0)
ans -= e[i1++];
else
ans -= o[i2++];
turn++;
}
if (l1 < l2) {
ans -= o[i2++];
} else if (l1 > l2) {
ans -= e[i1++];
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sumo = 0, sume = 0;
cin >> n;
vector<int> e, o;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x % 2 == 1) {
o.push_back(x);
sumo += x;
} else {
e.push_back(x);
sume += x;
}
}
sort(o.begin(), o.end());
reverse(o.begin(), o.end());
sort(e.begin(), e.end());
reverse(e.begin(), e.end());
int odd = o.size();
int even = e.size();
int ans = 0, tp = 0, ct = 0;
int de = min(odd, even) + 1;
for (int i = 0; i < de; i++) {
if (i < odd) {
tp += o[i];
}
if (i < even) {
ct += e[i];
}
}
if (tp > ct) {
ans = (sume - ct) + (sumo - tp);
} else {
ans = (sumo - tp) + (sume - ct);
}
cout << max(0, ans) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main() {
int a;
while (scanf("%d", &a) != EOF) {
int arr[a];
int arr2[a];
int m1 = 0;
int m2 = 0;
for (int i = 0; i < a; i++) {
int temp;
scanf("%d", &temp);
if (temp % 2 == 0)
arr[m1++] = temp;
else
arr2[m2++] = temp;
}
sort(arr, arr + m1, comp);
sort(arr2, arr2 + m2, comp);
if (m1 - m2 > -2 && m1 - m2 < 2)
printf("0");
else if (m1 == 0) {
long long sum = 0;
for (int i = 1; i < m2; i++) sum += (long long)arr2[i];
printf("%I64d", sum);
} else if (m2 == 0) {
long long sum = 0;
for (int i = 1; i < m1; i++) sum += (long long)arr[i];
printf("%I64d", sum);
} else if (m1 < m2) {
long long sum = 0;
int lol = m2 - m1 - 1;
for (int i = (m2 - lol); i < m2; i++) {
sum += (long long)arr2[i];
}
printf("%I64d", sum);
} else {
long long sum = 0;
int lol = m1 - m2 - 1;
for (int i = (m1 - lol); i < m1; i++) {
sum += (long long)arr[i];
}
printf("%I64d", sum);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
vector<int> odd;
vector<int> even;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
odd.push_back(a[i]);
else
even.push_back(a[i]);
}
if (odd.size() > 0) sort(odd.begin(), odd.end());
if (even.size() > 0) sort(even.begin(), even.end());
long long int ans = 0;
if (odd.size() > even.size()) {
for (int i = 0; i < odd.size() - even.size() - 1; i++) ans = ans + odd[i];
} else if (even.size() > odd.size()) {
for (int i = 0; i < even.size() - odd.size() - 1; i++) ans = ans + even[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
;
multiset<int, greater<int>> so, se;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
if (a % 2) {
so.insert(a);
} else {
se.insert(a);
}
}
bool odd = 0;
if (so.size() > se.size()) odd = 1;
while (true) {
if (odd) {
if (so.size() == 0) break;
so.erase(so.begin());
odd = 0;
} else {
if (se.size() == 0) break;
se.erase(se.begin());
odd = 1;
}
}
long long sum = 0;
while (so.size() > 0) {
sum += (*so.begin());
so.erase(so.begin());
}
while (se.size() > 0) {
sum += (*se.begin());
se.erase(se.begin());
}
cout << sum << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2001;
int a[N];
int t, n;
vector<int> odd;
vector<int> even;
int solve(int n, int a[]) {
int res = 0;
for (int i = 0; i < n; i++)
if (a[i] % 2 == 0)
even.push_back(a[i]);
else
odd.push_back(a[i]);
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
int d = odd.size() - even.size();
if (abs(d) <= 1)
return res;
else if (d >= 2) {
for (int i = 0; i < d - 1; i++) res += odd[i];
return res;
} else if (d <= -2) {
for (int i = 0; i < -d - 1; i++) res += even[i];
return res;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cout << solve(n, a) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, ans, yyy;
vector<int> v1, v2;
inline int read() {
int x = 0;
bool sign = false;
char alpha = 0;
while (!isdigit(alpha)) sign |= alpha == '-', alpha = getchar();
while (isdigit(alpha))
x = (x << 1) + (x << 3) + (alpha ^ 48), alpha = getchar();
return sign ? -x : x;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
x = read();
x & 1 ? v1.push_back(x) : v2.push_back(x);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (v1.size() == 0)
for (int i = 0; i < v2.size() - 1; i++) ans += v2[i];
else if (v2.size() == 0)
for (int i = 0; i < v1.size() - 1; i++) ans += v1[i];
else if (v1.size() - 1 > v2.size())
for (int i = 0; i < v1.size() - v2.size() - 1; i++) ans += v1[i];
else if (v1.size() < v2.size() - 1)
for (int i = 0; i < v2.size() - v1.size() - 1; i++) ans += v2[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, od[2010], ev[2010], cnt1 = 0, cnt2 = 0, sum = 0;
bool cmp(int _, int __) { return _ > __; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
if (a % 2 != 0)
od[++cnt1] = a;
else
ev[++cnt2] = a;
}
sort(od + 1, od + cnt1 + 1, cmp);
sort(ev + 1, ev + cnt2 + 1, cmp);
int x = min(cnt1, cnt2);
int xx = x;
for (++x; x <= max(cnt1, cnt2); x++) sum += od[x] + ev[x];
printf("%d", sum - max(od[xx + 1], ev[xx + 1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, d, e, f, g;
vector<int> v1, v2;
while (cin >> a) {
for (b = 1; b <= a; b++) {
cin >> c;
v1.push_back(c);
}
v2 = v1;
sort(v1.begin(), v1.end());
reverse(v1.begin(), v1.end());
for (b = 1; b <= a; b++) {
d = 0;
for (c = 0; c < v1.size(); c++) {
if (v1[c] != 0 && v1[c] % 2 != 0 && b % 2 != 0) {
v1[c] = 0;
d = 1;
break;
} else if (v1[c] != 0 && v1[c] % 2 == 0 && b % 2 == 0) {
v1[c] = 0;
d = 1;
break;
}
}
if (d == 0) {
break;
}
}
e = 0;
for (c = 0; c < v1.size(); c++) {
e += v1[c];
}
for (b = 1; b <= a; b++) {
d = 0;
for (c = 0; c < v1.size(); c++) {
if (v1[c] != 0 && v1[c] % 2 != 0 && b % 2 == 0) {
v1[c] = 0;
d = 1;
break;
} else if (v1[c] != 0 && v1[c] % 2 == 0 && b % 2 != 0) {
v1[c] = 0;
d = 1;
break;
}
}
if (d == 0) {
break;
}
}
f = 0;
for (c = 0; c < v1.size(); c++) {
f += v1[c];
}
cout << min(e, f) << endl;
v1.clear();
v2.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, n;
long long answer = 0;
vector<long long> odd, even;
int main() {
cin >> N;
for (int it = 0; it < N; ++it) {
cin >> n;
if (1 == n % 2)
odd.push_back(n);
else
even.push_back(n);
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
if (odd.size() < even.size()) {
for (int it = 0; it < ((int)even.size()) - ((int)odd.size()) - 1; ++it) {
answer += even[it];
}
} else {
for (int it = 0; it < ((int)odd.size()) - ((int)even.size()) - 1; ++it) {
answer += odd[it];
}
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, temp, i;
cin >> n;
int even[n], odd[n], evenlen = 0, oddlen = 0;
for (i = 0; i < n; i++) {
cin >> temp;
if (temp % 2 == 0) {
even[evenlen++] = temp;
} else {
odd[oddlen++] = temp;
}
}
long long ans = 0;
sort(even, even + evenlen);
sort(odd, odd + oddlen);
int remove = abs(evenlen - oddlen);
if (oddlen > evenlen) {
--remove;
for (i = 0; i < remove; i++) ans += odd[i];
} else if (oddlen < evenlen) {
--remove;
for (i = 0; i < remove; i++) ans += even[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int t, i, j, n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<long long int> odd, even;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (x % 2 == 0) {
even.push_back(x);
} else {
odd.push_back(x);
}
}
sort(even.begin(), even.end());
reverse(even.begin(), even.end());
sort(odd.begin(), odd.end());
reverse(odd.begin(), odd.end());
long long int index = min(even.size(), odd.size());
long long int sum = 0;
if (even.size() <= odd.size()) {
for (long long int i = index + 1; i < odd.size(); i++) {
sum += odd[i];
}
} else {
for (long long int i = index + 1; i < even.size(); i++) {
sum += even[i];
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n{};
cin >> n;
vector<int> a(n);
int num_odd{}, num_even{};
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0)
num_even++;
else
num_odd++;
}
sort(a.begin(), a.end());
int sum{}, num_rem{};
num_rem = max(num_odd, num_even) - min(num_odd, num_even) - 1;
int i{};
while (num_rem > 0) {
if (num_odd > num_even) {
if (a[i] % 2 != 0) {
sum += a[i];
num_rem--;
}
} else {
if (a[i] % 2 == 0) {
sum += a[i];
num_rem--;
}
}
i++;
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[10000], x, y, k = 0, ans = 0;
bool b[10000];
int main() {
int i, j;
cin >> n;
x = 0;
y = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] % 2 == 1) {
x += 1;
b[i] = 1;
} else {
y += 1;
b[i] = 0;
}
}
if (x == y || x + 1 == y || y + 1 == x)
cout << 0 << endl;
else {
if (x > y) {
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
if (a[i] % 2 == 1 && k != (x - y - 1)) {
ans += a[i];
k += 1;
}
}
cout << ans << endl;
} else {
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
if (a[i] % 2 == 0 && k != (y - x - 1)) {
ans += a[i];
k += 1;
}
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
long long sum = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
vector<int> odd, even;
for (int i = 0; i < n; i++) {
if (arr[i] & 1)
odd.push_back(arr[i]);
else
even.push_back(arr[i]);
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
if (odd.size() > even.size()) {
for (int i = 0; i < odd.size() - even.size() - 1; i++) sum += odd[i];
} else if (odd.size() == even.size())
sum = 0;
else {
for (int i = 0; i < even.size() - odd.size() - 1; i++) sum += even[i];
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k;
cin >> n;
vector<long long> a(n);
long long eve = 0, odd = 0;
long long sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
eve++;
} else {
odd++;
}
sum += a[i];
}
sort(a.begin(), a.end());
if (eve == odd - 1 || odd == eve - 1 || odd == eve) {
cout << 0;
return 0;
}
if (eve == n || odd == n) {
cout << sum - a[n - 1];
return 0;
}
long long sum1 = 0;
if (eve > odd) {
long long xx = eve - odd - 1;
long long c = 0;
for (j = 0; j < n; j++) {
if (c == xx) {
break;
}
if (a[j] % 2 == 0) {
sum1 += a[j];
c++;
}
}
} else {
long long xx = odd - eve - 1;
long long c = 0;
for (j = 0; j < n; j++) {
if (c == xx) {
break;
}
if (a[j] % 2 != 0) {
sum1 += a[j];
}
c++;
}
}
cout << sum1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt;
cin >> cnt;
long long a[cnt + 10];
vector<long long> x, y;
x.clear(), y.clear();
for (int i = 1; i <= cnt; i++) {
cin >> a[i];
if (a[i] % 2 == 0)
x.push_back(a[i]);
else
y.push_back(a[i]);
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
int n = (int)x.size(), m = (int)y.size();
long long sum1 = 0, sum2 = 0;
int l = n, r = m, now = 1;
while (l > 0 && r > 0) {
if (now == 1)
l--, now = 2;
else
r--, now = 1;
}
if (now == 1)
l--;
else if (now == 2)
r--;
for (int i = 0; i < l; i++) sum1 += x[i];
for (int i = 0; i < r; i++) sum1 += y[i];
l = n, r = m, now = 2;
while (l > 0 && r > 0) {
if (now == 1)
l--, now = 2;
else
r--, now = 1;
}
if (now == 1)
l--;
else if (now == 2)
r--;
for (int i = 0; i < l; i++) sum2 += x[i];
for (int i = 0; i < r; i++) sum2 += y[i];
cout << min(sum1, sum2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> a, b;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
if (x % 2 == 0)
a.push_back(x);
else
b.push_back(x);
}
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
long long mn;
long long sum = 0;
if (a.size() == b.size())
sum = 0;
else if (a.size() < b.size()) {
if (a.size() == 0)
b.erase(b.begin());
else
b.erase(b.begin(), b.begin() + a.size() + 1);
sum = accumulate(b.begin(), b.end(), 0);
} else if (a.size() > b.size()) {
if (b.size() == 0)
a.erase(a.begin());
else
a.erase(a.begin(), a.begin() + b.size() + 1);
sum = accumulate(a.begin(), a.end(), 0);
}
cout << sum;
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> odd, even;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x & 1)
odd.push_back(x);
else
even.push_back(x);
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
if (odd.size() == even.size())
cout << 0;
else if (even.size() > odd.size()) {
int sum = 0;
for (int i = 0; i < even.size() - odd.size() - 1; i++) {
sum += even[i];
}
cout << sum;
} else {
int sum = 0;
for (int i = 0; i < odd.size() - even.size() - 1; i++) {
sum += odd[i];
}
cout << sum;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int x, int y) {
if (x % 2 != y % 2) {
return x % 2 == 1;
}
if (x % 2 == 1) {
return x > y;
}
return x < y;
}
int main() {
int n, a[2005], sum1 = 0, sum2 = 0, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] % 2 == 1) {
sum1++;
} else {
sum2++;
}
}
sort(a + 1, a + n + 1, cmp);
if (sum1 >= sum2) {
for (int i = sum2 + 2; i <= n - sum2; i++) {
sum += a[i];
}
} else {
for (int i = sum1 + 1; i <= n - sum1 - 1; i++) {
sum += a[i];
}
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> odd;
vector<int> even;
int main() {
int n;
scanf("%d", &n);
int sum = 0;
int r;
while (n--) {
int tmp;
scanf("%d", &tmp);
sum += tmp;
if (tmp % 2)
odd.push_back(tmp);
else
even.push_back(tmp);
}
sort(odd.rbegin(), odd.rend());
sort(even.rbegin(), even.rend());
int k = min(odd.size(), even.size());
for (int i = 0; i < k; i++) {
sum -= odd[i];
sum -= even[i];
}
if ((int)odd.size() > k) {
sum -= odd[k];
}
if ((int)even.size() > k) {
sum -= even[k];
}
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > q;
int N;
int main() {
ios::sync_with_stdio(false);
cin >> N;
int t;
int es = 0;
int os = 0;
for (int i = 0; i < N; ++i) {
cin >> t;
if (t & 1)
os += 1;
else
es += 1;
q.push(t);
}
if (es == os || abs(es - os) == 1) {
cout << 0 << '\n';
} else {
if (es > os) {
int r = es - os - 1;
int ans = 0;
for (int i = 0; i < N; ++i) {
if (q.top() % 2 == 0) {
ans += q.top();
q.pop();
r -= 1;
} else {
q.pop();
}
if (!r) break;
}
cout << ans << '\n';
} else {
int r = os - es - 1;
int ans = 0;
for (int i = 0; i < N; ++i) {
if (q.top() % 2 == 1) {
ans += q.top();
q.pop();
r -= 1;
} else {
q.pop();
}
if (!r) break;
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> js;
vector<int> ous;
void Init() {
js.clear();
ous.clear();
}
int n;
bool cmp(const int &a, const int &b) { return a < b; }
int main() {
while (~scanf("%d", &n)) {
Init();
for (int i = 0; i < n; i++) {
int ans;
scanf("%d", &ans);
if (ans % 2) {
js.push_back(ans);
} else {
ous.push_back(ans);
}
}
sort(js.begin(), js.end(), cmp);
sort(ous.begin(), ous.end(), cmp);
if (js.size() == ous.size()) {
printf("0\n");
} else if (js.size() > ous.size()) {
int ans = js.size() - ous.size();
ans = ans - 1;
int sum = 0;
for (int i = 0; i < ans; i++) {
sum += js[i];
}
printf("%d\n", sum);
} else {
int ans = ous.size() - js.size();
ans = ans - 1;
int sum = 0;
for (int i = 0; i < ans; i++) {
sum += ous[i];
}
printf("%d\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
long long int i, j, n;
cin >> n;
vector<long long int> a(n);
vector<long long int> even;
vector<long long int> odd;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2) {
odd.push_back(a[i]);
} else {
even.push_back(a[i]);
}
}
if (odd.size() > even.size()) {
swap(odd, even);
}
sort(odd.rbegin(), odd.rend());
sort(even.rbegin(), even.rend());
long long int val = odd.size();
long long int sum = 0;
for (long long int i = val + 1; i < even.size(); i++) {
sum += even[i];
}
cout << sum << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int even = 0, odd = 0;
vector<int> v(n);
for (int& x : v) {
cin >> x;
x % 2 == 1 ? ++odd : ++even;
}
if (min(odd, even) * 2 == n) {
cout << 0;
return 0;
}
sort(v.rbegin(), v.rend());
int sum = 0;
bool taken = false;
even = odd = min(even, odd);
for (int x : v) {
if (not taken and ((x % 2 == 0 and not even) or (x % 2 == 1 and not odd))) {
taken = true;
continue;
}
if (x % 2 == 0)
even ? --even : sum += x;
else
odd ? --odd : sum += x;
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
int a[2005];
int ev = 0, od = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] % 2 == 0)
ev++;
else
od++;
}
if (ev == od || ev + 1 == od || od + 1 == ev)
printf("0\n");
else {
sort(a, a + n);
int nde, sum = 0;
if (od > ev) {
nde = od - ev - 1;
for (int i = 0; i < n; i++) {
if (a[i] % 2 != 0 && nde) {
sum += a[i];
nde--;
}
}
} else {
nde = ev - od - 1;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0 && nde) {
sum += a[i];
nde--;
}
}
}
printf("%d\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int p_mod = 9999999999999983;
const long double pi = 3.14159265358979323;
const long long int N = 1e6 + 9;
const long long int mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rand(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
long long int powerk(long long int x, long long int y);
long long int a[N];
void solve() {
long long int n, m = 0, flag = 0, t = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
t += a[i];
if (a[i] & 1) m++;
}
flag = n - m;
sort(a + 1, a + n + 1);
if (flag > m)
flag = m + 1;
else if (m > flag)
m = flag + 1;
long long int o = 0, e = 0, sum = 0;
for (int i = n; i >= 1; --i) {
if (a[i] & 1) {
if (m) sum += a[i], m--;
} else {
if (flag) sum += a[i], flag--;
}
}
cout << t - sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
}
long long int powerk(long long int x, long long int y) {
if (y == 0) return 1;
if (y == 1) return x % mod;
if (y & 1)
return ((powerk((x * x) % mod, y / 2) % mod) * x) % mod;
else
return powerk((x * x) % mod, y / 2) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, evenele = 0, oddele = 0, s;
cin >> n;
vector<long int> even;
vector<long int> odd;
for (long int i = 0; i < n; i++) {
cin >> s;
if (s % 2 == 0) {
even.push_back(s);
evenele++;
} else {
oddele++;
odd.push_back(s);
}
}
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
if (evenele == oddele) {
cout << 0 << endl;
} else if (evenele > oddele) {
long int ans = 0;
for (long int i = 0; i < (evenele - (oddele + 1)); i++) ans = ans + even[i];
cout << ans << endl;
} else {
long int ans = 0;
for (long int i = 0; i < (oddele - (evenele + 1)); i++) ans = ans + odd[i];
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 != 0) {
ans = (ans * a) % 1000000007;
}
a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
b >>= 1;
}
return ans;
}
void sieve(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p]) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++) {
if (prime[p]) cout << p << " ";
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
long long n, z;
cin >> n;
std::vector<long long> odd, even;
for (long long i = 0; i < n; i++) {
cin >> z;
if (z % 2 == 0)
even.push_back(z);
else
odd.push_back(z);
}
sort(odd.begin(), odd.end(), greater<long long>());
sort(even.begin(), even.end(), greater<long long>());
long long s = 0;
int i = 0, j = 0;
while (i < even.size() && j < odd.size()) {
i++;
j++;
}
i++;
j++;
while (i < even.size()) {
s += even[i];
i++;
}
while (j < odd.size()) {
s += odd[j];
j++;
}
cout << s;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> odd, even;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
sum += x;
if (x & 1)
odd.push_back(x);
else
even.push_back(x);
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
reverse(odd.begin(), odd.end());
reverse(even.begin(), even.end());
int sz = min(odd.size(), even.size());
sum -= accumulate(odd.begin(), odd.begin() + sz, 0);
sum -= accumulate(even.begin(), even.begin() + sz, 0);
if (odd.size() > sz)
sum -= odd[sz];
else if (even.size() > sz)
sum -= even[sz];
printf("%lld\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *arr = new int[n];
int odd = 0, even = 0;
vector<int> oddArr;
vector<int> evenArr;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] % 2 == 0) {
even++;
evenArr.push_back(arr[i]);
} else {
odd++;
oddArr.push_back(arr[i]);
}
}
bool takeEven;
int pick;
bool takeNone = false;
int total = 0;
if (abs(even - odd) - 1 == 0 || even - odd == 0) {
takeNone = true;
} else {
sort(evenArr.begin(), evenArr.end());
sort(oddArr.begin(), oddArr.end());
}
if (!takeNone) {
if (even - odd > 1) {
pick = even - (odd + 1);
for (int i = 0; i < pick; i++) {
total += evenArr[i];
}
} else if (odd - even > 1) {
pick = odd - (even + 1);
for (int i = 0; i < pick; i++) {
total += oddArr[i];
}
}
}
cout << total << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long int> A(n);
for (int i = 0; i < n; i++) cin >> A[i];
int i = 0, j = n - 1;
while (i < j) {
if (!(A[i] & 1) && (A[j] & 1))
i++, j--;
else if ((A[i] & 1) && !(A[j] & 1))
swap(A[i], A[j]), i++, j--;
else if (!(A[i] & 1) && !(A[j] & 1))
i++, swap(A[i], A[j]);
else if ((A[i] & 1) && (A[j] & 1))
j--, swap(A[i], A[j]);
}
int even_it;
if (!(A[0] & 1)) {
for (even_it = 0; !(A[even_it] & 1) && even_it < n; even_it++)
;
sort(A.begin(), A.begin() + even_it);
sort(A.begin() + even_it, A.end(), greater<long long int>());
} else {
even_it = -1;
sort(A.begin(), A.end(), greater<long long int>());
}
int even_no, odd_no, t;
if (even_it == -1)
even_no = 0, odd_no = n;
else
even_no = even_it, odd_no = n - even_it;
if ((even_no == odd_no) || abs(even_no - odd_no) == 1)
cout << "0\n";
else if (even_no > odd_no) {
t = even_no - odd_no - 1, i = 0;
long long int res = accumulate(A.begin(), A.begin() + t, 0);
cout << res << "\n";
} else {
t = odd_no - even_no - 1, i = n - 1;
long long int res = 0;
while (t--) {
res += A[i];
i--;
}
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc;
long long n;
cin >> n;
long long a[n + 5];
long long odd = 0, even = 0;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
odd++;
else
even++;
sum += a[i];
}
sort(a, a + n);
if (odd == even || abs(odd - even) == 1)
cout << 0 << endl;
else {
if (odd > even) {
odd = even + 1;
for (int i = n - 1; i >= 0; i--) {
if (odd > 0 && a[i] % 2 == 1) {
sum -= a[i];
odd--;
} else if (even > 0 && a[i] % 2 == 0) {
sum -= a[i];
even--;
}
}
} else if (odd < even) {
even = odd + 1;
for (int i = n - 1; i >= 0; i--) {
if (odd > 0 && a[i] % 2 == 1) {
sum -= a[i];
odd--;
} else if (even > 0 && a[i] % 2 == 0) {
sum -= a[i];
even--;
}
}
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2005];
int main() {
int n;
cin >> n;
int jj = 0, oo = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0)
jj++;
else
oo++;
}
if (jj == oo || abs(jj - oo) == 1) {
cout << "0" << endl;
return 0;
}
sort(a, a + n);
if (jj > oo) {
long long int ans = 0;
int l = jj - oo - 1;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
ans += a[i];
l--;
}
if (l == 0) break;
}
cout << ans << endl;
}
if (oo > jj) {
long long int ans = 0;
int l = oo - jj - 1;
for (int i = 0; i < n; i++) {
if (a[i] % 2 != 0) {
ans += a[i];
l--;
}
if (l == 0) break;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod_exp(long long x, long long y, long long mm) {
if (y == 0)
return (1);
else if (y % 2 == 0)
return (mod_exp((x * x) % mm, y / 2, mm));
else
return ((x * mod_exp((x * x) % mm, (y - 1) / 2, mm)) % mm);
}
void subset_sum(long long x[], long long n, set<long long>& z) {
long long t = 1 << n, sum;
for (long long i = 0; i < t; i++) {
sum = 0;
for (long long j = 0; j < n; j++) {
if (i & (1 << j)) sum += x[j];
}
z.insert(sum);
}
}
int main() {
long long sum, n, z;
cin >> n;
vector<long long> o, e;
for (long long i = 0; i < n; i++) {
cin >> z;
if (z % 2 == 0)
e.push_back(z);
else
o.push_back(z);
}
sort(e.begin(), e.end());
sort(o.begin(), o.end());
if (e.size() > o.size()) {
reverse(e.begin(), e.end());
sum = accumulate(o.begin(), o.end(), 0);
for (long long i = 0; i < o.size() + 1; i++) sum = sum + e[i];
} else if (e.size() < o.size()) {
reverse(o.begin(), o.end());
sum = accumulate(e.begin(), e.end(), 0);
for (long long i = 0; i < e.size() + 1; i++) sum = sum + o[i];
} else
sum = accumulate(e.begin(), e.end(), 0) + accumulate(o.begin(), o.end(), 0);
cout << accumulate(e.begin(), e.end(), 0) +
accumulate(o.begin(), o.end(), 0) - sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
vector<int> odd, even;
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 0)
odd.push_back(arr[i]);
else
even.push_back(arr[i]);
}
sort(odd.begin(), odd.end());
sort(even.begin(), even.end());
if (odd.size() < even.size()) {
int k = even.size() - odd.size() - 2;
long long int sum = 0;
while (k >= 0) {
sum += even[k];
k--;
}
cout << sum;
} else {
int k = odd.size() - even.size() - 2;
long long int sum = 0;
while (k >= 0) {
sum += odd[k];
k--;
}
cout << sum;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a[2005], ans = 0;
vector<int> odd;
vector<int> even;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if ((a[i] % 2) == 0)
even.push_back(a[i]);
else
odd.push_back(a[i]);
}
sort(odd.rbegin(), odd.rend());
sort(even.rbegin(), even.rend());
if (odd.size() > even.size())
for (int i = even.size() + 1; i < odd.size(); i++) ans += odd[i];
else
for (int i = odd.size() + 1; i < even.size(); i++) ans += even[i];
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.