text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int num[30];
string ans = "-1";
int n, m;
int numm[30];
void check(string s) {
for (int i = 0; i < 30; i++) numm[i] = num[i];
for (int i = 0; i < 26; i++)
while (numm[i]--) s += char(i + 'a');
if (ans == "-1")
ans = s;
else
ans = min(ans, s);
}
int main() {
string a, b;
cin >> a >> b;
n = a.length();
m = b.length();
string cur = "";
for (int i = 0; i < n; i++) num[a[i] - 'a']++;
bool p = 1;
for (int i = 0; i < min(n, m); i++) {
int j = b[i] - 'a';
j++;
while (j < 26 && num[j] == 0) j++;
if (j < 26) {
num[j]--;
check(cur + char(j + 'a'));
num[j]++;
}
cur += b[i];
num[b[i] - 'a']--;
if (num[b[i] - 'a'] < 0) {
p = 0;
break;
}
}
if (n > m && p) {
check(cur);
cout << ans << endl;
} else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int A['z' + 1];
bool was[100010];
int main() {
string s, t;
cin >> s >> t;
char MAX = 'a';
for (int i = 0; i < s.length(); i++) {
A[s[i]]++;
MAX = max(MAX, s[i]);
}
string res;
for (int i = 0; i < t.length(); i++) {
char ch = t[i];
if (A[ch] > 0) {
res.push_back(ch);
A[ch]--;
while (MAX >= 'a' && A[MAX] == 0) {
MAX--;
}
was[i] = MAX > ch;
} else {
if (MAX < 'a') {
cout << "-1";
return (0);
}
if (MAX > ch) {
char tmp = MAX;
for (char j = ch + 1;; j++)
if (A[j] > 0) {
tmp = j;
break;
}
res.push_back(tmp);
A[tmp]--;
for (char i = 'a'; i <= 'z'; i++)
if (A[i] > 0) {
while (A[i] > 0) {
res.push_back(i);
A[i]--;
}
}
cout << res;
return (0);
} else {
int k = i;
while (!was[k] && k > 0) {
k--;
A[res[res.length() - 1]]++;
res.erase(res.end() - 1);
}
if (was[k]) {
ch = t[k];
char tmp = MAX;
for (char j = ch + 1;; j++)
if (A[j] > 0) {
tmp = j;
break;
}
res.push_back(tmp);
A[tmp]--;
for (char i = 'a'; i <= 'z'; i++)
if (A[i] > 0) {
while (A[i] > 0) {
res.push_back(i);
A[i]--;
}
}
cout << res;
return (0);
} else {
cout << "-1";
return (0);
}
}
}
}
if (s.length() == t.length()) {
bool fl = false;
int pos = -1;
for (int i = 0; i < t.length(); i++)
if (was[i]) {
fl = true;
pos = i;
}
if (!fl) {
cout << "-1";
return (0);
}
string lol = res;
res.clear();
for (int i = 0; i < pos; i++) res.push_back(lol[i]);
for (int i = pos; i < lol.length(); i++) A[lol[i]]++;
char ch = t[pos];
char tmp = MAX;
for (char j = ch + 1;; j++)
if (A[j] > 0) {
tmp = j;
break;
}
res.push_back(tmp);
A[tmp]--;
for (char i = 'a'; i <= 'z'; i++)
if (A[i] > 0) {
while (A[i] > 0) {
res.push_back(i);
A[i]--;
}
}
cout << res;
return (0);
}
for (char i = 'a'; i <= 'z'; i++)
if (A[i] > 0) {
while (A[i] > 0) {
res.push_back(i);
A[i]--;
}
}
cout << res;
return (0);
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5010], t[5010], ans[5010];
int cnt[30];
int main() {
while (scanf("%s%s", s, t) != EOF) {
memset(cnt, 0, sizeof(cnt));
int n = strlen(s), m = strlen(t);
int i;
for (i = 0; i < n; ++i) ++cnt[s[i] - 'a'];
for (i = 0; i < m; ++i) {
if (cnt[t[i] - 'a'])
--cnt[t[i] - 'a'], ans[i] = t[i];
else
break;
}
if (i == m && n > m) {
for (int j = 0, k = m; j < 26; ++j)
while (cnt[j]--) ans[k++] = 'a' + j;
ans[n] = 0;
puts(ans);
} else {
bool found = 0;
for (; !found && i >= 0;) {
if (i != n) {
for (int j = t[i] - 'a' + 1; !found && j < 26; ++j)
if (cnt[j]) {
--cnt[j];
found = 1;
ans[i] = 'a' + j;
for (int k = 0, l = i + 1; k < 26; ++k)
while (cnt[k]--) ans[l++] = 'a' + k;
}
}
if (--i >= 0) cnt[t[i] - 'a']++;
}
ans[n] = 0;
if (found)
puts(ans);
else
puts("-1");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[5010], b[5010];
int Cnt[300];
char s[5010];
void Init() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) a[i] = s[i];
scanf("%s", s + 1);
m = strlen(s + 1);
for (int i = 1; i <= m; ++i) b[i] = s[i];
b[m + 1] = -1;
}
void Solve() {
int ans = -1, x = min(n, m) + 1;
for (int i = 1; i <= n; ++i) ++Cnt[a[i]];
for (int i = 1; i <= x; ++i) {
for (int j = 0; j <= 255; ++j)
if (j > b[i] && Cnt[j]) ans = i - 1;
if (i > m || !Cnt[b[i]]) break;
--Cnt[b[i]];
}
if (ans == -1) {
printf("-1\n");
return;
}
memset(Cnt, 0, sizeof(Cnt));
for (int i = 1; i <= n; ++i) ++Cnt[a[i]];
for (int i = 1; i <= ans; ++i) {
printf("%c", b[i]);
--Cnt[b[i]];
}
for (int i = 0; i <= 255; ++i)
if (i > b[ans + 1] && Cnt[i]) {
printf("%c", i);
--Cnt[i];
break;
}
for (int i = 0; i <= 255; ++i)
for (int j = 1; j <= Cnt[i]; ++j) printf("%c", i);
printf("\n");
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[30];
string ans = "-1";
int n, m;
int numm[30];
void check(string s) {
for (int i = 0; i < 30; i++) numm[i] = num[i];
for (int i = 0; i < 26; i++)
while (numm[i]--) s += char(i + 'a');
ans = s;
}
int main() {
string a, b;
cin >> a >> b;
n = a.length();
m = b.length();
string cur = "";
for (int i = 0; i < n; i++) num[a[i] - 'a']++;
bool p = 1;
for (int i = 0; i < min(n, m); i++) {
int j = b[i] - 'a';
j++;
while (j < 26 && num[j] == 0) j++;
if (j < 26) {
num[j]--;
check(cur + char(j + 'a'));
num[j]++;
}
cur += b[i];
num[b[i] - 'a']--;
if (num[b[i] - 'a'] < 0) {
p = 0;
break;
}
}
if (n > m && p) {
check(cur);
cout << ans << endl;
} else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long invMod(long long n) { return pwr(n, (1000000007LL) - 2); }
string str;
int n, cnt[5005][30], avail[30];
int main() {
ios_base::sync_with_stdio(0);
cin >> str;
for (int i = 0; i < (int)str.length(); i++) avail[str[i] - 'a']++;
int len = str.length();
cin >> str;
n = str.length();
cnt[0][str[0] - 'a']++;
for (int i = 1; i < n; i++) {
for (int j = 0; j < 26; j++) cnt[i][j] = cnt[i - 1][j];
cnt[i][str[i] - 'a']++;
}
if (len > n) {
bool impossible = false;
for (int j = 0; j < 26; j++)
if (cnt[n - 1][j] > avail[j]) impossible = true;
if (impossible) goto lb;
for (int i = 0; i < n; i++) {
cout << str[i];
avail[str[i] - 'a']--;
}
for (int i = 0; i < 26; i++)
while (avail[i]--) cout << ((char)('a' + i));
return 0;
}
lb:
int ans = -1;
for (int i = n - 1; i >= 0; i--) {
bool b = false;
if (i != 0) {
for (int j = 0; j < 26; j++)
if (avail[j] < cnt[i - 1][j]) b = true;
}
if (b) continue;
b = false;
for (int j = str[i] - 'a' + 1; j < 26; j++)
if (avail[j] > cnt[i - 1][j]) b = true;
if (!b) continue;
ans = i;
break;
}
if (ans == -1) {
cout << "-1";
return 0;
}
for (int i = 0; i < ans; i++) {
cout << str[i];
avail[str[i] - 'a']--;
}
for (int i = str[ans] - 'a' + 1; i < 26; i++)
if (avail[i] > 0) {
cout << ((char)(i + 'a'));
avail[i]--;
break;
}
for (int i = 0; i < 26; i++)
while (avail[i]--) cout << ((char)(i + 'a'));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int cnt[26];
char str[N];
string ret, tmp, pre;
string get(int x) {
cnt[x]--;
string r = "";
r += 'a' + x;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < cnt[i]; j++) r += 'a' + i;
}
cnt[x]++;
return r;
}
int main() {
int n, i, j, flag = 0;
scanf("%s", str);
for (i = 0; str[i]; i++) {
cnt[str[i] - 'a']++;
}
scanf("%s", str);
for (pre = "", i = 0; str[i]; i++) {
int now = str[i] - 'a';
for (j = now + 1; j < 26; j++) {
if (cnt[j]) break;
}
if (j < 26) {
tmp = pre + get(j);
if (!flag || ret > tmp) ret = tmp;
flag = 1;
}
if (!cnt[now]) break;
cnt[now]--;
pre += str[i];
}
if (!str[i]) {
for (j = 0; j < 26; j++)
if (cnt[j]) break;
if (j < 26) {
tmp = pre + get(j);
if (!flag || ret > tmp) ret = tmp;
flag = 1;
}
}
if (!flag)
puts("-1");
else
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5005;
char s[M], t[M];
int n = 0, c['z' + 1], can['z' + 1];
bool gd(int i) {
memset(c, 0, sizeof(c));
for (int j = 'a'; j <= 'z'; j++) c[j] = can[j];
char m = 'z';
for (i; i < n; i++) {
while (c[m] == 0) m--;
s[i] = m;
c[m]--;
}
return strcmp(s, t) > 0;
}
int main() {
scanf("%s%s", s, t);
for (int i = 0; s[i]; i++, n++) can[s[i]]++;
if (!gd(0)) {
puts("-1");
return 0;
}
for (int i = 0; i < n; i++) {
for (char j = 'a'; j <= 'z'; j++) {
if (can[j] > 0) {
can[j]--;
s[i] = j;
if (gd(i + 1)) break;
can[j]++;
}
}
}
puts(s);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int f[26] = {0};
char result[5050];
string a, b;
int rs = 0;
bool dfs(int pos) {
if (pos == b.size()) {
bool ff = false;
for (int j = 0; j < 26; j++) {
for (int k = 0; k < f[j]; k++) {
ff = true;
result[rs++] = j + 'a';
}
}
return ff;
}
int j = b[pos] - 'a';
if (f[j]) {
f[j]--;
result[rs++] = j + 'a';
if (dfs(pos + 1)) return true;
rs--;
f[j]++;
}
j = b[pos] - 'a' + 1;
while (j < 26 && f[j] == 0) j++;
if (j < 26) {
f[j]--;
result[rs++] = j + 'a';
for (j = 0; j < 26; j++) {
for (int k = 0; k < f[j]; k++) result[rs++] = j + 'a';
}
return true;
}
return false;
}
int main() {
cin >> a >> b;
for (int i = 0; i < a.size(); i++) {
f[a[i] - 'a']++;
}
if (dfs(0)) {
result[rs] = 0;
cout << result << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void lowest(char* s, vector<int>& remain) {
for (int i = 0; i < 26; i++) {
for (int j = 0; j < remain[i]; j++) *(s++) = i + 'a';
}
*s = '\0';
}
bool up(char* s, const char* t, vector<int>& remain, int size) {
if (size == 0) {
*s = '\0';
return false;
} else if (*t == '\0') {
lowest(s, remain);
return true;
} else {
int use = *t - 'a' + 1;
while (use < 27 && remain[use] == 0) use++;
if (use == 27) return false;
remain[use]--;
*s = (char)(use + 'a');
lowest(s + 1, remain);
remain[use]++;
return true;
}
}
bool eq(char* s, const char* t, vector<int>& remain, int size) {
if (size == 0) {
return false;
} else if (*t == '\0') {
lowest(s, remain);
return true;
} else {
int use = *t - 'a';
if (remain[use]) {
remain[use]--;
*s = (char)(use + 'a');
if (eq(s + 1, t + 1, remain, size - 1)) return true;
if (up(s + 1, t + 1, remain, size - 1)) return true;
remain[use]++;
}
return up(s, t, remain, size);
}
}
int main() {
string a, b;
cin >> a >> b;
vector<int> c(27);
for (int i = 0; i < (int)a.size(); i++) {
c[a[i] - 'a']++;
}
char ans[5001];
bool ok = eq(ans, b.c_str(), c, (int)a.size());
if (ok)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5555;
int n, m;
int number[26];
char buffer[MAX_N];
string result;
int main() {
scanf("%s", buffer);
n = strlen(buffer);
for (int i = 0; i < n; i++) {
number[buffer[i] - 'a']++;
}
scanf("%s", buffer);
m = strlen(buffer);
for (int i = 0; i < m && i < n; i++) {
for (int j = buffer[i] - 'a' + 1; j < 26; j++) {
if (number[j] > 0) {
number[j]--;
result = string(buffer, buffer + i) + char('a' + j);
for (int k = 0; k < 26; k++) {
result += string(number[k], 'a' + k);
}
number[j]++;
break;
}
}
if (number[buffer[i] - 'a']-- == 0) {
break;
}
if (i == m - 1 && n > m) {
result = string(buffer, buffer + m);
for (int k = 0; k < 26; k++) {
result += string(number[k], 'a' + k);
}
}
}
if (result == "") {
cout << -1 << endl;
} else {
cout << result << endl;
}
}
|
#include <bits/stdc++.h>
int diru[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dirv[] = {-1, 0, 1, -1, 1, -1, 0, 1};
using namespace std;
template <class T>
T sq(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
bool inside(T a, T b, T c) {
return a <= b && b <= c;
}
template <class T>
void setmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
char A[5010];
char B[5010];
char ans[5010];
int cnt[510];
int a, b, l;
int cal(int pos) {
if (pos == a) return -(1 << 29);
if (pos == b) return pos;
int i, j;
int cur[27];
for (j = 'a'; j < 'z' + 1; j++) cur[j - 'a'] = cnt[j];
for (i = 0; i < pos; i++) cur[B[i] - 'a']--;
int ret = -(1 << 29);
if (cur[B[pos] - 'a']) ret = cal(pos + 1);
for (j = B[pos] + 1; j < 'z' + 1; j++)
if (cur[j - 'a']) {
ret = max(ret, pos);
break;
}
return ret;
}
int main() {
int n, t = 1, m, i, j, k, last;
scanf("%s", A);
scanf("%s", B);
for (i = 0; A[i]; i++) cnt[A[i]]++;
a = i;
b = strlen(B);
k = cal(0);
if (k < 0) {
puts("-1");
return 0;
}
l = 0;
for (i = 0; i < k; i++) {
ans[l++] = B[i];
cnt[B[i]]--;
}
for (j = B[k] + 1; j < 'z' + 1; j++)
if (cnt[j]) {
ans[l++] = j;
cnt[j]--;
break;
}
for (j = 'a'; j < 'z' + 1; j++)
while (cnt[j]--) ans[l++] = j;
ans[l] = 0;
puts(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ritikio();
const long long int inff = LLONG_MAX;
const long long int minff = LLONG_MIN;
const long long int inf = 1e18;
const long long int pmod = 998244353;
const long long int mod = 1e9 + 7;
const long long int maxm = 2e6 + 3;
const long long int maxN = 1e5 + 3;
long long int find(long long int indx, vector<long long int>& v) {
long long int f = -1;
long long int n = (long long int)v.size();
for (long long int i = indx; i < n; i++) {
if (v[i] > 0) {
f = i;
break;
}
}
return f;
}
void solve() {
string s, t;
cin >> s >> t;
long long int n = s.length(), m = t.length();
vector<long long int> v1(27);
for (long long int i = 0; i < n; i++) v1[s[i] - 'a']++;
string ans = s;
for (long long int i = 0; i < n; i++) {
long long int f = 0;
for (long long int lt = 0; lt < 26; lt++) {
if (v1[lt] == 0) continue;
ans[i] = 'a' + lt;
v1[lt]--;
long long int pos = i + 1;
for (long long int j = 25; j > -1; j--) {
for (long long int k = 0; k < v1[j]; k++) ans[pos++] = 'a' + j;
}
if (ans > t) {
f = 1;
break;
}
v1[lt]++;
}
if (f == 0) {
cout << -1 << endl;
return;
}
}
cout << ans << endl;
}
signed main() {
ritikio();
long long int T = 1;
while (T--) {
solve();
}
}
void ritikio() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
|
#include <bits/stdc++.h>
using namespace std;
char n1[5002], n2[5002];
int l1, l2;
stack<char> res;
bool tfind(int i) {
if (i == l2) {
if (l1 <= l2)
return false;
else
return true;
}
int j;
char c;
for (j = 0; j < l1; j++) {
if (n1[j] > n2[i]) {
res.push(n1[j]);
n1[j] = 0;
return true;
} else if (n1[j] == n2[i]) {
c = n1[j];
n1[j] = 0;
if (tfind(i + 1)) {
res.push(c);
return true;
}
n1[j] = c;
}
}
return false;
}
int main() {
gets(n1);
gets(n2);
l1 = strlen(n1);
l2 = strlen(n2);
int i, j, c2;
sort(n1, n1 + l1);
if (tfind(0)) {
while (!res.empty()) {
putchar(res.top());
res.pop();
}
for (i = 0; i < l1; i++)
if (n1[i]) putchar(n1[i]);
} else
printf("-1\n");
}
|
#include <bits/stdc++.h>
char s[5005], t[5005];
int len, cnt[128];
int greedy(int n) {
int i, j;
int _cnt[128];
memcpy(_cnt, cnt, sizeof(cnt));
for (i = n, j = 'z'; i < len; i++) {
while (!_cnt[j]) j--;
_cnt[s[i] = j]--;
}
return strcmp(s, t) > 0;
}
int main() {
int i, j;
scanf("%s%s", s, t);
len = strlen(s);
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < len; i++) cnt[s[i]]++;
for (i = 0; i < len; i++) {
for (j = 'a'; j <= 'z'; j++)
if (cnt[j]) {
cnt[s[i] = j]--;
if (greedy(i + 1)) break;
cnt[j]++;
}
if (j > 'z') {
printf("-1\n");
return 0;
}
}
printf("%s\n", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cc[30];
char aa[10100], bb[10100];
bool Work(int now) {
int i, j;
for (; now >= 0; --now) {
++cc[aa[now] - 97];
for (j = bb[now] - 96; j < 26; ++j)
if (cc[j] > 0) break;
if (j < 26) break;
}
if (now < 0) return false;
for (j = bb[now] - 96; j < 26; ++j)
if (cc[j] > 0) break;
aa[now] = j + 97;
--cc[j];
for (i = now, j = 0; j < 26; ++j)
for (; cc[j] > 0; --cc[j]) aa[++now] = j + 97;
return true;
}
int main() {
int i, j;
scanf("%s", aa);
n = strlen(aa);
scanf("%s", bb);
m = strlen(bb);
memset(cc, 0, sizeof(cc));
for (i = 0; i < n; ++i) ++cc[aa[i] - 97];
bool flag = true;
for (i = 0; i < m; ++i)
if (i >= n) {
if (!Work(i - 1)) {
puts("-1");
return 0;
}
flag = false;
break;
} else {
if (cc[bb[i] - 97] > 0) {
--cc[bb[i] - 97];
aa[i] = bb[i];
} else {
flag = false;
for (j = 0; j < 26; ++j)
if (cc[j] > 0) break;
aa[i] = j + 97;
--cc[j];
if (!Work(i)) {
puts("-1");
return 0;
}
break;
}
}
if (flag) {
if (n == m) {
if (!Work(n - 1)) {
puts("-1");
return 0;
}
} else
for (i = m, j = 0; j < 26; ++j)
for (; cc[j] > 0; --cc[j]) aa[i++] = j + 97;
}
for (i = 0; i < n; ++i) printf("%c", aa[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
static const int MOD = 1000000007;
using ll = long long;
using uint = unsigned;
using ull = unsigned long long;
using namespace std;
template <class T>
constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
int main() {
string s, t;
cin >> s >> t;
vector<int> cnt(256);
int n = s.size();
for (int i = 0; i < n; ++i) {
cnt[s[i]]++;
}
while (s.size() > t.size()) t += '?';
int mx = -1;
auto cnt2 = cnt;
for (int i = 0; i <= s.size(); ++i) {
int ok = 0;
for (int j = t[i] + 1; j <= 'z'; ++j) {
if (cnt2[j]) ok = 1;
}
if (ok) mx = i;
if (i != s.size()) {
if (!cnt2[t[i]]) break;
cnt2[t[i]]--;
}
}
if (mx == -1) {
puts("-1");
return 0;
}
string ans;
for (int i = 0; i < mx; ++i) {
ans += t[i];
cnt[t[i]]--;
}
for (int j = t[mx] + 1; j <= 'z'; ++j) {
if (cnt[j]) {
cnt[j]--;
ans += j;
break;
}
}
for (int j = 'a'; j <= 'z'; ++j) {
while (cnt[j]) {
cnt[j]--;
ans += j;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, ans;
int alphabets[128];
int i = 0;
void find_matching() {
for (i = 0; i < s.length(); ++i) ++alphabets[s[i]];
for (i = 0; i < t.length(); ++i) {
if (alphabets[t[i]] > 0) {
ans[i] = t[i];
--alphabets[t[i]];
continue;
}
break;
}
return;
}
int main() {
cin >> s >> t;
ans.resize(s.length());
find_matching();
char c = 0;
for (; i >= 0; --i) {
for (c = t[i] + 1; c <= 'z'; c++) {
if (alphabets[c] > 0) break;
}
if (c <= 'z') break;
if (i > 0) ++alphabets[t[i - 1]];
}
if (i < 0) {
cout << "-1" << endl;
return 0;
}
ans[i++] = c;
--alphabets[c];
for (char k = 'a'; k <= 'z'; k++)
while (alphabets[k]--) {
ans[i++] = k;
};
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e3 + 5;
char s[maxn], t[maxn];
int sl, tl, cnt[256];
bool NoBigger(int ch) {
for (++ch; ch <= 'z'; ++ch)
if (cnt[ch]) return false;
return true;
}
char FirstBigger(int ch) {
for (++ch; ch <= 'z'; ++ch) {
if (cnt[ch]) {
--cnt[ch];
return ch;
}
}
}
bool Dfs(int k) {
if (k == tl) {
if (NoBigger(t[k]))
return false;
else {
for (int i = 0; i < k; i++) putchar(s[i]);
putchar(FirstBigger(t[k]));
for (int i = 'a'; i <= 'z'; i++)
while (cnt[i]--) putchar(i);
exit(0);
}
}
if (cnt[t[k]]) {
s[k] = t[k];
--cnt[s[k]];
if (!Dfs(k + 1)) {
++cnt[s[k]];
if (NoBigger(t[k]))
return false;
else {
for (int i = 0; i < k; i++) putchar(s[i]);
putchar(FirstBigger(t[k]));
for (int i = 'a'; i <= 'z'; i++)
while (cnt[i]--) putchar(i);
exit(0);
}
}
} else {
if (NoBigger(t[k]))
return false;
else {
for (int i = 0; i < k; i++) putchar(s[i]);
putchar(FirstBigger(t[k]));
for (int i = 'a'; i <= 'z'; i++)
while (cnt[i]--) putchar(i);
exit(0);
}
}
}
int main() {
scanf("%s%s", s, t);
sl = strlen(s), tl = strlen(t);
for (int i = 0; i < sl; i++) ++cnt[s[i]];
if (!Dfs(0)) printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double E = 2.71828182845904523536;
const long double pi = acos(-1);
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const long long inf = 1LL << 30;
const int N = 5050;
char s1[N], s2[N];
multiset<char> s;
int main() {
scanf("%s", &s1);
scanf("%s", &s2);
int n1 = strlen(s1);
int n2 = strlen(s2);
for (int i = 0; i < n1; i++) {
s.insert(s1[i]);
}
int pos = n2;
vector<int> v;
for (int i = 0; i < n2; i++) {
if (s.find(s2[i]) == s.end()) {
pos = i;
break;
}
s.erase(s.find(s2[i]));
v.push_back(s2[i]);
}
for (auto c : v) s.insert(c);
if (!pos) {
if (s.upper_bound(s2[0]) == s.end()) {
printf("-1");
return 0;
}
string ans = "";
char c = *s.upper_bound(s2[0]);
ans += c;
s.erase(s.find(c));
for (auto x : s) ans += x;
printf("%s", ans.c_str());
return 0;
}
if (pos == n2 && n1 > n2) {
string ans = "";
for (int i = 0; i < n2; i++) {
ans += s2[i];
s.erase(s.find(s2[i]));
}
for (auto c : s) ans += c;
printf("%s", ans.c_str());
return 0;
}
v.clear();
int pos1 = 0;
for (int i = 0; i < pos; i++) {
if (s.upper_bound(s2[i]) != s.end()) pos1 = i;
s.erase(s.find(s2[i]));
v.push_back(s2[i]);
}
if (s.upper_bound(s2[pos]) != s.end()) pos1 = pos;
for (auto c : v) s.insert(c);
if (s.upper_bound(s2[pos1]) == s.end()) {
printf("-1");
return 0;
}
string ans = "";
for (int i = 0; i < pos1; i++) {
ans += s2[i];
s.erase(s.find(s2[i]));
}
char c = *s.upper_bound(s2[pos1]);
ans += c;
s.erase(s.find(c));
for (auto x : s) ans += x;
printf("%s", ans.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i;
string s, t;
string ans;
const long long int maxn = 1e5;
map<char, int> m;
int main() {
ans = "";
cin >> s >> t;
for (auto i : s) m[i]++;
int i;
bool uneq = false;
for (i = 0; i < t.size(); ++i) {
if (m[t[i]] > 0) {
ans += t[i];
m[t[i]]--;
} else {
uneq = true;
break;
}
}
if (uneq || s.size() <= t.size()) {
priority_queue<char> p;
for (auto iter : m) {
if (iter.second > 0) {
p.push(iter.first);
}
}
if (p.size() && p.top() > t[i]) {
for (auto iter : m) {
if (iter.second > 0 && iter.first > t[i]) {
ans += iter.first;
m[iter.first]--;
break;
}
}
for (auto iter : m) {
for (int j = 0; j < iter.second; ++j) ans += iter.first;
}
cout << ans;
} else {
while (p.empty() || p.top() <= t[i]) {
if (ans.size() == 0) break;
p.push(ans[ans.size() - 1]);
m[ans[ans.size() - 1]]++;
ans.pop_back();
--i;
}
if (p.size() && p.top() > t[i]) {
for (auto iter : m) {
if (iter.second > 0 && iter.first > t[i]) {
ans += iter.first;
m[iter.first]--;
break;
}
}
for (auto iter : m) {
for (int j = 0; j < iter.second; ++j) ans += iter.first;
}
cout << ans;
} else {
cout << "-1";
}
}
} else {
for (auto iter : m) {
for (int j = 0; j < iter.second; ++j) {
ans += iter.first;
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5050], t[5050], goal[5050];
int cnt[200], l, l2;
bool dfs(int p, bool v) {
if (p == l2) {
if (v)
return puts(goal), 1;
else
return 0;
}
if (v) {
for (int i = 'a'; i < 'z' + 1; i++)
if (cnt[i] > 0) {
cnt[i] -= 1;
goal[p] = i;
return dfs(p + 1, v);
}
return 1;
} else {
for (int i = 'a'; i < 'z' + 1; i++)
if (cnt[i] > 0 && i >= t[p]) {
cnt[i] -= 1;
goal[p] = i;
if (dfs(p + 1, v | (i > t[p]))) return 1;
cnt[i] += 1;
}
}
return 0;
}
int main() {
scanf("%s%s", s, t);
l = strlen(t);
l2 = strlen(s);
for (int i = 0; i < l2; i++) cnt[s[i]]++;
if (!dfs(0, 0)) puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, d[256];
void att(int i, string s, string t, int greater) {
if (greater) {
for (int k = 'a'; k <= 'z'; k++)
for (int j = 0; j < d[k]; j++) s += char(k);
cout << s << endl;
exit(0);
}
if (i == n) return;
if (i < m) {
if (d[t[i]]) {
d[t[i]]--;
att(i + 1, s + t[i], t, 0);
d[t[i]]++;
}
for (int j = t[i] + 1; j <= 'z'; j++)
if (d[j]) {
d[j]--;
att(i + 1, s + char(j), t, 1);
d[j]++;
}
} else
att(i, s, t, 1);
}
int main() {
string s, t;
cin >> s >> t;
n = int(s.size());
m = int(t.size());
for (int i = 0; i < n; i++) d[s[i]]++;
s = "";
att(0, s, t, 0);
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
int c[256];
char s[MAXN], t[MAXN];
void gao() {
int ans = -1;
int n = strlen(s);
memset(c, 0, sizeof(c));
for (int i = 0; i < n; ++i) ++c[s[i]];
for (int i = 0; i < n; ++i) {
for (int ch = t[i] + 1; ch <= 'z'; ++ch) {
if (c[ch] > 0) {
ans = i;
break;
}
}
if (!c[t[i]]) break;
--c[t[i]];
}
if (ans == -1) {
puts("-1");
} else {
memset(c, 0, sizeof(c));
for (int i = 0; i < n; ++i) ++c[s[i]];
for (int i = 0; i < n; ++i) {
if (i > ans) {
for (int ch = 'a'; ch <= 'z'; ++ch) {
while (c[ch]) {
putchar(ch);
--c[ch];
}
}
} else {
char ch = t[i];
if (i == ans) {
for (++ch; ch <= 'z'; ++ch) {
if (c[ch]) break;
}
}
putchar(ch);
--c[ch];
}
}
puts("");
}
}
int main() {
while (scanf("%s%s", s, t) != EOF) {
gao();
}
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;
}
char S[6000], T[6000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> T >> S;
int N = strlen(S), M = strlen(T);
for (int i = 0; i < M; ++i) {
for (int j = i; j < M; ++j)
if (T[j] == S[i]) {
swap(T[i], T[j]);
break;
}
if (T[i] == S[i]) {
sort(T + i + 1, T + M, greater<char>());
if (string(T) > string(S)) continue;
}
int pick = -1;
for (int j = i; j < M; ++j)
if (T[j] > S[i] && (pick == -1 || T[j] < T[pick])) pick = j;
if (pick == -1) {
printf("-1\n");
return 0;
}
swap(T[i], T[pick]);
sort(T + i + 1, T + M);
break;
}
cout << T << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int F[5005][26];
int G[26];
int main() {
string s1, s2;
while (cin >> s1 >> s2) {
memset(G, 0, sizeof(G));
for (int i = 0; i < s1.size(); i++) G[s1[i] - 'a']++;
memset(F, 0, sizeof(F));
F[0][s2[0] - 'a'] = 1;
for (int i = 1; i < s2.size(); i++) {
for (int j = 0; j < 26; j++) F[i][j] = F[i - 1][j];
F[i][s2[i] - 'a']++;
}
string ans = "-1";
for (int i = s2.size() - 1; i >= -1; i--) {
bool ok = 1;
int Q[26] = {};
for (int j = 0; j < 26; j++) {
if (i >= 0 && F[i][j] > G[j])
ok = 0;
else
Q[j] = G[j] - (i >= 0 ? F[i][j] : 0);
}
if (ok) {
int first = -1;
for (int j = 0; j < 26; j++) {
if (Q[j] > 0 && (i == s2.size() - 1 || j > s2[i + 1] - 'a')) {
first = j;
break;
}
}
if (first != -1) {
string add = string(1, 'a' + first);
for (int j = 0; j < 26; j++)
if (j != first)
add += string(Q[j], 'a' + j);
else
add += string(Q[j] - 1, 'a' + j);
ans = s2.substr(0, i + 1) + add;
break;
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
long long int co[26];
string solve(long long int pos) {
long long int cur[26] = {};
string ans = t.substr(0, pos);
for (long long int i = 0; i < pos; i++) cur[t[i] - 'a']++;
for (long long int i = 0; i < 26; i++)
if (cur[i] > co[i]) return "";
for (long long int i = t[pos] - 'a' + 1; i < 26; ++i)
if (co[i] - cur[i] > 0) {
cur[i]++;
ans.push_back(i + 'a');
break;
}
for (long long int i = 0; i < 26; i++)
while (cur[i] < co[i]) {
ans.push_back(i + 'a');
cur[i]++;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s >> t;
sort(s.begin(), s.end());
if (s > t) {
cout << s << endl;
return 0;
}
reverse(s.begin(), s.end());
if (s <= t) {
cout << "-1" << endl;
return 0;
}
for (long long int i = 0; i < s.size(); i++) co[s[i] - 'a']++;
t.push_back('a' - 1);
for (long long int i = t.size() - 1; i >= 0; i--) {
string cur = solve(i);
if (cur > t) {
cout << cur << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, c = "";
int n, d[300];
char more(char q) {
for (char i = q + 1; i <= 'z'; i++)
if (d[i] > 0) return i;
return '#';
}
void v(int r) {
if (d[t[r]] > 0) {
c += t[r];
d[t[r]]--;
v(r + 1);
d[t[r]]++;
c = c.substr(0, r);
}
char x = more(t[r]);
if (x == '#') return;
c += x;
d[x]--;
for (char i = 'a'; i <= 'z'; i++) {
while (d[i] > 0) {
c += i;
d[i]--;
}
}
cout << c;
exit(0);
}
int main() {
cin >> s >> t;
n = s.length();
for (int i = 0; i < n; i++) d[s[i]]++;
v(0);
cout << "-1";
}
|
#include <bits/stdc++.h>
int c[30] = {0}, t[30], cnt, i = 0, j = 0, k;
char s[5100];
bool judge(char s[]) {
for (k = 1; k <= 27; k++) t[k] = c[k];
j = 0;
for (k = 27; k >= 1; k--) {
if (s[j] == 0) break;
if (t[k])
while (t[k]-- && s[j]) {
if (s[j] > k)
return false;
else if (s[j] == k)
j++;
else
return true;
if (t[k] == 0 || s[j] == 0) break;
}
}
for (k = 27; k >= 1; k--) {
if (t[k]) return true;
}
return false;
}
int main() {
scanf("%s", s);
for (; s[i]; i++) c[s[i] - 96]++;
cnt = i;
scanf("%s", s);
for (; s[j]; j++) s[j] -= 96;
if (judge(s) == 0) {
printf("-1\n");
return 0;
}
bool ok = 0;
for (i = 0; i < cnt; i++) {
if (c[s[i]]) {
c[s[i]]--;
if (judge(s + i + 1)) {
printf("%c", s[i] + 96);
c[s[i]]--;
} else
ok = 1;
c[s[i]]++;
} else
ok = 1;
if (ok) break;
}
for (j = s[i] + 1;; j++) {
if (c[j]) break;
}
printf("%c", j + 96), c[j]--;
for (i = 1; i <= 27; i++) {
while (c[i]--) printf("%c", i + 96);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int c[26] = {0};
int main() {
int i, j, y, n, m, k;
cin >> a >> b;
n = a.size();
m = b.size();
for (i = 0; i < n; i++) c[a[i] - 'a']++;
k = m;
for (i = 0; i < k && i < m; i++) {
if (c[b[i] - 'a'] > 0)
c[b[i] - 'a']--;
else
break;
}
if (i == k && n > k) {
cout << b;
for (j = 0; j < 26; j++)
for (y = 0; y < c[j]; y++) printf("%c", j + 'a');
cout << endl;
return 0;
}
int q = 0;
if (i == k) {
i = k - 1;
q = 1;
}
int I = i;
for (; i >= 0; i--) {
if (I != i || q) c[b[i] - 'a']++;
for (y = b[i] + 1 - 'a'; y < 26; y++)
if (c[y] > 0) break;
if (y < 26) {
for (j = 0; j < i; j++) cout << b[j];
c[y]--;
printf("%c", y + 'a');
for (j = 0; j < 26; j++)
for (y = 0; y < c[j]; y++) printf("%c", j + 'a');
cout << endl;
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string ans, a, b;
int freq[256];
bool pref(int k) {
ans = "";
fill(freq, freq + 256, 0);
for (int i = 0; i < ((int)(a).size()); ++i) freq[a[i]]++;
if (((int)(a).size()) < k + 1 || ((int)(b).size()) < k) return false;
for (int i = 0; i < k; ++i) {
if (!freq[b[i]])
return false;
else {
ans += b[i];
--freq[b[i]];
}
}
if (((int)(b).size()) > k) {
int i = b[k] + 1;
while (i < 256 && !freq[i]) ++i;
if (i == 256) {
return false;
}
ans += (char)i;
--freq[i];
}
for (int i = 0; i < 256; ++i)
for (int j = 0; j < freq[i]; ++j) ans += (char)i;
assert(ans > b);
return true;
}
void testCase() {
if (!(cin >> a >> b)) {
exit(0);
}
for (int k = ((int)(a).size()); k >= 0; --k)
if (pref(k)) {
printf("%s\n", ans.c_str());
return;
}
printf("-1\n");
}
int main() {
while (true) {
testCase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int a[26] = {0};
int n, m;
bool win = false;
bool go(int pos) {
if (win) {
if (pos == n) {
cout << s << endl;
return true;
}
for (int i = 0; i < 26; ++i)
if (a[i]) {
--a[i];
s[pos] = i + 'a';
go(pos + 1);
}
return true;
}
if (pos == n) return false;
if (pos == m) {
for (int i = 0; i < 26; ++i)
if (a[i]) {
s[pos] = i + 'a';
--a[i];
win = true;
go(pos + 1);
return true;
}
}
if (a[t[pos] - 'a']) {
--a[t[pos] - 'a'];
s[pos] = t[pos];
if (go(pos + 1)) return true;
++a[t[pos] - 'a'];
for (int i = t[pos] + 1 - 'a'; i < 26; ++i)
if (a[i]) {
win = true;
--a[i];
s[pos] = i + 'a';
go(pos + 1);
return true;
}
return false;
}
for (int i = t[pos] + 1 - 'a'; i < 26; ++i)
if (a[i]) {
win = true;
--a[i];
s[pos] = i + 'a';
go(pos + 1);
return true;
}
return false;
}
int main(void) {
cin >> s >> t;
n = s.length();
m = t.length();
for (int i = 0; i < n; ++i) ++a[s[i] - 'a'];
if (!go(0)) cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[5050], s2[5050], ans[5050];
int cnt[30], cnt2[30];
inline int pd(char s1[], char s2[], int cnt[]) {
int len = strlen(s1), len2 = strlen(s2);
for (int i = 0; i < len; i++) {
if (i >= len2) return 1;
for (int j = 25; j > s2[i] - 'a'; j--) {
if (cnt[j]) return 1;
}
if (cnt[s2[i] - 'a'])
cnt[s2[i] - 'a']--;
else
return 0;
}
if (len <= len2) return 0;
return 1;
}
int main(void) {
scanf("%s%s", s1, s2);
int len = strlen(s1), len2 = strlen(s2);
for (int i = 0; i < len; i++) cnt[s1[i] - 'a']++;
for (int i = 0; i < 26; i++) cnt2[i] = cnt[i];
if (!pd(s1, s2, cnt2)) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < len; i++) {
int j = s2[i] - 'a', flag = 0;
if (i < len2) {
if (cnt[j]) {
for (int k = 0; k < 26; k++) cnt2[k] = cnt[k];
cnt2[j]--;
if (pd(s1 + i + 1, s2 + i + 1, cnt2)) {
cnt[j]--;
ans[i] = 'a' + j;
flag = 1;
}
}
}
if (!flag) {
if (i >= len2)
j = 0;
else
j++;
for (; j < 26; j++) {
if (cnt[j]) {
cnt[j]--;
ans[i] = 'a' + j;
for (int p = 0; p < 26; p++)
for (int q = 1; q <= cnt[p]; q++) ans[++i] = 'a' + p;
break;
}
}
break;
}
}
ans[len] = 0;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[5005], s2[5005];
int arr[30];
int main() {
scanf("%s%s", s1, s2);
int i, j, k;
for (i = 0; s1[i]; i++) arr[s1[i] - 'a' + 1]++;
int len = strlen(s2);
s2[len++] = 'a' - 1;
for (i = 0; i < len; i++) {
int t = s2[i] - 'a' + 1;
if (arr[t])
arr[t]--;
else {
while (1) {
for (j = t + 1; j < 30; j++) {
if (arr[j]) {
for (k = 0; k < i; k++) {
printf("%c", s2[k]);
}
printf("%c", 'a' + j - 1);
arr[j]--;
for (j = 0; j < 30; j++) {
for (k = 0; k < arr[j]; k++) printf("%c", j + 'a' - 1);
}
return 0;
}
}
i--;
if (i < 0) {
puts("-1");
return 0;
}
t = s2[i] - 'a' + 1;
arr[t]++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int m;
int n;
int main() {
string s1, s2;
cin >> s1 >> s2;
sort((s1).begin(), (s1).end());
reverse((s1).begin(), (s1).end());
if (s1 <= s2) {
cout << -1 << endl;
return 0;
}
n = ((int)(s1).size());
for (int i = 0; i < (n); i++) {
int l = i, r = n - 1;
string bs = s1;
while (l <= r) {
int c = (l + r) / 2;
string s3 = s1;
if (i != c) {
for (int j = c; j > i; j--) s3[j] = s3[j - 1];
s3[i] = s1[c];
}
if (s3 > s2) {
bs = s3;
l = c + 1;
} else
r = c - 1;
}
s1 = bs;
}
cout << s1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
std::ios_base::sync_with_stdio(0), cin.tie(0);
string s, t;
cin >> s >> t;
int a[26] = {};
int n = s.size(), m = t.size();
for (int i = 0; i < n; ++i) a[s[i] - 'a']++;
bool ok = 0;
if (n < m) {
s = "";
for (int i = 0; i < n && !ok; ++i) {
if (a[t[i] - 'a']) {
a[t[i] - 'a']--;
s += t[i];
continue;
} else {
for (int j = t[i] - 'a' + 1; j < 26; ++j) {
if (a[j]) {
a[j]--;
s += char('a' + j);
ok = 1;
break;
}
}
if (ok) break;
for (int j = i - 1; j >= 0 && !ok; --j) {
a[s[j] - 'a']++;
s.pop_back();
for (int k = t[j] - 'a' + 1; k < 26; ++k) {
if (a[k]) {
a[k]--;
s += char(k + 'a');
ok = 1;
break;
}
}
}
if (!ok) {
cout << -1;
return 0;
}
}
}
if (!ok) {
cout << -1;
return 0;
}
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < a[i]; ++j) {
s += char('a' + i);
}
}
cout << s;
return 0;
}
s = "";
for (int i = 0; i < m && !ok; ++i) {
if (a[t[i] - 'a']) {
a[t[i] - 'a']--;
s += t[i];
continue;
} else {
for (int j = t[i] - 'a' + 1; j < 26; ++j) {
if (a[j]) {
a[j]--;
s += char('a' + j);
ok = 1;
break;
}
}
if (ok) break;
for (int j = i - 1; j >= 0 && !ok; --j) {
a[s[j] - 'a']++;
s.pop_back();
for (int k = t[j] - 'a' + 1; k < 26; ++k) {
if (a[k]) {
a[k]--;
s += char(k + 'a');
ok = 1;
break;
}
}
}
if (!ok) {
cout << -1;
return 0;
}
}
}
if (!ok) {
if (n == m) {
if (next_permutation(s.begin(), s.end()))
cout << s;
else
cout << -1;
return 0;
}
}
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < a[i]; ++j) {
s += char('a' + i);
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
string s, t;
int mp[28], tempMap[28];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, len1, len2, can = -1;
cin >> s >> t;
len1 = (int)s.size(), len2 = (int)t.size();
for (i = 0; i < len1; i++) {
mp[s[i] - 'a']++;
}
int rng = min(len1, len2) - 1;
if (len1 > len2) rng++;
for (i = 0; i < rng; i++) {
if (mp[t[i] - 'a']) {
mp[t[i] - 'a']--;
for (j = 0; j < 26; j++) {
tempMap[j] = mp[j];
}
bool flag = false;
if (i == len2 - 1) {
if (len1 > len2 && i == rng - 1) flag = true, can = i;
} else {
for (j = t[i + 1] - 'a' + 1; j < 26; j++) {
if (mp[j]) {
flag = true;
break;
}
}
if (flag) can = i;
}
} else {
break;
}
}
memset(mp, 0, sizeof mp);
for (i = 0; i < len1; i++) mp[s[i] - 'a']++;
if (can == -1) {
int found = -1;
for (i = t[0] - 'a' + 1; i < 26; i++) {
if (mp[i]) {
found = i;
break;
}
}
if (found == -1)
cout << -1 << endl;
else {
cout << (char)(found + 'a');
mp[found]--;
for (i = 0; i < 26; i++) {
for (j = 0; j < mp[i]; j++) {
cout << (char)(i + 'a');
}
}
cout << endl;
}
} else {
for (i = 0; i <= can; i++) {
cout << t[i];
mp[t[i] - 'a']--;
}
if (len1 > len2 && can == len2 - 1) {
for (i = 0; i < 26; i++) {
for (j = 0; j < mp[i]; j++) {
cout << (char)(i + 'a');
}
}
cout << endl;
} else {
for (i = t[can + 1] - 'a' + 1; i < 26; i++) {
if (mp[i]) {
cout << (char)(i + 'a');
mp[i]--;
break;
}
}
for (i = 0; i < 26; i++) {
for (j = 0; j < mp[i]; j++) {
cout << (char)(i + 'a');
}
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
int n, m, num[30], num2[30];
char s[N], t[N];
bool chk(int x) {
for (int i = 1; i <= x; i++) num[t[i] - 'a']--;
for (int i = 0; i <= 25; i++)
if (num[i] < 0) return 0;
return 1;
}
int main() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1), m = strlen(t + 1);
for (int i = 1; i <= n; i++) num[s[i] - 'a']++;
for (int i = 0; i <= 25; i++) num2[i] = num[i];
if (n > m && chk(m)) {
for (int j = 1; j <= m; j++) printf("%c", t[j]);
int pos = 0;
for (int j = m + 1; j <= n; j++) {
while (pos <= 25 && !num[pos]) ++pos;
printf("%c", pos + 'a');
--num[pos];
}
puts("");
return 0;
}
for (int i = (n > m ? m : n) - 1; i >= 0; i--) {
for (int j = 0; j <= 25; j++) num[j] = num2[j];
if (chk(i)) {
int ff = -1;
for (int j = t[i + 1] - 'a' + 1; j <= 25; j++) {
if (num[j]) {
ff = j;
break;
}
}
if (ff == -1) continue;
for (int j = 1; j <= i; j++) printf("%c", t[j]);
printf("%c", ff + 'a');
--num[ff];
int pos = 0;
for (int j = i + 2; j <= n; j++) {
while (pos <= 25 && !num[pos]) ++pos;
printf("%c", pos + 'a');
--num[pos];
}
puts("");
return 0;
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
int c[32], t[32], i, j, l;
char s[5120], k;
bool o(char *s) {
for (k = 27; k--; t[k] = c[k])
;
for (k = 26; *s; ++s, --t[k]) {
for (; k && !t[k]; --k)
;
if (k != *s) return k < *s;
}
for (; k && !t[k]; --k)
;
return !k;
}
int main() {
for (gets(s); s[l]; ++l) c[s[l] - 96]++;
for (gets(s); s[i]; ++i) s[i] -= 96;
if (o(s)) return puts("-1"), 0;
for (i = 0; i < l && s[i]; ++i) {
for (j = s[i]; !c[j]; ++j)
;
--c[j];
if (j > s[i]) {
putchar(j + 96);
break;
}
if (o(s + i + 1)) {
++c[j];
for (++j; !c[j]; ++j)
;
--c[j];
}
putchar(j + 96);
if (j > s[i]) break;
}
for (i = 1; i < 27; ++i)
for (; c[i]--;) putchar(i + 96);
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int cnt[26];
int cnt1[26];
int main() {
string s;
string t;
cin >> s;
cin >> t;
for (int i = 0; i < s.size(); i++) {
cnt[s[i] - 'a']++;
}
for (int i = 0; i < t.size(); i++) {
cnt1[t[i] - 'a']++;
}
string ans;
int gr = 0;
for (int itr = 0; itr < s.size(); itr++) {
int yes = 0;
for (int i = 0; i < 26; i++) {
if (cnt[i] == 0) continue;
if (gr == 1) {
cnt[i]--;
ans.push_back(i + 'a');
yes = 1;
break;
}
if (itr >= t.size() || t[itr] < (i + 'a')) {
cnt[i]--;
ans.push_back(i + 'a');
yes = 1;
gr = 1;
break;
}
if (itr < t.size() && t[itr] > (i + 'a')) continue;
cnt[i]--;
int idx = itr + 1;
int flag = 0;
for (int i1 = 25; i1 >= 0; i1--) {
for (int j = 0; j < cnt[i1]; j++) {
if (idx >= t.size()) {
flag = 1;
break;
}
if (t[idx] > (i1 + 'a')) {
flag = 2;
break;
}
if ((i1 + 'a') > t[idx]) {
flag = 1;
break;
}
if (flag) break;
idx++;
}
if (flag) break;
}
if (flag == 1) {
ans.push_back(i + 'a');
yes = 1;
break;
} else {
cnt[i]++;
}
}
if (yes == 0) {
printf("-1\n");
return 0;
}
}
if (ans < t) {
printf("-1\n");
return 0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int dp[5050][30], a[30] = {0};
int sl = s.length(), tl = t.length();
bool y, x;
string r = "";
for (int i = 0; i < sl; i++) a[s[i] - 'a']++;
for (int i = 0; i < 26; i++) dp[0][i] = a[i];
dp[0][t[0] - 'a']--;
for (int i = 1; i < tl; i++) {
for (int j = 0; j < 26; j++) dp[i][j] = dp[i - 1][j];
dp[i][t[i] - 'a']--;
}
for (int i = tl - 1; i >= 0; i--) {
y = true;
x = false;
for (int j = 0; j < 26; j++) {
if (dp[i][j] < 0) {
y = false;
break;
}
}
if (y) {
int c = (i == tl - 1) ? -1 : t[i + 1] - 'a', v = -1;
for (int k = c + 1; k < 26; k++) {
if (dp[i][k] > 0) {
v = k;
x = true;
break;
}
}
if (x) {
r = t.substr(0, i + 1);
r += ('a' + v);
dp[i][v]--;
for (int k = 0; k < 26; k++)
while ((dp[i][k]--) > 0) r += ('a' + k);
}
}
if (x) break;
}
int v = -1;
if (!x) {
int c = (t[0] - 'a') + 1;
for (int i = c; i < 26; i++)
if (a[i] > 0) {
v = i;
break;
}
if (v != -1) {
r += 'a' + v;
a[v]--;
for (int k = 0; k < 26; k++)
while ((a[k]--) > 0) r += ('a' + k);
}
} else
v = 0;
cout << ((v == -1) ? "-1" : r) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int t[5555], a[5555], st[33];
char c[5555];
int main() {
#pragma comment(linker, "/STACK:268435456")
#pragma warning(disable : 4996)
int i, j, n, x;
bool k;
gets(c);
n = strlen(c);
for (i = 0; i < 33; i++) {
st[i] = 0;
}
for (i = 0; i < n; i++) {
st[(int)(c[i] - 'a')]++;
}
gets(c);
for (i = 0; i < strlen(c); i++) {
t[i] = (int)(c[i] - 'a');
a[i] = -1;
}
for (i = strlen(c); i < n; i++) {
t[i] = -1;
a[i] = -1;
}
k = true;
for (i = 0; i < n && k; i++) {
if (st[t[i]] > 0) {
a[i] = t[i];
st[t[i]]--;
} else {
x = i;
k = false;
}
}
if (k) {
x = n - 1;
}
k = true;
while (k && x >= 0) {
if (a[x] != -1) {
st[a[x]]++;
}
for (j = t[x] + 1; j < 33 && k; j++) {
if (st[j] > 0) {
k = false;
a[x] = j;
st[j]--;
}
}
x--;
}
if (k) {
printf("-1");
} else {
for (i = x + 2; i < n; i++) {
k = true;
for (j = 0; j < 33 && k; j++) {
if (st[j] > 0) {
a[i] = j;
st[j]--;
k = false;
}
}
}
for (i = 0; i < n; i++) {
printf("%c", (char)(a[i] + 'a'));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnts[26];
int great(int k) {
for (int i = k + 1; i < 26; i++) {
if (cnts[i]) return i;
}
return -1;
}
void fill(string &s, int n, int pos) {
int aux[26];
for (int i = 0; i < 26; i++) aux[i] = cnts[i];
for (int i = 0; i < 26 && pos <= n; i++) {
while (aux[i] && pos <= n) {
aux[i]--;
s[pos++] = (char)i + 'a';
}
}
}
int cmp(string &s, string &t) {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t, res;
int n, m, aux, pos = 0, last = -1, j;
cin >> s >> t;
n = s.length(), m = t.length();
for (int i = 0; i < 26; i++) cnts[i] = 0;
res.assign(n, ' ');
for (int i = 0; i < n; i++) {
aux = s[i] % 'a';
cnts[aux]++;
}
bool flag = false;
while (pos < min(n, m)) {
aux = t[pos] % 'a';
if (cnts[aux]) {
last = pos;
cnts[aux]--;
res[pos] = (char)aux + 'a';
} else {
j = great(aux);
if (j != -1) {
cnts[j]--;
res[pos] = (char)j + 'a';
flag = true;
pos++;
break;
} else {
pos++;
break;
}
}
pos++;
}
if (!flag) {
while (last != -1) {
fill(res, n, last + 1);
if (t.compare(res) < 0) {
cout << res << '\n';
break;
}
aux = res[last] % 'a';
cnts[aux]++;
j = great(aux);
if (j != -1) {
cnts[j]--;
res[last] = (char)j + 'a';
}
fill(res, n, last + 1);
if (t.compare(res) < 0) {
cout << res << '\n';
break;
}
last--;
}
if (last == -1) cout << "-1\n";
} else {
fill(res, n, pos);
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int vis[5005];
string p, q;
int cnt[26];
int ans[5005];
int isBigger() {
for (int i = 1; i <= ans[0] && i - 1 < m; ++i) {
if (ans[i] < q[i - 1] - 'a') return -1;
if (ans[i] > q[i - 1] - 'a') return 1;
}
if (ans[0] == m)
return 0;
else if (ans[0] > m)
return 1;
else
return -1;
}
bool dfs(int i) {
int k = isBigger();
if (k > 0) return true;
if (i >= m) {
if (k > 0)
return true;
else if (k == 0)
return n > m;
else if (k < 0)
return false;
}
for (char c = q[i]; c <= 'z'; ++c) {
if (cnt[c - 'a'] == 0) continue;
--cnt[c - 'a'];
ans[++ans[0]] = c - 'a';
if (dfs(i + 1)) return true;
--ans[0];
++cnt[c - 'a'];
}
return false;
}
int main() {
cin >> p >> q;
n = p.size();
m = q.size();
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) ++cnt[p[i] - 'a'];
ans[0] = 0;
if (!dfs(0))
printf("-1\n");
else {
for (int i = 1; i <= ans[0]; ++i) cout << (char)(ans[i] + 'a');
for (int i = 0; i < 26; ++i)
for (int j = 0; j < cnt[i]; ++j) cout << (char)(i + 'a');
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
template <typename T>
inline void minimize(T& a, T b) {
a = std::min(a, b);
}
template <typename T>
inline void maximize(T& a, T b) {
a = std::max(a, b);
}
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << '\n';
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& s, pair<T1, T2>& t) {
s << t.first << ' ' << t.second;
return s;
}
template <typename T>
vector<T> readVector(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string original;
cin >> original;
;
string s;
cin >> s;
;
vector<int> chars(200);
for (auto c : original) chars[c]++;
if (original.length() > s.length()) {
vector<int> required(200);
for (auto c : s) required[c]++;
bool isOk = true;
for (char c = 'a'; c <= 'z'; c++)
if (required[c] > chars[c]) isOk = false;
if (isOk) {
cout << s;
for (char c = 'a'; c <= 'z'; c++)
for (int i = 0; i < chars[c] - required[c]; ++i) cout << c;
return 0;
}
}
for (int diff = s.length() - 1; diff >= 0; --diff) {
vector<int> required(200);
bool isOk = true;
for (int i = 0; i < diff; ++i) {
required[s[i]]++;
if (required[s[i]] > chars[s[i]]) isOk = false;
}
if (!isOk) continue;
for (char c = s[diff] + 1; c <= 'z'; c++)
if (chars[c] > required[c]) {
for (int i = 0; i < diff; ++i) cout << s[i];
required[c]++;
cout << c;
for (c = 'a'; c <= 'z'; c++)
for (int i = 0; i < chars[c] - required[c]; ++i) cout << c;
return 0;
}
}
cout << -1 << '\n';
}
|
#include <bits/stdc++.h>
char s[5009], t[5009], ans[5009];
int cnt[1 << 8];
int main() {
int i, j, k, l1, l2;
while (scanf("%s%s", s, t) != EOF) {
l1 = strlen(s);
l2 = strlen(t);
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < l1; i++) {
cnt[s[i]]++;
}
for (i = 0; i < l2; i++) {
if (cnt[t[i]] == 0) break;
ans[i] = t[i];
cnt[t[i]]--;
}
if (i == l2 && l1 > l2) {
for (j = 0; j < 128; j++) {
for (k = 0; k < cnt[j]; k++) ans[i++] = j;
}
ans[i] = 0;
puts(ans);
continue;
}
cnt[t[i]]--;
for (j = i; j >= 0; j--) {
cnt[t[j]]++;
for (k = t[j] + 1; k <= 'z'; k++) {
if (cnt[k]) break;
}
if (k <= 'z') {
ans[j++] = k;
cnt[k]--;
for (i = 0; i < 128; i++) {
for (k = 0; k < cnt[i]; k++) ans[j++] = i;
}
ans[j] = 0;
break;
}
}
puts(j < 0 ? "-1" : ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
char ans[5005];
int freq[27];
int func(int index, int possible) {
if (index == s.length()) return possible;
for (int i = 0; i < 26; i++) {
if (freq[i] > 0 && (possible || i >= t[index] - 'a')) {
ans[index] = i + 'a';
freq[i]--;
if (func(index + 1, possible || (i > t[index] - 'a'))) return 1;
freq[i]++;
}
}
return 0;
}
int main() {
cin >> s >> t;
for (int i = 0; i < s.length(); i++) freq[s[i] - 'a']++;
if (func(0, 0) == 0)
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5005], t[5005];
char ans[5005];
int letter[27], ls, lt, l;
bool search(int p) {
if (p >= lt) {
l = p;
ans[p] = '\0';
if (ls == lt) return false;
return true;
}
if (letter[t[p] - 'a'] > 0) {
letter[t[p] - 'a']--;
ans[p] = t[p];
if (search(p + 1)) return true;
letter[t[p] - 'a']++;
}
for (int i = t[p] - 'a' + 1; i < 26; i++)
if (letter[i] > 0) {
ans[p] = i + 'a';
ans[p + 1] = '\0';
letter[i]--;
l = p;
return true;
}
return false;
}
void getans() {
int i;
if (l >= lt) l--;
for (i = 0; i < 26; i++)
while (letter[i]--) {
ans[++l] = i + 'a';
}
ans[++l] = '\0';
printf("%s\n", ans);
}
int main() {
int i;
while (scanf("%s %s", s, t) != EOF) {
memset(letter, 0, sizeof(letter));
ls = strlen(s);
lt = strlen(t);
for (i = 0; i < ls; i++) letter[s[i] - 'a']++;
if (search(0)) {
if (l < lt) {
getans();
} else if (ans[lt - 1] != t[lt - 1] || ls > lt) {
getans();
} else
printf("-1\n");
} else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5050;
char s[maxn];
char t[maxn];
int a[30], b[30];
int main() {
int i, j, k, l, lens, lent, sum, cnt;
bool ans, flag;
while (~scanf("%s%s", s, t)) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
lens = strlen(s);
lent = strlen(t);
for (i = 0; i < lens; i++) a[s[i] - 'a']++;
for (i = 0; i < lent; i++) b[t[i] - 'a']++;
ans = true;
sum = 0;
for (i = 0; i < 26; i++) {
if (a[i] < b[i]) ans = false;
if (a[i] > b[i]) sum++;
}
int cnt;
if (ans && sum) {
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--) {
ans = true;
b[t[i] - 'a']--;
for (j = 0; j < 26; j++)
if (a[j] < b[j]) ans = false;
if (!ans) 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 limite = 10000;
string t;
string sol;
map<char, int> m;
bool alguien() {
for (map<char, int>::iterator it = m.begin(); it != m.end(); it++)
if (it->second) return true;
return false;
}
void completar(int is) {
for (map<char, int>::iterator it = m.begin(); it != m.end(); it++) {
while (it->second) {
sol[is++] = it->first;
(it->second)--;
}
}
}
bool sepuede(int is) {
if (is == int(t.size())) {
if (alguien()) {
completar(is);
return true;
}
return false;
}
if (m[t[is]]) {
m[t[is]]--;
sol[is] = t[is];
if (sepuede(is + 1)) return true;
m[t[is]]++;
}
map<char, int>::iterator it = m.begin();
while (it != m.end() and not((it->second) > 0 and (it->first) > t[is])) it++;
if (it != m.end()) {
(it->second)--;
sol[is] = it->first;
completar(is + 1);
return true;
}
return false;
}
int main() {
string s;
cin >> s >> t;
sol = s;
for (int i = 0; i < int(s.size()); i++) m[s[i]]++;
if (sepuede(0)) {
cout << sol << endl;
} else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[125];
char sa[5005];
int main() {
bool ok, whh;
int lens, lent;
string s, t, my;
cin >> s >> t;
memset(cnt, 0, sizeof cnt);
lens = s.length();
for (int i = 0; i < lens; i++) cnt[s[i]]++;
ok = true;
whh = false;
my = s;
lent = t.length();
if (lens <= lent) {
for (int i = 0; i < lens; i++) {
char c = t[i];
if (whh) {
c = 'a';
while (c <= 'z')
if (cnt[c]) {
cnt[c]--;
break;
} else
c++;
my[i] = c;
continue;
}
if (!ok) {
c = 'z';
while (c >= 'a')
if (cnt[c]) {
cnt[c]--;
break;
} else
c--;
my[i] = c;
continue;
}
while (c <= 'z')
if (cnt[c]) {
cnt[c]--;
break;
} else
c++;
if (c == t[i])
my[i] = c;
else if (c <= 'z') {
my[i] = c;
whh = true;
} else {
ok = false;
c = 'z';
while (c >= 'a')
if (cnt[c]) {
cnt[c]--;
break;
} else
c--;
my[i] = c;
continue;
}
}
if (my == t) {
strcpy(sa, my.c_str());
if (!next_permutation(sa, sa + lens))
ok = false;
else {
string tmp(sa);
my = tmp;
}
} else if (my < t) {
strcpy(sa, my.c_str());
while (next_permutation(sa, sa + lens)) {
string tmp(sa);
if (tmp > t) {
my = tmp;
break;
}
}
if (my <= t)
ok = false;
else
ok = true;
}
} else {
for (int i = 0; i < lens; i++) {
char c = t[i];
if (whh) {
c = 'a';
while (c <= 'z')
if (cnt[c]) {
cnt[c]--;
break;
} else
c++;
my[i] = c;
continue;
}
if (!ok) {
c = 'z';
while (c >= 'a')
if (cnt[c]) {
cnt[c]--;
break;
} else
c--;
my[i] = c;
continue;
}
while (c <= 'z')
if (cnt[c]) {
cnt[c]--;
break;
} else
c++;
if (c == t[i])
my[i] = c;
else if (c <= 'z') {
my[i] = c;
whh = true;
} else {
ok = false;
c = 'z';
while (c >= 'a')
if (cnt[c]) {
cnt[c]--;
break;
} else
c--;
my[i] = c;
continue;
}
}
if (my == t) {
strcpy(sa, my.c_str());
if (!next_permutation(sa, sa + lens))
ok = false;
else {
string tmp(sa);
my = tmp;
}
} else if (my < t) {
strcpy(sa, my.c_str());
while (next_permutation(sa, sa + lens)) {
string tmp(sa);
if (tmp > t) {
my = tmp;
break;
}
}
if (my <= t)
ok = false;
else
ok = true;
}
}
if (ok)
cout << my << endl;
else
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
string s, t;
int cntt[5010][30];
int cnts[5010][30];
int cntS[5010];
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> s >> t;
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
if (s <= t) {
cout << -1 << '\n';
return 0;
}
reverse(s.begin(), s.end());
for (int(i) = 0, j123 = int(s.size()); (i) < j123; (i)++) {
if (i > 0)
for (char ch = 'a'; ch <= 'z'; ch++)
cnts[i][ch - 'a'] = cnts[i - 1][ch - 'a'];
cnts[i][s[i] - 'a']++;
}
for (char ch = 'a'; ch <= 'z'; ch++)
cntS[ch - 'a'] = cnts[int(s.size()) - 1][ch - 'a'];
for (int(i) = 0, j123 = int(t.size()); (i) < j123; (i)++) {
if (i > 0)
for (char ch = 'a'; ch <= 'z'; ch++)
cntt[i][ch - 'a'] = cntt[i - 1][ch - 'a'];
cntt[i][t[i] - 'a']++;
}
int prefLen = -1;
int allgood = 1;
for (int(i) = 0, j123 = min(int(s.size()), int(t.size())) + 1; (i) < j123;
(i)++) {
int good = 1;
int any = 0;
if (i > 0) {
for (char ch = 'a'; ch <= 'z'; ch++) {
good &= cntt[i - 1][ch - 'a'] <= cnts[int(s.size()) - 1][ch - 'a'];
}
}
if (i < int(t.size()) && i < int(s.size())) {
for (char ch = t[i] + 1; ch <= 'z'; ch++) {
if (i > 0)
any |= cntt[i - 1][ch - 'a'] <= cnts[int(s.size()) - 1][ch - 'a'] - 1;
else
any |= 1 <= cnts[int(s.size()) - 1][ch - 'a'];
}
} else {
if (i < int(s.size()) && i >= int(t.size())) any = 1;
}
good &= any;
allgood &= good;
if (good) {
prefLen = i;
}
}
stringstream ss;
for (int i = 0; i < prefLen; i++) {
ss << t[i];
cntS[t[i] - 'a']--;
}
if (prefLen < int(t.size())) {
for (char ch = t[prefLen] + 1; ch <= 'z'; ch++) {
if (cntS[ch - 'a'] > 0) {
ss << ch;
cntS[ch - 'a']--;
break;
}
}
}
for (char ch = 'a'; ch <= 'z'; ch++) {
while (cntS[ch - 'a'] > 0) {
cntS[ch - 'a']--;
ss << ch;
}
}
ss << '\n';
cout << ss.str();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
vector<char> v;
int a[150] = {0}, f;
cin >> s >> t;
for (int i = 0; i < s.length(); i++) a[s[i]]++;
for (int i = 0; i < t.length(); i++) {
if (a[t[i]] && i != s.length() - 1) {
v.push_back(t[i]);
a[t[i]]--;
} else {
for (int j = t[i] + 1; j < 'a' + 26; j++) {
if (a[j]) {
v.push_back(j);
a[j]--;
goto print;
}
}
while (v.size()) {
char c = v.back();
a[c]++;
v.pop_back();
for (int j = c + 1; j < 'a' + 26; j++) {
if (a[j]) {
v.push_back(j);
a[j]--;
goto print;
}
}
}
cout << -1 << endl;
return 0;
}
}
print:
for (int i = 0; i < v.size(); i++) cout << (char)v[i];
for (int i = 'a'; i < 'a' + 26; i++) {
while (a[i]--) cout << char(i);
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool gt(long double a, long double b) { return a > b + 1e-9; }
string a, b;
int fa[26], fb[26];
int main() {
ios::sync_with_stdio(false);
cin >> a >> b;
for (int same = min(((int)(a).size()), ((int)(b).size())); same >= 0;
same--) {
memset(fa, 0, sizeof fa);
memset(fb, 0, sizeof fb);
for (register int i = (0); i < (int)(same); ++i) fb[b[i] - 'a']++;
for (register int i = (0); i < (int)(((int)(a).size())); ++i)
fa[a[i] - 'a']++;
bool ok = true;
for (register int i = (0); i < (int)(26); ++i)
if (fa[i] < fb[i])
ok = false;
else
fa[i] -= fb[i];
if (!ok) continue;
string tmp = b.substr(0, same);
for (register int i = (0); i < (int)(26); ++i)
if (i + 'a' > b[same] && fa[i] > 0) {
fa[i]--;
tmp += char(i + 'a');
break;
}
for (register int i = (0); i < (int)(26); ++i)
while (fa[i]--) tmp += char(i + 'a');
if (tmp > b) {
cout << tmp << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[32];
bool ok() {
for (int i = 0; i < (int)(32); i++)
if (cnt[i] < 0) return false;
return true;
}
int main() {
string s, t;
cin >> s >> t;
for (int i = 0; i < (int)(s.size()); i++) cnt[s[i] - 'a']++;
const int m = min(s.size(), t.size());
for (int i = 0; i < (int)(m); i++) cnt[t[i] - 'a']--;
string ans;
if (ok() && s.size() > t.size()) {
ans = t.substr(0, m);
for (int i = 0; i < (int)(32); i++)
while (cnt[i]--) ans += (char)(i + 'a');
} else {
for (int k = m - 1; k >= 0; k--) {
cnt[t[k] - 'a']++;
if (!ok()) continue;
int ix = -1;
for (int i = 31; i > t[k] - 'a'; i--)
if (cnt[i]) ix = i;
if (ix != -1) {
ans = t.substr(0, k);
cnt[ix]--;
ans += (char)(ix + 'a');
for (int i = 0; i < (int)(32); i++)
while (cnt[i]--) ans += (char)(i + 'a');
break;
}
}
if (ans.size() == 0) ans = "-1";
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int a1[28];
string repeat(char ch, int n) {
string s = "";
s += ch;
string ans = "";
while (n) {
if (n & 1) ans += s;
s += s;
n >>= 1;
}
return ans;
}
string dfs(int x) {
if (x == s2.size()) {
if (s1.size() == s2.size()) return "-1";
string temstring = "";
for (int i = 0; i < 26; i++) temstring += repeat(i + 'a', a1[i]);
return temstring;
}
int p = s2[x] - 'a';
if (a1[p] != 0) {
a1[p]--;
string temstring = dfs(x + 1);
if (temstring != "-1") {
return s2[x] + temstring;
} else {
a1[p]++;
}
}
for (int i = p + 1; i < 26; i++) {
if (a1[i] > 0) {
string temstring = "";
temstring += (i + 'a');
a1[i]--;
for (int j = 0; j < 26; j++) temstring += repeat(j + 'a', a1[j]);
return temstring;
}
}
return "-1";
}
int main() {
cin >> s1 >> s2;
for (int i = s1.size() - 1; i >= 0; i--) a1[s1[i] - 'a']++;
cout << dfs(0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 30;
int n, h[30];
string s, s1;
int main() {
cin >> s >> s1;
for (auto i : s) h[i - 'a']++;
int last = -1, n = s.length(), m = s1.length();
while (last < min(n - 1, m - 1) && h[s1[last + 1] - 'a'])
h[s1[++last] - 'a']--, s[last] = s1[last];
s1.push_back('a' - 1);
while (last >= -1) {
for (auto j = s1[last + 1] - 'a' + 1; j <= 25; j++)
if (h[j]) {
h[j]--;
s[last + 1] = 'a' + j;
int cur = last + 2;
for (auto i = 0; i <= 25; i++)
while (h[i]) s[cur++] = 'a' + i, h[i]--;
cout << s;
return 0;
}
if (last >= 0)
h[s1[last--] - 'a']++;
else
break;
}
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, inf = 1e9 + 7;
long long n, k, f[30];
string s, t, r;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j, a, b, ans = 0;
cin >> s >> t;
r = s;
sort(r.begin(), r.end(), greater<long long>());
if (r <= t) return cout << -1, 0;
n = s.size();
for (i = 0; i < n; i++) f[s[i] - 'a']++;
k = t.size();
for (i = 0; i < min(k, n); i++) {
if (f[t[i] - 'a']) {
s[i] = t[i], f[t[i] - 'a']--;
} else {
for (j = t[i] - 'a'; j < 26; j++)
if (f[j]) {
s[i] = char(j + 'a');
f[j]--;
i++;
for (j = 0; j < 26; j++) {
while (f[j]--) s[i] = char(j + 'a'), i++;
}
cout << s;
return 0;
}
for (j = 25; j >= 0; j--) {
while (f[j]--) s[i] = char(j + 'a'), i++;
}
next_permutation(s.begin(), s.end());
cout << s;
return 0;
}
}
if (i == n) next_permutation(s.begin(), s.end());
for (j = 0; j < 26; j++) {
while (f[j]--) s[i] = char(j + 'a'), i++;
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
char second[5555];
char t[5555];
int n, m;
int cnt[5555][26];
int tcnt[26], ccnt[26];
int main() {
scanf("%s", &second[1]);
second[0] = '*';
n = strlen(second) - 1;
scanf("%s", &t[1]);
t[0] = '*';
m = strlen(t) - 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < 26; ++j) cnt[i][j] = cnt[i - 1][j];
++cnt[i][t[i] - 'a'];
}
for (int i = 1; i <= n; ++i) ++tcnt[second[i] - 'a'];
if (n > m) {
bool ok = true;
for (int i = 0; i < 26; ++i) {
ccnt[i] = tcnt[i] - cnt[m][i];
if (ccnt[i] < 0) ok = false;
}
if (ok) {
for (int i = 1; i <= m; ++i) putchar(t[i]);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ccnt[i]; ++j) putchar('a' + i);
puts("");
return 0;
}
}
for (int i = m - 1; i >= 0; --i) {
bool ok = true;
for (int j = 0; j < 26; ++j) {
ccnt[j] = tcnt[j] - cnt[i][j];
if (ccnt[j] < 0) {
ok = false;
break;
}
}
if (!ok) continue;
ok = false;
for (int j = t[i + 1] - 'a' + 1; j < 26; ++j)
if (ccnt[j] > 0) {
ok = true;
break;
}
if (!ok) continue;
for (int j = 1; j <= i; ++j) putchar(t[j]);
for (int j = t[i + 1] - 'a' + 1; j < 26; ++j)
if (ccnt[j] > 0) {
putchar('a' + j);
--ccnt[j];
break;
}
for (int j = 0; j < 26; ++j)
for (int k = 0; k < ccnt[j]; ++k) putchar('a' + j);
puts("");
return 0;
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(pair<int, int> pair1, pair<int, int> pair2) {
return (pair1.first < pair2.first ||
(pair1.first == pair2.first && pair1.second < pair2.second));
}
vector<long long> v;
vector<long long> m;
vector<pair<int, int> > r;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
string c = s;
reverse(c.begin(), c.end());
if (t >= c) {
cout << -1;
return 0;
}
for (int i = 0; i < min(s.size(), t.size()); i++) {
int j = distance(s.begin(), lower_bound(s.begin() + i, s.end(), t[i]));
if (j >= s.size()) {
sort(s.begin() + i, s.end());
reverse(s.begin() + i, s.end());
next_permutation(s.begin(), s.end());
break;
}
swap(s[i], s[j]);
sort(s.begin() + i + 1, s.end());
if (s[i] > t[i]) {
break;
}
}
if (s == t) {
next_permutation(s.begin(), s.end());
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[5010], s2[5010], s3[5010];
int num[100];
bool cmp(char x, char y) { return x > y; }
bool ok(int p) {
int now = 0;
for (int i = 25; i >= 0; i--)
for (int j = 0; j < num[i]; j++) s3[now++] = i + 'a';
s3[now] = 0;
if (strcmp(s3, s2 + p) > 0) return true;
return false;
}
int main() {
while (scanf("%s%s", s1, s2) == 2) {
int len1 = strlen(s1), len2 = strlen(s2);
memset(num, 0, sizeof(num));
for (int i = 0; i < len1; i++) num[s1[i] - 'a']++;
int i;
if (!ok(0)) {
puts("-1");
continue;
}
bool okk = true;
for (int i = 0; i < len2; i++) {
if (num[s2[i] - 'a'] != 0) {
num[s2[i] - 'a']--;
if (ok(i + 1)) {
printf("%c", s2[i]);
continue;
}
num[s2[i] - 'a']++;
}
for (int ii = 0; ii < 26; ii++)
if (num[ii] > 0 && ii + 'a' > s2[i]) {
printf("%c", ii + 'a');
num[ii]--;
break;
}
for (int ii = 0; ii < 26; ii++)
for (int j = 0; j < num[ii]; j++) printf("%c", ii + 'a');
printf("\n");
okk = false;
break;
}
if (okk) {
for (int ii = 0; ii < 26; ii++)
for (int j = 0; j < num[ii]; j++) printf("%c", ii + 'a');
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:9999999999")
const long long mod = 998244353;
using namespace std;
bool check(string &x, vector<int> &cnt, string t) {
string a = x;
for (int i = 25; i >= 0; i--) {
for (int(j) = 0; (j) < cnt[i]; (j)++) a.push_back((char)(i + 'a'));
}
return (a > t);
}
int main() {
string s, t;
cin >> s;
cin >> t;
vector<int> cnt(26, 0);
for (int(i) = 0; (i) < s.length(); (i)++) {
cnt[s[i] - 'a']++;
}
sort((s).rbegin(), (s).rend());
if (s <= t) {
cout << -1;
return 0;
}
string ans = "";
for (int i = 0; i < s.length(); i++) {
if (i >= t.length()) {
for (int(j) = 0; (j) < 26; (j)++) {
for (int(k) = 0; (k) < cnt[j]; (k)++) {
ans.push_back((char)(j + 'a'));
}
}
cout << ans;
exit(0);
}
int x = t[i] - 'a';
string tmp = ans;
if (cnt[x]) {
tmp.push_back((char)(x + 'a'));
cnt[x]--;
if (check(tmp, cnt, t)) {
ans.push_back((char)(x + 'a'));
continue;
} else {
cnt[x]++;
tmp.pop_back();
for (int j = x + 1;; j++) {
if (cnt[j]) {
ans.push_back((char)(j + 'a'));
cnt[j]--;
break;
}
}
for (int(j) = 0; (j) < 26; (j)++) {
for (int(k) = 0; (k) < cnt[j]; (k)++) {
ans.push_back((char)(j + 'a'));
}
}
cout << ans;
exit(0);
}
} else {
for (int j = x + 1;; j++) {
if (cnt[j]) {
ans.push_back((char)(j + 'a'));
cnt[j]--;
break;
}
}
for (int(j) = 0; (j) < 26; (j)++) {
for (int(k) = 0; (k) < cnt[j]; (k)++) {
ans.push_back((char)(j + 'a'));
}
}
cout << ans;
exit(0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
char s[N], t[N];
int cntf[30], cnts[30], n, m, pos = -1, ans = -1;
int ff[30], fs[30];
bool cmp(char a, char b) { return (a > b); }
vector<char> ret;
int main() {
scanf("%s%s", s, t);
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; i++) cntf[s[i] - 'a']++;
for (int i = 0; i < m; i++) cnts[t[i] - 'a']++;
bool init = true;
for (int i = 0; i < 26; i++) {
if (cntf[i] < cnts[i]) {
init = false;
break;
}
}
if (init && n > m) {
printf("%s", t);
for (int i = 0; i < 26; i++) {
cntf[i] -= cnts[i];
for (int j = 0; j < cntf[i]; j++) cout << (char)(i + 'a');
}
return 0;
}
sort(s, s + n, cmp);
for (int i = 0; i < m; i++) {
bool ok = true;
for (int j = 0; j < 26; j++) {
if (cntf[j] < fs[j]) {
ok = false;
break;
}
}
if (!ok) break;
for (int j = t[i] - 'a' + 1; j < 26; j++) {
if (cntf[j] - fs[j] - 1 >= 0) {
ans = j;
pos = i;
break;
}
}
fs[t[i] - 'a']++;
}
if (ans == -1) {
printf("-1");
return 0;
}
memset(fs, 0, sizeof fs);
for (int i = 0; i < pos; i++) {
fs[t[i] - 'a']++;
ret.push_back(t[i]);
}
ret.push_back((char)(ans + 'a'));
cntf[ans]--;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < cntf[i] - fs[i]; j++) ret.push_back((char)(i + 'a'));
}
for (int i = 0; i < ret.size(); i++) cout << ret[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 20);
string str1, str2;
int sz1, sz2, cnt[MX];
string sol;
bool check(int pos) {
if (pos == sz2 + 1) return sz1 > sz2;
string str;
for (char j = 'z'; j >= 'a'; j--)
for (int i = 0; i < cnt[j]; i++) str.push_back(j);
for (int j = 0;; j++) {
if (j + pos > sz2) break;
if (j == str.length()) break;
if (str[j] > str2[j + pos]) return true;
if (str[j] < str2[j + pos]) return false;
}
return str.length() > sz2 - pos + 1;
}
void normalize(int pos) {
for (char j = 'a'; j <= 'z'; j++)
for (int i = 0; i < cnt[j]; i++) sol[pos++] = j;
}
int main() {
cin >> str1 >> str2;
sz1 = str1.size();
sz2 = str2.size();
str1 = "#" + str1;
str2 = "#" + str2;
sol.resize(sz1 + 1);
for (int j = 1; j <= sz1; j++) cnt[str1[j]]++;
if (!check(1)) {
puts("-1");
return 0;
}
for (int j = 1; j <= min(sz1, sz2); j++) {
if (cnt[str2[j]]) {
cnt[str2[j]]--;
if (check(j + 1)) {
sol[j] = str2[j];
continue;
}
cnt[str2[j]]++;
}
for (char let = str2[j] + 1; let <= 'z'; let++) {
if (!cnt[let]) continue;
sol[j] = let;
cnt[let]--;
normalize(j + 1);
goto fin;
}
}
normalize(sz2 + 1);
fin:;
cout << sol.substr(1, sz1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 999999999;
const double PI = 3.1415931;
const double eps = 1e-9;
int cnt[100], mem[100];
int main() {
ios_base::sync_with_stdio(false);
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) mem[s[i] - 'a']++;
for (int i = min(s.size(), t.size()); i >= 0; i--) {
if (i == s.size()) continue;
for (int j = 0; j < 26; j++) {
cnt[j] = mem[j];
}
string tmp;
bool flag = true;
for (int j = 0; j < i; j++) {
if (cnt[t[j] - 'a'] < 1) flag = false;
tmp += t[j];
cnt[t[j] - 'a']--;
}
if (!flag) continue;
if (i != t.size()) {
for (int j = t[i] - 'a' + 1; j <= 26; j++) {
if (j == 26) flag = false;
if (cnt[j] > 0) {
cnt[j]--;
tmp += char(j + 'a');
break;
}
}
}
if (!flag) continue;
for (int j = 0; j < 26; j++) {
while (cnt[j] > 0) {
cnt[j]--;
tmp += char(j + 'a');
}
}
cout << tmp << endl;
return 0;
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b, c, s;
int main() {
while (cin >> a >> b) {
sort(a.begin(), a.end());
int i = 0, r = -1, k = -1;
bool f = 0;
c = "";
while (i < b.length() && !a.empty()) {
int g = upper_bound(a.begin(), a.end(), b[i]) - a.begin();
if (a.length() - g > 0) {
k = c.length();
r = g;
s = a;
}
--g;
if (f < 0 || a[g] < b[i]) {
++g;
f = 1;
}
if (g < 0 || g >= a.length()) break;
c += a[g];
a.erase(a.begin() + g);
if (f) break;
++i;
}
c += a;
if (c > b)
cout << c << endl;
else {
if (r != -1) {
c = c.substr(0, k);
c += s[r];
s.erase(s.begin() + r);
c += s;
cout << c << endl;
} else {
cout << "-1" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
char s[10005], t[10005];
int cnt[10005], pre[10005], lent, lens;
bool ok;
int gen(int p, char x) {
for (int i = 0; i <= p; ++i) printf("%c", t[i]);
if (x != '#') {
printf("%c", x);
pre[x - 'a']--;
}
for (int i = 0; i < 26; ++i)
for (int j = 1; j <= pre[i]; ++j) printf("%c", i + 'a');
puts("");
}
int dfs(int dep) {
if (dep >= lent) {
if (lens == lent) return 0;
ok = true;
gen(dep - 1, '#');
return 0;
}
if (pre[t[dep] - 'a']) {
pre[t[dep] - 'a']--;
dfs(dep + 1);
pre[t[dep] - 'a']++;
if (ok) return 0;
}
int zz = t[dep] - 'a';
for (int i = zz + 1; i < 26; ++i)
if (pre[i]) {
gen(dep - 1, i + 'a');
ok = true;
return 0;
}
return 0;
}
int main() {
scanf("%s", s);
scanf("%s", t);
lent = strlen(t);
lens = strlen(s);
for (int i = 0; i < lens; ++i) pre[s[i] - 'a']++;
ok = false;
dfs(0);
if (!ok) puts("-1");
}
|
#include <bits/stdc++.h>
int n, c[26] = {0};
char str1[5005], str2[5001];
bool solve(int i) {
int c1[26];
for (int h = 0; h < 26; h++) c1[h] = c[h];
int h = 25;
for (; i < n; i++) {
while (c1[h] == 0) h--;
str1[i] = h + 'a';
c1[h]--;
}
return strcmp(str1, str2) > 0;
}
int main() {
scanf("%s%s", str1, str2);
n = strlen(str1);
for (int i = 0; i < n; i++) c[str1[i] - 'a']++;
if (!solve(0))
printf("-1\n");
else {
for (int i = 0; i < n; i++) {
for (int h = 0; h < 26; h++)
if (c[h] > 0) {
c[h]--;
str1[i] = h + 'a';
if (solve(i + 1)) break;
c[h]++;
}
}
printf("%s\n", str1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
int wys[26];
int twys[26];
int n, m;
string s, t;
char res[N];
bool proba(int tyle) {
int dl = 0;
for (int i = 0; i < (26); ++i) twys[i] = wys[i];
for (int i = 0; i < (tyle); ++i) {
if (twys[t[i] - 'a'] == 0) return false;
res[++dl] = t[i];
twys[t[i] - 'a']--;
}
int potrz;
if (tyle < m)
potrz = t[tyle] - 'a' + 1;
else
potrz = 0;
while (potrz < 26 && twys[potrz] == 0) {
potrz++;
}
if (potrz == 26) return false;
res[++dl] = (potrz + 'a');
twys[potrz]--;
int wsk = 0;
while (wsk < 26) {
while (twys[wsk] > 0) {
res[++dl] = (wsk + 'a');
twys[wsk]--;
}
wsk++;
}
res[dl + 1] = '\0';
return true;
}
bool p2(int tyle) {
int dl = 0;
for (int i = 0; i < (26); ++i) twys[i] = wys[i];
for (int i = 0; i < (tyle); ++i) {
if (twys[t[i] - 'a'] == 0) return false;
res[++dl] = t[i];
twys[t[i] - 'a']--;
}
int wsk = 0;
while (wsk < 26) {
while (twys[wsk] > 0) {
res[++dl] = (wsk + 'a');
twys[wsk]--;
}
wsk++;
}
res[dl + 1] = '\0';
return true;
}
string wzor() {
for (int i = 0; i < (n); ++i) wys[s[i] - 'a']++;
int maxTS = min(m, n - 1);
for (int i = maxTS; i >= (0); --i) {
if (proba(i)) {
string odp = s;
for (int j = 1; j <= (n); ++j) odp[j - 1] = res[j];
return odp;
}
}
if (n > m)
if (p2(m)) {
string odp = s;
for (int j = 1; j <= (n); ++j) odp[j - 1] = res[j];
return odp;
}
return "-1";
}
string brut() {
string pom = s;
sort(pom.begin(), pom.end());
do {
if (pom > t) {
return pom;
}
} while (next_permutation(pom.begin(), pom.end()));
return "-1";
}
int main() {
cin >> s >> t;
n = (int)s.size(), m = (int)t.size();
cout << wzor() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch;
int a[5005];
char b[5005], c[5005];
int cnt, ccnt, sum;
bool cmp() {
for (int i = 1; i <= sum; i++) {
if (c[i] > b[i]) {
return true;
} else if (c[i] < b[i]) {
return false;
}
}
return false;
}
void dfs(int num, bool ok) {
if (sum >= ccnt) {
if (cmp() == false) {
return;
}
for (int i = 1; i <= sum; i++) {
cout << c[i];
}
exit(0);
}
if (ok == false) {
if (a[b[num]] > 0) {
a[b[num]]--;
sum++;
c[sum] = b[num];
dfs(num + 1, ok);
a[b[num]]++;
sum--;
}
bool pd = false;
for (int i = b[num] + 1; i <= 'z'; i++) {
if (a[i] > 0) {
a[i]--;
sum++;
c[sum] = (char)i;
pd = true;
dfs(num + 1, true);
sum--;
a[i]++;
break;
}
}
if (pd == false) {
return;
}
} else {
for (int i = 'a'; i <= 'z'; i++) {
if (a[i] > 0) {
a[i]--;
sum++;
c[sum] = (char)i;
dfs(num + 1, ok);
sum--;
a[i]++;
}
}
}
}
int main() {
scanf("%c", &ch);
while (ch >= 'a') {
ccnt++;
a[ch]++;
scanf("%c", &ch);
}
scanf("%c", &ch);
while (ch >= 'a') {
cnt++;
b[cnt] = ch;
scanf("%c", &ch);
}
dfs(1, false);
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
int my[128] = {0};
char a[5005] = {0}, b[5005] = {0};
char str[5005] = {0};
bool tt(int x) {
int k = 0;
for (k = 'z'; k > b[x]; k--) {
if (my[k] > 0) {
return true;
}
}
if (my[b[x]] > 0) {
my[b[x]]--;
bool ans = tt(x + 1);
my[b[x]]++;
return ans;
}
return false;
}
int main() {
int i = 0, j = 0;
while (scanf("%s%s", a, b) == 2) {
memset(my, 0, sizeof(my));
for (i = 0; a[i]; i++) {
my[a[i]]++;
}
if (!tt(0)) {
printf("%d\n", -1);
continue;
}
for (i = 0;; i++) {
if (my[b[i]] > 0) {
my[b[i]]--;
if (tt(i + 1)) {
str[i] = b[i];
} else {
my[b[i]]++;
break;
}
} else {
break;
}
}
for (j = b[i] + 1; j <= 'z'; j++) {
if (my[j] > 0) {
break;
}
}
my[j]--;
str[i] = j;
for (j = 'a'; j <= 'z'; j++) {
while (my[j] > 0) {
str[++i] = j;
my[j]--;
}
}
str[++i] = '\0';
printf("%s\n", str);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10000], t[10000];
int sn, tn;
int a[30], b[30];
int main() {
scanf("%s", s);
sn = strlen(s);
scanf("%s", t);
tn = strlen(t);
for (int si = 0; si < sn; si++) {
int p = s[si] - 'a';
a[p]++, b[p]++;
}
int k = -1, mn = min(sn, tn), ai = 25;
for (int mi = 0; mi <= mn; mi++) {
while (ai >= 0 && !a[ai]) ai--;
if (ai < 0) break;
int p = t[mi] - 'a';
if (mi == mn)
k = mi;
else if (ai > p)
k = mi;
if (!a[p]) break;
a[p]--;
}
if (k == -1) {
puts("-1");
return 0;
}
for (int ki = 0; ki < k; ki++) {
int p = t[ki] - 'a';
printf("%c", t[ki]);
b[p]--;
}
int qi;
if (tn == k)
qi = 0;
else
qi = t[k] - 'a' + 1;
while (!b[qi]) qi++;
printf("%c", qi + 'a');
b[qi]--;
for (int bi = 0; bi < 26; bi++)
while (b[bi]--) printf("%c", bi + 'a');
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
char str1[5050], str2[5050];
int h[30];
int len, i, j;
bool same(char*, char*);
void ist(char*, char);
void del(char*);
bool workit();
int main() {
memset(str1, 0, sizeof(str1));
memset(str2, 0, sizeof(str2));
cin >> str1 >> str2;
len = strlen(str1);
memset(h, 0, sizeof(h));
for (i = 0; i < len; i++) h[str1[i] - 'a' + 1]++;
if (!workit()) cout << -1 << endl;
}
bool big(char* str1, char* str2) {
int len, len1, i;
len = strlen(str1);
len1 = strlen(str2);
int min = len;
if (min > len1) min = len;
for (i = 0; i < min; i++) {
if (str1[i] > str2[i]) return true;
if (str1[i] < str2[i]) return false;
}
if (len > len1) return true;
return false;
}
bool workit() {
int i, l, stt;
bool find, bigout;
char ans[5050];
memset(ans, 0, sizeof(ans));
l = 0;
stt = 1;
bigout = false;
while (l < len) {
find = false;
for (i = 1; i <= 26; i++)
if (h[i] > 0 && ('a' + i - 1 >= str2[l])) {
find = true;
ist(ans, (char)('a' + i - 1));
l++;
stt = 1;
break;
}
if (big(ans, str2)) break;
if (l == len && !big(ans, str2)) find = false;
while (!find) {
if (l == 0) return false;
l--;
del(ans);
for (i = 1; i <= 26; i++)
if (h[i] > 0 && 'a' + i - 1 > str2[l]) {
find = true;
ist(ans, (char)('a' + i - 1));
l++;
bigout = true;
break;
}
}
if (bigout) break;
}
for (; l < len;) {
for (i = 1; i <= 26; i++)
if (h[i] > 0) {
l++;
ist(ans, (char)('a' + i - 1));
break;
}
}
cout << ans << endl;
return true;
}
void del(char* str) {
int len;
len = strlen(str);
if (len == 0) return;
h[str[len - 1] - 'a' + 1]++;
str[len - 1] = '\0';
}
void ist(char* str, char x) {
int len;
len = strlen(str);
str[len] = x;
str[len + 1] = '\0';
h[x - 'a' + 1]--;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 100000 + 10;
char s[size], t[size], s1[size];
int num1[30], num2[30], flag = 0;
int main() {
cin >> s >> t;
memset(num1, 0, sizeof(num1));
for (int i = 0; i < strlen(s); i++) num1[s[i] - 'a']++;
int i, j;
for (i = 0; s[i] && t[i]; i++)
if (num1[t[i] - 'a'] > 0)
num1[t[i] - 'a']--, s1[i] = t[i];
else
break;
j = t[i] ? t[i] - 'a' : 0;
for (j; j < 26; j++)
if (num1[j] > 0) {
num1[j]--, s1[i++] = j + 'a';
flag = 1;
break;
}
if (flag) {
for (; s[i]; i++)
for (j = 0; j < 26; j++)
if (num1[j]) {
num1[j]--, s1[i] = j + 'a';
break;
}
puts(s1);
} else {
for (; s[i]; i++)
for (j = 25; j >= 0; j--)
if (num1[j]) {
num1[j]--, s1[i] = j + 'a';
break;
}
if (!next_permutation(s1, s1 + i))
puts("-1");
else
puts(s1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, ans;
int snum[26];
int cnt[5001][26];
int main() {
cin >> s >> t;
ans = s;
int len1 = s.size();
int len2 = t.size();
for (int i = 0; i < len1; i++) snum[s[i] - 'a']++;
for (int i = 1; i <= len2; i++)
for (int j = 0; j < 26; j++) {
if (j == t[i - 1] - 'a')
cnt[i][j] = cnt[i - 1][j] + 1;
else
cnt[i][j] = cnt[i - 1][j];
}
if (len1 > len2) {
int judge = 1;
for (int i = 0; i < 26; i++)
if (cnt[len2][i] > snum[i]) judge = 0;
if (judge == 1) {
for (int i = 0; i < len2; i++) {
cout << t[i];
snum[t[i] - 'a']--;
}
for (int i = 0; i < 26; i++)
if (snum[i] != 0) {
cout << (char)(i + 'a');
snum[i]--;
i--;
}
return 0;
}
}
for (int i = len2 - 1; i >= 0; i--) {
int judge, temp = t[i] - 'a';
for (int j = temp + 1; j < 26; j++) {
judge = 1;
if (snum[j] == 0)
judge = 0;
else {
for (int k = 0; k < 26; k++)
if (k != j && cnt[i][k] > snum[k]) judge = 0;
if (cnt[i][j] > snum[j] - 1) judge = 0;
}
if (judge == 1) {
ans[i] = j + 'a';
snum[j]--;
for (int k = 0; k < i; k++) {
ans[k] = t[k];
snum[t[k] - 'a']--;
}
for (int k = 0; k <= i; k++) cout << ans[k];
for (int k = 0; k < 26; k++)
if (snum[k] != 0) {
cout << (char)(k + 'a');
snum[k]--;
k--;
}
cout << endl;
return 0;
}
}
}
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(char* a, char* b) {
if (*a == *b) return;
*a ^= *b;
*b ^= *a;
*a ^= *b;
}
void rev(string& s, int l, int r) {
while (l < r) swap(&s[l++], &s[r--]);
}
int bsearch(string& s, int l, int r, int key) {
int index = -1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (s[mid] <= key)
r = mid - 1;
else {
l = mid + 1;
if (index = -1 || s[index] <= s[mid]) index = mid;
}
}
return index;
}
bool nextpermutation(string& s) {
int len = s.length(), i = len - 2;
while (i >= 0 && s[i] >= s[i + 1]) --i;
if (i < 0)
return false;
else {
int index = bsearch(s, i + 1, len - 1, s[i]);
swap(&s[i], &s[index]);
rev(s, i + 1, len - 1);
return true;
}
}
string return_lowest(string input) {
sort(input.begin(), input.end());
return input;
}
string find_smallest(string input, string allowed) {
if ((input).length() == 0)
if (allowed.length() == 0)
return "";
else
return return_lowest(allowed);
size_t found = allowed.find(input.substr(0, 1));
if (found == string::npos) {
int x = int(input.c_str()[0]);
for (char i = x; i <= 'z'; i++) {
size_t found = allowed.find(i);
if (found != string::npos) {
string temp = allowed;
string allowed2 = allowed.erase(found, 1);
return (temp[found] + return_lowest(allowed2));
}
}
return "falseFalse";
}
{
int x = int(input.c_str()[0]);
for (char i = x; i <= 'z'; i++) {
string allowed2 = allowed;
size_t found = allowed2.find(i);
if (found != string::npos) {
allowed2.erase(found, 1);
string fuc;
if (i == x)
fuc = find_smallest(input.substr(1, (input).length() - 1), allowed2);
else {
fuc = return_lowest(allowed2);
}
if (fuc == "falseFalse") continue;
return allowed[found] + fuc;
}
}
return "falseFalse";
}
}
int main() {
string input, allowed;
cin >> allowed >> input;
sort(allowed.begin(), allowed.end());
string temp = find_smallest(input, allowed);
if (temp == "falseFalse")
cout << -1;
else if (temp == input) {
nextpermutation(temp);
if (temp == input)
cout << -1;
else
cout << temp;
} else
cout << temp;
}
|
#include <bits/stdc++.h>
using namespace std;
int mark[130], ans[5005];
string s1, s2;
bool making(int p, int ck) {
if (p == s1.length()) return ck;
for (int i = 'a'; i <= 'z'; i++) {
if (mark[i] && (i >= s2[p] || ck)) {
ans[p] = i;
mark[i]--;
if (making(p + 1, ck || i > s2[p])) return true;
mark[i]++;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s1 >> s2;
for (int i = 0; i < s1.length(); i++) mark[s1[i]]++;
if (!making(0, 0))
cout << -1 << endl;
else {
for (int i = 0; i < s1.length(); i++) cout << (char)ans[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, flag, ans[5005], hav[26], a[5005];
char ch[5005];
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; ++i) hav[ch[i] - 'a']++;
scanf("%s", ch + 1);
m = strlen(ch + 1);
for (int i = 1; i <= m; ++i) a[i] = ch[i] - 'a';
for (int i = 1; i <= m && i <= n; ++i) {
if (hav[a[i]]) {
ans[i] = a[i];
hav[a[i]]--;
} else {
for (int j = a[i] + 1; j < 26; ++j) {
if (hav[j]) {
ans[i] = j;
hav[j]--;
flag = i;
break;
}
}
if (!flag) {
for (int k = i - 1; k; --k) {
hav[a[k]]++;
for (int j = a[k] + 1; j < 26; ++j) {
if (hav[j]) {
ans[k] = j;
hav[j]--;
flag = k;
break;
}
}
if (flag) break;
}
if (!flag) flag = -1;
}
break;
}
}
if (!flag) {
if (n > m)
flag = m;
else {
for (int i = n; i; --i) {
hav[a[i]]++;
for (int j = a[i] + 1; j < 26; ++j) {
if (hav[j]) {
ans[i] = j;
hav[j]--;
flag = i;
break;
}
}
if (flag) break;
}
if (!flag) flag = -1;
}
}
if (flag == -1)
puts("-1");
else {
for (int i = 1; i <= flag; ++i) printf("%c", ans[i] + 'a');
for (int i = 0; i < 26; ++i)
for (int j = 0; j < hav[i]; ++j) printf("%c", i + 'a');
puts("");
}
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>
using namespace std;
string gen(int *cnt) {
string res = "";
for (int c = 'a'; c <= 'z'; ++c)
for (int i = 0; i < (int)(cnt[c]); i++) res += char(c);
return res;
}
int main() {
string S, T;
while (cin >> S >> T) {
int N = S.length();
T.resize(N, '0');
int cnt[256] = {};
for (int c = 'a'; c <= 'z'; ++c) cnt[c] = count((S).begin(), (S).end(), c);
string res = "";
for (int i = 0; i < (int)(N); i++) {
int c = T[i];
if (cnt[c] > 0) {
--cnt[c];
string t = gen(cnt);
reverse((t).begin(), (t).end());
if (t > T.substr(i + 1)) {
res += char(c);
continue;
} else {
++cnt[c];
}
}
for (++c; c <= 'z'; ++c) {
if (cnt[c] > 0) {
res += char(c);
--cnt[c];
res += gen(cnt);
goto done;
}
}
res = "-1";
goto done;
}
done:;
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[27];
int num2[27];
inline int idx(char a) { return a - 'a'; }
char sa[5555], sb[5555], sans1[5555], sans2[5555], sans[5555];
inline char rev(int id) { return 'a' + id; }
int lena, lenb;
bool ans1, ans2;
int main() {
scanf("%s", sa);
scanf("%s", sb);
ans1 = false;
ans2 = false;
memset(num, 0, sizeof(num));
memset(num2, 0, sizeof(num2));
lena = strlen(sa);
lenb = strlen(sb);
for (int i = 0; i < lena; i++) {
num[idx(sa[i])]++;
num2[idx(sa[i])]++;
}
if (lena > lenb) {
int flag = 1;
for (int i = 0; i < lenb; i++) {
sans1[i] = sb[i];
if (!num[idx(sb[i])]) {
flag = 0;
break;
} else {
num[idx(sb[i])]--;
}
}
if (flag) {
ans1 = true;
int tl = lenb;
for (int i = 0; i < 26; i++) {
while (num[i]) {
num[i]--;
sans1[tl++] = rev(i);
}
}
sans1[tl] = '\0';
}
}
for (int i = 0; i < 26; i++) num[i] = num2[i];
int lastmch = -1;
for (int i = 0; i < lenb; i++) {
if (num[idx(sb[i])]) {
num[idx(sb[i])]--;
sans2[i] = sb[i];
lastmch = i;
} else {
int tl = i;
int fg = 0;
for (int j = idx(sb[i]) + 1; j < 26; j++) {
if (num[j]) {
fg = 1;
num[j]--;
sans2[tl++] = rev(j);
break;
}
}
if (!fg) {
for (int k = i - 1; k >= 0; k--) {
tl = k;
if (tl >= 0) {
num[idx(sb[k])]++;
for (int j = idx(sb[k]) + 1; j < 26; j++) {
if (num[j]) {
lastmch = k - 1;
fg = 1;
num[j]--;
sans2[tl++] = rev(j);
break;
}
}
}
if (fg) break;
}
}
if (fg) {
ans2 = true;
for (int j = 0; j < 26; j++) {
while (num[j]) {
num[j]--;
sans2[tl++] = rev(j);
}
}
}
sans2[tl] = '\0';
break;
}
}
if (lastmch == lenb - 1 && ans2 == 0) {
int i = lenb;
int fg = 0;
int tl;
for (int k = i - 1; k >= 0; k--) {
tl = k;
if (tl >= 0) {
num[idx(sb[k])]++;
for (int j = idx(sb[k]) + 1; j < 26; j++) {
if (num[j]) {
lastmch = k - 1;
fg = 1;
num[j]--;
sans2[tl++] = rev(j);
break;
}
}
}
if (fg) break;
}
if (fg) {
ans2 = true;
for (int j = 0; j < 26; j++) {
while (num[j]) {
num[j]--;
sans2[tl++] = rev(j);
}
}
}
sans2[tl] = '\0';
}
int fg = 0;
if (ans1 == false && ans2 == false) {
cout << -1 << endl;
return 0;
}
if (ans1) {
fg = 1;
strcpy(sans, sans1);
}
if (fg && ans2) {
if (strcmp(sans1, sans2) > 0) {
strcpy(sans, sans2);
} else {
strcpy(sans, sans1);
}
} else if (ans2) {
strcpy(sans, sans2);
}
puts(sans);
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;
struct robot {
int c, f, l;
};
int d;
inline bool operator<(const robot &a, const robot &b) {
if (a.l != b.l) return a.l < b.l;
if (!a.l) return false;
return a.f > b.f;
}
int sz, bad, ans1, ans2;
long long t[110000];
void take(int t1, int f1, int t2, int f2) {
t1 += t2;
t2 -= min(t2, bad);
int n = sz - t2;
int pos = int(upper_bound(t, t + n, f2) - t);
t1 += pos;
if (pos) f1 += (int)t[pos - 1];
if (t1 > ans1 || t1 == ans1 && f1 < ans2) {
ans1 = t1;
ans2 = f1;
}
}
int main() {
int n, s;
cin >> n >> d >> s;
vector<robot> a, b;
for (int i = 0; i < (int)(n); i++) {
robot x;
scanf("%d%d%d", &x.c, &x.f, &x.l);
x.l = x.l >= d;
if (x.c)
a.push_back(x);
else
b.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sz = 0;
long long sum = 0;
for (int i = (int)(b.size()) - 1; i >= 0; i--)
if (b[i].l) {
sum += b[i].f;
t[sz++] = sum;
} else
bad++;
take(0, 0, 0, s);
long long free = 0;
for (int i = 0; i < (int)(a.size()); i++) free += a[i].c;
free -= (int)a.size();
sum = 0;
for (int i = (int)(a.size()) - 1; i >= 0; i--)
if (a[i].l && s >= a[i].f) {
sum += a[i].f;
s -= a[i].f;
free++;
take((int)a.size(), (int)sum, (int)min(free, (long long)b.size()), s);
}
cout << ans1 << ' ' << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Robot {
long long c, f;
bool operator<(const Robot& rob) const { return f < rob.f; }
};
long long n, d, S, x;
vector<Robot> carry, nocarry;
int main() {
ios::sync_with_stdio(0);
cin >> n >> d >> S;
for (int i = 0; i < n; ++i) {
Robot rob;
cin >> rob.c >> rob.f >> x;
if (x < d) rob.f = 0x3f3f3f3f;
if (rob.c == 0)
nocarry.push_back(rob);
else
carry.push_back(rob);
}
sort(carry.begin(), carry.end());
sort(nocarry.begin(), nocarry.end());
long long numR = 0, fuel = 0;
while (numR < nocarry.size() && fuel + nocarry[numR].f <= S)
fuel += nocarry[numR++].f;
if (!carry.empty() && carry[0].f <= S) {
long long numR2 = 0, fuel2 = carry[0].f, compart = 0;
for (int i = 0; i < carry.size(); ++i) compart += carry[i].c;
for (int i = 1; i < carry.size(); ++i) nocarry.push_back(carry[i]);
sort(nocarry.begin(), nocarry.end());
while (numR2 + compart < nocarry.size() && fuel2 + nocarry[numR2].f <= S)
fuel2 += nocarry[numR2++].f;
numR2 = 1 + min(numR2 + compart, (long long)nocarry.size());
if (numR2 > numR || (numR2 == numR && fuel2 < fuel))
numR = numR2, fuel = fuel2;
}
cout << numR << ' ' << fuel << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int carry[111111];
int fuel[111111];
int limit[111111];
int pool[111111];
int main(void) {
int n = 0;
int d = 0;
int S = 0;
scanf("%d %d %d", &n, &d, &S);
int allcarry = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &carry[i], &fuel[i], &limit[i]);
allcarry += carry[i];
if (allcarry >= n) allcarry = n - 1;
}
int mincfuel = 0x7FFFFFFF;
int minid = -1;
for (int i = 0; i < n; i++) {
if (limit[i] < d) continue;
if (carry[i] > 0 && fuel[i] < mincfuel) {
mincfuel = fuel[i];
minid = i;
}
}
int fuelcost = 0;
int allmove = 0;
if (minid == -1 || mincfuel > S)
allcarry = 0;
else {
allmove++;
fuelcost += mincfuel;
}
int ptop = 0;
for (int i = 0; i < n; i++) {
if (limit[i] < d || i == minid) continue;
pool[ptop++] = fuel[i];
}
sort(pool, pool + ptop);
for (int i = 0; i < ptop && allmove + allcarry < n; i++) {
if (fuelcost + pool[i] <= S) {
fuelcost += pool[i];
allmove++;
} else
break;
}
int nocarry = 0;
ptop = 0;
for (int i = 0; i < n; i++) {
if (limit[i] < d || carry[i]) continue;
pool[ptop++] = fuel[i];
}
sort(pool, pool + ptop);
int nocarrycost = 0;
for (int i = 0; i < ptop; i++) {
if (nocarrycost + pool[i] <= S) {
nocarrycost += pool[i];
nocarry++;
} else
break;
}
int ans = allmove + allcarry;
int anscost = fuelcost;
if (nocarry > ans || (nocarry == ans && nocarrycost < fuelcost)) {
ans = nocarry;
anscost = nocarrycost;
}
printf("%d %d\n", ans, anscost);
while (getchar() != EOF)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e18 + 7;
const int N = 1e5 + 7;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-9;
struct Node {
int c, f, l;
Node() {}
Node(int _c, int _f, int _l) { c = _c, f = _f, l = _l; }
};
int n, d, S;
vector<Node> vec;
bool cmp(const Node &p, const Node &q) { return p.f < q.f; }
pair<int, int> solve() {
pair<int, int> ans = make_pair(0, 0);
int C = 0, flag = 0, minFuel = INF;
for (int i = (0); i < (n); ++i) {
int c, f, l;
scanf("%d%d%d", &c, &f, &l);
C = min(n, C + c);
if (l >= d && f <= S) {
vec.push_back(Node(c, f, l));
if (c > 0) flag = 1, minFuel = min(minFuel, f);
}
}
C *= flag;
if (C >= n) ans = make_pair(n, -minFuel), C = 0;
sort(vec.begin(), vec.end(), cmp);
if (flag) {
for (int i = (1); i < (((int)(vec).size())); ++i)
if (vec[i].f == minFuel) {
swap(vec[i], vec[0]);
break;
}
sort(vec.begin() + 1, vec.end(), cmp);
}
int s = 0;
for (int i = 0; i < ((int)(vec).size()) && s + vec[i].f <= S && C < n; ++i)
++C, s += vec[i].f;
ans = max(ans, make_pair(C, -s));
C = s = 0;
for (int i = 1; i < ((int)(vec).size()) && s + vec[i].f <= S && C < n; ++i)
++C, s += vec[i].f;
ans = max(ans, make_pair(C, -s));
return ans;
}
int main() {
scanf("%d%d%d", &n, &d, &S);
pair<int, int> ans = solve();
printf("%d %d\n", ans.first, -ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void input(T &x) {
char c = getchar();
x = 0;
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
}
inline long long bigmod(long long p, long long e, long long M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
const int N = 1e5 + 5;
int c[N], f[N], l[N];
const long long INF = 1e9 + 9;
long long n, d, s;
long long ans = 0;
long long fuel = INF;
void func1() {
vector<long long> v;
for (long long i = 0; i < n; i++) {
if (l[i] >= d) {
v.push_back(f[i]);
}
}
sort((v).begin(), (v).end());
fuel = 0;
for (long long i = 0; i < v.size(); i++) {
if (fuel + v[i] <= s) {
fuel += v[i];
ans++;
} else
break;
}
}
void func2() {
vector<long long> A, B;
long long C = 0;
for (long long i = 0; i < n; i++) {
if (c[i] > 0) {
C += c[i];
if (l[i] >= d) A.push_back(f[i]);
} else if (l[i] >= d)
B.push_back(f[i]);
C = min(C, n);
}
sort((A).begin(), (A).end());
sort((B).begin(), (B).end());
C = min(C, n);
if (A.size() == 0) return;
long long sum = A[0];
long long L = 1, R = 0;
long long cnt = L + R + C;
cnt = min(cnt, n);
if (sum <= s && (cnt > ans || (cnt == ans && sum < fuel))) {
ans = cnt;
fuel = sum;
}
while ((L < A.size() || R < B.size()) && sum <= s) {
long long now = INF;
if (L < A.size()) now = A[L];
if (R < B.size()) now = min(now, B[R]);
if (now == INF) break;
sum += now;
if (sum > s) break;
if (L < A.size() && now == A[L])
L++;
else if (R < B.size() && now == B[R])
R++;
cnt = L + R + C;
cnt = min(cnt, n);
if (cnt > ans || (cnt == ans && sum < fuel)) {
ans = cnt;
fuel = sum;
}
}
}
int main() {
cin >> n >> d >> s;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
input(c[i]), input(f[i]), input(l[i]);
}
func1();
func2();
if (ans > 0)
cout << ans << " " << fuel << endl;
else
printf("0 0\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ToInt(string& s, int len) {
int r = 0;
for (int i = 0, max_ = (len); i < max_; ++i) {
r *= 10;
r += s[i] - '0';
}
return r;
}
int GCD(int a, int b) { return b != 0 ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
vector<int> moveC;
vector<int> moveAll;
int main() {
int N, D, S, c, f, l;
long long sumC = 0;
while (scanf("%d %d %d", &N, &D, &S) == 3) {
sumC = 0;
moveC.clear();
moveAll.clear();
for (int i = 0, max_ = (N); i < max_; ++i) {
scanf("%d %d %d", &c, &f, &l);
sumC += c;
if (l >= D) {
if (c > 0) moveC.push_back(f);
moveAll.push_back(f);
}
}
sort((moveC).begin(), (moveC).end());
sort((moveAll).begin(), (moveAll).end());
long long res1 = 0, fuel1 = 0;
if ((int)(moveC).size() > 0 && moveC[0] <= S) {
res1 = sumC + 1;
fuel1 += moveC[0];
for (int i = 0, max_ = ((int)(moveAll).size()); i < max_; ++i)
if (moveAll[i] == moveC[0]) {
moveAll.erase(moveAll.begin() + i);
break;
}
int id = 0;
while (id < (int)(moveAll).size() && S - fuel1 >= moveAll[id]) {
if (res1 >= N) break;
++res1;
fuel1 += moveAll[id];
++id;
}
res1 = std::min(res1, (long long)N);
}
long long res2 = 0, fuel2 = 0;
if ((int)(moveAll).size() > 0) {
int id = 0;
while (id < (int)(moveAll).size() && S - fuel2 >= moveAll[id]) {
fuel2 += moveAll[id];
++res2;
++id;
}
}
long long res = 0, fuel = 0;
if (res1 > res2 || (res1 == res2 && fuel1 < fuel2)) {
res = res1;
fuel = fuel1;
} else {
res = res2;
fuel = fuel2;
}
if (res == 0)
printf("0 0\n");
else
printf("%I64d %I64d\n", res, fuel);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e9 + 7;
long long n, s, d, ts, ts2, ans, ans2, tmp, c_sum, mn;
vector<int> cvl, cv;
void input() {
cin >> n >> d >> s;
for (int i = 1, c, f, l; i <= n; i++) {
cin >> c >> f >> l;
c_sum += c;
if (l >= d) c ? cvl.push_back(f) : cv.push_back(f);
}
ts = ts2 = s;
}
int main() {
input();
cvl.push_back(maxn);
cv.push_back(maxn);
sort(cvl.begin(), cvl.end());
sort(cv.begin(), cv.end());
(cvl.size()) ? mn = cvl[0] : mn = -1;
for (int f : cv)
if (ts2 >= f) ans2++, ts2 -= f;
if (cvl.size() != 1 && s >= mn) {
ans = min(c_sum + 1, n);
ts -= mn;
int pl = 1, p = 0;
while (ans < n && (tmp = min(cvl[pl], cv[p])) <= ts) {
ts -= tmp;
ans++;
(tmp == cvl[pl]) ? pl++ : p++;
}
}
if (ans2 > ans)
ans = ans2, ts = ts2;
else if (ans2 == ans)
ts = min(ts, ts2);
cout << ans << ' ' << s - ts << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct robot {
int c, f;
};
int n, d, s, sumc, m;
robot a[maxn];
int ans1, ans2, tmp1, tmp2;
bool cmp(const robot &a, const robot &b) { return a.f < b.f; }
int main() {
scanf("%d%d%d", &n, &d, &s);
sumc = m = 0;
for (int i = 0, c, f, l; i < n; ++i) {
scanf("%d%d%d", &c, &f, &l);
sumc += c;
if (sumc > n) sumc = n;
if (l >= d) {
a[m].c = c;
a[m++].f = f;
}
}
ans1 = ans2 = 0;
sort(a, a + m, cmp);
while (ans1 < m) {
if (ans2 + a[ans1].f > s) break;
ans2 += a[ans1].f;
++ans1;
}
int head = -1;
for (int i = 0; i < m; ++i)
if (a[i].f <= s && a[i].c) {
head = i;
break;
}
if (head != -1) {
tmp1 = min(sumc + 1, n);
tmp2 = a[head].f;
if (tmp1 > ans1 || tmp1 == ans1 && tmp2 < ans2) {
ans1 = tmp1;
ans2 = tmp2;
}
for (int i = 0; i < m; ++i)
if (i != head) {
if (tmp1 == n || tmp2 + a[i].f > s) break;
++tmp1;
tmp2 += a[i].f;
if (tmp1 > ans1 || tmp1 == ans1 && tmp2 < ans2) {
ans1 = tmp1;
ans2 = tmp2;
}
}
}
printf("%d %d\n", ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v1;
vector<long long> v3;
long long sums[110000];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
long long n, d, S;
cin >> n >> d >> S;
long long cnt2 = 0;
long long sum2 = 0;
for (long long i = 0; i < n; i++) {
long long x1, x2, x3;
cin >> x1 >> x2 >> x3;
if (x1 > 0 && x3 >= d) {
v1.push_back(make_pair(x2, x1));
sum2 += x1;
cnt2++;
}
if (x1 > 0 && x3 < d) {
cnt2++;
sum2 += x1;
}
if (x1 == 0 && x3 >= d) v3.push_back(x2);
}
sort(v1.begin(), v1.end());
sort(v3.begin(), v3.end());
for (long long i = 0; i < v3.size(); i++) {
sums[i] = v3[i];
if (i > 0) sums[i] += sums[i - 1];
}
long long best = 0;
long long best2 = 0;
long long sum1 = 0;
for (long long i = 0; i <= v1.size(); i++) {
if (i > 0) sum1 += v1[i - 1].first;
if (sum1 > S) break;
long long ans = i;
long long ans2 = sum1;
long long left = 0;
if (i > 0) {
ans = cnt2;
left = sum2 - cnt2 + i;
}
long long l = -1;
long long r = v3.size();
while (r - l > 1) {
long long m = (l + r) >> 1;
if (sums[m] > S - sum1)
r = m;
else
l = m;
}
ans += l + 1 + left;
if (ans > n) {
l = l - (ans - n);
ans = n;
}
if (l > -1) ans2 += sums[l];
if (ans > best || (ans == best && ans2 < best2)) {
best = ans;
best2 = ans2;
}
}
cout << best << " " << best2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, s, c[100005], f[100005], l[100005], k;
vector<int> a, b;
int main() {
scanf("%d%d%d", &n, &d, &s);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &c[i], &f[i], &l[i]);
if (c[i]) k++;
if (l[i] >= d)
if (c[i])
a.push_back(f[i]);
else
b.push_back(f[i]);
}
sort(a.begin(), a.end());
a.push_back(2000000000);
sort(b.begin(), b.end());
b.push_back(2000000000);
int Sum = 0, Ans = 0, sum = 0, ans = 0;
for (int i = 0; b[i] <= s - Sum; Sum += b[i++], Ans++)
;
if (a[0] <= s) {
int tot = 1;
for (int i = 0; i < n; i++)
if (c[i]) tot = min(n, tot + c[i] - 1);
int l = 1, r = 0;
sum = a[0];
ans = min(k + tot, n);
while (ans < n) {
int tmp = min(a[l], b[r]);
if (tmp > s - sum) break;
ans++;
sum += tmp;
if (a[l] <= b[r])
l++;
else
r++;
}
if (ans > Ans || (ans == Ans && sum < Sum)) {
Ans = ans;
Sum = sum;
}
}
printf("%d %d", Ans, Sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Robot {
int c, f, l;
};
int N, D, S, n1, n2;
Robot a[100005], b[100005];
long long psum[100005];
int compare(Robot r1, Robot r2) {
if (r1.l < D) return false;
if (r1.l >= D && r2.l < D) return true;
return r1.f < r2.f;
}
int main() {
long long res1 = 0, res2 = 0;
n1 = n2 = 0;
scanf("%d %d %d", &N, &D, &S);
long long numEdges = 0;
for (int i = 0; i < N; i++) {
int c, f, l;
scanf("%d %d %d", &c, &f, &l);
if (c != 0) {
a[n1].c = c;
a[n1].f = f;
a[n1].l = l;
n1++;
} else {
b[n2].c = c;
b[n2].f = f;
b[n2].l = l;
n2++;
}
numEdges += c;
}
sort(a, a + n1, compare);
sort(b, b + n2, compare);
for (int i = 0; i < n2; i++) {
if (i == 0)
psum[i] = b[i].f;
else
psum[i] = psum[i - 1] + b[i].f;
}
for (int i = 0; i < n2; i++) {
if (b[i].l < D) {
n2 = i;
break;
}
}
long long totalFuel = 0;
for (int i = 0; i < n1; i++) {
if (a[i].l < D) break;
long long maxCarry =
((((long long)N) < (numEdges + i + 1)) ? ((long long)N)
: (numEdges + i + 1));
totalFuel += a[i].f;
if (totalFuel > (long long)S) break;
if (maxCarry > res1 || (maxCarry == res1 && totalFuel < res2)) {
res1 = maxCarry;
res2 = totalFuel;
}
long long sres1 = 0, sres2 = 0;
int low = 0, high = n2 - 1;
while (low <= high) {
int mid = (low + high) / 2;
long long sum = psum[mid];
if (sum + totalFuel > (long long)S || maxCarry + mid + 1 > N) {
high = mid - 1;
} else {
sres1 = maxCarry + mid + 1;
sres2 = sum + totalFuel;
low = mid + 1;
}
}
if (sres1 > res1 || (sres1 == res1 && sres2 < res2)) {
res1 = sres1;
res2 = sres2;
}
}
totalFuel = 0;
for (int i = 0; i < n2; i++) {
totalFuel += b[i].f;
if (totalFuel > (long long)S) break;
if ((long long)(i + 1) > res1 ||
((long long)(i + 1) == res1 && totalFuel < res2)) {
res1 = i + 1;
res2 = totalFuel;
}
}
cout << res1 << " " << res2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(const T &a) {
return a * a;
}
template <typename T>
inline int nread(vector<T> &a) {
int n;
cin >> n;
a.clear();
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
return n;
}
struct robot {
int c, f, l;
};
bool ls(robot a, robot b) { return a.f < b.f; }
int main() {
int n, d, s;
cin >> n >> d >> s;
vector<robot> matr, emp;
int hlam = 0;
long long int matrv = 0;
for (int i = 0; i < n; i++) {
robot tmp;
cin >> tmp.c >> tmp.f >> tmp.l;
matrv += tmp.c;
if (tmp.l >= d)
if (tmp.c >= 1)
matr.push_back(tmp);
else
emp.push_back(tmp);
else
hlam++;
}
sort(matr.begin(), matr.end(), ls);
sort(emp.begin(), emp.end(), ls);
int ost = s;
int ans = 0, oans = 0, cemp = 0, cmatr = 0;
for (int i = 0; i < emp.size(); i++) {
if (ost < emp[i].f) break;
ost -= emp[i].f;
cemp++;
}
ans = cemp;
oans = ost;
if (matr.size() > 0 && matr[0].f <= s) {
ost = s - matr[0].f;
emp.insert(emp.end(), matr.begin() + 1, matr.end());
sort(emp.begin(), emp.end(), ls);
cmatr = min((long long int)n, matrv + 1);
for (int i = 0; i < emp.size(); i++) {
if (ost < emp[i].f || cmatr == n) break;
ost -= emp[i].f;
cmatr++;
}
if (ans < cmatr || (ans == cmatr && oans < ost)) {
ans = cmatr;
oans = ost;
}
}
cout << ans << ' ' << s - oans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
const int oo = 0x7f7f7f7f;
struct node {
int c, f, l;
} robot[2][N];
int n, m[2], d, ts, t;
long long cc;
bool cmp(node x, node y) {
if (x.l >= d && y.l < d) {
return true;
}
if (x.l < d && y.l >= d) {
return false;
}
return x.f < y.f;
}
void init() {
scanf("%d%d%d", &n, &d, &ts);
m[0] = m[1] = 0;
for (int i = 0; i < n; ++i) {
int c, f, l;
scanf("%d%d%d", &c, &f, &l);
if (c) {
robot[1][m[1]++] = (node){c, f, l};
} else {
robot[0][m[0]++] = (node){c, f, l};
}
}
sort(robot[0], robot[0] + m[0], cmp);
sort(robot[1], robot[1] + m[1], cmp);
}
bool solve1() {
t = 0;
cc = 0;
for (int i = 0; i < m[1]; ++i) {
cc = cc - 1 + robot[1][i].c;
t = t + 1;
}
return (m[1] > 0 && robot[1][0].f <= ts);
}
void solve2(bool fff) {
int s = 0, ss, ans = oo, temp = 0;
for (int i = 0; i < m[0]; ++i)
if (robot[0][i].l >= d && s <= ts - robot[0][i].f) {
s = s + robot[0][i].f;
++temp;
}
ans = temp;
ss = s;
if (fff) {
int ks = 0, p = -1, ps;
for (int i = 0; i < m[1]; ++i)
if (robot[1][i].l >= d && ks <= ts - robot[1][i].f) {
++cc;
ks = ks + robot[1][i].f;
int q = min(cc, (long long)m[0]);
s = ks;
temp = t + q;
if (p == -1) {
ps = 0;
for (; p + 1 < m[0] - q &&
(robot[0][p + 1].l >= d && ps <= ts - ks - robot[0][p + 1].f);
++p) {
ps = ps + robot[0][p + 1].f;
}
} else {
while ((p >= 0 && ps > ts - ks) || p >= m[0] - q) {
ps = ps - robot[0][p--].f;
}
}
if (p != -1) {
s = ks + ps;
temp = temp + p + 1;
}
if (temp > ans || temp == ans && s < ss) {
ans = temp;
ss = s;
}
}
}
printf("%d %d\n", ans, ss);
}
int main() {
init();
solve2(solve1());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100007;
const int INF = 2e+9;
struct robot {
int c, f;
robot(int c = 0, int f = 0, int l = 0) : c(c), f(f) {}
};
robot a[MAXN];
int n, d, S;
int res, ans;
bool opr_sort(const robot &a, const robot &b) {
return a.c > b.c || (a.c == b.c && a.f > b.f);
}
bool opr_sort_sec(const robot &a, const robot &b) { return a.f < b.f; }
int main() {
scanf("%d %d %d", &n, &d, &S);
for (int i = 0; i < n; i++) {
int l;
scanf("%d %d %d", &a[i].c, &a[i].f, &l);
if (l < d) a[i].f = INF;
}
sort(a, a + n, opr_sort);
for (int i = 0; i <= n; i++) {
if (i == n || a[i].c == 0) {
sort(a, a + i, opr_sort_sec);
break;
}
}
res = 0;
ans = S;
if (a[0].f <= S && a[0].c) {
int s = S - a[0].f;
int c = a[0].c;
res = 1;
int I = 1;
while (I < n && c) {
c -= 1;
c += a[I].c;
res++;
I++;
}
for (int i = 1, j = I, k = n - 1; j <= k;) {
if (i < I && a[i].f < a[k].f) {
if (a[i].f > s) break;
s -= a[i].f;
i++;
j++;
res++;
} else {
if (a[k].f > s) break;
s -= a[k].f;
k--;
res++;
}
}
ans = s;
}
sort(a, a + n, opr_sort_sec);
int s = S;
int x = 0;
for (int i = 0; i < n; i++) {
if (a[i].f <= s) {
s -= a[i].f;
x++;
}
}
if (make_pair(res, ans) < make_pair(x, s)) {
res = x;
ans = s;
}
printf("%d %d\n", res, S - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, d, s, c, f, l;
scanf("%d %d %d", &n, &d, &s);
vector<pair<int, int> > a;
int m = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &c, &f, &l);
m = min(n, m + c);
if (l >= d) a.push_back(make_pair(f, c));
}
sort(a.begin(), a.end());
int r = 0, w = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i].first + w > s) break;
r++;
w += a[i].first;
}
int k;
for (k = 0; k < a.size(); k++)
if (a[k].second != 0) break;
if (k == a.size() || a[k].first > s) {
printf("%d %d\n", r, w);
return 0;
}
pair<int, int> ans = make_pair(r, -w);
r = 0;
w = a[k].first;
ans = max(ans, make_pair(min(m + 1, n), -w));
for (int i = 0; i < a.size(); i++) {
if (i == k) continue;
if (w + a[i].first > s) break;
r++;
w += a[i].first;
ans = max(ans, make_pair(min(n, m + 1 + r), -w));
}
printf("%d %d\n", ans.first, -ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[100100], f[100100], l[100100];
vector<int> a;
vector<long long> b;
int was[100100];
int main() {
int n, d, s;
scanf("%d%d%d", &n, &d, &s);
for (int i = (0); i < (n); ++i) scanf("%d%d%d", &c[i], &f[i], &l[i]);
for (int i = (0); i < (n); ++i) {
if ((l[i] >= d)) a.push_back(f[i]);
}
sort(a.begin(), a.end());
int res1 = 0, s1 = s;
for (int i = (0); i < (a.size()); ++i) {
if (s1 >= a[i]) {
res1++;
s1 -= a[i];
}
}
a.clear();
long long can = 0;
for (int i = (0); i < (n); ++i)
if ((l[i] >= d) && (c[i] > 0)) a.push_back(f[i]);
for (int i = (0); i < (n); ++i) can += c[i];
int cnt = 0;
for (int i = (0); i < (n); ++i)
if (c[i] > 0) cnt++;
int cnt1 = 0, cnt2 = 0;
for (int i = (0); i < (n); ++i)
if (c[i] == 0) {
if (l[i] >= d) {
cnt1++;
b.push_back(f[i]);
} else
cnt2++;
}
sort(b.begin(), b.end());
for (int i = (1); i < (b.size()); ++i) b[i] += b[i - 1];
sort(a.begin(), a.end());
int curf = 0;
for (int i = (0); i < (a.size()); ++i) {
curf += a[i];
if (curf > s) break;
int curres = cnt;
long long curcan = can - cnt + i + 1;
long long g = ((0 < cnt1 + cnt2 - curcan) ? (cnt1 + cnt2 - curcan) : (0));
curres += (cnt1 + cnt2 - g);
int l = 0;
int r = ((g - 1 < (int)b.size() - 1) ? (g - 1) : ((int)b.size() - 1));
int best = -1;
while (l <= r) {
int m = (l + r) / 2;
if (b[m] <= s - curf) {
best = m;
l = m + 1;
} else
r = m - 1;
}
if (best != -1) {
curres += best + 1;
curf += b[best];
}
int v = s - curf;
if ((curres > res1) || ((curres == res1) && (v > s1))) {
res1 = curres;
s1 = v;
}
if (best != -1) curf -= b[best];
}
printf("%d %d\n", res1, s - s1);
return 0;
}
|
#include <bits/stdc++.h>
int n, d, s;
using namespace std;
int main() {
cin >> n >> d >> s;
long long m = 0, sumc = 0;
vector<int> v, vv;
for (int i = 0; i < n; i++) {
int c, f, l;
cin >> c >> f >> l;
if (c) {
m++, sumc += c;
if (l >= d) v.push_back(f);
} else if (l >= d)
vv.push_back(f);
}
sort(v.begin(), v.end());
sort(vv.begin(), vv.end());
long long tt = 0, ii;
for (ii = 0; ii < vv.size() && vv[ii] + tt <= s; ii++) tt += vv[ii];
if (!v.size() || v[0] > s) {
if (ii == 0)
puts("0 0");
else
cout << ii << ' ' << tt << endl;
return 0;
}
long long cost = v[0], cnt = 0, t = sumc - m + 1, left = n - m;
if (t >= left) {
cout << n << ' ' << cost << endl;
return 0;
}
v.erase(v.begin());
for (int i = 0; i < vv.size(); i++) v.push_back(vv[i]);
sort(v.begin(), v.end());
left = left - t;
for (int i = 0; i < v.size() && cost + v[i] <= s; i++) {
cost += v[i];
left--;
if (left == 0) break;
}
n -= left;
if (ii > n || (ii == n && tt < cost)) n = ii, cost = tt;
cout << n << ' ' << cost << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int carry[100008], limit[100008], fuel[100008];
vector<pair<int, int> > c, wc;
int main() {
int n, d, S;
cin >> n >> d >> S;
int total = 0, id = -1, cost = 1e9 + 2;
for (int i = 0; i < n; i++) {
cin >> carry[i] >> fuel[i] >> limit[i];
total += carry[i];
if (total >= n) total = n - 1;
if (limit[i] >= d) {
if (carry[i] == 0) wc.push_back(pair<int, int>(fuel[i], i));
c.push_back(pair<int, int>(fuel[i], i));
if (carry[i] && fuel[i] < cost && fuel[i] <= S) cost = fuel[i], id = i;
}
}
sort(c.begin(), c.end());
sort(wc.begin(), wc.end());
if (id == -1)
total = 0;
else
total++;
for (int i = 0; i < c.size(); i++) {
if (total == n) break;
if (c[i].second == id) continue;
if (cost + c[i].first > S) break;
cost += c[i].first, total++;
}
int nocarry = 0, nocarrycost = 0;
for (int i = 0; i < wc.size(); i++) {
if (nocarrycost + wc[i].first > S) break;
nocarrycost += wc[i].first, nocarry++;
}
if (total < nocarry || (total == nocarry && cost > nocarrycost))
total = nocarry, cost = nocarrycost;
cout << total << " " << cost << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
vector<long long> v1, v2, v3, v4;
long long n, dis, s;
long long u[110000], c[110000], d[110000];
bool cmp(long long i, long long j) { return u[i] <= u[j]; }
void solve(long long ans, long long carry, long long have) {
long long tmp = s, th = 0;
for (long long i = 0; i < (((long long)(v2).size())); ++i) {
if (tmp >= v2[i]) {
tmp -= v2[i];
th++;
} else
break;
}
if (ans > s) {
cout << th << " " << s - tmp << endl;
return;
}
ans = s - ans;
if (((long long)(v3).size()) != 0) {
for (long long i = 0; i < (((long long)(v3).size())); ++i) {
carry += c[v3[i]] - 1;
have++;
}
}
long long now = min(((long long)(v4).size()), carry);
carry -= now;
have += now;
now = ((long long)(v2).size()) - 1;
while (carry && now >= 0) {
carry--;
have++;
v2[now] = -1;
now--;
}
v2.push_back(-1);
now = 0;
while (v2[now] != -1) {
if (ans >= v2[now]) {
ans -= v2[now];
have++;
now++;
} else
break;
}
long long reta, reth;
if (th > have) {
reta = s - tmp;
reth = th;
} else {
reta = s - ans;
reth = have;
}
cout << reth << " " << reta << endl;
}
int main() {
scanf("%I64d %I64d %I64d", &n, &dis, &s);
int sum = 0;
for (long long i = (1); i <= (n); ++i) {
scanf("%I64d %I64d %I64d", &c[i], &u[i], &d[i]);
if (d[i] < dis) {
if (c[i] == 0)
v4.push_back(i);
else
v3.push_back(i);
} else {
if (c[i] == 0)
v2.push_back(u[i]);
else
v1.push_back(i);
}
sum += c[i];
}
long long ans = 2000000000;
long long carry = 0;
long long jl = 0;
long long have = (long long)((long long)(v1).size());
for (long long i = 0; i < (((long long)(v1).size())); ++i) {
if (ans > u[v1[i]]) {
ans = u[v1[i]];
jl = i;
}
carry += c[v1[i]] - 1;
}
for (long long i = 0; i < (((long long)(v1).size())); ++i) {
if (i == jl) continue;
v2.push_back(u[v1[i]]);
}
carry = carry + 1;
sort(v2.begin(), v2.end());
for (long long i = (1); i <= (((long long)(v1).size()) - 1); ++i) {
v2.pop_back();
}
solve(ans, carry, have);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.