text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > tab;
vector<pair<int, int> > kar;
vector<int> res[1010];
int main(int argc, char** argv) {
int n, k;
cin >> n >> k;
int c, t;
for (int i = 0; i < n; ++i) {
cin >> c >> t;
if (t == 1)
tab.push_back(make_pair(c, i + 1));
else
kar.push_back(make_pair(c, i + 1));
}
long long ans = 0;
sort(tab.begin(), tab.end());
sort(kar.begin(), kar.end());
int curres = 0;
for (int i = 0; i < min(k - 1, (int)tab.size()); ++i) {
ans += ((long long)tab[tab.size() - 1 - i].first);
res[curres++].push_back(tab[tab.size() - 1 - i].second);
}
int lk = ans % 2;
ans /= 2;
if (tab.size() >= k) {
for (int i = 0; i < (tab.size() - k + 1); ++i) {
ans += tab[i].first;
res[k - 1].push_back(tab[i].second);
}
int v;
if (kar.size() > 0) {
if (tab.size() > 0)
v = min(tab[0].first, kar[0].first);
else
v = kar[0].first;
} else
v = tab[0].first;
if (v % 2) {
if (lk) {
++ans;
lk = 0;
} else
lk = 1;
}
ans -= (v / 2 + v % 2);
for (int i = 0; i < kar.size(); ++i) {
ans += kar[i].first;
res[k - 1].push_back(kar[i].second);
}
} else {
int tp = 0;
for (int i = 0; i < k - tab.size() - 1; ++i) {
res[curres++].push_back(kar[i].second);
++tp;
}
for (int i = tp; i < kar.size(); ++i) {
res[k - 1].push_back(kar[i].second);
}
for (int i = 0; i < kar.size(); ++i) ans += kar[i].first;
}
cout << ans;
if (lk) {
cout << ".5" << endl;
} else
cout << ".0" << endl;
for (int i = 0; i < k; ++i) {
cout << res[i].size() << " ";
for (int j = 0; j < res[i].size(); ++j) cout << res[i][j] << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:1600000000")
const int MAXN = 1005;
struct elem {
int c, t, num;
bool operator<(const elem& A) const {
if (t == 1 && A.t == 1) return c > A.c;
if (t == 1 && A.t == 2) return true;
if (t == 2 && A.t == 1) return false;
if (t == 2 && A.t == 2) return c > A.c;
return false;
}
};
int n, k;
elem a[MAXN];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i].c >> a[i].t;
a[i].num = i + 1;
}
sort(a, a + n);
double ans = 0;
for (int i = 0; i < k - 1; i++)
if (a[i].t == 1)
ans += 0.5 * a[i].c;
else
ans += a[i].c;
for (int i = k - 1; i < n; i++) ans += a[i].c;
if (a[k - 1].t == 1) {
int minn = a[k - 1].c;
for (int j = k; j < n; j++)
if (a[j].c < minn) minn = a[j].c;
ans -= 0.5 * minn;
}
cout.precision(1);
cout.setf(ios_base::fixed);
cout << ans << '\n';
for (int i = 0; i < k - 1; i++) cout << "1 " << a[i].num << '\n';
cout << n - k + 1 << ' ';
for (int i = k - 1; i < n; i++) cout << a[i].num << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 1005;
int n, k, c[K], t[K];
vector<pair<int, int> > v[2];
vector<int> sol[K];
void read() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &c[i], &t[i]);
v[t[i] - 1].push_back(make_pair(c[i], i));
}
}
void solve() {
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
for (int i = 1; i <= k && !v[0].empty(); ++i) {
sol[i].push_back(v[0][v[0].size() - 1].second);
v[0].pop_back();
}
for (int i = k; i >= 1; --i)
if (sol[i].empty()) {
sol[i].push_back(v[1][v[1].size() - 1].second);
v[1].pop_back();
}
while (!v[0].empty()) {
sol[k].push_back(v[0][v[0].size() - 1].second);
v[0].pop_back();
}
while (!v[1].empty()) {
sol[k].push_back(v[1][v[1].size() - 1].second);
v[1].pop_back();
}
}
double calc(vector<int> a) {
double rez = 0, min = 0;
bool red = 0;
for (int i = 0; i < (int)a.size(); ++i) {
if (t[a[i]] == 1) red = 1;
if (c[a[i]] < min || min == 0) min = c[a[i]];
rez += c[a[i]];
}
if (red) {
rez -= min;
rez += 1.0 * min / 2.0;
}
return rez;
}
void compute() {
double rez = 0;
for (int i = 1; i <= k; ++i) rez += calc(sol[i]);
printf("%.1lf\n", rez);
for (int i = 1; i <= k; ++i) {
printf("%d ", (int)sol[i].size());
for (int j = 0; j < (int)sol[i].size(); ++j) printf("%d ", sol[i][j]);
printf("\n");
}
}
int main() {
read();
solve();
compute();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
double p;
int s, n, t;
bool operator<(const node &t) const {
if (s != t.s) return s < t.s;
return p > t.p;
}
} f[1100];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
int cc = 0;
double ans = 0;
for (int i = 0; i < n; i++) {
scanf("%lf%d", &f[i].p, &f[i].s);
f[i].n = i + 1;
f[i].t = 0;
if (f[i].s == 1) cc++;
ans += f[i].p;
}
sort(f, f + n);
k--;
if (cc <= k) {
for (int i = 0; i < cc; i++) {
ans -= f[i].p * .5;
}
printf("%.1f\n", ans);
for (int i = 0; i < cc; i++) {
printf("%d %d\n", 1, f[i].n);
}
k -= cc;
while (k--) {
printf("1 %d\n", f[cc].n);
cc++;
}
printf("%d", n - cc);
for (int i = cc; i < n; i++) {
printf(" %d", f[i].n);
}
puts("");
} else {
for (int i = 0; i < k; i++) {
ans -= f[i].p * .5;
}
double mi = 23452352345.0;
for (int i = k; i < n; i++) {
mi = min(f[i].p, mi);
}
ans -= mi * .5;
printf("%.1f\n", ans);
for (int i = 0; i < k; i++) {
printf("%d %d\n", 1, f[i].n);
}
int p = n - k;
printf("%d", p);
for (int i = k; i < n; i++) {
printf(" %d", f[i].n);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int c, t, id;
bool operator<(const Node &p) const { return c > p.c; }
} a[1005];
double mv[1005];
bool yes[1005];
vector<pair<int, int> > v[1005];
int main() {
int n, K;
cin >> n >> K;
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].c, &a[i].t);
a[i].id = i + 1;
}
sort(a, a + n);
fill(mv, mv + n, 1e20);
int cur = 0;
for (int i = 0; i < n; i++) {
if (a[i].t == 1) {
yes[cur] = 1;
v[cur].push_back(make_pair(a[i].c, a[i].id));
mv[cur] = min(mv[cur], a[i].c * 1.0);
if (cur < K - 1) {
cur++;
}
}
}
for (int i = 0; i < n; i++) {
if (a[i].t == 2) {
v[cur].push_back(make_pair(a[i].c, a[i].id));
mv[cur] = min(mv[cur], a[i].c * 1.0);
if (cur < K - 1) {
cur++;
}
}
}
double ret = 0;
for (int i = 0; i < K; i++) {
for (int j = 0; j < v[i].size(); j++) {
ret += v[i][j].first;
}
if (yes[i]) {
ret -= 0.5 * mv[i];
}
}
printf("%.1f\n", ret);
for (int i = 0; i < K; i++) {
printf("%d", v[i].size());
for (int j = 0; j < v[i].size(); j++) {
printf(" %d", v[i][j].second);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int c[1001], t[1001];
pair<int, int> stool[1001], pencil[1001];
vector<int> cart[1001];
int main() {
scanf("%d %d", &n, &k);
int stoolNum = 0, pencilNum = 0;
for (int i = 0; i < n; i++) {
int tempA, tempB;
scanf("%d %d", &tempA, &tempB);
if (tempB == 1) {
stool[stoolNum].first = tempA;
stool[stoolNum].second = i + 1;
stoolNum++;
} else {
pencil[pencilNum].first = tempA;
pencil[pencilNum].second = i + 1;
pencilNum++;
}
}
sort(stool, stool + stoolNum);
reverse(stool, stool + stoolNum);
sort(pencil, pencil + pencilNum);
double sum = 0.0;
int lit = 2000000000;
if (k <= stoolNum) {
for (int i = 0; i < stoolNum; i++) {
cart[min(i, k - 1)].push_back(stool[i].second);
if (i < k - 1)
sum += (double)stool[i].first / 2.0;
else {
lit = min(lit, stool[i].first);
sum += stool[i].first;
}
}
for (int i = 0; i < pencilNum; i++) {
cart[k - 1].push_back(pencil[i].second);
lit = min(lit, pencil[i].first);
sum += pencil[i].first;
}
sum = sum - (double)lit / 2.0;
} else {
for (int i = 0; i < stoolNum; i++) {
cart[i].push_back(stool[i].second);
sum += (double)stool[i].first / 2.0;
}
for (int i = 0; i < pencilNum; i++) {
cart[min(i + stoolNum, k - 1)].push_back(pencil[i].second);
sum += (double)pencil[i].first;
}
}
printf("%.1f\n", sum);
for (int i = 0; i < k; i++) {
printf("%d ", cart[i].size());
for (int j = 0; j < cart[i].size() - 1; j++) printf("%d ", cart[i][j]);
printf("%d\n", cart[i][cart[i].size() - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
vector<pair<int, int> > type[2];
vector<int> ans[N];
int a[N], t[N];
int main() {
int n, k;
while (scanf("%d %d", &n, &k) == 2) {
type[0].clear();
type[1].clear();
for (int i = 0; i < int(k); i++) ans[i].clear();
for (int i = 0; i < int(n); i++) {
scanf("%d %d", &a[i], &t[i]);
type[t[i] - 1].push_back(make_pair(a[i], i));
}
long long full = 0, half = 0;
sort(type[0].begin(), type[0].end(), greater<pair<int, int> >());
sort(type[1].begin(), type[1].end(), greater<pair<int, int> >());
if (type[0].size() < k) {
for (int i = 0; i < int(type[0].size()); i++)
ans[i].push_back(type[0][i].second);
for (int i = 0; i < int(type[0].size()); i++) half += type[0][i].first;
for (int i = 0; i < int(type[1].size()); i++) full += type[1][i].first;
int s = k - type[0].size(), beg = type[0].size();
for (int i = 0; i < int(type[1].size()); i++) {
ans[beg + i % s].push_back(type[1][i].second);
}
} else {
for (int i = 0; i < int(k); i++) ans[i].push_back(type[0][i].second);
for (int i = k; i < int(type[0].size()); i++)
ans[k - 1].push_back(type[0][i].second);
for (int i = 0; i < int(k - 1); i++) half += a[ans[i][0]];
int idx = -1;
for (int i = 0; i < int(type[1].size()); i++)
ans[k - 1].push_back(type[1][i].second);
for (int i = 0; i < int(ans[k - 1].size()); i++) {
if (idx == -1 || a[ans[k - 1][idx]] > a[ans[k - 1][i]]) idx = i;
}
for (int i = 0; i < int(ans[k - 1].size()); i++)
if (i == idx)
half += a[ans[k - 1][i]];
else
full += a[ans[k - 1][i]];
}
printf("%I64d.%c\n", full + half / 2, (half & 1) == 1 ? '5' : '0');
for (int i = 0; i < int(k); i++) {
printf("%d", ans[i].size());
for (int a : ans[i]) printf(" %d", a + 1);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct things {
int va, ty, yu;
};
things a[10000];
int n, k, t = 1, s = 0;
int th[1100][1100];
int operator<(things a, things b) { return a.va < b.va; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].va, &a[i].ty);
a[i].yu = i;
if (a[i].ty == 1) s++;
}
if (s < k) {
double sum = 0;
for (int i = 1; i <= n; ++i)
if (a[i].ty == 1)
sum += a[i].va / 2.0;
else
sum += a[i].va;
printf("%.1lf\n", sum);
for (int i = 1; i <= n; ++i)
if (a[i].ty == 1) printf("1 %d\n", a[i].yu);
for (int i = 1; i <= n; ++i)
if (a[i].ty == 2) {
s++;
if (s < k)
printf("1 %d\n", a[i].yu);
else {
printf("%d", n - k + 1);
for (; i <= n; ++i)
if (a[i].ty == 2) printf(" %d", a[i].yu);
}
}
return 0;
}
double sum = 0;
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; --i) {
th[t][++th[t][0]] = a[i].yu;
sum = sum + a[i].va;
if (a[i].ty == 1 && t < k) {
t++;
sum = sum - (double)(a[i].va) / 2;
}
}
sum = sum - (double)(a[1].va) / 2;
printf("%.1lf\n", sum);
for (int i = 1; i <= t; ++i) {
printf("%d", th[i][0]);
for (int j = 1; j <= th[i][0]; ++j) printf(" %d", th[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int inf = 0x3f3f3f3f;
const int modu = 1e9 + 7;
int t, n, m, k, p, q, cnta, cntb;
double sum, res, ans;
struct pen {
int money;
int num;
int pp;
} a[maxn];
vector<int> ve[110];
bool cmp(const pen a, const pen b) {
return a.pp == b.pp ? a.money > b.money : a.pp < b.pp;
}
int main() {
cnta = inf;
sum = 0;
res = 0;
sum = 0;
memset(a, 0, sizeof(a));
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> p >> q;
cnta = min(cnta, p);
a[i].money = p;
a[i].pp = q;
a[i].num = i + 1;
}
sort(a, a + n, cmp);
int j;
for (j = 0; j < k - 1 && a[j].pp == 1; j++) {
sum += a[j].money * 0.5;
}
if (a[k - 1].pp == 1) sum -= cnta * 0.5;
for (j; j < n; j++) {
sum += a[j].money;
}
printf("%.1f\n", sum);
for (int i = 0; i < k - 1; ++i) {
printf("1 %d\n", a[i].num);
}
cout << n - k + 1;
for (int i = k - 1; i < n; ++i) {
printf(" %d", a[i].num);
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5 + 1e3;
int ans[N][N];
int cnt[N];
int has[N];
int idx[N];
int main() {
int n, k, c, t;
double cost = 0.0;
scanf("%d%d", &n, &k);
vector<pair<int, int> > v1, v2;
for (int i = 0; i < int(n); i++) {
scanf("%d%d", &c, &t);
if (t == 1)
v1.push_back({c, i + 1});
else
v2.push_back({c, i + 1});
idx[i + 1] = c;
}
sort(v1.rbegin(), v1.rend());
for (int i = 0; i < int(k); i++) {
if (i == int(v1.size())) break;
ans[i][cnt[i]++] = v1[i].second;
has[i] = 1;
}
bool flag = 0;
for (int i = int(k); i <= int(int(v1.size()) - 1); i++) {
ans[k - 1][cnt[k - 1]++] = v1[i].second;
flag = 1;
}
if (flag) {
for (int i = 0; i < int(int(v2.size())); i++)
ans[k - 1][cnt[k - 1]++] = v2[i].second;
} else {
int j = int(v1.size());
if (j >= k) j = k - 1;
for (int i = 0; i < int(int(v2.size())); i++) {
ans[j][cnt[j]++] = v2[i].second;
j++;
if (j >= k) j = k - 1;
}
}
for (int i = 0; i < int(k); i++) {
if (has[i]) {
int mn = 1e9;
for (int j = 0; j < int(cnt[i]); j++)
mn = min(mn, idx[ans[i][j]]), cost += idx[ans[i][j]];
cost -= double(mn) * 0.5;
} else {
for (int j = 0; j < int(cnt[i]); j++) cost += idx[ans[i][j]];
}
}
printf("%.1f\n", cost);
for (int i = 0; i < int(k); i++) {
printf("%d", cnt[i]);
for (int j = 0; j < int(cnt[i]); j++) printf(" %d", ans[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const long long int INF = 1000000000000000000ll;
vector<pair<int, int> > pen;
vector<pair<int, int> > st;
long long int dp[1001][1001];
long long int rec(int N, int K) {
if (N == 0) {
if (K > 0) return INF;
if (K == 0) return 0;
}
long long int& ret = dp[N][K];
}
int main() {
cin >> n >> k;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
sum += 2 * a;
if (b == 1)
st.push_back(pair<int, int>(2 * a, i));
else
pen.push_back(pair<int, int>(2 * a, i));
}
int K = k;
sort(st.begin(), st.end());
sort(pen.begin(), pen.end());
vector<int> items[1001];
if (st.size() >= k) {
int i;
for (i = st.size() - 1; k > 1; i--, k--) {
sum -= st[i].first / 2;
items[k - 1].push_back(st[i].second);
}
for (int j = 0; j <= i; j++) items[0].push_back(st[j].second);
for (int j = pen.size() - 1; j >= 0; j--) items[0].push_back(pen[j].second);
if (pen.size() > 0)
sum -= (min(st[0].first, pen[0].first)) / 2;
else
sum -= st[0].first / 2;
} else {
for (int i = st.size() - 1; i >= 0; k--, i--) {
sum -= st[i].first / 2;
items[k - 1].push_back(st[i].second);
}
int p = pen.size() - 1;
while (k > 0) {
items[k - 1].push_back(pen[p].second);
k--;
p--;
}
while (p >= 0) {
items[0].push_back(pen[p].second);
p--;
}
}
if (sum % 2 == 0)
cout << sum / 2 << ".0" << endl;
else
cout << sum / 2 << ".5\n";
for (int i = 0; i < K; i++) {
cout << items[i].size() << " ";
for (int j = items[i].size() - 1; j >= 0; j--)
cout << items[i][j] + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100100];
vector<int> cart[100100];
int id[100100];
int n, K;
double ans;
bool cmp(int x, int y) { return a[x].first < a[y].first; }
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
id[i] = i;
}
sort(id, id + n, cmp);
int cur = 0;
for (int i = n - 1; i >= 0; i--)
if (a[id[i]].second == 1) {
if (cart[K - 1].size() == 0)
ans += a[id[i]].first / 2.0;
else
ans += a[id[i]].first;
cart[cur].push_back(id[i]);
if (cur < K - 1) cur++;
}
if (cart[K - 1].size() == 0) {
for (int i = 0; i < n; i++)
if (a[id[i]].second == 2) {
cart[cur].push_back(id[i]);
if (cur < K - 1) cur++;
ans += a[id[i]].first;
}
} else {
ans += a[cart[K - 1][0]].first / 2.0;
for (int i = 0; i < n; i++)
if (a[id[i]].second == 2) {
cart[K - 1].push_back(id[i]);
ans += a[id[i]].first;
}
sort(cart[K - 1].begin(), cart[K - 1].end(), cmp);
ans -= a[cart[K - 1][0]].first / 2.0;
}
printf("%0.1lf\n", ans);
for (int i = 0; i < K; i++) {
printf("%d ", cart[i].size());
for (int j = 0; j < cart[i].size(); j++) printf("%d ", cart[i][j] + 1);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int id, c, t;
} pnt[100006];
bool cmp1(point p1, point p2) {
if (p1.t != p2.t) return p1.t < p2.t;
return p1.c > p2.c;
}
int main() {
int n, k, i, j, cnt, min1;
double ansn = 0;
scanf("%d%d", &n, &k), cnt = k - 1;
for (i = 1; i <= n; i++) scanf("%d%d", &pnt[i].c, &pnt[i].t), pnt[i].id = i;
sort(pnt + 1, pnt + 1 + n, cmp1);
for (i = 1; i <= n && cnt && pnt[i].t == 1; i++) {
ansn += pnt[i].c * 0.5, cnt--;
}
if (pnt[i].t == 1) {
min1 = pnt[i].c, j = i + 1;
for (; j <= n; j++) {
if (min1 > pnt[j].c) min1 = pnt[j].c;
}
}
j = i;
for (; j <= n; j++) {
ansn += pnt[j].c;
}
if (pnt[i].t == 1) ansn -= min1 * 0.5;
printf("%.1lf\n", ansn);
for (i = 1; i <= k - cnt - 1; i++) cout << "1 " << pnt[i].id << endl;
for (; i <= k - 1; i++) cout << "1 " << pnt[i].id << endl;
cout << n - k + 1;
for (i = k; i <= n; i++) {
cout << " " << pnt[i].id;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void sc(char& c) {
char temp[4];
scanf("%s", temp);
c = temp[0];
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
void debugarr(int* arr, int n) {
cout << "[";
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << "]" << endl;
}
int testnum;
int k, n;
vector<pair<int, int> > stool;
vector<pair<int, int> > other;
double ans;
vector<vector<int> > carts;
void preprocess() {}
void solve() {
sort(stool.begin(), stool.end(), greater<pair<int, int> >());
int a = stool.size();
carts.resize(k);
ans = 0;
if (a >= k - 1) {
for (int i = 0; i < k - 1; i++) {
carts[i].push_back(stool[i].second);
ans += stool[i].first / 2.0;
}
double last = 0;
double least = (int)1e9 + 1;
for (int i = k - 1; i < a; i++) {
carts[k - 1].push_back(stool[i].second);
last += stool[i].first;
least = min(least, (double)stool[i].first);
}
for (int i = 0; i < other.size(); i++) {
carts[k - 1].push_back(other[i].second);
last += other[i].first;
least = min(least, (double)other[i].first);
}
if (a >= k) last = last - least / 2.0;
ans += last;
} else {
for (int i = 0; i < a; i++) {
carts[i].push_back(stool[i].second);
ans += stool[i].first / 2.0;
}
for (int i = 0; i < k - 1 - a; i++) {
carts[a + i].push_back(other[i].second);
ans += other[i].first;
}
for (int i = k - 1 - a; i < other.size(); i++) {
carts[k - 1].push_back(other[i].second);
ans += other[i].first;
}
}
printf("%.1f\n", ans);
for (int i = 0; i < k; i++) {
printf("%d", carts[i].size());
for (int j = 0; j < carts[i].size(); j++) printf(" %d", carts[i][j]);
printf("\n");
}
}
bool input() {
scanf("%d", &n);
scanf("%d", &k);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
if (b == 1)
stool.push_back(make_pair(a, i + 1));
else
other.push_back(make_pair(a, i + 1));
}
return true;
}
int main() {
preprocess();
int T = 1;
for (testnum = 1; testnum <= T; testnum++) {
if (!input()) break;
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int cart[3010][3010], n, k;
struct node {
int id;
int price;
} stool[3010], pen[3010], a[3010];
bool cmp(node a, node b) { return a.price > b.price; }
int main() {
int c, t, x, y, z;
long long sum;
long long disc;
int mindisc;
while (~scanf("%d%d", &n, &k)) {
x = y = z = 0;
sum = disc = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &c, &t);
sum += c;
if (t == 1) {
stool[x].id = i + 1;
stool[x++].price = c;
} else {
pen[y].id = i + 1;
pen[y++].price = c;
}
}
sort(stool, stool + x, cmp);
if (x <= k) {
for (int i = 0; i < x; i++) {
cart[i][0] = stool[i].id;
disc += stool[i].price;
mindisc = stool[i].price;
}
for (int i = 0; i < y; i++) {
if (x + i < k)
cart[x + i][0] = pen[i].id;
else {
a[z].id = pen[i].id;
a[z++].price = pen[i].price;
}
}
} else {
for (int i = 0; i < x; i++) {
if (i < k) {
cart[i][0] = stool[i].id;
disc += stool[i].price;
mindisc = stool[i].price;
} else {
a[z].id = stool[i].id;
a[z++].price = stool[i].price;
}
}
for (int i = 0; i < y; i++) {
a[z].id = pen[i].id;
a[z++].price = pen[i].price;
}
}
sort(a, a + z, cmp);
disc -= mindisc;
if (x >= k && z > 0) mindisc = min(mindisc, a[z - 1].price);
disc += mindisc;
for (int i = 0; i < z; i++) cart[k - 1][1 + i] = a[i].id;
printf("%.1lf\n", 1.0 * sum - disc / 2.0);
for (int i = 0; i < k - 1; i++) printf("1 %d\n", cart[i][0]);
printf("%d", z + 1);
for (int i = 0; i <= z; i++) printf(" %d", cart[k - 1][i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int> > v1, v2;
vector<pair<int, int> > cart[1111];
double ans = 0;
int has1[1111];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int c, t;
cin >> c >> t;
if (t == 1) {
v1.push_back(make_pair(c, i));
} else {
v2.push_back(make_pair(c, i));
}
}
sort(v1.begin(), v1.end());
reverse(v1.begin(), v1.end());
for (int i = 0; i < v1.size() && i < k - 1; i++) {
cart[i].push_back(v1[i]);
has1[i] = 1;
}
for (int i = k - 1; i < v1.size(); i++) {
cart[k - 1].push_back(v1[i]);
has1[i] = 1;
}
if (v1.size() >= k - 1) {
for (int i = 0; i < v2.size(); i++) {
cart[k - 1].push_back(v2[i]);
}
} else {
for (int i = 0; i < v2.size(); i++) {
cart[min(i + (int)v1.size(), k - 1)].push_back(v2[i]);
}
}
for (int i = 0; i < k; i++) {
int minV = 2000000000;
for (int j = 0; j < cart[i].size(); j++) {
ans += cart[i][j].first;
minV = min(minV, cart[i][j].first);
}
if (has1[i]) {
ans -= minV / 2.0;
}
}
printf("%.1lf\n", ans);
for (int i = 0; i < k; i++) {
cout << cart[i].size();
for (int j = 0; j < cart[i].size(); j++) {
cout << " " << cart[i][j].second + 1;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1007;
int c[N], t[N];
bool cmp(int i, int j) { return c[i] > c[j]; }
int main() {
int n, k;
cin >> n >> k;
vector<int> v[3];
for (int i = 0; i < n; ++i) {
cin >> c[i] >> t[i];
v[t[i]].push_back(i);
}
sort((v[1]).begin(), (v[1]).end(), cmp);
int sz = (int)((v[1]).size()), uu = (int)((v[2]).size());
double sum = 0;
if (sz < k) {
for (int i = 0; i < sz; ++i) sum += (double)c[v[1][i]] / 2;
for (int i = 0; i < uu; ++i) sum += c[v[2][i]];
cout << fixed << setprecision(1) << sum << '\n';
for (int i = 0; i < sz; ++i) cout << 1 << ' ' << v[1][i] + 1 << '\n';
for (int i = 0; i < k - sz - 1; ++i)
cout << 1 << ' ' << v[2][i] + 1 << '\n';
cout << (n - (k - 1)) << ' ';
for (int i = k - sz - 1; i < n - sz; ++i) cout << v[2][i] + 1 << ' ';
cout << '\n';
} else {
for (int i = 0; i < k - 1; ++i) sum += (double)c[v[1][i]] / 2;
int mini = 1000000000;
for (int i = k - 1; i < sz; ++i) {
sum += c[v[1][i]];
mini = min(mini, c[v[1][i]]);
}
for (int i = 0; i < uu; ++i) {
sum += c[v[2][i]];
mini = min(mini, c[v[2][i]]);
}
sum -= (double)mini / 2;
cout << fixed << setprecision(1) << sum << '\n';
for (int i = 0; i < k - 1; ++i) cout << 1 << ' ' << v[1][i] + 1 << '\n';
cout << (n - (k - 1)) << ' ';
for (int i = k - 1; i < sz; ++i) cout << v[1][i] + 1 << ' ';
for (int i = 0; i < uu; ++i) cout << v[2][i] + 1 << ' ';
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
pair<int, int> ss[1 << 20];
int pi[1 << 20];
int S, P;
int main() {
cin >> n >> k;
long double sum = 0;
int small = 1e9;
for (int i = 0; i < n; ++i) {
int c, t;
cin >> c >> t;
sum += c;
if (t == 1)
ss[S++] = pair<int, int>(c, i + 1);
else
pi[P++] = i + 1;
small = min(small, c);
}
sort(ss, ss + S);
reverse(ss, ss + S);
for (int i = 0; i < min(k - 1, S); ++i) {
sum -= .5 * ss[i].first;
}
if (k - 1 < S) sum -= .5 * small;
cout << fixed << setprecision(1) << sum << '\n';
for (int i = 0; i < k - 1; ++i) {
if (i < S)
cout << 1 << ' ' << ss[i].second << '\n';
else
cout << 1 << ' ' << pi[--P] << '\n';
}
if (k <= S) {
cout << S + 1 - k + P;
for (int i = k - 1; i < S; ++i) cout << ' ' << ss[i].second;
} else {
cout << P;
}
for (int i = 0; i < P; ++i) cout << ' ' << pi[i];
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > stool;
vector<pair<int, int> > pencil;
vector<pair<int, int> > ans[1111];
bool iss[100005];
int main() {
int n = ({
int x;
scanf("%d", &x);
x;
}),
k = ({
int x;
scanf("%d", &x);
x;
});
for (int _n(n), i(0); i < _n; i++) {
int c = ({
int x;
scanf("%d", &x);
x;
}),
t = ({
int x;
scanf("%d", &x);
x;
});
if (t == 1)
stool.push_back(make_pair(c, i + 1));
else
pencil.push_back(make_pair(c, i + 1));
if (t == 1) iss[i + 1] = true;
}
sort((stool).begin(), (stool).end());
sort((pencil).begin(), (pencil).end());
int si = int(stool.size()) - 1, pi = int(pencil.size()) - 1,
sleft = int(stool.size()), pleft = int(pencil.size());
int ind = 0;
for (int i = 0; i < min(int(stool.size()), k); i++)
ans[ind++].push_back(stool[si--]);
if (ind == k) {
while (si >= 0) ans[k - 1].push_back(stool[si--]);
while (pi >= 0) ans[k - 1].push_back(pencil[pi--]);
} else {
while (ind < k) ans[ind++].push_back(pencil[pi--]);
while (pi >= 0) ans[k - 1].push_back(pencil[pi--]);
}
double score = 0;
for (int _n(k), i(0); i < _n; i++) {
int mn = (int)1e9;
bool sss = false;
for (typeof((ans[i]).begin()) it = (ans[i]).begin(); it != (ans[i]).end();
it++) {
int cst = it->first, ind = it->second;
mn = min(mn, cst);
if (iss[ind]) sss = true;
score += cst;
}
if (sss) score -= mn / 2.;
}
printf("%.1lf\n", score);
for (int _n(k), i(0); i < _n; i++) {
printf("%d", int(ans[i].size()));
for (typeof((ans[i]).begin()) it = (ans[i]).begin(); it != (ans[i]).end();
it++)
printf(" %d", it->second);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
vector<pair<int, int> > ve[3];
vector<int> temp, res;
bool cmp(pair<int, int> p, pair<int, int> q) { return p.first > q.first; }
int main() {
int n, k, c, t, cnt, num1, num2, minnum;
double sum;
while (cin >> n >> k) {
for (int i = 0; i <= 2; ++i) {
ve[i].clear();
}
temp.clear();
res.clear();
for (int i = 1; i <= n; ++i) {
cin >> c >> t;
ve[t].emplace_back(c, i);
}
sort(ve[1].begin(), ve[1].end(), cmp);
cnt = 0;
sum = 0.0;
for (int i = 0; i < ve[1].size() && cnt < k - 1; ++i) {
sum += ve[1][i].first * 1.0 / 2;
res.push_back(ve[1][i].second);
++cnt;
}
num1 = -1;
if (ve[1].size() > k - 1) {
num1 = cnt;
}
num2 = -1;
for (int i = 0; i < ve[2].size() && cnt < k - 1; ++i) {
sum += ve[2][i].first;
res.push_back(ve[2][i].second);
++cnt;
num2 = i;
}
if (~num1) {
for (int i = num1; i < ve[1].size(); ++i) {
minnum = min(ve[1][i].first, minnum);
sum += ve[1][i].first;
temp.push_back(ve[1][i].second);
}
}
for (int i = num2 + 1; i < ve[2].size(); ++i) {
minnum = min(ve[2][i].first, minnum);
sum += ve[2][i].first;
temp.push_back(ve[2][i].second);
}
if (minnum != inf) {
if (~num1) {
sum -= minnum * 1.0 / 2;
}
printf("%.1lf\n", sum);
cout << temp.size();
for (auto x : temp) {
cout << " " << x;
}
cout << endl;
} else {
printf("%.1lf\n", sum);
}
for (auto x : res) {
cout << 1 << " " << x << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1050;
vector<pair<int, int> > A, B;
int n, k;
long long ans = 0;
ostream& operator<<(ostream& out, const vector<int>& a) {
out << a.size();
for (int i = 0; i < (a.size()); ++i) out << ' ' << a[i];
out << endl;
return out;
}
int main(void) {
cin >> n >> k;
for (int i = 0; i < (n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
if (b == 1)
A.push_back(make_pair(a, i + 1));
else
B.push_back(make_pair(a, i + 1));
ans += 2 * a;
}
sort(A.begin(), A.end(), greater<pair<int, int> >());
sort(B.begin(), B.end(), greater<pair<int, int> >());
ostringstream sout;
int sa = A.size(), sb = B.size();
int ca = 0, cb = 0;
while (k--) {
vector<int> buf;
if (!k) {
int res = 0x7fffffff;
bool tag = (ca == sa);
while (ca < sa)
buf.push_back(A[ca].second), res = min(res, A[ca++].first);
while (cb < sb)
buf.push_back(B[cb].second), res = min(res, B[cb++].first);
if (!tag) ans -= res;
} else if (ca < sa) {
buf.push_back(A[ca].second);
ans -= A[ca++].first;
} else {
buf.push_back(B[cb++].second);
}
sout << buf;
}
printf("%.1lf\n", double(ans) / 2);
cout << sout.str();
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, k, cnt, minn = inf, b[1005];
bool tag[1005];
struct stool {
int c, id;
bool operator<(const stool &b) const { return c > b.c; }
} st[1005];
double ans;
long long sum;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1, c, t; i <= n; i++) {
scanf("%d %d", &c, &t), b[i] = c;
if (t == 2)
tag[i] = 1, sum += (long long)c;
else
st[++cnt] = (stool){c, i};
minn = min(minn, c);
}
sort(st + 1, st + 1 + cnt);
if (cnt < k) {
for (int i = 1; i <= cnt; i++) ans += (double)st[i].c * 0.5;
ans += (double)sum;
printf("%.1lf\n", ans);
for (int i = 1; i <= cnt; i++) printf("1 %d\n", st[i].id);
for (int i = 1; i <= n; i++) {
if (!tag[i]) continue;
cnt++;
if (cnt == k) printf("%d ", n - k + 1);
if (cnt >= k)
printf("%d ", i);
else
printf("1 %d\n", i);
}
} else {
for (int i = 1; i < k; i++) ans += (double)st[i].c * 0.5;
for (int i = k; i <= cnt; i++) {
if (st[i].c == minn)
minn = -1, ans += (double)st[i].c * 0.5;
else
ans += (double)st[i].c;
}
for (int i = 1; i <= n; i++) {
if (!tag[i]) continue;
if (b[i] == minn)
minn = -1, ans += (double)b[i] * 0.5;
else
ans += (double)b[i];
}
printf("%.1lf\n", ans);
for (int i = 1; i < k; i++) printf("1 %d\n", st[i].id);
printf("%d ", n - k + 1);
for (int i = k; i <= cnt; i++) printf("%d ", st[i].id);
for (int i = 1; i <= n; i++)
if (tag[i]) printf("%d ", i);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tab[1234], kar[1234], c[1243], ans[1234];
void bsort(int *tab, int nt) {
int i, j, t;
for (i = 1; i < nt; i++)
for (j = 1; j < nt; j++)
if (c[tab[j]] < c[tab[j - 1]])
t = tab[j], tab[j] = tab[j - 1], tab[j - 1] = t;
}
int main(void) {
int i, j, n, k, t, nt, nk;
long long res;
while (scanf(" %d %d", &n, &k) != EOF) {
nt = nk = 0;
res = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &c[i], &t);
if (t == 1)
tab[nt++] = i;
else
kar[nk++] = i;
res += 2 * c[i];
}
bsort(tab, nt);
bsort(kar, nk);
for (i = 0; i < nt && i < k; i++) {
ans[i] = tab[nt - i - 1];
res -= c[tab[nt - i - 1]];
}
if (i == k) {
res += c[tab[nt - i]];
res -= min(c[tab[0]], c[kar[0]]);
printf("%I64d.%I64d\n", res / 2, (res % 2) * 5);
for (i = 0; i < k - 1; i++) printf("1 %d\n", ans[i] + 1);
printf("%d ", n - k + 1);
for (; i < nt; i++) printf("%d ", tab[nt - i - 1] + 1);
for (i = 0; i < nk; i++) printf("%d ", kar[i] + 1);
printf("\n");
} else {
printf("%I64d.%I64d\n", res / 2, (res % 2) * 5);
for (i = 0; i < nt; i++) printf("1 %d\n", ans[i] + 1);
for (j = 0; i < k - 1; i++, j++) printf("1 %d\n", kar[j] + 1);
printf("%d ", n - k + 1);
for (; j < nk; j++) printf("%d ", kar[j] + 1);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void merge2(int* arr1, int* tempArr1, int* arr2, int* tempArr2, int left,
int mid, int right) {
int leftEnd = mid - 1;
int currPos = left;
int count = right - left + 1;
while ((left <= leftEnd) && (mid <= right)) {
if (arr1[left] <= arr1[mid]) {
tempArr1[currPos] = arr1[left];
tempArr2[currPos] = arr2[left];
left++;
} else {
tempArr1[currPos] = arr1[mid];
tempArr2[currPos] = arr2[mid];
mid++;
};
currPos++;
};
while (left <= leftEnd) {
tempArr1[currPos] = arr1[left];
tempArr2[currPos] = arr2[left];
left++;
currPos++;
};
while (mid <= right) {
tempArr1[currPos] = arr1[mid];
tempArr2[currPos] = arr2[mid];
mid++;
currPos++;
};
for (int i = 0; i <= count; i++) {
arr1[right] = tempArr1[right];
arr2[right] = tempArr2[right];
right--;
};
};
void mergeSort2(int* arr1, int* tempArr1, int* arr2, int* tempArr2, int left,
int right) {
int mid;
if (right > left) {
mid = (right + left) / 2;
mergeSort2(arr1, tempArr1, arr2, tempArr2, left, mid);
mergeSort2(arr1, tempArr1, arr2, tempArr2, mid + 1, right);
merge2(arr1, tempArr1, arr2, tempArr2, left, mid + 1, right);
};
};
int main(int argc, char* argv[]) {
int n, k;
const int MAX = 1001;
int a[MAX], b[MAX], ainds[MAX], binds[MAX], temp[MAX], temp2[MAX];
cin >> n >> k;
a[0] = 0;
b[0] = 0;
int acount = 0, bcount = 0;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int temp1, temp2;
cin >> temp1 >> temp2;
sum += temp1;
if (temp2 == 1) {
a[acount] = temp1;
ainds[acount] = i;
acount++;
} else {
b[bcount] = temp1;
binds[bcount] = i;
bcount++;
};
};
if (acount > 0) mergeSort2(a, temp, ainds, temp2, 0, acount - 1);
if (bcount > 0) mergeSort2(b, temp, binds, temp2, 0, bcount - 1);
sum *= 2;
if (acount >= k) {
for (int i = 0; i < k - 1; i++) {
sum -= a[acount - 1 - i];
};
if (a[0] * b[0] != 0)
sum -= min(b[0], a[0]);
else
sum -= max(b[0], a[0]);
(sum % 2 == 0) ? cout << sum / 2 << ".0" << endl
: cout << sum / 2 << ".5" << endl;
for (int i = 0; i < k - 1; i++) {
cout << "1 " << ainds[acount - i - 1] + 1 << endl;
};
cout << n - k + 1 << ' ';
for (int i = acount - k; i >= 0; i--) {
cout << ainds[i] + 1 << ' ';
};
for (int i = 0; i < bcount; i++) {
cout << binds[i] + 1 << ' ';
};
cout << endl;
} else {
for (int i = 0; i < acount; i++) {
sum -= a[acount - 1 - i];
};
(sum % 2 == 0) ? cout << sum / 2 << ".0" << endl
: cout << sum / 2 << ".5" << endl;
for (int i = 0; i < acount; i++) {
cout << "1 " << ainds[i] + 1 << endl;
};
for (int i = acount; i < k - 1; i++) {
cout << "1 " << binds[i - acount] + 1 << endl;
};
cout << n - k + 1 << ' ';
for (int i = k - 1; i < n; i++) {
cout << binds[i - acount] + 1 << ' ';
};
cout << endl;
};
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void swap(long long *xp, long long *yp) {
long long temp = *xp;
*xp = *yp;
*yp = temp;
}
const long long maxn = 1e5 + 1;
void print(vector<long long> v) {
long long i, j, n = v.size();
for (i = 0; i < n; i++) {
cout << v[i] << " ";
}
cout << "\n";
}
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) { return (a * b) / gcd(a, b); }
long long power(long long x, long long y) {
long long res = 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x);
y = y / 2;
x = (x * x);
}
return res;
}
int main() {
long long int i, j, inc, dec, t, r;
long long int c, d, e, temp, m, p, w, k, x, y, sum, pre, temp2, mid, n, low,
high;
t = 1;
n = 1;
while (t--) {
cin >> n >> k;
vector<pair<long long, long long>> stool, pencil;
vector<long long> an[k], a;
vector<bool> v(k, false);
double ans = 0;
for (i = 0; i < n; i++) {
cin >> x >> y;
a.push_back(x);
if (y == 1) {
stool.push_back(make_pair(x, i));
} else {
pencil.push_back(make_pair(x, i));
}
}
sort((stool).begin(), (stool).end());
reverse((stool).begin(), (stool).end());
for (i = 0; i < stool.size() && i < k; i++) {
an[i].push_back(stool[i].second);
v[i] = true;
}
if (stool.size() >= k) {
for (; i < stool.size(); i++) {
an[k - 1].push_back(stool[i].second);
}
for (i = 0; i < pencil.size(); i++) {
an[k - 1].push_back(pencil[i].second);
}
} else {
for (j = 0; i < k; i++, j++) {
an[i].push_back(pencil[j].second);
}
for (; j < pencil.size(); j++) {
an[k - 1].push_back(pencil[j].second);
}
}
for (i = 0; i < k; i++) {
m = INT_MAX;
for (j = 0; j < an[i].size(); j++) {
m = min(m, a[an[i][j]]);
ans += a[an[i][j]];
}
if (v[i]) {
ans -= m;
ans += (m / (double)2);
}
}
cout << setprecision(1) << fixed;
cout << ans << "\n";
;
for (i = 0; i < k; i++) {
cout << an[i].size() << " ";
for (j = 0; j < an[i].size(); j++) {
cout << an[i][j] + 1 << " ";
}
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int first, second, id;
bool operator<(const node b) const {
if (first != b.first) return first < b.first;
return second < b.second;
}
} p[10050];
vector<int> vt[10050];
int main() {
int n, k;
while (scanf("%d%d", &n, &k) != -1) {
double ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i].second, &p[i].first);
ans += p[i].second;
p[i].id = i + 1;
p[i].first = -p[i].first;
vt[i].clear();
}
sort(p, p + n);
double mn = 1e10;
for (int i = 0; i <= n - k; i++) {
if (mn > p[i].second) mn = 1.0 * p[i].second;
vt[0].push_back(p[i].id);
}
if (p[n - k].first == -1) ans -= mn / 2.0;
for (int i = n - k + 1; i < n; i++) {
if (p[i].first == -1) ans -= p[i].second / 2.0;
vt[i - (n - k)].push_back(p[i].id);
}
printf("%.1lf\n", ans);
sort(vt[0].begin(), vt[0].end());
int sz = vt[0].size();
printf("%d", sz);
for (int i = 0; i < sz; i++) printf(" %d", vt[0][i]);
puts("");
for (int i = 1; i < k; i++) {
printf("1 %d\n", vt[i][0]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, int> a[1111], b[1111];
long long cost[1111];
long long lim[1111];
int n, k;
int n1, n2;
vector<int> w[1111];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x *= 2;
if (y == 1) {
a[n1++] = make_pair(x, i + 1);
} else {
b[n2++] = make_pair(x, i + 1);
}
cost[i + 1] = x;
}
sort(a, a + n1, greater<pair<long long, int> >());
sort(b, b + n2, greater<pair<long long, int> >());
for (int i = 0; i < n1; ++i)
if (i < k) {
w[i].push_back(a[i].second);
} else {
w[k - 1].push_back(a[i].second);
}
if (n1 < k) {
for (int i = 0; i < n2; ++i)
if (n1 + i < k) {
w[n1 + i].push_back(b[i].second);
} else {
w[k - 1].push_back(b[i].second);
}
} else {
for (int i = 0; i < n2; ++i) w[k - 1].push_back(b[i].second);
}
long long ans = 0;
for (int i = 0; i < k; ++i) {
long long mn = cost[w[i][0]];
for (int j = 0; j < w[i].size(); ++j) {
ans += cost[w[i][j]];
mn = min(mn, cost[w[i][j]]);
}
if (i < n1) ans -= mn / 2;
}
cout << ans / 2 << ".";
if (ans & 1)
cout << "5\n";
else
cout << "0\n";
for (int i = 0; i < k; ++i) {
cout << w[i].size();
for (int j = 0; j < w[i].size(); ++j) cout << " " << w[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<vector<pair<long long, long long>>> ans(k);
long long gr = k, cnt = 0;
bool f = false;
vector<pair<pair<long long, long long>, long long>> a(n);
long double c = 0;
for (long long i = 1; i <= n; ++i) {
pair<long long, long long> x;
cin >> x.first >> x.second;
if (x.second == 1 && gr > 1) gr--;
if (x.second == 1) cnt++;
if (x.second == 2) f = true;
a[i - 1] = {x, i};
}
sort(a.begin(), a.end(),
greater<pair<pair<long long, long long>, long long>>());
k--;
long long free = 0;
for (long long i = 0; i < n; ++i) {
if (k == -1) {
for (long long j = i; j < n; ++j) {
ans[free].push_back({a[j].first.first, a[j].second});
if (free + 1 < gr) free++;
}
break;
}
if (a[i].first.second == 1) {
ans[k].push_back({a[i].first.first, a[i].second});
k--;
} else {
ans[free].push_back({a[i].first.first, a[i].second});
if (free + 1 < gr) free++;
}
}
cout << fixed << setprecision(1);
k = ans.size();
for (long long i = 0; i < ans.size(); ++i) {
long long mn = 1e9;
sort(ans[i].begin(), ans[i].end());
for (long long j = 0; j < ans[i].size(); ++j) {
if (j == 0 && k - cnt - 1 < i)
c += (long double)ans[i][j].first / 2;
else
c += ans[i][j].first;
}
}
cout << c << '\n';
for (auto i : ans) {
cout << i.size() << ' ';
for (auto j : i) cout << j.second << ' ';
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
const int kMaxN = 1000;
int n, k, a, b;
double tot = 0.0;
vector<int> lis;
struct Node {
int id, v;
Node() {}
Node(int _id, int _v) : id(_id), v(_v) {}
bool operator<(const Node &t) const { return v < t.v; }
} aa[kMaxN], bb[kMaxN];
void Solve(FILE *fin, FILE *fout) {
fscanf(fin, "%d%d", &n, &k);
for (int i = 0, c, t; i < n; i++) {
fscanf(fin, "%d%d", &c, &t);
if (t == 1)
aa[a++] = Node(i + 1, c);
else
bb[b++] = Node(i + 1, c);
tot += static_cast<double>(c);
}
sort(aa, aa + a);
sort(bb, bb + b);
if (a >= k) {
double ans = tot;
for (int i = 1; i < k; i++) ans -= aa[a - i].v * 0.5;
if (b > 0)
ans -= min(aa[0].v, bb[0].v) * 0.5;
else
ans -= aa[0].v * 0.5;
fprintf(fout, "%.1lf\n", ans);
int j = b - 1;
for (int i = 1; i < k; i++) {
lis.clear();
lis.push_back(aa[a - i].id);
while (j >= 0 && bb[j].v >= aa[a - i].v) {
lis.push_back(bb[j].id);
j--;
}
fprintf(fout, "%d", lis.size());
for (int k = 0, kk = lis.size(); k < kk; ++k)
fprintf(fout, " %d", lis[k]);
fprintf(fout, "\n");
}
lis.clear();
for (int i = k; i <= a; i++) lis.push_back(aa[a - i].id);
while (j >= 0) {
lis.push_back(bb[j].id);
j--;
}
fprintf(fout, "%d", lis.size());
for (int k = 0, kk = lis.size(); k < kk; ++k) fprintf(fout, " %d", lis[k]);
fprintf(fout, "\n");
} else {
double ans = tot;
for (int i = 1; i <= a; i++) ans -= aa[a - i].v * 0.5;
fprintf(fout, "%.1lf\n", ans);
int emp = k - a, j = b - 1;
for (int i = 1; i <= a; i++) {
lis.clear();
lis.push_back(aa[a - i].id);
while (j >= emp && bb[j].v >= aa[a - i].v) {
lis.push_back(bb[j].id);
j--;
}
fprintf(fout, "%d", lis.size());
for (int k = 0, kk = lis.size(); k < kk; k++)
fprintf(fout, " %d", lis[k]);
fprintf(fout, "\n");
}
for (int i = a + 1; i <= k; i++) {
emp--;
lis.clear();
while (j >= emp) {
lis.push_back(bb[j].id);
j--;
}
fprintf(fout, "%d", lis.size());
for (int k = 0, kk = lis.size(); k < kk; k++)
fprintf(fout, " %d", lis[k]);
fprintf(fout, "\n");
}
}
}
} // namespace
int main() {
::Solve(stdin, stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int p[10000];
int t[10000];
int u[10000];
vector<int> v;
bool compara(int i1, int i2) { return p[i1] < p[i2]; }
int main() {
cout.setf(ios::fixed);
cout.precision(1);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> p[i] >> t[i];
if (t[i] == 1) v.push_back(i);
}
sort(v.begin(), v.end(), compara);
double sol = 0;
vector<vector<int> > vsol;
for (int i = 0; i < k - 1 and i < int(v.size()); i++) {
int ind = v[int(v.size()) - 1 - i];
vsol.push_back(vector<int>(1, ind));
sol += double(p[ind]) / 2.0;
u[ind] = 1;
}
for (int i = 1; i <= n; i++) {
if (u[i] == 0) {
if (int(vsol.size()) < k) {
vsol.push_back(vector<int>(1, i));
if (int(vsol.size()) < k) sol += p[i];
} else
vsol.back().push_back(i);
}
}
v = vsol.back();
int minimo = 1000000000;
bool hay = false;
for (int i = 0; i < int(v.size()); i++) {
hay = hay or t[v[i]] == 1;
minimo = min(minimo, p[v[i]]);
sol += p[v[i]];
}
if (hay) sol -= double(minimo) / 2.0;
cout << sol << endl;
for (int i = 0; i < int(vsol.size()); i++) {
vector<int> w = vsol[i];
cout << int(w.size());
for (int j = 0; j < int(w.size()); j++) cout << " " << w[j];
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct p {
long long q, w, e;
};
p zx[200000], qwe[200000];
bool f(p z, p x) { return z.q < x.q; }
bool f1(p z, p x) { return z.q > x.q; }
double ans;
long long n, k, z, qq, ww, zxc, qw, k1, ma, zxx, ee;
vector<pair<long long, long long> > a[200000];
int main() {
cin >> n >> k;
z = 0;
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &qwe[i].q, &qwe[i].w);
qwe[i].e = i + 1;
}
sort(qwe, qwe + n, f1);
for (int i = 0; i < n; i++) {
qq = qwe[i].q;
ww = qwe[i].w;
ee = qwe[i].e;
if (ww == 1 && z < k) {
a[z++].push_back(make_pair(ee, qq));
} else {
zx[k1].q = qq;
zx[k1++].w = ee;
}
}
sort(zx, zx + k1, f);
zxc = k1 - 1;
for (int i = z; i < k; i++) {
a[i].push_back(make_pair(zx[zxc].w, zx[zxc].q));
zxc--;
}
for (int i = 0; i < z;) {
if (zxc == -1) break;
if (zx[zxc].q > a[i][0].second) {
a[i].push_back(make_pair(zx[zxc].w, zx[zxc].q));
zxc--;
} else
i++;
}
if (z < k) {
for (int i = 0; i <= zxc; i++) {
a[k - 1].push_back(make_pair(zx[i].w, zx[i].q));
}
} else {
zxx = 0;
for (int i = 0; i < k; i++)
if (a[i][0].second < a[zxx][0].second) zxx = i;
for (int i = 0; i <= zxc; i++) {
a[zxx].push_back(make_pair(zx[i].w, zx[i].q));
}
}
ans = 0;
for (int i = 0; i < k; i++) {
ma = 2000000000;
for (int j = 0; j < (int)a[i].size(); j++) {
ans += a[i][j].second;
ma = min(ma, a[i][j].second);
}
if (i < z) {
ans -= ma;
ans += ma / 2.0;
}
}
printf("%.1lf\n", ans);
for (int i = 0; i < k; i++) {
cout << a[i].size() << " ";
for (int j = 0; j < (int)a[i].size(); j++) cout << a[i][j].first << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const double EPS = 1e-9;
pair<int, int> T[2000], K[2000];
int cntT = 0, cntK = 0;
vector<int> ans[2000];
int minCost[2000];
bool tab[2000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long cost = 0;
for (int i = 0; i < n; ++i) {
int c, t;
scanf("%d%d", &c, &t);
cost += c * 2;
if (t == 1) {
T[cntT++] = pair<int, int>(c, i + 1);
} else {
K[cntK++] = pair<int, int>(c, i + 1);
}
}
sort(T, T + cntT);
sort(K, K + cntK);
reverse(T, T + cntT);
reverse(K, K + cntK);
memset(minCost, 0x7f, sizeof(minCost));
for (int i = 0; i < min(cntT, k); ++i) {
ans[i].push_back(T[i].second);
minCost[i] = min(minCost[i], T[i].first);
tab[i] = true;
}
for (int i = min(cntT, k); i < cntT; ++i) {
ans[k - 1].push_back(T[i].second);
minCost[k - 1] = min(minCost[k - 1], T[i].first);
tab[k - 1] = true;
}
int pos = 0;
for (int i = min(cntT, k); i < k; ++i) {
ans[i].push_back(K[pos].second);
minCost[i] = min(minCost[i], K[pos].first);
++pos;
}
while (pos < cntK) {
ans[k - 1].push_back(K[pos].second);
minCost[k - 1] = min(minCost[k - 1], K[pos].first);
++pos;
}
for (int i = 0; i < k; ++i) {
if (tab[i]) cost -= minCost[i];
}
printf("%I64d.%I64d\n", cost / 2, (cost % 2) * 5);
for (int i = 0; i < k; ++i) {
printf("%d", ans[i].size());
for (int j = 0; j < ans[i].size(); ++j) {
printf(" %d", ans[i][j]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const double eps = 1e-9;
const int INF = 1000000000;
int n, k, sc, pc;
pair<int, int> s[N], p[N];
vector<int> cart[N];
inline bool cmp(pair<int, int> p, pair<int, int> q) {
return p.first > q.first;
}
int main() {
while (~scanf("%d%d", &n, &k)) {
sc = pc = 0;
for (int i = 0; i < n; ++i) {
int c, d;
scanf("%d%d", &c, &d);
if (d == 1) {
s[sc++] = make_pair(c, i);
} else {
p[pc++] = make_pair(c, i);
}
}
sort(s, s + sc, cmp);
sort(p, p + pc, cmp);
for (int i = 0; i < k; ++i) {
cart[i].clear();
}
if (sc < k) {
long long ans = 0;
for (int i = 0; i < sc; ++i) {
ans = ans + s[i].first;
cart[i].push_back(s[i].second);
}
for (int j = 0; j < pc; ++j) {
ans = ans + p[j].first * 2;
cart[j % (k - sc) + sc].push_back(p[j].second);
}
cout << ans / 2 << ".";
if (ans % 2) {
puts("5");
} else {
puts("0");
}
} else {
long long ans = 0;
for (int i = 0; i < k - 1; ++i) {
ans = ans + s[i].first;
cart[i].push_back(s[i].second);
}
for (int i = k - 1; i < sc; ++i) {
ans = ans + s[i].first * 2;
cart[k - 1].push_back(s[i].second);
}
for (int j = 0; j < pc; ++j) {
ans = ans + p[j].first * 2;
cart[k - 1].push_back(p[j].second);
}
if (pc > 0) {
ans -= min(p[pc - 1].first, s[sc - 1].first);
} else {
ans -= s[sc - 1].first;
}
cout << ans / 2 << ".";
if (ans % 2) {
puts("5");
} else {
puts("0");
}
}
for (int i = 0; i < k; ++i) {
printf("%d", cart[i].size());
for (vector<int>::iterator j = cart[i].begin(); j != cart[i].end(); ++j) {
printf(" %d", (*j) + 1);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i = 0;
cin >> n >> k;
vector<pair<int, int> > O1, O2;
while (i < n) {
int a, b;
cin >> a >> b;
if (b == 1) {
O1.push_back(make_pair(a, i + 1));
} else {
O2.push_back(make_pair(a, i + 1));
}
i++;
}
sort(O1.begin(), O1.end());
sort(O2.begin(), O2.end());
reverse(O1.begin(), O1.end());
reverse(O2.begin(), O2.end());
double sum = 0;
vector<int> vec[k];
if (O1.size() >= k) {
i = 0;
while (i < k - 1) {
sum += ((double)O1[i].first / 2);
vec[i].push_back(O1[i].second);
i++;
}
while (i < O1.size()) {
O2.push_back(make_pair(O1[i].first, O1[i].second));
i++;
}
i = 1;
sort(O2.begin(), O2.end());
sum += ((double)O2[0].first / 2);
vec[k - 1].push_back(O2[0].second);
while (i < O2.size()) {
vec[k - 1].push_back(O2[i].second);
sum += O2[i].first;
i++;
}
} else {
i = 0;
while (i < O1.size()) {
sum += ((double)O1[i].first / 2);
vec[i].push_back(O1[i].second);
i++;
}
i = 0;
int l = O1.size(), subs = k - O1.size();
while (i < O2.size()) {
sum += (O2[i].first);
vec[i % subs + l].push_back(O2[i].second);
i++;
}
}
printf("%.1f\n", sum);
i = 0;
while (i < k) {
int j = 0;
cout << vec[i].size() << "\t";
while (j < vec[i].size()) {
cout << vec[i][j++] << "\t";
}
i++;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
long long int power(long long int n, long long int p) {
long long int ans = 1;
while (p > 0) {
p--;
n *= n;
}
}
long long int bitc(long long int n, long long int x) { return ((n >> x) & 1); }
long long int __gcd(long long int a, long long int b) {
return b == 0 ? a : __gcd(b, a % b);
}
long long int sub(long long int a, long long int b, long long int p = MOD) {
return ((a % p) - (b % p) + p) % p;
}
long long int mult(long long int a, long long int b, long long int p = MOD) {
return ((a % p) * (b % p)) % p;
}
long long int add(long long int a, long long int b, long long int p = MOD) {
return (a % p + b % p) % p;
}
long long int fpow(long long int n, long long int k, long long int p = MOD) {
long long int r = 1;
while (k > 0) {
if (k & 1) r = r * n % p;
n = n * n % p;
k = k >> 1;
}
return r;
}
long long int inv(long long int a, long long int p = MOD) {
return fpow(a, p - 2, p);
}
long long int fdiv(long long int a, long long int b, long long int p = MOD) {
long long int yinv = inv(b);
long long int ans = (a * yinv) % p;
return ans;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &item : a) {
in >> item;
}
return in;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, pair<T, U> &a) {
cout << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
istream &operator>>(istream &out, pair<T, U> &a) {
cin >> a.first >> a.second;
return out;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, map<T, U> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &item : a) {
out << item << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
std::vector<bool> is_prime;
std::vector<long long int> primes;
void sieve(long long int n) {
is_prime.resize(n + 2, true);
primes.clear();
long long int p;
for (p = 2; p * p <= n; p++) {
if (is_prime[p]) {
long long int i;
for (i = p * p; i <= n; i += p) {
is_prime[i] = false;
}
}
}
is_prime[0] = is_prime[1] = false;
long long int i;
for (i = 2; i <= n; i++) {
if (is_prime[i]) {
primes.emplace_back(i);
}
}
}
map<long long int, long long int> prime_factors(long long int n) {
map<long long int, long long int> s;
long long int i;
long long int tc = 0;
while (n % 2 == 0) {
tc++;
n /= 2;
}
if (tc > 0) {
s[2] = tc;
}
for (i = 3; i <= sqrt(n); i += 2) {
tc = 0;
while (n % i == 0) {
tc++;
n /= i;
}
if (tc > 0) {
s[i] = tc;
}
}
if (n > 2) {
s[n] += 1;
}
return s;
}
std::vector<long long int> fact_vec;
void fact_fun(long long int n) {
fact_vec.resize(n + 10);
long long int i;
fact_vec[0] = 1;
for (i = 1; i <= n + 2; i++) {
fact_vec[i] = (fact_vec[i - 1] * i) % MOD;
}
}
int main() {
long long int i, j;
ios::sync_with_stdio(false);
cin.tie(0);
long long int t;
t = 1;
while (t--) {
long long int n, k;
cin >> n >> k;
std::vector<pair<long long int, long long int>> v(n);
for (auto &p : v) {
cin >> p.first >> p.second;
}
vector<pair<long long int, long long int>> spl;
std::vector<pair<long long int, long long int>> nspl;
for (i = 0; i < n; i++) {
if (v[i].second == 1) {
spl.emplace_back(make_pair(v[i].first, i));
} else {
nspl.emplace_back(make_pair(v[i].first, i));
}
}
std::vector<bool> hasspl(k, false);
sort((spl).begin(), (spl).end(),
greater<pair<long long int, long long int>>());
std::vector<std::vector<long long int>> ans(k);
for (i = 0; i < k - 1; i++) {
if (spl.empty()) {
break;
}
hasspl[i] = true;
ans[i].emplace_back(spl.begin()->second);
spl.erase(spl.begin());
}
for (; i < k; i++) {
if (nspl.empty()) {
break;
}
ans[i].emplace_back(nspl.begin()->second);
nspl.erase(nspl.begin());
}
while (!spl.empty()) {
ans[k - 1].emplace_back(spl.begin()->second);
spl.erase(spl.begin());
hasspl[k - 1] = true;
}
while (!nspl.empty()) {
ans[k - 1].emplace_back(nspl.begin()->second);
nspl.erase(nspl.begin());
}
long double sum = 0;
for (i = 0; i < k; i++) {
long double tp = 0;
for (auto p : ans[i]) {
tp += v[p].first;
}
if (hasspl[i]) {
long long int mn = INF;
for (auto p : ans[i]) {
mn = min(mn, v[p].first);
}
tp -= mn;
tp = (long double)tp + (long double)mn / 2;
}
sum = (long double)sum + tp;
}
cout << fixed << setprecision(1) << sum << "\n";
for (i = 0; i < k; i++) {
cout << ans[i].size() << " ";
for (auto p : ans[i]) {
cout << p + 1 << " ";
}
cout << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
pair<int, int> x[1011], y[1011];
int nx, ny, px[1011], py[1011];
vector<int> kx[1011];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = (1), _b = (n); i <= _b; i++) {
int c, t;
scanf("%d%d", &c, &t);
c *= 2;
if (t == 1)
x[++nx] = make_pair(c, i);
else
y[++ny] = make_pair(c, i);
}
sort(x + 1, x + nx + 1);
sort(y + 1, y + ny + 1);
int cur = k;
for (int i = (nx), _b = (1); i >= _b; i--) {
kx[cur].push_back(x[i].first);
px[i] = cur;
cur--;
if (cur < 1) cur = 1;
}
for (int i = (ny), _b = (1); i >= _b; i--) {
kx[cur].push_back(y[i].first);
py[i] = cur;
cur--;
if (cur < 1) cur = 1;
}
long long sum = 0;
for (int i = (1), _b = (k); i <= _b; i++) {
long long cur = 0;
bool ok = false;
for (int x = (1), _b = (nx); x <= _b; x++)
if (px[x] == i) ok = true;
for (int x = 0, _a = (kx[i].size()); x < _a; x++) cur += kx[i][x];
sort(kx[i].begin(), kx[i].end());
if (ok) cur -= kx[i][0] / 2;
sum += cur;
}
cout << sum / 2 << '.' << ((sum % 2 == 0) ? 0 : 5) << endl;
for (int i = (1), _b = (k); i <= _b; i++) {
int cnt = 0;
for (int u = (1), _b = (nx); u <= _b; u++)
if (px[u] == i) cnt++;
for (int v = (1), _b = (ny); v <= _b; v++)
if (py[v] == i) cnt++;
printf("%d", cnt);
for (int u = (1), _b = (nx); u <= _b; u++)
if (px[u] == i) printf(" %d", x[u].second);
for (int v = (1), _b = (ny); v <= _b; v++)
if (py[v] == i) printf(" %d", y[v].second);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483646;
const int N = 1005;
int n, k;
int cart[N];
vector<int> c_ans[N];
struct Item {
int c, t;
int id;
} it[N];
int cmp(Item x, Item y) { return x.c > y.c; }
int main() {
int i, j;
double ans = 0;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d%d", &it[i].c, &it[i].t);
ans += it[i].c;
it[i].id = i + 1;
}
sort(it, it + n, cmp);
int m = 0;
memset(cart, -1, sizeof(cart));
for (i = 0; i < n && m < k; i++) {
if (it[i].t == 1) {
cart[i] = m;
m++;
}
}
for (i = 0; i < n && m < k; i++) {
if (cart[i] == -1) cart[i] = m++;
}
for (i = 0; i < n; i++)
if (cart[i] == -1) cart[i] = k - 1;
for (i = 0; i < k; i++) {
bool has_sto = false;
int minv = INF;
for (j = 0; j < n; j++) {
if (cart[j] == i) {
minv = min(minv, it[j].c);
if (it[j].t == 1) has_sto = true;
c_ans[i].push_back(j);
}
}
if (has_sto) ans -= (minv * 1.0 / 2);
}
printf("%.1lf\n", ans);
for (i = 0; i < k; i++) {
int tn = c_ans[i].size();
printf("%d", tn);
for (j = 0; j < tn; j++) {
putchar(' ');
printf("%d", it[c_ans[i][j]].id);
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct el {
int c, t, no;
bool operator<(const el& x) const { return c < x.c; }
};
int n, k;
el p[1024];
bool us[1024];
vector<el> ca[1024];
int main() {
int i, j, jj;
long long sm = 0, ot = 0;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d %d", &p[i].c, &p[i].t);
sm = sm + 2LL * p[i].c;
p[i].no = i;
}
sort(p + 1, p + n + 1);
memset(us, 0, sizeof(us));
j = 0;
jj = 0;
for (i = n; i > 0; i--) {
if ((p[i].t == 1) && (j < k)) {
j++;
ca[j].push_back(p[i]);
ot = ot + p[i].c;
jj = j;
us[i] = 1;
}
}
for (i = 1; i <= n; i++) {
if (us[i] == 0) {
if (j < k) j++;
ca[j].push_back(p[i]);
}
}
ot = 0;
for (i = 1; i <= jj; i++) {
sort(ca[i].begin(), ca[i].end());
ot = ot + ca[i][0].c;
}
sm = sm - ot;
cout << (sm / 2);
if (sm % 2 == 0)
printf(".0\n");
else
printf(".5\n");
for (i = 1; i <= k; i++) {
printf("%d", ca[i].size());
for (j = 0; j < (int)ca[i].size(); j++) printf(" %d", ca[i][j].no);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<pair<int, int> > St, Pen;
double sum = 0;
for (int i = (1); i <= (n); ++i) {
int c, type;
cin >> c >> type;
sum += c;
pair<int, int> elem = make_pair(c, i);
if (type == 1)
St.push_back(elem);
else
Pen.push_back(elem);
}
int s = (int)(St).size();
sort(St.begin(), St.end(), greater<pair<int, int> >());
vector<vector<pair<int, int> > > cart(k);
vector<bool> discount(k, 0);
int j = 0;
for (int i = (0); i <= ((int)(St).size() - 1); ++i) {
cart[j].push_back(St[i]);
discount[j] = 1;
if (j < k - 1) j++;
}
for (int i = (0); i <= ((int)(Pen).size() - 1); ++i) {
cart[j].push_back(Pen[i]);
if (j < k - 1) j++;
}
for (int i = (0); i <= ((int)(cart).size() - 1); ++i)
sort(cart[i].begin(), cart[i].end());
for (int i = (0); i <= ((int)(cart).size() - 1); ++i)
if (discount[i]) sum -= ((double)cart[i][0].first) / 2.0;
cout.precision(1);
cout << fixed << sum << '\n';
for (int i = (0); i <= ((int)(cart).size() - 1); ++i) {
cout << (int)(cart[i]).size() << ' ';
for (int j = (0); j <= ((int)(cart[i]).size() - 1); ++j)
cout << cart[i][j].second << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 500030;
struct node {
long long num;
long long val;
} pen[maxn], tot[maxn];
vector<node> vec[5000];
long long n, k, ci, ti;
int cmp(struct node& a, struct node& b) { return a.val > b.val; }
double sum = 0;
long long cnt1, cnt2;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> ci >> ti;
sum += ci;
if (ti == 1) {
tot[cnt1].val = ci;
tot[cnt1].num = i;
cnt1++;
} else {
pen[cnt2].val = ci;
pen[cnt2].num = i;
cnt2++;
}
}
sort(tot, tot + cnt1, cmp);
sort(pen, pen + cnt2, cmp);
int cnt = 1;
for (int i = 0; i < cnt1; i++) {
vec[cnt].push_back(tot[i]);
if (cnt != k) cnt++;
}
if (cnt1 < k) {
for (int i = 0; i < cnt1; i++) {
sum -= tot[i].val / 2.0;
}
int ss = 0;
for (int i = cnt1 + 1; i < k; i++) {
vec[i].push_back(pen[ss]);
ss++;
}
for (int i = ss; i < cnt2; i++) {
vec[k].push_back(pen[i]);
}
} else {
for (int i = 0; i < k - 1; i++) {
sum -= tot[i].val / 2.0;
}
if (cnt1 != 0 && cnt2 != 0)
sum -= min(tot[cnt1 - 1].val, pen[cnt2 - 1].val) / 2.0;
if (cnt2 == 0) sum -= tot[cnt1 - 1].val / 2.0;
for (int i = 0; i < cnt2; i++) {
vec[k].push_back(pen[i]);
}
}
printf("%.1lf\n", sum);
for (int i = 1; i <= k; i++) {
printf("%d", vec[i].size());
for (int j = 0; j < vec[i].size(); j++) {
printf(" %lld", vec[i][j].num);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
using namespace std;
int n, k;
vector<pair<int, int> > A;
vector<pair<int, int> > B;
int T[50001], D[50001];
vector<int> R[1024];
int main() {
cin >> n >> k;
for (int(i) = (0); (i) < (n); ++(i)) {
int a, b;
cin >> a >> b;
if (b == 1)
A.push_back(make_pair(a, i));
else
B.push_back(make_pair(a, i));
T[i] = b;
D[i] = a;
}
if (A.size() < k) {
for (int(i) = (0); (i) < (A.size()); ++(i)) R[i].push_back(A[i].second);
int t = k - A.size();
for (int(i) = (0); (i) < (B.size()); ++(i))
R[A.size() + (i % t)].push_back(B[i].second);
} else {
sort((A).begin(), (A).end());
reverse((A).begin(), (A).end());
for (int(i) = (0); (i) < (k - 1); ++(i)) R[i].push_back(A[i].second);
for (int(i) = (k - 1); (i) < (A.size()); ++(i))
R[k - 1].push_back(A[i].second);
for (int(i) = (0); (i) < (B.size()); ++(i)) R[k - 1].push_back(B[i].second);
}
double sum = 0;
for (int(i) = (0); (i) < (k); ++(i)) {
int m = 1000000000 + 1;
bool was = false;
double s = 0;
for (int(j) = (0); (j) < (R[i].size()); ++(j)) {
if (T[R[i][j]] == 1) was = true;
m = min(m, D[R[i][j]]);
s += D[R[i][j]];
}
if (was)
sum += (s - m) + (m / 2.0);
else
sum += s;
}
printf("%0.1f\n", sum);
for (int(i) = (0); (i) < (k); ++(i)) {
cout << R[i].size();
for (int(j) = (0); (j) < (R[i].size()); ++(j)) cout << ' ' << R[i][j] + 1;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1 << 10;
int n, k;
long long res[SZ][SZ][2];
int from1[SZ][SZ][2];
int from2[SZ][SZ][2];
int from3[SZ][SZ][2];
pair<pair<int, int>, int> b[SZ];
pair<int, int> p[SZ];
void update(int i2, int j2, int need2, int i1, int j1, int need1, int diff) {
if (res[i2][j2][need2] < res[i1][j1][need1] + diff) {
res[i2][j2][need2] = res[i1][j1][need1] + diff;
from1[i2][j2][need2] = i1;
from2[i2][j2][need2] = j1;
from3[i2][j2][need2] = need1;
}
}
vector<int> v[SZ];
void print(int i2, int j2, int need2) {
if (i2 == 0) return;
v[j2].push_back(i2 - 1);
print(from1[i2][j2][need2], from2[i2][j2][need2], from3[i2][j2][need2]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); ++i) {
scanf("%d%d", &p[i].first, &p[i].second);
b[i].first = p[i];
b[i].second = i;
}
sort(b, b + n);
for (int i = 0; i < (n); ++i) p[i] = b[i].first;
memset(res, -1, sizeof(res));
if (p[0].second == 1) {
res[1][0][0] = p[0].first;
} else {
res[1][0][0] = 0;
res[1][0][1] = p[0].first;
}
for (int i = 1; i < (n); ++i)
for (int j = 0; j < (k); ++j)
for (int need = 0; need < (2); ++need)
if (res[i][j][need] != -1) {
if (need) {
if (p[i].second == 1) update(i + 1, j, 0, i, j, 1, 0);
}
update(i + 1, j, need, i, j, need, 0);
if (!need) {
if (p[i].second == 1)
update(i + 1, j + 1, 0, i, j, need, p[i].first);
else {
update(i + 1, j + 1, 1, i, j, need, p[i].first);
update(i + 1, j + 1, 0, i, j, need, 0);
}
}
}
if (res[n][k - 1][0] == -1) throw -1;
long long sum = 0;
for (int i = 0; i < (n); ++i) sum += p[i].first;
cout << (2 * sum - res[n][k - 1][0]) / 2;
if (res[n][k - 1][0] & 1) {
cout << ".5";
} else {
cout << ".0";
}
cout << endl;
print(n, k - 1, 0);
for (int i = 0; i < (k); ++i) {
printf("%d", (int)v[i].size());
for (int j = 0; j < ((int)v[i].size()); ++j)
printf(" %d", b[v[i][j]].second + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = (1e-10);
bool EQ(double a, double b) { return abs((a) - (b)) < EPS; }
void fast_stream() { std::ios_base::sync_with_stdio(0); }
int N, K;
int a[1001];
int b[1001];
vector<pair<int, int> > pen;
vector<pair<int, int> > stl;
vector<int> res[1001];
void solve() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i];
if (b[i] == 1)
stl.push_back(pair<int, int>(a[i], i));
else
pen.push_back(pair<int, int>(a[i], i));
}
sort(stl.begin(), stl.end(), greater<pair<int, int> >());
double sum = 0;
if (stl.size() < K) {
for (int i = 0; i < stl.size(); i++) {
res[i].push_back(stl[i].second + 1);
sum += stl[i].first / 2.0;
}
int pos = 0;
for (int i = 0; i < pen.size(); i++) {
res[pos + stl.size()].push_back(pen[i].second + 1);
pos = (pos + 1) % (K - stl.size());
sum += pen[i].first;
}
} else {
int minNum = 1000000101;
for (int i = 0; i < stl.size(); i++) {
if (i < K) {
res[i].push_back(stl[i].second + 1);
if (i != K - 1)
sum += stl[i].first / 2.0;
else {
sum += stl[i].first;
minNum = min(minNum, stl[i].first);
}
} else {
res[K - 1].push_back(stl[i].second + 1);
minNum = min(minNum, stl[i].first);
sum += stl[i].first;
}
}
for (int i = 0; i < pen.size(); i++) {
res[K - 1].push_back(pen[i].second + 1);
sum += pen[i].first;
minNum = min(minNum, pen[i].first);
}
sum -= minNum / 2.0;
}
printf("%.1f\n", sum);
for (int i = 0; i < K; i++) {
cout << res[i].size() << " ";
for (int j = 0; j < res[i].size(); j++) {
cout << res[i][j];
if (j == res[i].size() - 1)
cout << endl;
else
cout << " ";
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t, class u>
void chmax(t &first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t &first, u second) {
if (second < first) first = second;
}
struct item {
int index;
int cost;
};
vector<item> stools, pencils;
vector<vector<item> > RED, WHITE;
vector<int> red_v;
bool lesser(struct item &left, struct item &right) {
return left.cost < right.cost;
}
int main() {
int n, k;
scanf("%d", &n);
scanf("%d", &k);
for (int rep = 0; rep < n; ++rep) {
int cost, type;
scanf("%d", &cost);
scanf("%d", &type);
if (type == 1) {
stools.push_back({rep, cost});
} else {
pencils.push_back({rep, cost});
}
}
sort(stools.begin(), stools.end(), lesser);
int numStools = int(stools.size());
int r = min(k, numStools), w = k - r;
RED.resize(r);
red_v.assign(r, 0);
for (int rep = 0; rep < r; ++rep) {
RED[rep].push_back(stools.back());
red_v[rep] = stools.back().cost;
stools.pop_back();
}
if (w > 0) {
WHITE.resize(w);
assert(int(pencils.size()) >= w);
for (int rep = 0; rep < w; ++rep) {
WHITE[rep].push_back(pencils.back());
pencils.pop_back();
}
while (!pencils.empty()) {
WHITE[w - 1].push_back(pencils.back());
pencils.pop_back();
}
assert(pencils.empty());
} else {
assert(k == r);
while (!stools.empty()) {
RED[r - 1].push_back(stools.back());
assert(stools.back().cost <= red_v[r - 1]);
red_v[r - 1] = stools.back().cost;
stools.pop_back();
}
assert(stools.empty());
for (auto &p : pencils) {
bool ok = false;
for (int rep = 0; rep < r; rep++) {
if (red_v[rep] <= p.cost) {
RED[rep].push_back(p);
ok = true;
break;
}
}
if (!ok) {
RED[r - 1].push_back(p);
red_v[r - 1] = min(red_v[r - 1], p.cost);
}
}
}
long long int sum = 0LL;
for (int rep = 0; rep < r; rep++) sum += red_v[rep];
long long int total_cost = 0LL;
for (vector<item> &p : RED) {
for (auto &pi : p) total_cost += pi.cost;
}
for (vector<item> &p : WHITE) {
for (auto &pi : p) total_cost += pi.cost;
}
total_cost -= sum;
if (sum & 1)
printf("%lld.5\n", sum / 2 + total_cost);
else
printf("%lld.0\n", sum / 2 + total_cost);
for (vector<item> &p : RED) {
printf("%ld ", p.size());
for (auto &pi : p) printf("%d ", pi.index + 1);
printf("\n");
}
for (vector<item> &p : WHITE) {
printf("%ld ", p.size());
for (auto &pi : p) printf("%d ", pi.index + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NK_MAX = 2005;
const int STOOL = 1, PENCIL = 2;
struct item {
int price, type, original;
bool operator<(const item &o) const { return price < o.price; }
};
int N, K;
item items[NK_MAX];
vector<int> carts[NK_MAX];
int main() {
scanf("%d %d", &N, &K);
int n_stools = 0;
double total_price = 0;
for (int i = 0; i < N; i++) {
scanf("%d %d", &items[i].price, &items[i].type);
items[i].original = i;
total_price += items[i].price;
if (items[i].type == STOOL) n_stools++;
}
sort(items, items + N);
double save = 0;
if (n_stools >= K) {
int k = 0, done = N;
for (int i = N - 1; i >= 0 && k < K - 1; i--)
if (items[i].type == STOOL) {
save += items[i].price;
for (int j = i; j < done; j++) carts[k].push_back(items[j].original);
done = i;
k++;
}
save += items[0].price;
for (int i = 0; i < done; i++) carts[k].push_back(items[i].original);
} else {
int k = 0;
for (int i = 0; i < N; i++)
if (items[i].type == STOOL) {
save += items[i].price;
carts[k].push_back(items[i].original);
k++;
}
assert(k == n_stools);
for (int i = 0; i < N; i++)
if (items[i].type == PENCIL) {
carts[k].push_back(items[i].original);
k++;
if (k == K) k = n_stools;
}
}
printf("%.1lf\n", total_price - 0.5 * save);
set<int> indices;
for (int i = 0; i < K; i++) {
printf("%d", (int)carts[i].size());
for (int j = 0; j < (int)carts[i].size(); j++) {
printf(" %d", carts[i][j] + 1);
indices.insert(carts[i][j]);
}
printf("\n");
}
assert((int)indices.size() == N);
return 0;
}
|
#include <bits/stdc++.h>
struct pen {
int po;
int cost;
int num;
};
int cmp(const void *a, const void *b) {
struct pen *x = (struct pen *)a;
struct pen *y = (struct pen *)b;
if (x->po == y->po) {
return y->cost - x->cost;
}
return x->po - y->po;
}
struct pen a[1010];
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n, k, i, num = 0, x, y;
long long sum = 0;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d%d", &a[i].cost, &a[i].po);
a[i].num = i;
sum += a[i].cost;
if (a[i].po == 1) num++;
}
qsort(a, n, sizeof(struct pen), cmp);
if (num < k) {
double tmp = 0;
for (i = 0; i < num; i++) tmp += a[i].cost;
double ans = sum - tmp / 2.0;
printf("%.1lf\n", ans);
for (i = 0; i < k - 1; i++) printf("1 %d\n", a[i].num + 1);
printf("%d", n - k + 1);
for (i = k - 1; i < n; i++) printf(" %d", a[i].num + 1);
printf("\n");
} else {
double tmp = 0;
for (i = 0; i < k - 1; i++) tmp += a[i].cost;
tmp += min(a[num - 1].cost, a[n - 1].cost);
double ans = sum - tmp / 2;
printf("%.1lf\n", ans);
for (i = 0; i < k - 1; i++) printf("1 %d\n", a[i].num + 1);
printf("%d", n - k + 1);
for (i = k - 1; i < n; i++) printf(" %d", a[i].num + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
vector<int> ans[N];
int n, k, mmin[N];
double s;
struct node {
int w, k, i;
friend bool operator<(const node &a, const node &b) {
if (a.k != b.k) return a.k < b.k;
if (a.w != b.w) return a.w > b.w;
return a.i < b.i;
}
} p[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &p[i].w, &p[i].k);
p[i].i = i;
s += p[i].w;
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= k; i++) mmin[i] = 2000000000;
int tt = 1, jj = 1;
for (tt; tt <= n && p[tt].k == 1; tt++)
;
for (int i = 1; i < tt; i++) {
ans[jj].push_back(p[i].i);
mmin[jj] = min(mmin[jj], p[i].w);
if (jj < k) jj++;
}
int pp = min(k, tt - 1);
if (pp < k)
while (jj <= k) {
mmin[jj] = min(mmin[jj], p[tt].w);
ans[jj++].push_back(p[tt++].i);
}
for (int i = n; i >= tt; i--) {
if (pp == 0) {
ans[1].push_back(p[i].i);
continue;
}
if (p[i].w <= mmin[pp]) {
if (pp == k) {
ans[pp].push_back(p[i].i);
mmin[pp] = p[i].w;
} else
ans[pp + 1].push_back(p[i].i);
continue;
}
for (int j = pp; j > 0; j--)
if (mmin[j] <= p[i].w) {
ans[j].push_back(p[i].i);
break;
}
}
for (int i = 1; i <= pp; i++) s -= (double)mmin[i] / 2;
printf("%.1lf\n", s);
for (int i = 1; i <= k; i++) {
int size = ans[i].size();
printf("%d", size);
for (int j = 1; j <= size; j++) printf(" %d", ans[i][j - 1]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, ns, np, oc, stools;
int idcart[1005][1005], cart[1005][1005], idst[1005], st[1005], idpen[1005],
pen[1005];
vector<pair<int, int> > vst, vpen;
int main() {
scanf("%d %d", &n, &k);
ns = np = 0;
for (i = 0; i < n; i++) {
int c, t;
scanf("%d %d", &c, &t);
if (t == 1) {
vst.push_back(make_pair(c, i + 1));
ns++;
} else {
vpen.push_back(make_pair(c, i + 1));
np++;
}
}
sort(vst.begin(), vst.end());
sort(vpen.begin(), vpen.end());
for (i = 0; i < k && ns - 1 - i >= 0; i++) {
cart[i][++cart[i][0]] = vst[ns - 1 - i].first;
idcart[i][++idcart[i][0]] = vst[ns - 1 - i].second;
}
stools = oc = i;
for (i = ns - k - 1; i >= 0; i--) {
cart[k - 1][++cart[k - 1][0]] = vst[i].first;
idcart[k - 1][++idcart[k - 1][0]] = vst[i].second;
}
j = 0;
for (i = oc; i < k; i++)
if (cart[i][0] == 0) {
idcart[i][++idcart[i][0]] = vpen[j].second;
cart[i][++cart[i][0]] = vpen[j++].first;
}
oc = j;
for (i = oc; i < np; i++) {
for (j = 0; j < k - 1; j++)
if (pen[i] >= cart[j][1]) {
cart[j][++cart[j][0]] = vpen[i].first;
idcart[j][++idcart[j][0]] = vpen[i].second;
break;
}
if (j == k - 1) {
cart[k - 1][++cart[k - 1][0]] = vpen[i].first;
idcart[k - 1][++idcart[k - 1][0]] = vpen[i].second;
}
}
for (i = 0; i < k; i++) sort(cart[i] + 1, cart[i] + cart[i][0] + 1);
double price = 0.0;
for (i = 0; i < k; i++) {
j = 1;
if (i < stools) {
price += cart[i][1] / 2.0;
j++;
}
for (; j <= cart[i][0]; j++) price += cart[i][j];
}
printf("%.1f\n", price);
for (i = 0; i < k; i++) {
printf("%d ", idcart[i][0]);
for (j = 1; j <= idcart[i][0]; j++) printf("%d ", idcart[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int p, id;
int t;
friend bool operator<(const node &a, const node &b) { return a.p > b.p; }
} a[1010], b[1010];
vector<node> ans[1010];
int n, m;
int main() {
scanf("%d%d", &n, &m);
int an = 0, bn = 0;
for (int i = 0; i < n; i++) {
int p, t;
scanf("%d%d", &p, &t);
if (t == 1) {
a[an].p = p;
a[an].t = 1;
a[an++].id = i;
} else {
b[bn].p = p;
b[bn].t = 2;
b[bn++].id = i;
}
}
sort(a, a + an);
for (int i = 0; i < m; i++) ans[i].clear();
for (int i = 0; i < min(an, m); i++) ans[i].push_back(a[i]);
for (int i = m; i < an; i++) ans[m - 1].push_back(a[i]);
if (an < m) {
for (int i = an; i < m; i++) ans[i].push_back(b[i - an]);
for (int i = m - an; i < bn; i++) ans[m - 1].push_back(b[i]);
} else {
for (int i = 0; i < bn; i++) ans[m - 1].push_back(b[i]);
}
double tot = 0;
for (int i = 0; i < m; i++) {
int tmp = -1;
int flag = 0;
for (int j = 0; j < ans[i].size(); j++) {
if (ans[i][j].t == 1) flag = 1;
if (tmp < 0 || ans[i][j].p < tmp) tmp = ans[i][j].p;
tot += ans[i][j].p;
}
if (flag) tot -= tmp * 1.0 / 2.0;
}
printf("%.1lf\n", tot);
for (int i = 0; i < m; i++) {
int k = ans[i].size();
printf("%d", k);
for (int j = 0; j < k; j++) printf(" %d", ans[i][j].id + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double tmp;
int N, K;
vector<pair<int, int> > s;
vector<pair<int, int> > p;
vector<int> chart[1010];
int main() {
scanf(" %d %d", &N, &K);
for (int i = 1, a, b; i <= N; i++) {
scanf(" %d %d", &a, &b);
if (b == 1)
s.push_back(pair<int, int>(a, i));
else
p.push_back(pair<int, int>(a, i));
}
sort(s.begin(), s.end());
sort(p.begin(), p.end());
int i, k;
for (i = (int)s.size() - 1, k = 1; k < K && i >= 0; k++, i--) {
tmp += (double)s[i].first / 2.00;
chart[k].push_back(s[i].second);
}
if (k == K) {
for (; i >= 0; i--) {
tmp += (double)s[i].first;
chart[k].push_back(s[i].second);
}
for (int l = 0; l < (int)p.size(); l++) {
chart[k].push_back(p[l].second);
tmp += (double)p[l].first;
}
if ((int)s.size() != K - 1 && s.size() && p.size()) {
if (p[0].first < s[0].first)
tmp -= (double)p[0].first / 2.00;
else
tmp -= (double)s[0].first / 2.00;
} else if ((int)s.size() != K - 1 && !p.size())
tmp -= (double)s[0].first / 2.00;
} else {
for (i = 0; i < (int)p.size() && k <= K; k++, i++) {
chart[k].push_back(p[i].second);
tmp += (double)p[i].first;
}
for (; i < (int)p.size(); i++) {
chart[k - 1].push_back(p[i].second);
tmp += (double)p[i].first;
}
}
printf("%.1lf\n", tmp);
for (int i = 1; i <= K; i++) {
printf("%d", (int)chart[i].size());
for (int j = 0; j < (int)chart[i].size(); j++) printf(" %d", chart[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > c1, c2;
int main() {
int n, k;
cin >> n >> k;
int c, t;
for (int i = 0; i < n; i++) {
cin >> c >> t;
if (t == 1)
c1.push_back(pair<int, int>(c, i + 1));
else
c2.push_back(pair<int, int>(c, i + 1));
}
sort(c1.begin(), c1.end());
sort(c2.begin(), c2.end());
cout.flags(ios::fixed);
cout.precision(1);
if (c1.size() >= k) {
double ans = 0;
for (int i = 1; i < k; i++) {
ans += c1[c1.size() - i].first / 2.;
}
for (int i = 1; i < c2.size(); i++) ans += c2[i].first;
if (c2.size()) {
if (c1[0].first < c2[0].first)
ans += (c1[0].first / 2. + c2[0].first);
else
ans += (c2[0].first / 2. + c1[0].first);
} else
ans += c1[0].first / 2.;
for (int j = (int)c1.size() - k; j > 0; j--) ans += c1[j].first;
cout << ans << endl;
for (int i = 1; i < k; i++)
cout << "1 " << c1[c1.size() - i].second << endl;
cout << (c2.size() + c1.size() - (k - 1));
for (int j = (int)c1.size() - k; j >= 0; j--) cout << " " << c1[j].second;
for (int i = 0; i < c2.size(); i++) cout << " " << c2[i].second;
cout << endl;
} else {
double ans = 0;
for (int i = 0; i < c1.size(); i++) ans += c1[i].first / 2.;
for (int i = 0; i < c2.size(); i++) ans += c2[i].first;
cout << ans << endl;
int x = c1.size();
for (int i = 0; i < c1.size(); i++) {
cout << "1 " << c1[i].second << endl;
}
int i = 0;
while (x + 1 < k) {
cout << "1 " << c2[i].second << endl;
x++;
i++;
}
cout << n - k + 1;
while (i < c2.size()) {
cout << " " << c2[i].second;
i++;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
vector<pair<long, long> > st, pe;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
if (b == 1) {
st.push_back(make_pair(a * 2LL, i + 1));
} else
pe.push_back(make_pair(a * 2LL, i + 1));
}
sort(st.rbegin(), st.rend());
sort(pe.rbegin(), pe.rend());
int dis = min(k, (int)st.size());
int i = 0;
int j = 0;
long long ans = 0;
vector<int> cart[1010];
if (dis == k) {
int cnum = 1;
for (int i = 0; i < dis - 1; i++) {
ans += st[i].first / 2LL;
cart[cnum++].push_back(st[i].second);
}
for (int i = dis - 1; i < st.size(); i++) {
ans += st[i].first;
cart[cnum].push_back(st[i].second);
}
for (int j = 0; j < pe.size(); j++) {
ans += pe[j].first;
cart[cnum].push_back(pe[j].second);
}
if (pe.size() > 0)
ans -= min(st[st.size() - 1].first / 2LL, pe[pe.size() - 1].first / 2LL);
else
ans -= st[st.size() - 1].first / 2LL;
} else {
int cnum = 1;
for (int i = 0; i < dis; i++) {
ans += st[i].first / 2LL;
cart[cnum++].push_back(st[i].second);
}
for (int j = 0; j < pe.size(); j++) {
if (cnum < k)
cart[cnum++].push_back(pe[j].second);
else
cart[cnum].push_back(pe[j].second);
ans += pe[j].first;
}
}
cout << ans / 2LL;
if (ans % 2)
printf(".5\n");
else
printf(".0\n");
for (int i = 1; i <= k; i++) {
printf("%d", cart[i].size());
for (int j = 0; j < cart[i].size(); j++) printf(" %d", cart[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
namespace IO_Optimization {
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) {
X = (X << 3) + (X << 1) + (ch ^ 48);
ch = getchar();
}
return w ? -X : X;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
} // namespace IO_Optimization
using namespace IO_Optimization;
int n, k;
double sum;
struct Node {
int num, pos;
} a[2000 + 2], b[2000 + 2];
struct Trans {
int s[2000 + 2];
} ans[2000 + 2];
int tot1, tot2;
inline bool cmp(Node x, Node y) { return x.num > y.num; }
int main() {
n = read(), k = read();
for (register int i = 1; i <= n; ++i) {
int x = read(), y = read();
if (y == 1)
a[++tot1].num = x, a[tot1].pos = i;
else
b[++tot2].num = x, b[tot2].pos = i;
}
sort(a + 1, a + 1 + tot1, cmp);
int noww = k - 1 < tot1 ? k - 1 : tot1;
for (register int i = 1; i <= noww; ++i) {
ans[i].s[++ans[i].s[0]] = a[i].pos;
sum += a[i].num * 0.5;
}
if (tot1 <= k - 1) {
for (register int i = 1; i <= tot2; ++i) {
int nowww = tot1 + i < k ? tot1 + i : k;
sum += b[i].num;
ans[nowww].s[++ans[nowww].s[0]] = b[i].pos;
}
} else {
int minn = 1e9;
for (register int i = k; i <= tot1; ++i) {
sum += a[i].num;
ans[k].s[++ans[k].s[0]] = a[i].pos;
minn = a[i].num < minn ? a[i].num : minn;
}
for (register int i = 1; i <= tot2; ++i) {
sum += b[i].num;
ans[k].s[++ans[k].s[0]] = b[i].pos;
minn = b[i].num < minn ? b[i].num : minn;
}
sum -= minn * 0.5;
}
printf("%.1lf\n", sum);
for (register int i = 1; i <= k; ++i, puts("")) {
write(ans[i].s[0]);
cout << " ";
for (register int j = 1; j <= ans[i].s[0]; ++j) {
write(ans[i].s[j]);
cout << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> arr[1005], pencil[1005];
int main() {
int n, k, cnt = 0, p_cnt = 0;
scanf("%d%d", &n, &k);
double tot = 0;
for (int i = 0; i < n; i++) {
int c, t;
scanf("%d%d", &c, &t);
tot += c;
if (!--t)
arr[cnt++] = make_pair(c, i);
else
pencil[p_cnt++] = make_pair(c, i);
}
sort(arr, arr + cnt, greater<pair<int, int> >());
sort(pencil, pencil + p_cnt, less<pair<int, int> >());
if (cnt < k) {
for (int i = 0; i < cnt; i++) tot -= (double)arr[i].first / 2;
printf("%.1lf\n", tot);
for (int i = 0; i < cnt; i++) printf("1 %d\n", arr[i].second + 1);
for (int i = cnt; i < k - 1; i++)
printf("1 %d\n", pencil[--p_cnt].second + 1);
printf("%d ", p_cnt);
while (p_cnt--) printf("%d%c", pencil[p_cnt].second + 1, " \n"[!p_cnt]);
} else {
for (int i = 0; i < k - 1; i++) tot -= (double)arr[i].first / 2;
tot -=
(double)min(arr[cnt - 1].first, p_cnt ? pencil[0].first : 1000000000) /
2;
printf("%.1lf\n", tot);
for (int i = 0; i < k - 1; i++) printf("1 %d\n", arr[i].second + 1);
printf("%d ", n - k + 1);
for (int i = k - 1; i < cnt; i++) printf("%d ", arr[i].second + 1);
for (int i = 0; i < p_cnt; i++) printf("%d ", pencil[i].second + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void remin(T& cur, const T& prop) {
if (cur > prop) cur = prop;
}
template <typename T>
inline void remax(T& cur, const T& prop) {
if (cur < prop) cur = prop;
}
int main() {
int i, j, n, goods, a, t;
vector<pair<int, int> > st, fl;
scanf("%d%d", &goods, &n);
for ((i) = (0); (i) < (goods); ++(i)) {
scanf("%d%d", &a, &t);
(t == 1 ? st : fl).push_back(make_pair(a, i + 1));
}
sort((st).begin(), (st).end(), greater<pair<int, int> >());
vector<vector<pair<int, int> > > res;
for ((i) = (0); (i) < (n); ++(i))
if (i < st.size())
res.push_back(vector<pair<int, int> >(1, st[i]));
else
break;
for ((j) = (0); (j) < (n - i); ++(j))
if (j < fl.size())
res.push_back(vector<pair<int, int> >(1, fl[j]));
else
break;
assert(res.size() == n);
vector<pair<int, int> >& tail = res.back();
tail.insert(tail.end(), st.begin() + i, st.end());
tail.insert(tail.end(), fl.begin() + j, fl.end());
sort((tail).begin(), (tail).end());
long long doubleSum = st.size() < n ? 0 : tail.front().first;
for ((i) = (0); (i) < ((st).size()); ++(i))
if (i < n - 1) doubleSum += res[i][0].first;
doubleSum = -doubleSum;
for ((i) = (0); (i) < ((res).size()); ++(i))
for ((j) = (0); (j) < ((res[i]).size()); ++(j))
doubleSum += res[i][j].first * 2;
printf("%I64d.%d", doubleSum / 2, (doubleSum % 2) * 5);
for ((i) = (0); (i) < ((res).size()); ++(i)) {
printf("\n%d", res[i].size());
for ((j) = (0); (j) < ((res[i]).size()); ++(j))
printf(" %d", res[i][j].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int BUFSIZE = 1 << 16;
char BUFFER[BUFSIZE + 5];
int REM = 0, POS = 0;
char GETCHAR() {
if (REM <= 0) {
POS = 0;
REM = fread(BUFFER, 1, BUFSIZE, stdin);
if (REM <= 0) return EOF;
}
--REM;
return BUFFER[POS++];
}
void GETALPHA(char &C) {
C = EOF;
while (!isalpha(C)) C = GETCHAR();
}
template <class T>
void GETINT(T &VAL) {
VAL = 0;
char C = EOF;
while (C != '-' && !isdigit(C)) C = GETCHAR();
bool NEG = C == '-';
if (NEG) C = GETCHAR();
while (isdigit(C)) {
VAL = VAL * 10 + C - '0';
C = GETCHAR();
}
if (NEG) VAL = -VAL;
}
const int MAXN = 1005;
struct Product {
int idx, type;
long long cost;
bool operator<(const Product &that) const { return cost > that.cost; }
};
int n, k;
Product a[MAXN];
vector<int> res[MAXN];
bool used[MAXN];
bool hasStool[MAXN];
int main() {
GETINT(n);
GETINT(k);
for (int i = (1); i <= (n); ++i) {
a[i].idx = i;
GETINT(a[i].cost);
GETINT(a[i].type);
}
sort(a + 1, a + n + 1);
memset(used, false, sizeof(used));
memset(hasStool, false, sizeof(hasStool));
int cnt = 0;
for (int i = (1); i <= (n); ++i)
if (cnt < k && a[i].type == 1) {
used[i] = true;
res[cnt].push_back(i);
hasStool[cnt] = true;
++cnt;
}
for (int i = (1); i <= (n); ++i)
if (cnt < k && !used[i]) {
used[i] = true;
res[cnt].push_back(i);
++cnt;
}
for (int i = (1); i <= (n); ++i)
if (!used[i]) res[k - 1].push_back(i);
double total = 0;
for (int i = 0; i < (k); ++i) {
long long small = a[res[i][0]].cost;
for (int j = 0; j < (res[i].size()); ++j) {
total += a[res[i][j]].cost;
small = min(small, a[res[i][j]].cost);
}
if (hasStool[i]) total -= 0.5 * small;
}
printf("%0.1lf\n", total);
for (int i = 0; i < (k); ++i) {
printf("%d ", res[i].size());
for (int j = 0; j < (res[i].size()); ++j) printf("%d ", a[res[i][j]].idx);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > a, b;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
vector<pair<long long, long long> > r[1001];
bool mark[1001];
int main() {
int n, k, t;
long long c;
memset(mark, false, sizeof mark);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> c >> t;
if (t == 1)
mark[i] = true, a.push_back(make_pair(c, i));
else
b.push_back(make_pair(c, i));
}
sort(a.begin(), a.end(), cmp);
sort(b.begin(), b.end(), cmp);
int j = 0;
for (int i = 0; i < a.size(); i++) {
if (j < k - 1)
r[j++].push_back(a[i]);
else
r[j].push_back(a[i]);
}
for (int i = 0; i < b.size(); i++) {
if (j < k - 1)
r[j++].push_back(b[i]);
else
r[j].push_back(b[i]);
}
double res = 0;
for (int i = 0; i < k; i++) {
long long mn = 0;
if (mark[r[i][0].second]) mn = 1000000003;
for (int j = 0; j < r[i].size(); j++) {
mn = min(mn, r[i][j].first);
res += r[i][j].first;
}
res -= mn / 2.0;
}
cout << setprecision(1) << fixed << res << endl;
for (int i = 0; i < k; i++) {
cout << r[i].size();
for (int j = 0; j < r[i].size(); j++) cout << " " << r[i][j].second + 1;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& x) {
return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-11;
char TEMPORARY_CHAR;
const int INF = 1e9;
const int N = 1 << 16;
inline void input(int& a) {
a = 0;
while ((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') {
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
pair<int, int> a[1000];
bool cmp(int i, int j) {
return a[i].second < a[j].second ||
(a[j].second == a[i].second && a[i].first > a[j].first);
}
int main() {
int(n);
input((n));
;
int(k);
input((k));
;
int o[1000];
int tab = 0;
for (int i = 0; i < (int)(n); i++) {
a[i].first = 2 * nxt();
a[i].second = nxt();
if (a[i].second == 1) tab++;
o[i] = i;
}
int r = min(k - 1, tab);
sort(o, o + n, cmp);
long long ans = 0;
vector<vector<int> > q(k);
int p = 0;
for (int i = 0; i < (int)(r); i++) {
ans += a[o[i]].first / 2;
q[p++].push_back(o[i] + 1);
}
int mi = a[r].first;
for (int i = (r); i <= (int)(n - 1); i++) {
mi = min(mi, a[o[i]].first);
ans += a[o[i]].first;
if (p < k - 1)
q[p++].push_back(o[i] + 1);
else
q[p].push_back(o[i] + 1);
}
if (tab > k - 1) ans -= mi / 2;
if (ans & 1)
cout << ans / 2 << ".5\n";
else
cout << ans / 2 << ".0\n";
for (int i = 0; i < (int)(k); i++) {
cout << (int)q[i].size() << " ";
for (__typeof((q[i]).begin()) it = (q[i]).begin(); it != (q[i]).end(); it++)
cout << *it << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double minn = 1e9 + 5, ans;
int n, k, tot;
bool vis[1005];
struct Node {
int id;
double var;
Node(int _id = 0, double _var = 0) {
id = _id;
var = _var;
}
friend bool operator<(Node a, Node b) { return a.var < b.var; }
} a[1005];
queue<int> Q[1005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
double x;
int t;
scanf("%lf%d", &x, &t);
if (t == 1) {
a[++tot] = Node(i, x);
} else {
ans += x;
minn = min(minn, x);
}
}
sort(a + 1, a + tot + 1);
if (k - 1 < tot) {
for (int i = 1; i <= k - 1; i++) {
ans += a[tot - i + 1].var * 0.5;
vis[a[tot - i + 1].id] = 1;
Q[i].push(a[tot - i + 1].id);
}
for (int i = k; i <= tot; i++) {
minn = min(minn, a[tot - i + 1].var);
ans += a[tot - i + 1].var;
vis[a[tot - i + 1].id] = 1;
Q[k].push(a[tot - i + 1].id);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) Q[k].push(i);
}
ans -= minn * 0.5;
printf("%.1lf\n", ans);
for (int i = 1; i <= k; i++) {
printf("%d", Q[i].size());
while (!Q[i].empty()) {
printf(" %d", Q[i].front());
Q[i].pop();
}
printf("\n");
}
} else {
for (int i = 1; i <= tot; i++) {
ans += 0.5 * a[i].var;
vis[a[i].id] = 1;
Q[i].push(a[i].id);
}
printf("%.1lf\n", ans);
if (k - 1 == tot) {
for (int i = 1; i <= n; i++) {
if (!vis[i]) Q[k].push(i);
}
for (int i = 1; i <= k; i++) {
printf("%d", Q[i].size());
while (!Q[i].empty()) {
printf(" %d", Q[i].front());
Q[i].pop();
}
printf("\n");
}
} else {
int now = tot;
while (now != k - 1) {
for (int i = 1; i <= n; i++) {
if (!vis[i]) Q[++now].push(i);
vis[i] = 1;
if (now == k - 1) break;
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) Q[k].push(i);
}
for (int i = 1; i <= k; i++) {
printf("%d", Q[i].size());
while (!Q[i].empty()) {
printf(" %d", Q[i].front());
Q[i].pop();
}
printf("\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000], s[1000], s1[1000];
void qs(int q, int w) {
int e = q, r = w, t = a[q + (rand() % (w - q + 1))], y;
do {
while (a[e] > t) e++;
while (a[r] < t) r--;
if (e <= r) {
y = a[e];
a[e] = a[r];
a[r] = y;
y = s[e];
s[e] = s[r];
s[r] = y;
y = s1[e];
s1[e] = s1[r];
s1[r] = y;
e++;
r--;
}
} while (e <= r);
if (q < r) qs(q, r);
if (e < w) qs(e, w);
}
int main() {
int q, w, e, r, t = 0, t1 = 0, *d[1000], d1[1000], f[1000];
double ans = 0;
scanf("%d%d", &q, &w);
for (e = 0; e < q; e++) {
scanf("%d%d", &a[e], &s[e]);
if (s[e] == 1) t1++;
ans += a[e];
s1[e] = e + 1;
f[e] = 1 << 30;
if (e == w - 1)
d[e] = new int[q];
else
d[e] = new int[1];
}
qs(0, q - 1);
t1 = min(t1, w);
for (e = 0; e < q; e++)
if (s[e] == 1) {
if (t == w) t--;
d[t][d1[t]] = s1[e];
d1[t]++;
f[t] = min(f[t], a[e]);
t++;
} else {
if (t1 == w) t1--;
d[t1][d1[t1]] = s1[e];
d1[t1]++;
f[t1] = min(f[t1], a[e]);
t1++;
}
for (e = 0; e < t; e++) ans -= ((double)f[e]) / 2;
printf("%.1f\n", ans);
for (e = 0; e < w; e++) {
printf("%d", d1[e]);
for (r = 0; r < d1[e]; r++) printf(" %d", d[e][r]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pr[1010];
int tip[1010];
int n, k;
deque<int> tab, tov;
struct compare {
bool operator()(const int& f, const int& s) const {
return (pr[f] != pr[s]) ? pr[f] < pr[s] : f < s;
}
};
set<int, compare> kor[1010];
bool has_t[1010];
vector<int> buf;
int main() {
long long comp = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
int c, t;
scanf("%d%d", &c, &t);
pr[i] = c;
tip[i] = t;
comp += 2LL * c;
if (t == 1)
tab.push_back(i);
else
tov.push_back(i);
}
sort(tab.begin(), tab.end(), compare());
sort(tov.begin(), tov.end(), compare());
int pos = 0;
while (!tab.empty()) {
has_t[pos] = true;
kor[pos].insert(tab.back());
tab.pop_back();
if ((pos + 1) < k) ++pos;
}
for (int i = k - 1; i >= 0; --i) {
if (kor[i].empty()) {
kor[i].insert(tov[0]);
tov.pop_front();
}
}
int full = min((int)tab.size(), k);
pos = k - 1;
while (!tov.empty()) {
kor[pos].insert(tov.back());
tov.pop_back();
if ((pos + 1) < k) ++pos;
}
for (int i = 0; i < k; ++i) {
if (has_t[i]) {
int take = *kor[i].begin();
comp -= pr[take];
}
}
if (comp % 2 == 0) {
cout << comp / 2 << ".0\n";
} else {
cout << comp / 2 << ".5\n";
}
for (int i = 0; i < k; ++i) {
buf.clear();
for (set<int, compare>::iterator it = kor[i].begin(); it != kor[i].end();
++it)
buf.push_back(*it + 1);
printf("%d", (int)buf.size());
for (int i = 0; i < buf.size(); ++i) printf(" %d", buf[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > v;
vector<pair<int, int> > w;
long long cost = 0;
for (int i = (0); i < (n); ++i) {
int c, t;
cin >> c >> t;
cost += c;
if (t == 2) {
v.push_back({c, i});
} else {
w.push_back({c, i});
}
}
sort(v.begin(), v.end());
sort(w.begin(), w.end());
vector<int> res;
long long sum = 0;
while (w.size() > 0 && res.size() < k - 1) {
res.push_back(w.back().second);
sum += w.back().first;
w.pop_back();
}
reverse(v.begin(), v.end());
while (v.size() > 0 && res.size() < k - 1) {
res.push_back(v.back().second);
v.pop_back();
}
reverse(v.begin(), v.end());
if (w.size() == 0) {
sum += 0;
} else if (v.size() == 0) {
sum += w[0].first;
} else {
sum += min(w[0].first, v[0].first);
}
sum = 2 * cost - sum;
cout << sum / 2 << (sum % 2 ? ".5" : ".0") << "\n";
for (auto i : res) {
cout << "1 " << i + 1 << "\n";
}
cout << v.size() + w.size() << " ";
for (auto i : w) {
cout << i.second + 1 << " ";
}
for (auto i : v) {
cout << i.second + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
pair<pair<int, int>, int> c[2000];
bool sale[2000];
double sum[2000];
int last[2000];
vector<int> b[1500];
void add(pair<int, int> &item, int id) {
bool s = (item.second == 1);
int cur = item.first;
int best = 0;
double mmin = 1000000000;
for (int i = 0; i < (int)(k); i++) {
double it = 0;
if (sale[i]) {
it = last[i] / 2. + cur / 2.;
} else if (s) {
it = cur / 2.;
} else
it = cur;
if (it < mmin) {
mmin = it;
best = i;
} else if (abs(it - mmin) < 1e-12) {
if (b[i].size() == 0) best = i;
}
}
b[best].push_back(id);
last[best] = cur;
if (s) sale[best] = true;
sum[best] += mmin;
}
int main() {
cin >> n >> k;
for (int i = 0; i < (int)(n); i++) {
cin >> c[i].first.first >> c[i].first.second;
c[i].second = i + 1;
}
sort(c, c + n, greater<pair<pair<int, int>, int> >());
for (int i = 0; i < (int)(n); i++) {
add(c[i].first, c[i].second);
}
double ans = 0;
for (int i = 0; i < (int)(k); i++) ans += sum[i];
printf("%.1lf\n", ans);
for (int i = 0; i < (int)(k); i++) {
printf("%d ", (int)b[i].size());
for (int j = 0; j < (int)b[i].size(); j++) printf("%d ", b[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int c, id;
};
bool cmp(data a, data b) { return a.c > b.c; }
vector<data> t1, t2;
vector<int> a[1001];
int c[1001];
bool ok[1001];
double total;
int k, n;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
data t;
int type;
cin >> t.c >> type;
t.id = i + 1;
if (type == 1)
t1.push_back(t);
else
t2.push_back(t);
}
sort(t1.begin(), t1.end(), cmp);
sort(t2.begin(), t2.end(), cmp);
int i = 0, j = 0, l = 0;
total = 0;
bool full = false;
for (; l < k; l++) c[l] = 2000000000;
l = 0;
memset(ok, false, sizeof ok);
for (; i < t1.size(); i++) {
a[l].push_back(t1[i].id);
c[l] = min(c[l], t1[i].c);
ok[l] = true;
total += t1[i].c;
if (!full) {
l++;
if (l == k) {
full = true;
l = k - 1;
}
}
}
for (; j < t2.size(); j++) {
a[l].push_back(t2[j].id);
c[l] = min(c[l], t2[j].c);
total += t2[j].c;
if (!full) {
l++;
if (l == k) {
full = true;
l = k - 1;
}
}
}
for (i = 0; i < k; i++)
if (ok[i]) total -= c[i] / 2.0;
printf("%.1f\n", total);
for (l = 0; l < k; l++) {
cout << a[l].size() << " ";
for (i = 0; i < a[l].size(); i++) cout << a[l][i] << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
struct penstool {
long order, price, kind;
};
bool compenstool(penstool A, penstool B) {
if (A.kind == B.kind) {
return A.price > B.price;
} else if (A.kind == 1) {
return 1;
} else if (B.kind == 1) {
return 0;
}
return 0;
}
int main() {
long n(0), k(0);
scanf("%ld %ld\n", &n, &k);
std::vector<penstool> itemVec(n + 1);
long minPrice(1e9);
for (int p = 1; p <= n; p++) {
itemVec[p].order = p;
scanf("%ld %ld\n", &itemVec[p].price, &itemVec[p].kind);
if (itemVec[p].price < minPrice) {
minPrice = itemVec[p].price;
}
}
sort(++itemVec.begin(), itemVec.end(), compenstool);
double totalPrice = 0;
for (long p = 1; p <= n; p++) {
if (itemVec[p].kind == 1 && p < k) {
totalPrice += 0.5 * itemVec[p].price;
} else {
totalPrice += itemVec[p].price;
}
}
if (itemVec[k].kind == 1) {
totalPrice -= 0.5 * minPrice;
}
printf("%.1lf\n", totalPrice);
for (long p = 1; p < k; p++) {
printf("1 %ld\n", itemVec[p].order);
}
printf("%ld ", n - k + 1);
for (long p = k; p <= n; p++) {
printf("%ld ", itemVec[p].order);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int const nmax = 1010;
int k, n;
vector<pair<int, int> > st, pe;
vector<int> ans[nmax];
bool dc[nmax];
long double p[nmax];
void solve() {
memset(dc, 0, sizeof(dc));
cin >> k >> n;
for (int i = 0; i < k; i++) {
int c, t;
cin >> c >> t;
p[i] = c;
if (t == 1)
st.push_back(pair<int, int>(c, i));
else
pe.push_back(pair<int, int>(c, i));
}
sort(st.begin(), st.end());
sort(pe.begin(), pe.end());
int k = 0;
while (!st.empty()) {
if (k >= n) k = n - 1;
dc[k] = 1;
ans[k].push_back(st.back().second);
st.pop_back();
k++;
}
for (int i = n - 1; i >= 0; i--) {
if (int((ans[i]).size()) > 0) break;
ans[i].push_back(pe.front().second);
pe.erase(pe.begin());
}
while (!pe.empty()) {
if (k >= n) k = n - 1;
ans[k].push_back(pe.back().second);
pe.pop_back();
k++;
}
long double sum = 0;
for (int i = 0; i < n; i++) {
long double m = INT_MAX;
for (int j = 0; j < int((ans[i]).size()); j++) {
int k = ans[i][j];
sum += p[k];
m = ((m) > (p[k]) ? (p[k]) : (m));
}
if (dc[i]) sum -= m / 2;
}
cout << fixed << setprecision(1) << sum << "\n";
for (int i = 0; i < n; i++) {
cout << int((ans[i]).size()) << " ";
for (int j = 0; j < int((ans[i]).size()); j++) cout << ans[i][j] + 1 << " ";
cout << "\n";
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ch[1005];
vector<pair<int, int> > data[2];
vector<pair<int, int> > table[1005];
int main() {
int i, j, k;
double ans = 0;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d %d", &j, &k);
data[k - 1].push_back(make_pair(j, i + 1));
}
sort(data[0].begin(), data[0].end());
sort(data[1].begin(), data[1].end());
for (i = data[0].size() - 1, j = 0; i >= 0 && j < m; i--, j++) {
table[j].push_back(data[0][i]);
ch[j] = 1;
}
if (i != -1) {
for (; i >= 0; i--) {
table[m - 1].push_back(data[0][i]);
}
ch[m - 1] = 1;
}
if (j != m) {
for (i = data[1].size() - 1; j < m; i--, j++) {
table[j].push_back(data[1][i]);
}
for (; i >= 0; i--) {
table[m - 1].push_back(data[1][i]);
}
} else {
for (i = data[1].size() - 1; i >= 0; i--) {
table[m - 1].push_back(data[1][i]);
}
}
for (i = 0; i < m; i++) {
if (ch[i]) {
sort(table[i].begin(), table[i].end());
ans += (double)table[i][0].first / 2;
} else {
ans += table[i][0].first;
}
for (j = 1; j < table[i].size(); j++) {
ans += table[i][j].first;
}
}
printf("%.1lf", ans);
for (i = 0; i < m; i++) {
printf("\n%d", table[i].size());
for (j = 0; j < table[i].size(); j++) {
printf(" %d", table[i][j].second);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, x, was[111111], jj, has[111111];
double res;
struct tp {
int c, type, ind;
} a[1111];
vector<tp> ans[111111];
bool cmp(tp a, tp b) { return (a.c > b.c) || (a.c == b.c && a.type < b.type); }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].c, &a[i].type);
if (a[i].type == 1) x++;
a[i].ind = i;
}
sort(a + 1, a + n + 1, cmp);
int j = 1, i = 1;
for (; i <= min(k - 1, x); i++) {
for (; j <= n; j++) {
if (a[j].type == 1 && !was[j]) {
ans[i].push_back(a[j]);
has[i] = 1;
was[j] = 1;
break;
}
}
}
j = i;
jj = j;
for (i = 1; i <= n; i++) {
if (was[i]) continue;
ans[j].push_back(a[i]);
if (a[i].type == 1) has[j] = 1;
j++;
if (j > k) j = k;
}
for (int i = 1; i <= n; i++) {
sort(ans[i].begin(), ans[i].end(), cmp);
for (int j = 0; j < ans[i].size(); j++) {
if (j == ans[i].size() - 1 && has[i])
res = res + (ans[i][j].c / 2.0 + .0);
else
res += ans[i][j].c;
}
}
printf("%.1lf\n", res);
for (int i = 1; i <= n; i++) {
if (ans[i].size() > 0) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j].ind);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int readint() {
int i;
scanf("%d", &i);
return i;
}
vector<pair<int, int> > K, T;
vector<vector<int> > result;
int main() {
int n = readint(), k = readint();
unsigned long long sum = 0;
for (int i = 0; i < int(n); ++i) {
int c = readint(), t = readint();
sum += 2 * c;
if (t == 1)
T.push_back(make_pair(2 * c, i));
else
K.push_back(make_pair(2 * c, i));
}
result.resize(k);
sort(K.begin(), K.end());
sort(T.begin(), T.end());
unsigned long long R = sum;
if (T.size() >= k) {
int first = T[0].first;
if (!K.empty()) first = min(K[0].first, T[0].first);
R -= first / 2;
for (int i = 0; i < int(K.size()); ++i) result[0].push_back(K[i].second);
for (int i = 0; i <= int(T.size()) - k; ++i)
result[0].push_back(T[i].second);
for (int j = 0; j < int(k - 1); ++j) {
int i = T.size() - 1 - j;
result[j + 1].push_back(T[i].second);
R -= T[i].first / 2;
}
} else {
for (int i = 0; i < int(T.size()); ++i) {
result[i].push_back(T[i].second);
R -= T[i].first / 2;
}
for (int j = 0; j < int(K.size()); ++j) {
int i = T.size() + j;
if (i >= k) {
result[T.size()].push_back(K[j].second);
} else {
result[i].push_back(K[j].second);
}
}
}
cout << (R / 2);
printf(".");
printf("%d\n", (R % 2) ? 5 : 0);
for (int i = 0; i < int(k); ++i) {
printf("%d", result[i].size());
for (int j = 0; j < int(result[i].size()); ++j)
printf(" %d", result[i][j] + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Obj {
int pri, typ, ind;
Obj() {}
Obj(int p, int t, int i) : pri(p), typ(t), ind(i) {}
} ite[1010];
vector<int> cat[1010];
bool cmp(Obj a, Obj b) { return a.pri > b.pri; }
int n, k, st, sc, pc;
long long ans;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
cat[i].clear();
scanf("%d%d", &ite[i].pri, &ite[i].typ);
ans += ite[i].pri * 2;
ite[i].ind = i;
if (ite[i].typ == 1) st++;
}
std::sort(ite, ite + n, cmp);
pc = st;
for (int i = 0; i < n; i++) {
if (ite[i].typ == 1 && sc < k) {
cat[sc].push_back(i);
if (sc < k - 1) ans -= ite[i].pri;
sc++;
} else {
if (ite[i].typ == 2 && pc < k) {
cat[pc].push_back(i);
pc++;
} else
cat[k - 1].push_back(i);
}
}
if (st >= k) ans -= ite[n - 1].pri;
printf("%I64d.%d\n", ans / 2, ans % 2 == 1 ? 5 : 0);
for (int i = 0; i < k; i++) {
printf("%d", cat[i].size());
for (int j = 0; j < cat[i].size(); j++) {
printf(" %d", ite[cat[i][j]].ind + 1);
}
puts("");
}
scanf(" ");
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = 1e9 + 9;
const int MAXN = 1e3 + 100;
struct item {
int val, type, id;
bool operator<(const item &rhs) const { return val > rhs.val; }
};
vector<item> items[2];
vector<item> cart[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
item it;
it.id = i + 1;
cin >> it.val >> it.type;
items[it.type - 1].push_back(it);
}
for (int i = 0; i < 2; ++i) {
sort(items[i].begin(), items[i].end());
}
for (int i = 0; i < min((int)items[0].size(), k); ++i) {
cart[i].push_back(items[0][i]);
}
for (int i = k; i < items[0].size(); ++i) {
cart[k - 1].push_back(items[0][i]);
}
int pnr = items[1].size() - 1, cnr = k - 1;
while (cnr >= 0 && cart[cnr].size() == 0) {
cart[cnr--].push_back(items[1][pnr--]);
}
int pi = 0, ci = 0;
while (pi <= pnr) {
if (ci == k - 1 || cart[ci][0].val <= items[1][pi].val) {
cart[ci].push_back(items[1][pi++]);
} else {
++ci;
}
}
double anssum = 0;
for (int i = 0; i < k; ++i) {
bool stool = false;
int mn = INF;
for (auto it : cart[i]) {
if (it.type == 1) stool = true;
mn = min(mn, it.val);
anssum += it.val;
}
if (stool) {
anssum -= mn / 2.0;
}
}
cout.precision(1);
cout << fixed << anssum << "\n";
for (int i = 0; i < k; ++i) {
cout << cart[i].size();
for (auto it : cart[i]) {
cout << " " << it.id;
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
long long sum;
struct item {
int no, cst, tp;
item(int n = 0, int c = 0, int t = 0) {
no = n;
cst = c;
tp = t;
}
bool operator<(const item &cmp) const { return cst < cmp.cst; }
} S[1001], P[1001], ans[1001][1001];
int K, N, sCnt, pCnt;
int cnt[1001];
int main() {
scanf("%d%d", &N, &K);
for (int i = 0; i < N; i++) {
int C, typ;
scanf("%d%d", &C, &typ);
if (typ == 1)
S[sCnt++] = item(i, C, 1);
else
P[pCnt++] = item(i, C, 2);
sum += C * 2;
}
std::sort(S, S + sCnt);
std::sort(P, P + pCnt);
for (int i = sCnt - 1, j = K - 1; i >= 0; --i) {
ans[j][cnt[j]++] = S[i];
if (j > 0) --j;
}
int k = 0;
for (int i = 0; i < K && cnt[i] == 0; ++i) {
ans[i][cnt[i]++] = P[k];
++k;
}
for (; k < pCnt; k++) ans[0][cnt[0]++] = P[k];
for (int i = 0; i < K; i++) {
int Min = 2147483647, avl = 0;
for (int j = 0; j < cnt[i]; ++j) {
if (ans[i][j].cst < Min) Min = ans[i][j].cst;
if (ans[i][j].tp == 1) avl = 1;
}
if (avl == 1) sum -= Min;
}
if (sum % 2 == 1)
printf("%I64d.5\n", sum / 2);
else
printf("%I64d.0\n", sum / 2);
for (int i = 0; i < K; i++) {
printf("%d", cnt[i]);
for (int j = 0; j < cnt[i]; ++j) printf(" %d", ans[i][j].no + 1);
putchar('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
if (false) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int n, k;
cin >> n >> k;
vector<pair<long long, int> > t, p;
for (int i = 0; i < n; i++) {
long long price;
int type;
cin >> price >> type;
if (type == 1) {
t.push_back(make_pair(price, i));
} else {
p.push_back(make_pair(price, i));
}
}
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
vector<vector<pair<long long, int> > > b(k);
long long price = 0;
int ii = 0;
for (; ii < t.size() && ii < k - 1; ii++) {
b[ii].push_back(t[ii]);
price += t[ii].first;
}
for (; ii < t.size(); ii++) {
b[k - 1].push_back(t[ii]);
price += 2 * t[ii].first;
}
int jj = 0;
for (; ii < k - 1 && jj < p.size(); ii++, jj++) {
b[ii].push_back(p[jj]);
price += 2 * p[jj].first;
}
for (; jj < p.size(); jj++) {
b[k - 1].push_back(p[jj]);
price += 2 * p[jj].first;
}
if (t.size() >= k) {
int pm = -1;
for (int i = 0; i < b[k - 1].size(); i++) {
if (pm < 0 || pm > b[k - 1][i].first) {
pm = b[k - 1][i].first;
}
}
price -= pm;
}
cout << (price / 2);
if (price % 2 != 0) {
cout << ".5";
} else {
cout << ".0";
}
cout << endl;
for (int i = 0; i < k; i++) {
cout << b[i].size();
for (int j = 0; j < b[i].size(); j++) {
cout << " ";
cout << (b[i][j].second + 1);
}
cout << endl;
}
if (false) {
fclose(stdin);
fclose(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, pos;
int c[1100], t[1100], key[1100], id[1100];
double ans, che;
inline int min(const double &x, const double &y) { return (x < y) ? x : y; }
int cmp(const int &x, const int &y) {
return (t[x] != t[y]) ? t[x] < t[y] : c[x] > c[y];
}
void work() {
for (int i = 0; i < n; i++) {
id[i] = i;
key[i] = i + 1;
scanf("%d%d", &c[i], &t[i]);
}
sort(id, id + n, cmp);
pos = 0;
ans = 0.0;
che = 1234567890.0;
for (int i = 0; i < k - 1; i++) {
if (t[id[pos]] == 1)
ans += ((double)c[id[pos]]) * 0.5;
else
ans += (double)c[id[pos]];
pos++;
}
for (int i = pos; i < n; i++) {
che = min(che, c[id[i]]);
ans += c[id[i]];
}
if (t[id[pos]] == 1) ans -= che * 0.5;
printf("%.1f\n", ans);
for (int i = 0; i < k - 1; i++) {
printf("1 %d\n", key[id[i]]);
}
printf("%d", n - pos);
for (int i = pos; i < n; i++) printf(" %d", key[id[i]]);
printf("\n");
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int> > a, b;
vector<int> kov[1010];
int x[1010], y[1010];
inline int min(int x, int y) { return (x < y) ? x : y; }
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) kov[i].clear();
double ans = 0;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
ans += x[i];
if (y[i] == 1) {
a.push_back(make_pair(x[i], i));
} else {
b.push_back(make_pair(x[i], i));
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int t = min(a.size(), k - 1);
int r = 0;
for (int i = a.size() - 1; i >= a.size() - t && i >= 0; i--) {
r++;
kov[r].push_back(a[i].second);
}
if (t == a.size()) {
for (int i = 0; i < b.size(); ++i) {
r++;
if (r > k) r = k;
kov[r].push_back(b[i].second);
}
} else {
for (int i = 0; i < b.size(); ++i) kov[k].push_back(b[i].second);
for (int i = 0; i < a.size() - t; i++) kov[k].push_back(a[i].second);
}
for (int i = 1; i <= k; i++) {
int _min = 1000000000;
bool ok = false;
for (int j = 0; j < kov[i].size(); j++) {
int id = kov[i][j];
if (x[id] < _min) _min = x[id];
if (y[id] == 1) ok = true;
}
if (ok) ans -= _min * 0.5;
}
printf("%.1lf\n", ans);
for (int i = 1; i <= k; i++) {
cout << kov[i].size();
for (int j = 0; j < kov[i].size(); j++) cout << " " << kov[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, k, tmp;
double sum = 0;
vector<pair<long, int> > tab, kar;
vector<vector<pair<long, int> > > v;
cin >> n >> k;
v.resize(k);
for (int i = 0; i < n; i++) {
long type, cost;
cin >> cost >> type;
pair<long, int> p;
p.first = cost;
p.second = i + 1;
if (type == 1) {
tab.push_back(p);
} else {
kar.push_back(p);
}
}
sort(tab.begin(), tab.end());
tmp = 0;
for (int i = tab.size() - 1; i >= 0; i--) {
v[tmp].push_back(tab[i]);
if (tmp < k - 1) tmp++;
}
for (int i = 0; i < kar.size(); i++) {
v[tmp].push_back(kar[i]);
if (tmp < k - 1) tmp++;
}
sort(v[k - 1].begin(), v[k - 1].end());
for (int i = 0; i < k; i++) {
bool b = false;
if (i < tab.size()) b = true;
for (int j = 0; j < v[i].size(); j++) {
if (b && j == 0) {
sum += (double)v[i][j].first * 0.5;
} else {
sum += (double)v[i][j].first;
}
}
}
printf("%0.1f%s", sum, "\n");
for (int i = 0; i < k; i++) {
cout << v[i].size() << " ";
for (int j = 0; j < v[i].size(); j++) {
cout << v[i][j].second << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int kind, ind;
double p;
} node[1100];
int N, K, num;
int cmp(const void *a, const void *b) {
if (((Node *)a)->kind == ((Node *)b)->kind) {
if (((Node *)a)->p < ((Node *)b)->p)
return 1;
else if (((Node *)a)->p > ((Node *)b)->p)
return -1;
return 0;
}
return ((Node *)a)->kind - ((Node *)b)->kind;
}
int main() {
int i, j;
cin >> N >> K;
for (i = 1; i <= N; i++) {
cin >> node[i].p >> node[i].kind;
if (node[i].kind == 1) num++;
node[i].ind = i;
}
qsort(node + 1, N, sizeof(Node), cmp);
if (num >= K) {
double ans = 0;
for (i = 1; i < K; i++) ans -= node[i].p;
if (node[num].p < node[N].p)
ans -= node[num].p;
else
ans -= node[N].p;
ans /= 2;
for (i = 1; i <= N; i++) ans += node[i].p;
printf("%.1f\n", ans);
for (i = 1; i < K; i++) printf("1 %d\n", node[i].ind);
printf("%d", N - K + 1);
for (i = K; i <= N; i++) printf(" %d", node[i].ind);
printf("\n");
} else {
double ans = 0;
for (i = 1; i <= num; i++) ans -= node[i].p;
ans /= 2;
for (i = 1; i <= N; i++) ans += node[i].p;
printf("%.1f\n", ans);
for (i = 1; i <= num; i++) printf("1 %d\n", node[i].ind);
for (; i < K; i++) printf("1 %d\n", node[i].ind);
printf("%d", N - K + 1);
for (i = K; i <= N; i++) printf(" %d", node[i].ind);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y;
int i, j = 0;
double temp = 0;
scanf("%d%d", &n, &m);
vector<pair<int, int> > second, first, voc(n);
vector<vector<int> > answer(m, vector<int>());
for (i = 0; i < n; i++) {
scanf("%d%d", &voc[i].first, &voc[i].second);
if (voc[i].second == 1) {
first.push_back(make_pair(voc[i].first, i));
} else {
second.push_back(make_pair(voc[i].first, i));
}
}
sort((first).begin(), (first).end());
sort((second).begin(), (second).end());
for (i = 0; i < first.size() && i < m; i++) {
answer[i].push_back(first[first.size() - i - 1].second);
}
for (; i < first.size(); i++) {
answer[m - 1].push_back(first[first.size() - i - 1].second);
}
for (int t = i; t < m; t++, j++) {
answer[t].push_back(second[j].second);
}
i = j, j = second.size() - 1;
for (int t = 0; t < m && j >= i; t++) {
if (second[j].first > voc[answer[t].back()].first) {
answer[t].push_back(second[j].second);
j--;
}
}
while (j >= i && j >= 0) {
answer[m - 1].push_back(second[j].second);
j--;
}
for (i = 0; i < m; i++) {
x = 0, y = ~(1 << 31);
for (j = 0; j < answer[i].size(); j++) {
temp += voc[answer[i][j]].first;
x |= (int)((voc[answer[i][j]].second == 1));
y = min(y, voc[answer[i][j]].first);
}
if (x) {
temp -= y * 0.5;
}
}
printf("%.1lf\n", temp);
for (i = 0; i < m; i++) {
printf("%d ", answer[i].size());
for (j = 0; j < answer[i].size(); j++) {
printf("%d ", answer[i][j] + 1);
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, n1, n2;
pair<long long, int> stool[1005], pencil[1005];
double ans;
void solve() {
sort(stool, stool + n1);
reverse(stool, stool + n1);
sort(pencil, pencil + n2);
reverse(pencil, pencil + n2);
vector<vector<int> > cart(k);
if (k > n1) {
for (int i = 0; i < n1; i++) {
ans -= 0.5 * (double)stool[i].first;
cart[i].push_back(stool[i].second);
}
for (int i = n1; i < n1 + n2 && i < k; i++)
cart[i].push_back(pencil[i - n1].second);
for (int i = k; i < n1 + n2; i++)
cart[k - 1].push_back(pencil[i - n1].second);
} else {
for (int i = 0; i < k - 1; i++) {
ans -= 0.5 * (double)stool[i].first;
cart[i].push_back(stool[i].second);
}
double minV = (double)stool[k - 1].first;
for (int i = k - 1; i < n1; i++) {
minV = min(minV, (double)stool[i].first);
cart[k - 1].push_back(stool[i].second);
}
for (int i = 0; i < n2; i++) {
minV = min(minV, (double)pencil[i].first);
cart[k - 1].push_back(pencil[i].second);
}
ans -= 0.5 * minV;
}
printf("%.1f\n", ans);
for (int i = 0; i < k; i++) {
printf("%d", (int)cart[i].size());
for (int j = 0; j < cart[i].size(); j++) printf(" %d", cart[i][j]);
printf("\n");
}
}
int main() {
cin >> n >> k;
long long c, t;
n1 = 0;
n2 = 0;
ans = 0.0;
for (int i = 1; i <= n; i++) {
cin >> c >> t;
if (t == 1)
stool[n1++] = make_pair(c, i);
else
pencil[n2++] = make_pair(c, i);
ans += (double)c;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
typedef struct {
int c;
int i;
} item;
int cmp(const void *a, const void *b) {
return ((item *)a)->c - ((item *)b)->c;
}
int d[1000][1000];
int main() {
int n, k, p = 0, q = 0, i, j;
double sum = 0;
item a[1000], b[1000];
int c[1000] = {0};
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (y == 1) {
a[p].c = x;
a[p++].i = i + 1;
} else {
b[q].c = x;
b[q++].i = i + 1;
}
sum += x;
}
qsort(a, p, sizeof(item), cmp);
qsort(b, q, sizeof(item), cmp);
for (i = 0; i < p && i < k; i++) {
d[i][c[i]++] = a[p - i - 1].i;
if (i < k - 1) sum -= a[p - i - 1].c / 2.0;
}
for (; i < p; i++) {
d[k - 1][c[k - 1]++] = a[p - i - 1].i;
}
for (i = 0; i < q; i++) {
if (i < k && c[k - i - 1] == 0) {
d[k - i - 1][c[k - i - 1]++] = b[i].i;
} else {
d[k - 1][c[k - 1]++] = b[i].i;
}
}
if (p >= k) {
int m = a[0].c;
if (q > 0 && b[0].c < m) m = b[0].c;
sum -= m / 2.0;
}
printf("%.1lf\n", sum);
for (i = 0; i < k; i++) {
printf("%d", c[i]);
for (j = 0; j < c[i]; j++) printf(" %d", d[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return n & two(b); }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
const int MAX = 1007;
int N, K;
vector<pair<long long, int> > in[2];
int main() {
scanf("%d%d", &N, &K);
for (int i = 0; i < (N); i++) {
int a, b;
scanf("%d%d", &a, &b);
in[b - 1].push_back(make_pair(a, i + 1));
}
sort(in[0].begin(), in[0].end());
reverse(in[0].begin(), in[0].end());
if (in[0].size() >= K) {
long long sum = 0, M = in[0].back().first;
for (int i = 0; i < (K - 1); i++) sum += in[0][i].first * 5;
for (int i = (K - 1); i <= ((int)in[0].size() - 1); i++)
sum += in[0][i].first * 10;
for (int i = 0; i < (in[1].size()); i++) {
sum += in[1][i].first * 10;
M = min(M, in[1][i].first);
}
sum -= M * 5;
cout << (sum / 10) << "." << (sum % 10) << endl;
for (int i = 0; i < (K - 1); i++) printf("1 %d\n", in[0][i].second);
printf("%d", in[0].size() - K + 1 + in[1].size());
for (int i = (K - 1); i <= ((int)in[0].size() - 1); i++)
printf(" %d", in[0][i].second);
for (int i = 0; i < (in[1].size()); i++) printf(" %d", in[1][i].second);
printf("\n");
} else {
long long sum = 0;
for (int i = 0; i < (in[0].size()); i++) sum += in[0][i].first * 5;
for (int i = 0; i < (in[1].size()); i++) sum += in[1][i].first * 10;
cout << (sum / 10) << "." << (sum % 10) << endl;
for (int i = 0; i < (in[0].size()); i++) printf("1 %d\n", in[0][i].second);
int index = 0;
for (int i = (in[0].size()); i <= (K - 2); i++)
printf("1 %d\n", in[1][index++].second);
printf("%d", in[1].size() - index);
while (index < in[1].size()) printf(" %d", in[1][index++].second);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
int n, k;
int c[1111], t[1111];
vector<int> r[1111];
int main() {
cin >> n >> k;
for (int i(0); i < (n); i++) scanf("%d %d", c + i, t + i);
vector<pair<int, int> > v;
for (int i(0); i < (n); i++)
if (t[i] == 1) v.push_back(pair<int, int>(c[i], i));
sort((v).begin(), (v).end());
reverse(v.begin(), v.end());
for (int i(0); i < (v.size()); i++) r[min(i, k - 1)].push_back(v[i].second);
int pos = k - 1;
for (int i(0); i < (k); i++)
if (r[i].size() == 0) {
pos = i;
break;
}
for (int i(0); i < (n); i++)
if (t[i] == 2) {
r[pos].push_back(i);
pos++;
pos = min(pos, k - 1);
}
double res = 0;
for (int i(0); i < (k); i++) {
int mn = 1000000000;
long long sum = 0;
bool hasc = 0;
for (int j(0); j < (r[i].size()); j++) {
if (t[r[i][j]] == 1) hasc = 1;
mn = min(mn, c[r[i][j]]);
sum += c[r[i][j]];
}
res += sum;
res -= mn;
if (hasc)
res += mn / 2.;
else
res += mn;
}
printf("%.1lf\n", res);
for (int i(0); i < (k); i++) {
cout << r[i].size();
for (int j(0); j < (r[i].size()); j++) printf(" %d", r[i][j] + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<pair<long long, int>> stool, pen;
vector<vector<int>> cart(k, vector<int>());
for (int i = 0; i < n; i++) {
long long c, t;
cin >> c >> t;
if (t == 1)
stool.push_back({c, i + 1});
else
pen.push_back({c, i + 1});
}
sort(stool.begin(), stool.end());
sort(pen.begin(), pen.end());
double cost = 0.0;
int ind = 0;
for (int i = stool.size() - 1; i >= 0; i--) {
if (ind != k - 1)
cost += double(stool[i].first) / 2.0;
else
cost += double(stool[i].first);
cart[ind].push_back(stool[i].second);
if (ind < k - 1) ind++;
}
for (int i = 0; i < pen.size(); i++) {
cost += double(pen[i].first);
cart[ind].push_back(pen[i].second);
if (ind < k - 1) ind++;
}
if (stool.size() >= k) {
if (pen.size() > 0) {
if (pen[0].first < stool[0].first)
cost -= double(pen[0].first) / 2.0;
else
cost -= double(stool[0].first) / 2.0;
} else
cost -= double(stool[0].first) / 2.0;
}
cout << fixed << setprecision(1) << cost << endl;
for (int i = 0; i < k; i++) {
cout << cart[i].size() << " ";
for (int j = 0; j < cart[i].size(); j++) cout << cart[i][j] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int r, c;
pair<int, int> x[1010];
pair<int, int> y[1010];
int cajas[1010][1010];
int size[1010];
while (scanf("%d %d", &n, &k) > 0) {
for (int i = 0; i < k; i++) size[i] = 0;
r = c = 0;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (b == 1) {
x[r].second = i + 1;
x[r].first = a;
r++;
} else {
y[c].second = i + 1;
y[c].first = a;
c++;
}
}
double suma = 0.0;
sort(x, x + r);
sort(y, y + c);
for (int i = 1; i < k; i++) {
if (r) {
suma += (1.0 * x[--r].first) / 2.0;
cajas[i][0] = x[r].second;
size[i] = 1;
} else {
suma += (1.0 * y[--c].first);
cajas[i][0] = y[c].second;
size[i] = 1;
}
}
if (r && c) {
for (int m = 0; m < c; m++) {
suma += (1.0 * y[m].first);
cajas[0][size[0]] = y[m].second;
size[0]++;
}
for (int m = 0; m < r; m++) {
suma += (1.0 * x[m].first);
cajas[0][size[0]] = x[m].second;
size[0]++;
}
if (x[0].first > y[0].first)
suma -= (1.0 * y[0].first) / 2.0;
else
suma -= (1.0 * x[0].first) / 2.0;
} else if (r) {
suma += (1.0 * x[0].first) / 2.0;
cajas[0][0] = x[0].second;
size[0] = 1;
for (int m = 1; m < r; m++) {
suma += (1.0 * x[m].first);
cajas[0][size[0]] = x[m].second;
size[0]++;
}
} else if (c) {
suma += (1.0 * y[0].first);
cajas[0][0] = y[0].second;
size[0] = 1;
for (int m = 1; m < c; m++) {
suma += (1.0 * y[m].first);
cajas[0][size[0]] = y[m].second;
size[0]++;
}
}
printf("%.1lf\n", suma);
for (int i = 0; i < k; i++) {
printf("%d", size[i]);
for (int m = 0; m < size[i]; m++) printf(" %d", cajas[i][m]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct node {
double p;
int id, k;
} cart[1010];
int cmp(node a, node b) {
if (a.k != b.k) return a.k < b.k;
return a.p > b.p;
}
vector<int> vec[1010];
int main() {
int i, j, cnt;
double minn, tot, tt, ans;
while (scanf("%d%d", &n, &m) != EOF) {
cnt = 0;
minn = 1000000000.0;
tot = 0.0;
tt = 0.0;
for (i = 0; i < n; i++) {
scanf("%lf%d", &cart[i].p, &cart[i].k);
cart[i].id = i;
if (cart[i].k == 1)
cnt++, tt += cart[i].p;
else
tot += cart[i].p;
minn = cart[i].p > minn ? minn : cart[i].p;
}
sort(cart, cart + n, cmp);
for (i = 0; i < n; i++) vec[i].clear();
if (cnt < m) {
for (i = 0; i < m - 1; i++) {
vec[i].push_back(cart[i].id);
}
for (; i < n; i++) {
vec[m - 1].push_back(cart[i].id);
}
ans = (tt / 2) + tot;
} else {
double tmp = 0, ttmp = 0;
for (i = 0; i < m - 1; i++) {
vec[i].push_back(cart[i].id), tmp += cart[i].p;
}
for (; i < n; i++) {
vec[m - 1].push_back(cart[i].id), ttmp += cart[i].p;
}
ans = (tmp + minn) / 2 + (ttmp - minn);
}
printf("%.01lf\n", ans);
for (i = 0; i < m; i++) {
printf("%d", vec[i].size());
for (j = 0; j < vec[i].size(); j++) {
printf(" %d", vec[i][j] + 1);
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tov {
int id, c, t;
};
bool comp(tov a, tov b) {
if (a.c > b.c) return true;
return false;
}
tov a[1010];
int b[1010];
long long pr = 0;
int main() {
int n, k;
cin >> n >> k;
int aa = 0;
for (int i = 0; i < n; i++) {
cin >> a[i].c >> a[i].t;
if (a[i].t == 1) aa++;
a[i].id = i;
b[i] = -1;
pr += a[i].c * 2;
}
sort(a, &a[n], comp);
int p = 1;
if (k > 1) {
for (int i = 0; i < n; i++) {
if (a[i].t == 1) {
pr -= a[i].c;
b[i] = p;
p++;
if (p >= k) break;
}
}
}
if (aa >= k) pr -= a[n - 1].c;
if (p < k) {
for (int i = 0; i < n; i++) {
if (b[i] == -1) {
b[i] = p;
p++;
if (p >= k) break;
}
}
}
p--;
long long pr1 = pr / 2;
cout << pr1;
if (pr1 * 2 < pr) {
cout << '.' << 5;
} else {
cout << '.' << 0;
}
cout << endl;
cout << n - p;
for (int i = 0; i < n; i++) {
if (b[i] == -1) {
cout << " " << a[i].id + 1;
}
}
cout << endl;
for (int i = 0; i < n; i++) {
if (b[i] != -1) {
cout << 1 << " " << a[i].id + 1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
int N, K;
pair<int, int> A[MAXN], B[MAXN];
vector<pair<int, int> > p[MAXN];
void calc() {
double ans = 0.0;
for (int i = 0; i < K; ++i) {
int c = 1000000009;
for (int j = 0; j < p[i].size(); ++j) {
ans += p[i][j].first;
if (p[i][j].first < c) {
c = p[i][j].first;
}
}
if (p[i][0].second < 0) {
ans -= c / 2.0;
}
}
printf("%.1f\n", ans);
}
int main() {
cin >> N >> K;
{
int an = 0, bn = 0;
for (int i = 0; i < N; ++i) {
int c, t;
cin >> c >> t;
if (t == 1)
A[an++] = make_pair(c, -i - 1);
else
B[bn++] = make_pair(c, i + 1);
}
sort(A, A + an);
reverse(A, A + an);
sort(B, B + bn);
reverse(B, B + bn);
for (int i = 0; i < K && i < an; i++) {
p[i].push_back(A[i]);
}
for (int i = K; i < an; ++i) {
p[K - 1].push_back(A[i]);
}
if (an >= K) {
for (int i = 0; i < bn; ++i) {
p[K - 1].push_back(B[i]);
}
} else {
for (int i = 0; i < bn; ++i) {
p[K - 1 - i % (K - an)].push_back(B[i]);
}
}
calc();
for (int i = 0; i < K; ++i) {
cout << p[i].size();
for (int j = 0; j < p[i].size(); ++j) {
cout << " " << abs(p[i][j].second);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 51, inf = 0x7fffffff;
struct Item {
int cost, type, id;
inline bool operator<(const Item &rhs) const { return this->cost > rhs.cost; }
};
Item chair[MAXN], other[MAXN];
int cnt, ccnt, totc, toto, x, y, minn = inf;
double res;
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
template <class T>
inline T Min(T x, T y) {
return x < y ? x : y;
}
int main() {
cnt = read(), ccnt = read();
for (register int i = 0; i < cnt; i++) {
x = read(), y = read();
y == 1 ? chair[++totc] = (Item){x, y, i} : other[++toto] = (Item){x, y, i};
}
sort(chair + 1, chair + totc + 1);
if (totc > ccnt - 1) {
for (register int i = 1; i < ccnt; i++) {
res += 1.0 * chair[i].cost / 2;
}
for (register int i = 1; i <= toto; i++) {
res += other[i].cost, minn = Min(minn, other[i].cost);
}
for (register int i = ccnt; i <= totc; i++) {
res += chair[i].cost, minn = Min(minn, chair[i].cost);
}
res -= 1.0 * minn / 2;
} else {
for (register int i = 1; i <= totc; i++) {
res += 1.0 * chair[i].cost / 2;
}
for (register int i = 1; i <= toto; i++) {
res += other[i].cost;
}
}
printf("%.1lf\n", res);
if (totc >= ccnt - 1) {
for (register int i = 1; i < ccnt; i++) {
printf("1 %d\n", chair[i].id + 1);
}
printf("%d ", totc + toto - ccnt + 1);
for (register int i = ccnt; i <= totc; i++) {
printf("%d ", chair[i].id + 1);
}
for (register int i = 1; i <= toto; i++) {
printf("%d ", other[i].id + 1);
}
} else {
for (register int i = 1; i <= totc; i++) {
printf("1 %d\n", chair[i].id + 1);
}
for (register int i = 1; i <= ccnt - totc - 1; i++) {
printf("1 %d\n", other[i].id + 1);
}
printf("%d ", toto - ccnt + totc + 1);
for (register int i = ccnt - totc; i <= toto; i++) {
printf("%d ", other[i].id + 1);
}
}
puts("");
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
struct P {
int pos, p;
P(int _pos, int _p) {
pos = _pos;
p = _p;
}
bool operator<(const P& b) const {
if (p != b.p) return p > b.p;
return pos < b.pos;
}
};
vector<P> K, T;
vector<int> res[1009];
long long sum[1009];
int minv[1009];
int main() {
memset(minv, 63, sizeof(minv));
int n, k, i1, i2, i;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d %d", &i1, &i2);
if (i2 == 1)
T.push_back(P(i + 1, i1));
else
K.push_back(P(i + 1, i1));
}
sort(K.begin(), K.end());
sort(T.begin(), T.end());
int f = T.size();
T.insert(T.end(), K.begin(), K.end());
int sz = T.size();
for (i = 0; i < k; i++) {
res[i].push_back(T[i].pos);
sum[i] += T[i].p;
minv[i] = min(minv[i], T[i].p);
}
for (; i < sz; i++) {
res[k - 1].push_back(T[i].pos);
sum[k - 1] += T[i].p;
minv[k - 1] = min(minv[k - 1], T[i].p);
}
double _sum = 0;
for (i = 0; i < k; i++) {
_sum += sum[i] - minv[i] * (i < f ? 0.5 : 0.0);
}
printf("%.1lf\n", _sum);
for (i = 0; i < k; i++) {
printf("%d", res[i].size());
for (int j = res[i].size() - 1; j >= 0; j--) printf(" %d", res[i][j]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
struct Node {
int n, v;
bool operator<(const Node& a) const { return v < a.v; }
};
long long sum;
double ans;
int l, m, v, t, n, k;
Node a[0X800], b[0X800];
int main() {
scanf("%d%d", &n, &k);
l = m = sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &v, &t);
sum += v;
if (t == 1) {
a[m].v = v;
a[m++].n = i + 1;
} else {
b[l].v = v;
b[l++].n = i + 1;
}
}
sort(a, a + m);
sort(b, b + l);
ans = 0;
if (m >= k) {
for (int i = 1; i < k; ++i) ans += a[m - k + i].v / 2.0;
if (l > 0)
ans += min(b[0].v, a[0].v) / 2.0;
else
ans += a[0].v / 2.0;
ans = sum - ans;
printf("%.1f\n", ans);
printf("%d", n - (k - 1));
for (int i = 0; i < l; ++i) printf(" %d", b[i].n);
for (int i = 0; i <= m - k; ++i) printf(" %d", a[i].n);
printf("\n");
for (int i = 1; i < k; ++i) printf("1 %d\n", a[m - k + i].n);
} else {
for (int i = 0; i < m; ++i) ans += a[i].v / 2.0;
ans = sum - ans;
printf("%.1f\n", ans);
for (int i = 0; i < m; ++i) printf("1 %d\n", a[i].n);
for (int i = m; i < k - 1; ++i) printf("1 %d\n", b[i - m].n);
printf("%d", n - k + 1);
for (int i = k - m - 1; i < l; ++i) printf(" %d", b[i].n);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> tt[1005], kk[1005];
int n1, n2, top;
vector<int> vv[1005];
int main() {
int k, i, j, n, a, tmp;
long long ans = 0, sum = 0;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d %d", &a, &tmp);
if (tmp == 1)
tt[n1++] = make_pair(a, i + 1);
else
kk[n2++] = make_pair(a, i + 1);
sum += (long long)a;
}
sort(tt, tt + n1);
sort(kk, kk + n2);
if (n1 < k) {
for (i = n1 - 1; i >= 0; i--) {
vv[top++].push_back(tt[i].second);
ans += (long long)tt[i].first;
}
for (i = 0; top < k; i++) vv[top++].push_back(kk[i].second);
for (; i < n2; i++) vv[top - 1].push_back(kk[i].second);
} else {
for (i = n1 - 1; top < k - 1; i--) {
vv[top++].push_back(tt[i].second);
ans += (long long)tt[i].first;
}
if (n1 > 0 && n2 > 0)
ans += (long long)min(tt[0].first, kk[0].first);
else if (n1 > 0)
ans += (long long)tt[0].first;
else
ans += (long long)kk[0].first;
for (; i >= 0; i--) vv[top].push_back(tt[i].second);
for (i = 0; i < n2; i++) vv[top].push_back(kk[i].second);
}
printf("%I64d.", sum - (ans + 1) / 2);
if (ans & 1)
printf("5");
else
printf("0");
putchar('\n');
for (i = 0; i < k; i++) {
printf("%d ", (int)vv[i].size());
for (j = 0; j < (int)vv[i].size(); j++) printf("%d ", vv[i][j]);
putchar('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct itom {
unsigned long long int price;
int no;
};
bool cmp(itom a, itom b) { return a.price < b.price; }
int main() {
int n, k;
cin >> n >> k;
vector<itom> stool;
vector<itom> pencil;
for (int i = 0; i < n; i++) {
unsigned long long int a;
int b;
cin >> a >> b;
if (b == 1) {
itom c;
c.price = a * 10;
c.no = i;
stool.push_back(c);
} else {
itom c;
c.price = a * 10;
c.no = i;
pencil.push_back(c);
}
}
if (stool.size()) sort(stool.begin(), stool.end(), cmp);
vector<vector<itom>> ans;
ans.resize(k);
unsigned long long int total = 0;
int i = 0;
while (stool.size()) {
if (i < k - 1) {
ans[i].push_back(stool.back());
stool.pop_back();
total += ans[i].back().price / 2;
i++;
} else {
ans[i].push_back(stool.back());
stool.pop_back();
if (stool.size())
total += ans[i].back().price;
else
total += ans[i].back().price / 2;
}
}
if (ans[i].size() == 0)
while (pencil.size()) {
ans[i].push_back(pencil.back());
pencil.pop_back();
total += ans[i].back().price;
if (i < k - 1) i++;
}
else {
unsigned long long int mins = ans[i].back().price;
while (pencil.size()) {
total = total + mins / 2 + pencil.back().price;
mins = min(pencil.back().price, mins);
total -= mins / 2;
ans[i].push_back(pencil.back());
pencil.pop_back();
}
}
if (total % 10)
cout << total / 10 << ".5" << endl;
else
cout << total / 10 << ".0" << endl;
for (int i = 0; i < k; i++) {
cout << ans[i].size() << " ";
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j].no + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct P {
int id, c, t;
void read(int _id) {
id = _id;
scanf("%d%d", &c, &t);
}
} p[1010];
bool cp(P a, P b) { return a.c > b.c; }
vector<P> sol[1010];
int main() {
int n, k;
long long ans = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) p[i].read(i + 1);
sort(p, p + n, cp);
int cnt = 0;
for (int i = 0; i < n; i++)
if (p[i].t == 1) {
sol[min(cnt, k - 1)].push_back(p[i]);
cnt++;
}
for (int i = 0; i < n; i++)
if (p[i].t == 2) {
sol[min(cnt, k - 1)].push_back(p[i]);
cnt++;
}
for (int i = 0; i < k; i++) {
int sml = 1234567890, flg = 0;
for (__typeof((sol[i]).begin()) it = (sol[i]).begin(); it != (sol[i]).end();
it++) {
ans += (2 * it->c);
sml = min(sml, it->c);
if (it->t == 1) flg = 1;
}
if (flg) ans -= sml;
}
printf("%I64d.%d\n", ans / 2, ans % 2 == 0 ? 0 : 5);
for (int i = 0; i < k; i++) {
printf("%d", ((int)(sol[i]).size()));
for (__typeof((sol[i]).begin()) it = (sol[i]).begin(); it != (sol[i]).end();
it++)
printf(" %d", it->id);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> s, p;
long long t = 0;
multimap<long long, long long> q;
long long m = 99999999999999;
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
m = min(m, l);
if (r == 1) {
s.push_back(l);
q.insert({l, i});
if (q.size() == k) q.erase(q.begin());
} else
p.push_back(l);
t += l;
}
sort(s.begin(), s.end(), greater<long long>());
long long sub = 0;
for (long long i = 0; i <= min((long long)s.size() - 1, k - 2); i++)
sub += s[i];
if (s.size() >= k) sub += m;
t -= sub;
t += sub / 2;
if (sub % 2)
cout << t << ".5"
<< "\n";
else
cout << t << ".0"
<< "\n";
set<long long> q1, q2;
auto it = q.begin();
while (it != q.end()) {
q1.insert(it->second);
it++;
}
for (long long i = 0; i < n; i++) {
if (q1.find(i) == q1.end()) q2.insert(i);
}
for (long long i = 0; i < k - 1; i++) {
if (q1.size() != 0) {
cout << 1 << " " << *q1.begin() + 1 << "\n";
q1.erase(q1.begin());
} else {
cout << 1 << " " << *q2.begin() + 1 << "\n";
q2.erase(q2.begin());
}
}
cout << q2.size() << " ";
while (q2.size()) {
cout << *q2.begin() + 1 << " ";
q2.erase(q2.begin());
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct ans {
int num, price;
} tmp[100005], d[10005];
int mk[10005];
vector<ans> res[10004];
bool cm(ans a, ans b) { return a.price > b.price; }
int main() {
int n, m;
int cnt, value, t;
int mn;
double solve;
int eva;
while (scanf("%d%d", &n, &m) == 2) {
memset(mk, 0, sizeof(mk));
solve = 0;
cnt = 0;
eva = 0;
mn = 1000000002;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &value, &t);
if (t == 1) {
tmp[cnt].num = i;
tmp[cnt].price = value;
cnt++;
} else {
d[eva].num = i;
d[eva].price = value;
eva++;
}
}
sort(tmp, tmp + cnt, cm);
int j = 0;
for (int i = 0; i < cnt; i++, j++) {
if (i < m) {
res[i].push_back(tmp[i]);
mk[i] = 1;
} else {
res[m - 1].push_back(tmp[i]);
}
}
if (j < m) {
int i = 0;
for (; i < eva && j < m; j++, i++) {
res[j].push_back(d[i]);
}
while (i < eva) {
res[m - 1].push_back(d[i]);
i++;
}
} else {
int i = 0;
while (i < eva) {
res[m - 1].push_back(d[i]);
i++;
}
}
solve = 0;
for (int i = 0; i < m; i++) {
int l = mn;
for (int k = 0; k < res[i].size(); k++) {
if (res[i][k].price < l) l = res[i][k].price;
solve += res[i][k].price * 1.0;
}
if (mk[i]) solve -= l * 1.0 / 2;
}
printf("%.1lf\n", solve);
for (int i = 0; i < m; i++) {
printf("%d ", res[i].size());
for (int k = 0; k < res[i].size(); k++) {
printf("%d ", res[i][k].num);
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct par {
int v, id;
par(int v = 0, int id = 0) : v(v), id(id) {}
} p[1010], s[1010];
bool cmp(par a, par b) { return a.v > b.v; }
int rs[1010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int qp = 0, qs = 0;
long long sum = 0;
int low = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
int x, t;
scanf("%d %d", &x, &t);
if (t == 1)
s[qs++] = par(x, i);
else
p[qp++] = par(x, i);
sum += x;
low = min(low, x);
}
sort(s, s + qs, cmp);
int dc = min(k - 1, qs);
double disc = 0;
memset(rs, -1, sizeof(rs));
for (int i = 0; i < min(k - 1, qs); i++) {
rs[s[i].id] = i;
disc += s[i].v / 2.0;
}
if (qs > k - 1) {
disc += low / 2.0;
for (int i = 0; i < n; i++)
if (rs[i] == -1) rs[i] = k - 1;
} else {
int cc = dc;
for (int i = 0; i < n; i++)
if (rs[i] == -1) {
rs[i] = cc++;
if (cc == k) cc = dc;
}
}
printf("%.1lf\n", sum - disc);
for (int i = 0; i < k; i++) {
int q = 0;
for (int j = 0; j < n; j++)
if (rs[j] == i) q++;
printf("%d", q);
for (int j = 0; j < n; j++)
if (rs[j] == i) printf(" %d", j + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DX[8] = {1, -1, 0, 0, 1, 1, -1, -1};
const int DY[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const int intmax = 0x7fffffff;
const int mod = 1000000007;
map<int, int> mp1, mp2;
vector<pair<int, int> > f1, f2, p[1005];
int n, nk;
int ans = 0;
int main() {
scanf("%d%d", &n, &nk);
long long ans = 0;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
if (b == 1) f1.push_back(make_pair(a, i));
if (b == 2) f2.push_back(make_pair(a, i));
ans += a;
}
sort(f1.begin(), f1.end(), greater<pair<int, int> >());
sort(f2.begin(), f2.end(), greater<pair<int, int> >());
long long des = 0;
if (f1.size() < nk) {
for (int i = 0; i < f1.size(); i++) {
p[i].push_back(f1[i]);
des += f1[i].first;
}
int j = 0;
for (int i = f1.size(); i < nk; i++, j++) p[i].push_back(f2[j]);
for (; j < f2.size(); j++) p[nk - 1].push_back(f2[j]);
} else {
for (int i = 0; i < nk; i++) {
p[i].push_back(f1[i]);
if (i != nk - 1) des += f1[i].first;
}
for (int i = nk; i < f1.size(); i++) p[nk - 1].push_back(f1[i]);
for (int i = 0; i < f2.size(); i++) p[nk - 1].push_back(f2[i]);
int minx = 1 << 30;
for (int i = 0; i < p[nk - 1].size(); i++)
minx = min(p[nk - 1][i].first, minx);
des += minx;
}
if (des & 1)
printf("%I64d.5\n", ans - 1 - des / 2);
else
printf("%I64d.0\n", ans - des / 2);
for (int i = 0; i < nk; i++) {
printf("%d", p[i].size());
for (int j = 0; j < p[i].size(); j++) printf(" %d", p[i][j].second + 1);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005;
long long n, k;
long long c[N], t[N];
vector<pair<long long, long long> > s, p;
double ans = 0;
bool vis[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> c[i] >> t[i];
if (t[i] == 1)
s.push_back({c[i], i});
else {
p.push_back({c[i], i});
ans += c[i];
}
}
sort(s.rbegin(), s.rend());
vector<long long> v;
long long printed = 0;
for (long long i = 0; i < s.size(); i++) {
if (i <= k - 2) {
ans += 0.5 * s[i].first;
vis[s[i].second] = 1;
} else
ans += s[i].first;
}
double mn = 1e9;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) mn = min(mn, 1.0 * c[i]);
}
if (s.size() >= k) ans -= 0.5 * mn;
cout << fixed << setprecision(1) << ans << "\n";
for (long long i = 0; i < s.size(); i++) {
if (i <= k - 2) {
printed++;
cout << 1 << " " << s[i].second << "\n";
}
}
vector<long long> rem;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) rem.push_back(i);
}
while (printed + 1 < k) {
cout << 1 << " " << rem.back() << "\n";
rem.pop_back();
printed++;
}
cout << rem.size() << " ";
for (auto &it : rem) cout << it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > a, b;
long long ans = 0;
int res = 1000000000;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
ans += x;
res = min(res, x);
if (y == 1)
a.push_back(make_pair(x, i));
else
b.push_back(make_pair(x, i));
}
ans *= 2;
sort((a).begin(), (a).end());
reverse((a).begin(), (a).end());
for (int i = 0; i < min(((int)a.size()), k - 1); ++i) ans -= a[i].first;
if (((int)a.size()) > k - 1) ans -= res;
cout << ans / 2;
if (ans % 2 == 1)
cout << ".5" << endl;
else
cout << ".0" << endl;
if (((int)a.size()) == k) {
for (int i = 0; i < k - 1; ++i)
cout << "1"
<< " " << a[i].second + 1 << endl;
cout << n - (k - 1) << " ";
cout << a[k - 1].second + 1 << " ";
for (int i = 0; i < ((int)b.size()); ++i) cout << b[i].second + 1 << " ";
cout << endl;
}
if (((int)a.size()) > k) {
for (int i = 0; i < k - 1; ++i)
cout << "1"
<< " " << a[i].second + 1 << endl;
cout << n - (k - 1) << " ";
for (int i = k - 1; i < ((int)a.size()); ++i)
cout << a[i].second + 1 << " ";
for (int i = 0; i < ((int)b.size()); ++i) cout << b[i].second + 1 << " ";
cout << endl;
}
if (((int)a.size()) < k) {
for (int i = 0; i < ((int)a.size()); ++i)
cout << "1"
<< " " << a[i].second + 1 << endl;
for (int i = 0; i < k - ((int)a.size()) - 1; ++i)
cout << "1"
<< " " << b[i].second + 1 << endl;
cout << n - (k - 1) << " ";
for (int i = k - ((int)a.size()) - 1; i < ((int)b.size()); ++i)
cout << b[i].second + 1 << " ";
cout << endl;
}
int x;
cin >> x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-10;
template <typename T, typename S>
vector<T>& operator<<(vector<T>& a, S b) {
a.push_back(b);
return a;
}
template <typename T>
void operator>>(vector<T>& a, int b) {
while (b--)
if (!a.empty()) a.pop_back();
}
bool isprime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long b_pow(long long x, long long n) {
return n ? b_pow(x * x, n / 2) * (n % 2 ? x : 1) : 1ll;
}
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int dis[10000];
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > a, b;
for (int i = 0; i < n; i++) {
int v, t;
cin >> v >> t;
if (t == 1) a.push_back(make_pair(v, i)), dis[i] = true;
if (t == 2) b.push_back(make_pair(v, i));
}
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
vector<pair<int, int> > x[1001];
for (int i = 0; i < a.size(); i++) {
x[min(i, k - 1)].push_back(a[i]);
}
if (a.size() < k) {
int h = 0;
for (int i = a.size(); i < k; i++) x[i].push_back(b[h++]);
for (int i = h; i < b.size(); i++) x[k - 1].push_back(b[i]);
} else {
int h = 0;
for (int i = h; i < b.size(); i++) x[k - 1].push_back(b[i]);
}
double calc = 0;
for (int i = 0; i < k; i++) {
bool flag = false;
if (dis[x[i][0].second]) flag = true;
int mini = INT_MAX;
for (int j = 0; j < x[i].size(); j++)
calc += x[i][j].first, mini = min(x[i][j].first, mini);
if (flag) {
calc -= mini;
calc += mini / 2.0;
}
}
printf("%.1lf\n", calc);
for (int i = 0; i < k; i++) {
cout << x[i].size();
for (int j = 0; j < x[i].size(); j++) cout << " " << x[i][j].second + 1;
cout << endl;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.