text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long arr = 5e5 + 100;
const long long md = 1e9 + 7;
const long long base = 1e9 + 7;
long long cnt[100];
string getmax() {
string res = "";
for (long long i = 0; i <= 9; i++) {
long long c = cnt[i];
while (c--) {
res += i + '0';
}
}
return (res);
}
bool ok(string st1, string st2) {
if (st1.size() < st2.size())
return (1);
else
return (st1 <= st2);
}
signed main() {
string a, b;
cin >> a >> b;
for (long long i = 0; i < a.size(); i++) cnt[a[i] - '0']++;
string ans = "";
for (long long i = 0; i < a.size(); i++) {
char mx = '0';
for (long long j = 0; j < 10; j++)
if (cnt[j] != 0) {
cnt[j]--;
string now = ans;
now += char(j + '0');
now += getmax();
if (ok(now, b)) mx = j + '0';
cnt[j]++;
}
cnt[mx - '0']--;
ans += mx;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
multiset<int> s;
string a, b, res;
void op(string &res) {
int id = res.size();
for (int i = 0; i < res.size(); i++)
if (res[i] != '0') {
id = i;
break;
}
res = res.substr(id, res.size() - id);
}
string check(multiset<int> s, int x) {
string st = "";
bool ok = 0;
for (auto it = s.begin(); it != s.end(); it++) {
if (*it == x && !ok)
ok = 1;
else
st += (*it + '0');
}
return st;
}
void print(multiset<int> s) {
string rs = "";
for (auto it = s.begin(); it != s.end(); it++) rs += char(*it + '0');
reverse(rs.begin(), rs.end());
res = res + rs;
op(res);
cout << res << "\n";
exit(0);
}
int get_res(int x) {
auto it = s.lower_bound(b[x] - '0');
if (it == s.end()) it = s.find(*s.rbegin());
if (*it > b[x] - '0' && it != s.begin()) it--;
return *it;
}
int main() {
cin >> a >> b;
for (int i = 0; i < a.size(); i++) s.insert(a[i] - '0');
if (a.size() < b.size()) print(s);
for (int i = 0; i < b.size(); i++) {
int cur_res = get_res(i);
if (cur_res < b[i] - '0') {
res += char(cur_res + '0');
s.erase(s.find(cur_res));
print(s);
} else {
if (check(s, cur_res) > b.substr(i + 1, b.size() - i - 1)) {
auto it = s.find(cur_res);
while (*it == cur_res) it--;
cur_res = *it;
res += char(cur_res + '0');
s.erase(s.find(cur_res));
print(s);
}
res += char(cur_res + '0');
}
s.erase(s.find(cur_res));
}
op(res);
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20];
int cnt[20];
int na, nb;
long long dfs(int pos, int zt, long long ans) {
if (pos == na) return ans;
for (int i = 9; i >= 0; i--)
if (cnt[i])
if (zt == 0 || i <= b[pos] - '0') {
cnt[i]--;
long long _ans = dfs(pos + 1, zt && i == b[pos] - '0', ans * 10 + i);
if (_ans != -1) return _ans;
cnt[i]++;
}
return -1;
}
int cmp(char a, char b) { return a > b; }
int main() {
scanf("%s%s", a, b);
na = strlen(a), nb = strlen(b);
if (na < nb) {
sort(a, a + na, cmp);
printf("%s\n", a);
return 0;
}
for (int i = (0); i < (na); i++) cnt[a[i] - '0']++;
printf("%lld\n", dfs(0, 1, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
void solve() {
long long a, b;
cin >> a >> b;
map<char, long long> mp;
string s = to_string(a);
string t = to_string(b);
for (long long i = 0; i < s.size(); i++) mp[s[i]]++;
if (t.size() > s.size()) {
sort(s.rbegin(), s.rend());
cout << s << "\n";
return;
}
string now;
for (long long i = 0; i < t.size(); i++) {
if (mp[t[i]]) {
mp[t[i]]--;
now.push_back(t[i]);
} else {
long long flag = 0;
for (long long j = t[i] - '0' - 1; j >= 0; j--) {
if (mp[j + '0']) {
flag = 1;
now.push_back('0' + j);
mp[j + '0']--;
string bache;
for (auto x : mp) {
long long p = x.second;
while (p--) bache.push_back(x.first);
}
sort(bache.rbegin(), bache.rend());
now += bache;
cout << now << "\n";
return;
}
}
if (!flag) {
while (now.size()) {
char cur = now.back();
mp[cur]++;
now.pop_back();
for (long long j = cur - '0' - 1; j >= 0; j--) {
if (mp[j + '0']) {
mp[j + '0']--;
now.push_back('0' + j);
string bache;
for (auto x : mp) {
long long p = x.second;
while (p--) bache.push_back(x.first);
}
sort(bache.rbegin(), bache.rend());
now += bache;
cout << now << "\n";
return;
}
}
}
}
}
}
cout << now << "\n";
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
int kolko[10] = {};
cin >> a >> b;
if (b.size() > a.size()) {
sort(a.begin(), a.end());
for (int i = a.size() - 1; i >= 0; i--) cout << a[i];
return 0;
}
for (int i = 0; i < a.size(); i++) kolko[a[i] - '0']++;
string sol = "";
for (int uzeo = 0; uzeo < a.size(); uzeo++) {
for (int i = 9; i >= 0; i--) {
if (kolko[i] == 0) continue;
string pom = "";
int pomKolko[10];
pom += char('0' + i);
for (int j = 0; j < 10; j++) pomKolko[j] = kolko[j];
pomKolko[i]--;
for (int j = 0; j < 10; j++)
while (pomKolko[j]) {
pom += char('0' + j);
pomKolko[j]--;
}
pom = sol + pom;
if (pom <= b) {
sol += char('0' + i);
kolko[i]--;
break;
}
}
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int a[300005], b[300005];
int la, lb;
int cnt[10];
void printCnt() {
for (int j = 9; j >= 0; j--) {
for (int i = 1; i <= cnt[j]; i++) cout << char('0' + j);
}
}
int top = 0;
bool chk(int id, int k) {
if (k < b[id]) return 1;
top = 0;
for (int j = 0; j < 10; j++) {
for (int i = 1; i <= cnt[j]; i++) {
++top;
if (j > b[id + top]) return 0;
if (j < b[id + top]) return 1;
}
}
return 1;
}
int main() {
cin >> s1 >> s2;
la = s1.length();
lb = s2.length();
for (int i = 0; i < la; i++) a[i] = s1[i] - '0';
for (int i = 0; i < lb; i++) b[i] = s2[i] - '0';
if (la < lb) {
sort(a, a + la);
for (int i = la - 1; i >= 0; i--) cout << a[i];
return 0;
}
for (int i = 0; i < la; i++) ++cnt[a[i]];
for (int i = 0; i < la; i++) {
for (int j = 9; j >= 0; j--) {
if (cnt[j] && j <= b[i]) {
--cnt[j];
if (chk(i, j)) {
cout << char(j + '0');
if (j < b[i]) {
printCnt();
return 0;
}
break;
}
++cnt[j];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long int>;
using vvi = vector<vi>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vld = vector<long double>;
using pii = pair<long long int, long long int>;
using psi = pair<string, long long int>;
using pci = pair<char, long long int>;
using vpii = vector<pii>;
long long int mod = 1e9 + 7;
long long int const maxn = 1e5 + 5;
long long int const inf = 1e18;
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int powm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int modinverse(long long int a, long long int m) {
return powm(a, m - 2, m);
}
bool prime(long long int x) {
if (x <= 1) return false;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) return false;
return true;
}
long long int divisor(long long int x) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(x); i++) {
if (x % i == 0) {
if (i != x / i)
cnt += 2;
else
cnt += 1;
}
}
return cnt;
}
vector<long long int> sieve(long long int n) {
bool prim[n + 1];
memset(prim, true, sizeof(prim));
for (long long int p = 2; p * p <= n; p++) {
if (prim[p] == true) {
for (int i = p * p; i <= n; i += p) prim[i] = false;
}
}
vector<long long int> v;
for (int i = 2; i <= n; i++)
if (prim[i]) v.push_back(i);
return v;
}
void solve() {
string a, b;
cin >> a >> b;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
if ((long long int)a.size() < (long long int)b.size()) {
cout << a;
return;
}
vi freq(10, 0);
for (auto i : a) freq[i - '0']++;
for (auto i : b) {
freq[i - '0']--;
}
bool f = true;
for (int i = 0; i <= 9; i++) {
if (freq[i] < 0) f = false;
}
if (f) {
cout << b;
return;
}
long long int n = (long long int)b.size();
for (int i = n - 1; i >= 0; i--) {
vi freq(10, 0);
for (auto i : a) freq[i - '0']++;
string x = "";
bool f = true;
for (int j = 0; j < i; j++) {
if (freq[b[j] - '0'] == 0) {
f = false;
break;
}
x += b[j];
freq[b[j] - '0']--;
}
for (auto j : x) {
if (j == '0') {
f = false;
break;
} else
break;
}
if (!f) continue;
f = false;
for (int j = (b[i] - '0') - 1; j >= 0; j--) {
if (freq[j]) {
f = true;
x += (j + '0');
freq[j]--;
break;
}
}
if (!f) continue;
string p = "";
for (int j = 0; j <= 9; j++) {
for (int k = 1; k <= freq[j]; k++) p += (j + '0');
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
long long int rem_l = (long long int)b.size() - (long long int)x.size();
for (int j = 0; j < rem_l; j++) x += p[j];
cout << x << "\n";
return;
}
}
int main() {
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
string a, b;
int main() {
cin >> a >> b;
int n = a.length();
if (n < b.length()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << '\n';
} else {
sort(a.begin(), a.end());
for (int i = 0; i < (n); i++) {
int j = i;
for (; j < n && a.substr(0, i) + string(1, a[j]) + a.substr(i, j - i) +
a.substr(j + 1) <=
b;
j++)
;
j--;
a = a.substr(0, i) + string(1, a[j]) + a.substr(i, j - i) +
a.substr(j + 1);
}
cout << a << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[26];
int c[26];
set<string> vis;
bool cmp(string a, string b) {
long long aa = 0;
for (int i = 0; i < a.size(); i++) {
aa = 10 * aa + a[i] - '0';
}
long long bb = 0;
for (int i = 0; i < b.size(); i++) {
bb = 10 * bb + b[i] - '0';
}
return aa <= bb;
}
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++) cnt[a[i] - '0']++;
string ans = "";
for (int j = 0; j < a.size(); j++) {
bool found = false;
for (int m = 9; m >= 0; m--) {
if (cnt[m] != 0) {
char maxchar = m + '0';
string minstr = "";
for (int i = 0; i <= 9; i++) {
if (maxchar == i + '0') {
for (int j = 1; j < cnt[i]; j++) minstr += i + '0';
} else {
for (int j = 0; j < cnt[i]; j++) minstr += i + '0';
}
}
if (cmp(ans + maxchar + minstr, b)) {
ans += maxchar;
cnt[maxchar - '0']--;
found = true;
}
}
if (found) break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 18) + 100;
int mem[3][N];
char a[20], b[20], aa, bb;
string ans;
int dp(int ok, int mask) {
if (mask == 0) {
return 1;
}
int &ret = mem[ok][mask];
if (ret != -1) {
return ret;
}
ret = 0;
int ind = 0;
for (long long i = 0; i <= aa - 1; i++) {
ind += (!(mask & (1 << i)));
}
for (int i = 0; i < aa; i++) {
if (mask & (1 << i)) {
if (!ok && a[i] > b[ind]) {
continue;
}
int mask_ = mask - (1 << i);
int ok_ = ok || (a[i] < b[ind]);
ret = ret || (dp(ok_, mask_));
if (ret == 1) {
ans = a[i] + ans;
return ret;
}
}
}
return ret;
}
void print(int ok, int mask) {
if (mask == 0) {
return;
}
int ret = mem[ok][mask];
int ind = 0;
for (long long i = 0; i <= aa - 1; i++) {
ind += (!(mask & (1 << i)));
}
for (int i = 0; i < aa; i++) {
if (mask & (1 << i)) {
if (!ok && a[i] > b[ind]) {
continue;
}
int mask_ = mask - (1 << i);
int ok_ = ok || (a[i] < b[ind]);
int tmp = (dp(ok_, mask_));
if (ret == tmp) {
printf("%d", (int)a[i] - '0');
print(ok_, mask_);
return;
}
}
}
return;
}
int main() {
memset(mem, -1, sizeof mem);
scanf(" %s", a);
scanf(" %s", b);
aa = strlen(a);
bb = strlen(b);
sort(a, a + aa, greater<char>());
if (aa < bb) {
printf("%s\n", a);
return 0;
}
dp(0, (1 << aa) - 1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long int const mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a, b;
cin >> a >> b;
sort(a.begin(), a.end());
for (long long int i = 0; i < a.length(); i++) {
for (long long 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 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 102;
string q1, q2;
long long cnt1[10] = {0};
string ans;
void dp(long long a1, long long flag) {
if (a1 == q1.size()) {
cout << ans << endl;
exit(0);
}
long long lim = 9;
if (!flag) lim = q2[a1] - '0';
for (long long i = lim; i >= 0; i--) {
if (cnt1[i]) {
ans += char(i + '0');
cnt1[i]--;
long long u1 = 1;
if (flag == 0 && (i == lim)) u1 = 0;
dp(a1 + 1, u1);
ans.pop_back();
cnt1[i]++;
}
}
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long inv(long long a) {
a %= 1000000007;
if (a < 0) a += 1000000007;
long long b = 1000000007, u = 0, v = 1;
while (a) {
long long t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0) u += 1000000007;
return u;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> q1 >> q2;
if (q1.size() < q2.size()) {
sort(q1.begin(), q1.end());
reverse(q1.begin(), q1.end());
cout << q1 << endl;
} else {
for (long long i = 0; i < q1.size(); i++) cnt1[q1[i] - '0']++;
dp(0, 0);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int I = 1e5 + 2;
const LL mod = 1e9 + 7, inf = 9e18;
int s[12];
inline bool comp(string a, string b) { return (a + b <= b + a); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string a, b;
cin >> a >> b;
string ans = "";
for (int i = 0; i < a.length(); ++i) {
s[int(a[i] - '0')]++;
}
if (a.length() < b.length()) {
for (int i = 9; i >= 0; i--) {
for (int j = 1; j <= s[i]; ++j) {
ans.push_back(char(i + '0'));
}
}
cout << ans << '\n';
return 0;
}
bool allow = false;
for (int i = 0; i < a.length(); ++i) {
if (allow == true) {
for (int i = 9; i >= 0; i--) {
for (int j = 1; j <= s[i]; ++j) {
ans.push_back(char(i + '0'));
}
}
cout << ans << '\n';
return 0;
}
string t = b.substr(i + 1, int(a.length()) - i);
if (i + 1 == a.length()) t = "";
int tt = int(b[i] - '0');
int limit = (allow ? 9 : tt);
bool poss = false;
for (int j = limit; j >= 0 and !poss; --j) {
if (!s[j]) continue;
s[j]--;
string tmp = "";
for (int k = 0; k <= 9; ++k) {
for (int c = 1; c <= s[k]; ++c) {
tmp += char(k + '0');
}
}
if ((j == tt and comp(tmp, t)) or j < tt) {
ans.push_back(char(j + '0'));
poss = true;
if (j < tt) allow = true;
}
if (poss == false) s[j]++;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
inline T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
string a, b, res, tmp;
long long dem[11];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
if (a.size() < b.size()) {
sort(a.begin(), a.end(), greater<char>());
cout << a;
return 0;
}
for (long long i = 0, _b = a.size(); i < _b; i++) {
dem[a[i] - '0']++;
}
for (long long i = 0, _b = a.size(); i < _b; i++) {
for (long long j = b[i] - 1 - '0', _b = 0; j >= _b; j--) {
if (dem[j]) {
dem[j]--;
string now = tmp + char(j + '0');
for (long long k = 9, _b = 0; k >= _b; k--)
for (long long ad = 0, _b = dem[k]; ad < _b; ad++) now += (k + '0');
res = max(res, now);
dem[j]++;
}
}
if (dem[b[i] - '0']) {
dem[b[i] - '0']--;
tmp += b[i];
if (tmp.size() == b.size() && tmp <= b) res = max(res, tmp);
} else
break;
}
cout << res;
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.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) <= stoll(b)) a = str;
}
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, cpy;
long long b, i, j, l;
int main() {
cin >> a >> b;
l = a.size();
sort(a.begin(), a.end());
for (i = 0; i < l; i++) {
for (j = i + 1; j < l; j++) {
cpy = a;
swap(cpy[i], cpy[j]);
sort(cpy.begin() + i + 1, cpy.end());
if (stoll(cpy) > stoll(a) && stoll(cpy) <= b) swap(a[i], a[j]);
}
}
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const double INF = 1e18;
const int mod = 1e9 + 7;
const int maxn = 20 + 5;
int cas = 1;
int vis[maxn];
long long int shu[maxn];
long long int a, b;
void dfs(int dep, long long int ans) {
if (dep <= 0) {
cout << ans << endl;
exit(0);
}
for (long long int i = 9; i >= 0; i--) {
if (vis[i] && ans + i * shu[dep] <= b) {
vis[i]--;
ans += i * shu[dep];
dfs(dep - 1, ans);
ans -= i * shu[dep];
vis[i]++;
}
}
}
void solve() {
cin >> a >> b;
if (a == b) {
cout << a << endl;
return;
}
int len = 0;
while (a) {
vis[a % 10]++;
a /= 10;
len++;
}
long long int rat = 1;
for (int i = 1; i <= len; i++) {
shu[i] = rat;
rat *= 10;
}
dfs(len, 0);
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
vector<int> vb, ans, ans2, tmp;
vector<pair<int, int> > va;
ans.clear();
ans2.clear();
tmp.clear();
int i, j, cnt = 0, x, mx, mxpos, fl;
cin >> a >> b;
for (i = 0; i < a.size(); i++) {
va.push_back(make_pair(a[i] - '0', 0));
tmp.push_back(0);
}
for (i = 0; i < b.size(); i++) vb.push_back(b[i] - '0');
sort(va.begin(), va.end());
if (a.size() == b.size()) {
for (i = 0; i < a.size(); i++) {
mxpos = -1;
x = vb[i];
mx = -1;
fl = 0;
ans2 = ans;
for (j = 0; j < a.size(); j++) {
if (va[j].first < x && va[j].second == 0) {
if (va[j].first > mx) {
mx = va[j].first;
mxpos = j;
}
}
}
if (mxpos != -1 && (mx != 0 || ans2.size() != 0)) {
ans2.push_back(mx);
for (j = a.size() - 1; j >= 0; j--)
if (va[j].second == 0 && j != mxpos) ans2.push_back(va[j].first);
for (j = 0; j < a.size(); j++) {
if (ans2[j] > tmp[j]) {
tmp = ans2;
break;
} else if (ans2[j] < tmp[j])
break;
}
}
for (j = 0; j < a.size(); j++) {
if (va[j].first == x && va[j].second == 0) {
va[j].second = 1;
fl = 1;
ans.push_back(va[j].first);
break;
}
}
if (fl == 0) break;
}
}
if (a.size() == b.size()) {
if (ans.size() == a.size()) tmp = ans;
for (i = 0; i < tmp.size(); i++) cout << tmp[i];
} else {
for (i = va.size() - 1; i >= 0; i--) cout << va[i].first;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = LLONG_MAX;
const int inf = INT_MAX;
const int nmax = 1e5 + 5;
const int mod = 1e9 + 7;
using namespace std;
long long a, b, pw = 1, pw1, cur, cur1, i, j, viz[21], tmp[21], l;
vector<long long> d;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> a >> b;
while (a) d.push_back(a % 10), a /= 10;
sort(d.begin(), d.end());
for (i = 0; i < d.size() - 1; i++) pw *= 10;
for (i = 0; i < d.size(); i++) {
for (j = d.size() - 1; j >= 0; j--)
if (!viz[j]) {
if (i != d.size() - 1) {
cur1 = d[j] * pw;
for (l = 0; l <= 20; l++) tmp[l] = 0;
tmp[j] = 1;
pw1 = pw / 10;
for (l = 0; l < d.size() && pw1; l++)
if (!viz[l] && !tmp[l]) cur1 += d[l] * pw1, tmp[l] = 1, pw1 /= 10;
if (cur + cur1 <= b) {
cur += d[j] * pw;
viz[j] = 1;
break;
}
} else {
if (cur + d[j] * pw <= b) {
cur += d[j] * pw;
viz[j] = 1;
break;
}
}
}
pw /= 10;
}
cout << cur << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a.size() < b.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a;
return 0;
}
sort(a.begin(), a.end());
for (int i = 0; i < a.length(); i++) {
for (int j = i + 1; j < a.length(); j++) {
if (a[i] < a[j]) swap(a[i], a[j]);
if (a > b) swap(a[i], a[j]);
}
}
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
while (cin >> a >> b) {
if (a.length() < b.length()) {
sort(a.begin(), a.end(), greater<char>());
cout << a << endl;
continue;
}
multiset<char> my(a.begin(), a.end());
if (my == multiset<char>(b.begin(), b.end())) {
cout << b << endl;
continue;
}
string prefix = "", ans = "";
for (int i = 0; i < (int)b.length(); i++) {
multiset<char>::iterator it = my.lower_bound(b[i]);
if (it != my.begin()) {
it--;
char x = (*it);
my.erase(it);
string suffix(my.begin(), my.end());
sort(suffix.begin(), suffix.end(), greater<char>());
ans = max(ans, prefix + x + suffix);
my.insert(x);
}
if (my.find(b[i]) != my.end()) {
prefix += b[i];
my.erase(my.find(b[i]));
} else
break;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9.2e18;
const int maxn = 2e5 + 70;
const int INF = 2.1e9;
const int maxm = 1e6 + 70;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
long long n, m, k, x, y;
vector<int> a, b;
bool vis[30];
long long solve(int p) {
long long m;
for (int i = a.size() - 1; i >= 0; i--) {
if (!vis[i]) {
m = a[i];
break;
}
}
long long ans;
if (m < b[p - 1]) {
ans = 0;
for (int i = a.size() - 1; i >= 0; i--) {
if (!vis[i]) {
ans *= 10;
ans += a[i];
}
}
return ans;
} else {
long long t;
for (int i = 0; i < a.size(); i++) {
if (!vis[i]) {
t = a[i];
break;
}
}
if (t > b[p - 1]) return -1;
for (int i = a.size() - 1; i >= 0; i--) {
if (!vis[i] && a[i] <= b[p - 1]) {
t = i;
m = a[i];
break;
}
}
if (m < b[p - 1]) {
vis[t] = 1;
ans = m;
for (int i = a.size() - 1; i >= 0; i--) {
if (!vis[i]) {
ans *= 10;
ans += a[i];
}
}
return ans;
} else {
if (p == 1)
return m;
else {
vis[t] = 1;
long long d = solve(p - 1);
vis[t] = 0;
if (d != -1) {
ans = m;
for (int i = 1; i < p; i++) ans *= 10;
ans += d;
return ans;
} else {
m = -1;
for (int i = a.size() - 1; i >= 0; i--) {
if (!vis[i] && a[i] < b[p - 1]) {
t = i;
m = a[i];
break;
}
}
if (m != -1) {
vis[t] = 1;
ans = m;
for (int i = a.size() - 1; i >= 0; i--) {
if (!vis[i]) {
ans *= 10;
ans += a[i];
}
}
return ans;
} else
return -1;
}
}
}
}
}
int main() {
while (cin >> x >> y) {
memset(vis, 0, sizeof(vis));
a.clear();
b.clear();
long long t = x;
while (t) {
a.push_back(t % 10);
t /= 10;
}
t = y;
while (t) {
b.push_back(t % 10);
t /= 10;
}
long long ans;
if (a.size() < b.size()) {
sort(a.begin(), a.end());
ans = 0;
for (int i = a.size() - 1; i >= 0; i--) {
ans *= 10;
ans += a[i];
}
} else {
sort(a.begin(), a.end());
ans = solve(a.size());
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string st1, st2, ans;
int tt[15], mmas[15];
void fin(int x) {
for (int i = x - 1; i >= 0; i--) {
if (tt[i]) {
tt[i]--;
ans += char(i + '0');
break;
}
}
for (int i = 9; i >= 0; i--) {
while (tt[i]--) {
ans += char(i + '0');
}
}
}
bool ccheck(int x) {
for (int i = 0; i <= 9; i++) {
mmas[i] = tt[i];
if (i == x) mmas[i]--;
}
string s = ans;
s += char(x + '0');
for (int i = 0; i <= 9; i++) {
while (mmas[i]--) {
s += char(i + '0');
}
}
return s <= st2;
}
int main() {
cin >> st1 >> st2;
for (int i = 0; i < (int)st1.size(); i++) {
int xx = st1[i] - '0';
tt[xx]++;
}
if ((int)st2.size() > (int)st1.size()) {
for (int i = 9; i >= 0; i--) {
while (tt[i]--) {
cout << i;
}
}
cout << endl;
return 0;
}
for (int i = 0; i < (int)st2.size(); i++) {
int xx = st2[i] - '0';
if (tt[xx]) {
if (ccheck(xx))
ans += st2[i];
else {
fin(xx);
break;
}
tt[xx]--;
} else {
fin(xx);
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int la, lb;
long long ans;
int num[10];
int flag1;
void find(string a, int la) {
memset(num, 0, sizeof(num));
for (int i = 0; i < la; i++) {
int te = a[i] - '0';
num[te]++;
}
}
bool cmp(char a, char b) { return a > b; }
void dfs(long long nu, int kk, int t) {
if (flag1) return;
if (kk == la) {
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 = b[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() {
cin >> a >> b;
la = a.length();
lb = b.length();
find(a, la);
if (lb > la) {
sort(a.begin(), a.end(), cmp);
cout << a;
return 0;
} else {
flag1 = 0;
dfs(0, 0, 0);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b;
sort(a.begin(), a.end());
if (a.length() < b.length()) {
reverse(a.begin(), a.end());
cout << a << endl;
} else {
for (int i = 0; i < a.length(); i++) {
for (int j = a.length() - 1; j > i; j--) {
c = a;
swap(a[i], a[j]);
sort(a.begin() + i + 1, a.end());
if (a > b) {
a = c;
} else
break;
}
}
cout << a << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
string a, b;
string calc(long long i, map<long long, long long> cnt) {
if (i == (long long)(b.size())) {
return "";
}
if (cnt[b[i] - '0']) {
cnt[b[i] - '0'] -= 1;
string ans = calc(i + 1, cnt);
if (ans != "-1") {
ans.insert(ans.begin(), b[i]);
return ans;
}
cnt[b[i] - '0'] += 1;
}
for (long long j = b[i] - '0' - 1; j >= 0; j--) {
if (cnt[j]) {
string ans = "";
ans += (j + '0');
cnt[j] -= 1;
for (long long k = 9; k >= 0; k--) {
while (cnt[k]--) {
ans += (k + '0');
}
}
return ans;
}
}
return "-1";
}
void solve() {
cin >> a >> b;
if ((long long)(a.size()) < (long long)(b.size())) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << '\n';
return;
}
map<long long, long long> cnt;
for (char c : a) {
cnt[c - '0'] += 1;
}
cout << calc(0, cnt) << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int digits[10], m;
inline long long lowest(long long current) {
long long res = current;
for (int i = 0; i < (10); i++)
for (int j = 0; j < (digits[i]); j++) res = res * 10 + i;
return res;
}
int main() {
long long a, b;
scanf("%lld%lld", &a, &b);
while (a) {
digits[a % 10]++;
a /= 10;
m++;
}
long long current = 0;
for (int i = 0; i < (m); i++)
for (int j = (9); j >= (0); j--)
if (digits[j]) {
digits[j]--;
long long new_current = current * 10 + j;
{};
if (lowest(new_current) <= b) {
current = new_current;
break;
} else
digits[j]++;
}
printf("%lld\n", current);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[10];
int bn[20];
int ans[20];
int dfs(int pos, bool limit) {
if (pos == -1) {
return 1;
}
int up;
if (limit)
up = bn[pos];
else
up = 9;
for (int i = up; i >= 0; --i) {
if (vis[i] > 0) {
vis[i]--;
if (dfs(pos - 1, limit && i == bn[pos])) {
ans[pos] = i;
return 1;
}
vis[i]++;
}
}
return 0;
}
int main() {
long long a, b;
while (cin >> a >> b) {
long long tmp;
tmp = a;
int la, lb;
la = lb = 0;
while (tmp) {
vis[tmp % 10]++;
tmp /= 10;
la++;
}
tmp = b;
while (tmp) {
bn[lb++] = tmp % 10;
tmp /= 10;
}
dfs(la - 1, la == lb);
for (int i = la - 1; i >= 0; --i) {
printf("%d", ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
const long long MOD = 1000000000 + 7;
const long long MAGIC = 123123123;
const double PI = 4 * atan(1.);
const double EPS = 1E-7;
void time_elapsed() {
cout << "\nTIME ELAPSED: " << (double)clock() / CLOCKS_PER_SEC << " sec\n";
}
struct frac;
template <typename T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
template <class T>
T gcd(T a, T b, T& x, T& y) {
if (!a) {
x = 0, y = 1;
return b;
}
T x1, y1;
T d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
template <typename T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <typename T, typename M>
T neg_mod(T a, M mod) {
return ((a % mod) + mod) % mod;
}
long long binpow(long long x, long long p) {
long long res = 1;
while (p) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
long long binpow_mod(long long x, long long p, long long m) {
long long res = 1;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
struct cmp_for_set {
bool operator()(const pair<long long, long long>& a,
const pair<long long, long long>& b) const {
return a > b;
}
};
string a, b;
map<char, int> amap;
bool check(int len, map<char, int>& need, string& res) {
map<char, int> aa = amap;
for (auto it : need) {
if (aa[it.first] < it.second) {
return false;
}
aa[it.first] -= it.second;
if (aa[it.first] == 0) {
aa.erase(it.first);
}
}
res.resize(a.size());
for (int i = 0; i < len; ++i) {
res[i] = b[i];
}
if (len == b.size()) {
return true;
}
char nxt = '0' - 1;
for (auto it : aa) {
if (it.first < b[len] && it.second > 0) {
nxt = it.first;
}
}
if (nxt == '0' - 1) {
return false;
}
res[len] = nxt;
aa[nxt]--;
vector<char> toadd;
for (auto it : aa) {
for (int j = 0; j < it.second; ++j) {
toadd.push_back(it.first);
}
}
for (int i = 0; i < toadd.size(); ++i) {
res[len + 1 + i] = toadd[(int)toadd.size() - 1 - i];
}
return true;
}
int main() {
cin >> a >> b;
for (int i = 0; i < a.size(); ++i) {
amap[a[i]]++;
}
string res = a;
sort(res.begin(), res.end());
if (a.size() < b.size()) {
sort(res.rbegin(), res.rend());
cout << res;
return 0;
}
map<char, int> need;
for (int i = 0; i <= b.size(); ++i) {
string cur;
if (check(i, need, cur)) {
res = cur;
}
need[b[i]]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 100;
const long long MOD = 1e9 + 7;
long long ditgit[20];
long long store[20];
bool used[20];
char b[20];
bool cmp(char aa, char bb) { return aa > bb; }
long long ans = 0;
long long len;
bool dfs(long long pos, bool lim) {
if (pos == len) {
long long curans = 0;
for (int i = 0; i < len; ++i) curans = curans * 10 + store[i];
ans = max(ans, curans);
return 1;
}
if (!lim) {
for (int j = 0; j < len; ++j)
if (!used[j]) {
store[pos] = ditgit[j];
used[j] = 1;
dfs(pos + 1, 0);
used[j] = 0;
return 1;
}
}
for (int i = 0; i < len; ++i) {
if (used[i] || ditgit[i] > b[pos]) continue;
used[i] = 1;
store[pos] = ditgit[i];
if (ditgit[i] < b[pos]) {
dfs(pos + 1, 0);
used[i] = 0;
return 1;
}
if (!dfs(pos + 1, 1)) {
used[i] = 0;
for (int j = i; j < len; ++j)
if (!used[j] && ditgit[j] < ditgit[i]) {
used[j] = 1;
store[pos] = ditgit[j];
dfs(pos + 1, 0);
return 1;
}
return 0;
} else
return 1;
}
return 0;
}
int main(int argc, char const *argv[]) {
char a[20];
cin >> a >> b;
len = strlen(a);
sort(a, a + len, cmp);
for (int i = 0; i < len; ++i) ditgit[i] = (a[i] - '0');
long long lenb = strlen(b);
if (lenb > len) {
for (int i = 0; i < len; ++i) cout << ditgit[i];
puts("");
return 0;
}
for (int i = 0; i < lenb; ++i) b[i] -= '0';
dfs(0, 1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 18;
const int INF = 1 << 30;
const long long LINF = 1LL << 60;
char s[MAX_N + 4], t[MAX_N + 4];
int cs[10];
int main() {
scanf("%s%s", s, t);
int n = strlen(s), m = strlen(t);
if (n < m) {
sort(s, s + n, greater<char>());
puts(s);
return 0;
}
for (int i = 0; i < n; i++) cs[s[i] - '0']++;
int k = 0;
for (; k < m; k++) {
int tk = t[k] - '0';
if (cs[tk] == 0) break;
s[k] = t[k];
cs[tk]--;
}
if (k >= m) {
puts(s);
return 0;
}
while (k >= 0) {
bool f = false;
for (int i = (t[k] - '0') - 1; i >= 0; i--)
if (cs[i] > 0) {
s[k++] = i + '0';
cs[i]--;
f = true;
break;
}
if (f) break;
cs[s[--k] - '0']++;
}
for (; k < m; k++) {
for (int i = 9; i >= 0; i--)
if (cs[i] > 0) {
s[k] = i + '0';
cs[i]--;
break;
}
}
puts(s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[21], b[21];
int ans[21], val[11];
int flag, k;
void dfs(int x) {
if (x == strlen(b)) {
for (int i = 0; i < strlen(b); i++) printf("%d", ans[i]);
printf("\n");
flag = 1;
return;
}
for (int i = 9; i >= 0; i--) {
if (val[i]) {
if (k || i < b[x] - '0') {
k = 1;
val[i]--;
ans[x] = i;
dfs(x + 1);
val[i]++;
} else if (i == b[x] - '0') {
val[i]--;
ans[x] = i;
dfs(x + 1);
val[i]++;
}
}
if (flag) return;
}
}
int main() {
while (~scanf("%s%s", &a, &b)) {
if (strlen(b) > strlen(a)) {
sort(a, a + strlen(a));
for (int i = strlen(a) - 1; i >= 0; i--) printf("%c", a[i]);
printf("\n");
} else {
flag = k = 0;
memset(val, 0, sizeof(val));
for (int i = 0; i < strlen(a); i++) val[a[i] - '0']++;
dfs(0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
int32_t main() {
ios::sync_with_stdio(0);
string a, b;
cin >> a >> b;
if ((int)(b.size()) > (int)(a.size())) {
sort(a.begin(), a.end(), greater<char>());
cout << a << endl;
return 0;
}
multiset<char> _st;
for (auto c : a) _st.insert(c);
string ans = "";
for (int i = 0; i <= (int)(b.size()); ++i) {
string res = "";
multiset<char> st;
st.insert(_st.begin(), _st.end());
bool can = true;
for (int j = 0; j < (int)(b.size()); ++j) {
if (j < i) {
auto it = st.lower_bound(b[j]);
if (it != st.end() and *it == b[j]) {
res.push_back(*it);
st.erase(it);
} else {
can = false;
}
} else if (j > i) {
auto it = prev(st.end());
res.push_back(*it);
st.erase(it);
} else {
auto it = st.lower_bound(b[j]);
if (it == st.begin())
can = false;
else {
it = prev(it);
res.push_back(*it);
st.erase(it);
}
}
}
if (res[0] == '0') can = false;
if (can and res <= b) ans = max(ans, res);
}
if (ans == "") assert(1 == 2);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string A, B;
int freq[11];
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;
}
for (auto it : A) freq[it - '0']++;
A.clear();
for (int i = 0; i < B.size(); i++) {
if (freq[B[i] - '0']) {
A.push_back(B[i]);
freq[B[i] - '0']--;
} else {
bool ok = false;
for (int c = B[i] - '0' - 1; c >= 0; c--)
if (freq[c] != 0) {
A.push_back(c + '0');
freq[c]--;
ok = true;
break;
}
if (ok) break;
do {
freq[A.back() - '0']++;
A.pop_back();
i--;
for (int c = B[i] - '0' - 1; c >= 0; c--)
if (freq[c] != 0) {
A.push_back(c + '0');
freq[c]--;
ok = true;
break;
}
} while (!ok);
break;
}
}
for (int c = 9; c >= 0; c--)
while (freq[c]--) A.push_back(c + '0');
cout << A << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char num1[20];
char num2[20];
bool calc(int pos, int len) {
if (pos == len) return true;
sort(num1 + pos, num1 + len, greater<char>());
bool res = false;
for (int i = pos; i < len && !res; i++) {
if (num1[i] == num2[pos]) {
swap(num1[i], num1[pos]);
sort(num1 + pos + 1, num1 + len);
if (strcmp(num1, num2) <= 0)
res = res || calc(pos + 1, len);
else
sort(num1 + pos, num1 + len, greater<char>());
} else if (num1[i] < num2[pos]) {
swap(num1[i], num1[pos]);
sort(num1 + pos + 1, num1 + len, greater<char>());
return true;
}
}
return res;
}
int main(int argc, char* argv[]) {
cin >> num1 >> num2;
int len1 = strlen(num1);
int len2 = strlen(num2);
if (len1 < len2) {
sort(num1, num1 + len1, greater<char>());
cout << num1 << endl;
} else {
calc(0, len1);
cout << num1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20];
bool used[20];
int sa, sb, ans[20];
int choose(char ch) {
int mx = -1;
for (int i = 0; i < sa; i++) {
if (!used[i] && a[i] <= ch && (mx == -1 || a[i] > a[mx])) {
mx = i;
}
}
return mx;
}
bool lower(int j) {
for (int i = 0; i < j; i++) {
if (a[ans[i]] < b[i]) {
return true;
}
}
return false;
}
void print(int j) {
for (int i = 0; i < j; i++) {
printf("%c", a[ans[i]]);
}
printf("\n");
}
int main() {
scanf("%s %s", a, b);
memset(used, false, sizeof(used));
sa = strlen(a);
sb = strlen(b);
if (sb > sa) {
int j = 0;
for (int i = 0; i < sa; i++) {
int mx = choose('9');
ans[j++] = mx;
used[mx] = true;
}
} else {
int j = 0;
for (int i = 0; i < sb; i++) {
int mx = choose(lower(j) ? '9' : b[i]);
if (mx == -1) {
j--;
while (choose(a[ans[j]] - 1) == -1) {
used[ans[j--]] = false;
}
used[ans[j]] = false;
ans[j] = choose(a[ans[j]] - 1);
used[ans[j]] = true;
i = j++;
} else {
ans[j++] = mx;
used[mx] = true;
}
}
}
for (int i = 0; i < sa; i++) {
printf("%c", a[ans[i]]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(2)
#pragma G++ optimize(2)
const int INF = 0x3f3f3f3f;
const long long LINF = 1000000000000000000;
long long n, a[2000005], b[2000005], l1, l2;
char s[25], ss[25], sss[25];
void solve(int x) {
for (int i = 1; i < x; i++) printf("%c", sss[i]);
for (int i = 9; i >= 0; i--) {
while (a[i]) {
printf("%d", i);
a[i]--;
}
}
printf("\n");
exit(0);
}
int main() {
scanf("%s", s + 1);
scanf("%s", ss + 1);
l1 = strlen(s + 1), l2 = strlen(ss + 1);
for (int i = 1; i <= l1; i++) a[s[i] - '0']++;
for (int i = 1; i <= l2; i++) b[ss[i] - '0']++;
if (l1 < l2) solve(1);
for (int i = 1; i <= l1; i++) {
if (a[ss[i] - '0']) {
sss[i] = ss[i];
a[ss[i] - '0']--;
} else {
for (int j = (ss[i] - '0') - 1; j >= 0; j--) {
if (a[j]) {
sss[i] = '0' + j;
a[j]--;
solve(i + 1);
}
}
int k = i - 1;
while (1) {
a[ss[k] - '0']++;
for (int j = (ss[k] - '0') - 1; j >= 0; j--) {
if (a[j]) {
sss[k] = '0' + j;
a[j]--;
solve(k + 1);
}
}
k--;
}
}
}
solve(l1 + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = int64_t;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
for (int t = 1; t <= T; t++) {
string x, y;
cin >> x >> y;
if ((int)x.size() < (int)y.size()) {
sort(x.begin(), x.end(), greater<char>());
cout << x << "\n";
return 0;
}
map<char, int> count;
for (auto i : x) {
count[i] += 1;
}
string res;
for (int i = 0; i < (int)y.size(); i++) {
if (count[y[i]] > 0) {
count[y[i]] -= 1;
res += y[i];
} else {
string min_;
for (auto c : count) {
if (c.second > 0) {
if (c.first < y[i]) {
min_ += c.first;
}
}
}
if ((int)min_.size() > 0) {
sort(min_.begin(), min_.end(), greater<char>());
res += min_[0];
count[min_[0]] -= 1;
string other;
for (auto item : count) {
for (int j = 0; j < item.second; j++) {
other += item.first;
}
}
sort(other.begin(), other.end(), greater<char>());
res += other;
cout << res << "\n";
return 0;
} else {
char c = '-';
int idx = -1;
for (int j = (int)res.size() - 1; j >= 0; j--) {
for (auto item : count) {
if (item.second > 0) {
if (res[j] > item.first) {
c = max(item.first, c);
}
}
}
for (int k = j + 1; k < (int)res.size(); k++) {
if (res[k] > c and res[k] < res[j]) {
c = res[k];
}
}
if (c != '-') {
idx = j;
break;
}
}
count[res[idx]] += 1;
count[c] -= 1;
string new_res;
for (int j = 0; j <= idx; j++) {
new_res += res[j];
}
new_res[idx] = c;
for (int j = idx + 1; j < (int)res.size(); j++) {
count[res[j]] += 1;
}
string other;
for (auto item : count) {
for (int j = 0; j < item.second; j++) {
other += item.first;
}
}
sort(other.begin(), other.end(), greater<char>());
new_res += other;
cout << new_res << "\n";
return 0;
}
}
}
cout << res << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
char a[30], b[30], c[30];
int num[10];
int numa, numb;
int findd(int n, int f) {
if (n == numa) return 1;
int i, k, j;
if (num[b[n] - '0'] != 0 && f == 1) {
num[b[n] - '0']--;
if (findd(n + 1, 1)) {
c[n] = b[n];
return 1;
} else {
num[b[n] - '0']++;
return findd(n, 0);
}
} else {
if (n != 0) {
for (i = 9; i >= 0; i--)
if (num[i] != 0 && i < (b[n] - '0')) break;
} else {
for (i = 9; i > 0; i--)
if (num[i] != 0 && i < (b[n] - '0')) break;
}
if ((n != 0 && i == -1) || (n == 0 && i == 0)) return 0;
c[n] = i + '0';
j = 9;
num[i]--;
for (i = n + 1; i < numa; i++) {
while (num[j] == 0) j--;
c[i] = j + '0';
num[j]--;
}
return 1;
}
}
int main() {
long long m, n, i, j, k, p, q, t;
for (i = 0; i < 10; i++) num[i] = 0;
scanf("%s%s", a, b);
numa = strlen(a);
numb = strlen(b);
for (i = 0; i < numa; i++) num[a[i] - '0']++;
if (numa < numb) {
for (i = 9; i >= 0; i--) {
while (num[i] != 0) {
printf("%d", i);
num[i]--;
}
}
printf("\n");
} else {
if (numa > numb) num[0] -= (numa - numb);
m = findd(0, 1);
if (m) {
for (i = 0; i < numa; i++) printf("%c", c[i]);
printf("\n");
} else {
num[0]--;
for (i = 9; i >= 0; i--) {
while (num[i] != 0) {
printf("%d", i);
num[i]--;
}
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[101];
map<char, int> s1map;
map<char, int> s2map;
vector<int> answer;
string s1;
string s2;
int main() {
cin >> s1;
for (int i = 0; i < s1.length(); i++) s1map[s1[i]]++;
cin >> s2;
int sz1 = s1.length();
int sz2 = s2.length();
if (sz1 < sz2) {
vector<int> temp;
for (int i = 0; i < s1.length(); i++) temp.push_back(s1[i] - '0');
sort(temp.begin(), temp.end());
for (int i = temp.size() - 1; i >= 0; i--) cout << temp[i];
cout << endl;
return 0;
}
for (int i = 0; i < s1.length(); i++) {
map<char, int> copymap;
vector<int> temp;
for (int c = '0'; c <= '9'; c++) copymap[c] = s1map[c];
for (int i = 0; i < answer.size(); i++) temp.push_back(answer[i]);
for (int j = '9'; j >= '0'; j--) {
if (copymap[j] > 0) {
copymap[j]--;
temp.push_back(j - '0');
bool possible = true;
for (int k = '0'; k <= '9'; k++) {
while (copymap[k] > 0) {
temp.push_back(k - '0');
copymap[k]--;
}
}
for (int k = 0; k < temp.size(); k++) {
if (temp[k] < s2[k] - '0') {
possible = true;
break;
} else if (temp[k] > s2[k] - '0') {
possible = false;
break;
}
}
if (possible) {
s1map[j]--;
answer.push_back(j - '0');
break;
} else {
for (int c2 = '0'; c2 <= '9'; c2++) copymap[c2] = s1map[c2];
temp.clear();
for (int i = 0; i < answer.size(); i++) temp.push_back(answer[i]);
}
}
}
}
for (int i = 0; i < answer.size(); i++) cout << answer[i];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 123;
long long a[maxn], b[maxn], n, m;
char s[maxn];
long long vis[20], t[20], sb[maxn];
void dfs(long long stp, long long sa) {
if (sa > sb[stp + 1]) return;
if (stp == 0) {
cout << sa << endl;
exit(0);
}
if (stp > n) {
dfs(stp - 1, sa);
return;
}
for (long long i = 9; i >= 0; i--)
if (vis[i] && sa * 10 + i <= sb[stp]) {
--vis[i];
dfs(stp - 1, sa * 10 + i);
++vis[i];
}
}
int main() {
long long i;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) a[i] = s[n - i + 1] - '0';
scanf("%s", s + 1);
m = strlen(s + 1);
for (i = 1; i <= m; i++) b[i] = s[m - i + 1] - '0';
for (i = m; i; i--) sb[i] = sb[i + 1] * 10 + b[i];
for (i = 1; i <= n; i++) ++vis[a[i]];
dfs(m, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
int si1 = a.size(), si2 = b.size();
if (si1 < si2) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a << endl;
} else {
string ans = a;
int fr[10];
memset(fr, 0, sizeof(fr));
for (int i = 0; i < si1; i++) {
fr[a[i] - '0']++;
}
bool check = true;
for (int i = 0; i < si1; i++) {
int temp = b[i] - '0';
if (check == false) {
for (int j = 9; j >= 0; j--) {
if (fr[j] > 0) {
fr[j]--;
ans[i] = '0' + j;
break;
}
}
} else {
bool found = false;
for (int j = temp; j >= 0; j--) {
if (fr[j] > 0) {
found = true;
fr[j]--;
ans[i] = '0' + j;
if (j < temp) check = false;
break;
}
}
if (found == false) {
check = false;
for (int j = i - 1; j >= 0; j--) {
int t = ans[j] - '0';
fr[t]++;
bool f = false;
for (int k = t - 1; k >= 0; k--) {
if (fr[k] > 0) {
f = true;
fr[k]--;
ans[j] = '0' + k;
break;
}
}
if (f == true) {
i = j;
break;
}
}
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long solve(string A, string B) {
vector<string> ans;
for (int x = 0; x < (B.size()); x++) {
map<char, int> mymap;
for (int i = 0; i < (A.size()); i++) mymap[A[i]]++;
for (int xx = 0; xx < (x); xx++)
if (mymap[B[xx]] <= 0)
goto end;
else
mymap[B[xx]]--;
for (auto c : mymap) {
if (c.second <= 0) continue;
map<char, int> mymap2(mymap);
mymap2[c.first]--;
string U;
for (auto t : mymap2)
for (int y = 0; y < (t.second); y++) U += t.first;
sort(U.begin(), U.end(), greater<char>());
string Ans;
for (int l = 0; l < (x); l++) Ans.push_back(B[l]);
Ans += c.first;
Ans += U;
assert(Ans.length() == A.length());
ans.push_back(Ans);
}
}
end:
ans.push_back(A);
sort(ans.begin(), ans.end());
ans.resize(distance(ans.begin(), unique(ans.begin(), ans.end())));
long long b = stoull(B);
long long answer = -1;
for (auto s : ans) {
if (s.length() != A.length()) continue;
if (s[0] == '0') continue;
long long first = stoull(s);
if (first <= b) answer = max(answer, first);
}
return answer;
}
int main(int argc, char *argv[]) {
cout.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cout << setprecision(14);
string A, B;
while (cin >> A >> B) {
cout << solve(A, B) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
constexpr int N = 5e2 + 1;
constexpr int MOD = 1e9 + 7;
constexpr int INF = 1e9 + 9;
string a, b, ans;
int alp[10], alt[10], id = 1;
bool can(int i) {
for (int i = 0; i < 10; i++) alt[i] = alp[i];
string t = b.substr(0, i);
for (auto ch : t) {
if (alt[ch - '0'])
alt[ch - '0']--;
else
return false;
}
return true;
}
bool can_l(int i) {
for (int i = 0; i < 10; i++) alt[i] = alp[i];
string t = b.substr(0, i - 1);
for (auto ch : t) {
if (alt[ch - '0'])
alt[ch - '0']--;
else
return false;
}
for (int j = b[i - 1] - '1'; j >= 0; j--) {
if (alt[j]) {
alt[j]--;
cout << t << static_cast<char>('0' + j);
for (int k = 9; k >= 0; k--) {
while (alt[k]) {
cout << static_cast<char>('0' + k);
alt[k]--;
}
}
return true;
}
}
return false;
}
void Solve() {
cin >> a >> b;
if (a.size() == 1) {
cout << a;
return;
}
if (a.size() < b.size()) {
sort(a.begin(), a.end(), greater<char>());
cout << a;
return;
}
for (auto ch : a) alp[ch - '0']++;
while (can(id++) && id < b.size())
;
if (id == b.size() && can(id))
cout << b;
else
while (!can_l(id--))
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int acnt[10];
int main() {
string A, B;
cin >> A >> B;
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
if (A.size() < B.size()) {
cout << A;
exit(0);
}
for (auto w : A) acnt[w - '0']++;
string ans = "";
for (int diff = B.size() - 1; diff >= 0; diff--) {
for (int fix = 0; fix < 10; fix++) {
int cnt[10];
memcpy(cnt, acnt, sizeof(acnt));
string res;
int p = 0;
while (res.size() < diff) {
res += B[p];
cnt[B[p] - '0']--;
p++;
}
cnt[fix]--;
res += (char)('0' + fix);
for (int i = 9; i >= 0; i--) {
while (cnt[i] > 0) {
res += (char)(i + '0');
cnt[i]--;
}
}
int can = 1;
for (int i = 0; i < 10; i++) {
can &= (cnt[i] == 0);
}
if (res <= B && can) {
ans = max(ans, res);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long INF = 1e18;
template <typename T1, typename T2>
inline bool chmin(T1& a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool chmax(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
T pow(T a, int b) {
return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1;
}
const int mod = 1000000007;
long long modpow(long long a, int b) {
return b ? modpow(a * a % mod, b / 2) * (b % 2 ? a : 1) % mod : 1;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
for (auto& vi : vec) os << vi << " ";
return os;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
T = 1;
while (T--) {
solve();
}
}
void solve() {
map<int, int> mp;
string s, t;
cin >> s >> t;
for (int i = 0; i < ((int)s.size()); ++i) mp[s[i] - '0']++;
if ((int)s.size() < (int)t.size()) {
for (int i = 0; i < ((int)s.size()); ++i) {
int ma = 0;
for (auto e : mp)
if (e.second) chmax(ma, e.first);
mp[ma]--;
cout << ma;
}
cout << endl;
} else {
string u;
int flg = 0;
for (int i = 0; i < ((int)s.size()); ++i) {
int ma = -1;
for (auto j = mp.end();; --j) {
if (j == mp.end()) continue;
pair<int, int> e = *j;
if (e.second) {
if (flg == 0) {
if (e.first == t[i] - '0') {
ma = e.first;
break;
} else if (e.first < t[i] - '0') {
flg = 1;
ma = e.first;
break;
}
} else {
ma = e.first;
break;
}
}
if (j == mp.begin()) {
if (ma == -1) {
while (ma == -1) {
mp[u.back() - '0']++;
u = u.substr(0, (int)u.size() - 1);
for (auto e : mp) {
if (e.second && e.first < t[(int)u.size()] - '0')
chmax(ma, e.first);
}
}
u += ma + '0';
mp[u.back() - '0']--;
string u2;
for (auto e : mp)
for (int j = 0; j < (e.second); ++j) u2 += e.first + '0';
sort(u2.begin(), u2.end(), greater<char>());
u += u2;
flg = 1;
cout << u << endl;
return;
}
break;
}
}
mp[ma]--;
u += ma + '0';
}
cout << u << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200010;
int main() {
string s, s1;
cin >> s >> s1;
vector<int> v;
for (int i = 0; i < s.size(); i++) {
v.push_back(s[i] - '0');
}
sort(v.begin(), v.end());
if (s.size() < s1.size()) {
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
} else {
string ans = "";
int f = 0, t = 0, rr = 0;
for (int i = 0; i < s1.size(); i++) {
int num = s1[i] - '0';
if (t == 1) {
v.push_back(ans[ans.size() - 1] - '0');
sort(v.begin(), v.end());
ans.erase(ans.begin() + ans.size() - 1);
num = num - 1;
}
int p;
if (f == 0) {
int pos = upper_bound(v.begin(), v.end(), num) - v.begin();
if (pos == NULL) {
i -= 2;
t = 1;
continue;
}
p = v[pos - 1];
v.erase(v.begin() + pos - 1);
if (p < num || t == 1) {
t = 0;
f = 1;
}
ans += (p + '0');
} else {
rr = 1;
cout << ans;
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
break;
}
}
if (rr == 0) cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
inline bool is_palindrome(const string& s) {
return std::equal(s.begin(), s.end(), s.rbegin());
}
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
string a, b, ans = "";
int sz;
void solve(int index, string& val, vector<int> cnt) {
if (index == sz) {
ans = max(ans, val);
return;
}
for (long long i = (long long)(9); i >= (long long)(0); i--) {
if (index == 0 && i == 0) continue;
if (cnt[i]) {
if (i == b[index] - '0') {
val += b[index];
cnt[i]--;
solve(index + 1, val, cnt);
cnt[i]++;
val.pop_back();
} else if (i < b[index] - '0') {
string tmp = val;
tmp += (char)(i + '0');
cnt[i]--;
for (long long j = (long long)(9); j >= (long long)(0); j--) {
while (cnt[j]) {
tmp += (char)(j + '0');
cnt[j]--;
}
}
ans = max(ans, tmp);
break;
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b;
sz = a.size();
int sz2 = b.size();
if (sz2 > sz) {
sort(a.begin(), a.end(), greater<char>());
cout << a;
return 0;
}
string val = "";
vector<int> cnt(10, 0);
for (long long i = (long long)(0); i < (long long)(sz); i++) {
cnt[a[i] - '0']++;
}
solve(0, val, cnt);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
vector<vector<int>> data;
int r, c;
Matrix(int row, int col, bool identity = false) : r(row), c(col) {
data.assign(row, vector<int>(col, 0));
if (identity) {
for (int i = 0; i < r; ++i) {
data[i][i] = 1;
}
}
}
Matrix operator*(Matrix& other) {
int m = r, n = c, p = other.c;
Matrix res(m, p);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < p; ++j) {
for (int k = 0; k < n; ++k) {
res.data[i][j] += data[i][k] * other.data[k][j];
}
}
}
return res;
}
};
vector<int> extendGcd(int a, int b) {
if (b == 0) {
return {a, 1, 0};
} else {
vector<int> tmp = extendGcd(b, a % b);
return {tmp[0], tmp[2], tmp[1] - (a / b) * tmp[2]};
}
}
Matrix matrix_power(Matrix base, long long exp) {
int n = base.r;
Matrix res(n, n, true);
while (exp) {
if (exp & 1) {
res = res * base;
}
base = base * base;
exp >>= 1;
}
return res;
}
template <typename T>
T power_mod(T base, int exp, int mod = 1000000007) {
T res = 1;
while (exp) {
if (exp & 1) res = res * base % mod;
base = base * base % mod;
exp >>= 1;
}
return res;
}
template <typename T>
T power(T base, int exp) {
T res = 1;
while (exp) {
if (exp & 1) res *= base;
base *= base;
exp >>= 1;
}
return res;
}
long long inv(long long a) { return power_mod(a, 1000000007 - 2); }
string a, b;
string res;
vector<int> cnt(10, 0);
bool dfs(int index, bool small) {
if (index == a.length()) return true;
if (small) {
for (int i = 9; i >= 0; --i) {
if (cnt[i]) {
res.push_back('0' + i);
--cnt[i];
return dfs(index + 1, small);
}
}
} else {
if (cnt[b[index] - '0']) {
res.push_back(b[index]);
--cnt[b[index] - '0'];
if (dfs(index + 1, false)) return true;
++cnt[b[index] - '0'];
res.pop_back();
}
for (int i = b[index] - '0' - 1; i >= 0; --i) {
if (cnt[i]) {
res.push_back('0' + i);
--cnt[i];
return dfs(index + 1, true);
}
}
return false;
}
}
int main() {
cin >> a >> b;
if (a.length() < b.length()) {
sort((a).begin(), (a).end(), greater<char>());
cout << a;
} else {
for (char ch : a) {
++cnt[ch - '0'];
}
dfs(0, false);
cout << res;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 2e6 + 5;
int ca[10], caa[10], na, nb;
string a, b;
long long ans = 0, bs[20];
void dfs(int dep, long long res) {
if (dep == nb) {
ans = max(ans, res);
return;
}
for (int i = (b[dep] - '0'); i >= (0); i--) {
if (dep == 0 && i == 0) continue;
if (!ca[i]) continue;
if (i == b[dep] - '0') {
ca[i]--;
dfs(dep + 1, res + bs[nb - 1 - dep] * i);
ca[i]++;
} else {
ca[i]--;
res += bs[nb - 1 - dep] * i;
long long base = 1;
for (int i = (0); i <= (9); i++) caa[i] = ca[i];
for (int i = (0); i <= (9); i++) {
while (caa[i]) {
res += base * i;
base *= 10;
caa[i]--;
}
}
ans = max(ans, res);
ca[i]++;
return;
}
}
}
int main() {
bs[0] = 1;
for (int i = (1); i <= (19); i++) bs[i] = bs[i - 1] * 10;
cin >> a >> b;
na = a.size(), nb = b.size();
for (int i = (0); i <= (na - 1); i++) ca[a[i] - '0']++;
if (na < nb) {
long long base = 1;
for (int i = (0); i <= (9); i++) {
while (ca[i]) {
ans += base * i;
base *= 10;
ca[i]--;
}
}
cout << ans;
} else {
dfs(0, 0);
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
int cnt[10] = {0};
int data[20], numb = 0, numa = 0;
while (b) {
data[numb++] = b % 10ll;
b /= 10ll;
}
while (a) {
cnt[a % 10ll]++;
a /= 10ll;
numa++;
}
if (numb > numa) {
for (int i = 9; i > -1; i--)
while (cnt[i]--) cout << i;
cout << endl;
return 0;
}
if (numa > numb) {
for (int i = numb; i < numa; i++) cout << 0;
cnt[0] -= numa - numb;
}
int num = numb;
int ans[20];
while (num--) {
int now = data[num];
if (cnt[now]) {
ans[num] = now;
cnt[now]--;
} else {
bool flag = true;
while (flag) {
for (int i = now - 1; i > -1 && flag; i--)
if (cnt[i]) {
ans[num--] = i;
cnt[i]--;
flag = false;
}
if (flag) {
now = data[++num];
cnt[now]++;
}
}
for (int i = 9; i > -1; i--)
while (cnt[i]--) ans[num--] = i;
num = 0;
}
}
while (numb--) cout << ans[numb];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
long long ac[10] = {0}, bc[10] = {0};
long long la, lb;
string func(long long ind, bool flag, long long c[10]) {
if (ind == la) return "";
long long lmt = (flag ? b[ind] - '0' : 9);
string str = "";
long long i;
for (i = lmt; i >= 0; i--) {
if (!c[i]) continue;
c[i]--;
bool nflag;
if (flag) {
if (i == lmt)
nflag = true;
else
nflag = false;
} else
nflag = false;
str = func(ind + 1, nflag, c);
c[i]++;
if (str.length() == (la - ind - 1)) break;
str = "";
}
char ch = i + '0';
if (c[i])
str = ch + str;
else
str = "";
return str;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b;
la = a.length(), lb = b.length();
for (long long i = 0; i < la; i++) ac[a[i] - '0']++;
for (long long i = 0; i < lb; i++) bc[b[i] - '0']++;
string str = "";
if (la < lb) {
for (long long i = 0; i < la; i++) {
for (long long j = 9; j >= 0; j--) {
if (!ac[j]) continue;
ac[j]--;
str += (j + '0');
break;
}
}
cout << str << endl;
return 0;
}
str = func(0, true, ac);
cout << str << endl;
}
|
#include <bits/stdc++.h>
int B[20], ctr[10];
int main(void) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long a, b;
std::cin >> a >> b;
int n1 = 0, n2 = 0;
long long t = a;
while (t) {
n1++;
ctr[t % 10]++;
t /= 10;
}
t = b;
while (t) {
B[20 - n2 - 1] = (t % 10);
n2++;
t /= 10;
}
if (n1 < n2) {
for (int j = n1; j > 0; j--) {
for (int i = 9; i >= 0; i--) {
if (ctr[i]) {
ctr[i]--;
std::cout << i;
break;
}
}
}
std::cout << "\n";
} else {
std::vector<int> res;
bool ok = 0;
for (int i = 0; i < n2; i++) {
bool tc = 0;
for (int j = 9; j >= 0; j--) {
if (ctr[j]) {
if (!ok) {
if (B[20 - n2 + i] < j)
continue;
else if (B[20 - n2 + i] > j) {
tc = 1;
ok = 1;
res.push_back(j);
ctr[j]--;
break;
} else {
tc = 1;
res.push_back(j);
ctr[j]--;
break;
}
} else {
ctr[j]--;
res.push_back(j);
tc = 1;
break;
}
}
}
if (!tc) {
int pos = -1;
for (int j = res.size() - 1; j >= 0; j--) {
ctr[res[j]]++;
for (int k = res[j] - 1; k >= 0; k--) {
if (ctr[k]) {
pos = j;
ctr[k]--;
res[j] = k;
tc = 1;
ok = 1;
break;
}
}
if (tc) break;
}
for (int j = pos + 1; j <= i; j++) {
for (int k = 9; k >= 0; k--) {
if (ctr[k]) {
ctr[k]--;
if (j != i)
res[j] = k;
else
res.push_back(k);
break;
}
}
}
}
}
for (auto u : res) std::cout << u;
std::cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
long long check(std::string &a, std::string &b, int l) {
int table[10] = {0};
for (int i = 0; i < a.length(); i++) {
int d = a[i] - '0';
table[d]++;
}
long long x = 0;
int i = 0;
for (int i = 0; i < l; i++) {
int d = b[i] - '0';
x = x * 10 + d;
if (--table[d] < 0) return -1;
}
if (l == b.length()) {
return x;
}
bool smaller = false;
for (int d = b[l] - '0' - 1; d >= 0; d--)
if (table[d] > 0) {
table[d]--;
x = x * 10 + d;
smaller = true;
break;
}
if (!smaller) {
return -1;
}
for (int d = 9; d >= 0; d--)
while (table[d] > 0) {
table[d]--;
x = x * 10 + d;
}
return x;
}
int main() {
std::string a, b;
std::getline(std::cin, a);
std::getline(std::cin, b);
if (b.length() > a.length()) {
std::sort(a.begin(), a.end(), std::greater<int>());
std::cout << a;
} else {
for (int l = b.length(); l >= 0; l--) {
long long x = check(a, b, l);
if (x >= 0) {
std::cout << x << std::endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50;
const long long inf = 1e18 + 7;
long long a, b;
int n = 0, m = 0;
int xa[maxn], xb[maxn];
long long gt[maxn], f[1 << 20];
long long calc(int u, int first, int ok) {
if (u > n) return 0;
if (f[first] != -1) return f[first];
f[first] = -inf;
if (ok) {
f[first] = 0;
for (int i = 1; i <= n; ++i)
if (first & (1 << (i - 1))) f[first] += (long long)xa[i] * gt[n - u], ++u;
return f[first];
}
for (int i = 1; i <= n; ++i)
if (first & (1 << (i - 1)) && xa[i] <= xb[u]) {
int second = first ^ (1 << (i - 1));
long long o = (long long)xa[i] * gt[n - u];
if (xa[i] < xb[u])
f[first] = max(f[first], o + calc(u + 1, second, 1));
else
f[first] = max(f[first], o + calc(u + 1, second, 0));
}
return f[first];
}
void solve() {
cin >> a >> b;
while (a) xa[++n] = a % 10, a /= 10;
sort(xa + 1, xa + n + 1, greater<int>());
while (b) xb[++m] = b % 10, b /= 10;
reverse(xb + 1, xb + m + 1);
if (n < m) {
for (int i = 1; i <= n; ++i) cout << xa[i];
return;
}
gt[0] = 1;
for (int i = 1; i < n; ++i) gt[i] = 10ll * gt[i - 1];
for (int first = 0; first < (1 << n); ++first) f[first] = -1;
cout << calc(1, (1 << n) - 1, 0);
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, temp;
cin >> a >> b;
int s = a.size();
sort(a.begin(), a.end());
for (int i = 0; i < s - 1; i++) {
for (int j = i + 1; j < s; j++) {
temp = a;
swap(temp[i], temp[j]);
if (stoll(temp) <= stoll(b)) {
a = temp;
}
}
}
cout << a << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> num1, num2;
string s, s1;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s >> s1;
for (int i = 0; i < s.size(); i++) num1.push_back(s[i] - '0');
for (int i = 0; i < s1.size(); i++) num2.push_back(s1[i] - '0');
sort(num1.begin(), num1.end());
reverse(num1.begin(), num1.end());
if (num2.size() > num1.size()) {
for (int i = 0; i < num1.size(); i++) cout << num1[i];
return 0;
}
bool b = 0, k = 0;
for (int i = 0; i < num1.size(); i++) {
if (b == 1) {
sort(num1.begin() + i, num1.end());
reverse(num1.begin() + i, num1.end());
break;
}
if (k) {
int maxx = 0;
for (int h = i; h < num1.size(); h++)
if (num1[h] < num2[i]) maxx = max(maxx, num1[h]);
for (int j = i; j < num1.size(); j++) {
if (num1[j] == maxx) {
long long x = num1[j];
for (int h = j; h > i; h--) num1[h] = num1[h - 1];
num1[i] = x;
if (x < num2[i]) b = 1;
break;
}
}
k = 0;
if (b == 0) {
i--;
i--;
k = 1;
}
continue;
}
if (num1[i] < num2[i]) {
int maxx = 0;
for (int h = i; h < num1.size(); h++)
if (num1[h] <= num2[i]) maxx = max(maxx, num1[h]);
for (int j = i; j < num1.size(); j++) {
if (num1[j] == maxx) {
long long x = num1[j];
for (int h = j; h > i; h--) num1[h] = num1[h - 1];
num1[i] = x;
if (x < num2[i]) b = 1;
break;
}
}
b = 1;
}
if (num1[i] > num2[i]) {
int maxx = 0;
for (int h = i + 1; h < num1.size(); h++)
if (num1[h] <= num2[i]) maxx = max(maxx, num1[h]);
for (int j = i; j < num1.size(); j++) {
if (num1[j] == maxx) {
long long x = num1[j];
for (int h = j; h > i; h--) num1[h] = num1[h - 1];
num1[i] = x;
if (x < num2[i]) b = 1;
break;
}
}
}
if (num2[i] < num1[i] && num2[i - 1] == num1[i - 1] && b == 0) {
k = 1;
i--;
i--;
}
}
for (int i = 0; i < num1.size(); i++) cout << num1[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
const int INF = 1 << 29;
const ll LL_INF = 1LL << 60;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
ll A, B;
string SA, SB;
int N;
map<int, int> cnts;
bool check(string tmp, map<int, int> rest) {
for (int i = 0; i <= 9; i++) {
for (int j = 0; j < rest[i]; j++) {
tmp += to_string(i);
}
}
return tmp <= SB;
}
int main() {
cin >> A >> B;
SA = to_string(A);
SB = to_string(B);
if (SA.size() < SB.size()) {
sort(SA.rbegin(), SA.rend());
cout << SA << endl;
return 0;
}
N = SA.size();
for (int i = 0; i < N; i++) {
cnts[SA[i] - '0']++;
}
string res = "";
for (int i = 0; i < N; i++) {
bool ok = false;
for (char j = 9; j >= 0; j--) {
if (cnts[j] > 0) {
string tmp = res + to_string(j);
map<int, int> rest = cnts;
rest[j]--;
if (check(tmp, rest)) {
ok = true;
cnts[j]--;
res = tmp;
break;
}
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[10];
string a, b;
string solve(int s, bool ch) {
if (s == a.length()) return "-";
string t, u;
for (int i = b[s] - 48; i >= ch; i--) {
if (d[i]) {
if (i == b[s] - 48) {
d[i]--;
u += (i + 48);
u += solve(s + 1, 0);
d[i]++;
} else {
d[i]--;
t += (i + 48);
for (int k = 9; k >= 0; k--) {
for (int z = 0; z < d[k]; z++) t += (k + 48);
}
break;
}
}
}
if (u.size() == 1 || !u.size())
return t;
else
return u;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> a >> b;
for (auto c : a) d[c - 48]++;
if (a.length() < b.length()) {
for (int i = 9; i >= 0; i--) {
for (int k = 0; k < d[i]; k++) cout << i;
}
} else {
string r = solve(0, 1);
if (r.back() == '-') r.pop_back();
cout << r;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1000000];
int n, m, k;
long long ans;
vector<int> make(string a) {
int n = a.size();
vector<int> b;
for (auto i = 0; i < n; i++) b.push_back(a[i] - '0');
return b;
}
void solve() {
string a, b;
cin >> a >> b;
n = a.size();
m = b.size();
if (n < m) {
sort(a.begin(), a.end());
;
reverse(a.begin(), a.end());
cout << a;
return;
}
int i = 0;
string ans;
for (i = 0; i < n; i++) {
bool flag = true;
bool enter = false;
for (auto j = 0; j < n; j++) {
if (a[j] == b[i]) {
enter = true;
string c = a;
c.erase(j, 1);
sort(c.begin(), c.end());
;
string d = b.substr(i + 1, n - i - 1);
if (d < c)
flag = false;
else {
ans = ans + a[j];
a.erase(j, 1);
}
break;
}
if (!flag) break;
}
if (!enter) break;
if (!flag) break;
}
if (i < n) {
m = a.size();
sort(a.begin(), a.end());
;
reverse(a.begin(), a.end());
for (auto j = 0; j < m; j++) {
if (a[j] < b[i]) {
ans = ans + a[j];
a.erase(j, 1);
break;
}
}
sort(a.begin(), a.end());
;
reverse(a.begin(), a.end());
}
cout << ans << a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(vis, false, sizeof vis);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007, inf = 9223372036854775807;
int main() {
string a, b;
cin >> a >> b;
if (b.size() > a.size()) {
sort(a.rbegin(), a.rend());
cout << a << endl;
return 0;
}
int i, n = a.size();
vector<long long> s(10), t;
for (auto x : a) {
s[x - '0']++;
}
t = s;
string ans;
for (i = 0; i < n; i++) {
if (s[b[i] - '0']) {
ans += b[i];
s[b[i] - '0']--;
} else
break;
}
for (int k = i; i < n && k >= 0; k--) {
int j;
for (j = (b[k] - '0') - 1; j >= 0; j--) {
if (s[j]) {
string t;
for (i = 0; i < k; i++) t += ans[i];
ans = t;
ans += '0' + j;
break;
}
}
s[b[k - 1] - '0']++;
if (j != -1) break;
}
for (auto x : ans) t[x - '0']--;
for (i = 9; i >= 0; i--) {
while (t[i]) {
ans += '0' + i;
t[i]--;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long compute(const string& str) {
long long res = 0;
for (char c : str) {
res = res * 10 + (c - '0');
}
return res;
}
string minimal_suffix(const vector<int>& digit_count) {
string res;
for (int d = 0; d <= 9; ++d) {
for (int i = 0; i < digit_count[d]; ++i) {
res += '0' + d;
}
}
return res;
}
int main() {
string a, b;
cin >> a >> b;
if (b.size() > a.size()) {
sort(a.rbegin(), a.rend());
cout << a;
return 0;
}
vector<int> digit_count(10, 0);
for (char c : a) {
digit_count[c - '0']++;
}
string max_res;
for (int pos = 0; pos < a.size(); ++pos) {
for (int d = 9; d >= 0; --d) {
if (digit_count[d] == 0) continue;
string cur = max_res;
cur += '0' + d;
digit_count[d]--;
cur += minimal_suffix(digit_count);
if (compute(cur) <= compute(b)) {
max_res = cur.substr(0, pos + 1);
break;
} else {
digit_count[d]++;
}
}
}
cout << max_res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void preproc() {}
void solve() {
string a, b;
cin >> a >> b;
vector<int> cnt(10);
int beg = (int)b.size() - (int)a.size();
while (a.size() != b.size()) a = '0' + a;
for (char ch : a) {
++cnt[ch - '0'];
}
long long res = 0;
bool ok = false;
function<void(int, long long, long long)> dfs = [&](int pos, long long d,
long long bb) {
bb = bb * 10 + (b[pos] - '0');
if (pos == (int)b.size()) {
res = max(res, d);
ok = true;
return;
}
for (int cur = 9; cur >= 0; --cur) {
long long nw = d * 10 + cur;
if (!ok && cnt[cur] > 0 && nw <= bb) {
--cnt[cur];
dfs(pos + 1, nw, bb);
++cnt[cur];
}
}
};
long long bb = 0;
for (int pos = 0; pos < beg; ++pos) {
bb = bb * 10 + (b[pos] - '0');
}
dfs(beg, 0, bb);
cout << res << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
preproc();
int tc = 1;
for (int Tt = 1; Tt <= tc; ++Tt) {
solve();
}
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s1, s2;
cin >> s1 >> s2;
int sz1 = s1.size(), sz2 = s2.size();
sort(s1.begin(), s1.end(), greater<char>());
if (sz1 < sz2) {
for (int i = 0; i < sz1; i++) cout << s1[i];
} else {
map<int, int> mp;
for (int i = 0; i < sz1; i++) {
mp[s1[i] - '0']++;
}
string res = "";
for (int i = 0; i < sz2; i++) {
bool flag = false;
for (int j = s2[i] - '0'; j >= 0; j--) {
if (mp[j] > 0) {
res += (j + '0');
mp[j]--;
flag = true;
break;
}
}
if (!flag) {
bool stop = false;
for (int j = (int)res.size() - 1; j >= 0; j--) {
for (int k = 9; k >= 0; k--) {
if (mp[k] > 0 && k < s2[j] - '0') {
mp[k]--;
mp[s2[j] - '0']++;
res[j] = (k + '0');
stop = true;
break;
}
}
if (stop)
break;
else {
mp[s2[j] - '0']++;
res.erase(res.end() - 1);
}
}
if (stop) break;
}
if (res[res.size() - 1] < s2[i]) break;
}
for (int j = 9; j >= 0; j--) {
while (mp[j]) {
res += (j + '0');
mp[j]--;
}
}
cout << res;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string st, sss;
int b[19];
int a[10], aa[19], d[19];
long long ans;
bool cmp(int x, int y) { return x > y; }
void dp(int n, int s[], long long ss, int c[], int f) {
if ((unsigned int)n > st.size()) {
ans = max(ans, ss);
return;
}
int i;
if (f == 1) {
for (i = 9; i >= 0; i--) {
if (c[i] != 0) {
c[i]--;
s[n] = i;
dp(n + 1, s, ss * 10 + i, c, 1);
s[n] = 0;
c[i]++;
break;
}
}
} else {
int xx;
if (n == 1)
xx = 1;
else
xx = 0;
for (i = b[n]; i >= xx; i--) {
if (i == b[n] && c[i] != 0) {
c[i]--;
s[n] = i;
dp(n + 1, s, ss * 10 + i, c, 0);
s[n] = 0;
c[i]++;
} else if (c[i] != 0) {
c[i]--;
s[n] = i;
dp(n + 1, s, ss * 10 + i, c, 1);
s[n] = 0;
c[i]++;
break;
}
}
}
return;
}
int main() {
getline(cin, st);
getline(cin, sss);
int i;
for (i = 0; (unsigned int)i < st.size(); i++) {
a[st[i] - '0']++;
aa[i + 1] = st[i] - '0';
}
for (i = 0; (unsigned int)i < sss.size(); i++) {
b[i + 1] = sss[i] - '0';
}
if (st.size() < sss.size()) {
sort(aa + 1, aa + st.size() + 1, cmp);
for (i = 1; (unsigned int)i <= st.size(); i++) {
printf("%d", aa[i]);
}
return 0;
}
dp(1, d, 0, a, 0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[20];
int a2[22];
int len;
int res[22];
bool tag = false;
void dfs(int idx, bool flg) {
if (tag) return;
if (idx == len) {
tag = true;
return;
}
int t;
for (int i = 9; i >= 0; i--) {
if (vis[i] > 0) {
if (flg || i == a2[idx]) {
vis[i]--;
res[idx] = i;
dfs(idx + 1, flg);
if (tag) return;
vis[i]++;
} else if (i < a2[idx]) {
vis[i]--;
res[idx] = i;
dfs(idx + 1, true);
if (tag) return;
vis[i]++;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
string s1, s2;
cin >> s1 >> s2;
if (s1.size() < s2.size()) {
sort(s1.rbegin(), s1.rend());
cout << s1 << endl;
} else {
len = s1.size();
for (int i = 0; i < len; i++) {
vis[s1[i] - '0']++;
}
for (int i = 0; i < len; i++) {
a2[i] = s2[i] - '0';
}
dfs(0, false);
for (int i = 0; i < len; i++) {
cout << res[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
scanf("%lld%lld", &a, &b);
vector<int> digits(10, 0);
long long aCopy = a, bCopy = b;
int aDigitsCount = 0;
while (aCopy > 0) {
int digit = aCopy % 10;
aCopy /= 10;
digits[digit]++;
aDigitsCount++;
}
deque<int> bDigits;
while (bCopy > 0) {
int digit = bCopy % 10;
bCopy /= 10;
bDigits.push_front(digit);
}
long long value = 0;
if (aDigitsCount < bDigits.size()) {
while (aDigitsCount > 0) {
int digit = 9;
while (digit >= 0 && digits[digit] == 0) {
digit--;
}
value *= 10;
value += digit;
digits[digit]--;
aDigitsCount--;
}
} else {
bool less = false, backward = false;
int pos = 0;
while (pos < bDigits.size()) {
int bDigit = bDigits[pos];
if (less)
bDigit = 9;
else if (backward)
bDigit--;
while (bDigit >= 0 && digits[bDigit] == 0) {
bDigit--;
}
if (bDigit == bDigits[pos]) {
value *= 10;
value += bDigit;
digits[bDigit]--;
pos++;
} else if (bDigit >= 0) {
value *= 10;
value += bDigit;
digits[bDigit]--;
pos++;
less = true;
backward = false;
} else {
int previous = value % 10;
digits[previous]++;
value /= 10;
pos--;
backward = true;
}
}
}
printf("%lld", value);
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>
using namespace std;
void optimise() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
string s;
cin >> s;
string s2;
cin >> s2;
sort(s.begin(), s.end());
for (long long int i = 0; i < s.size(); i++) {
for (long long int j = i + 1; j < s.size(); j++) {
string k = s;
swap(k[i], k[j]);
if (stoll(k) >= stoll(s) && stoll(k) <= stoll(s2)) s = k;
}
}
cout << s;
}
signed main() {
optimise();
long long int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long bip(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
n >>= 1;
}
return res;
}
const int maxn = INT_MAX;
const long long inf = 1e18;
const int mod = 998244353;
const int N = 1e5 + 10;
void solve() {
string a, b;
cin >> a >> b;
if ((int)b.size() > (int)a.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a;
return;
}
vector<int> cnt(10, 0);
for (int i = 0; i < (int)a.size(); i++) cnt[a[i] - '0']++;
vector<int> ans;
for (int i = 0; i < (int)b.size(); i++) {
int k = b[i] - '0';
bool ok = 0;
for (int j = k; j >= 0; j--) {
if (cnt[j]) {
ok = 1;
cnt[j]--;
ans.push_back(j);
if (j < k) {
for (int l = 9; l >= 0; l--) {
while (cnt[l]--) ans.push_back(l);
}
for (auto it : ans) cout << it;
return;
}
break;
}
}
if (ok == 0) {
for (int p = i - 1; p >= 0; p--) {
int k = b[p] - '0';
ans.pop_back();
cnt[k]++;
bool ok = 0;
for (int j = k - 1; j >= 0; j--) {
if (cnt[j]) {
ok = 1;
break;
}
}
if (ok) {
for (int j = k - 1; j >= 0; j--) {
if (cnt[j]) {
ans.push_back(j);
cnt[j]--;
for (int l = 9; l >= 0; l--) {
while (cnt[l]--) ans.push_back(l);
}
for (auto it : ans) cout << it;
return;
}
}
}
}
}
}
for (auto it : ans) cout << it;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int tt = 1;
while (tt--) {
solve();
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> freq(300005, vector<long long>(27));
vector<long long> adj[300005];
vector<bool> visited;
vector<bool> rec;
string st;
long long expo(long long x, long long n, long long M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return (expo((x * x) % M, n / 2, M)) % M;
else
return (x * expo((x * x) % M, (n - 1) / 2, M)) % M;
}
bool sortbysec(pair<pair<long long, long long>, long long> p1,
pair<pair<long long, long long>, long long> p2) {
if (p1.first.first == p2.first.first)
return p1.first.second > p2.first.second;
return p1.first.first < p2.first.first;
}
bool findcycle(long long v) {
visited[v] = true;
rec[v] = true;
for (auto it : adj[v]) {
if (!visited[it]) {
if (findcycle(it)) return true;
} else if (rec[it])
return true;
}
rec[v] = false;
return false;
}
bool checkcycle(long long n) {
for (long long i = 1; i <= n; i++) {
if (!visited[i]) {
if (findcycle(i)) return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, j, k, a, b, c, t, x, y, n, m, z, flag = 0, ans = 0, sum = 0;
t = 1;
while (t--) {
string s1, s2;
cin >> s1 >> s2;
long long n1 = s1.length();
long long n2 = s2.length();
if (n1 < n2) {
sort(s1.rbegin(), s1.rend());
cout << s1;
return 0;
}
multiset<char, greater<char>> ms;
string ans = "";
for (i = 0; i < n1; i++) {
ms.insert(s1[i]);
}
for (i = 0; i < n1; i++) {
string curr;
vector<char> v;
for (auto it : ms) {
v.push_back(it);
}
n = v.size();
for (j = 0; j < n; j++) {
x = v[j];
curr = ans;
curr += x;
string tmp = "";
for (k = n - 1; k >= 0; k--) {
if (k != j) tmp += v[k];
}
curr += tmp;
if (curr <= s2) {
auto it = ms.find(x);
ms.erase(it);
ans += x;
break;
}
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string a, b;
cin >> a >> b;
if (a.size() < b.size()) {
sort(a.rbegin(), a.rend());
cout << a << "\n";
return 0;
}
string ans = "";
long long f[10] = {0};
for (auto c : a) f[c - '0']++;
for (long long i = 0; i < b.size(); i++) {
for (long long j = 9; j >= 0; j--) {
if (f[j] == 0) continue;
string cur = ans + char(j + '0');
f[j]--;
for (long long k = 0; k < 10; k++) {
long long cnt = f[k];
while (cnt > 0) {
cur += char(k + '0');
cnt--;
}
}
if (cur <= b) {
ans += char(j + '0');
break;
} else
f[j]++;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &t) {
for (auto i : t) os << i.first << " : " << i.second << '\n';
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v) is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
multiset<char> s;
string ans = "";
void solve() {
string a, b;
cin >> a >> b;
if (b.size() > a.size()) {
sort(a.begin(), a.end(), greater<char>());
cout << a << '\n';
return;
}
for (auto x : a) s.insert(x);
for (int i = 0; i < b.size() and !s.empty(); i++) {
auto it = s.upper_bound(b[i]);
if (it != s.begin()) {
char c = *prev(it);
ans += c;
s.erase(s.find(c));
if (c == b[i]) continue;
while (!s.empty()) {
ans += *prev(s.end());
s.erase(prev(s.end()));
}
break;
}
long long j = i - 1;
while (j >= 0) {
s.insert(ans.back());
ans.pop_back();
it = s.upper_bound(b[j]);
if (*prev(it) != b[j]) {
j--;
continue;
}
it = s.lower_bound(b[j]);
if (it == s.begin()) {
j--;
continue;
}
it = prev(it);
ans += *it;
s.erase(it);
break;
}
while (!s.empty()) {
ans += *prev(s.end());
s.erase(prev(s.end()));
}
break;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct lastHaveSmaller {
int smallerIndx;
string aCopy;
string resCopy;
lastHaveSmaller() {
smallerIndx = 0;
aCopy = "";
resCopy = "";
}
};
bool f(char a, char b) { return a > b; }
int main() {
string a, b, res = "";
cin >> a >> b;
lastHaveSmaller LHS;
sort(a.begin(), a.end(), f);
if (a.length() < b.length()) {
cout << a;
return 0;
}
for (int i = 0; i < b.length(); i++) {
int j = -1;
for (int k = 0; k < a.length(); k++) {
if (a[k] <= b[i]) {
j = k;
break;
}
}
if (j == -1) {
res = LHS.resCopy;
a = LHS.aCopy;
res += a[LHS.smallerIndx];
a.erase(a.begin() + LHS.smallerIndx);
res += a;
cout << res;
return 0;
} else if (a[j] == b[i]) {
int smaller = -1;
for (int k = 0; k < a.length(); k++) {
if (a[k] < b[i]) {
smaller = k;
break;
}
}
if (smaller != -1) {
LHS.aCopy = a;
LHS.resCopy = res;
LHS.smallerIndx = smaller;
}
res += a[j];
a.erase(a.begin() + j);
} else if (a[j] < b[i]) {
res += a[j];
a.erase(a.begin() + j);
res += a;
cout << res;
return 0;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
std::string memo[2][20];
static std::string go(const std::string& bound, const std::string& source,
std::vector<char>& used, const long long& k,
const bool& eq, std::string& curr) {
if (k >= bound.length()) return curr;
if (memo[eq][k] != "") return memo[eq][k];
char top = eq ? bound[k] : '9';
std::string ret = "0";
for (long long i = 0; i < source.length(); ++i) {
if (used[i] || source[i] > top) continue;
used[i] = true;
curr[k] = source[i];
ret = std::max(ret,
go(bound, source, used, k + 1, eq && curr[k] == top, curr));
used[i] = false;
}
return memo[eq][k] = ret;
}
int main(void) {
std::string a, b;
std::cin >> a >> b;
std::sort(a.begin(), a.end(),
[](const char& a, const char& b) { return a > b; });
if (a.length() < b.length()) {
std::cout << a << "\n";
return 0;
}
for (long long i = 0; i < 2; ++i) std::fill(memo[i], memo[i] + 20, "");
std::vector<char> used(a.length(), false);
std::string curr = a;
std::printf("%s\n", go(b, a, used, 0, true, curr).data());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
if (a.length() < b.length())
cout << a << endl;
else {
reverse(a.begin(), a.end());
for (int i = 0; i < a.length(); i++) {
c = a;
for (int j = a.length() - 1; j >= i; j--) {
char temp = a[i];
a[i] = a[j];
a[j] = temp;
sort(a.begin() + i + 1, a.end());
if (a > b) {
a = c;
} else
break;
}
}
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[20], b[20];
int t[12], c[20];
inline void work1() {
for (int i = 9; i >= 0; i--)
if (t[i]) printf("%d", i), t[i]--, i++;
}
inline void out() {
for (int i = 0; i < strlen(a); i++) printf("%d", c[i]);
}
inline void dfs(int x, int flag) {
if (x == strlen(a)) {
out(), exit(0);
}
if (flag) {
int num = b[x] - '0';
if (t[num]) c[x] = num, t[num]--, dfs(x + 1, flag), t[num]++;
for (int i = num - 1; i >= 0; i--)
if (t[i]) {
c[x] = i, t[i]--, dfs(x + 1, 0), t[i]++;
break;
}
} else {
for (int i = 9; i >= 0; i--)
if (t[i]) {
c[x] = i;
t[i]--;
dfs(x + 1, 0), t[i]++;
break;
}
}
}
int main() {
scanf("%s%s", a, b);
for (int i = 0; i < strlen(a); i++) t[a[i] - '0']++;
if (strlen(a) < strlen(b)) work1(), exit(0);
dfs(0, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r, b, i, j;
string cad, cad2, cad3, cad4, resp;
cin >> cad >> cad2;
sort(cad.begin(), cad.end());
pos = cad.size();
if (pos == cad2.size()) {
for (i = 0; i < pos; i++) {
cad4.clear();
for (j = i + 1; j < cad2.size(); j++) {
cad4 = cad4 + cad2[j];
}
b = cad.size();
for (j = 0; j < b; j++) {
cad3.clear();
for (r = 0; r < j; r++) {
cad3 = cad3 + cad[r];
}
for (r = j + 1; r < b; r++) {
cad3 = cad3 + cad[r];
}
if (cad3 > cad4 && cad[j] == cad2[i]) {
j--;
break;
} else {
if (cad[j] > cad2[i]) {
j--;
break;
}
}
}
if (j == b) j--;
cad3.clear();
for (r = 0; r < j; r++) {
cad3 = cad3 + cad[r];
}
for (r = j + 1; r < b; r++) {
cad3 = cad3 + cad[r];
}
resp = resp + cad[j];
if (cad[j] < cad2[i]) {
for (r = b - 1; r > j; r--) {
resp = resp + cad[r];
}
for (r = j - 1; r >= 0; r--) {
resp = resp + cad[r];
}
cout << resp;
return 0;
}
cad.clear();
cad = cad3;
}
} else {
for (j = cad.size() - 1; j >= 0; j--) {
resp = resp + cad[j];
}
}
cout << resp;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long, long long);
long long mpower(long long, long long);
long long BIT[1000009];
long long query(long long);
void update(long long, long long);
vector<pair<long long, long long>> graph[1000009];
long long vis[1000009];
long long dis[1000009];
long long inc[1000009];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b, w;
cin >> a >> b >> w;
graph[a].push_back({b, w});
graph[b].push_back({a, w});
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (long long i = 1; i <= n; i++) {
cin >> dis[i];
inc[i] = dis[i];
pq.push({dis[i], i});
}
while (!pq.empty()) {
long long t = pq.top().second;
pq.pop();
if (vis[t]) continue;
vis[t] = 1;
for (pair<long long, long long> w : graph[t]) {
long long u = w.first;
long long wt = w.second;
;
if (dis[u] > dis[t] + 2 * wt) {
dis[u] = dis[t] + 2 * wt;
pq.push({dis[u], u});
}
}
}
for (long long i = 1; i <= n; i++) {
cout << dis[i] << " ";
}
return 0;
}
void update(long long x, long long delta) {
for (; x < 1000009; x += x & -x) BIT[x] += delta;
}
long long query(long long x) {
long long sum = 0;
for (; x > 0; x -= x & -x) sum += BIT[x];
return sum;
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) res = res * a;
a = a * a;
b = b / 2;
}
return res;
}
long long mpower(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b = b / 2;
}
return res;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
vector<vector<pll>> edges;
void solve() {
ll n, m;
cin >> n >> m;
edges.resize(n);
for (int i = 0, _n = (m); i < _n; i++) {
ll u, v, w;
cin >> u >> v >> w;
u--;
v--;
edges[u].push_back({v, w});
edges[v].push_back({u, w});
}
vector<long long> a(n);
for (int i = 0, _n = (n); i < _n; i++) cin >> a[i];
set<pll> second;
for (int i = 0, _n = (n); i < _n; i++) {
second.insert({a[i], i});
}
vector<bool> vis(n, 0);
while (!second.empty()) {
auto root = *(second.begin());
second.erase(second.begin());
for (auto& child : edges[root.second]) {
if (vis[child.first]) continue;
ll to = child.first;
ll wt = child.second;
if (2 * wt + root.first < a[to]) {
second.erase({a[to], to});
a[to] = 2 * wt + root.first;
second.insert({a[to], to});
}
}
vis[root.second] = 1;
}
for (auto& elem : a) {
cout << elem << ' ';
}
cout << '\n';
return;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<int, long long>>> gr(n);
for (int _ = 0; _ < m; ++_) {
int a, b;
long long w;
cin >> a >> b >> w;
--a;
--b;
gr[a].push_back({b, 2LL * w});
gr[b].push_back({a, 2LL * w});
}
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
vector<long long> dist(n);
for (int i = 0; i < n; ++i) {
cin >> dist[i];
q.push({dist[i], i});
}
while (!q.empty()) {
long long currLen = q.top().first;
int curr = q.top().second;
q.pop();
if (dist[curr] != currLen) {
continue;
}
for (auto& next : gr[curr]) {
if (dist[next.first] > dist[curr] + next.second) {
dist[next.first] = dist[curr] + next.second;
q.push({dist[next.first], next.first});
}
}
}
for (int i = 0; i < n; ++i) {
cout << dist[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Graph {
struct Edge {
int to;
long long cost;
Edge(int to, long long cost) : to(to), cost(cost) {}
};
vector<vector<Edge>> es;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
Graph g;
g.es.resize(n);
for (int i = 0; i < m; ++i) {
int a, b;
long long w;
cin >> a >> b >> w;
g.es[a - 1].emplace_back(b - 1, w);
g.es[b - 1].emplace_back(a - 1, w);
}
auto dist = vector<long long>(n);
for (int v = 0; v < n; ++v) cin >> dist[v];
auto comp = [&](int v1, int v2) {
return tie(dist[v1], v1) < tie(dist[v2], v2);
};
auto q = set<int, decltype(comp)>(comp);
for (int v = 0; v < n; ++v) q.insert(v);
while (not q.empty()) {
auto v = *q.begin();
q.erase(q.begin());
for (auto&& e : g.es[v]) {
if (dist[v] + 2 * e.cost < dist[e.to]) {
q.erase(q.find(e.to));
dist[e.to] = dist[v] + 2 * e.cost;
q.insert(e.to);
}
}
}
for (int v = 0; v < n; ++v) cout << dist[v] << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
set<pair<long long, int> > ord;
vector<pair<int, long long> > E[N];
long long sol[N];
int main() {
int n, m, u, v, i;
long long w;
scanf("%i %i", &n, &m);
while (m--) {
scanf("%i %i %lld", &u, &v, &w);
w *= 2;
E[u].push_back(make_pair(v, w));
E[v].push_back(make_pair(u, w));
}
for (i = 1; i <= n; i++)
scanf("%lld", &sol[i]), ord.insert(make_pair(sol[i], i));
while (!ord.empty()) {
u = ord.begin()->second;
ord.erase(ord.begin());
for (i = 0; i < E[u].size(); i++) {
v = E[u][i].first;
w = E[u][i].second;
if (sol[v] > sol[u] + w) {
ord.erase(make_pair(sol[v], v));
sol[v] = sol[u] + w;
ord.insert(make_pair(sol[v], v));
}
}
}
for (i = 1; i <= n; i++) printf("%lld ", sol[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long arr = 4e5;
vector<pair<long long, long long> > vec[arr];
long long a[arr];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
while (m--) {
long long u, v, c;
cin >> u >> v >> c;
vec[u].push_back({v, 2 * c});
vec[v].push_back({u, 2 * c});
}
set<pair<long long, long long> > setik;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
setik.insert({a[i], i});
}
while (!setik.empty()) {
pair<long long, long long> now = *setik.begin();
setik.erase(now);
long long u = now.second;
for (auto i : vec[u])
if (a[i.first] > a[u] + i.second) {
setik.erase({a[i.first], i.first});
a[i.first] = a[u] + i.second;
setik.insert({a[i.first], i.first});
}
}
for (long long i = 1; i <= n; i++) cout << a[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<pair<int, long long> > > g(1 + n);
for (int i = 0; i < m; ++i) {
int v1, v2;
long long w;
cin >> v1 >> v2 >> w;
g[v1].push_back({v2, w * 2});
g[v2].push_back({v1, w * 2});
}
const long long INF = LONG_LONG_MAX;
vector<long long> a(1 + n);
vector<long long> dist(1 + n, INF);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
dist[i] = a[i];
pq.push({a[i], i});
}
while (!pq.empty()) {
int v = pq.top().second;
long long curDist = pq.top().first;
pq.pop();
if (curDist > dist[v]) {
continue;
}
for (auto next : g[v]) {
int to = next.first;
long long len = next.second;
if (dist[v] + len < dist[to]) {
dist[to] = dist[v] + len;
pq.push({dist[to], to});
}
}
}
for (int v = 1; v <= n; ++v) {
cout << dist[v] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans[234567];
vector<pair<int, long long>> gr[234567];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int v, u;
long long w;
cin >> v >> u >> w;
gr[v].push_back({u, 2 * w});
gr[u].push_back({v, 2 * w});
}
set<pair<long long, int>> que;
for (int i = 1; i <= n; ++i) {
cin >> ans[i];
que.insert({ans[i], i});
}
while (que.size()) {
auto tmp = *que.begin();
que.erase(tmp);
for (auto u : gr[tmp.second]) {
if (ans[u.first] > ans[tmp.second] + u.second) {
que.erase({ans[u.first], u.first});
ans[u.first] = ans[tmp.second] + u.second;
que.insert({ans[u.first], u.first});
}
}
}
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, M = 600005;
struct edge {
int to, nxt;
long long val;
} e[M];
struct node {
int now;
long long val;
bool operator<(const node &x) const { return x.val < val; }
};
int head[N], n, m, cnt = 0;
long long a[N], dist[N];
bool vis[N];
priority_queue<node> q;
void addedge(int x, int y, long long z) {
++cnt;
e[cnt].to = y;
e[cnt].nxt = head[x];
e[cnt].val = z;
head[x] = cnt;
}
void dij() {
memset(dist, 0x3f3f3f, sizeof(dist));
dist[1] = 0;
q.push((node){1, 0});
while (!q.empty()) {
node s = q.top();
q.pop();
int x = s.now;
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (dist[x] + e[i].val < dist[v]) {
dist[v] = dist[x] + e[i].val;
if (!vis[v]) {
q.push((node){v, dist[v]});
}
}
}
}
return;
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y;
long long z;
scanf("%d%d%lld", &x, &y, &z);
addedge(x + 1, y + 1, z * 2ll);
addedge(y + 1, x + 1, z * 2ll);
}
for (int i = 2; i <= n + 1; ++i) {
scanf("%lld", &a[i]);
addedge(1, i, a[i]);
}
dij();
for (int i = 2; i <= n; ++i) printf("%lld ", dist[i]);
printf("%lld\n", dist[n + 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> adj[500005];
long long dist[500005], a[500005];
long long n;
void dijsktra() {
set<pair<long long, long long>> pq;
for (long long i = 0; i < n; i++) {
dist[i] = a[i];
pq.insert({dist[i], i});
}
while (!pq.empty()) {
long long u = pq.begin()->second;
pq.erase(pq.begin());
for (auto x : adj[u]) {
long long v = x.first;
long long w = x.second;
if (w + dist[u] < dist[v]) {
pq.erase({dist[v], v});
dist[v] = dist[u] + w;
pq.insert({dist[v], v});
}
}
}
}
void solve() {
long long m;
cin >> n >> m;
for (long long i = 0; i < n; i++) a[i] = 1e18, dist[i] = 1e18;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--;
v--;
adj[u].push_back({v, 2 * w});
adj[v].push_back({u, 2 * w});
}
for (long long i = 0; i < n; i++) cin >> a[i];
dijsktra();
for (long long i = 0; i < n; i++) cout << dist[i] << " ";
cout << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
long long d[200001];
std::vector<std::vector<std::pair<int, long long> > > G(200001);
std::priority_queue<std::pair<long long, int> > Q;
int main() {
std::cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%I64d", &u, &v, &w);
G[u].push_back(std::make_pair(v, w));
G[v].push_back(std::make_pair(u, w));
}
for (int i = 1; i <= n; i++) {
scanf("%I64d", &d[i]);
Q.push(std::make_pair(-d[i], i));
}
while (!Q.empty()) {
std::pair<long long, int> p;
p = Q.top();
Q.pop();
if (-d[p.second] != p.first) continue;
for (int i = 0; i < G[p.second].size(); i++) {
if (G[p.second][i].second * 2 + (-p.first) < d[G[p.second][i].first]) {
d[G[p.second][i].first] = G[p.second][i].second * 2 + (-p.first);
Q.push(std::make_pair(-d[G[p.second][i].first], G[p.second][i].first));
}
}
}
for (int i = 1; i <= n; i++) printf("%I64d ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, maxm = maxn * 3;
int n, m, i, s, x, y, head[maxn];
long long z, d[maxn];
struct node {
int to, nxt;
long long w;
} e[maxm];
struct mdata {
int x;
long long y;
bool operator<(const mdata& a) const { return y > a.y; }
} p, k;
priority_queue<mdata> q;
inline long long read() {
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
inline void add(int x, int y, long long z) {
e[++s].to = y;
e[s].nxt = head[x];
e[s].w = z;
head[x] = s;
}
void Dijkstra() {
memset(d, 0x6f, sizeof(d));
d[0] = 0;
p.x = p.y = 0;
q.push(p);
while (q.empty() == 0) {
p = q.top();
q.pop();
if (p.y != d[p.x]) continue;
for (int i = head[p.x]; i; i = e[i].nxt)
if (d[p.x] + e[i].w < d[e[i].to]) {
d[e[i].to] = d[p.x] + e[i].w;
k.x = e[i].to;
k.y = d[k.x];
q.push(k);
}
}
}
int main() {
n = read();
m = read();
s = 0;
for (i = 1; i <= m; i++) {
x = read();
y = read();
z = read();
z *= 2;
add(x, y, z);
add(y, x, z);
}
for (i = 1; i <= n; i++) {
z = read();
add(0, i, z);
}
Dijkstra();
for (i = 1; i <= n; i++) printf("%lld ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 6;
long long int n, m;
vector<pair<long long int, long long int> > edg[MAX];
long long int ara[MAX], dist[MAX], taken[MAX];
void solve() {
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
for (int i = 1; i <= n; i++) pq.push({ara[i], i});
while (!pq.empty()) {
long long int topnode = pq.top().second;
long long int topwt = pq.top().first;
pq.pop();
if (topwt > dist[topnode]) continue;
for (auto x : edg[topnode]) {
long long int xx = x.first;
long long int wt = x.second;
if (topwt + wt * 2 < dist[xx]) {
dist[xx] = topwt + wt * 2;
pq.push({dist[xx], xx});
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
while (m--) {
long long int u, v, w;
cin >> u >> v >> w;
edg[u].push_back({v, w});
edg[v].push_back({u, w});
}
for (int i = 1; i <= n; i++) {
cin >> ara[i];
dist[i] = ara[i];
}
solve();
for (int i = 1; i <= n; i++) cout << dist[i] << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
uint64_t n, m, d[N], c, u, w;
vector<pair<int, uint64_t> > v[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> c >> u >> w;
v[u].push_back(make_pair(c, 2 * w));
v[c].push_back(make_pair(u, 2 * w));
}
set<pair<uint64_t, int> > q;
for (int i = 1; i <= n; i++)
scanf("%I64d", &d[i]), q.insert(make_pair(d[i], i));
while (q.size()) {
int64_t sd = q.begin()->first, i = q.begin()->second;
q.erase(q.begin());
if (d[i] != sd) continue;
for (int j = 0; j < v[i].size(); j++)
if (d[v[i][j].first] > v[i][j].second + sd) {
d[v[i][j].first] = v[i][j].second + sd;
q.insert(make_pair(d[v[i][j].first], v[i][j].first));
}
}
for (int i = 1; i <= n; i++) printf("%I64d ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long n, m, a, u, v, w, d[200010];
vector<vector<pair<long long, long long> > > g;
set<pair<long long, long long> > se;
void solve() {
se.insert({0, n + 1});
while (!se.empty()) {
pair<int, int> now = *se.begin();
se.erase(se.begin());
long long v = now.second;
for (long long i = 0; i < g[v].size(); i++) {
long long len = g[v][i].second, to = g[v][i].first;
if (d[v] + len < d[to]) {
se.erase({d[to], to});
d[to] = d[v] + len;
se.insert({d[to], to});
}
}
}
}
int main() {
cin >> n >> m;
g.resize(n + 2);
for (long long i = 0; i < m; i++) {
cin >> u >> v >> w;
g[u].push_back({v, 2 * w});
g[v].push_back({u, 2 * w});
}
for (long long i = 1; i <= n; i++) {
cin >> a;
g[n + 1].push_back({i, a});
g[i].push_back({n + 1, a});
d[i] = INF;
}
d[n + 1] = 0;
solve();
for (long long i = 1; i <= n; i++) {
cout << d[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
map<int, map<int, long long>> t;
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d %d %lld", &u, &v, &w);
u--;
v--;
t[u].insert(make_pair(v, w));
t[v].insert(make_pair(u, w));
}
priority_queue<pair<long long, int>> p;
long long ta[200001] = {0};
for (int i = 0; i < n; i++) {
long long a;
scanf("%lld", &a);
ta[i] = a;
p.push(make_pair(-a, i));
}
int visited[200001] = {0};
while (!p.empty()) {
pair<long long, int> firstp = p.top();
p.pop();
int num = firstp.second;
if (!visited[num]) {
long long vtoprop = ta[num];
visited[num] = true;
for (auto it : t[num]) {
if (!visited[it.first]) {
long long exta = ta[it.first];
long long nv = 2 * it.second + vtoprop;
if (exta > nv) {
ta[it.first] = nv;
p.push(make_pair(-nv, it.first));
}
}
}
}
}
for (int i = 0; i < n; i++) {
cout << ta[i] << " ";
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
vector<pair<long long, int> > graph[MAXN];
long long minDistance[MAXN];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int in, out;
long long weight;
scanf("%d%d%lld", &in, &out, &weight);
graph[out].push_back({weight * 2, in});
graph[in].push_back({weight * 2, out});
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &minDistance[i]);
pq.push({minDistance[i], i});
}
while (!pq.empty()) {
int u = pq.top().second;
long long price = pq.top().first;
pq.pop();
if (minDistance[u] != price) {
continue;
}
for (auto e : graph[u]) {
int v = e.second;
if (minDistance[v] > e.first + minDistance[u]) {
minDistance[v] = e.first + minDistance[u];
pq.push({minDistance[v], v});
}
}
}
for (int i = 1; i <= n; i++) {
printf("%lld ", minDistance[i]);
}
puts("");
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct graph {
int to, next;
long long val;
} gr[N << 2];
int n, m, cnt, head[N];
long long dis[N];
void border(int u, int v, long long w) {
gr[++cnt].to = v;
gr[cnt].val = w;
gr[cnt].next = head[u];
head[u] = cnt;
return;
}
void dijkstra(int s) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
for (int i = 1; i <= n; i++) dis[i] = 1e18;
dis[s] = 0;
q.push(make_pair(dis[s], s));
while (!q.empty()) {
int u = q.top().second;
long long diss = q.top().first;
q.pop();
if (diss != dis[u]) continue;
for (int i = head[u]; i; i = gr[i].next) {
int v = gr[i].to;
if (dis[v] > dis[u] + gr[i].val) {
dis[v] = dis[u] + gr[i].val;
q.push(make_pair(dis[v], v));
}
}
}
return;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
border(u, v, 2 * w);
border(v, u, 2 * w);
}
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
border(0, i, x);
}
dijkstra(0);
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ui = unsigned int;
const int NMax = 2e5 + 5;
const ll inf = 1e18 + 5;
const int mod = 100003;
using zint = int;
int N, M;
ll dist[NMax];
vector<pair<int, ll> > v[NMax];
struct cmp {
bool operator()(pair<int, ll> a, pair<int, ll> b) {
return a.second > b.second;
}
};
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (int i = 1; i <= M; ++i) {
int x, y;
ll c;
cin >> x >> y >> c;
v[x].push_back({y, 2 * c});
v[y].push_back({x, 2 * c});
}
priority_queue<pair<int, ll>, vector<pair<int, ll> >, cmp> pq;
for (int i = 1; i <= N; ++i) {
ll d;
cin >> d;
v[0].push_back({i, d});
dist[i] = inf;
}
dist[0] = 0;
pq.push({0, 0});
while (pq.size()) {
int node = pq.top().first;
ll d = pq.top().second;
pq.pop();
if (dist[node] < d) {
continue;
}
for (auto p : v[node]) {
int nxt = p.first;
ll d = p.second;
if (dist[nxt] <= dist[node] + d) {
continue;
}
dist[nxt] = dist[node] + d;
pq.push({nxt, dist[nxt]});
}
}
for (int i = 1; i <= N; ++i) {
cout << dist[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000LL * 1000 * 1000 + 7;
const long long INF = 1LL * 1000 * 1000 * 1000 * 1000 * 1000;
const long long base = 1e18;
const int MAXN = 600000;
const double EPS = 1e-9;
const double PI = acos(-1.);
vector<pair<long long, long long> > g[200003];
int n, m, v1, v2;
int main() {
cin >> n >> m;
int second = n + 1;
for (int i = (0); i < (m); ++i) {
long long x, y, z;
cin >> x >> y >> z;
x--;
y--;
g[x].push_back(make_pair(y, 2 * z));
g[y].push_back(make_pair(x, 2 * z));
}
for (int i = (0); i < (n); ++i) {
long long x;
cin >> x;
g[second].push_back(make_pair(i, x));
g[i].push_back(make_pair(second, x));
}
n += 2;
vector<long long> d(n, INF), p(n);
d[second] = 0;
priority_queue<pair<long long, long long> > q;
q.push(make_pair(0, second));
while (!q.empty()) {
long long v = q.top().second, cur_d = -q.top().first;
q.pop();
if (cur_d > d[v]) continue;
for (size_t j = 0; j < g[v].size(); ++j) {
long long to = g[v][j].first, len = g[v][j].second;
if (d[v] + len < d[to]) {
d[to] = d[v] + len;
p[to] = v;
q.push(make_pair(-d[to], to));
}
}
}
for (int i = 0; i < n - 2; ++i) {
cout << d[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = (long long)1e18 + 7;
const int maxn = 1e6 + 7;
const int maxm = 2e6 + 7;
struct ed {
int to, nxt;
long long w;
} edge[maxm];
struct node {
int index;
long long w;
friend bool operator<(const node& x, const node& y) { return x.w < y.w; }
friend bool operator>(const node& x, const node& y) { return y < x; }
};
long long dist[maxn];
int n, m, s;
std::priority_queue<node, std::vector<node>, std::greater<node> > q;
int cnt = 1, head[maxn];
bool vis[maxn];
inline void add(int u, int v, long long w) {
edge[cnt].w = w;
edge[cnt].to = v;
edge[cnt].nxt = head[u];
head[u] = cnt++;
}
void dijkstra() {
node _;
_.index = s;
_.w = 0;
q.push(_);
while (!q.empty()) {
node a = q.top();
q.pop();
int x = a.index;
if (vis[x]) continue;
vis[x] = 1;
for (int it = head[x]; it; it = edge[it].nxt) {
if (dist[x] + edge[it].w < dist[edge[it].to]) {
dist[edge[it].to] = dist[x] + edge[it].w;
node b;
b.w = dist[edge[it].to];
b.index = edge[it].to;
q.push(b);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d", &u, &v);
std::cin >> w;
add(u, v, 2 * w), add(v, u, 2 * w);
}
for (int i = 1; i <= n; ++i) {
long long w;
std::cin >> w;
add(i, n + 1, w), add(n + 1, i, w);
}
for (int i = 1; i <= n + 1; i++) dist[i] = INF;
s = n + 1;
dist[s] = 0;
dijkstra();
for (int i = 1; i <= n; i++) std::cout << dist[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
inline void in(long long &x) {
int f = 1;
x = 0;
char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s <= '9' && s >= '0') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
long long n, m;
struct Edge {
long long v, w;
};
vector<Edge> g[maxn];
long long vis[maxn], d[maxn];
void spfa(long long s) {
memset(d, 0x3f, sizeof(d));
deque<long long> q;
d[s] = 0;
q.push_back(s);
vis[s] = 1;
while (!q.empty()) {
long long u = q.front();
q.pop_front();
vis[u] = 0;
int k = g[u].size();
for (register int i = 0; i < k; i++) {
Edge e = g[u][i];
long long w = e.w, v = e.v;
if (d[u] + w < d[v]) {
d[v] = d[u] + w;
if (vis[v] == 0) {
if (!q.empty() && d[v] < d[q.front()])
q.push_front(v);
else
q.push_back(v);
vis[v] = 1;
}
}
}
}
}
int main() {
in(n), in(m);
for (register long long i = 1; i <= m; ++i) {
long long u, v, k;
in(u), in(v), in(k);
g[u].push_back((Edge){v, k * 2});
g[v].push_back((Edge){u, k * 2});
}
for (register long long i = 1; i <= n; ++i) {
long long a;
in(a);
g[0].push_back((Edge){i, a});
}
spfa(0);
for (long long i = 1; i <= n; i++) {
printf("%I64d ", d[i]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.