text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct bb {
int x, o, va, l;
int a[1111], b[1111];
} box[1111];
struct pi {
int x, o;
} a[1111], b[1111];
bool cp1(pi x, pi y) { return x.x > y.x; }
bool cp2(pi x, pi y) { return x.x < y.x; }
int main() {
int n, k;
scanf("%d %d", &n, &k);
int x, y, e = 0, h = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
if (y == 2) {
a[e].x = x;
a[e++].o = i + 1;
} else {
b[h].x = x;
b[h++].o = i + 1;
}
}
sort(b, b + h, cp1);
if (h > k) {
for (int i = 0; i < k; i++) {
box[i].a[box[i].l] = b[i].x;
box[i].b[box[i].l++] = b[i].o;
box[i].va = b[i].x;
}
for (int i = k; i < h; i++) {
a[e].x = b[i].x;
a[e++].o = b[i].o;
}
} else {
for (int i = 0, j = 0; i < k, j < h; i++, j++) {
box[i].a[box[i].l] = b[j].x;
box[i].b[box[i].l++] = b[j].o;
box[i].va = b[j].x;
}
}
sort(a, a + e, cp2);
int st = 0;
for (int i = k - 1; i >= 0; i--)
if (box[i].l == 0) {
box[i].a[box[i].l] = a[st].x;
box[i].b[box[i].l++] = a[st++].o;
box[i].va = -1;
}
for (int j = st; j < e; j++) {
box[k - 1].a[box[k - 1].l] = a[j].x;
box[k - 1].b[box[k - 1].l++] = a[j].o;
if (box[k - 1].va != -1) {
if (box[k - 1].va > a[j].x) box[k - 1].va = a[j].x;
}
}
double ans = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < box[i].l; j++) {
ans += (double)box[i].a[j];
}
if (box[i].va != -1) ans -= 0.5 * box[i].va;
}
printf("%.1f\n", ans);
for (int i = 0; i < k; i++) {
printf("%d ", box[i].l);
for (int j = 0; j < box[i].l; j++) {
printf("%d ", box[i].b[j]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
inline int read() {
int v = 0, c = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') c = -1;
ch = getchar();
}
while (isdigit(ch)) {
v = v * 10 + ch - 48;
ch = getchar();
}
return v * c;
}
struct node {
int ti;
int ci;
int id;
} a[N];
bool book[N], used[N];
vector<int> G[N];
int n, k;
double ans;
inline bool cmp(node x, node y) { return x.ci > y.ci; }
inline bool cmpp(node x, node y) { return x.id < y.id; }
int main() {
int sum = 0, cnt;
n = read(), k = read();
for (int i = 1; i <= n; ++i) {
a[i].ci = read(), a[i].ti = read(), sum += (a[i].ti == 1);
a[i].id = i;
}
sort(a + 1, a + n + 1, cmp);
int need = max(0, k - sum), now = 1;
for (int i = 1; i <= n; ++i) {
if (a[i].ti == 1) {
book[now] = 1;
if (now < k)
G[now++].push_back(a[i].id);
else
G[now].push_back(a[i].id);
} else {
if (need && now < k)
G[now++].push_back(a[i].id), need--;
else
G[now].push_back(a[i].id);
}
}
sort(a + 1, a + n + 1, cmpp);
for (int i = 1; i <= now; ++i) {
for (int j = 0; j < (int)G[i].size(); ++j) {
if (j == G[i].size() - 1 && book[i])
ans += (double)a[G[i][j]].ci * 0.5;
else
ans += a[G[i][j]].ci;
}
}
printf("%.1lf\n", ans);
for (int i = 1; i <= now; ++i) {
printf("%d ", G[i].size());
for (int j = 0; j < (int)G[i].size(); ++j) printf("%d ", G[i][j]);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1024;
struct Product {
int cost, type;
int index;
bool operator<(const Product& other) const { return cost < other.cost; }
};
int n, k;
Product v[MAX_N];
vector<Product> sol[MAX_N];
bool vis[MAX_N];
void read() {
assert(scanf("%d %d", &n, &k) == 2);
for (int i = 1; i <= n; ++i) {
assert(scanf("%d %d", &v[i].cost, &v[i].type) == 2);
v[i].index = i;
}
}
double get_cost(vector<Product>& v) {
if (v.empty()) return 0.0;
bool has_stool = false;
double min_val = v[0].cost;
double total = 0.0;
for (size_t i = 0; i < v.size(); ++i) {
has_stool |= v[i].type == 1;
min_val = min(min_val, (double)v[i].cost);
total += v[i].cost;
}
if (has_stool) total -= min_val / 2;
return total;
}
void solve() {
sort(v + 1, v + n + 1);
int cart = 1;
for (int i = n; i; --i)
if (cart < k && v[i].type == 1) {
vis[i] = true;
sol[cart++].push_back(v[i]);
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
sol[cart].push_back(v[i]);
if (cart < k) ++cart;
}
double ans = 0;
for (int i = 1; i <= k; ++i) ans += get_cost(sol[i]);
printf("%.1lf\n", ans);
for (int i = 1; i <= k; ++i) {
printf("%d", sol[i].size());
for (size_t j = 0; j < sol[i].size(); ++j) printf(" %d", sol[i][j].index);
printf("\n");
}
}
int main() {
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e+9 + 7ll;
const long long linf = (long long)1e+18 + 7ll;
const long double eps = (long double)1e-9;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
static char buff[(int)2e6 + 17];
const int maxn = (int)2e5 + 17;
struct item {
int c, t, i;
item() {}
};
bool operator<(item a, item b) {
return a.c < b.c || (a.c == b.c && a.t < b.t);
}
int n, k;
item p[maxn];
vector<int> ans[maxn];
bool read() {
if (scanf("%d %d", &n, &k) != 2) return false;
for (int i = 0; i < n; ++i) scanf("%d %d", &p[i].c, &p[i].t), p[i].i = i;
return true;
}
void solve() {
sort(p, p + n);
int j = 0;
for (int i = n - 1; i >= 0; --i) {
ans[j].push_back(i);
if (p[i].t == 1 && j < k - 1) ++j;
}
for (int i = 0; i < k; ++i) reverse(ans[i].begin(), ans[i].end());
for (int i = 0; i < k; ++i)
if (ans[i].empty()) {
for (int j = 0; j < k; ++j)
if (((int)(ans[j].size())) > 1) {
ans[i].push_back(ans[j].back());
ans[j].pop_back();
break;
}
}
long long ansi = 0;
for (int i = 0; i < k; ++i) {
bool good = false;
for (int j = 0; j < ((int)(ans[i].size())); ++j)
ansi += 2ll * p[ans[i][j]].c, good |= int(p[ans[i][j]].t == 1);
if (good) ansi -= p[ans[i][0]].c;
}
printf("%.1f\n", (double)ansi / 2);
for (int i = 0; i < k; ++i) {
printf("%d ", ((int)(ans[i].size())));
for (auto j : ans[i]) printf("%d ", p[j].i + 1);
printf("\n");
}
}
int main() {
while (read()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Itm {
int val;
int id;
Itm(int v = 0, int i = 0) : val(v), id(i) {}
friend bool operator<(const Itm& a, const Itm& b) { return a.val > b.val; }
} I[1015], S[1015];
vector<int> car[1015];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int Ic = 0, Sc = 0;
for (int i = 0; i < n; i++) {
int v, k;
scanf("%d%d", &v, &k);
if (k == 1) {
S[Sc++] = Itm(v, i + 1);
} else if (k == 2) {
I[Ic++] = Itm(v, i + 1);
}
}
sort(S, S + Sc);
for (int i = 0; i < 1005; i++) car[i].clear();
int TT = 0, tIc = 0;
double ans = 0;
for (; TT < Sc; TT++) {
if (TT >= m - 1) break;
car[TT].push_back(S[TT].id);
ans += S[TT].val * 0.5;
}
if (TT == Sc) {
for (int i = TT; i < m - 1; tIc++, i++) {
car[i].push_back(I[tIc].id);
ans += I[tIc].val;
}
for (; tIc < Ic; tIc++) {
car[m - 1].push_back(I[tIc].id);
ans += I[tIc].val;
}
} else {
int mmin = 0x7fffffff;
for (; TT < Sc; TT++) {
if (mmin > S[TT].val) mmin = S[TT].val;
car[m - 1].push_back(S[TT].id);
ans += S[TT].val;
}
for (; tIc < Ic; tIc++) {
if (mmin > I[tIc].val) mmin = I[tIc].val;
car[m - 1].push_back(I[tIc].id);
ans += I[tIc].val;
}
ans -= mmin * 0.5;
}
printf("%.1f\n", ans);
for (int i = 0; i < m; i++) {
printf("%d", car[i].size());
for (int j = 0; j < car[i].size(); j++) {
printf(" %d", car[i][j]);
}
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<long long, int> > chairs;
vector<pair<long long, int> > pencils;
long long sum2 = 0;
for (int i = 0; i < n; ++i) {
long long c, t;
cin >> c >> t;
sum2 += 2 * c;
vector<pair<long long, int> >& vec = (t == 1 ? chairs : pencils);
vec.push_back(make_pair(c, i + 1));
}
sort((chairs).begin(), (chairs).end());
sort((pencils).begin(), (pencils).end());
vector<vector<int> > res(k);
for (int i = 0; i < k; ++i) {
long long mmin = 1000000001;
if (chairs.empty()) {
mmin = 0;
res[i].push_back(pencils.back().second);
pencils.pop_back();
} else {
res[i].push_back(chairs.back().second);
mmin = chairs.back().first;
chairs.pop_back();
}
if (i == k - 1) {
while (!chairs.empty()) {
res[i].push_back(chairs.back().second);
mmin = min(mmin, chairs.back().first);
chairs.pop_back();
}
while (!pencils.empty()) {
res[i].push_back(pencils.back().second);
mmin = min(mmin, pencils.back().first);
pencils.pop_back();
}
}
sum2 -= mmin;
}
sum2 *= 5;
cout << (sum2 / 10) << "." << (sum2 % 10) << 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;
double pi = asin(1.0) * 2;
struct point {
double x, y;
point() {}
point(double _x, double _y) {
x = _x;
y = _y;
}
inline void read() { scanf("%lf%lf", &x, &y); }
inline void show() { printf("%lf %lf\n", x, y); }
inline double dis() { return x * x + y * y; }
inline double dist() { return sqrt(x * x + y * y); }
};
inline point operator+(const point &a, const point &b) {
return point(a.x + b.x, a.y + b.y);
}
inline point operator-(const point &a, const point &b) {
return point(a.x - b.x, a.y - b.y);
}
inline point operator*(const point &a, const double &b) {
return point(a.x * b, a.y * b);
}
inline point operator/(const point &a, const double &b) {
return point(a.x / b, a.y / b);
}
inline double det(const point &a, const point &b) {
return a.x * b.y - a.y * b.x;
}
inline double dot(const point &a, const point &b) {
return a.x * b.x + a.y * b.y;
}
vector<pair<int, int> > a, b;
vector<vector<pair<int, int> > > ans;
long long sum;
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int q, w;
scanf("%d%d", &q, &w);
if (w == 1)
a.push_back(make_pair(q, i + 1));
else
b.push_back(make_pair(q, i + 1));
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sum = 0;
ans.clear();
for (int i = a.size() - 1, j = b.size() - 1, z = k; z > 0; z--) {
vector<pair<int, int> > t;
if (i >= 0)
t.push_back(a[i--]);
else
t.push_back(b[j--]);
if (z == 1) {
for (; i >= 0; i--) t.push_back(a[i]);
for (; j >= 0; j--) t.push_back(b[j]);
}
ans.push_back(t);
}
for (int i = 0; i < k; i++) {
int mi = 2000000000;
for (int z = 0; z < ans[i].size(); z++) {
mi = min(mi, ans[i][z].first);
sum += ans[i][z].first * 2;
}
if (i < a.size()) sum -= mi;
}
printf("%I64d.", sum / 2);
if (sum % 2 == 1)
puts("5");
else
puts("0");
for (int i = 0; i < k; i++) {
printf("%d", ans[i].size());
for (int z = 0; z < ans[i].size(); z++) printf(" %d", ans[i][z].second);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > c[2];
long long sum[2];
double ans = 0.;
int main() {
int n, k, t, a;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a >> t;
c[t - 1].push_back(pair<int, int>(a, i + 1));
sum[t - 1] += a;
}
sort(c[0].begin(), c[0].end());
while (c[0].size() > k) {
c[1].push_back(c[0][0]);
sum[0] -= c[0][0].first;
sum[1] += c[0][0].first;
c[0].erase(c[0].begin());
}
sort(c[1].begin(), c[1].end());
ans = sum[0] / 2. + sum[1] * 1.;
if (c[0].size() == k) {
if (c[1].size() && c[1][0].first < c[0][0].first)
ans += (c[1][0].first + c[0][0].first) / 2. + (-c[1][0].first) * 1.;
printf("%.1lf\n", ans);
for (int i = 0; i < k - 1; ++i)
cout << 1 << " " << c[0][k - i - 1].second << endl;
cout << c[1].size() + 1 << " " << c[0][0].second;
for (int i = 0; i < c[1].size(); ++i) cout << " " << c[1][i].second;
cout << endl;
} else {
printf("%.1lf\n", ans);
int m = c[0].size();
for (int i = 0; i < m; ++i)
cout << 1 << " " << c[0][m - i - 1].second << endl;
for (int i = m; i < k - 1; ++i)
cout << 1 << " " << c[1][i - m].second << endl;
cout << c[1].size() - (k - 1 - m);
for (int i = k - 1 - m; i < c[1].size(); ++i) cout << " " << c[1][i].second;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
int c[110000], tp[110000];
bool cmp(int a, int b) { return c[a] < c[b]; }
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > a, b;
for (int i = 0; i < (int)(n); i++) {
scanf("%d%d", &c[i], &tp[i]);
if (tp[i] == 1)
a.push_back(make_pair(c[i], i));
else
b.push_back(make_pair(c[i], i));
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
vector<vector<int> > ans;
if (k > (int)a.size()) {
for (int i = 0; i < (int)(a.size()); i++)
ans.push_back(vector<int>(1, a[i].second));
for (int i = 0; i < (int)(b.size()); i++)
if ((int)ans.size() < k)
ans.push_back(vector<int>(1, b[i].second));
else
ans.back().push_back(b[i].second);
} else {
while (k > 1 && a.size()) {
k--;
vector<int> cur;
cur.push_back(a.back().second);
while (b.size() && b.back().first >= a.back().first) {
cur.push_back(b.back().second);
b.pop_back();
}
ans.push_back(cur);
a.pop_back();
}
if (k == 1) {
vector<int> cur;
for (int i = 0; i < (int)(a.size()); i++) cur.push_back(a[i].second);
for (int i = 0; i < (int)(b.size()); i++) cur.push_back(b[i].second);
ans.push_back(cur);
} else
throw;
}
long long sum = 0;
for (int i = 0; i < (int)(ans.size()); i++) {
sort(ans[i].begin(), ans[i].end(), cmp);
for (int j = 0; j < (int)(ans[i].size()); j++) sum += 2 * c[ans[i][j]];
bool fnd = false;
for (int j = 0; j < (int)(ans[i].size()); j++)
if (tp[ans[i][j]] == 1) fnd = true;
if (fnd) sum -= c[ans[i][0]];
}
cout << sum / 2 << '.';
if (sum % 2)
cout << 5 << endl;
else
cout << 0 << endl;
for (int i = 0; i < (int)(ans.size()); i++) {
printf("%d", ans[i].size());
for (int j = 0; j < (int)(ans[i].size()); j++) printf(" %d", ans[i][j] + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tab {
int c, pl;
};
int ls(tab a, tab b) { return a.c > b.c; }
int main() {
int n, k;
cin >> n >> k;
vector<int> c(n), t(n);
vector<tab> tabs;
long long res = 0;
long long mn = 1000000000;
for (int i = 0; i < n; i++) {
cin >> c[i] >> t[i];
res += c[i];
mn = min(mn, (long long)c[i]);
if (t[i] == 1) {
tab nw;
nw.c = c[i];
nw.pl = i;
tabs.push_back(nw);
}
}
if (tabs.size() < k) mn = 0;
sort(tabs.begin(), tabs.end(), ls);
vector<bool> used(n, 0);
for (int i = 0; i < min(k - 1, (int)tabs.size()); i++) {
mn += tabs[i].c;
}
res -= mn / 2 + mn % 2;
cout << res;
if (mn % 2)
cout << ".5";
else
cout << ".0";
cout << endl;
for (int i = 0; i < min(k - 1, (int)tabs.size()); i++) {
cout << "1 " << tabs[i].pl + 1 << endl;
used[tabs[i].pl] = 1;
}
for (int i = 0; i < max(0, k - 1 - (int)tabs.size()); i++) {
int j = 0;
for (; used[j]; j++)
;
used[j] = 1;
cout << "1 " << j + 1 << endl;
}
cout << n - k + 1;
for (int i = 0; i < n; i++)
if (!used[i]) cout << " " << i + 1;
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct hh {
int num;
int c;
};
bool cmp(const hh p, const hh q) { return p.c < q.c; }
int main() {
int n, k;
scanf("%d%d", &n, &k);
hh a[1010], b[1010];
int i;
int p = 0, q = 0;
vector<int> ss[1010];
for (i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (y == 1) {
a[p].num = i + 1;
a[p++].c = x;
} else {
b[q].num = i + 1;
b[q++].c = x;
}
}
sort(a, a + p, cmp);
sort(b, b + q, cmp);
double ans = 0;
if (p >= k) {
for (i = 1; i < k; ++i) {
ans += a[p - i].c * 1.0 / 2;
ss[i].push_back(a[p - i].num);
}
if (q > 0) {
if (a[0].c > b[0].c) {
ans += b[0].c * 1.0 / 2;
ans += a[0].c;
} else {
ans += a[0].c * 1.0 / 2;
ans += b[0].c;
}
ss[k].push_back(b[0].num);
} else
ans += a[0].c * 1.0 / 2;
ss[k].push_back(a[0].num);
for (i = 1; i < q; ++i) {
ss[k].push_back(b[i].num);
ans += b[i].c;
}
for (i = p - k; i > 0; --i) {
ss[k].push_back(a[i].num);
ans += a[i].c;
}
} else {
for (i = 1; i <= p; ++i) {
ss[i].push_back(a[i - 1].num);
ans += a[i - 1].c * 1.0 / 2;
}
int e = 0;
for (i = p + 1; i <= k; ++i) {
ss[i].push_back(b[e].num);
ans += b[e++].c;
}
for (i = e; i < q; ++i) {
ss[k].push_back(b[i].num);
ans += b[i].c;
}
}
printf("%.1f\n", ans);
int j;
for (i = 1; i <= k; ++i) {
printf("%d", ss[i].size());
for (j = 0; j < ss[i].size(); ++j) printf(" %d", ss[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
double p;
int t;
int id;
};
bool cmp(Node a, Node b) { return a.p > b.p; }
int main() {
int i, j, k, N, M, l, m, K;
cin >> N >> K;
vector<Node> V(N);
vector<Node> P;
vector<Node> S;
vector<int> car[K + 1];
long long t1, t2;
for (i = 0; i < N; i++) {
cin >> V[i].p >> V[i].t;
V[i].id = i + 1;
if (V[i].t == 1)
S.push_back(V[i]);
else
P.push_back(V[i]);
}
sort(S.begin(), S.end(), cmp);
sort(P.begin(), P.end(), cmp);
for (i = 0; i < S.size() && i < K; i++) {
car[i].push_back(S[i].id);
}
for (j = i; j < S.size(); j++) {
car[K - 1].push_back(S[j].id);
}
for (j = 0; j < P.size(); j++) car[K - 1].push_back(P[j].id);
double ans = 0.0;
for (i = 0; i < K; i++) {
double MIN = 1000000000;
for (j = 0; j < car[i].size(); j++) {
ans += V[car[i][j] - 1].p;
MIN = min(MIN, V[car[i][j] - 1].p);
}
if (i < S.size()) ans -= MIN / 2.0;
}
printf("%.1lf\n", ans);
for (i = 0; i < K; i++) {
if ((int)car[i].size() == 0) {
car[i].push_back(car[K - 1].back());
car[K - 1].pop_back();
}
cout << car[i].size();
for (j = 0; j < car[i].size(); j++) {
cout << " " << V[car[i][j] - 1].id;
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int c;
int t;
int no;
};
node a[2000];
int cmp(node a, node b) {
if (a.t > b.t) {
return 0;
}
if (a.t < b.t) {
return 1;
}
return a.c > b.c;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].c, &a[i].t);
a[i].no = i + 1;
sum += a[i].c;
}
sort(a, a + n, cmp);
sum *= 2;
int j = 0;
for (j = 0; j < k - 1; j++) {
if (a[j].t == 2) {
break;
}
sum -= a[j].c;
}
if (a[j].t == 1) {
while (j < n && a[j].t == 1) {
j++;
}
sum -= ((a[j - 1].c < a[n - 1].c ? a[j - 1].c : a[n - 1].c));
}
printf("%.1lf\n", (double)(sum / 2.0));
for (int i = 0; i < k - 1; i++) {
printf("1 %d\n", a[i].no);
}
printf("%d", n - k + 1);
for (int i = k - 1; i < n; i++) {
printf(" %d", a[i].no);
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int u[1010];
int c[1010];
int t[1010];
vector<int> v[1010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<pair<int, int> > ss;
vector<pair<int, int> > is;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> t[i];
c[i] *= 2;
is.push_back({c[i], i});
if (t[i] == 1) {
ss.push_back({c[i], i});
}
}
sort(is.begin(), is.end());
sort(ss.begin(), ss.end());
int i2 = 0;
for (int i = ss.size() - 1; i >= 0; i--) {
if (u[ss[i].second] == 0) {
v[i2].push_back(ss[i].second);
u[ss[i].second] = 1;
if (i2 < k - 1) i2++;
}
}
for (int i = 0; i < (int)is.size(); i++) {
if (u[is[i].second] == 0) {
v[i2].push_back(is[i].second);
u[is[i].second] = 1;
if (i2 < k - 1) i2++;
}
}
long long vv = 0;
for (int i = 0; i < k; i++) {
long long p = 0;
int hs = 0;
long long mp = 2e9 + 10;
for (int ii = 0; ii < (int)v[i].size(); ii++) {
p += (long long)c[v[i][ii]];
if (t[v[i][ii]] == 1) {
hs = 1;
}
mp = min(mp, (long long)c[v[i][ii]]);
}
vv += p;
if (hs) vv -= mp / 2ll;
}
cout << fixed << setprecision(1) << (double)vv / (double)2 << endl;
for (int i = 0; i < k; i++) {
cout << v[i].size() << " ";
for (int a : v[i]) {
cout << a << " ";
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200 * 1000 + 9;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
void HakunaMatata() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> a, b;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
if (y == 1)
a.emplace_back(x, i + 1);
else
b.emplace_back(x, i + 1);
}
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
double ans = 0.0;
vector<long long> idx(k);
vector<long long> kk;
if ((long long)a.size() < k) {
for (long long i = 0; i < (long long)a.size(); i++) {
ans = ans + (1.0 * a[i].first) / 2;
idx[i] = a[i].second;
}
long long j = 0;
for (long long i = (long long)a.size(); i < k - 1; i++) {
ans = ans + b[j].first;
idx[i] = b[j].second;
j++;
}
while (j < (long long)b.size()) {
ans = ans + b[j].first;
kk.push_back(b[j].second);
j++;
}
cout << setprecision(1) << fixed << ans << '\n';
for (long long i = 0; i < k - 1; i++) {
cout << 1 << " " << idx[i] << '\n';
}
cout << (long long)kk.size() << " ";
for (long long i = 0; i < (long long)kk.size(); i++) {
cout << kk[i] << " ";
}
cout << '\n';
} else if ((long long)a.size() == k) {
for (long long i = 0; i < (long long)a.size() - 1; i++) {
ans = ans + (1.0 * a[i].first) / 2;
idx[i] = a[i].second;
}
long long j = 0;
vector<long long> temp;
kk.push_back(a[k - 1].second);
temp.push_back(a[k - 1].first);
ans = ans + a[k - 1].first;
while (j < (long long)b.size()) {
ans = ans + b[j].first;
kk.push_back(b[j].second);
temp.push_back(b[j].first);
j++;
}
if (temp.size() > 0) {
sort(temp.begin(), temp.end());
ans = ans - temp[0];
ans = ans + (1.0 * temp[0]) / 2;
}
cout << setprecision(1) << fixed << ans << '\n';
for (long long i = 0; i < k - 1; i++) {
cout << 1 << " " << idx[i] << '\n';
}
cout << (long long)kk.size() << " ";
for (long long i = 0; i < (long long)kk.size(); i++) cout << kk[i] << " ";
cout << '\n';
} else {
for (long long i = 0; i < k - 1; i++) {
ans = ans + (1.0 * a[i].first) / 2;
idx[i] = a[i].second;
}
long long i = k - 1;
vector<long long> temp;
while (i < (long long)a.size()) {
ans = ans + a[i].first;
kk.push_back(a[i].second);
temp.push_back(a[i].first);
i++;
}
long long j = 0;
while (j < (long long)b.size()) {
ans = ans + b[j].first;
kk.push_back(b[j].second);
temp.push_back(b[j].first);
j++;
}
if ((long long)temp.size() > 0) {
sort(temp.begin(), temp.end());
ans = ans - temp[0];
ans = ans + (1.0 * temp[0]) / 2;
}
cout << setprecision(1) << fixed << ans << '\n';
for (long long i = 0; i < k - 1; i++) {
cout << 1 << " " << idx[i] << '\n';
}
cout << (long long)kk.size() << " ";
for (long long i = 0; i < (long long)kk.size(); i++) {
cout << kk[i] << " ";
}
cout << '\n';
}
return;
}
signed main() {
HakunaMatata();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int N = 10005;
struct data {
int p, c, pp;
bool operator<(const data &a) const { return p < a.p; }
} d[N];
vector<int> ans[N];
int n, k;
int main() {
scanf("%d %d", &n, &k);
double sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &d[i].p, &d[i].c);
d[i].pp = i + 1;
sum += d[i].p;
}
sort(d, d + n);
int cnt = 0;
for (int i = n - 1; i >= 0; --i) {
if (d[i].c == 1) {
if (cnt < k - 1) {
sum -= d[i].p / 2.0;
}
cnt++;
}
}
if (cnt >= k) sum -= d[0].p / 2.0;
printf("%.1lf\n", sum);
bool use[N];
memset(use, false, sizeof(use));
cnt = 0;
for (int i = n - 1; i >= 0; --i) {
if (d[i].c == 1) {
if (cnt < k - 1) {
printf("1 %d\n", d[i].pp);
use[i] = true;
}
cnt++;
}
}
while (cnt < k - 1) {
for (int i = 0; i < n; ++i) {
if (!use[i] && d[i].c == 2) {
printf("1 %d\n", d[i].pp);
use[i] = true;
break;
}
}
cnt++;
}
printf("%d", n - k + 1);
for (int i = 0; i < n; ++i) {
if (!use[i]) printf(" %d", d[i].pp);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<vector<pair<int, int> > > cart(k);
vector<pair<int, int> > x, y;
for (int i = 0; i < n; i++) {
int c, t;
cin >> c >> t;
if (t == 1) {
x.push_back({c, i + 1});
} else {
y.push_back({c, i + 1});
}
}
sort(x.begin(), x.end());
reverse(x.begin(), x.end());
sort(y.begin(), y.end());
int i = 0;
for (int j = 0; j < x.size(); j++) {
if (i == k) {
cart[k - 1].push_back(x[j]);
} else {
cart[i].push_back(x[j]);
i++;
}
}
for (int j = 0; j < y.size(); j++) {
if (i == k) {
cart[k - 1].push_back(y[j]);
} else {
cart[i].push_back(y[j]);
i++;
}
}
double ans = 0;
for (int i = 0; i < k; i++) {
sort(cart[i].begin(), cart[i].end());
if (i < x.size())
ans += (cart[i][0].first * 1.0) / 2;
else
ans += (cart[i][0].first * 1.0);
for (int j = 1; j < cart[i].size(); j++) {
ans += cart[i][j].first;
}
}
printf("%.1f\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 << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct object {
int p;
int indice;
int k;
};
class compareObject {
public:
bool operator()(const object &o1, const object &o2) {
if (o1.k < o2.k or (o1.k == o2.k and o1.p >= o2.p))
return false;
else
return true;
}
};
class com {
public:
bool operator()(const object &o1, const object &o2) {
if (o1.p >= o2.p)
return false;
else
return true;
}
};
int main() {
priority_queue<object, vector<object>, compareObject> pq;
object tmpo;
int n, k;
vector<vector<int> > result;
vector<int> cs;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> tmpo.p >> tmpo.k;
tmpo.indice = i;
pq.push(tmpo);
}
vector<int> t;
double total = 0;
t.push_back(0);
int i = k;
for (i; i > 1 and pq.top().k == 1; --i) {
t[0] = pq.top().indice;
double tmp = (double)pq.top().p / 2;
total += tmp;
pq.pop();
result.push_back(t);
}
while (i > 1) {
t[0] = pq.top().indice;
total += pq.top().p;
pq.pop();
result.push_back(t);
--i;
}
t.resize(0);
priority_queue<object, vector<object>, com> p;
while (pq.size()) {
p.push(pq.top());
t.push_back(pq.top().indice);
pq.pop();
}
result.push_back(t);
bool found = false;
while (p.size()) {
if (p.top().k == 1) found = true;
if (p.size() == 1 and found)
total += (double)p.top().p / 2;
else
total += (p.top().p);
p.pop();
}
cout << setprecision(1) << fixed << total << endl;
for (int i = 0; i < result.size(); ++i) {
cout << result[i].size() << " ";
for (int j = 0; j < result[i].size(); ++j) cout << result[i][j] + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int N, K;
vector<pair<int, int> > st, pen;
vector<pair<int, int> > car[1005];
int main() {
cin >> N >> K;
double s = 0;
for (int i = 0; i < N; i++) {
int c, t;
cin >> c >> t;
s += c;
if (t == 1) {
st.push_back(pair<int, int>(c, i));
} else {
pen.push_back(pair<int, int>(c, i));
}
}
sort(st.begin(), st.end());
sort(pen.begin(), pen.end());
reverse(st.begin(), st.end());
reverse(pen.begin(), pen.end());
double red = 0;
if (st.size() >= K) {
for (int i = 0; i < K; i++) {
car[i].push_back(st[i]);
if (i < K - 1) red += (double)(st[i].first) / 2;
}
for (int i = K; i < st.size(); i++) {
car[K - 1].push_back(st[i]);
}
for (int i = 0; i < pen.size(); i++) {
car[K - 1].push_back(pen[i]);
}
double m = inf;
for (int i = 0; i < car[K - 1].size(); i++) {
if (m > car[K - 1][i].first) {
m = car[K - 1][i].first;
}
}
red += m / 2;
} else {
for (int i = 0; i < st.size(); i++) {
car[i].push_back(st[i]);
red += (double)(st[i].first) / 2;
}
for (int i = 0; i + st.size() < K; i++) {
car[i + st.size()].push_back(pen[i]);
if (i + st.size() < K - 1) {
}
}
int cur = K - st.size();
for (int i = cur; i < pen.size(); i++) {
car[K - 1].push_back(pen[i]);
}
}
s -= red;
printf("%.1f\n", s);
for (int i = 0; i < K; i++) {
cout << car[i].size();
for (int j = 0; j < car[i].size(); j++) {
cout << " " << car[i][j].second + 1;
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int> > stool, pencil;
int main() {
int tmp1, tmp2;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &tmp1, &tmp2);
if (tmp2 == 1)
stool.push_back(make_pair(tmp1, i + 1));
else
pencil.push_back(make_pair(tmp1, i + 1));
}
sort(pencil.begin(), pencil.end());
sort(stool.begin(), stool.end());
reverse(pencil.begin(), pencil.end());
reverse(stool.begin(), stool.end());
if (stool.size() < k) {
long long ans = 0LL;
for (int i = 0; i < stool.size(); ++i) {
ans += (long long)stool[i].first * (long long)5;
}
for (int i = 0; i < pencil.size(); ++i)
ans += (long long)pencil[i].first * (long long)10;
printf("%I64d.%I64d\n", ans / 10LL, ans % 10LL);
for (int i = 0; i < stool.size(); ++i) {
printf("1 %d\n", stool[i].second);
}
int last = k - stool.size();
for (int i = 0; i < last - 1; ++i) {
printf("1 %d\n", pencil[i].second);
}
printf("%d", pencil.size() - (last - 1));
for (int i = last - 1; i < pencil.size(); ++i)
printf(" %d", pencil[i].second);
printf("\n");
} else if (stool.size() == k) {
long long ans = 0LL;
for (int i = 0; i < stool.size() - 1; i++)
ans += (long long)stool[i].first * (long long)5;
int mi = stool[stool.size() - 1].first;
ans += (long long)mi * (long long)10;
for (int i = 0; i < pencil.size(); ++i) {
mi = min(mi, pencil[i].first);
ans += (long long)pencil[i].first * (long long)10;
}
ans -= (long long)mi * (long long)5;
printf("%I64d.%I64d\n", ans / 10LL, ans % 10LL);
for (int i = 0; i < stool.size() - 1; ++i) {
printf("1 %d\n", stool[i].second);
}
printf("%d", pencil.size() + 1);
printf(" %d", stool[stool.size() - 1].second);
for (int i = 0; i < pencil.size(); ++i) printf(" %d", pencil[i].second);
printf("\n");
} else {
long long ans = 0LL;
for (int i = 0; i < k - 1; ++i) {
ans += (long long)stool[i].first * (long long)5;
}
int mi = stool[k - 1].first;
for (int i = k - 1; i < stool.size(); ++i) {
mi = min(mi, stool[i].first);
ans += (long long)stool[i].first * (long long)10;
}
for (int i = 0; i < pencil.size(); ++i) {
mi = min(mi, pencil[i].first);
ans += (long long)pencil[i].first * (long long)10;
}
ans -= (long long)mi * (long long)5;
printf("%I64d.%I64d\n", ans / 10LL, ans % 10LL);
for (int i = 0; i < k - 1; ++i) printf("1 %d\n", stool[i].second);
printf("%d", pencil.size() + stool.size() - (k - 1));
for (int i = k - 1; i < stool.size(); ++i) printf(" %d", stool[i].second);
for (int i = 0; i < pencil.size(); ++i) printf(" %d", pencil[i].second);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
typedef struct {
int c, t, i;
} ele;
ele e[2012];
int cmp(ele a, ele b) { return a.t < b.t || a.t == b.t && a.c > b.c; }
int main() {
long long int ans = 0;
int n, k, i, min = (1 << 31) - 1;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d %d", &e[i].c, &e[i].t);
ans += e[i].c;
e[i].i = i + 1;
}
ans *= 2;
std::sort(e, e + n, cmp);
for (i = 0; i < k - 1; i++) {
if (e[i].t == 1) ans -= e[i].c;
}
if (e[i].t == 1) {
for (; i < n; i++)
if (min > e[i].c) min = e[i].c;
ans -= min;
}
printf("%I64d.%I64d\n", ans / 2, ans % 2 * 5);
for (i = 0; i < k - 1; i++) printf("1 %d\n", e[i].i);
printf("%d", n - k + 1);
for (; i < n; i++) printf(" %d", e[i].i);
putchar(10);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << p.first << ',' << p.second;
}
template <typename T>
struct point {
T x, y;
point(T xx = 0, T yy = 0) : x(xx), y(yy) {}
T len2() const { return x * x + y * y; }
double len() const { return sqrt(double(len2())); }
bool operator==(const point<T>& p) const { return x == p.x && y == p.y; }
};
template <typename T>
point<T> operator+(const point<T>& a, const point<T>& b) {
return point<T>(a.x + b.x, a.y + b.y);
}
template <typename T>
point<T> operator-(const point<T>& a, const point<T>& b) {
return point<T>(a.x - b.x, a.y - b.y);
}
template <typename T>
T scal(const point<T>& a, const point<T>& b) {
return a.x * b.x + a.y * b.y;
}
template <typename T>
T vect(const point<T>& a, const point<T>& b) {
return a.x * b.y - a.y * b.x;
}
template <typename T>
ostream& operator<<(ostream& os, const point<T>& p) {
return os << '(' << p.x << ',' << p.y << ')';
}
const int maxn = 100100;
vector<int> res[maxn];
pair<int, int> a[maxn];
int main() {
int n, k;
cin >> n >> k;
multimap<pair<int, int>, int> all;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
all.insert(make_pair(a[i], i));
}
sort(a, a + n);
int next = k - 1;
long long sum = 0;
for (int i = n - 1; i >= 0; i--)
if (a[i].second == 1) {
res[next].push_back(i);
next = max(0, next - 1);
}
for (int i = 0; i < n; i++)
if (a[i].second == 2) {
res[next].push_back(i);
next = max(0, next - 1);
}
for (int i = 0; i < k; i++) {
long long s = 0;
int mn = inf;
int has_tab = 0;
for (int j = 0; j < res[i].size(); j++) {
mn = min(mn, a[res[i][j]].first);
s += a[res[i][j]].first;
if (a[res[i][j]].second == 1) has_tab = 1;
}
sum += s + s;
if (has_tab) sum -= mn;
}
cout << (sum >> 1) << '.' << ((sum & 1) * 5) << endl;
for (int i = 0; i < k; i++) {
printf("%d", res[i].size());
for (int j = 0; j < res[i].size(); j++) {
pair<int, int> x = a[res[i][j]];
printf(" %d", all.find(x)->second + 1);
all.erase(all.find(x));
}
puts("");
}
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;
const int N = 1e3 + 5;
int n, k, c1, c2;
long long ans, maxx;
struct stool {
long long c;
int id;
} st[N];
struct piece {
long long c;
int id;
} p[N];
bool cmp1(stool u, stool v) { return u.c > v.c; }
bool cmp2(piece u, piece v) { return u.c > v.c; }
vector<int> cart[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
long long c;
int t;
cin >> c >> t;
ans += c;
if (t == 1) st[++c1] = (stool){c, i};
if (t == 2) p[++c2] = (piece){c, i};
}
sort(st + 1, st + c1 + 1, cmp1);
sort(p + 1, p + c2 + 1, cmp2);
for (int i = 1; i <= min(c1, k - 1); ++i)
cart[i].push_back(st[i].id), maxx += st[i].c;
if (c1 >= k - 1) {
if (c1 >= k) {
if (p[c2].c)
maxx += min(st[c1].c, p[c2].c);
else
maxx += st[c1].c;
}
for (int i = k; i <= c1; ++i) cart[k].push_back(st[i].id);
for (int i = 1; i <= c2; ++i) cart[k].push_back(p[i].id);
} else {
for (int i = 1; i <= c2; ++i) cart[min(i + c1, k)].push_back(p[i].id);
}
(ans *= 2) -= maxx;
printf("%.1lf\n", ans * 0.5);
for (int i = 1; i <= k; ++i) {
cout << cart[i].size() << " ";
for (int j = 0; j < cart[i].size(); ++j) printf("%d ", cart[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > ss;
vector<pair<int, int> > ps;
for (int i = 0; i < int(n); ++i) {
int c, t;
cin >> c >> t;
((t == 1) ? ss : ps).push_back(make_pair(c, i));
}
sort((ss).begin(), (ss).end(), greater<pair<int, int> >());
long long sum = 0;
vector<vector<int> > bs(k);
int i = 0;
for (; i < min<int>(k - 1, ss.size()); ++i) {
bs[i].push_back(ss[i].second);
sum += ss[i].first;
}
bool const b = (i != ss.size());
if (b) {
int cMin = INT_MAX;
for (int l = i; l < ss.size(); ++l) {
bs[i].push_back(ss[l].second);
sum += 2 * ss[l].first;
cMin = min(cMin, ss[l].first);
}
for (int l = 0; l < int(ps.size()); ++l) {
bs[i].push_back(ps[l].second);
sum += 2 * ps[l].first;
cMin = min(cMin, ps[l].first);
}
sum -= cMin;
} else {
int j = i;
for (int l = 0; l < int(ps.size()); ++l) {
bs[j].push_back(ps[l].second);
sum += 2 * ps[l].first;
j = ((j - i) + 1) % (k - i) + i;
}
}
cout.precision(1);
cout << fixed << sum / 2.0 << endl;
for (int i = 0; i < int(k); ++i) {
cout << bs[i].size() << " ";
for (int j = 0; j < int(bs[i].size()); ++j) {
cout << bs[i][j] + 1 << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
double p;
long long num;
} a1[1003], a2[1003], p1, p2;
long long n, k, c, t, s1, s2, h1 = 1, h2 = 1, b1, b2, sum, an[2003][1003];
double ans, s, max1 = 1e9;
long long cmp(node x, node y) { return x.p > y.p; }
signed main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) {
scanf("%lld%lld", &c, &t);
if (t == 1)
s1++, a1[s1].p = c, a1[s1].num = i;
else
s2++, a2[s2].p = c, a2[s2].num = i;
}
sort(a1 + 1, a1 + s1 + 1, cmp);
sort(a2 + 1, a2 + s2 + 1, cmp);
for (long long i = 1; i <= k - 1; i++) {
sum = 0, b1 = 0, b2 = 0;
if (h1 <= s1) p1 = a1[h1], sum++, h1++, b1 = 1;
if (h2 <= s2 && (s1 - h1 + 1 + s2 - h2 + 1 > k - i))
if ((sum != 0 && a2[h2].p > p1.p) || sum == 0)
sum++, p2 = a2[h2], h2++, b2 = 1;
if (b2 == 1) {
if (sum == 2)
ans += (double)p2.p + (double)p1.p / 2.0;
else
ans += (double)p2.p;
} else if (b1 == 1)
ans += (double)p1.p / 2.0;
an[i][1] = sum;
if (sum == 1)
if (b1 == 1)
an[i][2] = p1.num;
else
an[i][2] = p2.num;
else
an[i][2] = p1.num, an[i][3] = p2.num;
}
sum = 0, b1 = 0;
while (h1 <= s1)
sum++, b1 = 1, an[k][sum + 1] = a1[h1].num, max1 = min(max1, a1[h1].p),
s += (double)a1[h1].p, h1++;
while (h2 <= s2)
sum++, an[k][sum + 1] = a2[h2].num, max1 = min(max1, a2[h2].p),
s += (double)a2[h2].p, h2++;
an[k][1] = sum;
if (b1 == 1)
ans = ans + s - (double)max1 / 2.0;
else
ans = ans + s;
printf("%.1lf\n", ans);
for (long long i = 1; i <= k; i++) {
cout << an[i][1] << " ";
for (long long j = 1; j <= an[i][1]; j++) cout << an[i][j + 1] << " ";
cout << endl;
}
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());
while (!pencils.empty()) {
RED[r - 1].push_back(pencils.back());
red_v[r - 1] = min(red_v[r - 1], pencils.back().cost);
pencils.pop_back();
}
assert(pencils.empty());
}
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>
double const PI = 4 * atan(1.0);
using namespace std;
double tong = 0;
int n, k, type;
double c;
vector<pair<double, int> > V1, V2;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lf %d", &c, &type);
if (type == 1)
V1.push_back(make_pair(c, i));
else
V2.push_back(make_pair(c, i));
tong += c;
}
sort(V1.begin(), V1.end());
sort(V2.begin(), V2.end());
if (V1.size() < k) {
for (int i = 0; i < V1.size(); i++) tong -= V1[i].first / 2;
printf("%.1lf\n", tong);
for (int i = 0; i < V1.size(); i++) printf("1 %d\n", V1[i].second);
for (int i = V1.size(); i < k - 1; i++)
printf("1 %d\n", V2[i - V1.size()].second);
printf("%d", n - k + 1);
for (int i = k - 1; i < n; i++) printf(" %d", V2[i - V1.size()].second);
} else {
for (int i = V1.size() - 1; i > V1.size() - k; i--) tong -= V1[i].first / 2;
vector<pair<double, int> > V;
for (int i = V1.size() - k; i >= 0; i--) V.push_back(V1[i]);
for (int i = 0; i < V2.size(); i++) V.push_back(V2[i]);
sort(V.begin(), V.end());
tong -= V[0].first / 2;
printf("%.1lf\n", tong);
for (int i = V1.size() - 1; i > V1.size() - k; i--)
printf("1 %d\n", V1[i].second);
printf("%d", n - k + 1);
for (int i = 0; i < V.size(); i++) printf(" %d", V[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10, inf = 1e10;
int n, k, type[1010];
vector<int> carr[1010];
vector<pair<int, int> > stool, pencil, input;
int main() {
scanf("%d%d", &n, &k);
for (int(i) = 0; (i) < (n); (i)++) {
int c, t;
scanf("%d%d", &c, &t);
((t == 1) ? stool : pencil).push_back(make_pair(c, i));
input.push_back(make_pair(c, i));
type[i] = t;
}
sort(stool.rbegin(), stool.rend());
sort(pencil.rbegin(), pencil.rend());
long long ans = 0;
int i = 0, j = 0, lasthas = 0, minAss = numeric_limits<int>::max();
while (i < k - 1 && i < (int((stool).size())))
ans += stool[i].first, carr[i].push_back(stool[i].second), i++;
while (i + j < k - 1 && j < (int((pencil).size())))
ans += 2 * pencil[j].first, carr[i + j].push_back(pencil[j].second), j++;
while (i < (int((stool).size())))
minAss = min(minAss, stool[i].first), ans += 2 * stool[i].first,
carr[k - 1].push_back(stool[i].second), i++, lasthas = 1;
while (j < (int((pencil).size())))
minAss = min(minAss, pencil[j].first), ans += 2 * pencil[j].first,
carr[k - 1].push_back(pencil[j].second), j++;
if (lasthas) ans -= minAss;
cout << (ans / 2) << '.' << (ans % 2 * 5) << '\n';
for (int(i) = 0; (i) < (k); (i)++) {
printf("%d", (int((carr[i]).size())));
for (int(j) = 0; (j) < ((int((carr[i]).size()))); (j)++)
printf(" %d", carr[i][j] + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T a) {
return (a) * (a);
}
template <class T>
T abs(T a) {
return (a < 0) ? -(a) : (a);
}
const double Pi = acos(-1.0);
const double eps = 1e-20;
const int INF = 101e7;
const double phi = 0.5 + sqrt(5.0) / 2;
int comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.second != b.first.second)
return a.first.second < b.first.second;
else
return a.first.first > b.first.first;
}
int main() {
int n, k;
scanf("%d %d\n", &n, &k);
vector<pair<pair<int, int>, int> > q(n);
int chairs = 0;
long long score = 0;
for (int i = 0, _n = (n)-1; i <= _n; ++i) {
scanf("%d %d\n", &q[i].first.first, &q[i].first.second);
q[i].second = i + 1;
if (q[i].first.second == 1) chairs++;
score += q[i].first.first;
}
sort(q.begin(), q.end(), comp);
double res = score;
vector<vector<int> > basket(k);
if (chairs < k) {
for (int i = 0, _n = (chairs)-1; i <= _n; ++i) {
basket[i].push_back(q[i].second);
res -= 0.5 * q[i].first.first;
}
for (int i = (chairs), _b = (k - 2); i <= _b; ++i)
basket[i].push_back(q[i].second);
for (int i = (k - 1), _b = (n - 1); i <= _b; ++i)
basket[k - 1].push_back(q[i].second);
printf("%.1f\n", res);
for (int i = 0, _n = (k)-1; i <= _n; ++i) {
printf("%d ", ((int)((basket[i]).size())));
for (int j = 0, _n = (((int)((basket[i]).size()))) - 1; j <= _n; ++j)
printf("%d ", basket[i][j]);
printf("\n");
}
} else {
for (int i = 0, _n = (k - 1) - 1; i <= _n; ++i) {
basket[i].push_back(q[i].second);
res -= 0.5 * q[i].first.first;
}
int bonus = INF;
for (int i = (k - 1), _b = (n - 1); i <= _b; ++i)
bonus = min(bonus, q[i].first.first);
res -= 0.5 * bonus;
for (int i = (k - 1), _b = (n - 1); i <= _b; ++i)
basket[k - 1].push_back(q[i].second);
printf("%.1f\n", res);
for (int i = 0, _n = (k)-1; i <= _n; ++i) {
printf("%d ", ((int)((basket[i]).size())));
for (int j = 0, _n = (((int)((basket[i]).size()))) - 1; j <= _n; ++j)
printf("%d ", basket[i][j]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<pair<int, int> > v(n), s, p;
for (int i = 0; i < (n); ++i) scanf("%d %d", &v[i].first, &v[i].second);
for (int i = 0; i < (n); ++i)
if (v[i].second == 1)
s.push_back(make_pair(v[i].first, i));
else
p.push_back(make_pair(v[i].first, i));
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
vector<vector<pair<int, int> > > rr(k);
int tt = min<int>(k, s.size());
for (int i = 0; i < (tt); ++i) rr[i].push_back(s[i]);
if (tt == k) {
for (int i(tt); i < (s.size()); ++i) rr[k - 1].push_back(s[i]);
for (int i = 0; i < (p.size()); ++i) rr[k - 1].push_back(p[i]);
} else {
for (int i = 0; i < (p.size()); ++i) rr[min(tt + i, k - 1)].push_back(p[i]);
}
long long res = 0;
for (int i = 0; i < (k); ++i) {
vector<pair<int, int> >& act = rr[i];
bool ss = 0;
int minv = 1e9;
long long sum = 0;
for (int j = 0; j < (act.size()); ++j) {
pair<int, int>& vv = v[act[j].second];
ss |= (vv.second == 1);
minv = min(minv, vv.first);
sum += vv.first;
}
res += sum * 2;
if (ss) res -= minv;
}
printf("%I64d.%d\n", res / 2, (res % 2) ? 5 : 0);
for (int i = 0; i < (rr.size()); ++i) {
printf("%d", rr[i].size());
for (int j = 0; j < (rr[i].size()); ++j) {
printf(" %d", rr[i][j].second + 1);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int a, id;
bool operator<(const Node& x) const { return a > x.a; }
} T[1010], S[1010];
double f[1010][1010];
int Can[1010], point[1010];
int n, k, num1, num2;
double ans;
int main() {
scanf("%d%d", &n, &k);
int x, y;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
if (y == 1) {
T[num1].id = i + 1;
T[num1++].a = x;
} else {
S[num2].id = i + 1;
S[num2++].a = x;
}
}
sort(T, T + num1);
sort(S, S + num2);
if (num1 >= k - 1) {
for (int i = 0; i < k - 1; ++i) ans += (double)(T[i].a) / 2;
for (int i = k - 1; i < num1; ++i) ans += T[i].a;
for (int i = 0; i < num2; ++i) ans += S[i].a;
if (num1 >= k) {
double Num = T[num1 - 1].a;
if (num2) Num = ((Num) < (S[num2 - 1].a) ? (Num) : (S[num2 - 1].a));
ans -= Num / 2;
}
printf("%.1f\n", ans);
for (int i = 0; i < k - 1; ++i) printf("%d %d\n", 1, T[i].id);
printf("%d ", n - k + 1);
for (int i = k - 1; i < num1; ++i) printf("%d ", T[i].id);
for (int i = 0; i < num2; ++i) printf("%d ", S[i].id);
} else {
for (int i = 0; i < num1; ++i) ans += (double)(T[i].a) / 2;
for (int i = 0; i < num2; ++i) ans += S[i].a;
printf("%.1f", ans);
for (int i = 0; i < num1; ++i) printf("\n%d %d", 1, T[i].id);
int j, i;
for (i = num1, j = 0; i < k - 1; ++i, ++j) printf("\n%d %d", 1, S[j].id);
printf("\n%d", n - i);
for (; j < num2; ++j) printf(" %d", S[j].id);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, S = 0, c, t;
vector<pair<int, int> > stool, pencil;
vector<int> K[1005];
double AC, MN;
int main() {
scanf("%d%d", &n, &m);
S = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &c, &t);
if (t == 1) {
++S;
stool.push_back(make_pair(-c, i));
} else
pencil.push_back(make_pair(c, i));
}
AC = 0.0;
sort(stool.begin(), stool.end());
if (m > S) {
for (int i = 0; i < S; i++) {
AC += -stool[i].first * 0.5;
K[i].push_back(stool[i].second);
}
for (int i = 0; i < n - S; i++) {
AC += pencil[i].first;
K[min(S + i, m - 1)].push_back(pencil[i].second);
}
} else {
for (int i = 0; i < m - 1; i++) {
AC += -stool[i].first * 0.5;
K[i].push_back(stool[i].second);
}
MN = 1e20;
for (int i = m - 1; i < S; i++) {
MN = min(MN, -stool[i].first * 1.0);
K[m - 1].push_back(stool[i].second);
AC += -stool[i].first;
}
for (int i = 0; i < n - S; i++) {
MN = min(MN, pencil[i].first * 1.0);
K[m - 1].push_back(pencil[i].second);
AC += pencil[i].first;
}
AC -= MN * 0.5;
}
printf("%.1lf\n", AC);
for (int i = 0; i < m; i++) {
int siz = K[i].size();
printf("%d", siz);
for (int j = 0; j < siz; j++)
printf(" %d", K[i][j] + 1, j == siz - 1 ? '\n' : ' ');
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
template <class T>
double sqrt(T x) {
return sqrt((double)x);
}
template <class T>
T sqr(T x) {
return x * x;
}
const double PI = acos(-1.0);
const int INF = 1000000000;
const int MOD = 1000000007;
int main() {
double TIME_START = clock();
int n, k, b, c;
cin >> n >> k;
vector<int> pr(n);
vector<pair<int, int> > t, o;
for (int x = 0; x < n; x++) {
cin >> b >> c;
pr[x] = b;
if (c == 1)
t.push_back(make_pair(b, x));
else
o.push_back(make_pair(b, x));
}
vector<vector<pair<int, int> > > kor(k);
if (n == k) {
int j = 0;
for (int x = 0; x < t.size(); x++)
kor[j++].push_back(make_pair(t[x].second, 1));
for (int x = 0; x < o.size(); x++)
kor[j++].push_back(make_pair(o[x].second, 2));
} else {
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
sort(o.begin(), o.end());
reverse(o.begin(), o.end());
if (t.size() < k) {
int j = 0;
for (int x = 0; x < t.size(); x++)
kor[j++].push_back(make_pair(t[x].second, 1));
int x;
for (x = 0; x < k - t.size() - 1; x++)
kor[j++].push_back(make_pair(o[x].second, 2));
for (; x < o.size(); x++) kor[j].push_back(make_pair(o[x].second, 2));
} else {
if (t.size() == k) {
int j = 0;
for (int x = 0; x < t.size(); x++)
kor[j++].push_back(make_pair(t[x].second, 1));
j--;
for (int x = 0; x < o.size(); x++)
kor[j].push_back(make_pair(o[x].second, 2));
} else {
int j = 0;
int x;
for (x = 0; x < k; x++) kor[j++].push_back(make_pair(t[x].second, 1));
j--;
for (; x < t.size(); x++) kor[j].push_back(make_pair(t[x].second, 1));
for (int x = 0; x < o.size(); x++)
kor[j].push_back(make_pair(o[x].second, 2));
}
}
}
double price = 0;
for (int x = 0; x < kor.size(); x++) {
float all = 0;
bool tab = 0;
int mi = INF;
for (int y = 0; y < kor[x].size(); y++) {
all += pr[kor[x][y].first];
mi = min(mi, pr[kor[x][y].first]);
if (kor[x][y].second == 1) tab = 1;
}
if (tab == 0)
price += all;
else
price += all - mi / 2.;
}
char s[50];
sprintf(s, "%.2lf", price);
s[strlen(s) - 1] = 0;
cout << s << endl;
for (int x = 0; x < k; x++) {
cout << kor[x].size();
for (int y = 0; y < kor[x].size(); y++) cout << " " << kor[x][y].first + 1;
cout << endl;
}
fprintf(stderr, "\n\n%.15lf\n\n",
(double)(clock() - TIME_START) / CLOCKS_PER_SEC);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, pair<int, int> > > t(n);
for (int i = 0; i < n; ++i) {
cin >> t[i].first >> t[i].second.first;
t[i].second.second = i;
}
sort(t.begin(), t.end());
vector<vector<int> > res(k);
int count = 0;
int i;
for (i = n - 1; i >= 0 && count < k; --i)
if (t[i].second.first == 1) {
res[count].push_back(i);
++count;
}
if (count < k) {
int l = n - 1;
for (int j = count; j < k; ++j) {
while (t[l].second.first != 2) --l;
res[j].push_back(l);
--l;
}
for (int j = l; j >= 0; --j)
if (t[j].second.first == 2) res[k - 1].push_back(j);
} else
for (int j = n - 1; j >= 0; --j)
if (t[j].second.first == 2 || j < res[k - 1][0]) res[k - 1].push_back(j);
long long ag = 0;
for (int i = 0; i < n; ++i) ag += (long long)t[i].first;
long long sum = 0;
for (int i = 0; i < k; ++i)
if (t[res[i][0]].second.first == 1)
sum += (long long)min(t[res[i][(int)res[i].size() - 1]].first,
t[res[i][0]].first);
long double s = (long double)ag - (long double)sum / 2;
cout << fixed << setprecision(1) << s;
long long t1 = (long long)s;
long double s1 = (long double)t1;
cout << endl;
for (int i = 0; i < k; ++i) {
cout << (int)res[i].size() << " ";
for (int j = 0; j < (int)res[i].size(); ++j)
cout << t[res[i][j]].second.second + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long price[1020], type[1020];
vector<int> cart[1020];
int main() {
int K, N;
while (scanf("%d%d", &N, &K) != EOF) {
for (int i = 0; i < (int)(1020); ++i) cart[i].clear();
vector<pair<long long, int> > stool;
vector<pair<long long, int> > all;
long long sum = 0;
for (int i = 0; i < (int)(N); ++i) {
int p, t;
scanf("%d%d", &p, &t);
price[i] = p;
type[i] = t;
sum += p;
if (t == 1) {
stool.push_back(make_pair(p, i));
} else {
all.push_back(make_pair(p, i));
}
}
sort(stool.begin(), stool.end());
int idx = 0;
for (; idx < K; ++idx) {
if ((int)((stool).size()) == 0) break;
cart[idx].push_back(stool.back().second);
stool.pop_back();
}
for (__typeof((stool).begin()) it = (stool).begin(); it != (stool).end();
++it)
all.push_back(*it);
sort(all.begin(), all.end());
long long discount = 0;
int k = K - 1;
for (__typeof((all).begin()) it = (all).begin(); it != (all).end(); ++it) {
long long p = it->first;
if (k == idx - 1 && (int)((cart[k]).size()) == 1) {
discount += min(price[cart[k][0]], p);
}
cart[k].push_back(it->second);
if (idx + 1 <= k) {
k--;
}
}
for (int i = 0; i < (int)(K); ++i)
if (i < idx && (int)((cart[i]).size()) == 1) {
discount += price[cart[i][0]];
}
double res = sum - 0.5 * discount;
printf("%.1f\n", res);
for (int i = 0; i < (int)(K); ++i) {
printf("%d", (int)((cart[i]).size()));
for (__typeof((cart[i]).begin()) it = (cart[i]).begin();
it != (cart[i]).end(); ++it)
printf(" %d", 1 + *it);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long n, k, A, B;
vector<pair<int, long>> a;
vector<pair<int, long>> b;
long double sum = 0;
long double temps;
long minimum = 1000000001;
int main() {
cin >> n >> k;
pair<int, long> temp;
for (int i = 0; i < n; i++) {
cin >> temp.first >> temp.second;
if (temp.second == 1) {
temp.second = i + 1;
a.push_back(temp);
} else {
temp.second = i + 1;
if (temp.first < minimum) minimum = temp.first;
b.push_back(temp);
}
sum += temp.first;
}
sort(a.begin(), a.end());
vector<pair<int, long>>::iterator it = a.end();
int i = 0;
int N = (a.size() < k) ? a.size() : k - 1;
for (; i < N; i++) {
it--;
temps = (*it).first;
sum -= temps / 2;
}
if (a.size() >= k) {
temps = (minimum < a[0].first) ? minimum : a[0].first;
sum -= temps / 2;
}
printf("%.1f", sum);
it = a.end();
for (i = 0; i < N; i++) {
it--;
cout << endl << "1 " << (*it).second;
}
if (a.size() >= k) {
cout << endl << a.size() - k + 1 + b.size();
for (; it != a.begin();) {
it--;
cout << ' ' << (*it).second;
}
it = b.begin();
while (it != b.end()) {
cout << ' ' << (*it).second;
it++;
}
} else {
k -= a.size();
it = b.begin();
while (k > 1) {
cout << endl << "1 " << (*it).second;
it++;
k--;
}
if (it != b.end()) {
cout << endl << (int)(b.end() - it);
while (it != b.end()) {
cout << ' ' << (*it).second;
it++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
vector<int> to, ko;
vector<int> ans[2000];
bool f(int x, int y) { return (a[x] > a[y]); };
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int x, c;
scanf("%d%d", &c, &x);
a.push_back(c);
if (x == 1)
to.push_back(i);
else
ko.push_back(i);
}
sort(to.begin(), to.end(), f);
sort(ko.begin(), ko.end(), f);
int l = 0;
int i = 0;
double sum = 0.0;
for (int L = 0; L < m; L++) {
if (L == m - 1) {
for (int j = l; j < to.size(); j++) {
sum += a[to[j]];
ans[L].push_back(to[j]);
}
for (int j = i; j < ko.size(); j++) {
sum += a[ko[j]];
ans[L].push_back(ko[j]);
}
if (l < to.size()) {
double y = a[to[to.size() - 1]];
if (i < ko.size()) y = min(a[to[to.size() - 1]], a[ko[ko.size() - 1]]);
y /= 2;
sum -= y;
}
continue;
}
if (l < to.size()) {
double y = a[to[l]];
sum += y / 2;
ans[L].push_back(to[l]);
l++;
continue;
}
sum += a[ko[i]];
ans[L].push_back(ko[i]);
i++;
}
printf("%.1f\n", sum);
for (int i = 0; i < m; i++) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j] + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
vector<pair<double, int> > pencils;
vector<pair<double, int> > taburets;
vector<int> res[1000];
int main() {
int N, K;
cin >> N >> K;
double sum = 0;
for (int i = 0; i < N; i++) {
int t;
double c;
cin >> c >> t;
sum += c;
if (t == 1)
taburets.push_back(make_pair(c, i + 1));
else
pencils.push_back(make_pair(c, i + 1));
}
sort(taburets.begin(), taburets.end());
sort(pencils.begin(), pencils.end());
int k = taburets.size(), l = pencils.size();
int u = min(K - 1, k);
for (int i = 0; i < u; i++) sum -= taburets[k - i - 1].first / 2;
double a;
if (taburets.empty())
a = pencils[0].first / 2;
else if (pencils.empty())
a = taburets[0].first / 2;
else
a = min(taburets[0].first, pencils[0].first) / 2;
if (k >= K) sum -= a;
printf("%.1lf\n", sum);
vector<int> por;
for (int i = 0; i < k; i++) por.push_back(taburets[k - i - 1].second);
for (int i = 0; i < l; i++) por.push_back(pencils[i].second);
for (int i = 0; i < K - 1; i++) printf("%d %d\n", 1, por[i]);
cout << N - K + 1 << " ";
for (int i = K - 1; i < N - 1; i++) cout << por[i] << " ";
cout << por[N - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1010;
const int INF = 1000000000;
int n, k;
int type[MAX_N], cost[MAX_N], position[MAX_N];
vector<int> solution[MAX_N];
int commp(int i, int j) {
return type[i] < type[j] || (type[i] == type[j] && cost[i] > cost[j]);
}
long long FindCost() {
long long result = 0;
for (int i = 1; i <= k; ++i) {
int flag = 0;
long long sum = 0;
int best = INF;
for (size_t j = 0; j < solution[i].size(); ++j) {
flag |= type[solution[i][j]] == 1;
sum += 2 * cost[solution[i][j]];
best = min(best, cost[solution[i][j]]);
}
result += sum;
if (flag) {
result -= best;
}
}
return result;
}
int main() {
scanf("%d %d ", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d %d ", &cost[i], &type[i]);
position[i] = i;
}
sort(position + 1, position + n + 1, commp);
for (int i = 1; i <= k; ++i) {
solution[i].push_back(position[i]);
}
for (int i = k + 1; i <= n; ++i) {
solution[k].push_back(position[i]);
}
long long cost = FindCost();
long long a = cost / 2;
int b = cost % 2 == 0 ? 0 : 5;
cout << a << "." << b << endl;
for (int i = 1; i <= k; ++i) {
cout << solution[i].size() << " ";
for (size_t j = 0; j < solution[i].size(); ++j) {
cout << solution[i][j] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1005][1005];
vector<pair<int, int> > sp, pc;
int k, n, p1 = 0, p2 = 0;
int get(int p1, int p2) { return sp.size() - p1 + pc.size() - p2; }
vector<int> v[2000];
int main() {
double res = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int p, t;
cin >> p >> t;
if (t == 1)
sp.push_back(pair<int, int>(p, i));
else
pc.push_back(pair<int, int>(p, i));
}
sort(sp.begin(), sp.end());
sort(pc.begin(), pc.end());
reverse(pc.begin(), pc.end());
reverse(sp.begin(), sp.end());
for (int i = 0; i < k; i++) {
int rem = get(p1, p2);
if (i == k - 1) {
double mn = 1e10;
for (int j = p1; j < sp.size(); j++) {
v[i].push_back(sp[j].second);
res += sp[j].first;
mn = min(mn, (double)sp[j].first);
}
for (int j = p2; j < pc.size(); j++) {
v[i].push_back(pc[j].second);
res += pc[j].first;
mn = min(mn, (double)pc[j].first);
}
if (p1 < sp.size()) res -= mn / 2.;
} else if (p1 == sp.size()) {
if (i == k - 1) {
for (int j = p2; j < pc.size(); j++)
v[i].push_back(pc[j].second), res += pc[j].first;
} else
v[i].push_back(pc[p2].second), res += pc[p2++].first;
} else if (p2 == pc.size()) {
if (i == k - 1) {
for (int j = p1; j < sp.size(); j++)
v[i].push_back(sp[j].second), res += sp[j].first;
res -= (double)(sp[p1].first) / 2.;
} else
v[i].push_back(sp[p1].second), res += (double)sp[p1++].first / 2.;
} else
v[i].push_back(sp[p1].second), res += (double)sp[p1++].first / 2.;
}
printf("%.1lf\n", res);
for (int i = 0; i < k; i++) {
cout << v[i].size();
for (int j = 0; j < v[i].size(); j++) cout << ' ' << v[i][j] + 1;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long int, long long int> > a[2];
long long int n, k, c, d;
double res = 0.0;
cin >> n >> k;
for (long long int i = 0; i < ((long long int)(n)); ++i) {
cin >> c >> d;
a[d - 1].push_back(make_pair(c, i + 1));
res += c;
}
vector<vector<pair<long long int, long long int> > > ans(k);
sort((a[0]).begin(), (a[0]).end());
reverse((a[0]).begin(), (a[0]).end());
for (long long int index = 0; index < ((long long int)(2)); ++index)
for (long long int i = 0;
i < ((long long int)(((long long int)(a[index]).size()))); ++i)
for (long long int j = 0; j < ((long long int)(k)); ++j) {
if (((long long int)(ans[j]).size()) && j + 1 != k) continue;
ans[j].push_back(a[index][i]);
break;
}
for (long long int i = 0; i < ((long long int)(k)); ++i) {
sort((ans[i]).begin(), (ans[i]).end());
if (i < ((long long int)(a[0]).size())) res -= ans[i][0].first * 0.5;
}
printf("%0.1lf\n", res);
for (long long int i = 0; i < ((long long int)(k)); ++i) {
cout << ((long long int)(ans[i]).size()) << " ";
for (long long int j = 0;
j < ((long long int)(((long long int)(ans[i]).size()))); ++j)
cout << ans[i][j].second << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
int n, k;
vector<pair<int, int> > a, b;
vector<vector<pair<int, int> > > res;
bool u[1010];
int main() {
scanf("%d%d", &n, &k);
a.clear();
b.clear();
res.clear();
res.resize(k);
for (int i = 0; i < (int)(k); i++) res[i].clear();
long long sum = 0;
for (int i = 0; i < (int)(n); i++) {
int x, y;
scanf("%d%d", &x, &y);
sum += x * 2;
if (y == 1)
a.push_back(make_pair(x, i + 1));
else
b.push_back(make_pair(x, i + 1));
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int cur = k - 1;
memset(u, 0, sizeof(u));
for (int i = (int)(a.size()) - 1; i >= 0; i--) {
res[cur].push_back(a[i]);
u[cur] = 1;
cur--;
if (cur < 0) cur = 0;
}
for (int i = (int)(b.size()) - 1; i >= 0; i--) {
res[cur].push_back(b[i]);
cur--;
if (cur < 0) cur = 0;
}
for (int i = 0; i < (int)(k); i++) sort(res[i].begin(), res[i].end());
for (int i = 0; i < (int)(k); i++)
if (u[i]) {
sum -= res[i][0].first;
}
cout << sum / 2 << "." << (sum % 2) * 5 << endl;
for (int i = 0; i < (int)(k); i++) {
printf("%d", res[i].size());
for (int j = 0; j < (int)(res[i].size()); j++)
printf(" %d", res[i][j].second);
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pr {
int w, i;
};
bool operator<(const pr& a, const pr& b) { return a.w > b.w; }
pr tab[1005], pen[1005];
int p[1005], s[1005], mn[1005];
double w = 0;
int u = 0, tsz = 0, psz = 0;
int main() {
int n, k, t1, t2;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &t1, &t2);
w += t1;
if (t2 == 1) {
tab[tsz].w = t1;
tab[tsz].i = i;
++tsz;
} else {
pen[psz].w = t1;
pen[psz].i = i;
++psz;
}
}
sort(pen, pen + psz);
sort(tab, tab + tsz);
int ti = 0;
int br = min(tsz, k);
for (int i = 0; i < br; ++i) {
p[tab[i].i] = i;
s[i]++;
if (mn[i] == 0 || mn[i] > tab[i].w) mn[i] = tab[i].w;
}
for (int i = br; i < k; ++i) {
p[pen[ti].i] = i;
ti++;
s[i]++;
}
for (int i = br; i < tsz; ++i) {
p[tab[i].i] = k - 1;
s[k - 1]++;
mn[k - 1] = min(mn[k - 1], tab[i].w);
}
for (int i = ti; i < psz; ++i) {
p[pen[i].i] = k - 1;
s[k - 1]++;
mn[k - 1] = min(mn[k - 1], pen[i].w);
}
for (int i = 0; i < k; ++i) w -= mn[i] / 2.0;
printf("%.1lf\n", w);
for (int i = 0; i < k; ++i) {
printf("%d ", s[i]);
for (int j = 0; j < n; ++j)
if (p[j] == i) printf("%d ", j + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, r, p, st = 1;
double ans;
struct emm {
int c, id;
bool operator<(const emm &rhs) const { return c < rhs.c; }
} a[1005], b[1005];
vector<int> v[1005];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1, c, x; i <= n; i++) {
scanf("%d %d", &c, &x);
if (x == 1) {
a[++r].c = c, a[r].id = i;
} else {
b[++p].c = c, b[p].id = i;
}
ans += (double)c;
}
sort(a + 1, a + 1 + r);
sort(b + 1, b + 1 + p);
for (int i = 1, j = r; i <= k && j; i++, j--)
v[i].push_back(a[j].id), ans -= (double)a[j].c / 2.0;
if (r < k) {
for (int i = r + 1; i <= k; i++, st++) v[i].push_back(b[st].id);
for (int i = st; i <= p; i++) v[k].push_back(b[i].id);
} else {
ans += (double)a[r - k + 1].c / 2.0;
int minn = a[r - k + 1].c;
for (int i = 1; i + k <= r; i++)
v[k].push_back(a[i].id), minn = min(minn, a[i].c);
for (int i = 1; i <= p; i++)
v[k].push_back(b[i].id), minn = min(minn, b[i].c);
ans -= (double)minn / 2.0;
}
printf("%.1lf\n", ans);
for (int i = 1; i <= k; i++) {
printf("%d ", (int)v[i].size());
for (int j : v[i]) printf("%d ", j);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005;
struct node {
long long c, t, id;
} a[N];
long long n, k, cnt;
double ans;
inline bool cmp(node i, node j) {
if (i.t != j.t) return i.t < j.t;
return i.c > j.c;
}
signed main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i].c, &a[i].t);
a[i].id = i;
if (a[i].t == 1) cnt++;
ans += a[i].c;
}
sort(a + 1, a + 1 + n, cmp);
if (cnt >= k - 1) {
for (long long i = 1; i <= k - 1; i++) ans -= 0.5 * a[i].c;
if (cnt >= k) ans -= min(a[cnt].c, a[n].c) * 0.5;
} else {
for (long long i = 1; i <= cnt; i++) {
ans -= 0.5 * a[i].c;
}
}
printf("%.1lf\n", ans);
for (long long i = 1; i <= k - 1; i++) {
printf("1 %d\n", a[i].id);
}
printf("%d ", n - k + 1);
for (long long i = k; i <= n; i++) printf("%d ", a[i].id);
return 0;
}
|
#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];
signed main() {
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;
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 << endl;
long long printed = 0;
for (long long i = 0; i < s.size(); i++) {
if (i <= k - 2) {
printed++;
cout << 1 << " " << s[i].second << endl;
}
}
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() << endl;
rem.pop_back();
printed++;
}
cout << rem.size() << " ";
for (auto &it : rem) cout << it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const double PI = 3.141592653589793;
const int N = 1005;
long long res;
int minn, kol[N], juz[N], w, t[N], c[N], i, j, n, k, st;
vector<int> wek[N];
bool cmp(int a, int b) { return c[a] > c[b]; }
int main() {
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d %d", &c[i], &t[i]);
kol[i] = i;
juz[i] = 0;
}
j = 0;
sort(kol, kol + n, cmp);
for (i = 0; i < n; i++) {
w = kol[i];
if (t[w] == 1 && j < k) {
juz[w] = 1;
wek[j].push_back(w);
j++;
}
}
for (i = 0; i < n && j < k; i++)
if (juz[i] == 0) {
wek[j].push_back(i);
juz[i] = 1;
j++;
}
for (i = 0; i < n; i++)
if (juz[i] == 0) wek[k - 1].push_back(i);
res = 0;
for (i = 0; i < k; i++) {
minn = INF;
st = 0;
for (j = 0; j < wek[i].size(); j++) {
minn = min(minn, c[wek[i][j]]);
if (t[wek[i][j]] == 1) st = 1;
res += 2 * c[wek[i][j]];
}
if (st == 1) res -= minn;
}
cout << res / 2 << ".";
if (res % 2 == 1)
printf("5\n");
else
printf("0\n");
for (i = 0; i < k; i++) {
printf("%d ", wek[i].size());
for (j = 0; j < wek[i].size(); j++) printf("%d ", wek[i][j] + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void chkmax(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
inline void chkmin(T& x, U y) {
if (y < x) x = y;
}
const int MAXN = 1111;
int id[MAXN], cost[MAXN], tp[MAXN], ret[MAXN];
int chk[MAXN];
vector<int> V[MAXN];
bool cmp(int x, int y) { return cost[x] < cost[y]; }
int main() {
int n, m;
cin >> n >> m;
int tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &cost[i], &tp[i]), id[i] = i;
}
sort(id + 1, id + n + 1, cmp);
int cnt = 0, i;
long long ans = 0;
int rem = n;
for (i = n; i > 0 && cnt < m; i--) {
int u = id[i];
if (chk[u]) continue;
chk[u] = ++cnt;
rem--;
if (tp[u] == 2 && rem > m - cnt) {
int v = 0;
for (int j = i - 1; j > 0; j--) {
int w = id[j];
if (chk[w]) continue;
if (tp[w] == 1) {
v = w;
break;
}
}
if (v) {
chk[v] = cnt;
rem--;
}
}
}
for (int i = 1; i <= n; i++) {
int u = id[i];
if (!chk[u]) chk[u] = min(m, ++cnt);
}
for (int i = 1; i <= m; i++) ret[i] = 1e9 + 5;
for (int i = 1; i <= n; i++) {
ans += 2 * cost[i];
chkmin(ret[chk[i]], cost[i]);
V[chk[i]].push_back(i);
}
for (int i = 1; i <= m; i++) {
bool flg = 0;
for (int j = 0; !flg && j < V[i].size(); j++) {
if (tp[V[i][j]] == 1) flg = 1;
}
if (flg) ans -= ret[i];
}
printf("%.1lf\n", ans * 0.5);
for (int i = 1; i <= m; i++) {
printf("%d", V[i].size());
for (int j = 0; j < V[i].size(); j++) printf(" %d", V[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int c[1001], t[1001];
vector<pair<int, int> > tab, pen;
vector<int> res[1001];
int main() {
scanf("%d %d", &n, &k);
for (int i = (0), _b(n); i < _b; i++) {
scanf("%d %d", c + i, t + i);
if (t[i] == 1)
tab.push_back(pair<int, int>(c[i], i + 1));
else
pen.push_back(pair<int, int>(c[i], i + 1));
}
sort(tab.begin(), tab.end());
reverse(tab.begin(), tab.end());
while ((int)(tab).size() > k) {
pen.push_back(tab.back());
tab.pop_back();
}
sort(pen.begin(), pen.end());
reverse(pen.begin(), pen.end());
long long ans = 0;
int from = k - (int)(tab).size();
for (int i = (0), _b(from); i < _b; i++) {
res[i].push_back(pen.back().second);
ans += 2LL * pen.back().first;
pen.pop_back();
}
reverse(pen.begin(), pen.end());
for (int i = (0), _b((int)(tab).size()); i < _b; i++) {
res[from + i].push_back(tab[i].second);
ans += (long long)tab[i].first;
while ((int)(pen).size() && pen.back().first >= tab[i].first) {
res[from + i].push_back(pen.back().second);
ans += 2LL * c[res[from + i].back() - 1];
pen.pop_back();
}
}
if (!from) {
reverse(res[k - 1].begin(), res[k - 1].end());
while ((int)(pen).size()) {
ans += c[res[k - 1].back() - 1];
res[k - 1].push_back(pen.back().second);
ans += c[res[k - 1].back() - 1];
pen.pop_back();
}
} else
while ((int)(pen).size()) {
ans += 2LL * pen.back().first;
res[0].push_back(pen.back().second);
pen.pop_back();
}
printf("%I64d.%d\n", ans / 2, (ans % 2) * 5);
for (int i = (0), _b(k); i < _b; i++) {
printf("%d", (int)(res[i]).size());
for (int j = (0), _b((int)(res[i]).size()); j < _b; j++)
printf(" %d", res[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 5e5 + 10;
long long n, k, c[N], t[N];
vector<long long> ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
int dis = 0;
vector<pair<long long, int>> v, rk;
for (int i = 0; i < n; i++) {
cin >> c[i] >> t[i];
if (t[i] == 1) {
dis++;
v.push_back({c[i], i});
} else
rk.push_back({c[i], i});
}
sort(v.rbegin(), v.rend());
double res = 0.0;
if (dis >= k) {
for (int i = 0; i < k - 1; i++) {
ans[i].push_back(v[i].second);
res += (v[i].first / 2.0);
}
long long mn = 1e18;
for (int i = k - 1; i < (int)v.size(); i++) {
ans[k - 1].push_back(v[i].second);
res += v[i].first * 1.0;
mn = min(mn, v[i].first);
}
for (auto it : rk) {
ans[k - 1].push_back(it.second);
res += it.first * 1.0;
mn = min(mn, it.first);
}
res -= mn / 2.0;
} else {
for (int i = 0; i < (int)v.size(); i++) {
ans[i].push_back(v[i].second);
res += (v[i].first / 2.0);
}
int indx = 0;
for (int i = (int)v.size(); i < k; i++) {
ans[i].push_back(rk[indx].second);
res += (rk[indx++].first) * 1.0;
}
for (int i = indx; i < (int)rk.size(); i++) {
ans[k - 1].push_back(rk[i].second);
res += (rk[i].first) * 1.0;
}
}
cout << setprecision(1) << fixed << res << endl;
for (int i = 0; i < k; i++) {
auto &it = ans[i];
cout << it.size() << " ";
for (auto it2 : it) cout << it2 + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long Inf = 1LL << 62;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1, 0};
const int dy[] = {0, 1, 0, -1, -1, 1, 1, -1, 0};
const double eps = 1e-9;
const double pi = 3.1415926535897932384626433832795;
template <class T>
inline bool eq(const T &a, const T &b) {
return fabs(a - b) < eps;
}
template <class T>
inline bool deg2(const T &n) {
return (n & (n - 1)) == 0;
}
template <class T>
inline void chmax(T &a, const T &b) {
a = max(a, b);
}
inline int intRand(int l, int r) {
return ((rand() << 16) | rand()) % (r - l + 1) + l;
}
inline long long llRand(long long l, long long r) {
return (((1ll * rand()) << 48) | ((1ll * rand()) << 32) | (rand() << 16) |
rand()) %
(r - l + 1) +
l;
}
vector<pair<int, int> > a, b;
vector<int> ans[1000];
double sum;
int n, m, k, cnt, i, j, c, t, mini = inf;
int main() {
ios_base::sync_with_stdio(false);
srand(time(NULL));
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d%d", &c, &t);
if (t == 1)
a.push_back(make_pair(c, i + 1));
else
b.push_back(make_pair(c, i + 1));
}
sort(a.rbegin(), a.rend());
n = (int)a.size();
sort(b.begin(), b.end());
m = (int)b.size();
k--;
if (n <= k) {
for (i = 0; i < n; i++) {
sum += a[i].first / 2.0;
ans[cnt++].push_back(a[i].second);
}
for (i = 0; i < k - n; i++) {
sum += b[i].first;
ans[cnt++].push_back(b[i].second);
}
assert(cnt == k);
for (i = k - n; i < m; i++) {
sum += b[i].first;
ans[cnt].push_back(b[i].second);
}
} else {
for (i = 0; i < k; i++) {
sum += a[i].first / 2.0;
ans[i].push_back(a[i].second);
}
for (i = k; i < n; i++) {
mini = min(mini, a[i].first);
sum += a[i].first;
ans[k].push_back(a[i].second);
}
for (i = 0; i < m; i++) {
mini = min(mini, b[i].first);
sum += b[i].first;
ans[k].push_back(b[i].second);
}
sum -= mini / 2.0;
}
printf("%.1lf\n", sum);
for (i = 0; i <= k; i++) {
n = (int)ans[i].size();
printf("%d ", n);
for (j = 0; j < n; j++) printf("%d ", ans[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
const long long LINF = (long long)1E18;
int INP, AM;
char BUF[(1 << 10) + 1], *inp = BUF;
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? abs(a) : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
const char DEBUG_PARAM[] = "__LOCAL_TESTING";
const char IN[] = "input.txt";
const char OUT[] = "output.txt";
int ntest = 0, test;
inline void init();
inline void run();
inline void stop() { ntest = test - 1; }
int main(int argc, char* argv[]) {
if (argc > 1 && strcmp(argv[1], DEBUG_PARAM) == 0) {
freopen(IN, "r", stdin);
}
init();
if (ntest == 0) {
puts("ntest = ?");
return 0;
}
for (test = 1; test <= ntest; test++) {
run();
}
return 0;
}
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const long double EPS = 1E-9;
const long long MODULO = 1000000007LL;
inline void init() { ntest = 1; }
const int maxn = 1000 + 5;
vector<pair<int, int> > stool, pencil;
vector<int> res[maxn];
bool ok[maxn];
int cost[maxn];
int n, k;
double add(const vector<int>& r) {
bool dc = false;
double add = 0;
double minx = 1000000000;
for (typeof((r).begin()) it = (r).begin(); it != (r).end(); ++it) {
if (ok[*it]) dc = true;
add += cost[*it];
minx = min(minx, (double)cost[*it]);
}
if (dc) add -= minx / 2;
return add;
}
double cal() {
double r = 0;
for (int i = (1); i <= (k); i++) r += add(res[i]);
return r;
}
void solve() {
sort((stool).begin(), (stool).end());
sort((pencil).begin(), (pencil).end());
if (((int)(stool).size()) >= k) {
int s = ((int)(stool).size());
for (int i = (s - 1); i >= (0); i--) {
if (i - s + 1 + k > 0)
res[i - s + 1 + k].push_back(stool[i].second);
else {
res[1].push_back(stool[i].second);
}
}
for (typeof((pencil).begin()) it = (pencil).begin(); it != (pencil).end();
++it) {
res[1].push_back(it->second);
}
} else {
int s = ((int)(stool).size());
for (int i = 0; i < (s); i++) {
res[i + 1].push_back(stool[i].second);
}
for (int i = (s + 1); i <= (k); i++) {
res[i].push_back(pencil[i - s - 1].second);
}
for (int i = (k - s); i <= (((int)(pencil).size()) - 1); i++)
res[k].push_back(pencil[i].second);
}
printf("%.1lf\n", cal());
for (int i = (1); i <= (k); i++) {
cout << ((int)(res[i]).size()) << " ";
for (int j = 0; j < (((int)(res[i]).size())); j++) {
cout << res[i][j];
if (j != ((int)(res[i]).size()) - 1) cout << " ";
}
cout << endl;
}
}
inline void run() {
cin >> n >> k;
int c, t;
for (int i = (1); i <= (n); i++) {
cin >> c >> t;
cost[i] = c;
if (t == 1) {
stool.push_back(make_pair(c, i));
ok[i] = true;
} else
pencil.push_back(make_pair(c, i));
}
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > a[2000];
int main() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > tab;
deque<pair<long long, long long> > pen;
for (long long i = 0; i < n; i++) {
long long c, t;
cin >> c >> t;
if (t == 1)
tab.push_back(make_pair(c, i));
else
pen.push_back(make_pair(c, i));
}
sort(tab.begin(), tab.end());
reverse(tab.begin(), tab.end());
for (long long i = 0; i < min(k, (long long)tab.size()); i++)
a[i].push_back(tab[i]);
if (k < tab.size()) {
for (long long i = k; i < tab.size(); i++) a[k - 1].push_back(tab[i]);
for (long long i = 0; i < pen.size(); i++) a[k - 1].push_back(pen[i]);
} else {
for (long long j = tab.size(); j < k && !pen.empty(); j++) {
a[j].push_back(pen[0]);
pen.pop_front();
}
while (!pen.empty()) {
a[k - 1].push_back(pen[0]);
pen.pop_front();
}
}
double ans = 0;
for (long long i = 0; i < k; i++) {
long long mi = 2000000000;
bool ok = false;
if (i < tab.size()) ok = true;
double s = 0;
for (long long j = 0; j < a[i].size(); j++) {
s += a[i][j].first;
mi = min(mi, a[i][j].first);
}
ans += s;
if (ok) ans -= (mi + .0) / 2.0;
}
cout.precision(1);
cout << fixed << ans << endl;
for (long long i = 0; i < k; i++) {
cout << a[i].size() << " ";
for (long long j = 0; j < a[i].size(); j++)
cout << a[i][j].second + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int id, price, type;
data(int x, int y, int z) {
id = x;
price = y;
type = z;
}
bool operator<(const data &d) const {
if (d.price < price) {
return true;
}
if (d.price == price) {
return true;
}
return false;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<data> V;
int cnt = 0;
vector<pair<int, pair<int, int> > > S;
for (int i = 1; i <= n; i++) {
int c, t;
cin >> c >> t;
if (t == 1) {
++cnt;
S.push_back({c, {t, i}});
continue;
}
data D(i, c, t);
V.push_back(D);
}
sort(V.begin(), V.end());
sort(S.begin(), S.end());
int X = min(k - 1, cnt);
long double cost = 0.0;
vector<int> ans[1005];
int pos = 1;
int tot = 0;
int Y = X;
while (X--) {
int c = S.back().first;
int i = S.back().second.second;
ans[pos].push_back(i);
cost += (double)c / 2.00;
tot++;
pos++;
S.pop_back();
}
int kk = k;
if (S.size()) {
int mn = 1e8;
mn = min(S.front().first, ((V.size()) ? V.back().price : (int)1e8));
cost += (double)mn / 2.00;
if (S.front().first == mn) {
ans[pos].push_back(S.front().second.second);
for (int i = 1; i < S.size(); i++) {
cost += S[i].first;
ans[pos].push_back(S[i].second.second);
}
for (int i = 0; i < V.size(); i++) {
cost += V[i].price;
ans[pos].push_back(V[i].id);
}
} else {
ans[pos].push_back(V.back().id);
V.pop_back();
for (int i = 0; i < S.size(); i++) {
cost += S[i].first;
ans[pos].push_back(S[i].second.second);
}
for (int i = 0; i < V.size(); i++) {
cost += V[i].price;
ans[pos].push_back(V[i].id);
}
}
} else {
k -= Y;
int rem = (n - tot) / k + ((n - tot) % k);
int c = 0;
bool flag = false;
for (int i = 0; i < V.size(); i++) {
cost += V[i].price;
c++;
ans[pos].push_back(V[i].id);
if (c >= rem) {
if (!flag) {
rem -= ((n - tot) % k);
flag = true;
}
c = 0;
pos++;
}
}
}
cout << fixed << setprecision(1) << cost << endl;
for (int i = 1; i <= pos; i++) {
if (ans[i].size() == 0) {
continue;
}
cout << ans[i].size() << " ";
for (auto ii : ans[i]) {
cout << ii << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
typedef struct tov {
long long p;
long long typ;
long long num;
} tov;
tov a[1010];
long long ans[1010][1010];
long long lens[1010];
long long n, k;
int main(void) {
int i, j;
scanf("%I64d%I64d", &n, &k);
for (i = 0; i < n; ++i) {
scanf("%I64d%I64d", &a[i].p, &a[i].typ);
a[i].num = i + 1;
}
for (i = 0; i < n; ++i) {
for (j = 0; j < n - i - 1; ++j) {
if (a[j].p < a[j + 1].p) {
tov tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
}
long long p = 0, answ1 = 0, answ2 = 0, bad;
for (i = 0; i < n; ++i) {
if (p == k) {
break;
}
if (a[i].typ == 1) {
ans[p][lens[p]++] = a[i].num;
++p;
answ1 += a[i].p;
if (p == k) {
bad = a[i].p;
}
a[i].p = -1;
}
}
if (p == k) {
for (i = 0; i < n; ++i) {
if (a[i].p > 0) {
ans[k - 1][lens[k - 1]++] = a[i].num;
answ2 += a[i].p;
}
}
if (a[n - 1].p > 0) {
answ1 -= bad;
answ2 += bad;
answ1 += a[n - 1].p;
answ2 -= a[n - 1].p;
}
} else {
for (i = 0; i < n; ++i) {
if (p == k) {
break;
}
if (a[i].typ == 2) {
ans[p][lens[p]++] = a[i].num;
answ2 += a[i].p;
++p;
}
}
for (; i < n; ++i) {
if (a[i].typ == 2) {
ans[k - 1][lens[k - 1]++] = a[i].num;
answ2 += a[i].p;
}
}
}
printf("%I64d", answ2 + answ1 / 2);
if (answ1 % 2 == 1) {
printf(".5\n");
} else {
printf(".0\n");
}
for (i = 0; i < k; ++i) {
printf("%I64d ", lens[i]);
for (j = 0; j < lens[i]; ++j) {
printf("%I64d ", ans[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> st[1234], pen[1234];
int val[1234];
int typ[1234];
int main() {
int n, k;
int ss = 0, sp = 0;
int i;
scanf("%d%d", &n, &k);
int c, t;
for (i = 0; i < n; i++) {
scanf("%d%d", &c, &t);
val[i + 1] = c;
typ[i + 1] = t;
if (t == 1) {
st[ss++] = make_pair(c, i + 1);
} else {
pen[sp++] = make_pair(c, i + 1);
}
}
sort(st, st + ss, greater<pair<int, int> >());
sort(pen, pen + sp, greater<pair<int, int> >());
vector<vector<int> > car(k);
for (i = 0; i < ss && i < k; i++) {
car[i].push_back(st[i].second);
}
for (; i < ss; i++) {
car[k - 1].push_back(st[i].second);
}
int j;
for (j = k - 1; sp > 0 && car[j].empty(); sp--, j--) {
car[j].push_back(pen[sp - 1].second);
}
for (i = 0; i < sp; i++) {
car[k - 1].push_back(pen[i].second);
}
long long ans = 0;
int m;
int odd = 0;
for (i = 0; i < k; i++) {
m = val[car[i][0]];
t = 0;
for (j = 0; j < (int)car[i].size(); j++) {
m = min(m, val[car[i][j]]);
ans += val[car[i][j]];
if (typ[car[i][j]] == 1) t = 1;
}
if (t) {
ans -= m;
ans += m / 2;
if (m & 1) odd++;
}
}
cout << (ans + odd / 2) << '.' << ((odd & 1) ? 5 : 0) << endl;
for (i = 0; i < k; i++) {
cout << car[i].size();
for (j = 0; j < (int)car[i].size(); j++) {
cout << ' ' << car[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print_width(long long x) {
std::cout << std::fixed;
std::cout << std::setprecision(x);
}
long long power(long long x, long long y, long long p = 1000000007) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void printArr(long long a[], long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
void printVector(std::vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
long long Min(long long a, long long b, long long c) {
if (a < b and a < c) return a;
if (b < c) return b;
return c;
}
void initialize(long long arr[], long long n) {
for (long long i = 0; i <= n; i++) arr[i] = i;
}
long long root(long long arr[], long long i) {
while (arr[i] != i) {
arr[i] = arr[arr[i]];
i = arr[i];
}
return i;
}
void Union(long long arr[], long long a, long long b) {
long long root_a = root(arr, a);
long long root_b = root(arr, b);
arr[root_a] = root_b;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power_wm(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long double dpower(long double x, long long y) {
long double res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
print_width(1);
long double n, k;
cin >> n >> k;
vector<pair<long double, long double>> s, p;
long double cost = 0;
for (long long i = 0; i < n; i++) {
long double c, t;
cin >> c >> t;
if (t == 1) {
s.push_back(make_pair(c, i + 1));
} else {
p.push_back(make_pair(c, i + 1));
cost += c;
}
}
sort(s.begin(), s.end(), greater<pair<long long, long long>>());
;
sort(p.begin(), p.end(), greater<pair<long long, long long>>());
;
if (s.size() == 0) {
cout << cost << endl;
print_width(0);
long long rem = k - s.size();
for (long long i = 0; i < rem - 1; i++) {
cout << 1 << " ";
cout << p[i].second << " ";
cout << endl;
}
cout << p.size() - (rem - 1) << " ";
for (long long i = 0; i < p.size() - (rem - 1); i++)
cout << p[p.size() - i - 1].second << " ";
return 0;
}
if (p.size() > 0 and (p[p.size() - 1].first < s[s.size() - 1].first) and
s.size() >= k) {
cost -= (p[p.size() - 1].first / 2);
cost += (s[s.size() - 1].first);
} else {
cost += (s[s.size() - 1].first / 2);
}
for (long long i = 0; i < s.size() - 1; i++) {
if ((i + 1) < k) {
cost += (s[i].first / 2);
} else {
cost += (s[i].first);
}
}
cout << cost << endl;
print_width(0);
if (s.size() >= k) {
cout << p.size() + 1 + (s.size() - k) << " ";
cout << s[s.size() - 1].second << " ";
for (long long i = 0; i < p.size(); i++) cout << p[i].second << " ";
if (s.size() > k)
for (long long j = k - 1; j <= s.size() - 2; j++)
cout << s[j].second << " ";
cout << endl;
for (long long i = 0; i < k - 1; i++) {
cout << 1 << " ";
cout << s[i].second << " ";
cout << endl;
}
} else {
long long rem = k - s.size();
for (long long i = 0; i < s.size(); i++) {
cout << 1 << " ";
cout << s[i].second << " ";
cout << endl;
}
for (long long i = 0; i < rem - 1; i++) {
cout << 1 << " ";
cout << p[i].second << " ";
cout << endl;
}
cout << p.size() - (rem - 1) << " ";
for (long long i = 0; i < p.size() - (rem - 1); i++)
cout << p[p.size() - i - 1].second << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[1001], t[1001];
vector<pair<int, int> > st, pe;
vector<int> C[1001];
int main() {
int n, k;
long long sum_disc = 0, sum = 0;
scanf("%d%d", &n, &k);
for (int i = (0); i <= (int(n) - 1); ++i) scanf("%d%d", &c[i], &t[i]);
for (int i = (0); i <= (int(n) - 1); ++i) {
if (t[i] == 1)
st.push_back(make_pair(c[i], i));
else
pe.push_back(make_pair(c[i], i));
sum += c[i];
}
sort(st.begin(), st.end());
sort(pe.begin(), pe.end());
int S = st.size(), P = pe.size();
if (S < k) {
for (int i = (0); i <= (int(S) - 1); ++i) {
sum_disc += st[i].first;
C[i].push_back(st[i].second);
}
S--;
for (int i = (0); i <= (int(P) - 1); ++i) {
if (S + 1 < k) S++;
C[S].push_back(pe[i].second);
}
} else {
int pos = S - k;
for (int i = 1; i < k; i++) {
sum_disc += st[pos + i].first;
C[i].push_back(st[i + pos].second);
}
for (int i = 0; i <= pos; i++) {
C[0].push_back(st[i].second);
}
for (int i = (0); i <= (int(P) - 1); ++i) {
C[0].push_back(pe[i].second);
}
int ch = st[0].first;
if (pe.size() > 0) ch = min(st[0].first, pe[0].first);
sum_disc += ch;
}
long long pr = sum * 2 - sum_disc;
cout << pr / 2 << "." << 5 * (pr % 2) << endl;
for (int i = (0); i <= (int(k) - 1); ++i) {
cout << C[i].size();
for (typeof(C[i].begin()) j = C[i].begin(); j != C[i].end(); ++j)
cout << " " << *j + 1;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p[1005], q[1005];
vector<pair<long long, int> > x[3], a[1005];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> p[i] >> q[i];
x[q[i]].push_back(make_pair(p[i], i));
}
sort(x[1].begin(), x[1].end());
reverse(x[1].begin(), x[1].end());
int m = min(k - 1, int(x[1].size()));
for (int i = 0; i < m; ++i) a[i].push_back(x[1][i]);
int j = min(m, k - 1);
for (int i = m; i < x[1].size(); ++i)
a[j].push_back(x[1][i]), j = min(j + 1, k - 1);
for (int i = 0; i < x[2].size(); ++i)
a[j].push_back(x[2][i]), j = min(j + 1, k - 1);
long double ans = 0;
for (int i = 0; i < k; ++i) {
long long mini = (long long)(1e9), sum = 0;
bool d = 0;
for (int j = 0; j < a[i].size(); ++j) {
sum += a[i][j].first, mini = min(mini, a[i][j].first);
d = d || q[a[i][j].second] == 1;
}
if (d)
ans += sum - mini * 0.5;
else
ans += sum;
}
cout << setprecision(1) << fixed << ans << endl;
for (int i = 0; i < k; ++i) {
cout << a[i].size();
for (int j = 0; j < a[i].size(); ++j) cout << " " << a[i][j].second;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, sl, pl, c, t;
vector<pair<int, int> > ans[1000];
pair<int, int> st[1000], pen[1000];
double cost;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> c >> t;
if (t == 1)
st[sl++] = make_pair(c, i + 1);
else
pen[pl++] = make_pair(c, i + 1);
}
sort(st, st + sl, greater<pair<int, int> >());
sort(pen, pen + pl, greater<pair<int, int> >());
for (int i = 0; i < sl && i < k; ++i) {
ans[i].push_back(st[i]);
if (i == k - 1) {
for (++i; i < sl; ++i) ans[k - 1].push_back(st[i]);
} else
cost += double(st[i].first) / 2.0;
}
for (int i = k - 1, j = 0; i >= 0 && j < pl; --i, ++j) {
if (i && ans[i - 1].size() || ans[i].size() || i == 0) {
for (; j < pl; ++j) {
cost += pen[j].first;
ans[i].push_back(pen[j]);
ans[i].back().second *= -1;
}
} else {
ans[i].push_back(pen[j]);
cost += pen[j].first;
}
}
if (k <= sl) {
int mm = ans[k - 1][0].first;
cost += mm;
for (int i = 1; i < ans[k - 1].size(); ++i) {
if (ans[k - 1][i].second >= 0) cost += ans[k - 1][i].first;
mm = min(mm, ans[k - 1][i].first);
}
cost -= double(mm) / 2.0;
}
cout << setprecision(1) << fixed << cost << endl;
for (int i = 0; i < k; ++i) {
cout << ans[i].size();
for (int j = 0; j < ans[i].size(); ++j)
cout << " " << abs(ans[i][j].second);
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int c[N];
bool cmp(int a, int b) { return c[a] > c[b]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<int> a, b;
for (int i = 1; i <= n; i++) {
int t;
cin >> c[i] >> t;
if (t == 1)
a.push_back(i);
else
b.push_back(i);
}
sort((a).begin(), (a).end(), cmp);
double sum = 0;
int mn = INT_MAX, t = k;
for (int i = 0; i < (int)(a).size(); i++) {
if (t > 1)
sum += c[a[i]] / 2.0, --t;
else
mn = min(mn, c[a[i]]), sum += c[a[i]];
}
for (int i = 0; i < (int)(b).size(); i++)
mn = min(mn, c[b[i]]), sum += c[b[i]];
if ((int)(a).size() >= k) sum -= mn / 2.0;
cout << fixed << setprecision(1) << sum << '\n';
if ((int)(a).size() < k) {
for (int i = 0; i < (int)(a).size(); i++) cout << 1 << ' ' << a[i] << '\n';
for (int i = 0; i < (int)(b).size(); i++) {
if (t > 1)
--t, cout << 1 << ' ' << b[i] << '\n';
else if (t == 1) {
cout << (int)(b).size() - i << ' ' << b[i] << ' ';
--t;
} else
cout << b[i] << " \n"[i == (int)(b).size() - 1];
}
} else {
for (int i = 0; i < k - 1; i++) cout << 1 << ' ' << a[i] << '\n';
cout << (int)(b).size() + (int)(a).size() - (k - 1) << ' ';
for (int i = k - 1; i < (int)(a).size(); i++) cout << a[i] << ' ';
for (int i = 0; i < (int)(b).size(); i++)
cout << b[i] << " \n"[i == (int)(b).size() - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1111, MAXK = 1111;
int N, K;
vector<pair<int, int> > s, p;
vector<pair<int, int> > cart[MAXK];
vector<bool> has_stool;
int main() {
scanf("%d %d", &N, &K);
for (int i = 0; i < K; i++) has_stool.push_back(false);
for (int i = 0; i < N; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (b == 1)
s.push_back(make_pair(a, i + 1));
else
p.push_back(make_pair(a, i + 1));
}
sort(s.begin(), s.end());
sort(p.begin(), p.end());
for (int i = s.size() - 1, j = 0; i >= 0; i--) {
cart[j].push_back(s[i]);
has_stool[j] = true;
j++;
if (j >= K) j = K - 1;
}
for (int i = p.size() - 1, j = min((int)s.size(), K - 1); i >= 0; i--) {
cart[j].push_back(p[i]);
j++;
if (j >= K) j = K - 1;
}
long long price = 0;
for (int i = 0; i < K; i++) {
sort(cart[i].begin(), cart[i].end());
for (int j = 0; j < cart[i].size(); j++) price += 2 * cart[i][j].first;
if (has_stool[i]) price -= cart[i][0].first;
}
if (price % 2 == 1)
cout << (price / 2) << ".5" << endl;
else
cout << (price / 2) << ".0" << endl;
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].second);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > a;
int used[1010];
vector<vector<pair<int, int> > > g;
vector<pair<int, int> > tabs;
int cost[1010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
a.resize(n);
g.resize(k);
for (int i = (0); i < (n); ++i) {
scanf("%d%d", &a[i].first.first, &a[i].first.second);
a[i].first.first *= 2;
cost[i] = a[i].first.first;
a[i].second = i + 1;
}
sort(a.begin(), a.end());
int to = 0;
for (int i = n - 1; i >= 0; --i) {
if (tabs.size() == k) break;
if (a[i].first.second == 1) {
tabs.push_back(make_pair(a[i].first.first, to));
g[to].push_back(make_pair(a[i].first.first, a[i].second));
to++;
used[i] = 1;
}
}
for (int i = (0); i < (a.size()); ++i) {
if (to == k) break;
if (used[i] == 0) {
used[i] = 1;
g[to].push_back(make_pair(a[i].first.first, a[i].second));
to++;
}
}
for (int i = (0); i < (a.size()); ++i)
if (used[i] == 0)
g[k - 1].push_back(make_pair(a[i].first.first, a[i].second));
for (int i = (0); i < (g.size()); ++i) sort(g[i].begin(), g[i].end());
long long sum = 0;
for (int i = (0); i < (g.size()); ++i) {
for (int j = (0); j < (g[i].size()); ++j) {
int to = g[i][j].second;
if ((i < tabs.size()) && (j == 0))
sum += g[i][j].first / 2;
else
sum += g[i][j].first;
}
}
double res = sum / 2.0;
printf("%.1lf\n", res);
for (int i = (0); i < (g.size()); ++i) {
printf("%d", g[i].size());
for (int j = (0); j < (g[i].size()); ++j) {
int to = g[i][j].second;
printf(" %d", to);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pr {
int f, s;
pr(int fr = 0, int sd = 0) { f = fr, s = sd; }
bool operator<(const pr& p) const { return f < p.f; }
};
pr tb[1005];
pr pn[1005];
int ct = 0, cp = 0;
vector<int> a[1005];
double res = 0;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int cst, tp;
scanf("%d%d", &cst, &tp);
if (tp == 1) {
tb[ct].f = cst;
tb[ct].s = i + 1;
ct++;
} else {
pn[cp].f = cst;
pn[cp].s = i + 1;
cp++;
}
}
sort(tb, tb + ct);
sort(pn, pn + cp);
if (k > ct) {
for (int i = 0; i < ct; i++) {
a[i].push_back(tb[i].s);
res += tb[i].f / 2.0;
}
for (int i = 0, j = ct; i < cp; i++, j++) {
if (j == k) j = ct;
res += pn[i].f;
a[j].push_back(pn[i].s);
}
} else {
for (int i = 0; i < k - 1; i++) {
a[i].push_back(tb[ct - i - 1].s);
res += tb[ct - i - 1].f / 2.0;
}
for (int i = 0; i < cp; i++) {
a[k - 1].push_back(pn[i].s);
res += pn[i].f;
}
for (int i = 0; i < ct - (k - 1); i++) {
a[k - 1].push_back(tb[i].s);
res += tb[i].f;
}
int m1 = 1000000001;
int m2 = 1000000001;
if (ct > 0) m1 = tb[0].f;
if (cp > 0) m2 = pn[0].f;
res -= min(m1, m2) / 2.0;
}
printf("%.1lf\n", res);
for (int i = 0; i < k; i++) {
printf("%d ", a[i].size());
for (int j = 0; j < a[i].size(); j++) printf("%d ", a[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5005;
const int Maxl = 26;
char a[Maxn], b[Maxn];
int alen, blen;
int freq[Maxl];
bool Possible(int pos) {
int cur = Maxl - 1, tk = 0;
for (int i = pos; i < blen; i++) {
while (cur >= 0 && tk == freq[cur]) {
cur--;
tk = 0;
}
if (cur > b[i] - 'a') return true;
if (cur < b[i] - 'a') return false;
tk++;
}
while (cur >= 0 && tk == freq[cur]) {
cur--;
tk = 0;
}
return cur >= 0;
}
bool getMore(char lim, char &bet) {
for (bet = lim + 1; bet - 'a' < Maxl; bet++)
if (freq[bet - 'a']) return true;
return false;
}
void writeTo(int pos) {
for (int i = 0; i < Maxl; i++)
while (freq[i]--) a[pos++] = 'a' + i;
printf("%s\n", a);
}
int main() {
scanf("%s", a);
alen = strlen(a);
scanf("%s", b);
blen = strlen(b);
for (int i = 0; i < alen; i++) freq[a[i] - 'a']++;
if (!Possible(0))
printf("-1\n");
else {
for (int i = 0; i < blen; i++) {
if (freq[b[i] - 'a']) {
freq[b[i] - 'a']--;
if (Possible(i + 1)) {
a[i] = b[i];
continue;
} else
freq[b[i] - 'a']++;
}
char c;
if (getMore(b[i], c)) {
freq[c - 'a']--;
a[i] = c;
writeTo(i + 1);
return 0;
} else {
printf("-1\n");
return 0;
}
}
writeTo(blen);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c1[26];
int c2[26][5009];
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
for (int i = 0; i < s.length(); i++) {
c1[s[i] - 'a']++;
}
for (int i = 1; i <= t.length(); i++) {
c2[t[i - 1] - 'a'][i]++;
for (int j = 0; j < 26; j++) {
c2[j][i + 1] = c2[j][i];
}
}
for (int i = t.length() + 1; i <= 5000; i++) {
for (int j = 0; j < 26; j++) {
c2[j][i + 1] = c2[j][i];
}
}
if (s.length() > t.length()) {
bool ok = true;
for (int i = 0; i < 26; i++) {
if (c1[i] < c2[i][t.length()]) {
ok = false;
}
}
if (ok) {
cout << t;
for (int i = 0; i < 26; i++) {
while (c1[i] > c2[i][t.length()]) {
cout << char(i + 'a');
c1[i]--;
}
}
return 0;
}
}
for (int pos = s.length() - 1; pos >= 0; pos--) {
bool ok = true;
for (int i = 0; i < 26; i++) {
if (c1[i] < c2[i][pos]) {
ok = false;
}
}
if (!ok) continue;
for (int i = 0; i < 26; i++) {
c1[i] -= c2[i][pos];
}
int j = t[pos] - 'a' + 1;
while (j < 26 && !c1[j]) j++;
if (j == 26) {
for (int i = 0; i < 26; i++) {
c1[i] += c2[i][pos];
}
continue;
}
c1[j]--;
for (int k = 0; k < pos; k++) {
cout << t[k];
}
cout << char(j + 'a');
for (int i = 0; i < 26; i++) {
while (c1[i]) {
cout << char(i + 'a');
c1[i]--;
}
}
return 0;
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class first>
inline bool checkbit(T a, first pos) {
T t = 1;
return ((a & (t << pos)) > 0);
}
template <class T, class first>
inline T setbit(T a, first pos) {
T t = 1;
return (a | (t << pos));
}
template <class T, class first>
inline T resetbit(T a, first pos) {
T t = 1;
return (a & (~(t << pos)));
}
template <class T, class first>
inline T togglebit(T a, first pos) {
T t = 1;
return (a ^ (t << pos));
}
template <typename T>
T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
T Bigmod(T base, T power, T mod) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % mod;
base = (base * base) % mod;
power >>= 1;
}
return ret;
}
template <typename T>
T ModInverse(T number, T mod) {
return Bigmod(number, mod - 2, mod);
}
template <typename T>
T GCD(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
double DEG(double x) { return (180.0 * x) / ((2.0 * acos(0.0))); }
double RAD(double x) { return (x * (double)(2.0 * acos(0.0))) / (180.0); }
template <typename T>
T DIS(T x1, T y1, T x2, T y2) {
return sqrt((double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
template <class T>
inline bool setmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool setmax(T &a, T b) {
return a < b ? a = b, true : false;
}
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
char a[5007];
char b[5007];
int ase[27];
int cnt[27];
int main() {
scanf("%s", a + 1);
scanf("%s", b + 1);
int la = strlen(a + 1);
int lb = strlen(b + 1);
for (int i = 1; i <= la; i++) ase[a[i] - 'a']++;
int pos = -1;
int let = -1;
for (int i = 1; i <= lb; i++) {
bool flag = 1;
for (int j = 0; j <= 25; j++)
if (ase[j] < cnt[j]) {
flag = 0;
break;
}
if (flag)
for (int j = 0; j <= 25; j++)
if (ase[j] - cnt[j] > 0 && (j + 'a') > b[i]) {
pos = i;
let = j;
break;
}
cnt[b[i] - 'a']++;
}
bool flag = 1;
for (int i = 0; i <= 25; i++)
if (ase[i] < cnt[i]) {
flag = 0;
break;
}
if (flag && la > lb) {
for (int i = 1; i <= lb; i++) cout << b[i], ase[b[i] - 'a']--;
for (int i = 0; i <= 25; i++)
for (int j = 1; j <= ase[i]; j++) cout << char(i + 'a');
puts("");
;
return 0;
}
if (pos == -1)
cout << -1 << endl;
else {
for (int i = 1; i <= pos - 1; i++) {
cout << b[i];
ase[b[i] - 'a']--;
}
cout << char(let + 'a');
if (let >= 0) ase[let]--;
for (int i = 0; i <= 25; i++)
for (int j = 1; j <= ase[i]; j++) cout << char(i + 'a');
puts("");
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
char s1[maxn], s2[maxn];
char ans[maxn];
int num[30], cnt;
bool cmp(char a, char b) { return a > b; }
void print() {
for (int i = 0; i < cnt; i++) printf("%c", ans[i]);
for (int i = 0; i < 26; i++) {
while (num[i]--) printf("%c", 'a' + i);
}
printf("\n");
return;
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
int len = strlen(s1);
sort(s1, s1 + len, cmp);
if (strcmp(s1, s2) <= 0) {
printf("-1\n");
return 0;
}
for (int i = 0; i < len; i++) num[s1[i] - 'a']++;
len = strlen(s2);
cnt = 0;
for (int i = 0; i < len; i++) {
if (num[s2[i] - 'a']) {
ans[cnt++] = s2[i];
num[s2[i] - 'a']--;
} else {
for (int j = s2[i] - 'a' + 1; j < 26; j++) {
if (num[j]) {
ans[cnt++] = 'a' + j;
num[j]--;
print();
return 0;
}
}
for (int j = cnt - 1; j >= 0; j--) {
num[s2[j] - 'a']++;
for (int k = s2[j] - 'a' + 1; k < 26; k++) {
if (num[k]) {
ans[cnt - 1] = 'a' + k;
num[k]--;
print();
return 0;
}
}
cnt--;
}
}
}
if (strlen(s1) > len) {
print();
return 0;
}
for (int j = len - 1; j >= 0; j--) {
num[s2[j] - 'a']++;
for (int k = s2[j] - 'a' + 1; k < 26; k++) {
if (num[k]) {
ans[j] = 'a' + k;
num[k]--;
print();
return 0;
}
}
cnt--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int cnt[30];
int main() {
cin >> s1 >> s2;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < s1.length(); i++) {
cnt[s1[i] - 'a']++;
}
string ans = "";
for (int i = 0; i < s2.length(); i++) {
int k = -1;
for (int j = s2[i] - 'a'; j <= 25; j++) {
if (cnt[j] > 0) {
k = j;
break;
}
}
if (k == -1) {
break;
}
if (k == s2[i] - 'a') {
cnt[k]--;
string tmp = "";
for (int j = 25; j >= 0; j--) {
for (int k = 0; k < cnt[j]; k++) {
tmp += (j + 'a');
}
}
cnt[k]++;
if (i == s2.length() - 1 || s2.substr(i + 1, s2.length()) < tmp) {
ans += (k + 'a');
cnt[k]--;
} else {
k = -1;
for (int j = s2[i] - 'a' + 1; j <= 25; j++) {
if (cnt[j] > 0) {
k = j;
break;
}
}
if (k == -1) {
break;
}
ans += (k + 'a');
cnt[k]--;
break;
}
} else {
ans += (k + 'a');
cnt[k]--;
break;
}
}
for (int i = 0; i < 26; i++) {
for (int j = 0; j < cnt[i]; j++) {
ans += (i + 'a');
}
}
if (ans > s2) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnts[333];
int cntt[333];
int main() {
string s, t;
cin >> s >> t;
t.push_back('a' - 1);
for (auto c : t) {
cntt[c]++;
}
for (auto c : s) {
cnts[c]++;
}
for (int i = (int)t.size() - 1; i >= 0; i--) {
cntt[t[i]]--;
int f = 1;
for (int c = 'a' - 1; c <= 'z'; c++) {
if (cntt[c] > cnts[c]) {
f = 0;
break;
}
}
if (!f) continue;
for (int c = t[i] + 1; c <= 'z'; c++) {
if (cntt[c] < cnts[c]) {
f = c;
break;
}
}
if (f > 1) {
cout << t.substr(0, i);
cout << (char)f;
for (int i = 0; i < 333; i++) {
cnts[i] -= cntt[i];
}
cnts[f]--;
for (int i = 0; i < 333; i++) {
while (cnts[i]--) {
cout << (char)i;
}
}
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 7;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const double EPS = 1e-8;
int c[26];
char s[N], t[N];
void count(int n, char s[], int c[]) {
memset(c, 0, sizeof(c[0]) * 26);
for (int i = (0); i < (n); ++i) ++c[s[i] - 'a'];
}
void solve() {
int n = strlen(s), m = strlen(t), L = -1, last = -1;
count(n, s, c);
for (int i = (0); i < (min(n, m)); ++i) {
for (int j = (t[i] - 'a' + 1); j < (26); ++j)
if (c[j] > 0) {
L = i;
break;
}
if (!c[t[i] - 'a']) break;
--c[t[i] - 'a'], last = i;
}
if (n > m && last == m - 1) L = m;
if (L == -1) {
puts("-1");
return;
}
count(n, s, c);
for (int i = (0); i < (L); ++i) putchar(t[i]), --c[t[i] - 'a'];
for (int j = (0); j < (26); ++j)
if (c[j] > 0 && ('a' + j) > t[L]) {
putchar('a' + j), --c[j];
break;
}
for (int i = (L + 1); i < (n); ++i)
for (int j = (0); j < (26); ++j)
if (c[j] > 0) {
putchar('a' + j), --c[j];
break;
}
}
int main() {
scanf("%s %s", s, t);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int lft[26];
char s[111111], t[111111];
int n, m;
int main() {
gets(s);
n = (int)strlen(s);
for (int i = 0; i < n; ++i) lft[s[i] - 'a']++;
gets(t);
m = (int)strlen(t);
for (int i = 0; i < n; ++i) {
bool fnd = 0;
for (int let = 0; let < 26; ++let) {
if (!lft[let]) continue;
s[i] = 'a' + let;
lft[let]--;
int pos = i + 1;
for (int j = 25; j >= 0; --j) {
for (int k = 0; k < lft[j]; ++k) s[pos++] = 'a' + j;
}
s[n] = 0;
if (strcmp(s, t) == 1) {
fnd = 1;
break;
}
lft[let]++;
}
if (!fnd) {
cout << "-1\n";
return 0;
}
}
puts(s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iINF = 0x3f3f3f3f;
const long long lINF = 0x3f3f3f3f3f3f3f3f;
inline void read(long long& x) {
int f = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (f = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= f;
}
inline void read(int& x) {
long long t;
read(t);
x = t;
}
const int MAXN = 6000;
string s, t;
int lens;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s >> t;
lens = s.length();
for (int i = 0; i < lens; i++) {
for (int j = i; j < lens; j++) {
if (s[j] == t[i]) {
swap(s[i], s[j]);
break;
}
}
if (s[i] == t[i]) {
sort(s.begin() + i + 1, s.end(), greater<char>());
if (s > t) continue;
}
int pos = -1;
for (int j = i; j < lens; j++)
if (s[j] > t[i] && (pos == -1 || s[j] < s[pos])) pos = j;
if (pos == -1) {
cout << -1 << endl;
return 0;
}
swap(s[i], s[pos]);
sort(s.begin() + i + 1, s.end());
break;
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 5010;
char s[MAXN], t[MAXN];
int fac[30];
int len;
bool is_ok(int i) {
int nn[30];
for (int i = 0; i < 26; i++) nn[i] = fac[i];
int c = 25;
for (; i < len; i++) {
while (nn[c] == 0 && c >= 0) c--;
s[i] = c + 'a';
nn[c]--;
}
s[len] = 0;
return strcmp(s, t) > 0;
}
void solve() {
int c;
for (int i = 0; i < len; i++) {
for (c = 0; c < 26; c++) {
if (fac[c] == 0) continue;
if (c + 'a' < t[i]) continue;
fac[c]--;
s[i] = c + 'a';
if (is_ok(i + 1)) {
break;
}
fac[c]++;
}
if (s[i] > t[i]) {
for (i++; i < len; i++) {
for (c = 0; c < 26; c++) {
if (fac[c] != 0) {
s[i] = c + 'a';
fac[c]--;
break;
}
}
}
break;
}
}
s[len] = 0;
printf("%s\n", s);
}
int main() {
while (scanf("%s %s", s, t) == 2) {
memset(fac, 0, sizeof(fac));
len = strlen(s);
for (int i = 0; s[i]; i++) {
fac[s[i] - 'a']++;
}
if (is_ok(0) == 0) {
printf("-1\n");
continue;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int n, m;
vector<int> A(26, 0), B;
string str;
bool poss(int till) {
str = "";
B = A;
for (int i = 0; i < till; i++) {
if (B[t[i] - 'a'] == 0) return false;
B[t[i] - 'a']--;
str += t[i];
}
if (till == n) return false;
if (till < m) {
bool found = false;
for (int i = t[till] - 'a' + 1; i < 26; i++) {
if (B[i] != 0) {
str += ('a' + i);
B[i]--;
found = true;
break;
}
}
if (!found) return false;
}
for (int i = 0; i < 26; i++) {
str += string(B[i], 'a' + i);
}
return true;
}
int main() {
cin >> s >> t;
n = s.size(), m = t.size();
int k = min(n, m);
for (int i = 0; i < n; i++) {
A[s[i] - 'a']++;
}
if (n >= m) {
if (poss(m)) {
if (str != t) {
cout << str << endl;
return 0;
}
}
}
for (int fd = k; fd >= 0; fd--) {
if (poss(fd)) {
cout << str << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, string> ma;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
string st, temp, fin = "abcdefghijklmnopqrstuvwxyz";
cin >> st >> temp;
long long int arr[30], i, j = 0, t = -1;
for (i = 0; i < 26; i++) ma[i] = fin[i];
for (i = 0; i <= 30; i++) arr[i] = 0;
for (i = 0; i < st.length(); i++) arr[st[i] - 'a']++;
fin = "";
for (long long int k = 26; k >= 0; k--) {
while (arr[k]) {
fin += ma[k];
arr[k]--;
}
}
if (fin <= temp) {
cout << "-1" << endl;
return 0;
}
fin = "";
for (i = 0; i < st.length(); i++) arr[st[i] - 'a']++;
for (i = 0; i < temp.length() && t == -1; i++) {
if (arr[temp[i] - 'a'] > 0) {
fin += temp[i];
arr[temp[i] - 'a']--;
} else {
j = (long long int)(temp[i] - 'a');
long long int bc;
for (; j < 30; j++) {
if (arr[j] != 0) {
fin += ma[j];
arr[j]--;
for (long long int k = 0; k < 26; k++) {
while (arr[k]) {
fin += ma[k];
arr[k]--;
}
}
cout << fin << endl;
return 0;
}
}
t = i;
break;
}
}
if (t == -1) {
if (st.length() > temp.length()) {
for (long long int k = 0; k < 26; k++) {
while (arr[k]) {
fin += ma[k];
arr[k]--;
}
}
cout << fin << endl;
return 0;
} else
t = temp.length();
}
if (t != -1) {
t--;
long long int ln = fin.length();
while (t >= 0) {
arr[temp[t] - 'a']++;
j = (long long int)(temp[t] - 'a') + 1;
for (; j < 26; j++) {
if (arr[j] > 0) {
fin[t++] = ma[j][0];
arr[j]--;
for (long long int km = 0; km < 26; km++) {
while (arr[km] > 0) {
arr[km]--;
if (t < ln)
fin[t++] = ma[km][0];
else
fin += ma[km];
}
}
cout << fin << endl;
return 0;
}
}
t--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long d3 = 1000;
const long d4 = 10000;
const long d5 = 100000;
const long d6 = 1000000;
const long d7 = 10000000;
const long d8 = 100000000;
const long d9 = 1000000000;
int main() {
string s, t, answ = "";
long backup[128] = {};
for (int i = 0; i < 128; i++) {
backup[i] = 0;
}
cin >> s;
cin >> t;
long lenS = s.size();
long lenT = t.size();
if (lenT < lenS) {
t += '0';
lenT++;
}
for (long i = 0; i < lenS; i++) {
backup[s[i]]++;
}
bool fail = false;
bool solved = false;
for (long i = 0; (i < lenT) && (!fail) && (!solved); i++) {
if (backup[t[i]]) {
answ += t[i];
backup[t[i]]--;
} else {
for (char j = t[i] + 1; (j <= 'z') && (!solved); j++) {
if (backup[j]) {
solved = true;
backup[j]--;
answ += j;
}
}
fail = !solved;
}
}
if (solved) {
for (char i = 'a'; i <= 'z'; i++) {
for (int j = 0; j < backup[i]; j++) {
answ += i;
}
}
} else {
long lenA = answ.size();
for (int i = lenA - 1; (i >= 0) && (!solved); i--) {
backup[answ[i]]++;
answ = answ.substr(0, i);
for (char j = t[i] + 1; (j <= 'z') && (!solved); j++) {
if (backup[j]) {
solved = true;
backup[j]--;
answ += j;
}
}
}
if (solved) {
for (char i = 'a'; i <= 'z'; i++) {
for (int j = 0; j < backup[i]; j++) {
answ += i;
}
}
} else
answ = "-1";
}
cout << answ;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void calc(char *s, int *sum) {
for (int i = (0); i < (26); i++) sum[i] = 0;
int len = strlen(s);
for (int i = (0); i < (len); i++) {
sum[s[i] - 'a']++;
}
}
char s[110000], t[110000];
int main() {
while (scanf("%s %s", s, t) != EOF) {
int second[26], st[26];
calc(s, second);
calc(t, st);
bool can = true;
int more = 0;
for (int i = (0); i < (26); i++) {
if (second[i] < st[i]) can = false;
if (second[i] > st[i]) more++;
}
if (can && more > 0) {
int cnt = strlen(t);
for (int i = (0); i < (26); i++)
if (second[i] > st[i]) {
for (int j = (0); j < (second[i] - st[i]); j++) t[cnt++] = 'a' + i;
}
t[cnt] = 0;
cout << t << endl;
continue;
}
int lent = strlen(t);
for (int i = lent - 1; i >= 0; i--) {
st[t[i] - 'a']--;
bool can = true;
for (int j = (0); j < (26); j++)
if (second[j] < st[j]) can = false;
if (can == false) continue;
bool flag = false;
for (int j = (0); j < (26); j++)
if (j > t[i] - 'a' && second[j] > st[j]) {
flag = true;
second[j]--;
t[i] = 'a' + j;
int cnt = i + 1;
for (int i = (0); i < (26); i++)
if (second[i] > st[i]) {
for (int j = (0); j < (second[i] - st[i]); j++)
t[cnt++] = 'a' + i;
}
t[cnt] = 0;
cout << t << endl;
break;
}
if (flag) return 0;
}
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tab[26];
char a[5010], b[5010];
int len;
char c[5010];
int sol(int w) {
if (w == len) {
int ix = w;
for (int k = 0; k < 26; k++) {
int t = tab[k];
while (t) {
t--;
c[ix++] = k + 'a';
}
}
c[ix] = 0;
if (ix == w) return 0;
return 1;
}
int j = b[w] - 'a';
int ret;
if (tab[j]) {
c[w] = j + 'a';
tab[j]--;
ret = sol(w + 1);
tab[j]++;
}
if (!tab[j] || !ret) {
j++;
while (j < 26 && tab[j] == 0) {
j++;
}
if (j == 26) {
return 0;
} else {
c[w] = j + 'a';
tab[j]--;
int ix = w + 1;
for (int k = 0; k < 26; k++) {
int t = tab[k];
while (t) {
t--;
c[ix++] = k + 'a';
}
}
c[ix] = 0;
return 1;
}
}
return 1;
}
int main(int argc, char *argv[]) {
while (scanf("%s%s", a, b) != EOF) {
memset(tab, 0, sizeof(tab));
for (int i = 0; a[i] != 0; i++) {
tab[a[i] - 'a']++;
}
len = strlen(b);
if (!sol(0)) {
printf("-1\n");
} else {
printf("%s\n", c);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lb = 1000;
void vrikodara(long long n = 12) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(n) << fixed;
}
void solve() {
string s, t;
cin >> s >> t;
vector<long long> v1(26, 0), v2(26, 0);
for (auto i : s) v1[i - 'a']++;
for (auto i : t) v2[i - 'a']++;
long long n = t.length();
long long a = n;
if (s.length() <= n) {
a = s.length();
a--;
}
t += 55;
for (long long i = a - 1; i >= -1; i--) {
vector<long long> v = v1;
bool flag = true;
string ans = "";
for (long long j = 0; j <= i; j++) {
if (!v[t[j] - 'a']) {
flag = false;
break;
}
ans += t[j];
v[t[j] - 'a']--;
}
if (flag) {
char ch = t[i + 1];
flag = false;
for (long long i = 0; i < 26; i++) {
if (v[i] && (char)('a' + i) > ch) {
v[i]--;
char r = (char)(i + 'a');
ans += r;
for (long long i = 0; i < 26; i++) {
while (v[i]--) {
char r = (char)(i + 'a');
ans += r;
}
}
cout << ans;
return;
}
}
}
}
cout << "-1";
}
int32_t main() {
vrikodara();
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
t.push_back('a' - 1);
vector<int> have(256);
for (int i = 0; i < s.length(); ++i) ++have[s[i]];
int pref_len = 0;
for (int i = 0; i < t.length() - 1; ++i) {
if (!have[t[i]]) break;
--have[t[i]];
for (int j = t[i + 1] + 1; j <= 'z'; ++j) {
if (have[j]) {
pref_len = i + 1;
break;
}
}
}
fill(have.begin(), have.end(), 0);
for (int i = 0; i < s.length(); ++i) ++have[s[i]];
if (!pref_len) {
bool ok = false;
for (int j = t[0] + 1; j <= 'z'; ++j) {
if (have[j]) {
cout << char(j);
--have[j];
for (int i = 'a'; i <= 'z'; ++i) {
while (have[i]) {
cout << char(i);
--have[i];
}
}
ok = true;
break;
}
}
if (!ok) cout << -1;
} else {
for (int i = 0; i < pref_len; ++i) {
cout << t[i];
--have[t[i]];
}
for (int i = t[pref_len] + 1; i <= 'z'; ++i) {
if (have[i]) {
cout << char(i);
--have[i];
break;
}
}
for (int i = 'a'; i <= 'z'; ++i) {
while (have[i]) {
cout << char(i);
--have[i];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char sol[1000100], s[1000100], t[1000100];
int lit[1000100], n, m, K;
void back(int k, int eq) {
if (k > m || k > n) {
if (eq && n <= m) return;
for (int i = 'a'; i <= 'z'; ++i) {
for (int j = 1; j <= lit[i]; ++j) sol[k++] = i;
}
K = 1;
return;
}
if (eq) {
if (lit[t[k]]) {
sol[k] = t[k];
--lit[t[k]];
back(k + 1, eq);
if (K) return;
++lit[t[k]];
for (int i = t[k] + 1; i <= 'z'; ++i)
if (lit[i]) {
lit[i]--;
sol[k] = i;
back(k + 1, !eq);
if (K) return;
++lit[i];
return;
}
} else {
for (int i = t[k] + 1; i <= 'z'; ++i)
if (lit[i]) {
lit[i]--;
sol[k] = i;
back(k + 1, !eq);
if (K) return;
++lit[i];
return;
}
}
} else {
for (int i = 'a'; i <= 'z'; ++i)
if (lit[i]) {
lit[i]--;
sol[k] = i;
back(k + 1, eq);
if (K) return;
++lit[i];
return;
}
}
}
int main() {
cin >> (s + 1) >> (t + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) lit[s[i]]++;
m = strlen(t + 1);
back(1, 1);
if (K)
cout << (sol + 1);
else
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b, r;
int cnta[26], cntr[26];
void dfs(int k) {
for (int i = 0; i < 26; i++)
if (cnta[i] > 0 && 'a' + i > b[k]) {
r.assign(b, 0, k);
r.push_back('a' + i);
cnta[i]--;
memcpy(cntr, cnta, sizeof(cnta));
cnta[i]++;
break;
}
if (cnta[b[k] - 'a'] > 0) {
cnta[b[k] - 'a']--;
dfs(k + 1);
}
}
int main() {
cin >> a >> b;
for (int i = 0; i < a.size(); i++) cnta[a[i] - 'a']++;
dfs(0);
if (r.size()) {
for (int i = 0; i < 26; i++)
while (cntr[i]-- > 0) r.push_back('a' + i);
cout << r << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b, c;
string ans, temp;
int cnt[30];
int tcnt[30];
void con(int i, int n, int m) {
memset(tcnt, 0, sizeof tcnt);
if (i >= n) {
return;
}
bool q = 0;
if (i < m)
for (int j = b[i] - 'a' + 1; j < 30; j++) {
if (cnt[j] > tcnt[j]) {
q = 1;
temp[i] = j + 'a';
tcnt[j]++;
i++;
break;
}
}
else {
q = 1;
}
if (!q) {
temp = c;
return;
}
while (i < n) {
for (int j = 0; j < 30; j++) {
if (cnt[j] > tcnt[j]) {
tcnt[j]++;
temp[i] = j + 'a';
break;
}
}
i++;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> a >> b;
c = a;
int m = b.size();
sort(c.rbegin(), c.rend());
if (c <= b) {
cout << -1 << endl;
return 0;
}
int n = a.size();
for (int i = 0; i < n; i++) cnt[a[i] - 'a']++;
temp = c;
ans = c;
con(0, n, m);
ans = temp;
for (int i = 0; i < min(n, m); i++) {
if (cnt[b[i] - 'a']) {
cnt[b[i] - 'a']--;
for (int j = 0; j <= i; j++) temp[j] = b[j];
con(i + 1, n, m);
if (temp < ans && temp != b) ans = temp;
} else
break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int countbit(int n) { return (n == 0) ? 0 : 1 + countbit(n & (n - 1)); }
int lowbit(int n) { return (n ^ (n - 1)) & n; }
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
T sqr(T x) {
return x * x;
}
char a[5005], b[5005];
int lena, lenb;
int num[256];
char ans[5005];
bool ok;
void dfs(int pos, bool gt) {
if (pos == lena) {
if (gt) {
ok = 1;
printf("%s\n", ans);
exit(0);
}
}
if (ok) return;
if (gt) {
for (char x = 'a'; x <= 'z'; ++x) {
if (num[x] > 0) {
num[x]--;
ans[pos] = x;
dfs(pos + 1, 1);
num[x]++;
}
}
}
for (char x = b[pos]; x <= 'z'; ++x) {
if (num[x] > 0) {
ans[pos] = x;
num[x]--;
if (x == b[pos])
dfs(pos + 1, 0);
else
dfs(pos + 1, 1);
num[x]++;
}
}
}
int main() {
scanf("%s", a);
scanf("%s", b);
lena = strlen(a), lenb = strlen(b);
if (lena > lenb) {
for (int i = 0; i < lena - lenb; ++i) b[lenb + i] = 255;
}
for (int i = 0; i < lena; ++i) num[a[i]]++;
dfs(0, 0);
if (!ok) printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 5e3 + 10;
int len;
string ans;
string s1, s2;
int cnt[200];
void dfs(int cur = 0, bool flag = true) {
if (cur == len) {
if (flag)
return;
else
puts(ans.c_str()), exit(0);
}
if (cur == s1.length()) {
if (flag)
return;
else
puts(ans.c_str()), exit(0);
}
char low = flag ? s2[cur] : 'a';
for (int i = low; i <= 'z'; i++) {
if (cnt[i] == 0) continue;
cnt[i]--;
ans.push_back(i);
dfs(cur + 1, flag && i == s2[cur]);
cnt[i]++;
ans.pop_back();
}
}
int main() {
cin >> s1 >> s2;
while (s2.length() < s1.length()) s2 += 'a' - 1;
len = s2.length();
for (auto& c : s1) cnt[c]++;
dfs();
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 203600;
char s[N], t[N];
int n, m;
int b[256], b2[256];
int main() {
scanf("%s%s", s, t);
n = strlen(s);
m = strlen(t);
string ans = "";
for (int i = (0); i < (int)(n); i++) b[s[i]]++;
for (int j = min(n, m); j >= 0; j--) {
string tmp = "";
for (int first = ('a'); first <= (int)('z'); first++) b2[first] = b[first];
bool ok = true;
for (int second = (0); second < (int)(j); second++) {
if (b2[t[second]] <= 0) {
ok = false;
break;
}
tmp += t[second];
b2[t[second]]--;
}
if (!ok) continue;
int first = t[j] + 1;
while (first <= 'z' && b2[first] == 0) ++first;
if (first > 'z') continue;
tmp += first;
b2[first]--;
for (int first = ('a'); first <= (int)('z'); first++) {
while (b2[first]--) {
tmp += first;
}
}
if (tmp > t) {
ans = tmp;
break;
}
}
if (ans == "")
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, ans;
map<char, int> mp;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> s >> t;
sort(s.begin(), s.end());
for (int i = 0; i < t.size(); i++) {
auto iter = lower_bound(s.begin(), s.end(), t[i]);
if (iter == s.end()) {
for (int j = ans.size() - 1; j >= 0; j--) {
auto it = upper_bound(s.begin(), s.end(), ans[j]);
if (it != s.end()) {
char ch = *it;
s.erase(it);
s += ans.substr(j, ans.size() - j);
ans.erase(j, ans.size() - j);
ans += ch;
sort(s.begin(), s.end());
cout << ans + s << endl;
exit(0);
}
s += ans[j];
ans.erase(j, 1);
}
cout << -1 << endl;
exit(0);
}
ans += *iter;
s.erase(iter);
if (ans > t) {
ans += s;
cout << ans << endl;
exit(0);
}
}
ans += s;
if (ans == t) {
string tmp;
for (int i = ans.size() - 1; i >= 0; i--) {
auto it = upper_bound(tmp.begin(), tmp.end(), ans[i]);
if (it != tmp.end()) {
char ch = *it;
tmp.erase(it);
tmp += ans.substr(i, ans.size() - i);
ans.erase(i, ans.size() - i);
ans += ch;
sort(tmp.begin(), tmp.end());
ans += tmp;
break;
}
tmp += ans[i];
ans.erase(i, 1);
}
if (ans > t)
cout << ans << endl;
else
cout << -1 << endl;
} else if (ans > t)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5020;
char s[N], t[N];
int cnt[30], ans[N];
int lens, lent, tot;
void print(int k) {
for (int i = 0; i <= k; i++) printf("%c", ans[i]);
for (int i = 0; i < 26; i++)
for (int j = 1; j <= cnt[i]; j++) printf("%c", i + 'a');
exit(0);
}
void dfs(int k) {
if (k == lent) {
if (k < lens) print(k - 1);
return;
}
if (k == lens) return;
int cht = t[k] - 'a';
if (cnt[cht] > 0) {
cnt[cht]--;
ans[k] = t[k];
dfs(k + 1);
cnt[cht]++;
}
for (int i = cht + 1; i < 26; i++)
if (cnt[i]) {
cnt[i]--;
ans[k] = i + 'a';
print(k);
}
}
int main() {
scanf("%s", s);
scanf("%s", t);
lens = strlen(s);
lent = strlen(t);
for (int i = 0; i < lens; i++) cnt[s[i] - 'a']++;
dfs(0);
cout << -1;
}
|
#include <bits/stdc++.h>
const int maxn = 5010;
char s[maxn];
char t[maxn];
int a[30], b[30];
int main() {
int i, j, k, l;
bool can, flag;
while (scanf("%s%s", s, t) != EOF) {
can = true;
int lens = strlen(s);
int lent = strlen(t);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 0; i < lens; i++) a[s[i] - 'a']++;
for (i = 0; i < lent; i++) b[t[i] - 'a']++;
int more = 0;
for (i = 0; i < 26; i++) {
if (a[i] < b[i]) can = false;
if (a[i] > b[i]) more++;
}
int cnt;
if (can && more) {
cnt = lent;
for (i = 0; i < 26; i++)
for (j = 0; j < a[i] - b[i]; j++) t[cnt++] = 'a' + i;
t[cnt] = '\0';
printf("%s\n", t);
continue;
}
flag = false;
for (i = lent - 1; i >= 0; i--) {
can = true;
b[t[i] - 'a']--;
for (j = 0; j < 26; j++)
if (a[j] < b[j]) can = false;
if (!can) continue;
for (j = 0; j < 26; j++)
if (j > t[i] - 'a' && a[j] > b[j]) {
flag = true;
a[j]--;
t[i] = 'a' + j;
cnt = i + 1;
for (i = 0; i < 26; i++)
for (j = 0; j < a[i] - b[i]; j++) t[cnt++] = 'a' + i;
t[cnt] = 0;
printf("%s\n", t);
break;
}
if (flag) break;
}
if (!flag) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
const int B = 27;
int zhu[B], n, m;
char s[N], t[N];
void solve() {
memset(zhu, 0, sizeof(zhu));
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; ++i) zhu[s[i] - 'a']++;
int r = -1, p;
if (n > m)
p = m;
else
p = min(n, m) - 1;
for (int i = t[0] - 'a' + 1; i < 26; ++i)
if (zhu[i]) r = 0;
for (int i = 1; i <= p; ++i) {
zhu[t[i - 1] - 'a']--;
if (zhu[t[i - 1] - 'a'] < 0) break;
if (i == m) {
r = m;
continue;
}
for (int j = t[i] - 'a' + 1; j < 26; ++j)
if (zhu[j]) r = i;
}
if (r == -1) {
printf("-1\n");
return;
} else {
memset(zhu, 0, sizeof(zhu));
for (int i = 0; i < n; ++i) zhu[s[i] - 'a']++;
for (int i = 0; i < r; ++i) {
printf("%c", t[i]);
zhu[t[i] - 'a']--;
}
if (r < m)
for (int i = t[r] - 'a' + 1; i < 26; ++i)
if (zhu[i]) {
printf("%c", i + 'a');
zhu[i]--;
break;
}
for (int i = 0; i < 26; ++i)
while (zhu[i]--) printf("%c", i + 'a');
printf("\n");
}
}
int main() {
while (~scanf("%s%s", s, t)) solve();
}
|
#include <bits/stdc++.h>
const int N = 5000 + 10;
char s[N], t[N];
int app[N][30];
int tot[30];
int idx(char c) {
if (c >= 'a' && c <= 'z')
return c - 'a' + 1;
else
return 0;
}
int lens, lent;
int main() {
scanf("%s%s", s, t);
lens = strlen(s);
lent = strlen(t);
while (lent < lens) t[lent++] = ']';
for (int i = 0; i < lens; ++i) ++tot[idx(s[i])];
for (int i = 0; i < lent; ++i) {
if (i)
for (int j = 0; j < 30; ++j) app[i][j] = app[i - 1][j];
++app[i][idx(t[i])];
}
int pos = -1;
for (int j = 0; j < 30; ++j)
if (tot[j] > 0 && j > idx(t[0])) {
pos = 0;
break;
}
for (int i = 1; i < lens; ++i) {
bool done = true;
for (int j = 0; j < 30; ++j)
if (tot[j] - app[i - 1][j] < 0) done = false;
if (done) {
int c = idx(t[i]);
for (int j = c + 1; j < 30; ++j)
if (tot[j] - app[i - 1][j] > 0) {
pos = i;
break;
}
} else
break;
}
if (pos == -1)
printf("%d\n", pos);
else {
for (int i = 0; i < pos; ++i) putchar(t[i]);
if (pos > 0)
for (int j = 0; j < 30; ++j) tot[j] -= app[pos - 1][j];
for (int j = 0; j < 30; ++j)
if (j > idx(t[pos]) && tot[j] > 0) {
putchar('a' + j - 1);
--tot[j];
break;
}
for (int j = 1; j < 30; ++j)
while (tot[j] > 0) {
--tot[j];
putchar(j + 'a' - 1);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char prm[5005];
char nb[5005];
int idx[27];
int tk[5005];
int frq[27];
char rs[5005];
FILE *f1 = stdin;
int main() {
fscanf(f1, "%s%s", prm, nb);
int n = strlen(prm), i;
sort(prm, prm + n);
int nt = strlen(nb);
for (i = 0; i < 5005; i++) tk[i] = 0;
for (i = 0; i < 27; i++) frq[i] = 0;
for (i = 0; i < n; i++) frq[prm[i] - 'a']++;
int z;
char eq = '1';
for (i = 0; i < nt; i++) {
z = nb[i] - 'a';
while (frq[z] == 0 && z < 26) z++;
if (z == 26) break;
frq[z]--;
if (z > (nb[i] - 'a')) {
eq = '0';
rs[i] = z + 'a';
i++;
break;
}
rs[i] = z + 'a';
}
int x = i - 1;
if (z == 26 && eq == '0') {
printf("-1");
exit(0);
}
if ((z == 26 || nt >= n) && eq == '1') {
for (; x >= 0; x--) {
z = rs[x] - 'a' + 1;
while (frq[z] == 0 && z < 26) z++;
frq[rs[x] - 'a']++;
if (z != 26) {
rs[x] = z + 'a';
frq[z]--;
i = x + 1;
break;
}
}
if (x == -1) {
printf("-1\n");
exit(0);
}
}
for (; i < n; i++) {
z = 0;
while (frq[z] == 0 && z < 26) z++;
rs[i] = z + 'a';
frq[z]--;
}
printf("%s", rs);
scanf("%*d");
}
|
#include <bits/stdc++.h>
using namespace std;
char a[2000000];
char s[2000000];
int w[2000000];
char ans[2000000];
int main() {
cin >> a;
{
int f = 0;
int flag = 0;
cin >> s;
memset(w, 0, sizeof(w));
for (int i = 0; i < strlen(a); i++) w[a[i]]++;
for (int i = 0; i < strlen(a); i++) {
if (i >= strlen(s)) {
f = 1;
while (i < strlen(a)) {
for (int k = 'a'; k <= 'z'; k++)
if (w[k]) {
ans[i++] = k, w[k]--;
break;
}
}
break;
}
if (w[s[i]] && i != strlen(a) - 1) {
w[s[i]]--;
ans[i] = s[i];
} else {
for (int k = s[i] + 1; k <= 'z'; k++) {
if (w[k]) {
w[k]--;
ans[i++] = k;
flag = 1;
break;
}
}
if (flag) {
f = 1;
while (i < strlen(a)) {
for (int k = 'a'; k <= 'z'; k++)
if (w[k]) {
ans[i++] = k, w[k]--;
break;
}
}
break;
} else {
for (i = i - 1; i >= 0; i--) {
w[ans[i]]++;
for (int k = s[i] + 1; k <= 'z'; k++)
if (w[k]) {
w[k]--;
ans[i++] = k;
flag = 1;
break;
}
if (flag) break;
}
if (flag) {
f = 1;
while (i < strlen(a)) {
for (int k = 'a'; k <= 'z'; k++)
if (w[k]) {
ans[i++] = k, w[k]--;
break;
}
}
break;
}
}
break;
}
}
if (f)
cout << ans << endl;
else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ntest = 0, test = 0;
inline void init();
inline void run();
inline void stop() { ntest = test - 1; }
int main() {
init();
while (++test <= ntest) {
run();
}
return 0;
}
const int INF = (int)1E9 + 5;
const double EPS = 1E-11;
const long long MOD = (long long)1E9 + 7;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
inline void init() { ntest = 1; }
string s, t;
int cnt[300];
char ret[5005];
bool doDfs(int level, bool larger) {
if (level >= ((int)(s).size())) {
if (larger) {
for (int i = 0; i < (((int)(s).size())); i++) {
printf("%c", ret[i]);
}
puts("");
return true;
}
return false;
}
int MIN = 'a';
if (!larger && ((int)(t).size()) > level) {
MIN = t[level];
}
for (int ch = (MIN); ch <= ('z'); ch++) {
if (cnt[ch] <= 0) {
continue;
}
cnt[ch]--;
ret[level] = ch;
if (!larger) {
if (((int)(t).size()) > level) {
if (doDfs(level + 1, ch > t[level])) {
return true;
}
} else {
if (doDfs(level + 1, true)) {
return true;
}
}
} else {
if (doDfs(level + 1, true)) {
return true;
}
}
cnt[ch]++;
}
return false;
}
inline void run() {
getline(cin, s);
getline(cin, t);
for (typeof((s).begin()) it = (s).begin(); it != (s).end(); it++) {
cnt[*it]++;
}
if (!doDfs(0, false)) {
puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100009;
string s, t;
int chars[32];
void fillrest(int poz) {
int i, j;
j = 0;
for (i = poz; i < s.length(); ++i) {
while (chars[j] <= 0) {
++j;
}
s[i] = j + 'a';
--chars[j];
}
}
char searchGreaterThan(char which) {
char c;
for (c = which + 1; c <= 'z'; ++c) {
if (chars[c - 'a'] > 0) {
break;
}
}
return c;
}
int main() {
int i, j;
char c;
cin >> s >> t;
for (i = 0; i < s.length(); ++i) {
++chars[s[i] - 'a'];
}
for (i = 0; i < t.length(); ++i) {
if (chars[t[i] - 'a'] > 0) {
--chars[t[i] - 'a'];
s[i] = t[i];
} else {
for (; i >= 0; --i) {
c = searchGreaterThan(t[i]);
if (c <= 'z') {
s[i] = c;
--chars[c - 'a'];
fillrest(i + 1);
break;
} else {
if (i > 0) {
++chars[s[i - 1] - 'a'];
}
}
}
if (searchGreaterThan('a' - 1) <= 'z') {
cout << -1 << endl;
} else {
cout << s << endl;
}
return 0;
}
}
if (t.length() <= s.length()) {
t.push_back('a' - 1);
for (; i >= 0; --i) {
c = searchGreaterThan(t[i]);
if (c <= 'z') {
s[i] = c;
--chars[c - 'a'];
fillrest(i + 1);
break;
} else {
if (i > 0) {
++chars[s[i - 1] - 'a'];
}
}
}
if (searchGreaterThan('a' - 1) <= 'z') {
cout << -1 << endl;
} else {
cout << s << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
long l, i;
char s[5010], ans[5010];
long a[30];
void add(long x) {
for (long i = 1; i <= 26; i++)
for (long j = 1; j <= a[i]; j++) ans[x++] = i + 96;
}
bool dfs(long x) {
if (x >= l) {
add(x);
return 1;
}
if ((--a[s[x] - 96]) >= 0 && dfs(x + 1)) {
ans[x] = s[x];
return 1;
}
a[s[x] - 96]++;
long i;
for (i = s[x] - 96 + 1; i <= 26; i++)
if (a[i]) break;
if (i <= 26) {
ans[x] = i + 96;
a[i]--;
add(x + 1);
return 1;
}
return 0;
}
int main() {
gets(s);
for (l = strlen(s), i = 0; i < l; i++) a[s[i] - 96]++;
gets(s);
s[strlen(s)] = 96;
l = strlen(s);
if (!dfs(0)) {
printf("-1\n");
return 0;
}
puts(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5100];
char mas[5100];
int l, sum;
int b[30];
bool rec(int x) {
if (x == sum && sum > l) {
return 1;
}
if (x == sum && sum <= l) {
if (mas[x] > s[x])
return 1;
else
return 0;
}
if (x < sum) {
bool fl = 0;
if (b[s[x] - 'a'] > 0) {
mas[x] = s[x];
b[s[x] - 'a']--;
if (rec(x + 1)) {
return 1;
} else
b[s[x] - 'a']++;
}
{
for (int i = s[x] - 'a' + 1; i < 26; i++) {
if (b[i] > 0) {
mas[x] = i + 'a';
b[i]--;
for (int z = x + 1; z < sum; z++) {
for (int j = 0; j < 26; j++) {
if (b[j] > 0) {
b[j]--;
mas[z] = j + 'a';
break;
}
}
}
return 1;
}
}
return 0;
}
}
}
int main() {
cin >> s;
l = strlen(s);
sum = l;
for (int i = 0; i < l; i++) b[s[i] - 'a']++;
cin >> s;
l = strlen(s);
for (int i = l; i < sum; i++) s[i] = 'a';
if (rec(0)) {
for (int i = 0; i < sum; i++) printf("%c", mas[i]);
printf("\n");
} else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
char s[5005], n[5005], ans[5005];
int cnt[30], ls, ln;
bool rec(int i, bool free) {
if (i == ls) {
if (strcmp(n, ans) < 0) {
printf("%s", ans);
return 1;
} else
return 0;
}
if (free || i >= ln) {
for (int j = 0; j < 26; ++j)
if (cnt[j]) {
ans[i] = j + 'a';
--cnt[j];
if (rec(i + 1, 1)) return 1;
++cnt[j];
}
return 0;
} else {
bool flag = 0;
if (cnt[n[i] - 'a']) {
ans[i] = n[i];
--cnt[n[i] - 'a'];
flag = 1;
}
if (flag && rec(i + 1, 0))
return 1;
else {
if (flag) ++cnt[n[i] - 'a'];
for (int j = n[i] - 'a' + 1; j < 26; ++j)
if (cnt[j]) {
ans[i] = j + 'a';
--cnt[j];
if (rec(i + 1, 1)) return 1;
++cnt[j];
}
return 0;
}
}
}
int main() {
scanf(" %s %s", s, n);
memset(cnt, 0, sizeof cnt);
memset(ans, 0, sizeof ans);
ls = strlen(s), ln = strlen(n);
for (int i = 0; i < ls; ++i) ++cnt[s[i] - 'a'];
if (!rec(0, 0)) printf("-1");
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.