text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ss = stringstream;
using ul = unsigned long long;
template <typename T>
inline T LCM(T a, T b) {
return (a * b) / GCD(a, b);
}
template <typename T>
inline T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
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 string toString(T a) {
return to_string(a);
}
template <typename T>
inline void toInt(string s, T &x) {
ss str(s);
str >> x;
}
inline void lower(string &s) {
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it)
*it = tolower(*it);
}
inline void upper(string &s) {
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it)
*it = toupper(*it);
}
const ll inf = 999999999999999999;
const int iinf = 999999999;
bool palin(string s) {
string s1 = s;
reverse(s.begin(), s.end());
return (s == s1);
}
ll triangle(ll n) { return (n * (n + 1)) / 2; }
bool check(ll n) {
if (n == 1) return 0;
if (n == 2 or n == 3) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (ll i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
const ll N = 1000005;
bool mark[N / 2];
vector<ll> prime;
void seive() {
prime.push_back(2);
for (ll i = 3; i * i <= N; i += 2) {
if (!mark[i / 2]) {
for (ll j = i * i; j <= N; j += i * 2) {
mark[j / 2] = 1;
}
}
}
for (ll i = 3; i <= N; i += 2) {
if (!mark[i / 2]) {
prime.push_back(i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string a, b;
cin >> a >> b;
sort((a).begin(), (a).end());
int n = a.length();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string t = a;
swap(t[i], t[j]);
if (stoll(t) > stoll(a) and stoll(t) <= stoll(b)) {
a = t;
}
}
}
cout << a;
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[30], b[30];
int c[18];
int ext(int x, int len) {
--c[b[x] - '0'];
int it = x + 1;
for (int i = 0; i <= 9; ++i) {
for (int j = 0; j < c[i]; ++j)
if (i < b[it] - '0') {
++c[b[x] - '0'];
return 1;
} else if (i > b[it] - '0') {
++c[b[x] - '0'];
return 0;
} else
++it;
}
++c[b[x] - '0'];
return 1;
}
int main() {
scanf("%s%s", a, b);
for (char *ch = a; *ch; ++ch) ++c[*ch - '0'];
if (strlen(a) < strlen(b)) {
for (int i = 9; ~i; --i)
while (c[i]) {
--c[i];
putchar(i + '0');
}
putchar('\n');
return 0;
}
int lenb = strlen(b);
for (int i = 0; i < lenb; ++i) {
if ((!c[b[i] - '0']) || (!ext(i, lenb))) {
int j;
for (j = b[i] - '0' - 1; !c[j]; --j)
;
--c[j];
putchar(j + '0');
for (j = 9; ~j; --j) {
while (c[j]) {
--c[j];
putchar(j + '0');
}
}
putchar('\n');
return 0;
} else {
--c[b[i] - '0'];
putchar(b[i]);
}
}
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
template <typename T>
T getint() {
T val = 0;
char c;
while ((c = getchar()) && !(c >= '0' && c <= '9'))
;
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
if ((int)(a).size() < (int)(b).size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << "\n";
return 0;
}
string marad = a;
string akt;
string ans((int)(a).size(), '0');
for (int i = 0; i < (int)(a).size(); ++i) {
bool van = false;
for (int j = 0; j < (int)(marad).size(); ++j) {
if (b[i] > marad[j]) {
if (marad[j] == '0' && i == 0) continue;
char tmp = marad[j];
string cpy = marad;
cpy.erase(find((cpy).begin(), (cpy).end(), tmp));
sort((cpy).begin(), (cpy).end());
reverse((cpy).begin(), (cpy).end());
string curr = akt + tmp + cpy;
ans = max(ans, curr);
} else if (b[i] == marad[j]) {
van = true;
}
}
if (van) {
marad.erase(find((marad).begin(), (marad).end(), b[i]));
akt.push_back(b[i]);
string cpy = marad;
sort(cpy.begin(), cpy.end());
string curr = akt + cpy;
if (curr <= b) {
ans = max(ans, curr);
}
} else
break;
}
cout << ans << "\n";
return 0;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
unsigned long long int factorials[20];
vector<unsigned long long int> aChars;
unsigned long long int b;
unsigned long long int getPermutation(unsigned long long int permNum) {
vector<unsigned long long int> indexes(aChars.size());
vector<bool> used(20);
for (int i = aChars.size() - 1; i >= 0; i--) {
unsigned long long int index = permNum / factorials[i];
permNum %= factorials[i];
for (int j = 0, k = -1; j < 20; j++) {
if (!used[j]) k++;
if (k == index) {
indexes[i] = j;
used[j] = true;
break;
}
}
}
unsigned long long int result = 0, pow = 1;
for (int i = 0; i < aChars.size(); i++) {
result += aChars[indexes[i]] * pow;
pow *= 10;
}
return result;
}
int main() {
string a;
unsigned long long int b;
cin >> a >> b;
factorials[0] = factorials[1] = 1;
for (unsigned long long int i = 2; i <= 19; i++)
factorials[i] = factorials[i - 1] * i;
aChars.resize(a.length());
for (int i = 0; i < a.length(); i++)
aChars[i] = (unsigned long long int)(a[i] - '0');
sort(aChars.begin(), aChars.end());
unsigned long long int l = 0, r = factorials[a.length()] - 1;
while (r - l > 1) {
unsigned long long int mid = (l + r) / 2;
unsigned long long int num = getPermutation(mid);
if (num <= b)
l = mid;
else
r = mid - 1;
}
unsigned long long int resL = getPermutation(l), resR = getPermutation(r);
if (resR <= b)
cout << resR << endl;
else
cout << resL << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long INF = 2e18 + 7;
string sa, sb;
long long dp[19][1 << 19];
int len;
long long power[20];
inline long long atoi(string &str) {
long long ans = 0;
for (auto it : str) {
ans = ans * 10 + it - '0';
}
return ans;
}
long long fun(int p, int mask) {
if (p < 0) return 0;
if (dp[p][mask] != -1) return dp[p][mask];
long long ans = -INF, mx = -1, eq = -1;
for (int i = 0; i < len; i++) {
if (mask & (1 << i)) continue;
if (sa[i] == sb[p])
eq = i;
else if (sa[i] < sb[p] && (mx == -1 || sa[i] > sa[mx])) {
mx = i;
}
}
if (eq != -1)
ans = max(ans, (sa[eq] - '0') * power[p] + fun(p - 1, mask | (1 << eq)));
string v;
if (mx == -1) goto L1;
for (int i = 0; i < len; i++) {
if (i == mx || mask & (1 << i)) continue;
v.push_back(sa[i]);
}
sort(v.begin(), v.end(), greater<char>());
ans = max(ans, (sa[mx] - '0') * power[p] + atoi(v));
L1:
return dp[p][mask] = ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
power[0] = 1;
for (int i = 1; i < 20; i++) {
power[i] = 10 * power[i - 1];
}
long long a, b;
cin >> a >> b;
sa = to_string(a);
sb = to_string(b);
int la = sa.length();
int lb = sb.length();
if (la < lb) {
sort(sa.begin(), sa.end(), greater<char>());
cout << sa << "\n";
return 0;
}
memset(dp, -1, sizeof dp);
reverse(sb.begin(), sb.end());
len = la;
long long ans = fun(len - 1, 0);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[10];
bool flag = 0;
string a, b, ans;
inline void dfs(int x, string now) {
if (x == a.length()) {
cout << now;
exit(0);
}
for (register int j = 9; j >= 0; --j)
if (s[j] && (now + char(j + '0') <= b))
--s[j], dfs(x + 1, now + char(j + '0')), ++s[j];
}
int main() {
cin >> a >> b;
if (a.length() < b.length()) {
sort(a.begin(), a.end(), greater<int>());
cout << a;
return 0;
}
for (int i = 0; i < a.length(); ++i) ++s[a[i] - '0'];
dfs(0, "");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
t = 1;
while (t--) {
string a, b;
cin >> a >> b;
if (a.size() < b.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << endl;
} else {
string ans;
string::iterator it;
sort(a.begin(), a.end());
for (int i = 0; i < b.size(); i++) {
it = upper_bound(a.begin(), a.end(), b[i]);
if (it == a.begin()) {
while (it == a.begin()) {
auto temp = ans[ans.size() - 1];
ans = ans.substr(0, ans.size() - 1);
a += temp;
sort(a.begin(), a.end());
it = lower_bound(a.begin(), a.end(), temp);
}
ans += *--it;
a.erase(it);
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
ans += a;
break;
}
ans += *(--it);
a.erase(it);
if (b[i] > ans[i]) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
ans += a;
break;
}
}
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s, b, ans = "";
int pos = 0;
bool cho[20];
inline bool check() {
string ok = "";
int len1 = s.length();
for (int i = 0; i < len1; i++)
if (!cho[i]) ok += s[i];
int len2 = ok.length();
for (int i = 0; i < len2; i++) {
if (ok[i] < b[i + pos + 1]) return 0;
if (ok[i] == b[i + pos + 1]) continue;
if (ok[i] > b[i + pos + 1]) return 1;
}
return 0;
}
int main() {
cin >> s >> b;
sort(s.begin(), s.end());
if (b.length() > s.length()) {
reverse(s.begin(), s.end());
cout << s << '\n';
return 0;
}
for (int i = s.length() - 1; ~i; i--) {
if (cho[i]) continue;
if (s[i] < b[pos]) {
ans += s[i];
cho[i] = 1;
pos++;
break;
} else if (s[i] == b[pos]) {
cho[i] = 1;
if (check()) {
cho[i] = 0;
continue;
}
ans += s[i];
i = s.length();
pos++;
continue;
}
}
for (int i = s.length() - 1; ~i; i--)
if (!cho[i]) ans += s[i];
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50020;
int v[MAXN];
string s, b;
int tab[10];
long long target;
void completa(long long *n) {
long long &x = *n;
while (log10(x) + 1 < b.size()) {
x *= 10;
}
}
long long faz_num(string s) {
int tam = s.size();
long long k = 1;
long long num = 0;
for (int i = tam - 1; i >= 0; i--, k *= 10) num += (s[i] - '0') * k;
if (log10(num) + 1 < b.size() && num) completa(&num);
return num;
}
bool f = 0;
void vai(string a, int used) {
if (faz_num(a) > target) return;
if (used == (int)b.size()) {
f = 1;
cout << a << '\n';
return;
}
int i = 9;
if (!f) {
while (i >= 0) {
if (tab[i]) {
tab[i]--;
a += (i + 48);
vai(a, used + 1);
tab[i]++;
a.pop_back();
}
i--;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(tab, 0, sizeof tab);
cin >> b >> s;
target = faz_num(s);
for (size_t i = 0; i < b.size(); i++) {
tab[b[i] - '0']++;
}
f = 0;
string aux;
vai(aux, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[25], f[125];
string a, b;
vector<int> ans;
bool check(int x, int s) {
for (int i = 0; i <= 15; i++) {
f[i] = cnt[i];
}
int j;
for (int i = x; i <= b.length(); i++) {
for (j = 0; j < 10; j++) {
if (f[j]) {
if (s == 1 && j > (b[i - 1] - '0')) continue;
break;
}
}
if (j >= 10) return 0;
f[j]--;
if (s == 1)
if (j < (b[i - 1] - '0')) s = 0;
}
return 1;
}
int main() {
cin >> a >> b;
if (b.length() > a.length()) {
sort(a.begin(), a.end(), greater<char>());
cout << a << endl;
} else {
for (int i = 1; i <= a.length(); i++) cnt[a[i - 1] - '0']++;
int s;
for (int i = s = 1; i <= b.length(); i++) {
int x = 0;
for (x = 9; x >= 0; x--) {
if (cnt[x]) {
if (s == 1 && x > (b[i - 1] - '0')) continue;
cnt[x]--;
int ns = s;
if (ns == 1)
if (x < (b[i - 1] - '0')) ns = 0;
if (check(i + 1, ns)) break;
cnt[x]++;
}
}
cout << x;
if (s == 1)
if (x < b[i - 1] - '0') s = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int main() {
cin >> s1 >> s2;
long long int i, j, k, n;
if (s2.size() > s1.size()) {
sort(s1.begin(), s1.end());
reverse(s1.begin(), s1.end());
cout << s1 << "\n";
return 0;
}
bool flag = false;
if (s1 == s2) {
cout << s1;
return 0;
}
n = s2.size();
for (j = n; j >= 0; j--) {
int hsh[15] = {0};
for (i = 0; i < n; i++) hsh[s1[i] - '0']++;
long long int cnt = 0;
string ans = "";
for (i = 0; i < j; i++) {
if (hsh[s2[i] - '0'] > 0) {
cnt++;
hsh[s2[i] - '0']--;
char x = s2[i];
ans += x;
}
}
if (cnt != j) continue;
if (cnt == n) {
cout << ans << "\n";
return 0;
}
char y = s2[j];
y--;
for (char x = y; x >= '0'; x--) {
if (hsh[x - '0'] > 0) {
ans += x;
hsh[x - '0']--;
break;
}
}
for (char x = '9'; x >= '0'; x--) {
int cnt = hsh[x - '0'];
while (cnt > 0) {
ans += x;
cnt--;
}
}
if (ans <= s2) {
cout << ans;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, pos, l, r;
int a[19];
int so[19];
int solen;
int ptr[19];
int b[19];
int alen, blen;
int f[19] = {0};
char sa[20];
char sb[20];
int answer[19];
void input() {
scanf("%s%s", sa, sb);
int i;
for (i = 0; sa[i]; i++) {
a[i] = sa[i] - '0';
f[i] = 0;
}
alen = i;
for (i = 0; sb[i]; i++) {
b[i] = sb[i] - '0';
}
blen = i;
}
int bsearch(int d) {
int s, e;
int m;
for (s = 0, e = solen - 1; s <= e;) {
m = (s + e) / 2;
if (so[m] == d) return m;
if (so[m] > d) {
e = m - 1;
} else {
s = m + 1;
}
}
return e;
}
bool dfs(int bi, bool tie) {
if (bi == alen) return true;
int k = alen - 1;
if (tie) {
k = bsearch(b[bi]);
if (k >= 0) k = ptr[k];
}
int j;
for (j = k; j >= 0; j--) {
if (f[j] == 0) {
if (tie == true && a[j] != b[bi]) tie = false;
answer[bi] = a[j];
f[j] = 1;
if (dfs(bi + 1, tie) == true) return true;
f[j] = 0;
answer[bi] = -1;
if (tie) {
for (j--; j >= 0; j--) {
if ((a[j] < b[bi]) && !f[j]) {
j++;
tie = false;
break;
}
}
}
}
}
return false;
}
void solution() {
sort(a, a + alen);
so[0] = a[0];
ptr[0] = 0;
solen = 1;
for (int i = 1, j = 0; i < alen; i++) {
if (a[i] != a[i - 1]) {
so[++j] = a[i];
solen++;
}
ptr[j] = i;
}
for (int i = 0; i < alen; i++) {
answer[i] = -1;
}
if (alen == blen) {
bool tie = true;
dfs(0, tie);
} else {
bool tie = false;
dfs(0, tie);
}
}
int main(int argc, char **argv) {
input();
solution();
bool nz = false;
for (int i = 0; i < alen; i++) {
if (answer[i] == -1) break;
if (answer[i] == 0 && !nz) continue;
if (answer[i] > 0 && !nz) nz = true;
cout << answer[i];
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long a, inv, nr1, nr2;
int fr[11];
string b;
vector<int> res;
int main() {
cin >> a >> b;
while (a != 0) {
nr1++;
fr[a % 10]++;
a /= 10;
}
if (b.size() > nr1) {
for (int i = 9; i >= 0; i--)
for (int j = 1; j <= fr[i]; j++) cout << i;
return 0;
}
for (auto it : b) {
int c = it - '0';
if (fr[c] == 0) {
int ok = 0;
for (int i = c - 1; i >= 0 + (res.size() == 0); i--)
if (fr[i] != 0) {
res.push_back(i);
fr[i]--;
ok = 1;
break;
}
if (ok) {
for (auto it : res) cout << it;
for (int i = 9; i >= 0; i--)
for (int j = 1; j <= fr[i]; j++) cout << i;
return 0;
} else {
while (true) {
for (int i = res.back() - 1; i >= 0; i--) {
if (fr[i] != 0) {
fr[res.back()]++;
res.back() = i;
fr[i]--;
ok = 1;
break;
}
}
if (ok) break;
fr[res.back()]++;
res.pop_back();
}
for (auto it : res) cout << it;
for (int i = 9; i >= 0; i--)
for (int j = 1; j <= fr[i]; j++) cout << i;
return 0;
}
} else {
res.push_back(c);
fr[c]--;
}
inv /= 10;
}
for (auto it : res) cout << it;
for (int i = 9; i >= 0; i--)
for (int j = 1; j <= fr[i]; j++) cout << i;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Compare(string s, string t) {
if (s == t) return 0;
if (s.length() > t.length()) return 1;
if (s.length() < t.length()) return -1;
return s > t ? 1 : -1;
}
string remC(string s, int pos1, int pos2) {
string ret = "";
bool flag = false;
for (int i = 0; i < pos1; i++) {
ret += s[i];
}
ret += s[pos2];
for (int i = pos1; i < s.length(); i++) {
if (i != pos2) ret += s[i];
}
return ret;
}
int main() {
string s, t, tmp, ans;
cin >> s >> t;
sort(s.begin(), s.end());
ans = s;
for (int i = 0; i < s.length(); i++) {
for (int j = s.length() - 1; j > i; j--) {
tmp = ans;
tmp = remC(tmp, i, j);
if (Compare(tmp, t) <= 0 && tmp[0] != '0') {
ans = max(ans, tmp);
break;
}
}
s = ans;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long siz = 1e5 + 10;
const long long base = 32;
const long long MAXX = 1e18;
long long res[20][2][2][(1 << 18)];
long long n, m;
vector<long long> x, y;
long long Po[siz];
long long dp(long long pos, bool sta, bool lar, long long mask) {
if (pos >= n) {
return (mask == ((1 << n) - 1)) ? 0 : -MAXX;
}
long long &ans = res[pos][sta][lar][mask];
if (ans != -1) {
return ans;
}
ans = -MAXX;
for (long long i = 0; i < n; i++) {
if (lar) {
if ((mask & (1 << i)) != 0) {
continue;
}
if (!sta && (x[i] == 0)) {
continue;
}
ans =
max(ans, x[i] * Po[n - pos - 1] + dp(pos + 1, 1, 1, mask | (1 << i)));
} else {
if (((mask & (1 << i)) != 0) || (x[i] > y[pos])) {
continue;
}
if (!sta && (x[i] == 0)) {
continue;
}
ans = max(ans, x[i] * Po[n - pos - 1] +
dp(pos + 1, 1, (x[i] < y[pos]), mask | (1 << i)));
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
while (n) {
x.push_back(n % 10);
n /= 10;
}
while (m) {
y.push_back(m % 10);
m /= 10;
}
Po[0] = 1;
for (long long i = 1; i <= 18; i++) {
Po[i] = Po[i - 1] * 10;
}
reverse(x.begin(), x.end());
reverse(y.begin(), y.end());
n = (int)x.size();
m = (int)y.size();
if (n < m) {
sort(x.begin(), x.end());
for (long long i = n - 1; i >= 0; i--) {
cout << x[i];
}
cout << '\n';
return 0;
}
memset(res, -1, sizeof(res));
cout << dp(0, 0, 0, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool used[20];
string get_num(string a, string b, int minimize) {
for (int i = 0; i < 20; i++) used[i] = false;
string num = "";
bool to_max = false;
if (b.length() > a.length()) to_max = true;
for (int i = 0; i < (int)b.length(); i++) {
char max = '0';
int idx = -1;
for (int j = 0; j < (int)a.length(); j++) {
if (i == minimize) {
if (!used[j] && a[j] >= max && a[j] < b[i]) {
idx = j;
max = a[j];
}
} else if ((to_max && !used[j] && a[j] >= max) ||
(!used[j] && a[j] >= max && a[j] <= b[i])) {
idx = j;
max = a[j];
}
}
if (idx == -1) {
for (int j = 0; j < (int)a.length(); j++) {
if (!used[j]) {
idx = j;
max = a[j];
}
}
}
used[idx] = true;
if (!to_max && max < b[i]) to_max = true;
num += max;
if (num.length() == a.length()) break;
}
return num;
}
int main(void) {
string a, b;
cin >> a >> b;
string ans = "";
for (int i = 0; i <= (int)b.length(); i++) {
string tmp = get_num(a, b, i);
if ((tmp.length() < b.length() || tmp <= b) && (ans == "" || tmp > ans))
ans = tmp;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[10], b[10];
string mas(vector<int>& bs) {
string s = "";
int i, j;
for (i = 9; i >= 0; i--) {
if (bs[i]) {
s += (char)(i + 48);
bs[i]--;
i++;
}
}
return s;
}
string mis(vector<int>& bs) {
string s = "";
int i, j;
for (i = 0; i <= 9; i++) {
if (bs[i]) {
s += (char)(i + 48);
bs[i]--;
i--;
}
}
return s;
}
string sol(string astr, string bstr) {
int i, j, f = 0;
string ans = "";
if (astr.length() < bstr.length()) {
vector<int> aa(a, a + 10);
return mas(aa);
} else {
if (a[bstr[0] - 48]) {
string s2 = "";
s2 += bstr[0];
vector<int> aa(a, a + 10);
aa[bstr[0] - 48]--;
s2 += mis(aa);
if (s2 <= bstr) f = 1;
}
if (f == 0) {
for (i = bstr[0] - 48 - 1; i >= 0; i--) {
if (a[i]) {
ans += (char)(i + 48);
a[i]--;
b[i]--;
break;
}
}
vector<int> aa(a, a + 10);
return ans + mas(aa);
} else {
ans += bstr[0];
a[bstr[0] - 48]--;
b[bstr[0] - 48]--;
return ans + sol(astr.substr(1, astr.length() - 1),
bstr.substr(1, bstr.length() - 1));
}
}
}
int main() {
string as, bs;
cin >> as;
cin >> bs;
int i;
for (i = 0; i < as.length(); i++) a[as[i] - 48]++;
for (i = 0; i < bs.length(); i++) b[bs[i] - 48]++;
cout << sol(as, bs);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 0, y = 0;
string s1, s2;
cin >> s1 >> s2;
x = s1.length();
y = s2.length();
sort(s1.begin(), s1.end());
if (x < y) {
reverse(s1.begin(), s1.end());
cout << s1 << endl;
return 0;
}
string temp;
for (int i = 0; i < x; i++)
for (int j = x - 1; j > i; j--) {
temp = s1;
swap(s1[i], s1[j]);
sort(s1.begin() + i + 1, s1.end());
if (s1.compare(s2) > 0) {
s1 = temp;
} else {
break;
}
}
cout << s1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmax(T& a1, T a2) {
a1 = std::max(a1, a2);
}
template <typename T>
void chmin(T& a1, T a2) {
a1 = std::min(a1, a2);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = 0; i < v.size(); i++) os << (i == 0 ? "" : ", ") << v[i];
os << "]";
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, map<T1, T2>& mp) {
os << "{";
for (auto it = mp.begin(); it != mp.end(); it++) {
os << "(" << it->first << ": " << it->second << ")";
it++;
if (it != mp.end()) os << ", ";
it--;
}
os << "}";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, set<T>& st) {
os << "{";
for (auto it = st.begin(); it != st.end(); it++) {
os << *it;
++it;
if (it != st.end()) os << ", ";
it--;
}
os << "}";
return os;
}
using int64 = long long;
using Graph = std::vector<std::vector<int>>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string A, B;
cin >> A >> B;
if (A.size() < B.size()) {
sort(A.begin(), A.end(), greater<char>());
cout << A << endl;
return 0;
}
vector<int> cnt(10, 0);
for (char ch : A) cnt[ch - '0']++;
string ans = "";
for (long long i = 0; (i) < (long long)(A.size() + 1); (i)++) {
vector<int> cnt_copy = cnt;
bool flag = true;
for (long long j = 0; (j) < (long long)(i); (j)++) {
int d = B[j] - '0';
if (cnt_copy[d] <= 0) flag = false;
cnt_copy[d]--;
}
if (not flag) continue;
if (i == A.size()) {
ans = B;
continue;
}
int digit = -1;
for (long long d = 0; (d) < (long long)(B[i] - '0'); (d)++) {
if (cnt_copy[d] > 0) digit = d;
}
if (digit < 0) continue;
string res = B.substr(0, i);
res.push_back(digit + '0');
cnt_copy[digit]--;
for (long long j = (long long)(i + 1); (j) < (long long)(A.size()); (j)++) {
for (int d = 9; d >= 0; d--) {
if (cnt_copy[d] > 0) {
res.push_back(d + '0');
cnt_copy[d]--;
break;
}
}
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long GH = b;
vector<int> varb, varia;
int compt1 = 0;
int compt2 = 0;
while (a) {
compt1++;
varia.push_back(a % 10);
a /= 10LL;
}
while (b) {
compt2++;
varb.push_back(b % 10);
b /= 10LL;
}
if (compt1 < compt2) {
sort(varia.begin(), varia.end());
reverse(varia.begin(), varia.end());
for (int i = 0; i < varia.size(); i++) printf("%d", varia[i]);
return 0;
}
reverse(varb.begin(), varb.end());
reverse(varia.begin(), varia.end());
vector<long long> e;
for (int k = 0; k < varb.size(); k++)
for (int j = 0; j < varia.size(); j++)
if (varb[k] >= varia[j]) {
multiset<int> s;
for (int i = 0; i < varia.size(); i++)
if (i != j) s.insert(varia[i]);
bool f = 1;
vector<int> tempor;
for (int i = 0; i < k; i++) {
if (s.size() == 0) {
f = 0;
break;
}
auto it = prev(s.end());
while (it != s.begin() && *it > varb[i]) it--;
if (*it > varb[i]) {
f = 0;
break;
}
tempor.push_back(*it);
s.erase(it);
}
if (f) {
long long r = 0;
vector<int> p;
for (int i = 0; i < tempor.size(); i++) p.push_back(tempor[i]);
p.push_back(varia[j]);
if (s.size()) {
for (auto it = prev(s.end()); it != s.begin(); it--)
p.push_back(*it);
p.push_back(*s.begin());
}
for (int i = 0; i < p.size(); i++) r = r * 10LL + p[i];
e.push_back(r);
}
}
sort(e.begin(), e.end());
reverse(e.begin(), e.end());
for (long long ans : e)
if (ans <= GH) {
printf("%I64d", ans);
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long t1, t2, n, m, tb[30], a[30], b[30], s[30];
bool v[20][530000][2], g[30];
void f(long long p, long long q, long long w, long long num) {
long long i, tw;
if (p == n) {
cout << num;
exit(0);
}
if (v[p][q][w]) return;
v[p][q][w] = 1;
for (i = 0; i < n; i++) {
if (p == 0 && a[i] == 0) continue;
if (g[i]) continue;
if (w == 0 && a[i] > b[p]) continue;
g[i] = 1;
if (w == 0 && a[i] == b[p])
tw = 0;
else
tw = 1;
f(p + 1, q + s[i], tw, num * 10 + a[i]);
g[i] = 0;
}
}
int main() {
long long i, j;
cin >> t1 >> t2;
while (t1 > 0) {
a[n++] = t1 % 10;
t1 /= 10;
}
while (t2 > 0) {
tb[m++] = t2 % 10;
t2 /= 10;
}
for (i = 0; i < m; i++) {
b[i] = tb[m - i - 1];
}
sort(a, a + n, greater<int>());
s[0] = 1;
for (i = 1; i <= 20; i++) s[i] = s[i - 1] * 2;
if (n < m)
f(0, 0, 1, 0);
else
f(0, 0, 0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll MAXN = 1e9 + 1;
bool trynum(int i, int num, string as, ll b) {
as[i] = (char)num + '0';
ll a = stoll(as);
if (a <= b) {
return true;
}
return false;
}
void solveC() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll a, b;
cin >> a >> b;
if (a == b) {
cout << a;
return;
}
string as = to_string(a);
string bs = to_string(b);
map<int, int> anum;
for (int i = 0; i < as.size(); i++) {
anum[as[i] - '0']++;
}
string ans;
ans.resize(as.size(), '0');
if (as.size() == bs.size()) {
for (int i = 0; i < as.size(); i++) {
for (int i1 = 9; i1 >= 0; i1--) {
if (anum[i1] != 0 && trynum(i, i1, ans, b)) {
ans[i] = (char)i1 + '0';
anum[i1]--;
break;
}
if (i1 == 0) {
bool flag = true;
while (flag) {
--i;
int last_num = ans[i] - '0';
anum[last_num]++;
ans[i] = '0';
if (last_num == 0) {
continue;
}
for (int i1 = last_num - 1; i1 >= 0; i1--) {
if (anum[i1] != 0 && trynum(i, i1, ans, b)) {
ans[i] = (char)i1 + '0';
anum[i1]--;
flag = false;
break;
}
}
}
}
}
}
} else {
for (int i = 0; i < as.size(); i++) {
for (int i1 = 9; i1 >= 0; i1--) {
if (anum[i1] != 0) {
ans[i] = (char)i1 + '0';
anum[i1]--;
break;
}
}
}
}
cout << ans;
}
int main() {
solveC();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20], c[20];
int main() {
int m;
while (cin >> a >> b) {
m = strlen(a);
sort(a, a + m);
if (m < strlen(b)) {
for (int i = m - 1; i >= 0; i--) cout << a[i];
return 0;
}
strcpy(c, a);
for (int i = 0; i < m; i++) {
strcpy(a, c);
for (int j = i; j < m; j++) {
swap(a[i], a[j]);
if (strcmp(a, b) != 1) strcpy(c, a);
}
}
puts(a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25];
int a[25];
long long b;
bool vis[25];
bool check1(long long sum, int len) {
for (int i = len - 1; i >= 0; i--) {
if (vis[i]) continue;
sum = sum * 10LL + a[i];
}
if (sum > b)
return true;
else
return false;
}
long long dfs(int dis, long long sum, int len) {
if (check1(sum, len)) return 0LL;
if (dis > len) return sum;
long long Max = 0LL;
for (int i = 0; i < len; i++) {
if (!vis[i]) {
vis[i] = true;
Max = max(Max, dfs(dis + 1, sum * 10LL + a[i], len));
vis[i] = false;
if (Max != 0) return Max;
}
}
return 0;
}
void print(long long ans, int len) {
long long tmp = ans;
int cnt;
while (tmp != 0) {
cnt++;
tmp /= 10;
}
for (int i = 1; i <= len - cnt; i++) printf("0");
printf("%I64d\n", ans);
}
int main() {
while (~scanf("%s %I64d", s, &b)) {
int len = strlen(s);
for (int i = 0; i < len; i++) a[i] = s[i] - '0';
sort(a, a + len);
reverse(a, a + len);
long long ans = dfs(1, 0LL, len);
print(ans, len);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, digit_a;
long long freq[15];
long long po[20];
void solve(long long digitRem, long long genNum) {
if (digitRem < 0) {
cout << genNum << endl;
exit(0);
}
for (int dig = 9; dig >= 0; dig--) {
if (freq[dig] > 0 && (genNum + dig * po[digitRem]) <= b) {
freq[dig]--;
solve(digitRem - 1, genNum + dig * po[digitRem]);
freq[dig]++;
}
}
}
void pre() {
po[0] = 1;
for (int i = 1; i < 20; i++) po[i] = po[i - 1] * 10;
memset(freq, 0, sizeof freq);
}
int main() {
pre();
cin >> a >> b;
while (a > 0) {
int m = a % 10;
freq[m]++;
a /= 10;
digit_a++;
}
solve(digit_a - 1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
vector<long long> f;
vector<long long> s;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long a, b;
cin >> a >> b;
while (a > 0) {
long long rem = a % 10;
a /= 10;
f.push_back(rem);
}
while (b > 0) {
long long rem = b % 10;
b /= 10;
s.push_back(rem);
}
reverse(f.begin(), f.end());
reverse(s.begin(), s.end());
long long dp[10];
memset(dp, 0, sizeof(dp));
for (auto x : f) {
dp[x]++;
}
if (f.size() < s.size()) {
sort(f.begin(), f.end(), greater<long long>());
for (auto x : f) {
cout << x;
}
cout << endl;
return 0;
}
bool done = 0;
for (long long i = 0; i < s.size(); ++i) {
long long x = s[i];
for (long long num = x; num >= 0; --num) {
if (dp[num] > 0) {
if (num == x) {
dp[num]--;
vector<long long> rem;
for (long long j = 0; j < 10; ++j) {
long long tmp = dp[j];
while (tmp--) {
rem.push_back(j);
}
}
sort(rem.begin(), rem.end());
bool val = 1;
for (long long j = i + 1; j < s.size(); ++j) {
if (rem[j - (i + 1)] > s[j]) val = 0;
if (rem[j - (i + 1)] < s[j]) break;
}
if (!val) {
dp[num]++;
continue;
}
dp[num]++;
}
cout << num;
if (num < x) done = 1;
dp[num]--;
break;
}
}
if (done) break;
}
vector<long long> rem;
for (long long i = 0; i < 10; ++i) {
while (dp[i] > 0) {
rem.push_back(i);
dp[i]--;
}
}
sort(rem.begin(), rem.end(), greater<long long>());
for (auto x : rem) {
cout << x;
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, la, lb, lans;
long long xb[300], ans[300];
multiset<long long> xa;
bool dfs(long long d, bool lim) {
if (d > lb) {
return 1;
}
if (!lim) {
long long t = *xa.rbegin();
xa.erase(xa.find(t));
ans[d] = t;
if (dfs(d + 1, 0)) {
return 1;
} else {
xa.insert(t);
return 0;
}
} else {
if (xa.upper_bound(xb[d]) == xa.begin()) return 0;
long long t = *(--xa.upper_bound(xb[d]));
ans[d] = t;
xa.erase(xa.find(t));
if (dfs(d + 1, t >= xb[d]))
return 1;
else {
xa.insert(t);
if (xa.lower_bound(xb[d]) == xa.begin()) return 0;
t = *(--xa.lower_bound(xb[d]));
ans[d] = t;
xa.erase(xa.find(t));
if (dfs(d + 1, 0)) {
return 1;
} else {
xa.insert(t);
return 0;
}
}
}
}
int main() {
long long i, t;
bool fl = 0;
scanf("%lld%lld", &a, &b);
for (la = 0; a; a /= 10) ++la, xa.insert(a % 10);
for (lb = 0; b; b /= 10) xb[++lb] = b % 10;
reverse(xb + 1, xb + lb + 1);
if (la < lb) {
while (!xa.empty()) {
t = *xa.rbegin();
xa.erase(xa.find(t));
printf("%lld", t);
}
} else {
dfs(1, 1);
for (i = 1; i <= lb; i++) printf("%lld", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int logy(long long int x, long long int y) {
return ceil((long double)(log(x) / log(y)));
}
long long int powe(long long int a, long long int b) {
long long int re = 1;
while (b) {
if (b & 1) re = (re * a);
a = (a * a);
b = b >> 1;
}
return re;
}
bool flag = 0, flag1 = 0, flag2 = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int tt = 1;
while (tt--) {
long long int a[10] = {0};
long long int n, m, last = -1;
cin >> n >> m;
long long int tn = n, tm = m, l1 = 0, l2 = 0;
while (tn) a[tn % 10]++, tn /= 10, l1++;
while (tm) tm /= 10, l2++;
vector<long long> ans;
if (l1 < l2) {
for (long long int i = 10 - 1; i >= 0; i--)
for (long long int j = 0; j < a[i]; j++) cout << i;
return 0;
}
for (long long int i = l2 - 1; i >= 0; i--) {
long long int md = powe(10, i);
long long int x = m / md;
x %= 10;
if (!a[x]) {
for (long long int j = x - 1; j >= 0; j--)
if (a[j]) {
ans.push_back(j);
flag = 1;
a[j]--;
break;
}
if (flag == 0) {
for (long long int j = ans.size() - 1; j >= 0; j--) {
for (long long int k = ans[j] - 1; k >= 0; k--) {
if (a[k]) {
a[ans[j]]++;
a[k]--;
ans[j] = k;
vector<long long> fans;
for (long long int l = 0; l < j + 1; l++)
fans.push_back(ans[l]);
ans.clear();
for (long long int l = 0; l < fans.size(); l++)
ans.push_back(fans[l]);
for (long long int i = 10 - 1; i >= 0; i--)
for (long long int j = 0; j < a[i]; j++) ans.push_back(i);
flag = 1;
break;
}
}
if (flag) break;
a[ans[j]]++;
}
break;
} else {
for (long long int i = 10 - 1; i >= 0; i--)
for (long long int j = 0; j < a[i]; j++) ans.push_back(i);
break;
}
}
a[x]--;
ans.push_back(x);
}
for (long long int i = 0; i < ans.size(); i++) cout << ans[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a;
long long b;
int main() {
cin >> a >> b;
sort(a.begin(), a.end());
for (int i = 0; i < a.size(); i++)
for (int j = i + 1; j < a.size(); j++) {
string str = a;
swap(str[i], str[j]);
if (stoll(str) > stoll(a) && stoll(str) <= b) swap(a[i], a[j]);
}
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(long long int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (long long int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (long long int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
vector<long long int> merge(vector<long long int> v1,
vector<long long int> v2) {
vector<long long int> temp;
long long int i = 0, j = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[j])
temp.push_back(v1[i]), i++;
else
temp.push_back(v2[j]), j++;
}
while (i < v1.size()) temp.push_back(v1[i]), i++;
while (j < v2.size()) temp.push_back(v2[j]), j++;
return temp;
}
long long int fun(string a) {
long long int c = 0;
for (auto e : a) {
c = c * 10 + (e - '0');
}
return c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int a, b;
cin >> a >> b;
string s = to_string(a);
string t = to_string(b);
if (s.size() < t.size()) {
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
for (long long int i = 0; i < s.size(); i++) {
sort(s.begin() + i, s.end());
reverse(s.begin() + i, s.end());
sort(s.begin() + i + 1, s.end());
while (fun(s) > b) {
prev_permutation(s.begin() + i, s.end());
sort(s.begin() + i + 1, s.end());
}
}
cout << s << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[10];
string a, b;
vector<int> cur;
void pr() {
for (int i = 0; i < cur.size(); i++) cout << cur[i];
cout << endl;
exit(0);
}
void form() {
for (int i = 9; i >= 0; i--) {
for (int j = 1; j <= cnt[i]; j++) cur.push_back(i);
}
}
void dg(int x) {
if (x == a.size()) {
pr();
return;
}
int xx = b[x] - '0';
if (cnt[xx]) {
cur.push_back(xx);
cnt[xx]--;
dg(x + 1);
cnt[xx]++;
cur.pop_back();
}
for (int i = xx - 1; i >= 0; i--) {
if (cnt[i]) {
cur.push_back(i);
cnt[i]--;
form();
pr();
return;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b;
if (a.size() != b.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << endl;
return 0;
}
for (int i = 0; i < b.size(); i++) cnt[a[i] - '0']++;
dg(0);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
long long a, b;
int countA[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int B[100];
int lenB = 0;
int lenA = 0;
long long ans = 0;
bool valid = false;
scanf("%I64d%I64d", &a, &b);
while (true) {
if (a < 10) {
countA[a] += 1;
break;
} else {
countA[a % 10] += 1;
a /= 10;
lenA += 1;
}
}
while (true) {
if (b < 10) {
B[lenB] = b;
break;
} else {
B[lenB] = b % 10;
b /= 10;
lenB += 1;
}
}
if (lenB > lenA) valid = true;
for (int i = lenB; i >= 0; i--) {
if (valid) break;
if (countA[B[i]] > 0) {
countA[B[i]]--;
ans = ans * 10 + B[i];
} else {
int k = i;
while (!valid) {
for (int j = B[k] - 1; j >= 0; j--) {
if (countA[j] > 0) {
countA[j]--;
ans = ans * 10 + j;
valid = true;
break;
}
}
if (!valid) {
k++;
countA[ans % 10] += 1;
ans /= 10;
}
}
}
}
for (int i = 9; i >= 0; i--) {
while (countA[i] > 0) {
ans = ans * 10 + i;
countA[i]--;
}
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20], c[20];
int main() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
while (~scanf("%s%s", a, b)) {
int aa, bb;
aa = strlen(a);
bb = strlen(b);
sort(a, a + aa);
if (aa < bb) {
for (int i = aa - 1; i >= 0; i--) {
printf("%c", a[i]);
}
printf("\n");
continue;
}
strcpy(c, a);
for (int i = 0; i < aa; i++) {
strcpy(a, c);
for (int j = i; j < aa; j++) {
swap(a[i], a[j]);
if (strcmp(a, b) != 1) {
strcpy(c, a);
}
}
}
puts(a);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> x[2];
int main() {
long long a, b;
cin >> a >> b;
while (a) {
x[0].push_back(a % 10);
a /= 10;
}
while (b) {
x[1].push_back(b % 10);
b /= 10;
}
reverse(x[1].begin(), x[1].end());
sort(x[0].begin(), x[0].end(), greater<int>());
if (x[1].size() > x[0].size()) {
for (int i = 0; i < x[0].size(); i++) printf("%d", x[0][i]);
return 0;
}
for (int i = 0; i < x[0].size(); i++) {
int is = 1;
int dex = i;
if (x[0][i] > x[1][i]) dex = -1;
for (int j = i + 1; j < x[0].size(); j++) {
if (x[0][j] <= x[1][i]) {
if (dex == -1 || x[0][dex] < x[0][j]) dex = j;
}
}
if (dex != -1) swap(x[0][i], x[0][dex]);
if (x[0][i] > x[1][i]) is = 0;
if (is == 0) {
for (int j = i - 1; j >= 0; j--) {
int cur = -1;
for (int k = j + 1; k < x[0].size(); k++) {
if (x[0][k] < x[0][j]) {
if (cur == -1 || x[0][k] > x[0][cur]) cur = k;
}
}
if (cur != -1) {
swap(x[0][cur], x[0][j]);
sort(x[0].begin() + j + 1, x[0].end(), greater<int>());
i = x[0].size() - 1;
break;
}
}
}
if (x[0][i] < x[1][i] && i + 1 != x[0].size()) {
sort(x[0].begin() + i + 1, x[0].end(), greater<int>());
break;
}
}
for (int i = 0; i < x[0].size(); i++) printf("%d", x[0][i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int dp[N][1 << N][2];
string a, b;
string ans;
int solve(int idx = 0, int mask = 0, int flag = 0) {
if (idx == int(a.size())) return 1;
int &ret = dp[idx][mask][flag];
if (~ret) return ret;
ret = 0;
for (int i = int(int(a.size()) - 1); i >= 0; i--) {
if (mask & (1 << i)) continue;
if (flag) {
if (solve(idx + 1, mask | (1 << i), 1)) {
ans += a[i];
return ret = 1;
}
} else {
if (a[i] <= b[idx]) {
if (solve(idx + 1, mask | (1 << i), a[i] < b[idx])) {
ans += a[i];
return ret = 1;
}
}
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof dp);
cin >> a >> b;
if (int(b.size()) > int(a.size())) {
sort(a.rbegin(), a.rend());
cout << a << endl;
return 0;
}
sort(a.begin(), a.end());
solve(0, 0);
reverse(ans.begin(), ans.end());
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int phi(int n) {
int result = n;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n = n / i;
result -= result / i;
}
if (n > 1) result -= result / n;
return result;
}
long long int mod_pow(long long int base, long long int e) {
long long int ans = 1;
while (e) {
if (e & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
e >>= 1;
}
return ans;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
string a, b, ans;
void solve(int arr[], int j) {
if (ans.length() == a.length()) {
return;
}
bool pre = false;
if (arr[b[j] - '0'] > 0) {
arr[b[j] - '0']--;
ans += b[j];
solve(arr, j + 1);
if (ans.length() == a.length()) {
return;
}
arr[b[j] - '0']++;
ans = ans.substr(0, ans.length() - 1);
}
for (int i = b[j] - '0' - 1; i >= 0; i--) {
if (arr[i] > 0) {
arr[i]--;
pre = true;
ans += char(i + '0');
break;
}
}
if (pre) {
for (int i = 9; i >= 0; i--) {
while (arr[i]) {
ans += char(i + '0');
arr[i]--;
}
}
}
return;
}
int main() {
cin >> a >> b;
if (b.length() > a.length()) {
sort(a.begin(), a.end());
for (int i = a.length() - 1; i >= 0; i--) cout << a[i];
return 0;
}
int arr[10] = {0};
for (int i = 0; i < a.length(); i++) arr[a[i] - '0']++;
solve(arr, 0);
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long freq[10];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
vector<long long> va, vb;
while (a) va.push_back(a % 10), freq[a % 10]++, a /= 10;
while (b) vb.push_back(b % 10), b /= 10;
reverse(va.begin(), va.end());
reverse(vb.begin(), vb.end());
if (vb.size() != va.size()) {
sort(va.begin(), va.end(), greater<long long>());
for (auto it : va) cout << it;
return 0;
}
long long i, j, n = vb.size();
i = 0;
vector<long long> ans;
while (i < n) {
long long x = vb[i];
for (; x >= 0; --x)
if (freq[x]) break;
while (x < 0) {
ans.pop_back();
--i;
x = vb[i] - 1;
freq[x + 1]++;
for (; x >= 0; --x)
if (freq[x]) break;
}
freq[x]--;
ans.push_back(x);
++i;
if (x != vb[i - 1]) {
j = 0;
while (j <= 9) {
while (freq[j]) ans.push_back(j), freq[j]--;
++j;
}
sort(ans.begin() + i, ans.end(), greater<long long>());
break;
}
}
for (auto it : ans) cout << it;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int f[10], nf;
int g[20], ans[20], ng;
int k;
bool gt;
void dfs(int ind, bool pd) {
if (ind == 0) {
gt = true;
return;
}
if (pd && f[g[ind]] > 0) {
ans[ind] = g[ind];
f[g[ind]]--;
dfs(ind - 1, pd);
if (gt) return;
f[g[ind]]++;
}
if (pd) {
for (k = g[ind] - 1; k >= 0; k--)
if (f[k]) {
ans[ind] = k;
f[k]--;
dfs(ind - 1, false);
if (gt) return;
f[k]++;
}
}
if (!pd)
for (k = 9; k >= 0; k--)
if (f[k]) {
ans[ind] = k;
f[k]--;
dfs(ind - 1, pd);
if (gt) return;
f[k]++;
}
return;
}
int main() {
scanf("%I64d%I64d", &a, &b);
nf = 0;
ng = 0;
gt = false;
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
while (b) {
g[++ng] = b % 10;
b /= 10;
}
while (a) {
f[a % 10]++;
a /= 10;
nf++;
}
if (nf < ng) {
for (int i = 9; i >= 0; i--)
for (int j = 1; j <= f[i]; j++) printf("%d", i);
puts("");
} else {
dfs(ng, 1);
for (int i = ng; i >= 1; i--) printf("%d", ans[i]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int limB = 25;
int N;
char A[limB], B[limB];
int main() {
int M;
cin >> A >> B;
N = strlen(A), M = strlen(B);
if (M > N) {
for (int i = 0; i < N; i++) B[i] = '9';
}
for (int i = 0; i < N; i++) {
sort(A + i, A + N);
int ip = i;
for (int j = i; j < N; j++) {
if (A[j] > B[i]) break;
bool fca = true;
for (int k = i, w = i + 1; k < N; k++) {
if (k == j) {
continue;
}
if (A[k] < B[w]) break;
if (A[k] > B[w]) fca = false;
w++;
}
fca |= (A[j] < B[i]);
if (fca) ip = j;
}
swap(A[i], A[ip]);
if (A[i] < B[i]) {
sort(A + i + 1, A + N);
reverse(A + i + 1, A + N);
break;
}
}
printf("%s\n", A);
}
|
#include <bits/stdc++.h>
using namespace std;
int numdig[256];
int used[256];
int main() {
int i, j;
string a, b, c;
char next, mindigit;
cin >> a >> b;
for (i = 0; i < a.length(); i++) {
numdig[a[i]]++;
}
i = 0;
c = "";
if (a.length() == b.length()) {
while ((i < a.length()) && (numdig[b[i]] > used[b[i]])) used[b[i++]]++;
if (i < a.length()) {
mindigit = '0';
while (numdig[mindigit] == used[mindigit]) mindigit++;
while (b[i] <= mindigit) {
used[b[--i]]--;
mindigit = min(mindigit, b[i]);
}
b[i]--;
while (numdig[b[i]] == used[b[i]]) b[i]--;
used[b[i++]]++;
}
for (j = 0; j < i; j++) c += b[j];
}
next = '9';
while (next >= '0') {
while (numdig[next] > used[next]) {
c += next;
used[next]++;
}
next--;
}
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[20], t[20], vis[20];
int main() {
long long a, b;
cin >> a >> b;
int cnta = 0, cntb = 0;
while (a > 0) {
t[++cnta] = a % 10;
a /= 10;
}
while (b > 0) {
s[++cntb] = b % 10;
b /= 10;
}
sort(t + 1, t + 1 + cnta);
if (cnta < cntb) {
for (int i = cnta; i >= 1; i--) cout << t[i];
cout << endl;
return 0;
}
stack<int> ans;
bool f = 0;
for (int i = cntb; i >= 1 && f == 0; i--) {
int j;
for (j = cnta; j >= 1; j--) {
if (vis[j]) continue;
if (t[j] < s[i]) {
vis[j] = 1;
ans.push(j);
f = 1;
break;
} else if (t[j] == s[i]) {
vis[j] = 1;
ans.push(j);
break;
}
}
if (j == 0) {
int cnt = 0;
while (!cnt) {
vis[ans.top()] = 0;
ans.pop();
i++;
for (int j = cnta; j >= 1; j--) {
if (t[j] < s[i] && !vis[j]) {
ans.push(j);
cnt = 1;
vis[j] = 1;
break;
}
}
}
stack<int> q;
while (!ans.empty()) {
q.push(ans.top());
ans.pop();
}
while (!q.empty()) {
int z = q.top();
cout << t[z];
q.pop();
}
for (int i = cnta; i >= 1; i--) {
if (!vis[i]) cout << t[i];
}
cout << endl;
return 0;
}
}
stack<int> q;
while (!ans.empty()) {
q.push(ans.top());
ans.pop();
}
while (!q.empty()) {
cout << t[q.top()];
q.pop();
}
for (int i = cnta; i >= 1; i--) {
if (!vis[i]) cout << t[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[10], A[20];
long long ans = 0;
int check(int k) {
long long x = 0;
for (int i = 0; i <= 9; i++)
for (int j = 1; j <= c[i]; j++) x = x * 10 + i;
long long y = 0;
for (int i = k; i >= 1; i--) y = y * 10 + A[i];
if (x <= y) return 1;
return 0;
}
void DFS(int x, long long now, int f) {
if (x < 1) {
ans = now;
return;
}
for (int j = 9; j >= 0; j--) {
if (c[j] && (j <= A[x] || f)) {
c[j]--;
f = (j < A[x]) | f;
if (check(x - 1) || f) DFS(x - 1, now * 10 + j, f);
if (ans) return;
c[j]++;
}
}
}
int main() {
long long a, b;
cin >> a >> b;
int wa = 0, wb = 0;
while (a) {
c[a % 10]++;
a /= 10;
wa++;
}
int top = 0;
while (b) {
A[++top] = b % 10;
b /= 10;
wb++;
}
if (wa < wb) {
for (int i = 9; i >= 0; i--)
for (int j = 1; j <= c[i]; j++) printf("%d", i);
puts("");
return 0;
}
DFS(top, 0, 0);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
string ans;
int al, bl;
bool used[22];
bool changed;
int chloc;
void backtrack(int i) {
int prev = -1;
if (i == al) {
cout << ans;
exit(0);
}
for (int j = 0; j < al; j++) {
if (used[j] || (!changed && a[j] > b[i]) || prev == a[j]) continue;
used[j] = true;
prev = a[j];
if (!changed && a[j] < b[i]) changed = true, chloc = i;
ans.push_back(a[j]);
backtrack(i + 1);
ans.pop_back();
used[j] = false;
if (chloc == i) changed = false, chloc = 0;
}
}
int main() {
cin >> a;
cin >> b;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
al = a.size(), bl = b.size();
if (al < bl) {
cout << a;
return 0;
}
backtrack(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
const long long MOD = 1e9 + 7;
long long arr[N], i, j, n, m, k;
unordered_map<char, int> mp;
string a = "", b = "";
void file_o() {}
void executionTime() {}
bool check(string t, string b) {
for (int i = 0; i < b.size(); i++) {
if (t[i] < b[i]) return true;
if (t[i] > b[i]) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
file_o();
cin >> a;
cin >> b;
sort(a.begin(), a.end());
if (a.size() < b.size()) {
reverse(a.begin(), a.end());
cout << a;
} else {
for (int i = 0; i < a.size() - 1; i++) {
for (int j = i + 1; j < a.size(); j++) {
string t = a;
swap(t[i], t[j]);
if (check(t, b)) a = t;
}
}
cout << a;
}
executionTime();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int la, lb, cnt[20], ans[25];
char a[25], b[25];
void find(int v, bool flag) {
if (v > lb) {
for (int i = 1; i <= lb; i++) printf("%d", ans[i]);
exit(0);
}
if (flag && cnt[b[v] - '0']) {
cnt[b[v] - '0']--;
ans[v] = b[v] - '0';
find(v + 1, 1);
ans[v] = 0;
cnt[b[v] - '0']++;
}
for (int i = (flag ? b[v] - '0' - 1 : 9); i >= 0; i--)
if (cnt[i]) {
ans[v] = i;
cnt[i]--;
find(v + 1, 0);
ans[v] = 0;
cnt[i]++;
}
}
int main() {
scanf("%s%s", a + 1, b + 1);
la = strlen(a + 1), lb = strlen(b + 1);
for (int i = 1; i <= la; i++) cnt[a[i] - '0']++;
if (lb > la) {
lb = la;
for (int i = 1; i <= lb; i++) b[i] = '9';
}
find(1, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
string a, b, ans;
vector<char> v;
bool check(int pos) {
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (v[i] < b[i + pos]) return true;
if (v[i] > b[i + pos]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
int i, j;
cin >> a;
cin >> b;
for (i = 0; i < a.length(); i++) v.push_back(a[i]);
sort(v.begin(), v.end());
if (b.size() > a.size()) {
for (i = v.size() - 1; i >= 0; i--) cout << v[i];
return 0;
}
for (i = 0; i < b.size(); i++) {
char c = '0';
int k = 0;
for (j = 0; j < v.size(); j++) {
if (v[j] <= b[i]) {
c = max(c, v[j]);
k = j;
}
}
if (c < b[i]) {
ans += c;
v.erase(v.begin() + k);
break;
}
v.erase(v.begin() + k);
bool f = check(i + 1);
if (f == true) {
ans += c;
continue;
}
v.push_back(c);
sort(v.begin(), v.end());
c = '0';
for (j = 0; j < v.size(); j++) {
if (v[j] < b[i]) {
c = max(c, v[j]);
k = j;
}
}
ans += c;
v.erase(v.begin() + k);
break;
}
cout << ans;
sort(v.begin(), v.end());
for (i = v.size() - 1; i >= 0; i--) cout << v[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int temp[10];
long long A, B;
bool flag = false;
void dfs(int x, long long ans) {
if (x == b.size()) {
flag = true;
A = ans;
}
if (x < b.size()) {
for (int i = 9; i >= 0; i--) {
if (temp[i] > 0) {
ans += pow(10, b.size() - x - 1) * i;
temp[i]--;
if (ans <= B) {
dfs(x + 1, ans);
}
temp[i]++;
ans -= pow(10, b.size() - x - 1) * i;
}
if (flag) break;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> a >> b;
long long t = 1;
for (int i = b.size() - 1; i >= 0; i--) {
B += t * (b[i] - '0');
t *= 10;
}
for (int i = 0; i < a.size(); i++) {
temp[a[i] - '0']++;
}
if (b.size() > a.size()) {
sort(a.begin(), a.end());
for (int i = a.size() - 1; i >= 0; i--) {
cout << a[i];
}
return 0;
} else {
dfs(0, 0);
cout << A << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int MAXN = 100005;
const long long mod = 1e7 + 9;
const int inf = 0x3f3f3f3f;
char a[20];
char b[20];
bool cmp(char i, char j) { return i > j; }
int num[500];
int lena, lenb;
int flag = 0;
vector<char> ans;
stack<char> q;
bool dfs(int x, int en, int aa) {
if (flag) return false;
if (x == lenb) {
flag = 1;
return true;
}
if (en == 1) {
int cnt = 0;
ans.clear();
for (char t = '9'; t >= '0'; t--) {
if (num[t]) {
for (int i = 0; i < num[t]; i++) {
ans.push_back(t);
}
}
}
flag = 1;
return true;
}
char s = b[x];
bool mm = false;
int cnt = 0;
for (char t = s; t >= '0'; t--) {
if (num[t]) {
num[t]--;
if (t == s) {
mm = dfs(x + 1, 0, aa + 1);
} else {
mm = dfs(x + 1, 1, aa + 1);
}
if (mm == true) {
q.push(t);
return true;
}
num[t]++;
}
}
return false;
}
int main() {
scanf("%s", a);
scanf("%s", b);
lena = strlen(a);
lenb = strlen(b);
if (lena < lenb) {
sort(a, a + lena, cmp);
cout << a << endl;
return 0;
}
for (int i = 0; i < lena; i++) {
num[a[i]]++;
}
dfs(0, 0, 1);
while (!q.empty()) {
cout << q.top();
q.pop();
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[20][10];
bool used[20];
int A[20];
int B[20];
int C[20];
int cnt;
long long a, b;
long long ans;
bool cmp(int a, int b) { return a > b; }
int digit(long long a) {
int cur = 0;
long long temp = a;
while (temp) {
temp /= 10;
cur++;
}
temp = a;
int cnt = cur;
while (temp) {
C[cur--] = temp % 10;
temp /= 10;
}
return cnt;
}
long long change(int D[]) {
long long ret = 0, temp = 1;
int cur = cnt;
int tot = 0;
for (int i = 1; i <= cnt; i++) {
if (!used[i]) {
tot++;
D[cur--] = A[i];
}
}
for (int i = cnt; i >= 1; i--) {
ret += temp * D[i];
temp *= 10;
}
return ret;
}
void dfs(int state, bool flag) {
if (state == cnt + 1) {
long long ret = 0, temp = 1;
for (int i = cnt; i >= 1; i--) {
ret += temp * C[i];
temp *= 10;
}
if (ret <= b) {
ans = max(ans, ret);
}
return;
}
bool dflag;
for (int i = 1; i <= cnt; i++) {
if (state == 1 && A[i] > B[1]) continue;
if (flag && A[i] > B[state]) continue;
if (!used[i]) {
C[state] = A[i];
used[i] = true;
long long ret = change(C);
dflag = flag;
if (ret > b || ret <= ans) {
used[i] = false;
continue;
}
if (state == 1) {
if (A[i] == B[1])
flag = true;
else
flag = false;
}
if (state > 1 && flag) {
if (A[i] == B[state])
flag = true;
else
flag = false;
}
dfs(state + 1, flag);
flag = dflag;
used[i] = false;
}
}
}
int main() {
while (scanf("%I64d%I64d", &a, &b) != EOF) {
memset(C, 0, sizeof(C));
int len = digit(a);
cnt = len;
for (int i = 1; i <= len; i++) A[i] = C[i];
sort(A + 1, A + cnt + 1, cmp);
len = digit(b);
for (int i = 0; i <= len; i++) B[i] = C[i];
if (cnt < len) {
long long ret = 0, temp = 1;
for (int i = cnt; i >= 1; i--) {
ret += A[i] * temp;
temp *= 10;
}
printf("%I64d\n", ret);
continue;
}
memset(C, 0, sizeof(C));
memset(vis, false, sizeof(vis));
ans = 0;
memset(used, false, sizeof(used));
dfs(1, false);
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ad[100] = {0};
int bd[100] = {0};
int lena = 0;
int lenb = 0;
int retVal[100] = {0};
int retIdx = 0;
void bar(int idx) {
int tmp[100] = {0};
int len = 0;
for (int i = 0; i < lenb; i++) {
if (bd[i] != -1) {
tmp[len++] = bd[i];
}
}
sort(tmp, tmp + len, greater<int>());
for (int i = 0; i < len; i++) {
retVal[retIdx++] = tmp[i];
}
return;
}
int foo(int idx) {
int minDig = -1;
int minDigIdx = -1;
int minDig2 = -1;
int minDigIdx2 = -1;
bool doneb = false;
for (int i = 0; i < lenb; i++) {
if (bd[i] != -1) {
doneb = true;
}
if (bd[i] <= ad[idx] && (bd[i] > minDig)) {
minDig = bd[i];
minDigIdx = i;
}
if (bd[i] < ad[idx] && (bd[i] > minDig2)) {
minDig2 = bd[i];
minDigIdx2 = i;
}
}
if (!doneb) {
return 0;
}
if (doneb && minDig == -1) {
return -1;
}
if (minDig == ad[idx]) {
bd[minDigIdx] = -1;
retVal[retIdx++] = minDig;
int ret = foo(idx + 1);
if (ret == -1) {
bd[minDigIdx] = minDig;
retIdx--;
retVal[retIdx] = 0;
if (minDig2 == -1) {
return -1;
}
bd[minDigIdx2] = -1;
retVal[retIdx++] = minDig2;
bar(idx + 1);
}
} else if (minDig < ad[idx]) {
bd[minDigIdx] = -1;
retVal[retIdx++] = minDig;
bar(idx + 1);
}
return 0;
}
void revad(int start, int end) {
int temp;
while (start < end) {
temp = ad[start];
ad[start] = ad[end];
ad[end] = temp;
start++;
end--;
}
}
void revbd(int start, int end) {
int temp;
while (start < end) {
temp = bd[start];
bd[start] = bd[end];
bd[end] = temp;
start++;
end--;
}
}
int main() {
long long a, b;
scanf("%lld", &b);
scanf("%lld", &a);
while (a != 0) {
ad[lena++] = a % 10;
a /= 10;
}
while (b != 0) {
bd[lenb++] = b % 10;
b /= 10;
}
revad(0, lena - 1);
revbd(0, lenb - 1);
if (lenb < lena) {
bar(0);
} else {
foo(0);
}
for (int i = 0; i < retIdx; i++) {
printf("%d", retVal[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10;
int n, pos;
string a, b;
int num[N];
bool ok() {
for (int i = 0; i < pos; i++) num[b[i] - '0']--;
for (int i = 0; i <= 9; i++) {
if (num[i] >= 0) continue;
for (int i = 0; i < pos; i++) num[b[i] - '0']++;
return 0;
}
string ans = "";
for (int i = b[pos] - '0' - 1; i >= 0; i--) {
if (!num[i]) continue;
cout << b.substr(0, pos);
num[i]--;
cout << i;
for (int j = 9; j >= 0; j--)
while (num[j]--) cout << j;
cout << '\n';
return 1;
}
for (int i = 0; i < pos; i++) num[b[i] - '0']++;
return 0;
}
int main() {
cin >> a >> b;
if (a.size() != b.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << '\n';
return 0;
}
n = a.size();
string c = b;
sort(c.begin(), c.end());
sort(a.begin(), a.end());
if (a == c) return cout << b << '\n', 0;
for (int i = 0; i < n; i++) num[a[i] - '0']++;
pos = n - 1;
while (!ok()) pos--;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
string as, bs;
int len(long long x) { return to_string(x).length(); }
int gn(char dg) { return (int)(dg - '0'); }
pair<string, bool> fmax(vector<int> dc, int p, bool smad) {
string res = "";
if (smad) {
for (int i = 9; i >= 0; --i) {
for (int j = 0; j < dc[i]; ++j) {
res += to_string(i);
}
}
return {res, true};
}
int dib = gn(bs[p]);
if (dc[dib] > 0) {
dc[dib]--;
if (p < as.length() - 1) {
auto nres = fmax(dc, p + 1, false);
if (nres.second) {
res += bs[p];
res += nres.first;
return {res, true};
}
} else {
res += bs[p];
return {res, true};
}
dc[dib]++;
}
for (int i = dib - 1; i >= 0; --i) {
if (dc[i] > 0) {
dc[i]--;
auto nres = fmax(dc, p + 1, true);
res += to_string(i);
res += nres.first;
return {res, true};
}
}
return {res, false};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
as = to_string(a);
bs = to_string(b);
if (len(b) > len(a)) {
sort(as.begin(), as.end());
reverse(as.begin(), as.end());
cout << as << "\n";
return 0;
}
vector<int> v;
for (int i = 0; i <= 9; ++i) {
int cc = 0;
for (int j = 0; j < as.length(); ++j) {
if (gn(as[j]) == i) {
cc++;
}
}
v.push_back(cc);
}
cout << fmax(v, 0, false).first << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[22], b[22];
int f[22][262144];
int getbit(int x, int i) { return x >> i & 1; }
int onbit(int x, int i) { return x | (1 << i); }
int cal(int i, int x) {
if (f[i][x] != -1) return f[i][x];
if (i > n) return f[i][x] = 1;
f[i][x] = 0;
for (int j = 1; j <= n; ++j)
if (!getbit(x, j - 1) && a[j] <= b[i]) {
if (a[j] < b[i])
f[i][x] = 1;
else
f[i][x] = cal(i + 1, onbit(x, j - 1));
if (f[i][x]) break;
}
return f[i][x];
}
void trace(int i, int x) {
if (i > n) return;
for (int j = 1; j <= n; ++j)
if (!getbit(x, j - 1) && a[j] <= b[i]) {
if (a[j] < b[i]) {
cout << a[j];
for (int k = 1; k <= n; ++k)
if (!getbit(x, k - 1) && k != j) cout << a[k];
return;
} else if (f[i + 1][onbit(x, j - 1)] == 1) {
cout << a[j];
trace(i + 1, onbit(x, j - 1));
return;
}
}
}
int main() {
scanf("%s%s", &a[1], &b[1]);
n = strlen(&a[1]);
m = strlen(&b[1]);
sort(a + 1, a + n + 1, greater<char>());
if (n < m) {
for (int i = 1; i <= n; ++i) cout << a[i];
return 0;
}
memset(f, -1, sizeof(f));
cal(1, 0);
trace(1, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
long long power(long long s, int x) {
long long ret = 1;
while (x) {
if (x & 1) ret *= s;
x /= 2;
s = s * s;
}
return ret;
}
long long toInt(string s) {
stringstream geek(s);
long long x = 0;
geek >> x;
return x;
}
const int maxi = 20;
string a, b, res = "";
long long dp[(1 << maxi) + 2][2];
int lim, n;
long long pp[maxi];
long long lol(int mask, int strict) {
int pos = __builtin_popcount(mask);
char limit;
if (strict)
limit = b[pos];
else
limit = '9';
if (pos >= n) {
if (mask == lim)
return 0;
else
return INT_MIN;
}
if (dp[mask][strict] != -1) return dp[mask][strict];
long long ret = -1 * (1e18);
int x = n - pos - 1;
for (int i = 0; i < n; i++) {
int val = a[i] - '0';
long long temp = val;
if (!check(mask, i)) {
if (strict && a[i] <= limit) {
if (a[i] == limit) {
long long tt = lol(Set(mask, i), strict);
temp = temp * pp[x] + tt;
ret = max(ret, temp);
} else if (a[i] < limit) {
long long tt = lol(Set(mask, i), 0);
temp = temp * pp[x] + tt;
ret = max(ret, temp);
}
} else if (!strict) {
long long tt = lol(Set(mask, i), strict);
temp = temp * pp[x] + tt;
ret = max(ret, temp);
}
}
}
return dp[mask][strict] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pp[0] = 1;
for (int i = 1; i < maxi; i++) pp[i] = pp[i - 1] * 10;
memset(dp, -1, sizeof(dp));
cin >> a >> b;
n = a.size();
lim = (1 << n) - 1;
if (b.size() > a.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << endl;
} else {
cout << lol(0, 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int numbit[35];
long long a, b;
long long tans, nans;
int tcnt;
int cnt;
bool flag[35];
long long solve(int base, int ridix) {
long long r = 1;
long long ans = 0;
for (int i = 0; i < ridix; i++) {
ans += base * r;
r *= 10;
}
return ans;
}
long long solve2(int ridix) {
long long r[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000,
100000000000,
1000000000000,
10000000000000,
100000000000000,
1000000000000000,
10000000000000000,
100000000000000000,
1000000000000000000};
return r[ridix - 1];
}
void dfs(int index) {
if (tans > b) {
return;
}
long long ttmp = nans / solve2(cnt - tcnt) * solve2(cnt - tcnt);
if (ttmp == tans && tans != 0) {
return;
}
int max = 0;
for (int i = 1; i < cnt; i++) {
if (flag[i]) {
max = numbit[i];
break;
}
}
long long tmp = tans + solve(max, cnt - tcnt - 1);
if (tmp > 0 && tmp <= nans) {
return;
}
int min = 0;
for (int i = cnt - 1; i >= 1; i--) {
if (flag[i]) {
min = numbit[i];
break;
}
}
tmp = tans + solve(min, cnt - tcnt - 1);
if (tmp > b) {
return;
}
if (tmp == b && min != max) {
return;
}
if (tcnt == cnt - 1) {
if (tans <= b) {
nans = tans;
}
return;
}
for (int i = 1; i < cnt; i++) {
if (flag[i]) {
tans += numbit[i] * solve2(cnt - tcnt - 1);
tcnt++;
flag[i] = false;
dfs(i);
flag[i] = true;
tcnt--;
tans -= numbit[i] * solve2(cnt - tcnt - 1);
}
}
}
bool compare(int a, int b) { return a > b; }
int main() {
scanf("%lld", &a);
scanf("%lld", &b);
cnt = 1;
numbit[0] = 0;
while (a) {
numbit[cnt++] = a % 10;
a /= 10;
}
sort(numbit + 1, numbit + cnt, compare);
for (int i = 0; i < cnt; i++) {
flag[i] = true;
}
flag[0] = false;
tcnt = 0;
nans = 0;
tans = 0;
dfs(0);
printf("%lld", nans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
string a, b;
int main() {
cin >> a >> b;
if (a.size() != b.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << endl;
} else {
string aa = a, bb = b;
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
if (aa == bb) {
cout << b << endl;
return 0;
}
for (int i = a.size() - 1; i >= 0; --i) {
string na = a;
string ans = "";
bool f = true;
for (int j = (0); j < (i); ++j) {
int pos = -1;
for (int k = (0); k < (na.size()); ++k)
if (na[k] == b[j]) {
pos = k;
break;
}
if (pos == -1) {
f = false;
break;
}
na.erase(na.begin() + pos);
ans += b[j];
}
if (!f) continue;
int mx = -1;
for (int j = (0); j < (na.size()); ++j)
if (na[j] < b[i]) {
if (mx == -1 || na[mx] < na[j]) mx = j;
}
if (mx == -1) continue;
ans += na[mx];
na.erase(na.begin() + mx);
sort(na.begin(), na.end());
reverse(na.begin(), na.end());
ans += na;
cout << ans << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int MOD = 1e9 + 7;
string a, b;
int cnt[10];
int main() {
cin >> a >> b;
for (int i = (0); i < ((int)a.size()); ++i) {
++cnt[a[i] - '0'];
}
if (b.size() > a.size()) {
for (int i = 9; i >= 0; --i) {
for (int j = (0); j < (cnt[i]); ++j) {
cout << i;
}
}
return 0;
}
string nov = "";
int len = (int)a.size();
for (int i = (0); i < (len); ++i) {
for (int j = 9; j >= 0; --j) {
string k = nov;
if (!cnt[j]) continue;
k += j + '0';
--cnt[j];
bool ok = true;
for (int l = (0); l < (10); ++l)
for (int m = (0); m < (cnt[l]); ++m) k += '0' + l;
for (int l = (0); l < ((int)b.size()); ++l) {
if (k[l] < b[l])
break;
else if (k[l] > b[l]) {
ok = false;
break;
}
}
if (ok) {
nov += '0' + j;
break;
} else
++cnt[j];
}
}
cout << nov;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
string as, bs;
int len(long long x) { return to_string(x).length(); }
int gn(char dg) { return (int)(dg - '0'); }
pair<string, bool> fmax(vector<int> dc, int p, bool smad) {
string res = "";
if (smad) {
for (int i = 9; i >= 0; --i) {
for (int j = 0; j < dc[i]; ++j) {
res += to_string(i);
}
}
return {res, true};
}
int dib = gn(bs[p]);
if (dc[dib] > 0) {
dc[dib]--;
if (p < as.length() - 1) {
auto nres = fmax(dc, p + 1, false);
if (nres.second) {
res += bs[p];
res += nres.first;
return {res, true};
}
} else {
res += bs[p];
return {res, true};
}
dc[dib]++;
}
for (int i = dib - 1; i >= 0; --i) {
if (dc[i] > 0) {
dc[i]--;
auto nres = fmax(dc, p + 1, true);
res += to_string(i);
res += nres.first;
return {res, true};
}
}
return {res, false};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
as = to_string(a);
bs = to_string(b);
if (len(b) > len(a)) {
sort(as.begin(), as.end());
reverse(as.begin(), as.end());
cout << as << "\n";
return 0;
}
if (len(b) < len(a)) {
cout << "-1\n";
return 0;
}
vector<int> v;
for (int i = 0; i <= 9; ++i) {
int cc = 0;
for (int j = 0; j < as.length(); ++j) {
if (gn(as[j]) == i) {
cc++;
}
}
v.push_back(cc);
}
auto res = fmax(v, 0, false);
if (!res.second) {
cout << "-1\n";
} else {
cout << res.first << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a;
long long b, res, cnt[1000];
int main() {
cin >> a >> b;
for (int i = 0; i <= a.size() - 1; i++) ++cnt[a[i] - '0'];
for (int i = 1; i <= a.size(); i++) {
for (int j = 9; j >= 0; j--)
if (cnt[j]) {
cnt[j]--;
long long cur = 10 * res + j;
for (int t = 0; t <= 9; t++)
for (int n = 1; n <= cnt[t]; n++) cur = cur * 10 + t;
if (cur <= b) {
res = res * 10 + j;
break;
}
cnt[j]++;
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20], res[20];
int n, m;
inline bool judge() {
int pos = n;
for (int i = 1; i <= n; ++i) {
if (a[i] != '-') {
res[pos] = a[i];
pos--;
}
}
return (strcmp(res + 1, b + 1) <= 0);
}
int main() {
scanf("%s", a + 1);
scanf("%s", b + 1);
n = strlen(a + 1);
m = strlen(b + 1);
sort(a + 1, a + n + 1, greater<char>());
if (m > n) return puts(a + 1), 0;
for (int i = 1; i <= m; ++i) res[i] = '0';
char ch;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (a[j] == '-')
continue;
else {
ch = res[i] = a[j];
a[j] = '-';
if (judge())
break;
else
a[j] = ch;
}
puts(res + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int la, lb, vis[20], flag;
char a[20], b[20], ans[20];
bool cmp(char a, char b) { return a > b; }
void play(int x) {
if (flag) return;
if (x == la) {
flag = 1;
return;
}
for (int i = 9; i >= 0; i--) {
if (vis[i] > 0 && i + '0' == b[x]) {
ans[x] = i + '0';
vis[i]--;
play(x + 1);
if (flag)
return;
else
vis[i]++;
} else if (vis[i] > 0 && i + '0' < b[x]) {
ans[x] = i + '0';
vis[i]--;
int d = x + 1;
for (int j = 9; j >= 0; j--)
while (vis[j] > 0) {
ans[d++] = j + '0';
vis[j]--;
}
flag = 1;
return;
}
}
}
int main() {
scanf("%s%s", a, b);
memset(vis, 0, sizeof(vis));
la = strlen(a);
lb = strlen(b);
flag = 0;
sort(a, a + la, cmp);
for (int i = 0; i < la; i++) {
vis[a[i] - '0']++;
}
if (la < lb)
puts(a);
else {
play(0);
for (int i = 0; i < la; i++) printf("%c", ans[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool f(int index, string &b, vector<int> &cnt, bool upper, long long &ans) {
if (index == b.size()) {
return true;
}
if (upper) {
for (int i = 9; i >= 0; --i) {
if (cnt[i]) {
cnt[i]--;
ans = 10 * ans + i;
return f(index + 1, b, cnt, upper, ans);
}
}
} else {
int d = b[index] - '0';
for (int i = d; i >= 0; --i) {
if (cnt[i]) {
cnt[i]--;
ans = 10 * ans + i;
bool is_possible = f(index + 1, b, cnt, i != d, ans);
cnt[i]++;
if (is_possible) {
return true;
}
ans /= 10;
}
}
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
string a, b;
cin >> a >> b;
if (a.size() != b.size()) {
if (a.size() > b.size()) {
assert(false);
}
sort(a.begin(), a.end(), greater<char>());
cout << a << '\n';
return 0;
}
vector<int> cnt(10);
for (auto c : a) {
cnt[c - '0']++;
}
long long ans = 0;
f(0, b, cnt, false, ans);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j;
vector<int> cnt;
string st, lim, ans;
void dfs(int x, string st, bool up, vector<int> cnt2) {
if (x == lim.size()) {
if (st <= lim) ans = max(ans, st);
return;
}
int i;
if (!up) {
int j;
for (j = 9; !cnt2[j]; j--)
;
while (x < lim.size()) {
while (!cnt2[j]) j--;
cnt2[j]--;
st.push_back(j + '0');
x++;
}
if (st <= lim) ans = max(ans, st);
return;
}
for (i = 0; i <= lim[x] - '0'; i++) {
if (cnt2[i]) {
cnt2[i]--;
string st1 = st;
st1.push_back(i + '0');
dfs(x + 1, st1, i == lim[x] - '0', cnt2);
cnt2[i]++;
}
}
}
int main() {
cin >> st >> lim;
if (lim.size() > st.size()) {
sort(st.begin(), st.end());
reverse(st.begin(), st.end());
cout << st;
return 0;
}
for (i = 0; i <= 9; i++) cnt.push_back(0);
for (i = 0; i < st.length(); i++) cnt[st[i] - '0']++;
dfs(0, "", 1, cnt);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dig(const string &a) {
int l = a.size(), i = 0;
long long ans = 0;
while (i < l) {
ans *= 10;
ans += (a[i] - '0');
i++;
}
return ans;
}
int main() {
string a;
long long b;
cin >> a >> b;
int l = a.size();
sort(a.begin(), a.end());
for (int i = 0; i < l; i++) {
for (int j = i + 1; j < l; j++) {
string temp = a;
swap(temp[i], temp[j]);
sort(temp.begin() + i + 1, temp.end());
if (dig(a) < dig(temp) && dig(temp) <= b) swap(a[i], a[j]);
}
}
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool checkBit(long long int n, long long int i) { return (n & (1LL << i)); }
long long int setBit(long long int n, long long int i) {
return (n | (1LL << i));
}
long long int resetBit(long long int n, long long int i) {
return (n & (~(1LL << i)));
}
const long long int MX = 1e18;
const long long int mod = 1e9 + 7;
map<int, int> m;
void solve() {
string a, b;
cin >> a >> b;
set<int> s;
for (auto x : a) {
m[x - '0']++;
s.insert(x - '0');
}
vector<int> ans;
int n = a.size();
int np = b.size();
if (np > n) {
for (int i = 9; i >= 0; i--) {
while (m[i]--) {
cout << i;
}
}
return;
}
for (int i = n; i >= 0; i--) {
int vis[11] = {0};
for (int j = 0; j < 10; j++) vis[j] = m[j];
set<int> sp = s;
ans.clear();
int flag = 0;
for (int j = 0; j < i; j++) {
int crt = b[j] - '0';
if (vis[crt] <= 0) {
flag = 1;
break;
}
vis[crt]--;
ans.push_back(crt);
if (vis[crt] == 0) {
sp.erase(crt);
}
}
if (flag) continue;
if (i == n and flag == 0) {
break;
}
int crt = b[i] - '0';
for (int j = crt - 1; j >= 0; j--) {
if (vis[j] > 0) {
ans.push_back(j);
vis[j]--;
for (int j = 9; j >= 0; j--) {
while (vis[j]--) {
ans.push_back(j);
}
}
flag = 1;
break;
}
}
if (flag == 1) break;
}
for (auto x : ans) {
cout << x;
}
cout << "\n";
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using bigint = long long int;
using vi = vector<int>;
bigint ans;
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
string A, B;
cin >> A >> B;
sort(A.begin(), A.end());
for (int i = 0; i < A.length(); i++) {
for (int j = i + 1; j < A.length(); j++) {
string str = A;
swap(str[i], str[j]);
if (stoll(str) > stoll(A) && stoll(str) <= stoll(B)) A = str;
}
}
cout << A << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 50;
const long long INF = 1e9;
long long dx[] = {-1, 0, 1, 0};
long long dy[] = {0, 1, 0, -1};
template <typename T>
void __print(long long x) {
cerr << x;
}
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long mod = 1e9 + 7;
bool compare(const pair<pair<long long, long long>, long long> &i,
const pair<pair<long long, long long>, long long> &j) {
return i.second < j.second;
}
long long modexp(long long x, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return r % mod;
}
long long modinv(long long x) { return modexp(x, mod - 2); }
vector<long long> sieve(long long n) {
long long *arr = new long long[n + 1]();
vector<long long> vect;
for (long long i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (long long j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a + b) % mod) + mod) % mod;
}
long long mod_mul(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a * b) % mod) + mod) % mod;
}
long long mod_sub(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a - b) % mod) + mod) % mod;
}
long long mod_div(long long a, long long b) {
a = a % mod;
b = b % mod;
return (mod_mul(a, modinv(b)) + mod) % mod;
}
void solve() {
string s;
cin >> s;
sort(s.begin(), s.end(), greater<char>());
string s1;
cin >> s1;
string temp = "";
if (s.size() < s1.size()) {
cout << s << "\n";
return;
}
long long n = s.size();
for (long long i = 0; i < n; i++) {
string str = temp;
string z;
for (long long j = 0; j < n; j++) {
z = s;
str = temp + s[j];
z.erase(j, 1);
sort(z.begin(), z.end());
if (str + z <= s1) {
temp = str;
s.erase(j, 1);
break;
}
}
}
cout << temp << "\n";
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[32], b[32];
int dig[10];
long long check(int to) {
long long ans = 0;
int dig2[10];
for (int i = 0; i < 10; ++i) {
dig2[i] = dig[i];
}
for (int i = 0; i < to; ++i) {
if (!dig2[b[i] - '0']) {
return -1;
}
ans *= 10;
ans += b[i] - '0';
--dig2[b[i] - '0'];
}
if (to == m) {
return ans;
}
bool flag = 0;
for (int i = b[to] - '0' - 1; i >= 0; --i) {
if (dig2[i]) {
--dig2[i];
ans *= 10;
ans += i;
flag = 1;
break;
}
}
if (!flag) {
return -1;
}
for (int i = 9; i >= 0; --i) {
while (dig2[i]) {
ans *= 10;
ans += i;
--dig2[i];
}
}
return ans;
}
int main() {
cin >> a >> b;
n = strlen(a);
m = strlen(b);
for (int i = 0; i < n; ++i) {
++dig[a[i] - '0'];
}
if (n < m) {
for (int i = 9; i >= 0; --i) {
while (dig[i]) {
cout << i;
--dig[i];
}
}
cout << "\n";
return 0;
}
for (int i = m; i >= 0; --i) {
long long a = check(i);
if (a != -1) {
cout << a << "\n";
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int na[20];
int num[10];
long long ten[20];
bool vis[20];
int cn = 0;
long long a, b;
void dfs(int c, long long co) {
if (c < 0) {
cout << co;
exit(0);
} else {
for (int i = 9; i >= 0; i--) {
if (num[i] > 0 && ten[c] * i + co <= b) {
num[i]--;
dfs(c - 1, co + ten[c] * i);
num[i]++;
}
}
}
}
int main() {
memset(vis, 0, sizeof(vis));
cin >> a >> b;
long long x = a;
ten[0] = 1;
for (int i = 1; i < 19; i++) ten[i] = ten[i - 1] * 10;
while (x) {
num[x % 10]++;
x /= 10;
cn++;
}
dfs(cn - 1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
long long ha[22];
long long hb[22];
int cnt = 0;
void dfs(int pos, long long ans, bool able) {
if (ans > b) return;
if (pos == cnt) {
if (able) {
cout << ans << endl;
exit(0);
} else if (ans <= b) {
cout << ans << endl;
exit(0);
}
return;
}
if (able) {
long long mx = 0;
for (int i = 1; i < cnt; i++) {
if (ha[i] > ha[mx]) mx = i;
}
long long haha = -1;
swap(haha, ha[mx]);
dfs(pos + 1, ans * 10 + haha, 1);
swap(haha, ha[mx]);
return;
}
long long bound = hb[pos];
long long sav[22];
for (int i = 0; i < cnt; i++) sav[i] = ha[i];
sort(ha, ha + cnt);
long long i = upper_bound(ha, ha + cnt, bound) - ha - 1;
if (i >= cnt) {
for (int i = 0; i < cnt; i++) ha[i] = sav[i];
return;
}
long long haha = -1;
for (; i >= 0; i--) {
if (ha[i] == -1) break;
if (ha[i] == 0 && pos == 0) break;
if (ha[i] == ha[i + 1]) continue;
swap(haha, ha[i]);
dfs(pos + 1, ans * 10 + haha, (haha < bound));
swap(haha, ha[i]);
}
for (int i = 0; i < cnt; i++) ha[i] = sav[i];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> a >> b;
while (a > 0) {
ha[cnt] = a % 10;
cnt++;
a /= 10;
}
long long mx = 0;
sort(ha, ha + cnt);
for (int i = cnt - 1; i >= 0; i--) mx = mx * 10 + ha[i];
if (mx <= b) {
cout << mx << endl;
return 0;
}
ha[cnt] = 2333;
long long sav = b;
cnt = 0;
while (b > 0) {
hb[cnt] = b % 10;
cnt++;
b /= 10;
}
reverse(hb, hb + cnt);
b = sav;
dfs(0, 0LL, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string A, B;
int has[10];
string res;
void Create(int from) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < has[i]; j++) {
res[from++] = i + '0';
}
}
}
int main() {
cin >> A >> B;
int st = 0;
for (int i = 0; i < A.length(); i++) has[A[i] - '0']++;
while (A.length() < B.length()) {
A = "0" + A;
st++;
}
res = A;
for (int i = st; i < A.length(); i++) {
for (int j = 10 - 1; j >= 0; j--) {
if (has[j] > 0) {
has[j]--;
res[i] = j + '0';
Create(i + 1);
if (res <= B) break;
has[j]++;
}
}
}
int pos = 0;
while (res[pos] == '0') pos++;
cout << res.substr(pos) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pos[10];
int dp[1 << 20][2];
int path[1 << 20][2];
char letters[1 << 20];
int n;
string a, b;
int lsb(int x) { return x & -x; }
bool solve(int bit, int pref, int id) {
if (id == n) return 1;
int &ans = dp[bit][pref];
if (ans != -1) return ans;
ans = 0;
for (int i = 9; i >= 0; i--) {
if (pref && i > (b[id] - '0')) continue;
if (!pos[i]) continue;
int x = bit & pos[i];
int y = x ^ pos[i];
if (y) {
int p = lsb(y);
int newPref = i == (b[id] - '0');
ans = solve(bit | p, pref & newPref, id + 1);
if (ans) {
path[bit][pref] = p;
break;
}
}
}
return ans;
}
int main() {
cin >> a >> b;
sort((a).begin(), (a).end(), greater<char>());
if (a.size() < b.size()) {
cout << a << endl;
return 0;
}
n = a.size();
for (int i = 0; i < a.size(); i++) {
pos[a[i] - '0'] |= 1 << i;
letters[1 << i] = a[i];
}
memset(dp, -1, sizeof dp);
solve(0, 1, 0);
int bit = 0, pref = 1, id = 0;
while (id != n) {
int x = path[bit][pref];
printf("%c", letters[x]);
bit |= x;
if (letters[x] < b[id]) pref = 0;
id++;
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
vector<long long> power(19);
long long ans;
void poss() {
power[0] = 1;
for (long long i = 1; i < 19; i++) power[i] = power[i - 1] * 10;
}
bool findans(vector<long long> fre, long long as, long long b,
long long digit) {
if (digit == 1) {
for (long long j = 9; j >= 0; j--) {
if (fre[j]) {
fre[j]--;
long long temp = as + j;
if (temp <= b) {
ans = temp;
return true;
} else
return false;
}
}
}
for (long long j = 9; j >= 0; j--) {
if (fre[j]) {
long long temp = as + j * power[digit - 1];
if (temp <= b) {
fre[j]--;
bool pra = findans(fre, temp, b, digit - 1);
if (pra) {
return true;
} else
fre[j]++;
}
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
poss();
long long a, b;
cin >> a >> b;
string s = to_string(a);
vector<long long> fre(10);
for (long long i = 0; i < s.size(); i++) fre[s[i] - '0']++;
bool d = findans(fre, 0, b, s.size());
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct comparator {
bool operator()(long long int i, long long int j) { return i > j; }
};
bool sortpair(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return (b.first - b.second) > (a.first - a.second);
}
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long int min(long long int a, long long int b) { return a > b ? b : a; }
long long int min(long long int a, long long int b, long long int c) {
if (a <= b && a <= c) {
return a;
} else if (b <= a && b <= c) {
return b;
} else {
return c;
}
}
long long int max(long long int a, long long int b) { return a > b ? a : b; }
long long int lcm(long long int a, long long int b) {
return (a * b / gcd(a, b));
}
bool check(long long int x) {
while (x % 2 == 0) {
x /= 2;
}
while (x % 3 == 0) {
x /= 3;
}
if (x != 1) {
return false;
}
return true;
}
long long int ans(int num, int n) {
if (n == 1) {
return num;
} else if (n == 2) {
return num + 1;
} else if (n == 3) {
return num + 2;
} else if (n % 3 == 0) {
return ans(num + 2, (n - 1) / 2);
} else if (n % 2 == 0) {
return ans(num + 1, n / 2);
}
}
vector<long long int> getprimes() {
vector<long long int> pl(101, 1);
for (int i = 2; i <= 100; i++) {
if (pl[i] == 1) {
for (int j = 2 * i; j <= 100; j += i) {
pl[j] = 0;
}
}
}
return pl;
}
long long int ans(int n) {
if (n == 0) {
return 1;
} else if (n == 1 || n == 2) {
return 0;
} else if (n < 0) {
return 0;
} else {
return (ans(n - 7) | ans(n - 3));
}
}
long long int primefactorise(int n) {
if (n == 1) {
return 1;
}
long long int ans = n;
while (n % 2 == 0) {
n = n / 2;
if (n != 1) {
ans += n;
}
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
n = n / i;
if (n != 1) {
ans += n;
}
}
}
ans += 1;
return ans;
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans *= a;
}
b /= 2;
a *= a;
}
return ans;
}
long long int DFS(vector<vector<long long int> > g, long long int top,
vector<long long int> col, stack<long long int> s2) {
col[top] = 1;
long long int size = g[top].size();
for (int i = 0; i < size; i++) {
if (col[g[top][i]] == 0) {
col[g[top][i]] = 1;
DFS(g, g[top][i], col, s2);
}
}
s2.push(top);
}
long long int ans1 = 1;
long long int mincost = 0;
long long int mini = INT_MAX;
long long int num = 0;
vector<long long int> c;
class Graph {
int V;
list<int> *adj;
void fillOrder(int v, bool visited[], stack<int> &Stack);
void DFSUtil(int v, bool visited[]);
public:
Graph(int V);
void addEdge(int v, int w);
void printSCCs();
Graph getTranspose();
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::DFSUtil(int v, bool visited[]) {
visited[v] = true;
if (c[v] < mini) {
num = 1;
mini = c[v];
} else if (c[v] == mini) {
num++;
}
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i]) DFSUtil(*i, visited);
}
Graph Graph::getTranspose() {
Graph g(V);
for (int v = 0; v < V; v++) {
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i) {
g.adj[*i].push_back(v);
}
}
return g;
}
void Graph::addEdge(int v, int w) { adj[v].push_back(w); }
void Graph::fillOrder(int v, bool visited[], stack<int> &Stack) {
visited[v] = true;
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i]) fillOrder(*i, visited, Stack);
Stack.push(v);
}
void Graph::printSCCs() {
stack<int> Stack;
bool *visited = new bool[V];
for (int i = 0; i < V; i++) visited[i] = false;
for (int i = 0; i < V; i++)
if (visited[i] == false) fillOrder(i, visited, Stack);
Graph gr = getTranspose();
for (int i = 0; i < V; i++) visited[i] = false;
while (Stack.empty() == false) {
int v = Stack.top();
Stack.pop();
mini = INT_MAX;
num = 0;
if (visited[v] == false) {
gr.DFSUtil(v, visited);
mincost += mini;
ans1 = (num * ans1) % (1000000007);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int a, b;
cin >> a >> b;
vector<long long int> arr(10, 0), brr, crr(10, 0);
vector<long long int> e;
while (a > 0) {
arr[a % 10]++;
e.push_back(a % 10);
a /= 10;
}
brr = arr;
vector<long long int> c;
while (b > 0) {
crr[b % 10]++;
c.push_back(b % 10);
b /= 10;
}
long long int n1 = c.size(), n2 = e.size();
if (n2 < n1) {
for (int i = 9; i >= 0; i--) {
while (arr[i] != 0) {
cout << i;
arr[i]--;
}
}
return 0;
} else {
int flag = 0;
for (int i = 0; i < 10; i++) {
if (arr[i] != crr[i]) {
flag = 1;
break;
}
}
if (flag == 0) {
for (int i = n1 - 1; i >= 0; i--) {
cout << c[i];
}
return 0;
} else {
long long int m = -1;
for (int i = n1 - 1; i >= 0; i--) {
arr = brr;
int flag1 = 0;
long long int temp = 0;
for (int j = n1 - 1; j > i; j--) {
if (arr[c[j]] != 0) {
temp *= 10;
temp += c[j];
arr[c[j]]--;
} else {
flag1 = 1;
break;
}
}
if (flag1 == 1) {
continue;
} else {
int flag2 = 0;
for (int j = c[i] - 1; j >= 0; j--) {
if (arr[j] != 0) {
temp *= 10;
temp += j;
arr[j]--;
flag2 = 1;
break;
}
}
if (flag2 == 0) {
continue;
}
int flag3 = 0;
for (int j = i - 1; j >= 0; j--) {
flag2 = 0;
for (int k = 9; k >= 0; k--) {
if (arr[k] != 0) {
temp *= 10;
temp += k;
arr[k]--;
flag2 = 1;
break;
}
}
if (flag2 == 0) {
flag3 = 1;
break;
}
}
if (flag3 == 1) {
continue;
} else {
if (temp > m) {
m = temp;
}
}
}
}
cout << m << endl;
}
}
}
|
#include <bits/stdc++.h>
const int64_t kInfty = 1e18;
const double kEps = 1e-7;
int64_t FindDigits(int64_t a) {
int64_t res = 0;
while (a > 0) {
++res;
a /= 10;
}
return res;
}
std::vector<int64_t> Extract(int64_t a) {
std::vector<int64_t> res;
while (a > 0) {
res.push_back(a % 10);
a /= 10;
}
std::reverse(res.begin(), res.end());
return res;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int64_t a, b;
std::cin >> a >> b;
int64_t dig_a = FindDigits(a);
int64_t dig_b = FindDigits(b);
std::vector<int64_t> dig = Extract(a);
if (dig_a < dig_b) {
std::sort(dig.begin(), dig.end(), std::greater<int64_t>());
for (int64_t digit : dig) std::cout << digit;
return 0;
}
std::sort(dig.begin(), dig.end());
std::vector<int64_t> target = Extract(b);
std::vector<int64_t> res;
for (size_t i = 0; i < target.size(); ++i) {
int64_t insert = target[i];
for (; insert >= 0; --insert) {
bool ok = false;
for (auto it = dig.begin(); it != dig.end(); ++it)
if (*it == insert) {
ok = true;
res.push_back(insert);
dig.erase(it);
break;
}
if (ok) break;
}
if (insert < 0) {
while (!res.empty()) {
int64_t del = *res.rbegin();
dig.push_back(del);
res.pop_back();
int64_t new_insert = del - 1;
for (; new_insert >= 0; --new_insert) {
bool ok = false;
for (auto it = dig.begin(); it != dig.end(); ++it)
if (*it == new_insert) {
res.push_back(new_insert);
ok = true;
dig.erase(it);
break;
}
if (ok) break;
}
if (new_insert < 0)
continue;
else {
std::sort(dig.begin(), dig.end(), std::greater<int64_t>());
for (int64_t x : res) std::cout << x;
for (int64_t x : dig) std::cout << x;
return 0;
}
}
}
if (insert < target[i]) {
for (int64_t x : res) std::cout << x;
for (auto it = dig.rbegin(); it != dig.rend(); ++it) std::cout << *it;
return 0;
}
}
for (int64_t val : res) std::cout << val;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, q, o, ot;
vector<long long> a, b;
long long f[33];
void rc(long long s, long long j) {
if (j == n) {
for (long long j = 0; j < n; j++)
if (f[j] != 1) s = s * 10 + a[j];
ot = max(ot, s);
return;
}
for (long long i = 0; i < n; i++)
if (f[i] != 1)
if (a[i] < b[j]) {
f[i] = 1;
long long ss = s;
ss = ss * 10 + a[i];
for (long long j = 0; j < n; j++)
if (f[j] != 1) ss = ss * 10 + a[j];
f[i] = 0;
ot = max(ss, ot);
break;
}
for (long long i = 0; i < n; i++)
if (f[i] != 1)
if (a[i] == b[j]) {
f[i] = 1;
rc(s * 10 + a[i], j + 1);
f[i] = 0;
break;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
cin >> m;
while (n != 0) {
a.push_back(n % 10);
n /= 10;
}
while (m != 0) {
b.push_back(m % 10);
m /= 10;
}
if (b.size() > a.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
for (i = 0; i < a.size(); i++) cout << a[i];
return 0;
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
m = 1 << a.size();
m--;
q = a.size();
n = a.size();
for (i = 0; i < n; i++)
if (a[i] < b[0]) {
f[i] = 1;
ot = a[i];
for (j = 0; j < n; j++)
if (f[j] == 0) ot = ot * 10 + a[j];
f[i] = 0;
break;
}
for (i = 0; i < n; i++)
if (a[i] == b[0]) {
f[i] = 1;
rc(a[i], 1);
f[i] = 0;
break;
}
cout << ot << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
const int inf = 0x3f3f3f3f;
int num[10], top, len2;
char ch1[maxn], ch2[maxn];
long long ans;
void find() {
memset(num, 0, sizeof(num));
int le = strlen(ch1), i;
for (i = 0; i < le; i++) {
int te = ch1[i] - '0';
num[te]++;
}
}
int flag1;
void dfs(long long nu, int kk, int t) {
if (flag1) return;
if (kk == top) {
ans = nu;
flag1 = 1;
return;
}
if (t == 1) {
for (int i = 9; i >= 0; i--) {
if (num[i]) {
long long t = nu * 10;
t += i;
num[i]--;
dfs(t, kk + 1, 1);
num[i]++;
}
}
} else {
int m = ch2[kk] - '0', j;
for (j = m; j >= 0; j--) {
if (num[j]) {
long long t = nu * 10;
t += j;
num[j]--;
if (j != m)
dfs(t, kk + 1, 1);
else
dfs(t, kk + 1, 0);
num[j]++;
}
}
}
return;
}
int main() {
int i, j;
scanf("%s%s", ch1, ch2);
int len1 = strlen(ch1);
len2 = strlen(ch2);
top = len1;
find();
ans = 0;
if (len1 < len2) {
for (i = 9; i >= 0; i--) {
if (num[i]) {
while (num[i]) {
ans *= 10;
ans += i;
num[i]--;
}
}
}
} else {
flag1 = 0;
dfs(0, 0, 0);
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1E5;
string a, b;
int num[20], len1, len2;
void bfs(int x, ll ans, bool limit) {
int now = b[x] - '0';
int k = limit ? now : 9;
for (int i = k; i >= 0; i--) {
if (num[i]) {
if (x == len1 - 1) {
cout << ans * 10 + i << endl;
exit(0);
}
num[i]--;
bfs(x + 1, ans * 10 + i, limit && i == now);
num[i]++;
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> a >> b;
len1 = a.size();
len2 = b.size();
for (int i = 0; i < len1; i++) {
num[a[i] - '0']++;
}
if (len1 == 1) {
cout << a << endl;
return 0;
}
if (len1 < len2) {
ll ans = 0;
for (int i = 9; i >= 0; i--) {
while (num[i]) {
ans = ans * 10 + i;
num[i]--;
}
}
cout << ans << endl;
} else {
for (int i = b[0] - '0'; i >= 1; i--) {
if (num[i]) {
num[i]--;
bfs(1, i, b[0] - '0' == i);
num[i]++;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, suf, ans = "", temp = "";
cin >> a >> b;
if (a == b) {
cout << a;
return 0;
}
sort(a.begin(), a.end());
suf = a;
int x[10] = {0};
for (int i = 0; i < a.length(); i++) x[a[i] - '0']++;
if (a.length() < b.length()) {
reverse(suf.begin(), suf.end());
cout << suf << endl;
return 0;
}
bool flag = false;
for (int i = 0; i < b.length(); i++) {
char c = b[i];
if (ans + temp == b) {
cout << b;
break;
}
if (x[c - '0']) {
x[c - '0']--;
ans += c;
temp = "";
for (int j = 0; j <= 9; j++) {
int z = x[j];
while (z--) temp += to_string(j);
}
if (ans + temp <= b)
continue;
else {
x[c - '0']++;
for (int j = c - '0' - 1; j >= 0; j--) {
if (x[j]) {
x[j]--;
temp = "";
ans[ans.length() - 1] = j + '0';
for (int k = 9; k >= 0; k--) {
while (x[k]) {
temp += to_string(k);
x[k]--;
}
}
cout << ans + temp << endl;
flag = true;
break;
}
}
if (flag) break;
}
} else {
for (int j = c - '0' - 1; j >= 0; j--) {
if (x[j]) {
temp = "";
ans += to_string(j);
x[j]--;
for (int k = 9; k >= 0; k--) {
while (x[k]) {
temp += to_string(k);
x[k]--;
}
}
cout << ans + temp << endl;
flag = true;
break;
}
}
if (flag) break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a;
long long b;
int main() {
cin >> a >> b;
sort(a.begin(), a.end());
for (int i = 0; i < a.size(); i++)
for (int j = i + 1; j < a.size(); j++) {
string t = a;
swap(t[j], t[i]);
sort(t.begin() + i + 1, t.end());
if (stoll(t) > stoll(a) && stoll(t) <= b) swap(a[i], a[j]);
}
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
string sol, cur;
int fr[10], aux[10];
int main() {
int i, j;
ios::sync_with_stdio(false);
cin >> a >> b;
for (auto it : a) {
fr[it - '0']++;
aux[it - '0']++;
}
if (a.size() < b.size()) {
sort(a.begin(), a.end(), greater<int>());
for (auto it : a) cout << it;
return 0;
}
for (j = b[0] - '0' - 1; j > 0; j--) {
if (aux[j] > 0) {
aux[j]--;
sol.push_back(j + '0');
break;
}
}
if (sol.size()) {
for (j = 9; j >= 0; j--) {
while (aux[j]) {
aux[j]--;
sol.push_back(j + '0');
}
}
}
for (i = 0; i < b.size(); i++) {
if (fr[b[i] - '0'] == 0) break;
fr[b[i] - '0']--;
cur.push_back(b[i]);
if (i + 1 < b.size()) {
int d = -1;
for (j = b[i + 1] - '0' - 1; j >= 0; j--) {
if (fr[j] > 0) {
cur.push_back(j + '0');
d = j;
break;
}
}
if (d > -1) {
fr[d]--;
for (j = 9; j >= 0; j--) {
for (int k = 0; k < fr[j]; k++) {
cur.push_back(j + '0');
}
}
fr[d]++;
if (sol < cur) sol = cur;
}
while (cur.size() > i + 1) {
cur.pop_back();
}
} else {
sol = cur;
}
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
getline(cin, a);
getline(cin, b);
vector<int> digA;
for (int i = 0; i < a.size(); i++) {
digA.push_back(a[i] - '0');
}
sort(digA.begin(), digA.end());
vector<int> res;
vector<int>::iterator it, itt;
bool guarenteSmaller = false;
if (a.size() < b.size()) {
for (int i = digA.size() - 1; i >= 0; i--) cout << digA[i];
cout << endl;
return 0;
}
int hasSmall = 0;
for (int i = 0; i < b.size() && digA.size() > 0 && res.size() < a.size();
i++) {
if (!guarenteSmaller) {
it = upper_bound(digA.begin(), digA.end(), b[i] - '0');
if (it != digA.begin() && digA[0] < *(it - 1))
hasSmall = i;
else if (it == digA.begin()) {
int temp = res[hasSmall];
while (res.size() > hasSmall) {
digA.push_back(res[res.size() - 1]);
res.erase(res.end() - 1);
}
sort(digA.begin(), digA.end());
it = lower_bound(digA.begin(), digA.end(), temp);
it--;
i = hasSmall - 1;
res.push_back(*it);
digA.erase(it);
guarenteSmaller = true;
continue;
}
it--;
if (guarenteSmaller) {
i--;
continue;
}
if ((*it) < (b[i] - '0')) guarenteSmaller = true;
res.push_back((*it));
digA.erase(it);
} else if (digA.size() > 0) {
it = digA.end() - 1;
res.push_back(*it);
digA.erase(it);
}
}
for (int i = 0; i < a.size(); i++) cout << res[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
string s1, s2;
int len1, len2;
int bo[N], a[N], b[N];
vector<int> v, vans;
bool get_ans() {
for (int i = 0; i < (int)vans.size(); i++) v[i + 1] = vans[i];
int nn = (int)vans.size();
for (int i = 0; i <= 9; i++)
for (int j = 1; j <= bo[i]; j++) v[++nn] = i;
for (int i = 1; i <= len1; i++)
if (v[i] != b[i] && v[i] > b[i])
return false;
else if (v[i] != b[i] && v[i] < b[i])
return true;
return true;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> s1 >> s2;
len1 = s1.size(), len2 = s2.size();
if (len1 < len2) {
sort(s1.begin(), s1.end());
reverse(s1.begin(), s1.end());
cout << s1 << endl;
return 0;
}
v.resize(len1 + 1);
for (int i = 0; i < len1; i++) a[i + 1] = s1[i] - '0';
for (int i = 0; i < len2; i++) b[i + 1] = s2[i] - '0';
for (int i = 1; i <= len1; i++) bo[a[i]]++;
bool haved = 0;
for (int i = 0; i < len1; i++) {
for (int j = 9; j >= 0; j--)
if (bo[j]) {
int k = s2[i] - '0';
if (j <= k || haved) {
bo[j]--;
vans.push_back(j);
if (get_ans()) {
if (j < k) haved = 1;
break;
}
vans.pop_back();
bo[j]++;
}
}
}
for (int i = 0; i < (int)vans.size(); i++) cout << vans[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
long long int mp[10];
long long int x[20];
bool solve(long long int idx, bool isSmall) {
if (idx == b.size()) {
return true;
}
long long int start = b[idx] - '0';
if (isSmall) start = 9;
for (long long int j = start; j >= 0; j--) {
if (mp[j] > 0) {
mp[j]--;
x[idx] = j;
bool flag = false;
if (isSmall) flag = true;
if (j < start) flag = true;
bool temp = solve(idx + 1, flag);
if (temp) return true;
mp[j]++;
}
}
return false;
}
int main() {
cin >> a >> b;
if (b.size() > a.size()) {
sort(a.rbegin(), a.rend());
cout << a << endl;
return 0;
} else {
for (long long int i = 0; i < a.size(); i++) {
mp[a[i] - '0']++;
}
solve(0, false);
for (long long int i = 0; i < b.size(); i++) {
cout << x[i];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
long double x, y;
point() {
x = 0;
y = 0;
}
point(long long a, long long b) {
x = a;
y = b;
}
bool operator==(const point& b) { return x == b.x and y == b.y; }
bool operator>(const point& b) {
if (x > b.x) return true;
if (x < b.x) return false;
if (x == b.x) {
if (y < b.y) return false;
if (y > b.y) return true;
return true;
}
}
bool operator<(point& b) { return (b > point(x, y)); }
point(long double x1, long double y1) {
x = x1;
y = y1;
}
long double dist(point b) {
return sqrt((b.x - x) * (b.x - x) + (y - b.y) * (y - b.y));
}
long double dist_kv(point b) {
return ((b.x - x) * (b.x - x) + (y - b.y) * (y - b.y));
}
bool point_on_sig(point& a, point& b) {
return abs(a.dist(b) - (dist(a) + dist(b))) <= 1e-6;
}
long double polar_angle() {
long double alpha = atan2(y, x);
long double pi = 3.141592654;
if (alpha < 0) alpha += 2 * pi;
return alpha;
}
};
struct line {
long double A, B, C;
line() {
A = 0;
B = 0;
C = 0;
}
line(point& a, point& b) {
A = a.y - b.y;
B = b.x - a.x;
C = -A * a.x - B * a.y;
}
line(long double a, long double b, long double c) {
A = a;
B = b;
C = c;
}
line line_perp_dan_cherez_point(point a) {
return line(-B, A, -(A * a.y) + B * a.x);
}
bool onli(point a) { return A * a.x + B * a.y + C == 0; }
point intersect_lines(line& a) {
point p;
p.x = -(((C * a.B) - (a.C * B)) / ((A * a.B) - (a.A * B)));
p.y = -(((A * a.C) - (a.A * C)) / ((A * a.B) - (a.A * B)));
return p;
}
bool intersect(line& b) { return A * b.B - B * b.A != 0; }
bool operator==(line& a) { return A == a.A && B == a.B && C == a.C; }
long double distance_perpendicular(point& d) {
return abs(A * d.x + B * d.y + C) / (sqrt(A * A + B * B));
}
};
long long INF = (long long)1e20;
struct node {
long long x, y, sz;
node* l;
node* r;
node(long long xx, long long yy) {
x = xx;
sz = 1;
y = yy;
l = nullptr;
r = nullptr;
}
};
long long sz(node* r) { return (r != nullptr) ? r->sz : 0; }
void upd_sz(node* r) {
if (r != nullptr) r->sz = 1 + sz(r->l) + sz(r->r);
}
node* merge(node* a, node* b) {
if (a == nullptr) {
upd_sz(a);
return b;
}
if (b == nullptr) {
upd_sz(a);
return a;
}
if (a->y > b->y) {
node* x = merge(a->r, b);
a->r = x;
upd_sz(a);
return a;
}
node* x = merge(a, b->l);
b->l = x;
upd_sz(b);
return b;
}
pair<node*, node*> split(node* r, long long x) {
if (r == nullptr) {
return {nullptr, nullptr};
}
if (sz(r->l) >= x) {
auto p = split(r->l, x);
r->l = p.second;
upd_sz(r);
upd_sz(p.first);
return {p.first, r};
}
if (sz(r->l) + 1 == x) {
auto p = r->r;
r->r = nullptr;
upd_sz(r);
upd_sz(p);
return {r, p};
}
auto p = split(r->r, x - sz(r->l) - 1);
r->r = p.first;
upd_sz(r);
upd_sz(p.second);
return {r, p.second};
}
void print_kurevo(node* r) {
if (r == nullptr) return;
print_kurevo(r->l);
cout << r->x << ' ';
print_kurevo(r->r);
}
void print_kurevo1(node* r) {
if (r == nullptr) return;
cout << "START " << r->x << '\n';
print_kurevo1(r->l);
print_kurevo1(r->r);
cout << "END " << r->x << '\n';
}
int main() {
string a, b;
cin >> a >> b;
if (b.size() > a.size()) {
sort(a.rbegin(), a.rend());
cout << a;
return 0;
}
multiset<char> ms;
for (auto i : a) ms.insert(i);
string ans;
long long can = -1;
string thens;
multiset<char> thenm;
bool built = true;
for (int i = 0; i < b.size(); ++i) {
char mm = 'K';
for (auto j : ms) {
if (j <= b[i]) mm = j;
}
if (mm == 'K') {
mm = 'K';
for (auto j : thenm) {
if (j < b[can]) mm = j;
}
thens += mm;
thenm.erase(thenm.find(mm));
cout << thens;
string aaa;
for (auto j : thenm) {
aaa += j;
}
sort(aaa.rbegin(), aaa.rend());
cout << aaa;
return 0;
}
if (mm > (*ms.begin())) {
can = i;
thens = ans;
thenm = ms;
}
ans += mm;
ms.erase(ms.find(mm));
if (mm < b[i]) {
cout << ans;
string aaa;
for (auto j : ms) {
aaa += j;
}
sort(aaa.rbegin(), aaa.rend());
cout << aaa;
return 0;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
char s[N], str[N];
int a[10], beixuan[N], print[N];
void printend(int *a) {
for (int i = 9; i >= 0; i--) {
while (a[i]) {
a[i]--;
printf("%d", i);
}
}
exit(0);
}
void printstart(int i, int *print) {
for (int j = 0; j <= i; j++) printf("%d", print[j]);
}
bool same(char *s, char *str) {
int lens = strlen(s), lenstr = strlen(str);
if (lens != lenstr) return false;
for (int i = 0; i < lens; i++)
if (s[i] != str[i]) return false;
return true;
}
void theend(int fail) {
int stop;
for (int i = fail - 1; i >= 0; i--) {
if (beixuan[i] != -1) {
stop = i;
a[print[i]]++;
print[i] = beixuan[i];
a[beixuan[i]]--;
break;
} else
a[print[i]]++;
}
printstart(stop, print);
printend(a);
}
int main() {
scanf("%s", s);
scanf("%s", str);
int len = strlen(s);
for (int i = 0; i < len; i++) a[int(s[i] - '0')]++;
memset(beixuan, -1, sizeof(beixuan));
if (same(s, str)) {
printf("%s", str);
return 0;
}
if (strlen(s) != strlen(str)) {
printend(a);
}
len = strlen(str);
for (int i = 0; i < len; i++) {
int pos = str[i] - '0';
bool first = false, stop = false;
;
for (int j = pos; j >= 0; j--) {
if (a[j] == 0) continue;
if (first) {
beixuan[i] = j;
break;
}
first = true;
a[j]--;
if (!stop && j != pos) stop = !stop;
print[i] = j;
}
if (stop) {
printstart(i, print);
printend(a);
}
if (!first) theend(i);
}
printstart(len - 1, print);
printend(a);
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int la, lb;
int bi[20];
int cnt[10], cnti[10];
int ai[20];
int ans[20];
bool f = false;
void dfs(int id) {
if (f) return;
if (id > la) {
int i = 1;
while (ai[i] == bi[i] && i <= la) i++;
if (ai[i] < bi[i] || i == la + 1) f = true;
return;
}
int i = 1;
while (ai[i] == bi[i] && i <= id) i++;
if (ai[i] > bi[i]) return;
for (int i = 9; i >= 0; i--) {
if (f) return;
if (id == 1 && i == 0) return;
if (cnti[i]) {
ai[id] = i;
cnti[i]--;
dfs(id + 1);
cnti[i]++;
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> a >> b;
la = a.size();
lb = b.size();
for (int i = 0; i < lb; i++) bi[i + 1] = b[i] - '0';
for (int i = 0; i < la; i++) cnt[a[i] - '0']++;
if (la < lb) {
for (int i = 9; i >= 0; i--)
while (cnt[i]) {
cout << i;
cnt[i]--;
}
} else {
for (int i = 0; i <= 9; i++) cnti[i] = cnt[i];
dfs(1);
for (int i = 1; i <= la; i++) cout << ai[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string sa, sb, ret;
int cnt[10];
bool dfs(int i, string cur, bool bound) {
if (i == sa.size()) {
if (cur <= sb) {
ret = cur;
return true;
}
return false;
}
int j = 9;
if (bound) j = sb[i] - '0';
for (; j >= 0; j--) {
if (cnt[j] == 0) continue;
cnt[j]--;
cur.push_back(j + '0');
if (dfs(i + 1, cur, bound && (j == sb[i] - '0'))) {
return true;
}
cnt[j]++;
cur.pop_back();
}
return false;
}
int main() {
long long a, b;
cin >> a >> b;
sa = to_string(a);
sb = to_string(b);
if (sa.size() < sb.size()) {
sort(sa.begin(), sa.end(), greater<char>());
cout << sa << endl;
return 0;
}
for (char c : sa) {
cnt[c - '0']++;
}
dfs(0, "", true);
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long int INF = 1e18;
const int N = 100005;
const int MOD = 1e9 + 7;
const double EPS = 1e-6;
const double PI = acos(-1.0);
long long int a, b;
long long int cnt[20] = {0};
long long int ans = 0;
void solve() {
for (int i = 9; i >= 0; i--) {
if (cnt[i] >= 1) {
cnt[i]--;
long long int temp = ans * 10 + i;
for (int j = 0; j <= 9; j++) {
for (int k = 1; k <= cnt[j]; k++) {
temp = temp * 10 + j;
}
}
if (temp <= b) {
ans = ans * 10 + i;
solve();
} else
cnt[i]++;
}
}
}
int main(int argc, char const *argv[]) {
cin >> a >> b;
while (a) {
cnt[a % 10]++;
a /= 10;
}
solve();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s1, s2;
cin >> s1 >> s2;
int l1 = s1.length(), l2 = s2.length();
sort(s1.begin(), s1.end());
reverse(s1.begin(), s1.end());
if (l2 > l1) {
cout << s1 << endl;
return 0;
}
bool rollback = false;
int iChar = -1;
while (++iChar < l1) {
if (s1[iChar] < s2[iChar]) break;
if (s1[iChar] == s2[iChar] && (!rollback)) continue;
int iBest = -1, vBest = -1;
for (int iRepl = iChar + 1; iRepl < l1; ++iRepl) {
if (s1[iRepl] > s2[iChar]) continue;
if (rollback && s1[iRepl] == s2[iChar]) continue;
if (s1[iRepl] - '0' >= vBest) {
iBest = iRepl;
vBest = s1[iRepl] - '0';
}
}
if (iBest == -1) {
rollback = true;
iChar -= 2;
continue;
}
swap(s1[iChar], s1[iBest]);
sort(s1.begin() + iChar + 1, s1.end());
reverse(s1.begin() + iChar + 1, s1.end());
if (s1[iChar] < s2[iChar]) break;
}
cout << s1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int cnt[10];
void ans() {
for (int i = 9; i >= 0; i--) {
while (cnt[i]) {
cout << i;
cnt[i]--;
}
}
}
vector<int> ss;
int an(int pos) {
if (pos == b.size()) return 1;
for (int i = 9; i >= 0; i--) {
if (i <= (b[pos] - '0') && cnt[i]) {
ss.push_back(i);
cnt[i]--;
if (i == b[pos] - '0') {
if (an(pos + 1) == 0) {
cnt[i]++;
ss.pop_back();
continue;
}
}
return 1;
}
}
return 0;
}
int main() {
cin >> a >> b;
int len = a.size();
for (int i = 0; i < len; i++) {
cnt[a[i] - '0']++;
}
if (a.size() < b.size()) {
ans();
} else {
an(0);
for (int i = 0; i < ss.size(); i++) cout << ss[i];
ans();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
string s1, s2;
int len1, len2;
int bo[N], a[N], b[N];
vector<int> v, vans;
bool get_ans() {
for (int i = 0; i < (int)vans.size(); i++) v[i + 1] = vans[i];
int nn = (int)vans.size();
for (int i = 0; i <= 9; i++)
for (int j = 1; j <= bo[i]; j++) v[++nn] = i;
for (int i = 1; i <= len1; i++)
if (v[i] != b[i] && v[i] > b[i])
return false;
else if (v[i] != b[i] && v[i] < b[i])
return true;
return true;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> s1 >> s2;
len1 = s1.size(), len2 = s2.size();
if (len1 < len2) {
sort(s1.begin(), s1.end());
reverse(s1.begin(), s1.end());
cout << s1 << endl;
return 0;
}
v.resize(len1 + 1);
for (int i = 0; i < len1; i++) a[i + 1] = s1[i] - '0';
for (int i = 0; i < len2; i++) b[i + 1] = s2[i] - '0';
for (int i = 1; i <= len1; i++) bo[a[i]]++;
bool haved = 0;
for (int i = 0; i < len1; i++) {
for (int j = 9; j >= 0; j--)
if (bo[j]) {
int k = s2[i] - '0';
if (j <= k || haved) {
bo[j]--;
vans.push_back(j);
if (get_ans()) {
if (j < k) haved = 1;
break;
}
vans.pop_back();
bo[j]++;
}
}
}
for (int i = 0; i < (int)vans.size(); i++) cout << vans[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, i, j, k;
string A, B;
bool ok[25];
char c[25];
bool Check(int i, int j) {
string s, sir;
int cnt;
if (i == N - 1) return true;
for (cnt = i + 1; cnt < N; cnt++) s += B[cnt];
for (cnt = 1; cnt <= M; cnt++)
if (ok[cnt] == false && cnt != j) sir += c[cnt];
sort(sir.begin(), sir.end());
return sir <= s;
}
int main() {
cin >> A >> B;
N = A.size();
for (i = 0; i < N; i++) c[++M] = A[i];
sort(c + 1, c + M + 1);
if (A.size() < B.size()) {
for (j = M; j >= 1; j--) cout << c[j];
return 0;
}
for (i = 0; i < N; i++) {
for (j = M; j >= 1; j--) {
if (c[j] > B[i]) continue;
if (c[j] == B[i] && ok[j] == false && Check(i, j) == true) {
ok[j] = true;
cout << c[j];
break;
}
if (c[j] < B[i] && ok[j] == false) {
cout << c[j];
ok[j] = true;
for (k = M; k >= 1; k--) {
if (ok[k] == false) cout << c[k];
}
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1ll << 60;
const double Inf = 1e20;
const double eps = 1e-9;
void gmax(int &a, int b) { a = (a > b ? a : b); }
void gmin(int &a, int b) { a = (a < b ? a : b); }
const int maxn = 20;
char a[maxn], b[maxn];
int na[maxn], nb[maxn], sa, sb;
bool used[maxn];
int main() {
scanf("%s%s", a + 1, b + 1);
sa = strlen(a + 1);
sb = strlen(b + 1);
for (int i = 1; i <= sa; ++i) na[i] = a[i] - '0';
for (int i = 1; i <= sb; ++i) nb[i] = b[i] - '0';
if (sa < sb) {
sort(na + 1, na + sa + 1);
for (int i = sa; i >= 1; --i) printf("%d", na[i]);
puts("");
return 0;
}
bool p = true;
na[0] = -1;
for (int i = 1; i <= sb; ++i) {
int mx = 0;
for (int j = 1; j <= sa; ++j)
if (!used[j]) {
vector<int> tmp;
if ((p && na[j] <= nb[i]) || !p) {
if (p && na[j] == nb[i]) {
tmp.clear();
for (int k = 1; k <= sa; ++k)
if (!used[k] && k != j) tmp.push_back(na[k]);
sort(tmp.begin(), tmp.end());
int poi = i + 1;
bool gg = false;
for (auto v : tmp)
if (v < nb[poi])
break;
else if (v == nb[poi])
++poi;
else {
gg = true;
break;
}
if (!gg && na[j] > na[mx]) mx = j;
} else if (na[j] > na[mx])
mx = j;
}
}
if (na[mx] == nb[i])
p = p & true;
else
p = false;
used[mx] = true;
printf("%d", na[mx]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, bx, res;
int digA, digB;
int n[10];
bool found = false;
void f(long long x, int d) {
if (d == digA) {
if (x <= b) {
found = true;
res = x;
}
return;
}
b *= 10;
b += bx % 10;
bx /= 10;
for (int i = 9; i >= 0; i--) {
if (n[i] > 0 && x * 10 + i <= b) {
n[i]--;
f(x * 10 + i, d + 1);
if (found) return;
n[i]++;
}
}
bx *= 10;
bx += b % 10;
b /= 10;
}
int main() {
cin >> a >> b;
for (int i = 0; i < 10; i++) n[i] = 0;
while (a > 0) {
n[a % 10]++;
a /= 10;
digA++;
}
bx = b;
while (bx > 0) {
bx /= 10;
digB++;
}
if (digA < digB) {
b = 0;
for (int i = 0; i < digA; i++) {
b *= 10, b += 9;
}
bx = b;
b = 0;
} else {
while (b > 0) {
bx *= 10;
bx += b % 10;
b /= 10;
}
}
f(0, 0);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20], ans[20];
int vis[10];
int n, m;
int cut;
void dfs(int x, int falg) {
if (x == n) {
cut = 1;
return;
}
for (int i = 9; i >= 0; --i) {
if (vis[i]) {
if (falg || b[x] - '0' == i) {
ans[x] = i + '0';
vis[i]--;
dfs(x + 1, falg);
if (cut) return;
vis[i]++;
} else if (i < b[x] - '0') {
ans[x] = i + '0';
vis[i]--;
dfs(x + 1, 1);
if (cut) return;
vis[i]++;
}
}
}
}
int main() {
scanf("%s", a);
scanf("%s", b);
n = strlen(a);
m = strlen(b);
if (m > n) {
sort(a, a + n);
for (int i = n - 1; i >= 0; --i) {
printf("%c", a[i]);
}
} else {
for (int i = 0; i < n; ++i) {
vis[a[i] - '0']++;
}
cut = 0;
dfs(0, 0);
printf("%s", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
sort(a.begin(), a.end());
for (int i = 0; i < a.length(); i++) {
for (int j = i + 1; j < a.length(); j++) {
string t = a;
swap(t[i], t[j]);
if (stoll(t) > stoll(a) && stoll(t) <= stoll(b)) a = t;
}
}
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[20];
char s2[20];
int vis[15];
long long ans;
bool flag;
bool cmp(char a, char b) { return a > b; }
long long toll(char a[]) {
long long result = 0;
int l = strlen(a);
for (int i = 0; i < l; i++) {
result = result * 10 + a[i] - '0';
}
return result;
}
void dfs(int n, char a[], long long num2) {
if (n == strlen(a)) {
long long temp = toll(a);
if (temp <= num2) {
ans = max(ans, temp);
return;
}
return;
} else {
for (int i = 9; i >= 0; i--) {
if (vis[i] > 0) {
a[n] = i + '0';
vis[i]--;
if (a[n] < s2[n]) {
for (int i = 9; i >= 0; i--) {
while (vis[i]) {
a[++n] = i + '0';
vis[i]--;
}
}
long long temp = toll(a);
if (temp <= num2) {
ans = max(ans, temp);
}
return;
} else if (a[n] > s2[n]) {
vis[i]++;
continue;
}
dfs(n + 1, a, num2);
vis[i]++;
}
}
return;
}
return;
}
int main() {
while (~scanf("%s", s1)) {
scanf("%s", s2);
memset(vis, 0, sizeof(vis));
ans = -1;
memset(vis, 0, sizeof(vis));
int l1 = strlen(s1);
int l2 = strlen(s2);
sort(s1, s1 + l1, cmp);
if (l2 > l1) {
printf("%s\n", s1);
} else {
for (int i = 0; i < l2; i++) {
vis[s1[i] - '0']++;
}
char t[20];
strcpy(t, s2);
dfs(0, t, toll(s2));
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct $ {
$() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(9);
}
} $;
string s, t;
bool canForm(int i) {
sort(s.begin() + i, s.end());
if (i == 0) {
return s.substr(i, s.size() - i) <= t.substr(i, s.size() - i);
}
if (s.substr(0, i) > t.substr(0, i)) return false;
if (s.substr(0, i) < t.substr(0, i)) return true;
return s.substr(i, s.size() - i) <= t.substr(i, s.size() - i);
}
int main() {
cin >> s >> t;
if (t.size() > s.size()) {
sort(s.rbegin(), s.rend());
cout << s << endl;
} else {
sort(s.rbegin(), s.rend());
for (int i = 0; i < s.size(); i++) {
for (int j = i; j < s.size(); j++) {
sort(s.begin() + i, s.end(), [](char a, char b) { return a > b; });
swap(s[i], s[j]);
if (canForm(i + 1)) {
break;
}
}
}
cout << s.substr(0, s.size()) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(string a, string b) {
string s;
vector<long long> freq(10, 0);
for (long long i = 0; i < a.size(); i++) freq[a[i] - '0']++;
long long flag = 1;
for (long long i = 0; i < b.size(); i++) {
long long change = 0;
for (long long j = 9; j >= 0; j--) {
if (freq[j] > 0 && j <= b[i] - '0' && flag) {
change = 1;
s += j + '0';
freq[j]--;
if (s[i] < b[i]) flag = 0;
break;
}
}
if (change == 0) break;
}
long long flagg = 1, pos;
flag = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == b[i])
continue;
else if (s[i] < b[i]) {
flag = 1;
flagg = 0;
break;
}
}
if (flag == 1) {
for (long long j = 9; j >= 0; j--) {
while (freq[j] > 0) {
s += j + '0';
freq[j]--;
}
}
}
if (s.size() == a.size()) {
cout << s << '\n';
return;
}
if (flagg == 1) {
long long check = 0;
long long pos = s.size() - 1;
for (long long j = pos; j >= 0; j--) {
check = 0;
for (long long i = 9; i >= 0; i--) {
if (freq[i] > 0 && i < b[j] - '0') {
freq[i]--;
freq[s[j] - '0']++;
s[j] = i + '0';
check = 1;
pos = j;
break;
}
}
if (check == 1)
break;
else
freq[s[j] - '0']++;
}
string ans;
for (long long i = 0; i <= pos; i++) ans += s[i];
for (long long j = 9; j >= 0; j--) {
while (freq[j] > 0) {
ans += j + '0';
freq[j]--;
}
}
s = ans;
}
cout << s;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string a, b;
cin >> a >> b;
if (a.size() < b.size()) {
sort(a.begin(), a.end(), greater<char>());
cout << a << '\n';
} else {
solve(a, b);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.