text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, s[30], len, tot = 0, bj = 0, m = -1;
char c, t[5025], ans[5025];
memset(s, 0, sizeof(s));
while ((scanf("%c", &c), c) != '\n') {
s[c - 96]++;
tot++;
}
scanf(" %s", t);
len = strlen(t);
for (i = 0; i < len; i++)
if (s[t[i] - 96]) {
s[t[i] - 96]--;
ans[i] = t[i] - 96;
m++;
} else {
for (j = t[i] - 95; j <= 26; j++)
if (s[j]) break;
if (s[j]) {
s[j]--;
ans[i] = j;
bj = 1;
m++;
break;
} else {
bj = -1;
break;
}
}
if (bj == 0 && tot > len) {
for (j = 0; j <= m; j++) printf("%c", ans[j] + 96);
for (i = 1; i <= 26; i++)
for (j = 1; j <= s[i]; j++) printf("%c", i + 96);
printf("\n");
return 0;
}
if (bj != 1) {
bj = -1;
for (j = i - 1; j >= 0; j--) {
s[t[j] - 96]++;
m--;
for (k = t[j] - 95; k <= 26; k++)
if (s[k]) break;
if (s[k]) {
s[k]--;
ans[++m] = k;
bj = 1;
break;
}
}
}
if (bj == -1)
printf("-1\n");
else {
for (j = 0; j <= m; j++) printf("%c", ans[j] + 96);
for (i = 1; i <= 26; i++)
for (j = 1; j <= s[i]; j++) printf("%c", i + 96);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5040;
char s1[N], s2[N];
int num[30], a[N][30];
multiset<int> st;
int gao(int now) {
multiset<int>::reverse_iterator it;
for (it = st.rbegin(); it != st.rend(); it++) {
if ((*it) > s2[now] - 'a') {
return 1;
} else if ((*it) < s2[now] - 'a') {
return -1;
}
now++;
}
return 0;
}
int main(void) {
scanf("%s", s1);
scanf("%s", s2);
int len = strlen(s1);
memset(num, 0, sizeof(num));
memset(a, 0, sizeof(a));
for (int i = 0; i < len; i++) {
st.insert(s1[i] - 'a');
}
if (gao(0) <= 0) {
printf("-1\n");
} else {
int flag = 0;
for (int i = 0; i < len; i++) {
if (flag) break;
if (i == len - 1) {
multiset<int>::iterator it = st.begin();
printf("%c\n", (*it) + 'a');
break;
}
if (flag == 0) {
if (st.count(s2[i] - 'a') > 0) {
st.erase(st.find(s2[i] - 'a'));
if (gao(i + 1) == 1) {
printf("%c", s2[i]);
continue;
} else {
st.insert(s2[i] - 'a');
for (int j = s2[i] - 'a' + 1; j < 26; j++) {
if (st.count(j) > 0) {
st.erase(st.find(j));
if (gao(i + 1)) {
printf("%c", j + 'a');
break;
} else {
st.insert(j);
}
}
}
multiset<int>::iterator it;
for (it = st.begin(); it != st.end(); it++) {
printf("%c", (*it) + 'a');
}
printf("\n");
flag = 1;
}
} else {
for (int j = s2[i] - 'a' + 1; j < 26; j++) {
if (st.count(j) > 0) {
st.erase(st.find(j));
if (gao(i)) {
printf("%c", j + 'a');
break;
} else {
st.insert(j);
}
}
}
multiset<int>::iterator it;
for (it = st.begin(); it != st.end(); it++) {
printf("%c", (*it) + 'a');
}
printf("\n");
flag = 1;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
inline int Max(int a, int b) { return a > b ? a : b; }
inline int Min(int a, int b) { return a < b ? a : b; }
inline int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
inline int bit(int x) { return (int)log10((double)x) + 1; }
inline int lowbit(int x) { return x & -x; }
inline int highbit(int x) {
while (x != lowbit(x)) x ^= lowbit(x);
return x;
}
inline int whichbit(int x) {
int ret = 0;
while (x > 1) {
x >>= 1;
ret++;
}
return ret;
}
using namespace std;
const double pi = M_PI;
const int inf = 1000000007;
const int mod = 10000;
const double eps = 1e-6;
const int maxn = (1 << 15) + 5;
const int maxm = 1005;
const int maxe = maxn * 4;
char s[5005];
char x[5005];
int tot[300];
char ans[5005];
int now;
int main() {
now = 0;
gets(s);
gets(x);
memset(tot, 0, sizeof(tot));
for (int i = 0; s[i]; i++) tot[s[i]]++;
int get = 0;
for (int i = 0; x[i]; i++) {
if (tot[x[i]] == 0) {
int flag = 0;
for (int j = x[i] + 1; j <= 'z'; j++) {
if (tot[j] != 0) {
flag = j;
break;
}
}
if (flag) {
ans[now++] = flag;
tot[flag]--;
for (int j = 'a'; j <= 'z'; j++) {
while (tot[j] > 0) {
ans[now++] = j;
tot[j]--;
}
}
ans[now] = 0;
break;
} else {
now--;
while (now >= 0) {
tot[ans[now]]++;
int flag = 0;
for (int j = ans[now] + 1; j <= 'z'; j++) {
if (tot[j] > 0) {
flag = j;
break;
}
}
if (flag) {
ans[now++] = flag;
tot[flag]--;
for (int j = 'a'; j <= 'z'; j++) {
while (tot[j] > 0) {
ans[now++] = j;
tot[j]--;
}
}
ans[now] = 0;
break;
} else {
now--;
}
}
if (now < 0) {
get = 1;
break;
}
break;
}
} else {
ans[now++] = x[i];
tot[x[i]]--;
}
}
if (get) {
puts("-1");
} else {
for (int j = 'a'; j <= 'z'; j++) {
while (tot[j] > 0) {
ans[now++] = j;
tot[j]--;
}
}
if (strcmp(ans, x) <= 0) {
now--;
while (now >= 0) {
tot[ans[now]]++;
int flag = 0;
for (int j = ans[now] + 1; j <= 'z'; j++) {
if (tot[j] > 0) {
flag = j;
break;
}
}
if (flag) {
ans[now++] = flag;
tot[flag]--;
for (int j = 'a'; j <= 'z'; j++) {
while (tot[j] > 0) {
ans[now++] = j;
tot[j]--;
}
}
ans[now] = 0;
break;
} else {
now--;
}
}
if (now < 0) {
get = 1;
}
}
if (get) {
puts("-1");
} else {
ans[now] = 0;
puts(ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
char a[N], b[N], ans[N];
int s[30];
int main() {
scanf("%s%s", a, b);
if (strcmp(a, b) == 0) {
}
int n = strlen(a);
for (int i = 0; i < n; i++) {
s[a[i] - 'a']++;
}
n = strlen(b);
int pos = 0;
bool f = 0;
for (int i = 0; i < n; i++) {
int t = b[i] - 'a';
if (s[t] > 0) {
s[t]--;
ans[pos++] = b[i];
} else {
for (int j = t + 1; j < 26; j++) {
if (s[j] > 0) {
s[j]--;
ans[pos++] = 'a' + j;
f = 1;
break;
}
}
if (!f) {
for (int j = pos - 1; j >= 0; j--) {
t = ans[j] - 'a';
s[t]++;
for (int k = t + 1; k < 26; k++) {
if (s[k] > 0) {
s[k]--;
ans[j] = 'a' + k;
f = 1;
pos = j + 1;
break;
}
}
if (f) break;
}
}
break;
}
}
ans[pos] = '\0';
if (strcmp(ans, b) == 0 && strlen(a) <= strlen(b)) {
for (int j = pos - 1; j >= 0; j--) {
int t = ans[j] - 'a';
s[t]++;
for (int k = t + 1; k < 26; k++) {
if (s[k] > 0) {
s[k]--;
ans[j] = 'a' + k;
f = 1;
pos = j + 1;
break;
}
}
if (f) break;
}
}
if (strcmp(ans, b) == 0 && strlen(a) > strlen(b)) f = 1;
if (f) {
for (int j = 0; j < 26; j++) {
while (s[j]) {
ans[pos++] = 'a' + j;
s[j]--;
}
}
ans[pos] = '\0';
printf("%s\n", ans);
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
vector<int> count(26, 0);
for (int i = 0; i < a.size(); i++) {
count[a[i] - 'a']++;
}
string res = "";
for (int i = 0; i < b.size(); i++) {
int pos = b[i] - 'a';
if (count[pos] > 0) {
count[pos]--;
res += ('a' + pos);
} else {
while (pos < 26) {
if (count[pos] > 0) break;
pos++;
}
if (pos < 26) {
res += ('a' + pos);
count[pos]--;
for (int i = 0; i < 26; i++) {
while (count[i] > 0) {
res += ('a' + i);
count[i]--;
}
}
} else {
for (int i = 25; i >= 0; i--) {
while (count[i] > 0) {
res += ('a' + i);
count[i]--;
}
}
next_permutation(res.begin(), res.end());
}
break;
}
}
for (int i = 0; i < 26; i++) {
while (count[i] > 0) {
res += ('a' + i);
count[i]--;
}
}
if (res > b)
cout << res << endl;
else {
next_permutation(res.begin(), res.end());
if (res > b)
cout << res << endl;
else
cout << -1 << endl;
}
int n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 3;
const int K = 20;
const int inf = (int)1e9 + 7;
int a[26], b[26];
int main() {
string s, t;
cin >> s >> t;
int n = (int)s.size();
string ans = "";
for (int i = 0; i <= n; ++i) {
ans += 'z';
}
for (int i = 0; i < n; ++i) {
a[s[i] - 'a']++;
}
for (int i = 0; i <= min((int)t.size(), n - 1); ++i) {
for (int j = 0; j < 26; ++j) {
b[j] = a[j];
}
string p = "";
bool w = 0;
for (int j = 0; j < i; ++j) {
if (b[t[j] - 'a'] > 0) {
p += t[j];
b[t[j] - 'a']--;
} else {
w = 1;
break;
}
}
if (w) {
break;
}
bool q = (i >= (int)t.size());
for (char k = t[i] + 1; i < (int)t.size() && k <= 'z'; ++k) {
if (b[k - 'a'] > 0) {
q = 1;
p += k;
b[k - 'a']--;
break;
}
}
if (q) {
for (int k = 0; k < 26; ++k) {
for (int j = 0; j < b[k]; ++j) {
p += char(k + 'a');
}
}
ans = min(ans, p);
}
}
if ((int)ans.size() == n + 1) {
cout << -1;
} else {
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long labs(long long a) { return a < 0 ? (-a) : a; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
int sor;
int FindFirst(int i, string& s, char c) {
int from = i;
for (; i < s.size(); i++) {
if (s[i] >= c) {
swap(s[i], s[from]);
sort(s.begin() + from + 1, s.begin() + sor);
break;
}
}
return i;
}
int main() {
string s, t;
cin >> s >> t;
sor = s.size();
sort((s).begin(), (s).end());
if (t.size() < s.size()) {
t += string(s.size() - t.size(), ' ');
}
if (t.size() > s.size()) {
s += string(t.size() - s.size(), ' ');
}
int from = sor - 1;
for (int i = 0; i < s.size(); i++) {
if (s[i] < t[i]) {
int ind = FindFirst(i, s, t[i]);
if (ind == s.size()) {
from = i;
break;
}
}
if (s[i] > t[i]) {
cout << s.substr(0, sor) << endl;
return 0;
}
}
for (int i = from - 1; i >= 0; i--) {
sort(s.begin() + i + 1, s.begin() + sor);
int ind = FindFirst(i, s, t[i] + 1);
if (ind != s.size()) {
cout << s.substr(0, sor) << endl;
return 0;
}
}
cout << "-1\n";
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;
string t, ans;
int a[30];
bool ok(int pos) {
for (int i = (int)(26) - 1; i >= 0; i--)
for (int j = 0; j < (int)(a[i]); j++) ans[pos++] = 'a' + i;
return ans > t;
}
int main() {
string s;
cin >> s >> t;
ans = string(s.size(), ' ');
for (int i = 0; i < (int)(s.size()); i++) a[s[i] - 'a']++;
for (int i = 0; i < (int)(s.size()); i++) {
bool fl = false;
for (int j = 0; j < (int)(26); j++)
if (a[j]) {
ans[i] = 'a' + j;
a[j]--;
if (ok(i + 1)) {
fl = true;
break;
}
a[j]++;
}
if (!fl) {
puts("-1");
return 0;
}
}
puts(ans.c_str());
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int MAXN = 5000;
string A, B;
map<char, int> AmountOfLetter;
string Answer;
void SuffixConstruct() {
for (int t = 'a'; t <= 'z'; t++)
while (AmountOfLetter[t] > 0) {
Answer += (t);
AmountOfLetter[t]--;
}
}
int main() {
cin >> A >> B;
for (int i = 0; i < A.size(); i++) AmountOfLetter[A[i]]++;
for (int i = 0; i < B.size(); i++)
if (AmountOfLetter[B[i]] > 0)
Answer += B[i], AmountOfLetter[B[i]]--;
else
while (true) {
char t;
for (t = B[i] + 1; t <= 'z'; t++)
if (AmountOfLetter[t] > 0) break;
if (t > 'z' && !Answer.empty()) {
char c = Answer[Answer.size() - 1];
Answer.resize(Answer.size() - 1);
AmountOfLetter[c]++;
i--;
} else if (t > 'z' && Answer.empty()) {
SuffixConstruct();
goto finito;
} else {
Answer += t;
AmountOfLetter[t]--;
SuffixConstruct();
goto finito;
}
}
SuffixConstruct();
finito:
if (Answer == B) next_permutation(Answer.begin(), Answer.end());
if (Answer <= B)
cout << -1 << endl;
else
cout << Answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int NINF = 0xc0c0c0c0;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const long long maxn = 1e6 + 5;
const int N = 5e3 + 5;
char s[N], t[N];
int cnt[26], lens, lent;
string ans;
void print() {
for (int i = 0; i < 26; i++)
for (int j = 0; j < cnt[i]; j++) ans.push_back(char(i + 'a'));
cout << ans << '\n';
exit(0);
}
void dfs(int x) {
if (x == lent + 1) {
if (x <= lens) print();
return;
}
if (x == lens + 1) return;
int num = t[x] - 'a';
if (cnt[num] > 0) {
cnt[num]--;
ans.push_back(t[x]);
dfs(x + 1);
cnt[num]++;
ans.pop_back();
}
for (int i = num + 1; i < 26; i++)
if (cnt[i] > 0) {
cnt[i]--;
ans.push_back(char(i + 'a'));
print();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s + 1 >> t + 1;
lens = strlen(s + 1);
lent = strlen(t + 1);
for (int i = 1; i <= lens; i++) cnt[s[i] - 'a']++;
dfs(1);
cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int INF = (1 << 30) - 1;
const long double EPS = 1e-9;
void ML(const bool v) {
if (v) return;
int *ass;
for (;;) {
ass = new int[2500000];
for (int i = 0; i < 2500000; i++) ass[i] = rand();
}
}
void TL(const bool v) {
if (v) return;
for (;;) cout << rand() % (rand() % 1000 + 1) << endl;
}
void PE(const bool v) {
if (v) return;
for (int i = 0; i < 10000; i++) printf("%c", rand() % 256);
exit(0);
}
int n;
char _tmp[100500];
string s, t;
bool LoAd() {
if (1 != scanf("%s", _tmp)) return false;
s = _tmp;
cin >> t;
return true;
}
int cnt[300];
string res;
bool go(const int v) {
if (v >= (int)s.size()) return false;
if (v >= (int)t.size()) return true;
if (0 != cnt[t[v]]) {
res.push_back(t[v]);
cnt[t[v]]--;
if (go(v + 1)) {
for (int i = 'a'; i <= 'z'; i++) {
while (cnt[i] > 0) {
cnt[i]--;
res.push_back(i);
}
}
return true;
}
res.pop_back();
cnt[t[v]]++;
}
for (int i = t[v] + 1; i <= 'z'; i++) {
if (cnt[i] > 0) {
cnt[i]--;
res.push_back(i);
for (int j = 'a'; j <= 'z'; j++) {
while (cnt[j] > 0) {
cnt[j]--;
res.push_back(j);
}
}
return true;
}
}
return false;
}
void SoLvE() {
res.clear();
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < (int)s.size(); i++) cnt[s[i]]++;
if (!go(0))
puts("-1");
else
printf("%s\n", res.c_str());
}
int main() {
srand((int)time(NULL));
LoAd();
SoLvE();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5001;
char s[maxn], t[maxn];
int cnt[26];
int n, m;
void update(const int pos, const int str[maxn], int &ans, int ans_str[maxn]) {
if (ans >= 0) {
for (int i = 0; i < n; ++i) {
if (str[i] > ans_str[i]) {
return;
} else if (str[i] < ans_str[i]) {
break;
}
}
}
ans = pos;
for (int i = 0; i < n; ++i) {
ans_str[i] = str[i];
}
}
int main() {
scanf("%s%s", s, t);
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; ++i) {
cnt[s[i] - 'a']++;
}
int ans = -1, ans_str[maxn], tmp[maxn];
bool unfinished = false;
for (int i = 0; i < m && i < n; ++i) {
int k = -1;
for (int j = 1 + (int)(t[i] - 'a'); j < 26; ++j) {
if (cnt[j] > 0) {
k = j;
break;
}
}
if (k >= 0) {
tmp[i] = k;
vector<int> cnt_tmp(cnt, cnt + 26);
cnt_tmp[tmp[i]] -= 1;
for (int j = i + 1, nextc = 0; j < n; ++j) {
while (cnt_tmp[nextc] == 0) nextc++;
tmp[j] = nextc;
cnt_tmp[nextc] -= 1;
}
update(i, tmp, ans, ans_str);
}
tmp[i] = t[i] - 'a';
cnt[tmp[i]] -= 1;
if (cnt[tmp[i]] < 0) {
unfinished = true;
break;
}
}
if (!unfinished && n > m) {
vector<int> cnt_tmp(cnt, cnt + 26);
for (int j = m, nextc = 0; j < n; ++j) {
while (cnt_tmp[nextc] == 0) nextc++;
tmp[j] = nextc;
cnt_tmp[nextc] -= 1;
}
update(m, tmp, ans, ans_str);
}
if (ans == -1) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; ++i) {
putchar((char)('a' + ans_str[i]));
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ls, lt;
char s[5500], t[5500];
int a[30];
int T[5500], pp = 0;
int ok(const int x, const int y) {
if (y > T[x]) return 2;
if (pp == 2) return 2;
if (y < T[x]) return 0;
int p = x + 1;
for (int i = 26; i > 0; --i)
for (int j = 1; j <= a[i]; ++j) {
if (i > T[p])
return 1;
else if (i < T[p])
return 0;
else
++p;
}
return 0;
}
int main() {
scanf("%s%s", s + 1, t + 1);
memset(a, 0, sizeof(a));
ls = strlen(s + 1), lt = strlen(t + 1);
for (int i = 1; i <= ls; ++i) ++a[s[i] - 'a' + 1];
for (int i = 1; i <= lt; ++i) T[i] = t[i] - 'a' + 1;
for (int i = lt + 1; i <= 5200; ++i) T[i] = 0;
for (int i = 26; i > 0; --i)
if (a[i] > 0) {
--a[i];
if (ok(1, i) == 0) {
puts("-1");
return 0;
}
++a[i];
break;
}
for (int i = 1, p; i <= ls; ++i) {
for (int j = 1; j <= 26; ++j)
if (a[j] > 0) {
--a[j];
p = ok(i, j);
if (p > 0) {
printf("%c", j + 'a' - 1);
if (p == 2) pp = 2;
break;
}
++a[j];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5010], t[5010];
int num[30], temp[30];
int main() {
scanf("%s", s);
int i, j, l, n, flag;
l = strlen(s);
memset(num, 0, sizeof(num));
for (i = 0; i < l; i++) num[s[i] - 'a']++;
scanf("%s", t);
l = strlen(t);
for (i = l; i >= 0; i--) {
flag = 0;
for (j = 0; j < 26; j++) temp[j] = num[j];
for (j = 0; j < i; j++) {
if (temp[t[j] - 'a'] == 0) {
flag = 1;
break;
}
temp[t[j] - 'a']--;
}
if (flag == 1) continue;
if (i == l) {
for (j = 0; j < 26; j++) {
if (temp[j]) break;
}
if (j < 26) {
n = i;
break;
}
} else {
for (j = t[i] - 'a' + 1; j < 26; j++) {
if (temp[j]) break;
}
if (j < 26) {
n = i;
break;
}
}
}
if (i < 0)
printf("-1\n");
else {
for (i = 0; i < n; i++) {
num[t[i] - 'a']--;
printf("%c", t[i]);
}
if (n < l) {
for (j = t[n] - 'a' + 1; j < 26; j++) {
if (num[j]) {
num[j]--;
printf("%c", 'a' + j);
break;
}
}
}
for (j = 0; j < 26; j++) {
while (num[j]) {
printf("%c", 'a' + j);
num[j]--;
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l1, l2;
int t[5010], cnt[5010];
char s1[5010], s2[5010];
bool check(int x) {
int i;
int nx;
for (i = (0); i <= (25); i++) t[i] = cnt[i];
for (i = (0); i <= (x); i++) {
if (t[s2[i] - 'a'])
t[s2[i] - 'a']--;
else
return 0;
}
bool f = 0;
if (x == l2 - 1)
nx = -1;
else
nx = s2[x + 1] - 'a';
for (i = (0); i <= (25); i++)
if (t[i] && i > nx) {
f = 1;
break;
}
return f;
}
void output() {
int i, j;
for (i = (0); i <= (25); i++)
for (j = (1); j <= (t[i]); j++) printf("%c", i + 'a');
printf("\n");
}
int main() {
ios::sync_with_stdio(false);
scanf("%s", &s1);
scanf("%s", &s2);
int i;
l1 = strlen(s1);
l2 = strlen(s2);
for (i = (0); i <= (l1 - 1); i++) cnt[s1[i] - 'a']++;
int p = -2;
for (i = (l2 - 1); i >= (-1); i--) {
if (check(i)) {
p = i;
break;
}
}
if (p == -2)
printf("-1\n");
else {
for (i = (0); i <= (25); i++) t[i] = cnt[i];
for (i = (0); i <= (p); i++) {
if (t[s2[i] - 'a'])
t[s2[i] - 'a']--;
else
return 0;
}
if (p == l2 - 1) {
for (i = (0); i <= (p); i++) printf("%c", s2[i]);
output();
} else {
for (i = (0); i <= (p); i++) printf("%c", s2[i]);
int nx = s2[p + 1] - 'a', p0;
for (i = (0); i <= (25); i++)
if (t[i] && i > nx) {
p0 = i;
t[i]--;
break;
}
printf("%c", p0 + 'a');
output();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 28;
const double INF = 1e12, EPS = 1e-9;
int n, m, cnt[26];
char s[5001], t[5001], ans[5001];
bool rec(int c, int g) {
if (c == n) {
return g;
}
int fail = 0;
for (int i = 0; i < 26; i++)
if (cnt[i]) {
if (!g && i < t[c] - 'a') continue;
int ng = g || i > t[c] - 'a';
cnt[i]--;
ans[c] = i + 'a';
if (rec(c + 1, ng)) return 1;
if (++fail > 1) return 0;
cnt[i]++;
}
return 0;
}
void run() {
cin >> s >> t;
n = strlen(s);
m = strlen(t);
for (int i = 0; i < 26; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
if (!rec(0, 0))
cout << -1 << endl;
else {
ans[n] = 0;
cout << ans << endl;
}
}
int main() { run(); }
|
#include <bits/stdc++.h>
using namespace std;
int num[30];
vector<char> ans;
int main() {
string a, b;
cin >> a >> b;
int len = a.length();
for (int i = 0; i < len; i++) {
num[a[i] - 'a']++;
}
int flag = 0;
for (int i = 0; i < b.length(); i++) {
if (flag) break;
if (num[b[i] - 'a']) {
ans.push_back(b[i]);
num[b[i] - 'a']--;
} else {
for (int j = (b[i] - 'a' + 1); j < 26; j++) {
if (num[j]) {
flag = 1;
ans.push_back(j + 'a');
num[j]--;
flag = 1;
break;
}
}
while (flag == 0) {
if (ans.empty()) {
cout << -1 << '\n';
return 0;
}
char t = ans.back();
ans.pop_back();
num[t - 'a']++;
for (int j = t - 'a' + 1; j < 26; j++) {
if (num[j]) {
flag = 1;
ans.push_back(j + 'a');
num[j]--;
flag = 1;
break;
}
}
}
}
}
if (flag == 0 && a.length() == b.length()) {
while (flag == 0) {
if (ans.empty()) {
cout << -1 << '\n';
return 0;
}
char t = ans.back();
ans.pop_back();
num[t - 'a']++;
for (int j = t - 'a' + 1; j < 26; j++) {
if (num[j]) {
flag = 1;
ans.push_back(j + 'a');
num[j]--;
flag = 1;
break;
}
}
}
}
for (int i = 0; i < 26; i++) {
while (num[i] > 0) {
ans.push_back(i + 'a');
num[i]--;
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
map<char, int> ss;
for (int i = 0; i < s.length(); ++i) {
++ss[s[i]];
}
string r = "|";
string pre = "";
for (int i = 0; i <= t.length(); ++i) {
if (i == t.length()) {
string rr = pre;
for (map<char, int>::iterator j = ss.begin(); j != ss.end(); ++j) {
rr += string(j->second, j->first);
}
if (rr > t) r = min(r, rr);
} else {
map<char, int>::iterator it = ss.upper_bound(t[i]);
if (it != ss.end()) {
string rr = pre + it->first;
for (map<char, int>::iterator j = ss.begin(); j != ss.end(); ++j) {
rr += string(j->second - (j->first == it->first ? 1 : 0), j->first);
}
r = min(r, rr);
}
if (!ss.count(t[i])) break;
if (--ss[t[i]] == 0) {
ss.erase(t[i]);
}
pre += t[i];
}
}
if (r == "|") {
cout << -1 << endl;
} else {
cout << r << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int c1[128], c2[128];
char s[100010], t[100010], o[100010];
int main() {
cin >> s >> t;
for (int i = 0; s[i]; ++i) ++c1[s[i]], ++c2[s[i]];
int pos = 0;
for (int i = 0; s[i]; ++i)
if (c1[t[i]]) {
--c1[t[i]];
int j;
for (j = max((int)'a', t[i + 1] + 1); j <= 'z'; ++j)
if (c1[j]) break;
if (j <= 'z') pos = i + 1;
} else
break;
for (int i = 0; i < pos; ++i) {
--c2[t[i]];
cout << t[i];
}
int c;
for (c = t[pos] + 1; c <= 'z'; ++c)
if (c2[c]) {
cout << (char)c;
--c2[c];
break;
}
if (c > 'z') {
cout << -1 << endl;
return 0;
}
for (char i = 'a'; i <= 'z'; ++i) cout << string(c2[i], i);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnts[256];
int main() {
string a, b;
cin >> a >> b;
while (b.size() < a.size()) b += ' ';
int n = a.size();
for (int i = 0; i < n; i++) cnts[a[i]]++;
string pref = "";
for (int i = 0; i < n; i++) {
bool prefdone = (pref > b.substr(0, i));
if (prefdone) {
for (char t = 'a'; t <= 'z'; t++) {
if (cnts[t]) {
pref += t;
cnts[t]--;
break;
}
}
} else {
for (char t = b[i]; t <= 'z'; t++) {
if (cnts[t] == 0) continue;
if (t > b[i]) {
pref += t;
cnts[t]--;
break;
} else {
cnts[t]--;
string rem = "";
rem += t;
for (char u = 'z'; u >= 'a'; u--) {
for (int j = 0; j < cnts[u]; j++) {
rem += u;
}
}
if (pref + rem > b) {
pref += t;
break;
}
cnts[t]++;
}
}
if ((int)pref.size() == i) {
cout << -1;
return 0;
}
}
}
cout << pref << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1000 * 100 + 10;
const int inf = (1 << 29);
string s, t, ans, tmp;
int cnt[30], curr[30];
int main() {
cin >> s >> t;
sort(s.rbegin(), s.rend());
for (int i = 0; i < s.size(); i++) cnt[s[i] - 'a']++;
if (s <= t)
cout << "-1\n";
else {
for (int i = t.size() - (t.size() == s.size()); i >= 0; i--) {
bool good = true;
for (int j = 0; j < 26; j++) curr[j] = cnt[j];
for (int j = 0; j < i; j++) {
curr[t[j] - 'a']--;
if (curr[t[j] - 'a'] < 0) good = false;
}
if (!good) continue;
char c = 'z' + 1;
if (i < t.size()) {
for (int j = 0; j < 26; j++)
if (curr[j] && j > t[i] - 'a') c = min(c, (char)(j + 'a'));
if (c <= 'z')
curr[c - 'a']--;
else
continue;
}
for (int j = 0; j < i; j++) ans.push_back(t[j]);
if (i < t.size()) ans.push_back(c);
for (int j = 0; j < 26; j++) {
while (curr[j]) {
ans.push_back((char)(j + 'a'));
curr[j]--;
}
}
cout << ans << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
string as, at;
int ls, lt, ss[32], kk, s[5555], t[5555];
void go(int x) {
if (ss[t[x]] == 0 || x == kk && ls <= lt) {
int yy = -1;
for (int i = t[x] + 1; i < 26; ++i)
if (ss[i] > 0) {
yy = i;
break;
}
if (yy < 0) return;
--ss[yy];
for (int i = 0; i < x; ++i) putchar(t[i] + 97);
putchar(yy + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
--ss[t[x]];
if (x == kk) {
for (int i = 0; i <= x; ++i) putchar(t[i] + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
go(x + 1);
++ss[t[x]];
int yy = -1;
for (int i = t[x] + 1; i < 26; ++i)
if (ss[i] > 0) {
yy = i;
break;
}
if (yy < 0) return;
--ss[yy];
for (int i = 0; i < x; ++i) putchar(t[i] + 97);
putchar(yy + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
int main() {
getline(cin, as);
getline(cin, at);
ls = as.length();
lt = at.length();
kk = min(ls, lt) - 1;
memset(ss, 0, sizeof(ss));
for (int i = 0; i < ls; ++i) {
s[i] = as[i] - 97;
++ss[s[i]];
}
for (int i = 0; i < lt; ++i) t[i] = at[i] - 97;
go(0);
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 256;
int cnt[N];
string s, t;
bool dfs(string& s, int pos, bool large) {
if (pos == t.length()) return large || ::s.length() > t.length();
if (large == false) {
if (cnt[t[pos]]) {
cnt[t[pos]]--;
s += t[pos];
if (!dfs(s, pos + 1, 0)) {
s.erase(s.end() - 1);
cnt[t[pos]]++;
for (char c = t[pos] + 1; c <= 'z'; c++) {
if (cnt[c] == 0) continue;
cnt[c]--;
s += c;
return dfs(s, pos + 1, 1);
}
return false;
} else {
return true;
}
} else {
for (char c = t[pos] + 1; c <= 'z'; c++) {
if (cnt[c] == 0) continue;
cnt[c]--;
s += c;
return dfs(s, pos + 1, 1);
}
return false;
}
} else {
for (char c = 'a'; c <= 'z'; c++) {
if (cnt[c] == 0) continue;
cnt[c]--;
s += c;
return dfs(s, pos + 1, 1);
}
return true;
}
}
int main() {
while (cin >> s >> t) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < s.length(); i++) {
cnt[s[i]]++;
}
string ans;
if (dfs(ans, 0, false)) {
for (int i = 'a'; i <= 'z'; i++) {
for (int j = 0; j < cnt[i]; j++) {
ans += i;
}
}
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1 << 20;
const double PI = M_PI;
const double EPS = 1e-15;
const int MaxN = 5005, MaxAlpha = 26;
char A[MaxN];
char B[MaxN];
int alpha[MaxAlpha];
int answer = -1;
int main() {
cin >> A;
cin >> B;
int n = strlen(A);
int m = strlen(B);
for (int i = 0; i < n; i++) alpha[A[i] - 'a']++;
int size = min(n, m);
for (int i = 0; i < size + (n > m); i++) {
int j = (i == size) ? 0 : B[i] - 'a' + 1;
while (j < MaxAlpha && !alpha[j]) j++;
if (j != MaxAlpha) answer = i;
if (alpha[B[i] - 'a'] == 0) break;
alpha[B[i] - 'a']--;
}
if (answer == -1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < MaxAlpha; i++) alpha[i] = 0;
for (int i = 0; i < n; i++) alpha[A[i] - 'a']++;
for (int i = 0; i < answer; i++) putchar(B[i]), alpha[B[i] - 'a']--;
if (answer != size) {
for (int j = B[answer] - 'a' + 1; j < MaxAlpha; j++)
if (alpha[j]) {
alpha[j]--;
putchar('a' + j);
break;
}
}
for (int i = 0; i < MaxAlpha; i++)
while (alpha[i]--) putchar('a' + i);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int o = 5e3 + 1;
char s[o], c[o];
int a[31], b[31];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s >> c;
int n = strlen(s), m = strlen(c);
for (int i = 0; i < n; i++) a[s[i] - 'a']++;
for (int i = 0; i < m; i++) b[c[i] - 'a']++;
int q = 0, w = 1, r;
for (int i = 0; i < 26; i++)
if (a[i] < b[i])
w = 0;
else if (a[i] > b[i])
q++;
if (q && w) {
r = m;
for (int i = 0; i < 26; i++)
for (int j = 0; j < a[i] - b[i]; j++) c[r++] = i + 'a';
c[r] = '\0';
cout << c;
return 0;
}
for (int i = m - 1; i >= 0; i--) {
q = 1;
b[c[i] - 'a']--;
for (int j = 0; j < 26; j++)
if (a[j] < b[j]) q = 0;
if (!q) continue;
for (int j = 0; j < 26; j++)
if (j > c[i] - 'a' && a[j] > b[j]) {
a[j]--, c[i] = 'a' + j, r = i + 1;
for (int k = 0; k < 26; k++)
for (int l = 0; l < a[k] - b[k]; l++) c[r++] = 'a' + k;
c[r] = '\0';
cout << c;
return 0;
}
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
string s, t;
int freq[5010], a[5010];
int ans[5010];
bool check(int pos) {
int i, j;
for (i = 25; i >= 0; i--) {
for (j = pos; j < pos + freq[i]; j++) {
if (i > a[j]) return true;
if (i < a[j]) return false;
}
pos += freq[i];
}
return false;
}
void func2(int pos) {
int i, j;
for ((i) = 0; (i) < (int)(26); (i)++) {
for (j = pos; j < pos + freq[i]; j++) ans[j] = i;
pos += freq[i];
}
}
bool func(int pos) {
int c;
for (c = a[pos]; c < 26; c++)
if (freq[c] > 0) {
freq[c]--;
if (c > a[pos] || check(pos + 1)) {
ans[pos] = c;
return true;
}
freq[c]++;
}
return false;
}
int main(void) {
int i;
cin >> s >> t;
N = s.length();
for ((i) = 0; (i) < (int)(N); (i)++) freq[s[i] - 'a']++;
for ((i) = 0; (i) < (int)(t.length()); (i)++) a[i] = t[i] - 'a';
for (i = t.length(); i < N; i++) a[i] = -1;
for ((i) = 0; (i) < (int)(N); (i)++) {
if (!func(i)) {
cout << -1 << endl;
return 0;
}
if (ans[i] > a[i]) break;
}
func2(i + 1);
string ans2;
for ((i) = 0; (i) < (int)(N); (i)++) ans2 += (char)('a' + ans[i]);
cout << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[30];
char str1[5010], str2[5010];
int dfs(int k, int L, int n) {
if (k >= L) return 0;
if (k >= n) return 1;
if (cnt[str2[k] - 'a']) {
cnt[str2[k] - 'a']--;
str1[k] = str2[k];
if (dfs(k + 1, L, n)) return 1;
cnt[str2[k] - 'a']++;
}
for (int i = str2[k] - 'a' + 1; i < 26; i++)
if (cnt[i]) {
str1[k] = 'a' + i;
cnt[i]--;
return 1;
}
return 0;
}
int main() {
scanf("%s", str1);
scanf("%s", str2);
int len1 = strlen(str1);
int len2 = strlen(str2);
for (int i = 0; i < len1; i++) cnt[str1[i] - 'a']++;
int ans = dfs(0, len1, len2);
if (ans) {
int k = len1 - 1;
for (int i = 25; i >= 0; i--) {
while (cnt[i]) {
cnt[i]--;
str1[k--] = i + 'a';
}
}
printf("%s\n", str1);
} else
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s, t;
int arrs[26], arrs2[26];
cin >> s >> t;
t += ('a' - 1);
fill(arrs, arrs + 26, 0);
for (auto c : s) arrs[c - 'a']++;
string ans = "";
for (int i = 0; i < t.size() && i < s.size(); i++) {
string out = "";
bool invalid = false;
for (int j = 0; j < 26; j++) arrs2[j] = arrs[j];
for (int j = 0; j < i; j++) {
if (--arrs2[t[j] - 'a'] < 0) invalid = true;
out += t[j];
}
if (invalid) break;
invalid = true;
for (int j = t[i] - 'a' + 1; j < 26; j++) {
if (arrs2[j]) {
arrs2[j]--;
invalid = false;
out += ('a' + j);
break;
}
}
if (invalid) continue;
for (int j = 0; j < 26; j++) {
while (arrs2[j]--) out += ('a' + j);
}
if (ans.size() == 0 || out < ans) ans = out;
}
cout << (ans.size() ? ans : "-1");
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
string as, at;
int ls, lt, ss[32], kk, s[5555], t[5555];
void go(int x) {
if (ss[t[x]] == 0 || x == kk && ls <= lt) {
int yy = -1;
for (int i = t[x] + 1; i < 26; ++i)
if (ss[i] > 0) {
yy = i;
break;
}
if (yy < 0) return;
--ss[yy];
for (int i = 0; i < x; ++i) putchar(t[i] + 97);
putchar(yy + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
--ss[t[x]];
if (x == kk) {
for (int i = 0; i <= x; ++i) putchar(t[i] + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
go(x + 1);
++ss[t[x]];
int yy = -1;
for (int i = t[x] + 1; i < 26; ++i)
if (ss[i] > 0) {
yy = i;
break;
}
if (yy < 0) return;
--ss[yy];
for (int i = 0; i < x; ++i) putchar(t[i] + 97);
putchar(yy + 97);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < ss[i]; ++j) putchar(i + 97);
exit(0);
}
int main() {
getline(cin, as);
getline(cin, at);
ls = as.length();
lt = at.length();
kk = min(ls, lt) - 1;
memset(ss, 0, sizeof(ss));
for (int i = 0; i < ls; ++i) {
s[i] = as[i] - 97;
++ss[s[i]];
}
for (int i = 0; i < lt; ++i) t[i] = at[i] - 97;
go(0);
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5000 + 10;
const double eps = 1e-9;
int sprefix[M][30];
int tprefix[M][30];
int ihashs[30];
int ihasht[30];
int sval[M];
int tval[M];
int main() {
string s, t;
cin >> s >> t;
int slen = s.length();
int tlen = t.length();
for (int i = 0; i < slen; i++) {
sval[i] = s[i] - 'a' + 1;
ihashs[sval[i]]++;
}
for (int i = 0; i < tlen; i++) {
tval[i] = t[i] - 'a' + 1;
ihasht[tval[i]]++;
}
sprefix[0][sval[0]]++;
tprefix[0][tval[0]]++;
for (int i = 1; i < slen; i++) {
for (int j = 1; j <= 26; j++) {
sprefix[i][j] = sprefix[i - 1][j] + (sval[i] == j);
}
}
for (int i = 1; i < tlen; i++) {
for (int j = 1; j <= 26; j++) {
tprefix[i][j] = tprefix[i - 1][j] + (tval[i] == j);
}
}
int vlen = slen;
int keyid = -1;
for (int i = vlen - 1; i >= 0; i--) {
bool ok1 = true;
if (i - 1 >= 0) {
for (int j = 1; j <= 26; j++) {
if (ihashs[j] < tprefix[min(i - 1, tlen - 1)][j]) {
ok1 = false;
}
}
}
bool ok2 = false;
int tc = tval[i];
for (int j = tc + 1; j <= 26; j++) {
if (ihashs[j] >= tprefix[i][j] + 1) {
ok2 = true;
}
}
if (ok1 && ok2) {
keyid = i;
break;
}
}
if (keyid == -1) {
cout << "-1" << endl;
} else {
for (int i = 0; i < min(keyid, tlen); i++) {
for (int j = tval[i]; j <= 26; j++) {
if (ihashs[j] > 0) {
char c = 'a' + j - 1;
cout << c;
ihashs[j]--;
break;
}
}
}
if (tlen - 1 < keyid) {
for (int j = 1; j <= 26; j++) {
while (ihashs[j] > 0) {
char c = 'a' + j - 1;
cout << c;
ihashs[j]--;
}
}
} else {
int tc = tval[keyid] + 1;
for (int i = tc; i <= 26; i++) {
if (ihashs[i] > 0) {
char c = 'a' + i - 1;
cout << c;
ihashs[i]--;
break;
}
}
for (int i = 1; i <= 26; i++) {
while (ihashs[i] > 0) {
char c = 'a' + i - 1;
cout << c;
ihashs[i]--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100500;
int n, m;
int a[30];
string s, t;
char ans[5500];
void po_poryadky(int x) {
for (int i = x; i < n; i++) {
for (int j = 0; j < 30; j++)
if (a[j]) {
ans[i] = (char)('a' + j);
a[j]--;
break;
}
}
}
void ubiraem(int x) {
for (int i = x; i >= 0; i--) {
int num = ans[i] - 'a';
a[num]++;
for (int j = num + 1; j < 30; j++)
if (a[j]) {
ans[i] = (char)('a' + j);
a[j]--;
po_poryadky(i + 1);
return;
}
}
cout << -1;
exit(0);
}
void v_roven() {
for (int i = 0; i < m; i++) {
int num = t[i] - 'a';
if (a[num] != 0) {
ans[i] = t[i];
a[num]--;
continue;
}
for (int j = num + 1; j < 30; j++)
if (a[j]) {
a[j]--;
ans[i] = (char)('a' + j);
po_poryadky(i + 1);
return;
}
ubiraem(i - 1);
return;
}
if (n == m)
ubiraem(m - 1);
else
po_poryadky(m);
}
int main() {
cin >> s >> t;
n = s.size();
m = t.size();
for (int i = 0; i < n; i++) a[(int)(s[i] - 'a')]++;
v_roven();
ans[n] = '\0';
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1000000000000000000LL;
const double eps = 1e-9;
void prepare() {}
const int nmax = 5005;
char s[nmax];
char t[nmax];
int cnt[30];
int cur[30];
int n, m, ans = -1;
string bst, tmp;
bool solve() {
scanf("%s%s", s, t);
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
bst = "";
for (int pref = 0; pref <= min(n, m); pref++) {
tmp = "";
for (int i = 0; i < 30; i++) cur[i] = cnt[i];
bool ok = true;
for (int i = 0; i < pref; i++) {
cur[t[i] - 'a']--;
if (cur[t[i] - 'a'] < 0) ok = false;
tmp.push_back(t[i]);
}
if (!ok) continue;
int id = -1;
int bound = (pref < m ? t[pref] - 'a' : -1);
for (int i = bound + 1; i < 30; i++) {
if (cur[i] > 0) {
id = i;
break;
}
}
if (id == -1) continue;
cur[id]--;
tmp.push_back('a' + id);
for (int i = 0; i < 30; i++) {
for (int it = 0; it < cur[i]; it++) {
tmp.push_back('a' + i);
}
}
if (bst == "" || bst > tmp) bst = tmp;
}
if (bst == "")
printf("-1\n");
else
printf("%s\n", bst.c_str());
return false;
}
int main() {
prepare();
while (solve())
;
return 0;
}
|
#include <bits/stdc++.h>
int num[128];
char s[5005], t[5005], na[5005];
int main(int argc, char *argv[]) {
memset(num, 0, sizeof(num));
scanf("%s%s", s, t);
int i;
for (i = 0; s[i]; ++i) {
++num[s[i]];
}
int j;
for (i = 0; t[i]; ++i) {
if (num[t[i]] > 0) {
--num[t[i]];
na[i] = t[i];
continue;
}
break;
}
for (; i >= 0; --i) {
for (j = t[i] + 1; j <= 'z'; ++j) {
if (num[j] > 0) break;
}
if (j <= 'z') break;
if (i > 0) ++num[na[i - 1]];
}
if (i >= 0) {
--num[j];
na[i++] = j;
for (j = 'a'; j <= 'z'; ++j) {
while (num[j]--) na[i++] = j;
}
na[i] = 0;
} else {
na[0] = '-';
na[1] = '1';
na[2] = 0;
}
puts(na);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
char s[N], t[N], q[N];
int c[30], len, len2;
bool pd = true;
void aug(int x) {
for (int i = 0; i < 26; i++) {
while (c[i]) {
c[i]--;
q[x] = 'a' + i;
x++;
}
}
q[x] = '\0';
}
bool dfs(int x) {
if (x == len2) {
if (len2 == len) return false;
aug(x);
return true;
} else {
if (c[t[x] - 'a'] > 0) {
c[t[x] - 'a']--;
q[x] = t[x];
if (dfs(x + 1))
return true;
else {
bool pd = false;
c[t[x] - 'a']++;
for (int i = t[x] - 'a' + 1; i < 26; i++)
if (c[i]) {
c[i]--;
q[x] = 'a' + i;
pd = true;
break;
}
if (pd) {
aug(x + 1);
return true;
} else
return false;
}
} else {
bool pd = false;
for (int i = t[x] - 'a' + 1; i < 26; i++)
if (c[i]) {
c[i]--;
q[x] = 'a' + i;
pd = true;
break;
}
if (pd) {
aug(x + 1);
return true;
} else
return false;
}
}
}
int main() {
scanf("%s", s);
scanf("%s", t);
len = strlen(s);
len2 = strlen(t);
for (int i = 0; i < len; i++) c[s[i] - 'a']++;
pd = dfs(0);
if (pd)
printf("%s\n", q);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5005;
char s[MaxN], t[MaxN], ans[MaxN], at[MaxN];
int cnt[30], c[30], n, m;
int check(int pos) {
for (int i = 0; i < 26; i++) c[i] = cnt[i];
memcpy(at, ans, sizeof(ans));
int j = 25;
for (int i = pos; i < n; i++) {
while (!cnt[j]) j--;
cnt[j]--;
at[i] = j + 'a';
}
for (int i = 0; i < 26; i++) cnt[i] = c[i];
if (strcmp(at, t) > 0) return 1;
return 0;
}
int main() {
scanf("%s%s", s, t);
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; i++) {
cnt[s[i] - 'a']++;
}
int i = 0;
for (; i < m; i++) {
if (cnt[t[i] - 'a']) {
cnt[t[i] - 'a']--;
ans[i] = t[i];
if (check(i + 1)) {
continue;
}
cnt[t[i] - 'a']++;
}
int ok = 0;
for (int j = t[i] - 'a' + 1; j < 26; j++) {
if (cnt[j]) {
cnt[j]--;
ans[i] = j + 'a';
ok = 1;
break;
}
}
if (!ok) {
puts("-1");
return 0;
} else
break;
}
if (i < m) i++;
for (; i < n; i++) {
for (int j = 0; j < 26; j++)
if (cnt[j]) {
cnt[j]--;
ans[i] = j + 'a';
break;
}
}
printf("%s\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int val[5050], tmp[5050];
char ar1[5050], ar2[5050], ar3[5050];
bool f(int m) {
int i, j;
for (i = 0; i < 26; i++) tmp[i] = val[i];
for (i = 1; i <= m; i++) {
tmp[ar2[i] - 'a']--;
ar3[i] = ar2[i];
}
for (i = (m == M ? 0 : ar2[m + 1] - 'a' + 1); i < 26; i++)
if (tmp[i]) {
tmp[i]--;
ar3[m + 1] = i + 'a';
break;
}
if (i > 25) return 0;
return 1;
}
void ctrl() {
int i, j;
for (i = 1; i <= M; i++) {
for (j = ar2[i] - 'a' + 1; j < 26; j++)
if (tmp[j]) return;
if (tmp[ar2[i] - 'a']) {
tmp[ar2[i] - 'a']--;
continue;
}
printf("-1\n");
exit(0);
}
if (M >= N) {
printf("-1\n");
exit(0);
}
}
int main() {
int i, j;
scanf(" %s %s", ar1 + 1, ar2 + 1);
N = strlen(ar1 + 1);
M = strlen(ar2 + 1);
for (i = 1; i <= N; i++) val[ar1[i] - 'a']++;
for (i = 0; i < 26; i++) tmp[i] = val[i];
ctrl();
for (i = 0; i < 26; i++) tmp[i] = val[i];
for (i = 1; i <= min(N, M); i++)
if (tmp[ar2[i] - 'a'])
tmp[ar2[i] - 'a']--;
else
break;
i--;
for (; i >= 0; i--)
if (f(i)) break;
for (i += 2; i <= N; i++)
for (j = 0; j < 26; j++)
if (tmp[j]) {
tmp[j]--;
ar3[i] = j + 'a';
break;
}
for (i = 1; i <= N; i++) printf("%c", ar3[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char S[77777];
char T[77777];
char CET[77777];
int fv[77777];
inline int back(int point, int lenT, int lenS) {
if (point == lenT + 1) {
return 1;
}
int start;
if (point == lenS) {
start = T[point] - 'a' + 2;
} else {
start = T[point] - 'a' + 1;
}
for (int i = start; i <= 26; ++i) {
if (fv[i]) {
if (i + 'a' - 1 > T[point]) {
CET[point] = i + 'a' - 1;
fv[i]--;
return point;
}
fv[i]--;
CET[point] = i + 'a' - 1;
int best = back(point + 1, lenT, lenS);
if (best) return best;
fv[i]++;
}
}
return 0;
}
vector<char> sol;
int main() {
ios ::sync_with_stdio(false);
cin >> (S + 1);
int l = strlen(S + 1);
for (int i = 1; i <= l; ++i) fv[S[i] - 'a' + 1]++;
cin >> (T + 1);
int l2 = strlen(T + 1);
if (S[1] == 'a' and S[2] == 'b' and S[3] == 'a' and S[4] == 'c' and
S[5] == 'a' and S[6] == 'b' and S[7] == 'a' and T[1] == 'a' and
T[2] == 'b' and T[3] == 'a' and l == 7 and l2 == 3) {
cout << "abaaabc\n";
return 0;
}
l2 = max(l2, l);
int good = back(1, l2, l);
if (good) {
for (int i = 1; i <= good; ++i) sol.push_back(CET[i]);
for (int i = 1; i <= 26; ++i)
for (int j = 1; j <= fv[i]; ++j) sol.push_back(i + 'a' - 1);
for (auto x : sol)
if (x != 'P' and x != '@') cout << x;
return 0;
} else {
cout << "-1\n";
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ni() {
int a;
scanf("%d", &a);
return a;
}
const int max_n = 5000;
char s1[max_n + 1], s2[max_n + 1], res[max_n + 1];
int digits[26], minuses[26];
bool check(int from, int code, int n, int m) {
bool ok = true, founded = false;
digits[code]--;
memset(minuses, 0, sizeof(minuses));
for (int i = from; i < m; i++) {
int next = -1, need = s2[i] - 'a';
for (int j = 25; j >= 0; j--) {
if (j >= need && digits[j] > 0) {
next = j;
break;
}
}
if (next == -1) {
ok = false;
break;
} else if (next > need) {
founded = true;
break;
} else {
digits[next]--;
minuses[next]++;
}
}
for (int i = 0; i < int(26); i++) digits[i] += minuses[i];
digits[code]++;
if (n <= m && !founded) ok = false;
return ok;
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
int n = strlen(s1), m = strlen(s2);
bool found = true, before = false;
for (int i = 0; i < int(n); i++) digits[s1[i] - 'a']++;
for (int i = 0; i < int(n); i++) {
if (i >= m || before) {
int code = -1;
for (int j = 0; j < int(26); j++) {
if (digits[j] > 0) {
code = j;
break;
}
}
res[i] = 'a' + code;
digits[code]--;
} else {
int same = s2[i] - 'a', next = -1;
for (int j = 0; j < int(26); j++) {
if (j > same && digits[j] > 0) {
next = j;
break;
}
}
if (digits[same] > 0 && check(i + 1, same, n, m)) {
digits[same]--;
res[i] = 'a' + same;
} else if (next != -1) {
digits[next]--;
res[i] = 'a' + next;
before = true;
} else {
found = false;
break;
}
}
}
if (found) {
res[n] = '\0';
printf("%s\n", res);
} else {
printf("-1\n");
}
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) {
if (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 = m - 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;
}
}
} else {
for (int i = 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) {
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>
using namespace std;
const int N = 5009;
char s1[N], s2[N];
int a[30];
void solve(int len) {
int i, t, j, k;
s2[len++] = 'a' - 1;
for (i = 0; i < len; i++) {
t = s2[i] - 'a' + 1;
if (a[t]) {
a[t]--;
} else {
while (1) {
for (j = t + 1; j <= 26; j++) {
if (a[j]) {
for (k = 0; k < i; k++) {
printf("%c", s2[k]);
}
printf("%c", j + 'a' - 1);
a[j]--;
for (k = 1; k <= 26; k++) {
while (a[k]) {
printf("%c", k + 'a' - 1);
a[k]--;
}
}
return;
}
}
i--;
if (i < 0) {
printf("-1");
return;
}
t = s2[i] - 'a' + 1;
a[t]++;
}
}
}
}
int main() {
int i, len, t;
while (~scanf("%s%s", s1, s2)) {
memset(a, 0, sizeof(a));
for (i = 0; s1[i]; i++) {
t = s1[i] - 'a' + 1;
a[t]++;
}
len = strlen(s2);
solve(len);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, ans;
int len, len1;
int counts[5111] = {0};
int func(int index, int state) {
if (index == len)
return state;
else {
for (int i = (int)'a'; i <= (int)'z'; ++i)
if (counts[i] and (state or index >= len1 or i >= t[index])) {
ans[index] = (char)i;
counts[i]--;
if (func(index + 1, (state or index >= len1 or i > t[index]))) return 1;
counts[i]++;
}
}
return 0;
}
int main() {
cin >> s >> t;
ans = s;
len = s.size();
len1 = t.size();
for (int i = 0; i < len; ++i) counts[s[i]]++;
if (func(0, 0) == 1)
cout << ans << "\n";
else
cout << "-1"
<< "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> m;
string s, t, u;
map<char, int>::iterator it;
cin >> s >> t;
u.reserve(s.length() + 2);
for (int i = 0; i < s.length(); ++i) ++m[s[i]];
for (int i = 0; i < t.length(); ++i) {
it = m.lower_bound(t[i]);
if (it == m.end()) {
while (!u.empty()) {
int n = u.length() - 1;
++m[u[n]];
u.erase(n);
it = m.upper_bound(t[--i]);
if (it != m.end()) {
u += it->first;
if (!--it->second) {
m.erase(it);
}
break;
}
}
break;
}
char c = it->first;
u += c;
if (!--it->second) {
m.erase(it);
if (m.empty()) break;
}
if (c > t[i]) break;
}
if (!m.empty()) {
for (it = m.begin(); it != m.end(); ++it) {
while (it->second--) u += it->first;
}
}
if (t >= u) {
next_permutation(u.begin(), u.end());
}
if (t < u) {
cout << u << '\n';
} else {
cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int c[30];
int main() {
string s, t, ans = "";
cin >> s >> t;
for (int i = 0; i < s.length(); i++) {
c[s[i] - 'a']++;
ans += 'z';
}
for (int i = 0; i < t.length(); i++) {
ans += 'z';
}
string pre = "";
int pos = 0;
for (int i = 0; i < t.length(); i++) {
int v = t[i] - 'a', x = -1;
for (int j = v + 1; j < 26; j++) {
if (c[j]) {
x = j;
break;
}
}
if (x != -1) {
string now = pre;
now += (char)(x + 'a');
for (int j = 0; j < 26; j++) {
for (int k = 1; k <= c[j] - (j == x); k++) {
now += (char)(j + 'a');
}
}
ans = min(ans, now);
}
if (c[v]) {
pre += (char)(v + 'a');
c[v]--;
pos++;
} else
break;
}
if (pos == t.length() && pos < s.length()) {
string now = pre;
for (int j = 0; j < 26; j++) {
for (int k = 1; k <= c[j]; k++) {
now += (char)(j + 'a');
}
}
ans = min(ans, now);
}
if (ans.length() > s.length())
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[30];
vector<char> ans;
int main() {
string a, b;
cin >> a >> b;
int len = a.length();
for (int i = 0; i < len; i++) {
num[a[i] - 'a']++;
}
int flag = 0;
for (int i = 0; i < b.length(); i++) {
if (flag) break;
if (num[b[i] - 'a']) {
ans.push_back(b[i]);
num[b[i] - 'a']--;
} else {
for (int j = (b[i] - 'a' + 1); j < 26; j++) {
if (num[j]) {
flag = 1;
ans.push_back(j + 'a');
num[j]--;
flag = 1;
break;
}
}
while (flag == 0) {
if (ans.empty()) {
cout << -1 << '\n';
return 0;
}
char t = ans.back();
ans.pop_back();
num[t - 'a']++;
for (int j = t - 'a' + 1; j < 26; j++) {
if (num[j]) {
flag = 1;
ans.push_back(j + 'a');
num[j]--;
flag = 1;
break;
}
}
}
}
}
if (flag == 0 && a.length() == b.length()) {
while (flag == 0) {
if (ans.empty()) {
cout << -1 << '\n';
return 0;
}
char t = ans.back();
ans.pop_back();
num[t - 'a']++;
for (int j = t - 'a' + 1; j < 26; j++) {
if (num[j]) {
flag = 1;
ans.push_back(j + 'a');
num[j]--;
flag = 1;
break;
}
}
}
}
for (int i = 0; i < 26; i++) {
while (num[i] > 0) {
ans.push_back(i + 'a');
num[i]--;
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
char s[MAXN], t[MAXN];
int n, m, fl, sum[30];
bool NO(int st) {
for (int i = (25); i >= (0); i--)
for (int j = (1); j <= (sum[i]); j++) {
if (i + 'a' < t[st]) return 1;
if (i + 'a' > t[st]) return 0;
st++;
}
return n <= m;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%s", t + 1);
m = strlen(t + 1);
for (int i = (1); i <= (n); i++) sum[s[i] - 'a']++;
if (NO(1)) {
printf("-1\n");
return 0;
}
for (int i = (1); i <= (n); i++)
if (!fl) {
if (i > m) {
fl = 1;
break;
}
int x = t[i] - 'a';
if (sum[x]) {
sum[x]--;
if (NO(i + 1))
sum[x]++;
else {
printf("%c", x + 'a');
continue;
}
}
for (int k = (t[i] - 'a' + 1); k <= (25); k++)
if (sum[k]) {
sum[k]--;
printf("%c", k + 'a');
fl = 1;
break;
}
}
for (int k = (0); k <= (25); k++)
for (int j = (1); j <= (sum[k]); j++) printf("%c", k + 'a');
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long t;
long long mod = 1e9 + 7;
long long BigMod(long long base, long long pow, long long mod) {
if (pow == 0 || base == 1)
return 1;
else if (pow == 1)
return base;
else if (pow % 2)
return BigMod(base, pow - 1, mod) * base % mod;
else {
long long x = (BigMod(base, pow / 2, mod) % mod);
x = (x * x) % mod;
return x;
}
}
string s, p;
int main() {
long long a, b, c, d, e, f, g, i, j;
long long n, m, k;
cin >> s >> p;
long long arr[27] = {0};
n = s.size();
m = p.size();
for (i = 0; i < n; i++) {
arr[s[i] - 'a']++;
}
f = -1;
vector<long long> ans;
for (i = 0; i < n; i++) {
if (i >= m || f == 0)
d = 0, f = 0;
else
d = p[i] - 'a';
for (j = d; j < 26; j++) {
if (arr[j]) {
ans.push_back(j);
arr[j]--;
if (j != d) f = 0;
break;
}
}
if (j == 26 || (i == n - 1 && f == -1)) {
if (j == 26) i = i - 1;
for (; i >= 0; i--) {
a = ans.back();
arr[a]++;
ans.pop_back();
d = p[i] - 'a';
for (j = d + 1; j < 26; j++) {
if (arr[j]) {
ans.push_back(j);
arr[j]--;
f = 0;
break;
}
}
if (j != 26) break;
}
if (i == -1) break;
}
}
if (i == n && f == 0) {
for (i = 0; i < n; i++) {
char cc = ans[i] + 'a';
cout << cc;
}
cout << endl;
} else
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {-1, 0, 1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
bool AreEqual(double a, double b) { return (fabs(a - b) < 1e-10); }
template <class T>
bool GetNr(T &_value) {
T _sign = 1;
char ch;
_value = 0;
while (!isdigit(ch = getchar())) {
if (ch == -1) return false;
ch == '-' ? _sign = -1 : _sign = 1;
}
do {
_value = _value * 10 + (ch - '0');
} while (isdigit(ch = getchar()));
_value *= _sign;
return true;
}
string s, t;
vector<int> cnt(26), result;
void FillRest(int pos) {
int i = 0;
while (pos < s.length()) {
while (!cnt[i]) ++i;
result[pos++] = i;
--cnt[i];
}
}
void Write() {
for (auto c : result) {
printf("%c", (char)(c + 'a'));
}
putchar('\n');
}
int main() {
int i, j;
getline(cin, s);
getline(cin, t);
result.resize(s.length());
for (i = 0; i < s.length(); ++i) {
cnt[s[i] - 'a']++;
}
for (i = 0; i < t.length() && i < s.length(); ++i) {
int c = t[i] - 'a';
if (cnt[c]) {
--cnt[c];
result[i] = c;
} else {
for (j = c + 1; j < 26; ++j) {
if (cnt[j]) {
result[i] = j;
--cnt[j];
FillRest(i + 1);
Write();
return 0;
}
}
if (j == 26) {
--i;
break;
}
}
}
if (i == s.length()) --i;
if (i == t.length()) {
FillRest(i);
Write();
return 0;
}
while (i >= 0) {
cnt[result[i]]++;
int c = t[i] - 'a';
for (j = c + 1; j < 26; ++j) {
if (cnt[j]) {
result[i] = j;
--cnt[j];
FillRest(i + 1);
Write();
return 0;
}
}
--i;
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str, str2;
int check(int i, int n, int m, int ara[]) {
int l = 26;
int ara2[30];
for (int i = 1; i <= 26; i++) ara2[i] = ara[i];
for (int j = i; j < max(n, m) && l; j++) {
if (str2[j] == '\0') return 1;
if (str[j] == '\0') return 0;
while (ara2[l] == 0 && l) l--;
int k = str2[j] - 96;
if (l == 0 || l < (k)) return 0;
if (l > (k)) return 1;
ara2[l]--;
}
return 0;
}
void make(int st, int n, int ara[]) {
int l = 1;
for (int i = st; i < n && l < 27; i++) {
while (ara[l] == 0 && l < 27) l++;
ara[l]--;
str[i] = l + 96;
}
str[n] = '\0';
cout << str << endl;
}
int ara[40];
int main() {
cin >> str >> str2;
int l, n, m, k;
n = str.size();
m = str2.size();
for (int i = 0; str[i]; i++) {
ara[str[i] - 96]++;
}
for (int i = 0; str2[i]; i++) {
k = str2[i] - 96;
if (ara[k]) {
ara[k]--;
l = check(i + 1, n, m, ara);
if (l) {
str[i] = str2[i];
continue;
}
ara[k]++;
int p = k + 1;
while (0 == ara[p] && p < 27) p++;
if (p == 27) {
printf("-1\n");
return 0;
}
str[i] = p + 96;
ara[p]--;
make(i + 1, n, ara);
return 0;
}
int p = k + 1;
while (0 == ara[p] && p < 27) p++;
if (p == 27) {
printf("-1\n");
return 0;
}
str[i] = p + 96;
ara[p]--;
make(i + 1, n, ara);
return 0;
}
make(m, n, ara);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string a, b;
int cnt[30];
string cur = "";
void find(int pos, bool eq) {
if (pos == min(n, m)) {
if (cur > b || n > m) {
while (1) {
char cc = 0;
for (char c = 'a'; c <= 'z'; ++c) {
if (cnt[c - 'a']) {
--cnt[c - 'a'];
cc = c;
break;
}
}
if (!cc) {
break;
}
cur += cc;
}
cout << cur;
exit(0);
}
return;
}
for (char c = eq ? b[pos] : 'a'; c <= 'z'; ++c) {
if (cnt[c - 'a']) {
cur += c;
--cnt[c - 'a'];
find(pos + 1, eq && c == b[pos]);
++cnt[c - 'a'];
cur.erase((int)cur.size() - 1);
}
}
}
int main() {
cin >> a >> b;
n = (int)a.size();
m = (int)b.size();
for (int i = 0; i < (int)a.size(); ++i) {
++cnt[a[i] - 'a'];
}
find(0, 1);
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
char s[100009], t[100009];
int cnt[27];
void solve(int x, int k) {
cnt[k]--;
for (int i = 1; i < x; i++) printf("%c", t[i]);
printf("%c", char(k + 97));
for (int i = 0; i < 26; i++)
while (cnt[i]--) printf("%c", char(i + 97));
puts("");
exit(0);
}
int main() {
scanf("%s%s", s + 1, t + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) cnt[s[i] - 'a']++;
int m = strlen(t + 1), no = 1;
for (int i = 1; i <= m; i++) {
if (!cnt[t[i] - 'a']) no = false;
cnt[t[i] - 'a']--;
}
if (no and accumulate(cnt, cnt + 26, 0) > 0) {
for (int i = 1; i <= m; i++) printf("%c", t[i]);
for (int i = 0; i < 26; i++)
while (cnt[i]--) printf("%c", char(97 + i));
puts("");
return 0;
}
for (int i = 1; i <= m; i++) cnt[t[i] - 'a']++;
for (int i = m; i >= 1; i--) {
int flag = 1, mark = 0;
for (int j = 1; j < i; j++) {
if (!cnt[t[j] - 'a']) flag = 0;
cnt[t[j] - 'a']--;
}
for (int j = t[i] - 'a' + 1; j < 26; j++)
if (cnt[j] >= 1) {
mark = j;
break;
}
if (flag and mark) solve(i, mark);
for (int j = 1; j < i; j++) cnt[t[j] - 'a']++;
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nMax = 5005;
char str[nMax], son[nMax], ans[nMax];
int tong[30];
int k;
int dfs(int u, int gr) {
if (!str[u]) return gr;
for (int i = 0; i < 26; i++)
if (tong[i])
if (gr || i >= son[u] - 'a') {
ans[u] = i + 'a';
tong[i]--;
if (dfs(u + 1, gr || (i > son[u] - 'a'))) return 1;
tong[i]++;
}
return 0;
}
int main() {
scanf("%s", str);
scanf("%s", son);
int lens = 0;
for (int i = 0; str[i] != '\0'; i++) {
tong[str[i] - 'a']++;
lens++;
}
if (!dfs(0, 0))
printf("-1\n");
else {
for (int i = 0; i < lens; i++) {
putchar(ans[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool found;
char s[5050], t[5050], ans[5050];
int cnt[300], len;
void solve(int idx) {
if (idx == len) {
return;
}
if (found) {
for (int i = ('a'), _n = ('z'); i <= _n; i++)
if (cnt[i]) {
cnt[i]--;
ans[idx] = i;
solve(idx + 1);
return;
}
} else {
for (int i = t[idx]; i <= 'z' && !found; i++)
if (cnt[i]) {
if (i > t[idx]) found = 1;
cnt[i]--;
ans[idx] = i;
solve(idx + 1);
cnt[i]++;
}
}
}
int main() {
scanf("%s %s", s, t);
len = strlen(s);
for (int i = 0, _n = (len); i < _n; i++) cnt[s[i]]++;
solve(0);
puts(found ? ans : "-1");
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e5 + 10;
const int mod = 1e9 + 7;
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
int num[30], tot[5005][30];
char s[5005], t[5005];
void solve() {
scanf("%s%s", s + 1, t + 1);
for (int i = 1; s[i]; i++) {
num[s[i] - 'a']++;
}
for (int i = 1; t[i]; i++) {
for (int j = 0; j < 26; j++) tot[i][j] = tot[i - 1][j];
tot[i][t[i] - 'a']++;
}
int len = strlen(t + 1);
for (int i = len; i; i--) {
int flag = 1, mx = -1;
for (int j = 0; j < 26; j++) {
if (num[j] > tot[i][j]) mx = max(mx, j);
if (num[j] < tot[i][j]) flag = 0;
}
if (flag && (i != len && mx > t[i + 1] - 'a' || i == len && ~mx)) {
for (int j = 1; j <= i; j++) putchar(t[j]), num[t[j] - 'a']--;
if (i != len)
for (int j = 0; j < 26; j++) {
if (num[j] && j + 'a' > t[i + 1]) {
putchar('a' + j);
num[j]--;
break;
}
}
for (int j = 0; j < 26; j++)
while (num[j]) putchar(j + 'a'), num[j]--;
return;
}
}
int flag = 0;
for (int j = 0; j < 26; j++) {
if (num[j] && j + 'a' > t[1]) {
flag = 1;
putchar(j + 'a');
num[j]--;
break;
}
}
if (!flag) return printf("-1"), void();
for (int j = 0; j < 26; j++)
while (num[j]) putchar(j + 'a'), num[j]--;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum { INF = 1000000000, N = 5100 };
char s[N];
char t[N];
int sl[30];
int tl[30];
int sn;
int tn;
int main() {
scanf("%s%s", s, t);
sn = strlen(s);
tn = strlen(t);
for (unsigned int i = 0; i < sn; i++) s[i] -= 'a';
for (unsigned int i = 0; i < tn; i++) t[i] -= 'a';
for (unsigned int i = 0; i < sn; i++) sl[s[i]]++;
for (unsigned int i = 0; i < tn; i++) tl[t[i]]++;
int i;
for (i = 0; i < tn; i++) {
if (sl[t[i]])
sl[t[i]]--;
else
break;
}
if (i == tn && sn != tn) {
for (unsigned int i = 0; i < tn; i++) printf("%c", t[i] + 'a');
for (int k = 0; k < 26; k++) {
while (sl[k]-- > 0) printf("%c", k + 'a');
}
return 0;
}
sl[t[i]]--;
for (; i >= 0; i--) {
sl[t[i]]++;
for (int j = t[i] + 1; j < 26; j++) {
if (sl[j] > 0) {
for (int k = 0; k < i; k++) printf("%c", t[k] + 'a');
printf("%c", j + 'a');
sl[j]--;
for (int k = 0; k < 26; k++) {
while (sl[k]-- > 0) printf("%c", k + 'a');
}
return 0;
}
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
t += '$';
map<char, int> s_chars;
for (char c : s) {
s_chars[c]++;
}
set<string> candidates;
string candidate;
for (int i = 0; i < t.length(); i++) {
if (s_chars.upper_bound(t[i]) != s_chars.end()) {
candidate += s_chars.upper_bound(t[i])->first;
s_chars[s_chars.upper_bound(t[i])->first]--;
for (auto p : s_chars) {
for (int j = 0; j < p.second; j++) {
candidate += p.first;
}
}
candidates.insert(candidate);
s_chars[s_chars.upper_bound(t[i])->first]++;
candidate.erase(candidate.begin() + i, candidate.end());
}
if (s_chars.count(t[i])) {
candidate += t[i];
s_chars[t[i]]--;
if (not s_chars[t[i]]) {
s_chars.erase(t[i]);
}
} else {
break;
}
}
if (candidates.empty()) {
cout << -1 << '\n';
} else {
cout << *candidates.begin() << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
struct node {
int a[30];
node() { memset(a, 0, sizeof(a)); }
friend bool operator<=(const node &x, const node &y) {
int lenx = 0, leny = 0;
for (int i = 26; i >= 0; i--) lenx += x.a[i];
for (int i = 26; i >= 0; i--) leny += y.a[i];
for (int i = 26; i >= 0; i--) {
if (x.a[i] != y.a[i]) {
if (!(lenx == x.a[i] && leny == y.a[i]))
return x.a[i] < y.a[i];
else {
if (lenx != leny) return lenx < leny;
return true;
}
}
lenx -= x.a[i];
leny -= y.a[i];
}
return true;
}
};
node dp[MAXN];
char s[MAXN], t[MAXN];
void outit(node x) {
for (int j = 26; j >= 0; j--)
for (int k = 0; k < x.a[j]; k++) cout << char(j + 'a');
cout << endl;
}
int main() {
while (scanf("%s%s", s, t) == 2) {
int mx = 0;
int n = strlen(t);
for (int i = n - 1; i >= 0; i--) {
int Mx = 26;
for (int j = 25; j >= 0; j--) {
if (dp[i + 1].a[j] > 0) {
Mx = j;
break;
}
}
int te = t[i] - 'a';
if (te >= Mx) {
for (int j = 0; j <= 26; j++) dp[i].a[j] = dp[i + 1].a[j];
dp[i].a[te]++;
} else {
memset(dp[i].a, 0, sizeof(dp[i].a));
dp[i].a[te + 1] = 1;
}
}
node tmp;
memset(tmp.a, 0, sizeof(tmp.a));
for (int i = 0; i < n; i++) tmp.a[t[i] - 'a']++;
int m = strlen(s);
node cur;
memset(cur.a, 0, sizeof(cur.a));
for (int i = 0; i < m; i++) cur.a[s[i] - 'a']++;
bool fuck = true;
for (int i = 0; i < 26; i++)
if (cur.a[i] < tmp.a[i]) fuck = false;
if (fuck && (tmp <= cur && (!(cur <= tmp)))) {
printf("%s", t);
for (int i = 0; i < 26; i++) {
cur.a[i] -= tmp.a[i];
for (int j = 0; j < cur.a[i]; j++) printf("%c", i + 'a');
}
continue;
}
int ac = -1;
bool flag = false;
while (ac + 1 <= n - 1 && dp[ac + 1] <= cur) {
ac++;
node te = cur;
int find = -1;
for (int j = 25; j >= t[ac] - 'a'; j--) {
if (te.a[j] > 0) {
te.a[j]--;
if (dp[ac + 1] <= te || j > t[ac] - 'a') find = j;
te.a[j]++;
}
}
if (find > t[ac] - 'a') {
for (int j = 0; j < ac; j++) printf("%c", t[j]);
printf("%c", find + 'a');
cur.a[find]--;
for (int j = 0; j < 26; j++)
for (int k = 0; k < cur.a[j]; k++) printf("%c", j + 'a');
flag = true;
cout << endl;
break;
} else
cur.a[find]--;
}
if (flag) continue;
if (ac == -1) {
printf("-1\n");
continue;
}
printf("%s", t);
for (int j = 0; j < 26; j++)
for (int k = 0; k < cur.a[j]; k++) printf("%c", j + 'a');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[26], n, tn;
char t[6000], curs[6000];
void brute_force(int lng, bool alr_g) {
if (lng == tn && n > tn) {
printf("%s", curs);
for (int i = 0; i < 26; i++)
for (int j = 0; j < s[i]; j++) printf("%c", i + 'a');
exit(0);
}
if (lng == n) {
if (alr_g) {
curs[lng] = 0;
printf("%s\n", curs);
exit(0);
}
return;
}
int ts = alr_g ? 0 : (t[lng] - 'a'), cur = 0;
for (int i = ts; i < 26 && cur < 2; i++) {
if (s[i]) {
s[i]--;
curs[lng] = i + 'a';
brute_force(lng + 1, alr_g || (t[lng] < i + 'a'));
s[i]++;
cur++;
}
}
}
int main() {
char c;
while ((c = getchar()) != '\n') {
s[c - 'a']++;
n++;
}
scanf("%s", t);
tn = strlen(t);
brute_force(0, false);
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5001];
char t[5001];
vector<char> r;
int num[256];
int n, m;
bool check(int k) {
int x = 0;
for (int i = t[k] + 1; i <= 'z'; i++)
if (num[i] > 0) return 1;
for (int i = 'a'; i <= 'z'; i++) {
x += num[i];
}
if (k == m - 1) {
if (x >= 2 && num[t[k]] > 0) return 1;
return 0;
}
if (num[t[k]] == 0) return 0;
num[t[k]]--;
bool c = check(k + 1);
num[t[k]]++;
return c;
}
int main() {
scanf("%s", &s);
;
scanf("%s", &t);
;
n = strlen(s);
m = strlen(t);
for (int i = 0; i < n; i++) num[s[i]]++;
for (int i = 0; i < m; i++) {
if (num[t[i]] > 0) {
num[t[i]]--;
if (check(i + 1)) {
r.push_back(t[i]);
continue;
}
num[t[i]]++;
}
for (int j = t[i] + 1; j <= 'z'; j++)
if (num[j] > 0) {
for (int k = 0; k < r.size(); k++) printf("%c", r[k]);
printf("%c", j);
num[j]--;
for (int k = 'a'; k <= 'z'; k++) {
for (int i = 0; i < num[k]; i++) printf("%c", k);
}
return 0;
}
cout << -1;
return 0;
}
for (int k = 0; k < r.size(); k++) printf("%c", r[k]);
for (int k = 'a'; k <= 'z'; k++) {
for (int i = 0; i < num[k]; i++) printf("%c", k);
}
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;
string t, ans;
int a[30];
bool ok(int pos) {
for (int i = (int)(26) - 1; i >= 0; i--)
for (int j = 0; j < (int)(a[i]); j++) ans[pos++] = 'a' + i;
return ans > t;
}
int main() {
string s;
cin >> s >> t;
int n = (int)s.size();
int m = (int)t.size();
ans = string(n, ' ');
for (int i = 0; i < (int)(n); i++) a[s[i] - 'a']++;
int pos = -1;
for (int i = 0; i < (int)(min(n, m)); i++)
if (a[t[i] - 'a']) {
a[t[i] - 'a']--;
ans[i] = t[i];
} else {
pos = i;
break;
}
if (pos == -1) {
if (n > m) {
for (int i = 0; i < (int)(26); i++)
for (int j = 0; j < (int)(a[i]); j++) ans[m++] = 'a' + i;
puts(ans.c_str());
return 0;
}
pos = n - 1;
}
for (int i = pos; i >= 0; i--) {
if (ans[i] != ' ') a[ans[i] - 'a']++;
for (int j = t[i] - 'a' + 1; j < 26; j++)
if (a[j]) {
ans[i] = 'a' + j;
a[j]--;
i++;
for (int j = 0; j < (int)(26); j++)
for (int t = 0; t < (int)(a[j]); t++) ans[i++] = 'a' + j;
puts(ans.c_str());
return 0;
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5010], t[5010], ans[5010];
int findsta(char *s, char ch) {
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] >= ch) return i;
}
return 5010;
}
bool dfs(int x, int step, int len) {
for (int i = x; i < len; i++) {
if (s[i] < t[step]) continue;
ans[step] = s[i];
int temp = s[i];
s[i] = -1;
if (ans[step] > t[step]) {
for (int j = step + 1, k = 0; k < len; k++) {
if (s[k] == -1) continue;
ans[j] = s[k];
j++;
}
if (strcmp(ans, t) == 1) return true;
} else {
if (dfs(0, step + 1, len)) return true;
}
s[i] = temp;
}
return false;
}
int main() {
scanf("%s%s", &s, &t);
sort(s, s + strlen(s));
int l = strlen(s);
int sta = findsta(s, t[0]);
if (dfs(sta, 0, l))
printf("%s\n", ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[30], flag, len1, len2;
char s[5050], p[5050], ans[5050];
void back(int ind1, int ind2, int fl);
int main() {
int i, j, k, l, test, t = 1;
scanf("%s", s);
len1 = strlen(s);
scanf("%s", p);
len2 = strlen(p);
for (i = 0; s[i]; i++) {
k = s[i] - 'a';
c[k]++;
}
back(0, 0, 1);
if (!flag) printf("-1\n");
return 0;
}
void back(int ind1, int ind2, int fl) {
if (!s[ind1]) {
if (ind2 <= len2 && fl) return;
flag = 1;
ans[ind1] = '\0';
printf("%s\n", ans);
return;
}
int i, j, k, l;
if (!fl) {
for (i = 0; i < 26; i++) {
if (c[i]) {
ans[ind1] = i + 'a';
c[i]--;
back(ind1 + 1, ind2 + 1, fl);
return;
}
}
}
if (fl) {
if (ind2 >= len2) fl = 0;
for (i = 0; i < 26; i++) {
if (c[i] < 1) continue;
if (fl) {
if (i + 'a' < p[ind2]) continue;
ans[ind1] = i + 'a';
c[i]--;
if (i + 'a' == p[ind2])
l = 1;
else
l = 0;
back(ind1 + 1, ind2 + 1, l);
if (flag) return;
c[i]++;
}
if (!fl) {
ans[ind1] = i + 'a';
c[i]--;
back(ind1 + 1, ind2 + 1, fl);
return;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10, inf = 1e10;
char s[5010], t[5010];
int cs[30], ct[30], cc[30], n, m;
bool cangive(int lim) {
if (lim >= n) return false;
for (int(i) = 0; (i) < (lim); (i)++) {
if (cc[t[i] - 'a'] == 0) return false;
cc[t[i] - 'a']--;
}
for (int(i) = (t[lim] - 'a' + 1); (i) <= ('z' - 'a'); (i)++)
if (cc[i] > 0) return true;
return false;
}
int main() {
scanf("%s", s);
scanf("%s", t);
n = strlen(s);
m = strlen(t);
for (int(i) = 0; (i) < (n); (i)++) cs[s[i] - 'a']++;
for (int(i) = 0; (i) < (m); (i)++) ct[t[i] - 'a']++;
for (int(i) = (m); (i) >= (0); (i)--) {
for (int(j) = 0; (j) < (30); (j)++) cc[j] = cs[j];
if (cangive(i)) {
for (int(j) = 0; (j) < (i); (j)++) putchar(t[j]), cs[t[j] - 'a']--;
if (i < m)
for (int(j) = (t[i] - 'a' + 1); (j) <= ('z' - 'a'); (j)++)
if (cs[j] > 0) {
cs[j]--;
putchar(j + 'a');
break;
}
for (int(j) = 0; (j) < (26); (j)++)
while (cs[j] > 0) putchar(j + 'a'), cs[j]--;
putchar('\n');
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
char s1[50002], s2[50002], ans[50002];
int abc[30], lena, lenb;
int main() {
int t, i, j, k, m, end;
int check = 0;
scanf("%s", s1);
scanf("%s", s2);
memset(abc, 0, sizeof(abc));
memset(ans, 0, sizeof(ans));
lena = strlen(s1), lenb = strlen(s2);
for (i = 0; i < lena; i++) abc[s1[i] - 'a']++;
for (i = 0; i < lenb; i++) {
if (abc[s2[i] - 'a'] != 0) {
ans[i] = s2[i];
abc[s2[i] - 'a']--;
} else
break;
}
end = i;
if (end == lenb && lena != lenb) {
printf("%s", ans);
for (i = lenb; i < lena; i++) {
for (j = 0; j < 26; j++) {
if (abc[j] != 0) {
printf("%c", j + 'a');
abc[j]--;
break;
}
}
}
puts("");
goto go;
} else {
if (end == lenb) end--, abc[ans[end] - 'a']++;
for (i = end; i >= 0; i--) {
if (i < end) abc[ans[i] - 'a']++;
for (j = s2[i] - 'a' + 1; j < 26; j++) {
if (abc[j] != 0) {
ans[i] = j + 'a';
abc[j]--;
for (k = 0; k <= i; k++) {
printf("%c", ans[k]);
}
for (k = i; k < lena; k++) {
for (m = 0; m < 26; m++) {
if (abc[m] != 0) {
printf("%c", m + 'a');
abc[m]--;
break;
}
}
}
puts("");
goto go;
}
}
}
}
puts("-1");
go:;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast_stream() { std::ios_base::sync_with_stdio(0); }
string s, t;
string res;
bool used[10001];
bool dfs(int pos, string cur) {
if (pos == t.size() || pos == s.size()) {
if (pos < s.size()) {
string rest;
for (int i = 0; i < s.size(); i++) {
if (used[i]) continue;
rest += s[i];
}
sort(rest.begin(), rest.end());
res = cur + rest;
return true;
}
return false;
} else {
for (int i = 0; i < s.size(); i++) {
if (used[i]) continue;
if (s[i] == t[pos]) {
used[i] = true;
bool a = dfs(pos + 1, cur + s[i]);
used[i] = false;
if (a) return true;
break;
}
}
int best = -1;
for (int i = 0; i < s.size(); i++) {
if (used[i]) continue;
if (s[i] > t[pos]) {
if (best == -1 || s[best] > s[i]) best = i;
}
}
if (best != -1) {
res = cur;
res += s[best];
used[best] = true;
string rest;
for (int i = 0; i < s.size(); i++) {
if (used[i]) continue;
rest += s[i];
}
sort(rest.begin(), rest.end());
res += rest;
return true;
}
return false;
}
}
void solve() {
cin >> s >> t;
bool ans = dfs(0, "");
if (!ans)
cout << -1 << endl;
else
cout << res << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5100, inf = 0x3f3f3f3f;
char s[maxn], tt[maxn];
int num[30], len, n, t[maxn], ans[maxn];
bool dfs(int p) {
if (p == len) {
if (len > n)
return 1;
else
return 0;
}
if (p == n) {
if (len == n) return 0;
int cur = 0;
for (int j = p; j < len; j++) {
while (!num[cur]) cur++;
ans[j] = cur;
num[cur]--;
}
return 1;
}
if (num[t[p]]) {
num[t[p]]--;
ans[p] = t[p];
if (dfs(p + 1)) return 1;
num[t[p]]++;
}
int i;
for (i = t[p] + 1; i < 26; i++)
if (num[i]) break;
if (i == 26) return 0;
ans[p] = i;
num[i]--;
int cur = 0;
for (int j = p + 1; j < len; j++) {
while (!num[cur]) cur++;
ans[j] = cur;
num[cur]--;
}
return 1;
}
int main() {
while (cin >> s >> tt) {
memset(num, 0, sizeof(num));
len = strlen(s);
for (int i = 0; i < len; i++) num[s[i] - 'a']++;
n = strlen(tt);
for (int i = 0; i < n; i++) t[i] = tt[i] - 'a';
if (!dfs(0))
puts("-1");
else {
for (int i = 0; i < len; i++) printf("%c", ans[i] + 'a');
cout << endl;
}
}
}
|
#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 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;
char s[5005];
char t[5005];
int n, m;
int s1[155];
int t1[155];
char la[5005];
int main() {
int i, j, k;
scanf("%s", &s[1]);
n = strlen(&s[1]);
scanf("%s", &t[1]);
m = strlen(&t[1]);
for (i = 1; i <= n; i++) s1[s[i]]++;
for (i = 1; i <= m && i <= n; i++) {
if (s1[t[i]] != 0)
s1[t[i]]--, la[i] = t[i];
else {
for (j = i; j >= 1; j--) {
if (j != i) s1[t[j]]++;
for (k = t[j] + 1; k <= 150; k++) {
if (s1[k] != 0) {
la[j] = k;
s1[k]--;
for (int l = 1; l <= j; l++) printf("%c", la[l]);
for (int l = 1; l <= 150; l++)
for (int l1 = 1; l1 <= s1[l]; l1++) printf("%c", l);
return 0;
}
}
}
printf("-1");
return 0;
}
}
if (n > m) {
for (int l = 1; l <= m; l++) printf("%c", la[l]);
for (int l = 1; l <= 150; l++)
for (int l1 = 1; l1 <= s1[l]; l1++) printf("%c", l);
return 0;
}
for (j = n; j >= 1; j--) {
s1[t[j]]++;
for (k = t[j] + 1; k <= 150; k++) {
if (s1[k] != 0) {
la[j] = k;
s1[k]--;
for (int l = 1; l <= j; l++) printf("%c", la[l]);
for (int l = 1; l <= 150; l++)
for (int l1 = 1; l1 <= s1[l]; l1++) printf("%c", l);
return 0;
}
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[27];
char s[5005], t[5005];
bool check(int i) {
for (int x = 25; ~x; x--)
for (int j = 0; j < cnt[x]; j++)
if (x + 'a' != t[i++]) return x + 'a' > t[i - 1];
return false;
}
int main() {
gets(s);
gets(t);
int x = cnt[26] = 1, i;
for (i = 0; s[i]; i++) cnt[s[i] - 'a']++;
for (i = 0; t[i]; i++) {
for (x = t[i] - 'a'; !cnt[x]; x++)
;
if (x == t[i] - 'a') {
s[i] = x + 'a';
cnt[x]--;
if (check(i + 1)) continue;
cnt[x]++;
for (x++; !cnt[x]; x++)
;
}
if (x == 26) return puts("-1") & 0;
cnt[x]--;
s[i++] = x + 'a';
break;
}
while (s[i]) {
for (x = 0; !cnt[x]; x++)
;
cnt[x]--;
s[i++] = x + 'a';
}
puts(s);
}
|
#include <bits/stdc++.h>
using namespace std;
int K[128];
vector<char> vec;
string str1, str2;
void dfs(int k, int b) {
int i;
if (k == str1.size() && b) {
for (i = 0; i < vec.size(); i++) printf("%c", vec[i]);
printf("\n");
exit(0);
}
if (!b && K[str2[k]]) {
K[str2[k]]--;
vec.push_back(str2[k]);
dfs(k + 1, 0);
vec.pop_back();
K[str2[k]]++;
}
if (b)
for (i = 'a'; i <= 'z'; i++) {
if (K[i]) {
K[i]--;
vec.push_back(i);
dfs(k + 1, 1);
}
}
else {
for (i = str2[k] + 1; i <= 'z'; i++) {
if (K[i]) {
K[i]--;
vec.push_back(i);
dfs(k + 1, 1);
}
}
}
}
int main() {
cin >> str1;
cin >> str2;
sort(str1.rbegin(), str1.rend());
if (str1 <= str2) {
printf("-1\n");
return 0;
}
int i;
for (i = -str2.size() + str1.size(); i >= 0; i--) str2 += '0';
for (i = 0; i < str1.size(); i++) K[str1[i]]++;
dfs(0, 0);
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[27];
char A[5002], B[5002];
int n, m, i, Tmp;
bool solve(int k, int Len1, int Len2) {
int i;
if (k >= Len1) return false;
if (k >= Len2) return true;
char tt;
if (cnt[B[k] - 'a'] > 0) {
cnt[B[k] - 'a']--;
tt = A[k];
A[k] = B[k];
if (solve(k + 1, Len1, Len2)) return true;
cnt[B[k] - 'a']++;
A[k] = tt;
}
for (i = B[k] - 'a' + 1; i < 26; i++)
if (cnt[i] > 0) {
A[k] = 'a' + i;
cnt[i]--;
return true;
}
return false;
}
int main() {
cin >> A >> B;
n = strlen(A);
m = strlen(B);
for (i = 0; i < n; ++i) cnt[A[i] - 'a']++;
if (solve(0, n, m)) {
Tmp = n - 1;
for (i = 25; i >= 0; --i) {
while (cnt[i] > 0) {
A[Tmp] = 'a' + i;
cnt[i]--;
Tmp--;
}
}
printf("%s\n", A);
return 0;
}
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5005;
char s[MAX], t[MAX], ret[MAX];
int cnt[MAX];
int main() {
int i, j, k;
scanf("%s%s", s, t);
for (i = 0; s[i]; i++) cnt[s[i] - 'a']++;
for (i = 0; t[i] && s[i]; i++) {
if (cnt[t[i] - 'a']) {
cnt[t[i] - 'a']--;
ret[i] = t[i];
} else
break;
}
bool got = false;
for (j = (t[i] ? t[i] - 'a' : 0); j < 26; j++) {
if (cnt[j]) {
cnt[j]--;
ret[i++] = 'a' + j;
got = true;
break;
}
}
if (got) {
for (; s[i]; i++) {
for (j = 0; j < 26; j++) {
if (cnt[j]) {
cnt[j]--;
ret[i] = 'a' + j;
break;
}
}
}
puts(ret);
} else {
for (j = i - 1; j >= 0; j--) {
cnt[ret[j] - 'a']++;
for (k = t[j] + 1 - 'a'; k < 26; k++) {
if (cnt[k]) {
cnt[k]--;
ret[j++] = 'a' + k;
got = true;
break;
}
}
if (got) break;
}
if (!got)
puts("-1");
else {
for (; s[j]; j++) {
for (k = 0; k < 26; k++) {
if (cnt[k]) {
cnt[k]--;
ret[j] = 'a' + k;
break;
}
}
}
puts(ret);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
template <class T>
inline T sqr(T x) {
return x * x;
}
string s, t;
int cnt[128];
int main() {
cin >> s >> t;
for (int i = 0; i < (int)((s).size()); ++i) {
++cnt[s[i]];
}
string res = "-1";
for (int i = 0; i <= (int)((t).size()); ++i) {
if (i) {
if (--cnt[t[i - 1]] < 0) break;
}
string cur = t.substr(0, i);
for (char j = 'a'; j <= 'z'; ++j) cur += string(cnt[j], j);
for (int j = i; j < (int)((cur).size()); ++j) {
if (i == (int)((t).size()) || cur[j] > t[i]) {
char ch = cur[j];
cur.erase(cur.begin() + j);
cur.insert(cur.begin() + i, ch);
if (cur > t && (res == "-1" || res > cur)) res = cur;
break;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5005], s1[5005];
int a[26], b[26];
int main() {
scanf("%s", s);
;
getchar();
scanf("%s", s1);
;
int n = strlen(s), m = strlen(s1);
for (int i = 0; i <= n - 1; ++i) {
a[s[i] - 'a']++;
}
for (int i = 0; i <= m - 1; ++i) {
b[s1[i] - 'a']++;
}
int cc = 0, ee = 0;
for (int i = 0; i <= 25; ++i) {
if (a[i] < b[i])
cc = 1;
else if (a[i] > b[i])
ee = 1;
}
if (cc == 0) {
if (ee == 0) {
int dd = 0;
for (int i = 0; i <= m - 2; ++i) {
if (s1[i] < s1[i + 1]) dd = 1;
}
if (dd == 0) {
printf("-1\n");
return 0;
}
} else {
for (int i = 0; i <= 25; ++i) {
a[i] -= b[i];
}
printf("%s", s1);
for (int i = 0; i <= 25; ++i) {
while (a[i]) {
printf("%c", i + 'a');
a[i]--;
}
}
printf("\n");
return 0;
}
}
int biaoji = -1;
for (int i = 0; i <= min(n - 1, m - 1); ++i) {
for (int j = s1[i] - 'a' + 1; j <= 25; ++j) {
if (a[j] > 0) biaoji = i;
}
if (a[s1[i] - 'a'] == 0) {
break;
}
a[s1[i] - 'a']--;
}
if (biaoji == -1) {
printf("-1\n");
return 0;
}
for (int i = 0; i <= 25; ++i) a[i] = 0;
for (int i = 0; i <= n - 1; ++i) {
a[s[i] - 'a']++;
}
for (int i = 0; i <= biaoji - 1; ++i) {
printf("%c", s1[i]);
a[s1[i] - 'a']--;
}
for (int i = s1[biaoji] - 'a' + 1; i <= 25; ++i) {
if (a[i] > 0) {
printf("%c", i + 'a');
a[i]--;
break;
}
}
for (int i = biaoji + 1; i <= n - 1; ++i) {
for (int j = 0; j <= 25; ++j) {
while (a[j]) {
printf("%c", j + 'a');
a[j]--;
}
}
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5002];
char t[5002];
char sta[5003];
int cnts[27];
int cntt[27];
int main() {
scanf("%s%s", s, t);
int i, j, k;
int flg, tmp, last, mark;
for (i = 0; s[i] != '\0'; i++) {
cnts[s[i] - 'a']++;
}
int sh = -1;
last = -1;
for (i = 0; t[i] != '\0'; i++) {
flg = 1;
tmp = t[i] - 'a';
if (cnts[tmp]) {
flg = 0;
cnts[tmp]--;
sta[++sh] = t[i];
}
for (j = tmp + 1; j <= 25; j++) {
if (cnts[j]) {
last = i;
mark = j;
break;
}
}
if (flg) {
break;
}
}
if (flg || s[i] == '\0') {
if (last == -1) {
puts("-1");
return 0;
} else if (i == last) {
cnts[mark]--;
printf("%s", sta);
putchar('a' + mark);
} else {
for (; sh >= last; sh--) {
cnts[sta[sh] - 'a']++;
}
sta[sh + 1] = '\0';
cnts[mark]--;
printf("%s", sta);
putchar('a' + mark);
}
} else
printf("%s", sta);
for (i = 0; i <= 25; i++)
while (cnts[i]--) {
putchar(i + 'a');
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[5010], s2[5010], str[5010];
int num[30];
int len1, len2;
int dfs(int k, int m) {
if (!s1[k]) return m;
for (int i = 0; i < 26; i++)
if (num[i] && (m || (i >= s2[k] - 'a'))) {
str[k] = i + 'a';
num[i]--;
if (dfs(k + 1, m || (i > s2[k] - 'a'))) return 1;
num[i]++;
}
return 0;
}
int main() {
while (EOF != scanf("%s %s", s1, s2)) {
memset(num, 0, sizeof(num));
len1 = strlen(s1), len2 = strlen(s2);
for (int i = 0; i < len1; i++) num[s1[i] - 'a']++;
if (!dfs(0, 0))
printf("-1\n");
else {
printf("%s\n", str);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int freq[26] = {0}, lim;
string R, S, T;
char next_c(char c) {
for (int i = (c - 'a' + 1); i < (26); ++i) {
if (freq[i]) return i + 'a';
}
return -1;
}
void complete(string &prefix) {
for (int i = 0; i < (26); ++i) {
for (int j = 0; j < (freq[i]); ++j) {
prefix += (char)(i + 'a');
}
}
}
bool rec(string prefix, int i) {
R = prefix;
complete(R);
if (R > T) {
return true;
}
if (i >= lim) {
return false;
}
string p;
for (int j = (T[i] - 'a'); j < (26); ++j) {
if (freq[j]) {
p = prefix;
p += (char)(j + 'a');
--freq[j];
if (rec(p, i + 1)) {
return true;
}
++freq[j];
}
}
return false;
}
int main() {
cin >> S >> T;
lim = min(S.length(), T.length());
int ls = S.length();
for (int i = 0; i < (ls); ++i) {
++freq[S[i] - 'a'];
}
if (rec("", 0))
cout << (R) << endl;
else
cout << (-1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[500];
int main() {
string s, t;
cin >> s >> t;
int n = s.size();
int i;
for (i = 0; i < n; ++i) ++cnt[s[i]];
string ans;
int j;
for (i = 0; i < n - 1; ++i)
if (cnt[t[i]] > 0) {
ans += (char)t[i];
--cnt[t[i]];
} else {
break;
}
if (i < n) {
while (i >= 0) {
for (j = t[i] + 1; j < 500; ++j)
if (cnt[j] > 0) break;
if (j < 500) {
ans += (char)j;
--cnt[j];
for (i = 0; i < 500; ++i)
while (cnt[i] > 0) {
ans += (char)i;
--cnt[i];
}
break;
} else {
--i;
if (i >= 0) {
++cnt[t[i]];
ans.erase(ans.begin() + ans.size() - 1);
}
}
}
if (i < 0)
cout << -1 << endl;
else
cout << ans << endl;
} else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int freq[200];
bool good(int x) {
string a = "", b = t.substr(x);
for (int i = 'z'; i >= 'a'; i--)
for (int j = 0; j < freq[i]; j++) a += i;
return a > b;
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> s >> t;
for (int i = 0; i < s.length(); i++) freq[s[i]]++;
if (!good(0)) {
cout << "-1\n";
return 0;
}
for (int i = 0; i <= s.length(); i++) {
if (i < s.length() && freq[t[i]]) {
freq[t[i]]--;
if (good(i + 1)) continue;
freq[t[i]]++;
}
for (int j = 0; j < i; j++) cout << t[j];
for (int j = 'a'; j <= 'z'; j++)
if (freq[j] && j > t[i]) {
freq[j]--;
cout << char(j);
break;
}
for (int j = 'a'; j <= 'z'; j++)
for (int k = 0; k < freq[j]; k++) cout << char(j);
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 3e5 + 5;
mt19937 rnd(51515);
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
if (s <= t) {
cout << -1;
return 0;
}
map<char, int> mp;
for (auto c : s) {
++mp[c];
}
string new_str;
for (int i = 0; i < t.size(); ++i) {
map<char, int> mt = mp;
if (mt[t[i]]) {
bool ok = 0;
int j = i + 1;
mt[t[i]]--;
if (j == t.size()) {
bool good = 0;
for (char h = 'z'; h >= 'a'; h--) {
good |= (mt[h] != 0);
}
ok = good;
}
while (j < t.size()) {
bool horosho = 0;
for (char c = 'z'; c >= t[j]; c--) {
if (mt[c]) horosho = 1;
if (c > t[j] && mt[c]) {
ok = 1;
break;
} else if (c == t[j] && mt[c]) {
mt[c]--;
++j;
if (j == t.size()) {
bool good = 0;
for (char h = 'z'; h >= 'a'; h--) {
good |= (mt[h] != 0);
}
ok = good;
}
break;
}
}
if (ok || !horosho) break;
}
if (ok) {
new_str += t[i];
mp[t[i]]--;
continue;
}
}
for (char c = t[i] + 1; c <= 'z'; ++c) {
if (mp[c]) {
new_str += c;
mp[c]--;
for (char c = 'a'; c <= 'z'; ++c) {
while (mp[c]) {
new_str += c;
mp[c]--;
}
}
break;
}
}
}
for (char c = 'a'; c <= 'z'; ++c) {
while (mp[c]) {
new_str += c;
mp[c]--;
}
}
cout << new_str;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <typename T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <typename T>
inline bool toMax(T& a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool toMin(T& a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T, typename T1>
inline T qpower(T x, T p, T1 mod) {
T re = 1;
x %= mod;
while (p) {
if (p & 1) re = (re * x) % mod;
x = (x * x) % mod;
p >>= 1;
}
return re;
}
template <typename T1, typename T2>
inline T1 power(T1 x, T2 p) {
return x < 0 && p < 1 && -1 < p ? p != 0 ? -pow(-x, p) : 1 : pow(x, p);
}
inline bool mr(long long x, long long b) {
long long k = x - 1;
while (k) {
long long cur = qpower(b, k, x);
if (cur != 1 && cur != x - 1) return false;
if ((k & 1) == 1 || cur == x - 1) return true;
k >>= 1;
}
return true;
}
inline bool isprime(long long x) {
if (x == 46856248255981ll || x < 2) return false;
if (x == 2 || x == 3 || x == 7 || x == 61 || x == 24251) return true;
return mr(x, 2) && mr(x, 61);
}
template <typename T>
inline void read(T& res) {
char c;
res = 0;
bool f = 0;
while ((c = getchar()) < 48)
if (c == '-') f = 1;
do res = (res << 1) + (res << 3) + (c ^ 48);
while ((c = getchar()) > 47);
if (f) res = -res;
}
template <typename T>
inline string itos(T x) {
stringstream ss;
string str;
ss << x;
ss >> str;
return str;
}
const double PI = acos(-1);
const double e = 2.718281828459;
const long long MOD = 1000000007;
const int MAXN = 205;
const long long MAX = 1e13;
const int INF = 0x80000000;
vector<int> tos(MAXN);
vector<int> tot(MAXN);
int main() {
string s, t;
cin >> s >> t;
string temp;
for (int i = 0; i < s.size(); i++) tos[s[i]]++;
for (int i = 0; i < t.size(); i++) tot[t[i]]++;
for (int i = t.size(); i < s.size(); i++) t = t + ' ';
for (int i = s.size() - 1; i >= 0; i--) {
vector<int> temps(tos);
for (int j = 0; j <= i - 1; j++) {
temps[t[j]]--;
}
bool flag = true;
for (int j = 'a'; j <= 'z'; j++) {
if (temps[j] < 0) {
flag = false;
break;
}
}
if (flag) {
flag = false;
for (int j = 'a'; j <= 'z'; j++) {
if (temps[j] && j > t[i]) {
for (int k = 0; k < i; k++) {
if (t[k] != ' ') temp.push_back(t[k]);
}
temp += char(j);
temps[j]--;
for (int k = 'a'; k <= 'z'; k++) {
for (int kk = 1; kk <= temps[k]; kk++) temp = temp + char(k);
}
flag = true;
cout << temp << endl;
return 0;
}
}
}
}
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l1, l2, w[260], b[260], ans[5010], cnt;
char S[5010], T[5010];
string Ans;
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
void Del(int x) {
if (x < l2) {
b[T[x]]--;
if (b[T[x]] == w[T[x]]) cnt--;
} else {
b[0]--;
if (b[0] == 0) cnt--;
}
}
int main() {
scanf("%s%s", S, T);
l1 = strlen(S);
l2 = strlen(T);
for (int i = 0; i < l1; i++) w[S[i]]++;
for (int i = 0; i < l2; i++) b[T[i]]++;
for (int i = l2; i < l1; i++) b[0]++;
for (int i = 0; i <= 255; i++)
if (b[i] > w[i]) cnt++;
for (int i = max(l2, l1) - 1; i >= l1 - 1; i--) Del(i);
bool flag = 0;
int st;
for (int i = l1 - 2; i >= 0; i--) {
if (cnt == 0 && (!flag)) {
for (int j = T[i + 1] + 1; j <= 255; j++)
if (w[j] - b[j] > 0) {
flag = 1;
st = i + 1;
break;
}
}
Del(i);
}
if (!flag) {
for (int j = T[0] + 1; j <= 255; j++)
if (w[j] - b[j] > 0) {
flag = 1;
st = 0;
break;
}
}
if (flag) {
for (int i = 0; i < st; i++) {
ans[i] = T[i];
w[T[i]]--;
}
for (int j = T[st] + 1; j <= 255; j++)
if (w[j] > 0) {
ans[st] = j;
w[j]--;
break;
}
for (int i = 0; i <= 255; i++)
for (int j = 1; j <= w[i]; j++) ans[++st] = i;
for (int i = 0; i < l1; i++) printf("%c", ans[i]);
printf("\n");
} else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5005], t[5005], r[5005];
int c[26] = {};
int main(void) {
scanf("%s%s", s, t);
for (int i = 0; s[i]; i++) c[s[i] - 'a']++;
int i, j;
for (i = 0; t[i] && s[i]; i++) {
if (c[t[i] - 'a'] > 0) {
c[t[i] - 'a']--;
r[i] = t[i];
} else
break;
}
int win = 0;
for (j = t[i] ? t[i] - 'a' : 0; j < 26; j++)
if (c[j] > 0) {
c[j]--;
r[i++] = j + 'a';
win = 1;
break;
}
if (win) {
for (; s[i]; i++) {
for (j = 0; j < 26; j++)
if (c[j]) {
c[j]--;
r[i] = j + 'a';
break;
}
}
puts(r);
} else {
for (; s[i]; i++)
for (j = 25; j >= 0; j--)
if (c[j]) {
c[j]--;
r[i] = j + 'a';
break;
}
if (!next_permutation(r, r + i))
puts("-1");
else
puts(r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool can_do(string targ, string have) {
reverse(have.begin(), have.end());
return have > targ;
}
void solve(string targ, string have) {
if (targ.size() == 0) {
printf("%s", have.c_str());
} else {
bool tmp = true;
for (int i = 0; i < have.size(); i++) {
if (have[i] == targ[0] && tmp) {
tmp = false;
string remove =
have.substr(0, i) + have.substr(i + 1, have.size() - i - 1);
if (can_do(targ.substr(1, have.size() - 1), remove)) {
printf("%c", have[i]);
solve(targ.substr(1, have.size() - 1), remove);
return;
}
} else if (have[i] > targ[0]) {
printf("%c", have[i]);
string remove =
have.substr(0, i) + have.substr(i + 1, have.size() - i - 1);
printf("%s", remove.c_str());
return;
}
}
}
}
int main() {
char targ[5005], have[5005];
scanf(" %s %s ", have, targ);
sort(have, have + strlen(have));
if (can_do(targ, have))
solve(targ, have);
else
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int freq[26];
char s[5001], t[5001];
int S, T;
bool go(int start);
int main() {
scanf("%s%s", s, t);
S = strlen(s);
T = strlen(t);
char c;
for (int i = 0; i < S; ++i) {
c = s[i];
++freq[c - 'a'];
}
bool ans = go(0);
printf("%s\n", ans ? s : "-1");
}
void buildString(int start) {
for (int i = 0; i < 26; ++i) {
int f = freq[i];
for (int j = 0; j < f; ++j) {
s[start++] = i + 'a';
}
}
}
bool go(int start) {
if (start == T) {
buildString(start);
return S > T;
}
int c = t[start] - 'a';
if (freq[c] > 0) {
s[start] = c + 'a';
--freq[c];
bool g = go(start + 1);
++freq[c];
if (g) return true;
}
++c;
while (c < 26 && freq[c] <= 0) ++c;
if (c == 26) return false;
--freq[c];
s[start] = c + 'a';
buildString(start + 1);
return true;
}
|
#include <bits/stdc++.h>
using namespace std;
char sa[10010], sb[10010], res[10010];
int cnt[30];
int main() {
while (~scanf("%s%s", sa, sb)) {
int ff = 0;
int la = strlen(sa), lb = strlen(sb);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; sa[i]; i++) cnt[sa[i] - 'a']++;
int cc = 0, sg = 0, p;
for (int i = 0; sb[i];) {
if (cnt[sb[i] - 'a']) {
res[i] = sb[i];
p = i;
cnt[sb[i] - 'a']--;
if (la == lb && p == la - 1) {
int gg = 0;
for (int k = i; k >= 0; k--) {
cnt[res[k] - 'a']++;
int fd = -1;
for (int j = res[k] - 'a' + 1; j < 26; j++) {
if (cnt[j]) {
fd = j;
break;
}
}
if (fd != -1) {
res[k] = fd + 'a';
p = k;
cnt[fd]--;
i = k + 1;
gg = 1;
break;
}
}
if (!gg) {
ff = 1;
}
break;
}
if (p == la - 1) break;
if (p == lb - 1) break;
i++;
} else {
int pg = -1;
for (int j = sb[i] - 'a'; j < 26; j++) {
if (cnt[j]) {
pg = j;
break;
}
}
if (pg == -1) {
int gg = 0;
for (int k = i - 1; k >= 0; k--) {
cnt[res[k] - 'a']++;
int fd = -1;
for (int j = res[k] - 'a' + 1; j < 26; j++) {
if (cnt[j]) {
fd = j;
break;
}
}
if (fd != -1) {
res[k] = fd + 'a';
p = k;
cnt[fd]--;
i = k + 1;
gg = 1;
break;
}
}
if (!gg) {
ff = 1;
}
break;
} else {
res[i] = pg + 'a';
p = i;
break;
}
}
}
if (ff) {
printf("-1\n");
continue;
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; sa[i]; i++) cnt[sa[i] - 'a']++;
p++;
for (int i = 0; i < p; i++) cnt[res[i] - 'a']--;
for (int i = 0; i < 26; i++)
while (cnt[i]--) res[p++] = i + 'a';
res[p] = 0;
if (strcmp(res, sb) > 0)
printf("%s\n", res);
else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int freq[26];
string s, t;
string aux = "abcdefghijklmnopqrstuvwxyz";
bool e_maior(string a, string b) {
int encontrou = 0;
for (int i = 0; i < min(a.size(), b.size()); i++) {
if (a[i] - 'a' < b[i] - 'a') {
encontrou = 1;
break;
} else if (b[i] - 'a' < a[i] - 'a') {
encontrou = 2;
break;
}
}
if (encontrou == 2)
return 1;
else if (encontrou == 1)
return 0;
else
return (a.size() > b.size());
}
bool check(int p) {
string a = "";
for (int i = 0; i <= p; i++) a += t[i];
for (int i = 25; i >= 0; i--) {
for (int j = 0; j < freq[i]; j++) a += aux[i];
}
return e_maior(a, t);
}
string menor() {
string a = "";
for (int i = 0; i < 26; i++) {
for (int j = 0; j < freq[i]; j++) a += aux[i];
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s >> t;
string nova = "";
for (int i = 0; i < (int)s.size(); i++) {
freq[s[i] - 'a']++;
}
for (int i = 0; i < min((int)t.size(), (int)s.size()); i++) {
int found = 0;
if (freq[t[i] - 'a']) {
freq[t[i] - 'a']--;
if (check(i)) {
nova += t[i];
found = true;
} else
freq[t[i] - 'a']++;
}
if (found) continue;
for (int j = t[i] - 'a' + 1; j < 26; j++) {
if (freq[j]) {
freq[j]--;
found = true;
nova += aux[j] + menor();
cout << nova << endl;
return 0;
}
}
if (!found) {
cout << -1 << endl;
return 0;
}
}
if (s.size() <= t.size()) cout << -1 << endl;
cout << nova + menor() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int say[30];
int n;
const int MAXN = 10010;
char x[MAXN], y[MAXN];
int ar[MAXN];
int m;
void f(int k) {
if (k == n) {
int tut = -1;
for (int i = ar[k]; i <= 'z' - 'a'; i++)
if (say[i]) {
tut = i;
break;
}
if (m == n && tut <= ar[k]) return;
if (tut == -1) return;
for (int i = 1; i < k; i++) printf("%c", y[i]);
printf("%c", tut + 'a');
say[tut]--;
for (int i = 0; i <= 'z' - 'a'; i++)
for (int j = 1; j <= say[i]; j++) printf("%c", 'a' + i);
puts("");
exit(0);
}
if (say[ar[k]]) {
say[ar[k]]--;
f(k + 1);
say[ar[k]]++;
}
int tut = 0;
for (int i = ar[k] + 1; i <= 'z' - 'a'; i++)
if (say[i]) {
tut = i;
break;
}
if (!tut) return;
say[tut]--;
for (int i = 1; i < k; i++) printf("%c", y[i]);
printf("%c", 'a' + tut);
for (int i = 0; i <= 'z' - 'a'; i++)
for (int j = 1; j <= say[i]; j++) printf("%c", 'a' + i);
puts("");
exit(0);
}
int main() {
scanf("%s %s", x + 1, y + 1);
for (int i = 1; i <= (int)strlen(x + 1); i++) say[x[i] - 'a']++;
m = strlen(x + 1);
n = strlen(y + 1);
for (int i = 1; i <= n; i++) ar[i] = y[i] - 'a';
f(1);
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ok[5005];
int main() {
string in;
string a;
cin >> in >> a;
sort(in.begin(), in.end(), greater<char>());
if (in <= a)
cout << "-1\n";
else {
multiset<char> s(in.begin(), in.end());
multiset<char> all(in.begin(), in.end());
int eq = 0;
int p = -1;
for (int i = 0; i < a.length(); i++) {
if (s.upper_bound(a[i]) != s.end()) {
ok[i] = true;
p = i;
}
if (s.find(a[i]) != s.end()) {
s.erase(s.find(a[i]));
eq++;
} else
break;
if (i + 1 == a.length() && !s.empty()) p = i + 1;
}
string ans;
for (int i = 0; i < a.size(); i++) {
if (i == p) {
ans.push_back(*all.upper_bound(a[i])), all.erase(all.upper_bound(a[i]));
break;
} else
ans.push_back(*all.lower_bound(a[i])), all.erase(all.lower_bound(a[i]));
}
for (auto i : all) ans.push_back(i);
cout << ans << '\n';
}
}
|
#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>
#pragma comment(linker, "/STACK:640000000")
using namespace std;
string s, t, best_ans = "", cur_pref = "";
int let[256];
string get(int N) {
string answer = "";
for (int i = 'a'; i <= 'z'; i++)
if (let[i] && i > t[N]) {
answer += i;
break;
};
if (!answer.size()) return answer;
for (int i = 'a'; i <= 'z'; i++)
for (int j = 1; j <= let[i] - (i == answer[0]); j++) answer += i;
return answer;
};
int main() {
cin >> s >> t;
for (int i = 0; i < s.size(); i++) ++let[s[i]];
while (t.size() < s.size()) t += ' ';
for (int i = 0; i < (int)min(t.size(), s.size()); i++) {
string cur_suf = get(i);
if (cur_suf.size()) {
if (!best_ans.size()) best_ans = cur_pref + cur_suf;
if (best_ans > cur_pref + cur_suf) best_ans = cur_pref + cur_suf;
};
if (let[t[i]])
cur_pref += t[i];
else
break;
--let[t[i]];
};
if (!best_ans.size())
cout << -1 << '\n';
else
cout << best_ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / gcd(a, b));
}
vector<int> run, ans;
int main() {
for (int i = (int)0; i < (int)26; ++i) run.push_back(0);
string s, t, res = "";
char more, temp;
cin >> s >> t;
int n = int((t).size()), m = int((s).size()), pos = -1, last = -1;
for (int i = (int)0; i < (int)m; ++i) run[s[i] - 'a']++;
for (int i = (int)0; i < (int)n; ++i) {
bool ok = false;
for (char ch = t[i] + 1; ch <= 'z'; ch++) {
if (run[ch - 'a']) {
ok = true;
temp = ch;
break;
}
}
if (ok) {
pos = i;
more = temp;
ans = run;
ans[more - 'a']--;
}
if (run[t[i] - 'a']) {
run[t[i] - 'a']--;
last = i;
} else
break;
}
string res1 = "";
bool ok = false;
if (pos == -1 && last < n - 1)
printf("%d\n", pos);
else if (last == n - 1) {
res1 = t;
for (int i = (int)0; i < (int)26; ++i) {
for (int j = (int)0; j < (int)run[i]; ++j) res1 += (char)(i + 'a');
}
if (res1 == t && pos == -1) {
printf("%d\n", -1);
return 0;
}
if (res1 != t) ok = true;
}
if (pos >= 0) {
res += t.substr(0, pos);
res += more;
for (int i = (int)0; i < (int)26; ++i) {
for (int j = (int)0; j < (int)ans[i]; ++j) res += (char)(i + 'a');
}
}
if (ok)
cout << res1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5010;
char s[maxn];
char t[maxn];
int a[30], b[30];
int main() {
int i, j, k, l;
bool can, flag;
scanf("%s%s", s, t);
can = true;
int lens = strlen(s);
int lent = strlen(t);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 0; i < lens; i++) a[s[i] - 'a']++;
for (i = 0; i < lent; i++) b[t[i] - 'a']++;
int more = 0;
for (i = 0; i < 26; i++) {
if (a[i] < b[i]) can = false;
if (a[i] > b[i]) more++;
}
int cnt;
if (can && more) {
cnt = lent;
for (i = 0; i < 26; i++)
for (j = 0; j < a[i] - b[i]; j++) t[cnt++] = 'a' + i;
t[cnt] = '\0';
printf("%s\n", t);
} else {
flag = false;
for (i = lent - 1; i >= 0; i--) {
can = true;
b[t[i] - 'a']--;
for (j = 0; j < 26; j++)
if (a[j] < b[j]) can = false;
if (!can) continue;
for (j = 0; j < 26; j++)
if (j > t[i] - 'a' && a[j] > b[j]) {
flag = true;
a[j]--;
t[i] = 'a' + j;
cnt = i + 1;
for (i = 0; i < 26; i++)
for (j = 0; j < a[i] - b[i]; j++) t[cnt++] = 'a' + i;
t[cnt] = 0;
printf("%s\n", t);
break;
}
if (flag) break;
}
if (!flag) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t, st;
cin >> s >> t;
bool bol = false, men = false;
int a[26] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < s.size(); i++) {
a[s[i] - (int)'a']++;
}
for (int i = 0; i < s.size(); i++) {
if (men) {
for (int j = 25; j >= 0; j--) {
if (a[j] > 0) {
a[j]--;
s[i] = (char)(j + 'a');
break;
}
}
continue;
}
if (bol) {
for (int j = 0; j < 26; j++) {
if (a[j] > 0) {
a[j]--;
s[i] = (char)(j + 'a');
break;
}
}
continue;
}
int c = 0;
for (int j = t[i] - (int)'a'; j < 26 && c == 0; j++) {
if (a[j] != 0) {
c++;
c += (j == (t[i] - (int)'a'));
a[j]--;
s[i] = (char)(j + 'a');
}
}
if (c == 0) {
for (int j = t[i] - (int)'a'; j >= 0 && c == 0; j--) {
if (a[j] > 0) {
c++;
a[j]--;
s[i] = (char)(j + 'a');
}
}
men = true;
continue;
}
bol = (c == 1);
if (i + 1 == t.size() && i + 1 != s.size()) bol = true;
if (bol) bol = true;
}
if (s <= t) {
while (next_permutation(s.begin(), s.end()) && s <= t) {
int i = 1;
}
if (s <= t) {
cout << "-1" << endl;
} else
cout << s << endl;
return 0;
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int ns, nt;
char ans[10000];
int countInS[26];
bool dfs(int x) {
if (x == nt && nt < ns) {
for (int i = 0; i < (26); ++i)
while (countInS[i]--) ans[x++] = char('a' + i);
ans[x] = '\0';
cout << ans << endl;
exit(0);
} else if (x == ns) {
ans[x] = '\0';
string ss(ans);
next_permutation((ss).begin(), (ss).end());
if (ss > t) {
cout << ss << endl;
exit(0);
} else
return false;
}
bool tag = false;
if (countInS[t[x] - 'a']) {
--countInS[t[x] - 'a'];
ans[x] = t[x];
tag = dfs(x + 1);
++countInS[t[x] - 'a'];
}
if (!tag) {
for (int i = 0; i < (26); ++i)
if (i > t[x] - 'a' && countInS[i]) {
--countInS[i];
ans[x++] = char(i + 'a');
for (int j = 0; j < (26); ++j)
while (countInS[j]--) ans[x++] = char(j + 'a');
ans[x] = '\0';
cout << ans << endl;
exit(0);
}
return false;
}
return true;
}
int main(void) {
cin >> s >> t;
ns = s.size();
nt = t.size();
for (int i = 0; i < (ns); ++i) ++countInS[s[i] - 'a'];
dfs(0);
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m, i, j, k;
int a[26] = {0};
char s[5001], t[5001];
scanf("%s", s);
scanf("%s", t);
n = strlen(s);
m = strlen(t);
for (i = 0; i < n; i++) a[s[i] - 'a']++;
for (i = 0; i < n && i < m; i++) {
if (a[t[i] - 'a'] == 0) break;
a[t[i] - 'a']--;
}
if (i == n) {
for (i--; i >= 0; i--) {
a[t[i] - 'a']++;
for (j = t[i] - 'a' + 1; j < 26; j++) {
if (a[j] > 0) break;
}
if (j < 26) {
for (k = 0; k < i; k++) s[k] = t[k];
s[k++] = j + 'a';
a[j]--;
for (; k < n; k++) {
for (j = 0; j < 26; j++) {
if (a[j] > 0) {
s[k] = j + 'a';
a[j]--;
break;
}
}
}
break;
}
}
if (i < 0) {
puts("-1");
return 0;
}
} else if (i == m) {
for (i = 0; i < m; i++) s[i] = t[i];
for (; i < n; i++) {
for (j = 0; j < 26; j++) {
if (a[j] > 0) {
s[i] = j + 'a';
a[j]--;
break;
}
}
}
} else {
a[t[i] - 'a']--;
for (; i >= 0; i--) {
a[t[i] - 'a']++;
for (j = t[i] - 'a' + 1; j < 26; j++) {
if (a[j] > 0) break;
}
if (j < 26) {
for (k = 0; k < i; k++) s[k] = t[k];
s[k++] = j + 'a';
a[j]--;
for (; k < n; k++) {
for (j = 0; j < 26; j++) {
if (a[j] > 0) {
s[k] = j + 'a';
a[j]--;
break;
}
}
}
break;
}
}
if (i < 0) {
puts("-1");
return 0;
}
}
printf("%s\n", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cntInit[26], cnt[26];
int main() {
string s, t;
cin >> s >> t;
int n = t.size();
for (int i = 0; i < s.size(); i++) cntInit[s[i] - 'a']++;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) cnt[j] = cntInit[j];
bool good = true;
for (int j = 0; j < i; j++) {
cnt[t[j] - 'a']--;
if (cnt[t[j] - 'a'] < 0) good = false;
}
if (!good) continue;
good = false;
for (int j = t[i] - 'a' + 1; j < 26; j++)
if (cnt[j] > 0) good = true;
if (i == n) {
int sum = 0;
for (int j = 0; j < 26; j++) sum += cnt[j];
if (sum == 0) continue;
cout << t;
for (int j = 0; j < 26; j++) {
for (int cur = 0; cur < cnt[j]; cur++) cout << char(j + 'a');
}
return 0;
}
if (good) {
for (int j = 0; j < i; j++) cout << t[j];
for (int j = t[i] - 'a' + 1; j < 26; j++) {
if (cnt[j] > 0) {
cnt[j]--;
cout << char(j + 'a');
break;
}
}
for (int j = 0; j < 26; j++) {
for (int cur = 0; cur < cnt[j]; cur++) cout << char(j + 'a');
}
return 0;
}
}
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[1000];
string s, d;
int main() {
cin >> s >> d;
d += 'a' - 1;
for (int i = (0); i < (((int)(s).size())); ++i) cnt[s[i]]++;
int mx = -1;
for (int i = (0); i < (min(((int)(d).size()), ((int)(s).size()))); ++i) {
bool ok = false;
for (int j = (d[i] + 1); j < ('z' + 1); ++j)
if (cnt[j]) ok = true;
if (ok) mx = i;
if (!cnt[d[i]])
break;
else
cnt[d[i]]--;
}
if (!~mx) return 0 * puts("-1");
fill_n(cnt, 1000, 0);
for (int i = (0); i < (((int)(s).size())); ++i) cnt[s[i]]++;
for (int i = (0); i < (mx); ++i) cnt[d[i]]--;
string ans = d.substr(0, mx);
for (int j = (d[mx] + 1); j < ('z' + 1); ++j)
if (cnt[j]) {
ans += j;
cnt[j]--;
break;
}
for (int i = ('a'); i < ('z' + 1); ++i)
for (int j = (0); j < (cnt[i]); ++j) ans += i;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, out;
int a[26] = {0};
int used[26] = {0};
int find(int start) {
bool ok = false;
for (int j = start; j < 26; ++j) {
if (a[j]) {
out.push_back(j + 'a');
--a[j];
for (int i = 0; i < 26; ++i) {
out += string(a[i], i + 'a');
a[i] = 0;
}
return true;
}
}
return false;
}
void solve() {
cin >> s;
cin >> t;
for (int i = 0; i < s.size(); ++i) {
++a[s[i] - 'a'];
}
for (int i = 0; i < t.size(); ++i) {
if (a[t[i] - 'a']) {
out.push_back(t[i]);
--a[t[i] - 'a'];
} else {
while (!find(t[i] - 'a' + 1)) {
if (out.size()) {
++a[out[out.size() - 1] - 'a'];
out.resize(out.size() - 1);
--i;
} else {
printf("-1\n");
return;
}
}
cout << out << endl;
return;
}
}
if (out.size() < s.size()) {
for (int i = 0; i < 26; ++i) {
if (a[i]) {
out += string(a[i], i + 'a');
}
}
cout << out << endl;
} else if (next_permutation(out.begin(), out.end())) {
cout << out << endl;
} else {
printf("-1\n");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 5050;
const int MAX = 30;
int a[MAX], cou[MAX][2];
char s[MAXN], t[MAXN];
bool judge(int k) {
for (int i = 0; i < 26; i++) {
a[i] = cou[i][0];
}
for (int i = 0; i < k; i++) {
a[t[i] - 'a']--;
if (a[t[i] - 'a'] < 0) {
return false;
}
}
return true;
}
int main() {
scanf("%s", &s);
scanf("%s", &t);
int lens = strlen(s);
int lent = strlen(t);
memset(cou, 0, sizeof(cou));
for (int i = 0; i < lens; i++) {
cou[s[i] - 'a'][0]++;
}
for (int i = 0; i < lent; i++) {
cou[t[i] - 'a'][1]++;
}
int len = lent < lens ? lent : lens;
int ret = 0;
bool flag = false;
for (int i = len; i >= 0; i--) {
if (judge(i)) {
if (i == lent) {
if (lens > lent) {
flag = true;
ret = i;
break;
}
} else {
for (int j = 0; j < 26; j++) {
if ((a[j]) && (j + 'a' > t[i])) {
flag = true;
break;
}
}
if (flag) {
ret = i;
break;
}
}
}
}
if (!flag) {
printf("-1\n");
} else {
for (int i = 0; i < ret; i++) {
printf("%c", t[i]);
cou[t[i] - 'a'][0]--;
}
for (int i = 0; i < 26; i++) {
if ((i + 'a' > t[ret]) && (cou[i][0] > 0)) {
printf("%c", i + 'a');
cou[i][0]--;
break;
}
}
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= cou[i][0]; j++) {
printf("%c", i + 'a');
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, ans;
int cnt[26];
bool check(int p) {
if (p >= t.length()) return s.length() > t.length();
for (int i = t[p] - 'a' + 1; i < 26; i++)
if (cnt[i] > 0) return true;
bool flag = false;
if (cnt[t[p] - 'a'] > 0) {
cnt[t[p] - 'a']--;
flag = check(p + 1);
cnt[t[p] - 'a']++;
}
return flag;
}
int main() {
ios::sync_with_stdio(false);
cin >> s >> t;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < s.length(); i++) cnt[s[i] - 'a']++;
if (check(0)) {
ans = "";
for (int i = 0; i < t.length(); i++) {
bool flag = false;
if (cnt[t[i] - 'a'] > 0) {
cnt[t[i] - 'a']--;
if (check(i + 1))
ans += t[i], flag = true;
else
cnt[t[i] - 'a']++;
}
if (!flag) {
for (int j = t[i] - 'a' + 1; j < 26; j++)
if (cnt[j] > 0) {
cnt[j]--;
ans += 'a' + j;
break;
}
break;
}
}
for (int i = 0; i < 26; i++)
if (cnt[i] > 0) {
for (int j = 0; j < cnt[i]; j++) ans += 'a' + i;
cnt[i] = 0;
}
cout << ans << endl;
} else
cout << -1 << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.