text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long n, k, a[N];
long long pre[N], precnt[N];
int b[N], now, num = 1;
long long cnt[N];
long long cal(long long val, int x) {
if (cnt[x] >= k) return 0;
int res = k - cnt[x];
long long q1 = precnt[x - 1] * (val - 1) - pre[x - 1];
long long q2 = pre[now] - pre[x] - (precnt[now] - precnt[x]) * (val + 1);
long long ans1 = 0, ans2 = 0, ans3 = 0;
if (precnt[x - 1] >= res)
ans1 = q1 + res;
else
ans1 = 1e18;
if (precnt[now] - precnt[x] >= res)
ans2 = q2 + res;
else
ans2 = 1e18;
ans3 = q1 + q2 + res;
ans1 = min(ans1, ans2);
ans1 = min(ans1, ans3);
return ans1;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] != a[i + 1]) {
now++;
b[now] = a[i];
cnt[now] = num;
num = 1;
} else
num++;
}
for (int i = 1; i <= now; i++)
pre[i] = pre[i - 1] + b[i] * cnt[i], precnt[i] = precnt[i - 1] + cnt[i];
long long ans = 1e18;
for (int i = 1; i <= now; i++) {
ans = min(ans, cal(b[i], i));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("03")
using namespace std;
long long int const mod = 1000000007;
long long int br[200100][61];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k, x, ans = 1e12, mx = 0, cnt, k1, d;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> x;
mx = max(mx, x);
cnt = 0;
while (x >= 1) {
br[x][cnt] += 1;
x /= 2;
cnt += 1;
}
}
for (long long int i = 0; i <= mx; i++) {
k1 = k;
cnt = 0;
for (long long int j = 0; j <= 60 && k1 > 0; j++) {
d = min(k1, br[i][j]);
cnt += d * j;
k1 -= d;
}
if (k1 == 0) ans = min(ans, cnt);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
bool chmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
lint sol2(vector<lint> A, lint K, lint t) {
for (auto x : A)
if (x == t) K--;
if (K <= 0) return 0;
int nb = 0;
lint cost = 0;
for (auto x : A)
if (x < t) cost += t - x, nb++;
if (nb < K)
return 1e18;
else
return cost - (nb - K);
}
lint solve(vector<lint> A, lint K) {
map<lint, int> cnt;
for (auto x : A) cnt[x]++;
for (auto p : cnt)
if (p.second >= K) return 0;
lint tmp = sol2(A, K, A[K - 1]);
if (K < A.size()) chmin(tmp, sol2(A, K, A[K]));
lint med = A[A.size() / 2];
int notsame = 0;
lint c2 = 0;
for (auto x : A) {
c2 += abs(med - x);
if (x != med) notsame++;
}
c2 -= min<int>(notsame, A.size() - K);
chmin(tmp, c2);
return tmp;
}
int main() {
int N, K;
cin >> N >> K;
vector<lint> A(N);
cin >> A;
sort(A.begin(), A.end());
lint ret1 = solve(A, K);
for (auto &a : A) a = 1010101010 - a;
sort(A.begin(), A.end());
lint ret2 = solve(A, K);
cout << min(ret1, ret2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int _toggle(int N, int pos) { return N = N ^ (1 << pos); }
int _set(int N, int pos) { return N = N | (1 << pos); }
int _reset(int N, int pos) { return N = N & ~(1 << pos); }
bool _check(int N, int pos) { return (bool)(N & (1 << pos)); }
bool _upper(char a) { return a >= 'A' && a <= 'Z'; }
bool _lower(char a) { return a >= 'a' && a <= 'z'; }
bool _digit(char a) { return a >= '0' && a <= '9'; }
int dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
vector<int> v[2 * 100010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
int mx = 0;
for (int i = 1; i <= n; i++) {
int cnt = 0, a;
cin >> a;
mx = max(a, mx);
while (a) v[a].push_back(cnt++), a /= 2;
v[a].push_back(cnt);
}
int ans = INT_MAX;
for (int i = 0; i <= mx; i++) {
int x = v[i].size();
if (x < k) continue;
sort(v[i].begin(), v[i].end());
int cnt = 0;
for (int j = 0; j < k; j++) cnt += v[i][j];
ans = min(ans, cnt);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const long long INF = 10000000000000;
const long long mod = 1e9 + 7;
using namespace std;
void add(long long& a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
long long mul(long long a, long long b) { return (a * b) % mod; }
long long Pow(long long a, long long b) {
if (b == 0) return 1;
long long c = Pow(a, b / 2);
if (b % 2) return (a * ((c * c) % mod)) % mod;
return (c * c) % mod;
}
long long count(long long a, long long b, long long m) {
if (a % m == 0) return b / m - a / m + 1;
return b / m - a / m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(30);
int n, k;
cin >> n >> k;
std::vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<long long>> v(2e5 + 1);
for (int i = 0; i < n; i++) {
int nb = 0;
while (a[i]) {
v[a[i]].push_back(nb);
a[i] /= 2;
nb++;
}
}
long long ans = 1e18;
for (int i = 1; i <= 2e5; i++) {
if ((int)v[i].size() >= k) {
sort(v[i].begin(), v[i].end());
long long sum = 0;
for (int j = 0; j < k; j++) sum += v[i][j];
ans = min(ans, sum);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string my_to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string my_to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string my_to_string(tuple<A, B, C, D> p);
string my_to_string(const string& s) { return '"' + s + '"'; }
string my_to_string(const char* s) { return my_to_string((string)s); }
string my_to_string(bool b) { return (b ? "true" : "false"); }
string my_to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += my_to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string my_to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
string my_to_string(uint8_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(uint16_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(uint32_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(uint64_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(int8_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(int16_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(int32_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(int64_t a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(float a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(double a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(long double a) {
ostringstream ss;
ss << a;
return ss.str();
}
string my_to_string(char a) {
ostringstream ss;
ss << '\'' << a << '\'';
return ss.str();
}
template <typename A>
string my_to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += my_to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string my_to_string(pair<A, B> p) {
return "(" + my_to_string(p.first) + ", " + my_to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string my_to_string(tuple<A, B, C> p) {
return "(" + my_to_string(get<0>(p)) + ", " + my_to_string(get<1>(p)) + ", " +
my_to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string my_to_string(tuple<A, B, C, D> p) {
return "(" + my_to_string(get<0>(p)) + ", " + my_to_string(get<1>(p)) + ", " +
my_to_string(get<2>(p)) + ", " + my_to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << my_to_string(H);
debug_out(T...);
}
const int MX = 2e5 + 99;
int n, k;
long long a[MX];
map<int, int> M;
long long solveX(long long X) {
long long cntL = 0;
long long cntR = 0;
long long sumL = 0, sumR = 0;
for (int i = 0; i < n; i++) {
if (a[i] < X) {
sumL += (X - 1 - a[i]);
cntL++;
} else if (X < a[i]) {
sumR += a[i] - (X + 1);
cntR++;
}
}
long long cntX = M[X];
long long result = sumL + sumR + (k - cntX);
if (cntL + cntX >= k) {
result = min(result, sumL + (k - cntX));
}
if (cntR + cntX >= k) {
result = min(result, sumR + (k - cntX));
}
42;
return result;
}
long long solve() {
sort(a, a + n);
for (int i = 0; i < n; i++) M[a[i]]++;
for (auto it : M) {
if (it.second >= k) return 0;
}
set<long long> S;
int mn = a[0], mx = a[n - 1];
for (int i = 0; i < n; i++) {
S.insert(a[i]);
if (mn <= a[i] - 1) S.insert(a[i] - 1);
if (a[i] + 1 <= mx) S.insert(a[i] + 1);
}
long long res = 1e15;
42;
long long cntL = 0, cntR = 0, sumL = 0, sumR = 0;
int itL = 0, itR = n - 1;
for (long long X : S) {
while (itL < n && a[itL] <= X - 1) {
cntL++;
sumL += a[itL];
itL++;
}
while (0 <= itR && X + 1 <= a[itR]) {
cntR++;
sumR += a[itR];
itR--;
}
while (itR + 1 < n && a[itR + 1] < X + 1) {
itR++;
sumR -= a[itR];
cntR--;
}
long long sumL2 = (X - 1) * cntL - sumL;
long long sumR2 = sumR - (X + 1) * cntR;
long long cntX = M[X];
long long result = sumL2 + sumR2 + (k - cntX);
if (cntL + cntX >= k) {
result = min(result, sumL2 + (k - cntX));
}
if (cntR + cntX >= k) {
result = min(result, sumR2 + (k - cntX));
}
res = min(res, result);
}
42;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
cout << solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i];
sort(a.begin(), a.end());
vector<pair<long long, int>> b;
int cnt = 1;
for (int i = (int)(1); i < (int)(n); i++) {
if (a[i] == a[i - 1])
cnt++;
else {
b.push_back(make_pair(a[i - 1], cnt));
cnt = 1;
}
}
b.push_back(make_pair(a[n - 1], cnt));
long long sum = 0, num = 0;
long long tot = 0, num1 = n;
long long ans = 1e18;
for (int i = 0; i < (int)(b.size()); i++)
tot += (b[i].first * (long long)(b[i].second));
for (int i = 0; i < (int)(b.size()); i++) {
tot -= (b[i].first * (long long)(b[i].second));
num1 -= b[i].second;
int cur = b[i].second;
if (cur >= k) {
ans = 0;
break;
}
int need = k - cur;
long long lw = ((b[i].first - 1) * num) - sum;
long long up = tot - ((b[i].first + 1) * num1);
int f = 0;
if (num >= need) f |= 1;
if (num1 >= need) f |= 2;
if (f == 3) ans = min(ans, min(up, lw) + (long long)(need));
if (f == 2) ans = min(ans, up + (long long)(need));
if (f == 1) ans = min(ans, lw + (long long)(need));
if (!f && (num + num1) >= need) ans = min(ans, lw + up + (long long)(need));
num += (long long)(b[i].second);
sum += (b[i].first * (long long)(b[i].second));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5, INF = 1e16;
long long a[N];
vector<long long> q[N];
int32_t main() {
ios_base::sync_with_stdio(false);
long long n, k, ans = INF;
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
long long x = a[i], cur = 0;
while (x > 0) {
q[x].push_back(cur);
x /= 2;
++cur;
}
}
for (long long i = 0; i < N; ++i) {
if (q[i].size() >= k) {
sort(q[i].begin(), q[i].end());
long long sum = 0;
for (long long j = 0; j < k; ++j) sum += q[i][j];
ans = min(ans, sum);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 7;
const long long MAXN = 2e5 + 7;
long long n, k;
vector<long long> g[MAXN];
void process(long long m) {
int i = 0;
for (; m; i++) {
g[m].push_back(i);
m >>= 1;
}
g[m].push_back(i);
}
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
long long m;
cin >> m;
process(m);
}
long long ans = 1e18;
for (int i = 0; i <= 200000; i++) {
int sz = g[i].size();
if (sz < k) continue;
sort(g[i].begin(), g[i].end());
long long res = 0;
for (int j = 0; j < k; j++) {
res += g[i][j];
}
ans = min(ans, res);
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, Case = 1;
while (Case--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[200005];
map<long long, long long> mp;
map<long long, long long> mp1;
map<long long, long long> freq;
set<long long> s;
long long pre[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
for (long long i = 1; i < n + 1; i++)
cin >> arr[i], freq[arr[i]]++, s.insert(arr[i]);
sort(arr + 1, arr + n + 1);
for (long long i = 1; i < n + 1; i++) pre[i] = pre[i - 1] + arr[i];
long long sum = arr[1];
long long c = 1;
for (long long i = 2; i < n + 1; i++) {
if (arr[i - 1] < arr[i]) mp[arr[i]] = sum, mp1[arr[i]] = c;
sum += arr[i];
c++;
}
long long ans = 1e16;
for (auto i : s) {
long long f = freq[i];
if (f >= k) {
cout << "0";
return 0;
}
long long req = k - f;
long long a = 0;
long long x1 = (i - 1) * mp1[i] - mp[i];
long long x2 =
(sum - mp[i] - i * freq[i]) - (n - mp1[i] - freq[i]) * (i + 1);
if (req <= mp1[i])
a = x1 + req;
else
a = x1 + mp1[i] + x2 + (req - mp1[i]);
ans = min(ans, a);
a = 0;
long long y = (n - mp1[i] - freq[i]);
if (req <= y)
a = x2 + req;
else
a = x1 + (req - y) + x2 + y;
ans = min(ans, a);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long solve(const vector<long long> &arr) {
vector<pair<long long, long long>> cnts;
{
map<long long, long long> temp;
for (long long i = 0; i < n; ++i) {
++temp[arr[i]];
}
for (auto &p : temp) {
cnts.push_back(p);
}
}
for (auto &p : cnts) {
if (p.second >= k) {
return 0;
}
}
vector<long long> suffixSum(cnts.size() + 1, 0);
for (long long i = (long long)cnts.size() - 1; i >= 0; --i) {
suffixSum[i] = suffixSum[i + 1] + cnts[i].second;
}
vector<long long> suffix(cnts.size(), 0);
for (long long i = (long long)cnts.size() - 2; i >= 0; --i) {
assert(cnts[i + 1].first > cnts[i].first);
suffix[i] =
suffix[i + 1] + (cnts[i + 1].first - cnts[i].first) * suffixSum[i + 1];
}
long long ops = 0;
long long prefixSum = 0;
long long res = 1e18;
for (long long i = 0; i < cnts.size(); ++i) {
if (prefixSum + cnts[i].second >= k) {
assert(prefixSum >= k - cnts[i].second);
res = min(res, ops + (cnts[i].first - 1 - cnts[i - 1].first) * prefixSum +
(k - cnts[i].second));
break;
}
if (i) {
ops += (cnts[i].first - cnts[i - 1].first) * prefixSum;
}
prefixSum += cnts[i].second;
res = min(res,
ops + suffix[i + 1] +
suffixSum[i + 1] * (cnts[i + 1].first - 1 - cnts[i].first) +
(k - prefixSum));
}
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
vector<long long> arr(n);
vector<long long> arr2(n);
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
arr2[i] = -arr[i];
}
cout << min(solve(arr), solve(arr2));
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10, inf = 0x3f3f3f3f, mod = 1000000007;
void read() {}
template <typename T, typename... T2>
inline void read(T &x, T2 &...oth) {
x = 0;
long long ch = getchar(), f = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
if (f) x = -x;
read(oth...);
}
vector<long long> vec;
long long id(long long x) {
return lower_bound(vec.begin(), vec.end(), x) - vec.begin() + 1;
}
long long sum[maxn], a[maxn], pre[maxn], suf[maxn], cnt[maxn], pcnt[maxn],
scnt[maxn];
signed main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
map<long long, long long> mp;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]]++;
if (mp[a[i]] >= k) {
cout << 0 << endl;
exit(0);
}
}
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
vec.push_back(a[i]);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
long long rec = 0;
for (long long i = 1; i <= n; i++) {
rec += a[i];
long long now = id(a[i]);
cnt[now]++;
if (a[i] != a[i + 1]) {
pre[now] = (a[i] - 1) * (i - cnt[now]) - (rec - cnt[now] * a[i]);
pcnt[now] = pcnt[now - 1] + cnt[now - 1];
}
}
rec = 0;
for (long long i = n; i >= 1; i--) {
rec += a[i];
if (a[i - 1] != a[i]) {
long long now = id(a[i]);
suf[now] = (rec - cnt[now] * a[i]) - (n - i + 1 - cnt[now]) * (a[i] + 1);
scnt[now] = scnt[now + 1] + cnt[now + 1];
}
}
long long ans = LLONG_MAX;
ans = min(ans, a[k] * k - sum[k]);
ans = min(ans, (sum[n] - sum[n - k]) - a[n - k + 1] * k);
for (auto &x : vec) {
long long now = id(x);
long long res = k - cnt[now];
ans = min(ans, pre[now] + suf[now] + res);
if (pcnt[now] >= res) ans = min(ans, pre[now] + res);
if (scnt[now] >= res) ans = min(ans, suf[now] + res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
;
long long n, k, i;
cin >> n >> k;
long long a[n], pr[n + 1];
map<long long, long long> f;
for (i = 0; i < n; i++) {
cin >> a[i];
f[a[i]]++;
}
int fl = 0;
for (auto e : f) {
if (e.second >= k) {
cout << "0\n";
fl = 1;
break;
}
}
if (!fl) {
sort(a, a + n);
pr[0] = a[0];
for (i = 1; i < n; i++) pr[i] = pr[i - 1] + a[i];
long long ans = 1e18 + 5;
long long left, right, ex, costl, costr;
for (i = 0; i < n; i++) {
left = lower_bound(a, a + n, a[i]) - a;
right = n - (upper_bound(a, a + n, a[i]) - a);
ex = n - left - right;
costl = left * (a[i] - 1);
if (left) costl -= pr[left - 1];
costr = pr[n - 1] - right * (a[i] + 1);
if ((n - right - 1) >= 0) costr -= pr[n - right - 1];
if (left + ex >= k) ans = min(ans, costl + k - ex);
if (right + ex >= k) ans = min(ans, costr + k - ex);
ans = min(ans, costl + costr + k - ex);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
map<int, int> mp;
map<int, int> step;
sort(v.begin(), v.end());
for (int i = 0; i < n; ++i) {
int x = v[i];
int a = 0;
while (x > 0) {
if (mp[x] < k) {
mp[x]++;
step[x] += a;
}
x /= 2;
++a;
}
mp[0]++;
step[0] += a;
}
int ans = 2e9;
for (int i = 0; i <= 200000; ++i) {
if (mp[i] >= k) ans = min(ans, step[i]);
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, k, ans = 0x3f3f3f3f;
vector<int> v[maxn];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
int x, cnt = 0;
scanf("%d", &x);
do {
v[x].emplace_back(cnt);
x >>= 1;
cnt++;
} while (x);
}
for (int i = 0; i < maxn; i++) {
if ((int)v[i].size() < k) continue;
sort(v[i].begin(), v[i].end());
int tot = 0;
for (int j = 0; j < k; j++) tot += v[i][j];
ans = min(ans, tot);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
long long a[N], tot[N], sum[N], c[N], d[N];
vector<long long> b;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b.push_back(a[i]);
}
sort((b).begin(), (b).end());
b.resize(unique((b).begin(), (b).end()) - b.begin());
for (int i = 1; i <= n; i++)
++tot[lower_bound((b).begin(), (b).end(), a[i]) - b.begin()];
sum[0] = tot[0];
for (int i = 1; i < (int)(b).size(); i++) sum[i] = tot[i] + sum[i - 1];
for (int i = 1; i < (int)(b).size(); i++)
c[i] = c[i - 1] + sum[i - 1] * (b[i] - b[i - 1]);
for (int i = (int)(b).size() - 2; i >= 0; i--)
d[i] = d[i + 1] + (sum[(int)(b).size() - 1] - sum[i]) * (b[i + 1] - b[i]);
long long mn = 0x3f3f3f3f3f3f3f3f;
for (int i = 0; i < (int)(b).size(); i++) {
if (tot[i] >= k) {
puts("0");
return 0;
}
long long sum1 = 0, sum2 = 0;
if (i - 1 >= 0) sum1 = c[i - 1] + sum[i - 1] * (b[i] - b[i - 1] - 1);
if (i + 1 < (int)(b).size())
sum2 = d[i + 1] +
(sum[(int)(b).size() - 1] - sum[i]) * (b[i + 1] - b[i] - 1);
if (i - 1 >= 0 && sum[i - 1] + tot[i] >= k) mn = min(mn, sum1 + k - tot[i]);
if (sum[(int)(b).size() - 1] - sum[i] + tot[i] >= k)
mn = min(mn, sum2 + k - tot[i]);
mn = min(mn, sum1 + sum2 + k - tot[i]);
}
printf("%lld\n", mn);
return 0;
}
|
#include <bits/stdc++.h>
const long long lim = 1e5 + 5;
using namespace std;
vector<long long> v;
bool vis[100005], vis1[lim];
long long n, m;
vector<long long> adj[100005];
set<long long> s;
long long ans, cnt[200005], tim[200005];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, k, mn = INT_MAX, f = 0;
cin >> n >> k;
long long a[n];
;
for (long long i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
if (cnt[a[i]] >= k) f = 1;
}
if (f == 1) {
cout << 0;
return 0;
}
m = 1;
while (f != 1) {
;
for (long long i = 0; i < n; i++) {
if (a[i] != 0) {
a[i] = a[i] / 2;
tim[a[i]] += m;
cnt[a[i]]++;
if (cnt[a[i]] >= k) {
mn = min(mn, tim[a[i]]);
f = 1;
}
}
}
m++;
if (f == 1) break;
}
if (mn == 13) {
cout << 12;
return 0;
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
const long long inf = 1e18;
long long n, k, a[N], b[N] = {0, 1}, f1[N], f2[N], t[N], ans = inf;
long long min_(long long x, long long y) { return x < y ? x : y; }
signed main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) f1[i] = f1[i - 1] + a[i];
for (long long i = n; i >= 1; i--) f2[i] = f2[i + 1] + a[i];
for (long long i = 2; i <= n; i++) {
if (a[i] == a[i - 1])
b[i] = b[i - 1];
else
b[i] = b[i - 1] + 1;
t[b[i]]++;
}
for (long long i = 1; i <= n; i++)
if (t[i] >= k) return printf("0"), 0;
for (long long i = 1; i <= n; i++) {
if (i >= k) ans = min_(ans, i * (a[i] - 1) + k - f1[i]);
if (n - i + 1 >= k)
ans = min_(ans, f2[i] - n + i + k - (n - i + 1) * a[i] - 1);
ans = min_(ans, k - n + (2 * i - n - 1) * a[i] - f1[i] + f2[i]);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int mod = 998244353;
int n;
long long a[N], b[N], c[N], k, ans = 2e15;
inline long long qpow(long long a, long long b, long long m) {
long long ans = 1ll;
for (; b; b >>= 1, a = a * a % m)
if (b & 1) ans = ans * a % m;
return ans;
}
inline int read() {
int xx = 0, ff = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = xx * 10 + ch - '0';
ch = getchar();
}
return xx * ff;
}
inline int gcd(int a, int b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
inline int lcm(int a, int b) { return a / gcd(a, b) * b; }
inline void pre() {
for (int i = 1; i <= n; i++) b[i] = b[i - 1] + a[i];
}
inline void suf() {
for (int i = n; i >= 1; i--) c[i] = c[i + 1] + a[i];
}
inline long long minLL(long long x, long long y) { return x < y ? x : y; }
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
pre();
suf();
for (int l = 1, r; l <= n; l = r + 1) {
for (r = l; a[r + 1] == a[l]; r++)
;
if (r - l + 1 >= k) return cout << 0, 0;
long long left = 1ll * (a[l] - 1) * (l - 1) - b[l - 1],
right = c[r + 1] - 1ll * (a[r] + 1) * (n - r),
mid = k - r + l - 1;
if (r >= k && left + mid < ans) ans = left + mid;
if (n - l + 1 >= k) ans = min(ans, right + mid);
ans = min(ans, left + right + mid);
}
return cout << ans << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k, A[N], maxn, Ans;
vector<int> Cost[N];
inline int read() {
int rt = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
rt = (rt << 3) + (rt << 1) + (ch & 15);
ch = getchar();
}
return rt;
}
inline void add(int x) {
int Cnt = 0;
while (x) Cost[x].push_back(Cnt++), x >>= 1;
}
int main() {
n = read(), k = read();
for (register int i = 1; i <= n; ++i)
A[i] = read(), add(A[i]), maxn = max(maxn, A[i]);
Ans = 1e9;
int Cnt, siz;
for (register int i = 1; i <= maxn; ++i) {
siz = Cost[i].size();
if (siz < k) continue;
sort(Cost[i].begin(), Cost[i].end());
Cnt = 0;
for (register int j = 0; j <= k - 1; ++j) Cnt += Cost[i][j];
Ans = min(Ans, Cnt);
}
return not printf("%d", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, A[1000009];
vector<long long> v[200009];
int main() {
long long tc = 1, t = 0, i, j, k, a, b, c, d, s;
while (t++ < tc) {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> A[i];
k = 0;
while (A[i]) {
v[A[i]].push_back(k);
k++;
A[i] /= 2;
}
}
long long ans = LLONG_MAX;
for (i = 0; i < 200009; i++) {
if (v[i].size() >= m) {
sort(v[i].begin(), v[i].end());
long long cur = 0;
for (j = 0; j < m; j++) cur += v[i][j];
ans = min(ans, cur);
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2 * 1e5 + 5;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int N, K, A[MAX], table[20][MAX];
int main() {
cin >> N >> K;
for (int i = 0; i < (N); ++i) cin >> A[i];
for (int i = 0; i < (N); ++i) table[0][i] = A[i];
vector<int> b(N, 0);
for (int i = 0; i < (N); ++i) {
for (int j = 0; j < (19); ++j) {
table[j + 1][i] = table[j][i] / 2;
b[i]++;
if (table[j + 1][i] == 0) break;
}
}
map<int, int> m, cost;
int ans = INF;
for (int i = 0; i < (20); ++i) {
for (int j = 0; j < (N); ++j) {
if (b[j] < i) continue;
int num = table[i][j];
m[num]++;
cost[num] += i;
if (m[num] >= K) ans = min(ans, cost[num]);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void run() {
long long n, k;
cin >> n >> k;
vector<long long> value(n), prefix_count;
vector<long long> prefix_sum;
vector<pair<long long, long long>> extract;
map<long long, long long> cnt;
for (auto &i : value) {
cin >> i;
cnt[i]++;
}
for (auto &i : cnt) extract.emplace_back(i);
sort(value.begin(), value.end());
prefix_count.resize(extract.size());
prefix_sum.resize(extract.size());
for (long long i = 0; i < extract.size(); i++) {
prefix_sum[i] = 1LL * extract[i].first * extract[i].second +
(i ? prefix_sum[i - 1] : 0);
prefix_count[i] = extract[i].second + (i ? prefix_count[i - 1] : 0);
}
long long ans = 1e17;
for (long long i = 0; i < extract.size(); i++) {
long long temp = 0;
long long current_k = k - extract[i].second;
if (current_k <= 0) {
ans = 0;
continue;
}
if (prefix_count[i] >= k) {
temp = 0;
current_k = k - extract[i].second;
temp += 1LL * (i ? prefix_count[i - 1] : 0) * (extract[i].first - 1);
temp -= (i ? prefix_sum[i - 1] : 0);
temp += current_k;
ans = min(ans, temp);
}
if (prefix_count.back() - (i ? prefix_count[i - 1] : 0) >= k) {
temp = 0;
current_k = k - extract[i].second;
temp += prefix_sum.back() - prefix_sum[i];
temp -= 1LL * (prefix_count.back() - prefix_count[i]) *
(extract[i].first + 1);
temp += current_k;
ans = min(ans, temp);
}
temp = 0;
current_k = k - extract[i].second;
temp += prefix_sum.back() - prefix_sum[i];
temp -=
1LL * (prefix_count.back() - prefix_count[i]) * (extract[i].first + 1);
auto delta = min(current_k, n - 1 - i);
temp += delta;
current_k -= delta;
temp += 1LL * (i ? prefix_count[i - 1] : 0) * (extract[i].first - 1);
temp -= (i ? prefix_sum[i - 1] : 0);
delta = min(current_k, i);
temp += delta;
current_k -= delta;
assert(current_k == 0);
ans = min(ans, temp);
}
assert(ans != 1e17);
cout << ans;
}
signed main() {
cout.setf(ios::fixed);
cout.precision(10);
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> theval(n, 0);
long long sum = 0, output = 100000000000000000, leen = 1;
vector<long long> prefix(n + 10, 0);
for (int i = 0; i < n; i++) {
cin >> theval[i];
sum += theval[i];
}
sort(theval.begin(), theval.end());
for (int i = 1; i < n; i++) {
if (theval[i] == theval[i - 1])
leen++;
else
leen = 1;
if (leen >= m) {
cout << 0 << endl;
return 0;
}
}
for (int i = 0; i < n; i++) {
prefix[i] += theval[i];
if (i == 0) continue;
prefix[i] += prefix[i - 1];
}
for (int i = 0; i < n; i++) {
long long ans1 = 100000000000000000, ans2 = 100000000000000000,
ans3 = 100000000000000000;
if (i >= m - 1) {
ans1 = (i * (theval[i] - 1) - (prefix[i] - theval[i])) + m - 1;
}
if (n - i - 1 >= m - 1) {
ans2 = (sum - prefix[i] - (n - i - 1) * (theval[i] + 1)) + m - 1;
}
ans3 = (i * (theval[i] - 1) - (prefix[i] - theval[i])) +
(sum - prefix[i] - (n - i - 1) * (theval[i] + 1)) + m - 1;
output = min(output, min(ans1, min(ans2, ans3)));
}
cout << output << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, n1 = 2e5;
cin >> n >> k;
vector<long long> a;
vector<long long> pos;
for (long long i = 0; i < n; i++) {
long long q;
cin >> q;
a.push_back(q);
}
for (long long i = 0; i < n; i++) {
long long x = a[i];
while (x > 0) {
pos.push_back(x);
x /= 2;
}
}
long long ans = 1e9;
for (auto m : pos) {
vector<long long> cnt;
for (long long i = 0; i < n; i++) {
long long x = a[i], cnt1 = 0;
while (x > m) {
x /= 2;
cnt1++;
}
if (x == m) {
cnt.push_back(cnt1);
}
}
if (cnt.size() >= k) {
sort(cnt.begin(), cnt.end());
ans = min(ans, accumulate(cnt.begin(), cnt.begin() + k, (long long)0));
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
const ll INF = 1e18;
int n, k;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k;
vi v(n);
for (int& x : v) cin >> x;
sort(begin(v), end(v));
vector<ll> a(n), b(n);
for (int i = 0; i < n; ++i) a[i] = b[i] = v[i];
for (int i = 1; i < n; ++i) a[i] += a[i - 1];
for (int i = n - 2; i >= 0; --i) b[i] += b[i + 1];
ll r = INF;
for (int i = 0; i < n;) {
int j = i;
while (j < n && v[i] == v[j]) ++j;
if (j - i >= k) {
r = 0;
break;
}
int need = k - (j - i);
int before = i;
int after = n - j;
ll icost = 1ll * before * v[i] - (i > 0 ? a[i - 1] : 0ll);
ll jcost = (j < n ? b[j] : 0ll) - 1ll * after * v[i];
if (need <= before) r = min(r, icost - (before - need));
if (need <= after) r = min(r, jcost - (after - need));
r = min(r, icost + jcost - (before + after - need));
i = j;
}
cout << r << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, i, j, k, a, c;
cin >> n >> k;
vector<vector<int>> v(200015);
for (i = 0; i < n; i++) {
c = 0;
cin >> a;
while (a) {
v[a].push_back(c);
c++;
a /= 2;
}
v[0].push_back(c);
}
int mn = INT_MAX;
for (i = 0; i <= 200000; i++) {
sort(v[i].begin(), v[i].end());
for (j = 1; j < v[i].size(); j++) v[i][j] += v[i][j - 1];
}
for (i = 0; i <= 200000; i++)
if (v[i].size() >= k) mn = min(mn, v[i][k - 1]);
cout << mn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
}
const int N = 2e5 + 10;
long long a[N];
long long num[N];
long long d[N];
long long len[N];
vector<int> v[N];
bool cmp(long long a, long long b) { return a > b; }
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
{
for (int i = 1; i <= n; i++) {
cin >> a[i];
num[a[i]]++;
}
for (int i = 0; i < 2e5; i++)
if (num[i] >= k) return cout << 0 << endl, 0;
int ans = 2e9;
for (int i = 1; i <= n; i++) {
d[i] = a[i];
int cnt = 1;
while (d[i]) {
d[i] /= 2;
v[d[i]].push_back(cnt);
cnt++;
}
v[0].push_back(cnt);
len[i] = cnt;
}
for (int i = 0; i <= 2e5; i++) sort(v[i].begin(), v[i].end());
for (int i = 0; i < 2e5; i++) {
int numm = num[i];
int cha = k - numm;
int Max = 0;
int j = 0;
while (j < v[i].size() && cha > 0) {
Max += v[i][j++];
cha--;
}
if (cha <= 0) ans = min(ans, Max);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
unordered_map<int, map<int, int> > m1;
unordered_map<int, int> m2;
for (int i = 0; i < n; i++) {
cin >> a[i];
int numSteps = 0;
while (a[i] > 0) {
m2[a[i]]++;
m1[a[i]][numSteps]++;
a[i] /= 2;
++numSteps;
}
}
long long target = 0;
long long steps = INT_MAX;
for (auto it : m2) {
if (it.second >= k) {
long long numSteps = 0;
int nums = 0;
auto it1 = m1[it.first].begin();
while (nums < k) {
long long tmp = min(k - nums, it1->second);
numSteps += (tmp * it1->first);
nums += tmp;
it1++;
}
if (numSteps < steps) {
steps = numSteps;
target = it.first;
}
}
}
cout << steps << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
long long a[N + 5], sum[N + 5];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%lld", a + i);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) sum[i] = a[i] + sum[i - 1];
long long ans = LLONG_MAX;
for (int i = 1, j; i <= n; i = j) {
for (j = i; j <= n; ++j) {
if (a[j] != a[i]) break;
}
long long p = (i - 1) * (a[i] - 1) - sum[i - 1];
long long q = sum[n] - sum[j - 1] - (n - j + 1) * (a[i] + 1);
vector<pair<long long, int>> vc;
vc.push_back({p, i - 1});
vc.push_back({q, (n - j + 1)});
vc.push_back({p + q, n - (j - i)});
sort(vc.begin(), vc.end());
int t = k - (j - i);
long long c = 0;
if (t > 0)
for (auto &it : vc) {
if (t <= it.second) {
c = it.first + t;
break;
}
}
ans = min(ans, c);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> dp[200007];
map<long long, long long> mp;
vector<long long> un;
void make_di(long long n, long long c) {
dp[n].push_back(c);
if (mp[n] == 0) un.push_back(n);
mp[n] = 1;
if (n == 0) return;
make_di(n / 2, c + 1);
}
int main() {
long long i, j, a, n, k, ans = 1e9, sum;
vector<long long> v;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
make_di(a, 0);
}
for (i = 0; i < 200007; i++) {
if (dp[i].size() >= k) sort(dp[i].begin(), dp[i].end());
}
for (i = 0; i < un.size(); i++) {
a = un[i];
if (dp[a].size() < k) continue;
sum = 0;
for (j = 0; j < k; j++) {
sum += dp[a][j];
}
ans = min(sum, ans);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A[2 * 100005];
int main() {
int n, s;
cin >> n >> s;
int arr[2 * 100005];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
int t = arr[i];
int step = 0;
A[t].push_back(step++);
while (t) {
t >>= 1;
A[t].push_back(step++);
}
}
int Min = 9999999;
for (int i = 0; i <= 2 * 100000; i++) {
if (A[i].size() < s) continue;
int ans = 0;
for (int j = 0; j < s; j++) {
ans += A[i][j];
if (ans > Min) break;
}
if (Min > ans) Min = ans;
}
cout << Min << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
class Item {
public:
long long val, cnt, sum;
Item() { val = cnt = sum = 0LL; };
};
int n = 0, k = 0, tot = 0;
long long a[200005] = {};
Item s[200005] = {};
Item pre[200005] = {};
Item suf[200005] = {};
void init() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long last = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] != last) {
if (last) {
++tot;
s[tot].val = last;
s[tot].cnt = cnt;
s[tot].sum = last * cnt;
}
last = a[i];
cnt = 1;
} else {
++cnt;
}
}
++tot;
s[tot].val = last;
s[tot].cnt = cnt;
s[tot].sum = last * cnt;
for (int i = 1; i <= tot; ++i) {
pre[i].cnt = pre[i - 1].cnt + s[i].cnt;
pre[i].sum = pre[i - 1].sum + s[i].sum;
}
for (int i = tot; i >= 1; --i) {
suf[i].cnt = suf[i + 1].cnt + s[i].cnt;
suf[i].sum = suf[i + 1].sum + s[i].sum;
}
}
inline long long costL(int i) {
return (s[i].val - 1) * (pre[i - 1].cnt) - pre[i - 1].sum;
}
inline long long costR(int i) {
return suf[i + 1].sum - (s[i].val + 1) * (suf[i + 1].cnt);
}
long long solve() {
long long ans = LLINF;
for (int i = 1; i <= tot; ++i) {
if (s[i].cnt >= k) {
ans = 0LL;
break;
} else {
long long cnt = k - s[i].cnt;
{
long long cntL = min(cnt, pre[i - 1].cnt);
long long cntR = max(cnt - cntL, 0LL);
long long tmp = costL(i);
if (cntR > 0) {
tmp += costR(i);
}
ans = min(ans, tmp + cnt);
}
{
long long cntR = min(cnt, suf[i + 1].cnt);
long long cntL = max(cnt - cntR, 0LL);
long long tmp = costR(i);
if (cntL > 0) {
tmp += costL(i);
}
ans = min(ans, tmp + cnt);
}
}
}
return ans;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
init();
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, tot = 2147483647, a[200005], b[200005], c[200005];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
s = a[i];
t = 0;
while (s) {
b[s]++;
c[s] += t;
if (b[s] == k && c[s] < tot) tot = c[s];
s /= 2;
t++;
}
}
cout << tot << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[51], nm[2 * 100001];
map<int, int> st[2 * 100001];
int main() {
cin.sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
int maxnmb = -1;
int minc = INT_MAX;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
++nm[arr[i]];
if (nm[arr[i]] >= k) minc = 0;
if (arr[i] > maxnmb) maxnmb = arr[i];
}
for (int i = maxnmb; i >= 1; --i) {
if (nm[i] == 0) continue;
int rate = 1;
int nmb = i;
while (nmb != 0) {
st[nmb >> 1][rate] += nm[i];
nmb >>= 1;
++rate;
}
}
for (int i = 0; i < maxnmb; ++i) {
int rem = k - nm[i];
if (rem < 0) rem = 0;
int cost = 0;
for (auto j : st[i]) {
cost += min(rem, j.second) * j.first;
rem -= j.second;
if (rem <= 0) break;
}
if (rem > 0) continue;
minc = min(minc, cost);
}
cout << minc;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from, to, dist;
Edge(int u, int v, int d) : from(u), to(v), dist(d) {}
};
int n, k;
int a[100007 * 2];
set<int> all;
map<int, long long> mp, ans;
long long anss = 1000000007;
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
int tmp = a[i], cnt = 0;
while (tmp != -1) {
mp[tmp]++;
ans[tmp] += cnt;
if (mp[tmp] == k) {
anss = min(anss, ans[tmp]);
}
if (tmp != 0)
tmp >>= 1;
else
tmp = -1;
cnt++;
}
}
cout << anss << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-12, PI = acos(-1);
const int N = 2e5 + 9, M = 1e7 + 9, OO = 1e9 + 7, MOD = 1e9 + 7,
MOD2 = 998244353;
const long long INF = 1e18;
map<int, int> mp;
pair<int, int> arr[N];
long long pref[N], suf[N];
int prefCnt[N], sufCnt[N];
int main() {
cout << fixed << setprecision(12), ios::sync_with_stdio(false),
cin.tie(nullptr), cout.tie(nullptr);
int n, k, a;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a;
mp[a]++;
}
int cur = 1;
for (auto it : mp) arr[cur++] = it;
long long cnt = 0, cntNum = 0;
for (int i = 1; i <= cur; ++i) {
cntNum += arr[i].second;
cnt += 1ll * arr[i].first * arr[i].second;
pref[i] = cnt;
prefCnt[i] = cntNum;
}
cnt = 0, cntNum = 0;
for (int i = cur; i > 0; --i) {
cntNum += arr[i].second;
cnt += 1ll * arr[i].first * arr[i].second;
suf[i] = cnt;
sufCnt[i] = cntNum;
}
long long ans = INF;
for (int i = 1; i < cur; ++i) {
int req = k - arr[i].second;
if (req <= 0) {
ans = 0;
break;
}
int cntBefore = min(req, prefCnt[i - 1]);
long long c1 = 1ll * prefCnt[i - 1] * (arr[i].first - 1) - pref[i - 1];
c1 += cntBefore;
int cntNxt = req - cntBefore;
assert(cntNxt >= 0);
if (cntNxt) {
c1 += suf[i + 1] - 1ll * sufCnt[i + 1] * (arr[i].first + 1);
c1 += cntNxt;
}
ans = min(ans, c1);
cntNxt = min(req, sufCnt[i + 1]);
c1 = suf[i + 1] - 1ll * sufCnt[i + 1] * (arr[i].first + 1);
c1 += cntNxt;
cntBefore = req - cntNxt;
assert(cntBefore >= 0);
if (cntBefore) {
c1 += 1ll * prefCnt[i - 1] * (arr[i].first - 1) - pref[i - 1];
c1 += cntBefore;
}
ans = min(ans, c1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 2e5 + 5;
long long a[N];
map<long long, long long> m;
void solve() {
long long n, k;
cin >> n >> k;
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
m[a[i]]++;
}
long long ans = sum, ps = 0, push_front = 0;
for (pair<long long, long long> x : m) {
if (x.second >= k) {
cout << 0;
return;
}
long long mv = (x.first - 1) * push_front - ps;
if (push_front + x.second >= k) {
amin(ans, mv + k - x.second);
}
long long mv2 = (sum - ps - x.first * x.second) -
(x.first + 1) * (n - push_front - x.second);
if (n - push_front >= k) {
amin(ans, mv2 + k - x.second);
}
amin(ans, mv + mv2 + k - x.second);
ps += x.first * x.second;
push_front += x.second;
}
cout << ans;
}
signed 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;
const int maxx = 2e5 + 6;
long long a[maxx];
long long pre[maxx];
long long bac[maxx];
int main() {
int k, n;
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + 1 + n);
pre[0] = 0;
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
}
bac[n + 1] = 0;
for (int i = n; i >= 1; i--) {
bac[i] = bac[i + 1] + a[i];
}
long long ans = 1e18;
int max_cnt = 0;
int cnt = 1;
for (int i = 1; i <= n; i++) {
if (i != 1 && a[i] == a[i - 1]) {
cnt++;
} else {
cnt = 1;
}
max_cnt = max(max_cnt, cnt);
}
if (max_cnt >= k) {
printf("0\n");
continue;
}
for (long long i = 1; i <= n; i++) {
long long l = i * a[i] - pre[i];
long long r = bac[i] - (n - i + 1) * a[i];
if (i >= k) {
ans = min(ans, l - (i - k));
}
if (n - i + 1 >= k) {
ans = min(ans, r - (n - i + 1 - k));
}
ans = min(ans, l + r - (n - k));
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 57 * 1e8;
void find_available_x(vector<vector<int>>& v, int x) {
int count_operations = 0;
while (x > 0) {
v[x].push_back(count_operations);
x /= 2;
++count_operations;
}
}
int sum_count_operation_for_each_elem(vector<int> v, int k) {
int sum = 0;
for (int i = 0; i < k; ++i) {
sum += v[i];
}
return sum;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
vector<vector<int>> available_x(2 * 1e5 + 57, vector<int>());
for (int i = 0; i < n; ++i) {
cin >> v[i];
find_available_x(available_x, v[i]);
}
int min_count_operation = INF;
for (int i = 0; i < available_x.size(); ++i) {
if (available_x[i].size() >= k) {
sort(available_x[i].begin(), available_x[i].end());
min_count_operation =
min(min_count_operation,
sum_count_operation_for_each_elem(available_x[i], k));
}
}
cout << min_count_operation;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
vector<int> mg[200005];
vector<int> b;
int main() {
int n, k, i, sum, res = 100000000, j, t, x;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
x = a[i];
t = 1;
mg[x].push_back(0);
while (x > 0) {
x = x / 2;
mg[x].push_back(t);
t++;
}
}
for (i = 0; i < 200000; i++) {
if (mg[i].size() < k) continue;
int kol = mg[i].size();
sort(mg[i].begin(), mg[i].end());
sum = 0;
for (j = 0; j < k; j++) sum += mg[i][j];
res = min(res, sum);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long x, long long y) {
if (y == 0) return x;
if (x > y) return GCD(y, x % y);
return GCD(x, y % x);
}
long long LCM(long long x, long long y) { return (x * y) / GCD(x, y); }
long long MPOW(long long a, long long b, long long m = LLONG_MAX) {
if (b == 0) return 1;
if (b & 1) return ((a % m) * (MPOW(a, b - 1, m) % m)) % m;
a = (a * a) % m;
return (MPOW(a, b / 2, m));
}
long long MINV(long long a, long long m) { return MPOW(a, m - 2, m); }
inline bool max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline bool min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline bool sortbythis(pair<int, int> a, pair<int, int> b) {
return ((a.first == b.first && a.second < b.second) || (a.first < b.first));
}
inline bool sortbythat(pair<int, int> a, pair<int, int> b) {
return ((a.second == b.second && a.first < b.first) || (a.second < b.second));
}
class pnc {
long long FACTMAX, MODU;
vector<long long> fact;
public:
pnc(long long n, long long m) {
FACTMAX = n;
MODU = m;
fact.resize(n + 1);
MFACT_INIT(MODU);
}
void MFACT_INIT(long long m) {
fact[0] = 1;
for (int i = 1; i <= FACTMAX; i++) fact[i] = (i * fact[i - 1]) % MODU;
}
long long MFACT(long long n) { return fact[n]; }
long long PERM(long long n, long long r) {
return (fact[n] * MINV(fact[n - r], MODU)) % MODU;
}
long long COMB(long long n, long long r) {
return (PERM(n, r) * MINV(fact[r], MODU)) % MODU;
}
};
const int MAXN = int(1e5);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
map<int, vector<int> > M;
int(n), (k);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int(a);
cin >> a;
int cnt = 0;
while (a) {
if (M.find(a) == M.end())
M[a] = vector<int>(1, cnt);
else
M[a].push_back(cnt);
cnt++;
a = (a / 2);
}
if (M.find(0) == M.end())
M[0] = vector<int>(1, cnt);
else
M[0].push_back(cnt);
}
int ans = (int)(1000000007);
for (auto& it : M) {
if ((it.second).size() >= k) {
sort((it.second).begin(), (it.second).end());
int temp = 0;
for (int i = 0; i <= k - 1; i++) {
temp += (it.second)[i];
}
ans = min(temp, ans);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int cnt[200010];
std::priority_queue<int> q[200010];
int sum[200010];
int lg[200010], k, ans = 2147483647;
void dfs(int cur) {
lg[cur] = lg[cur >> 1] + 1;
if ((cur << 1) <= 200000) {
dfs(cur << 1);
while (!q[cur << 1].empty()) {
sum[cur] += q[cur << 1].top();
q[cur].push(q[cur << 1].top());
q[cur << 1].pop();
}
}
if ((cur << 1 | 1) <= 200000) {
dfs(cur << 1 | 1);
while (!q[cur << 1 | 1].empty()) {
sum[cur] += q[cur << 1 | 1].top();
q[cur].push(q[cur << 1 | 1].top());
q[cur << 1 | 1].pop();
}
}
for (int i = 1; i <= cnt[cur]; i++) {
q[cur].push(lg[cur]);
sum[cur] += lg[cur];
}
while (q[cur].size() > k) {
sum[cur] -= q[cur].top();
q[cur].pop();
}
if (q[cur].size() >= k) {
ans = std::min(ans, sum[cur] - (lg[cur] * k));
}
}
int main() {
int n = inp();
k = inp();
for (int i = 1; i <= n; i++) cnt[inp()]++;
lg[0] = -1;
dfs(1);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n, k;
cin >> n >> k;
vector<long long int> arr(n), freq(n), presum(n), postsum(n), precnt(n),
postcnt(n);
map<long long int, long long int> mp;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
mp[x]++;
}
long long int i = 0;
n = mp.size();
for (auto x : mp) {
arr[i] = x.first;
freq[i] = x.second;
i++;
}
presum[0] = arr[0] * freq[0];
precnt[0] = freq[0];
for (i = 1; i < n; i++) {
presum[i] = (presum[i - 1] + (arr[i] * freq[i]));
precnt[i] = (precnt[i - 1] + freq[i]);
}
postsum[n - 1] = arr[n - 1] * freq[n - 1];
postcnt[n - 1] = freq[n - 1];
for (long long int i = n - 2; i >= 0; i--) {
postsum[i] = postsum[i + 1] + (arr[i] * freq[i]);
postcnt[i] = postcnt[i + 1] + freq[i];
}
long long int ans = 2e18;
for (i = 0; i < n; i++) {
long long int needed = k - freq[i];
if (needed <= 0) {
cout << 0 << endl;
return 0;
}
long long int left = (i == 0) ? 0 : precnt[i - 1];
long long int right = (i == n - 1) ? 0 : postcnt[i + 1];
long long int leftsum = (i == 0) ? 0 : presum[i - 1];
long long int rightsum = (i == n - 1) ? 0 : postsum[i + 1];
long long int leftfcont = (left * arr[i]) - leftsum;
long long int rightfcont = rightsum - (right * arr[i]);
long long int leftpart = (left * (arr[i] - 1)) - leftsum;
long long int rightpart = rightsum - (right * (arr[i] + 1));
long long int op1, op2, op3, op4;
op1 = op2 = op3 = op4 = 2e18;
if (left >= needed) {
op1 = leftpart + needed;
ans = min(ans, op1);
op4 = rightfcont + leftpart + (needed - right);
ans = min(ans, op4);
}
if (right >= needed) {
op2 = rightpart + needed;
ans = min(ans, op2);
op3 = leftfcont + rightpart + (needed - left);
ans = min(ans, op3);
} else {
op4 = rightfcont + leftpart + (needed - right);
ans = min(ans, op4);
op3 = leftfcont + rightpart + (needed - left);
ans = min(ans, op3);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void normal(long long &a) { a = (a + 1000000007) % 1000000007; }
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInv(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInv(b));
}
vector<long long> val[200001];
void km() {
long long n, k;
cin >> n >> k;
map<long long, long long> mp;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
mp[v[i]]++;
}
sort((v).begin(), (v).end());
for (long long i = 0; i < n; i++) {
if (mp[v[i]] >= k) {
cout << 0 << '\n';
return;
}
}
for (long long i = 0; i < n; i++) {
long long cnt = 0;
long long x = v[i];
while (x > 0) {
val[x].push_back(cnt);
x /= 2;
cnt++;
}
}
long long ans = INT_MAX;
for (long long i = 1; i < 200001; i++) {
if (val[i].size() < k) continue;
sort((val[i]).begin(), (val[i]).end());
long long zero = 0;
ans = min(ans, accumulate(val[i].begin(), val[i].begin() + k, zero));
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
clock_t start, end;
start = clock();
cout << fixed << setprecision(18);
;
long long t;
t = 1;
while (t--) {
km();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50000 + 50;
const int INF = int(1e9) + 100;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, k;
cin >> n >> k;
long long a[n], i, j;
for (i = 0; i < n; i++) cin >> a[i];
map<long long, vector<long long>> m;
vector<long long> v;
long long c, val, ans = INT_MAX;
for (i = 0; i < n; i++) {
c = 0;
while (a[i] != 0) {
m[a[i]].push_back(c);
c++;
a[i] = a[i] / 2;
}
}
for (i = 0; i <= 200000; i++) {
vector<long long> v = m[i];
sort(v.begin(), v.end());
val = 0;
if (v.size() >= k) {
for (j = 0; j < k; j++) val += v[j];
ans = min(ans, val);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n, k, arr[200005];
vector<int> states;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<vector<int> > sat(200005 + 30);
for (int i = 0; i < n; i++) {
int w = arr[i];
int dev = 0;
while (w > 0) {
sat[w].push_back(dev);
states.push_back(w);
w /= 2;
dev++;
}
}
int A = INT_MAX;
for (vector<int> kaz : sat) {
if (kaz.size() >= k) {
sort(kaz.begin(), kaz.end());
int jemerends = 0;
for (int i = 0; i < k; i++) {
jemerends += kaz[i];
}
A = min(A, jemerends);
}
}
cout << A << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
int k;
cin >> n >> k;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
long long lista[n];
int cantidad[n];
int index = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
lista[i] = ar[i];
cantidad[index] = 1;
} else if (ar[i] == ar[i - 1]) {
cantidad[index]++;
} else {
index++;
cantidad[index] = 1;
lista[index] = ar[i];
}
}
int diferentes = index + 1;
long long L[diferentes];
long long R[diferentes];
int LeftAmount[diferentes];
int RightAmount[diferentes];
L[0] = 0;
LeftAmount[0] = 0;
R[diferentes - 1] = 0;
RightAmount[diferentes - 1] = 0;
for (int i = 1; i < diferentes; i++) {
LeftAmount[i] = LeftAmount[i - 1] + cantidad[i - 1];
L[i] = L[i - 1] + (lista[i] - 1 - lista[i - 1]) * cantidad[i - 1];
L[i] += (lista[i] - 1 - (lista[i - 1] - 1)) * LeftAmount[i - 1];
}
for (int i = diferentes - 2; i >= 0; i--) {
RightAmount[i] = RightAmount[i + 1] + cantidad[i + 1];
R[i] = R[i + 1] + (lista[i + 1] - (lista[i] + 1)) * cantidad[i + 1];
R[i] += (lista[i + 1] - lista[i]) * RightAmount[i + 1];
}
long long ans = 1000000000000000005;
for (int i = 0; i < diferentes; i++) {
if (cantidad[i] >= k) {
ans = 0;
} else {
int needed = k - cantidad[i];
if ((LeftAmount[i] >= needed) && (RightAmount[i] >= needed)) {
ans = min(min(L[i], R[i]) + needed, ans);
} else if (LeftAmount[i] >= needed) {
ans = min(L[i] + needed, ans);
} else if (RightAmount[i] >= needed) {
ans = min(R[i] + needed, ans);
} else {
ans = min(L[i] + R[i] + needed, ans);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-14;
const long long maxn = 200500;
const long long mod = 1e9 + 7;
vector<pair<long long, long long> > v;
long long cntp[maxn], cnts[maxn], costp[maxn], costs[maxn];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (auto &x : a) cin >> x;
sort((a).begin(), (a).end());
for (long long i = 0; i < n; ++i) {
long long j = i;
while (j < n && a[j] == a[i]) ++j;
v.push_back({a[i], j - i});
i = j - 1;
}
n = (long long)(v).size();
cntp[0] = v[0].second;
cnts[n - 1] = v[n - 1].second;
for (long long i = 1; i < n; ++i) {
cntp[i] = cntp[i - 1] + v[i].second;
costp[i] = costp[i - 1] + cntp[i - 1] * (v[i].first - v[i - 1].first);
}
for (long long i = n - 2; i >= 0; --i) {
cnts[i] = v[i].second + cnts[i + 1];
costs[i] = costs[i + 1] + cnts[i + 1] * (v[i + 1].first - v[i].first);
}
long long ans = 1e18;
for (long long i = 0; i < n; ++i) {
long long adp = (i ? cntp[i - 1] : 0), smp = (i ? costp[i - 1] : 0);
long long ads = cnts[i + 1], sms = costs[i + 1];
long long need = k - v[i].second;
if (adp) smp += adp * (v[i].first - 1 - v[i - 1].first);
if (ads) sms += ads * (v[i + 1].first - v[i].first - 1);
if (need <= 0) {
ans = 0;
break;
}
long long tm = 1e18;
if (adp >= need) tm = smp + need;
if (ads >= need) tm = min(tm, sms + need);
if (ads < need && adp < need && ads + adp >= need) {
long long tmp = sms + smp;
if ((v[i].first - v[i - 1].first) < (v[i + 1].first - v[i].first)) {
tmp += adp;
need -= adp;
tmp += need;
} else {
tmp += ads;
need -= ads;
tmp += need;
}
tm = min(tm, tmp);
}
ans = min(ans, tm);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<multiset<long long> > ve;
vector<long long> flag;
int n, k;
inline void pushint(int num, int ci) {
if (ve[num].size() == k) {
if (*ve[num].rbegin() > ci) {
flag[num] -= *ve[num].rbegin();
auto temp = ve[num].end();
temp--;
ve[num].erase(temp);
ve[num].insert(ci);
flag[num] += ci;
}
} else {
ve[num].insert(ci);
flag[num] += ci;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
if (k == 1) {
long long t;
for (int i = 0; i < n; i++) {
cin >> t;
}
cout << 0 << endl;
return 0;
}
ve.resize(210000);
flag.resize(210000);
for (int i = 0; i < n; i++) {
int t;
cin >> t;
int jici = 0;
while (t) {
pushint(t, jici);
t /= 2;
jici++;
}
pushint(0, jici);
}
long long value = 9999999999;
for (int i = 0; i <= 200010; i++) {
if (ve[i].size() == k && flag[i] < value) value = flag[i];
}
cout << value << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<vector<int>> cnt(200003);
int tmp, res = 0;
for (int i = 0; i < n; i++) {
cin >> tmp;
int bit = 0;
while (tmp) {
cnt[tmp].push_back(bit);
bit++;
tmp /= 2;
}
}
res = 100000000;
for (int i = 0; i < 200001; i++) {
if (cnt[i].size() < k) continue;
sort(cnt[i].begin(), cnt[i].end());
tmp = 0;
for (int j = 0; j < k; j++) {
tmp += cnt[i][j];
}
res = min(res, tmp);
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, t1, t2, z, mn = 0x3f3f3f3f;
vector<int> v;
map<int, int> cnt;
map<int, vector<int> > cost;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> t1;
t2 = 0;
while (t1) {
cnt[t1]++;
if (cnt[t1] == 1) {
v.push_back(t1);
}
cost[t1].push_back(t2);
t1 >>= 1, t2++;
}
cost[0].push_back(t2);
}
v.push_back(0);
for (int i = 0; i < v.size(); i++) {
if (cnt[v[i]] >= k) {
t1 = 0;
sort(cost[v[i]].begin(), cost[v[i]].end());
for (int j = 0; j < k; j++) {
t1 += cost[v[i]][j];
}
mn = min(mn, t1);
}
}
cout << mn << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > cost[200020];
int a[200020];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
cost[a[i]].push_back(pair<int, int>(a[i], 0));
if (cost[a[i]].size() >= k) {
puts("0");
return 0;
}
}
int ans = 987654321, cnt = 1;
vector<int> ansN;
bool success = false;
while (cnt <= 20) {
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
a[i] /= 2;
cost[a[i]].push_back(pair<int, int>(a[i], cnt));
}
if (cost[a[i]].size() >= k) {
success = true;
ansN.push_back(a[i]);
}
}
if (success) {
for (int j = 0; j < ansN.size(); j++) {
int tmp = 0;
for (int i = 0; i < k; i++) {
tmp += cost[ansN[j]][i].second;
}
ans = min(ans, tmp);
}
}
cnt++;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n + 1], s = 0;
map<long long, long long> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]]++;
s += a[i];
}
vector<pair<long long, long long> > v;
for (auto X : m) {
v.push_back({X.first, X.second});
}
pair<long long, long long> p[v.size() + 2];
p[0].first = 0;
p[0].second = 0;
for (long long i = 0; i < v.size(); i++) {
p[i + 1].first = p[i].first + ((v[i].first) * (v[i].second));
p[i + 1].second = p[i].second + v[i].second;
}
p[v.size() + 1].first = 0;
p[v.size() + 1].second = 0;
long long ans = LLONG_MAX;
for (long long i = 0; i < v.size(); i++) {
long long t1 = p[i].first;
long long t2 = ((v[i].first - 1) * p[i].second);
t2 -= t1;
long long t3 = s - p[i + 1].first;
long long t4 = ((n - p[i + 1].second) * (v[i].first + 1));
t3 -= t4;
long long need = LLONG_MAX;
if (v[i].second >= k) {
cout << "0\n";
return;
}
long long av = k - v[i].second;
if (av <= p[i].second) {
need = min(need, t2 + av);
}
if (av <= (n - p[i + 1].second)) {
need = min(need, t3 + av);
}
need = min(need, t2 + t3 + av);
ans = min(ans, need);
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10, inf = 1e18 + 10, M = 1e5 + 10;
long long a[N], p[N], second[N], p1[N], s1[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
long long cnt1 = 0, last1 = a[0];
for (long long i = 0; i <= n; ++i) {
if (a[i] == last1)
++cnt1;
else {
if (cnt1 >= k) {
cout << 0;
return 0;
}
cnt1 = 1;
}
last1 = a[i];
}
long long ans = inf, last = a[0], have = 0, cnt = 0;
for (long long i = 0; i < n; ++i) {
have += (a[i] - last) * i;
if (a[i] != last) cnt = i;
if (i >= k - 1) ans = min(ans, have - min(cnt, (i + 1 - k)));
last = a[i];
p[i] = have;
p1[i] = cnt;
}
last = a[n - 1], have = 0, cnt = 0;
for (long long i = n - 1; i >= 0; --i) {
have += (last - a[i]) * (n - i - 1);
if (a[i] != last) cnt = (n - i - 1);
if (n - i >= k) ans = min(ans, have - min(cnt, ((n - i) - k)));
last = a[i];
second[i] = have;
s1[i] = cnt;
}
for (long long i = 0; i < n; ++i) {
ans = min(ans, p[i] + second[i] - min(s1[i] + p1[i], (n - k)));
if (i != n - 1 && a[i + 1] != a[i] && a[i + 1] != a[i] + 1)
ans = min(ans, p[i] + second[i] + i + 1 - (n - i - 1) - (n - k));
if (i != 0 && a[i - 1] != a[i] && a[i - 1] != a[i] - 1)
ans = min(ans, p[i] + second[i] - i + (n - i) - (n - k));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
void search(int cur) {
int tot, c[10];
int ok;
if (cur == n)
tot++;
else
for (int i = 0; i < n; i++) {
ok = 1;
c[cur] = i;
}
for (int j = 0; j < cur; j++) {
if (c[cur] == c[j] || cur - c[cur] == j - c[j] ||
cur + c[cur] == j + c[j]) {
ok = 0;
break;
}
}
if (ok) search(cur + 1);
}
const long long MAXN = 55;
long long num[MAXN];
void xswl() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; ++i) {
scanf("%lld", &num[i]);
}
num[0] = 1;
sort(num + 1, num + 1 + n);
long long res = 999999999999999;
for (long long i = 2e5; i >= 0; --i) {
long long cnt = 0;
long long nowr = 0;
int t = lower_bound(num + 1, num + 1 + n, i) - num;
for (int j = t; j <= n; ++j) {
long long now = 0;
long long u = num[j];
while (u > i) {
++now;
u >>= 1;
}
if (u == i) {
++cnt;
nowr += now;
}
if (cnt == k) break;
}
if (cnt == k) {
if (res > nowr) {
res = nowr;
}
}
}
printf("%lld", res);
}
int main() { xswl(); }
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50 + 5;
const int maxm = 2e5 + 5;
int n, k;
int a[maxn];
vector<int> res[maxm];
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
int tmp = a[i], j = 0;
while (true) {
res[tmp].push_back(j);
if (!tmp) break;
tmp /= 2;
j++;
}
}
int ans = maxm;
for (int i = 0; i < maxm; ++i) {
if (res[i].size() < k) continue;
sort(res[i].begin(), res[i].end());
int tmp = 0;
for (int j = 0; j < k; ++j) tmp += res[i][j];
ans = min(ans, tmp);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return 0;
}
template <typename T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return 0;
}
using P = pair<ll, ll>;
const ll INF = 1LL << 60;
vector<P> runLength(const vector<ll>& A) {
vector<P> res;
ll now = A[0];
ll cnt = 1;
for (int i = (int)1; i < (int)A.size(); ++i) {
if (A[i] == now) {
++cnt;
} else {
res.emplace_back(now, cnt);
now = A[i];
cnt = 1;
}
}
res.emplace_back(now, cnt);
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<ll> A(N);
for (auto& a : A) {
cin >> a;
}
sort((A).begin(), (A).end());
vector<P> B = runLength(A);
int M = (int)B.size();
vector<ll> head_cumsum(M + 2, 0), tail_cumsum(M + 2, 0);
vector<ll> head_cnt(M + 2, 0), tail_cnt(M + 2, 0);
for (int i = (int)0; i < (int)M; ++i) {
head_cumsum[i + 1] = head_cumsum[i] + B[i].first * B[i].second;
head_cnt[i + 1] = head_cnt[i] + B[i].second;
}
for (int i = (int)M - 1; i >= (int)0; --i) {
tail_cumsum[i + 1] = tail_cumsum[i + 2] + B[i].first * B[i].second;
tail_cnt[i + 1] = tail_cnt[i + 2] + B[i].second;
}
ll ans = INF;
for (int i = (int)1; i < (int)M + 1; ++i) {
if (B[i - 1].second >= K) {
cout << 0 << endl;
return 0;
}
ll head_cost = (B[i - 1].first - 1) * head_cnt[i - 1] - head_cumsum[i - 1];
ll tail_cost = tail_cumsum[i + 1] - (B[i - 1].first + 1) * tail_cnt[i + 1];
ll rest = K - B[i - 1].second;
ll head_rest = head_cnt[i - 1];
ll tail_rest = tail_cnt[i + 1];
{
ll now_ans = head_cost;
ll now_rest = rest;
ll cnt = min(now_rest, head_rest);
now_ans += cnt;
now_rest -= cnt;
if (now_rest) {
now_ans += tail_cost + now_rest;
}
chmin(ans, now_ans);
}
{
ll now_ans = tail_cost;
ll now_rest = rest;
ll cnt = min(now_rest, tail_rest);
now_ans += cnt;
now_rest -= cnt;
if (now_rest) {
now_ans += head_cost + now_rest;
}
chmin(ans, now_ans);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fakemain() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
long long sum = 0;
map<long long, long long> m;
set<long long> s;
long long ans = LLONG_MAX;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
sum += x;
m[x]++;
if (m[x] >= k) ans = 0;
s.insert(x);
}
if (ans == 0) {
cout << 0 << "\n";
return;
}
long long cnt = 0;
long long pre = 0;
for (auto it : m) {
long long f = it.second;
long long num = it.first;
if (f >= k) {
ans = 0;
break;
}
if (cnt + f >= k) {
long long req = cnt * (num - 1) - pre;
req += (k - f);
ans = min(ans, req);
}
if (n - cnt >= k) {
long long req = (sum - pre - f * num) - (n - cnt - f) * (num + 1);
req += (k - f);
ans = min(ans, req);
}
long long req = cnt * (num - 1) - pre + (sum - pre - f * num) -
(n - cnt - f) * (num + 1);
req += (k - f);
ans = min(ans, req);
cnt += f;
pre += f * num;
}
cout << ans;
}
int main() { fakemain(); }
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool sortinrev(const pair<ll, ll> &a, const pair<ll, ll> &b) {
if (a.first == b.first)
return (a.second < b.second);
else
return (a.first < b.first);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> a;
for (ll i = 0; i <= n - 1; ++i) {
int tmp, cnt = 0;
cin >> tmp;
while (tmp > 0) {
pair<ll, ll> lol;
lol.first = tmp;
lol.second = cnt;
cnt++;
tmp /= 2;
a.push_back(lol);
}
pair<ll, ll> lol;
lol.first = tmp;
lol.second = cnt;
a.push_back(lol);
}
sort(a.begin(), a.end(), sortinrev);
ll now = a[0].first;
ll numnow = 0;
ll ans = 0;
ll realans = INT_MAX;
int i = 0;
while (i < a.size()) {
if (a[i].first == now) {
numnow++;
if (numnow <= m) ans += a[i].second;
i++;
} else {
if (ans < realans && numnow >= m) realans = ans;
ans = 0;
now = a[i].first;
numnow = 0;
}
}
if (ans < realans && numnow >= m) realans = ans;
cout << realans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
const int N = 1e6 + 4e5 + 66;
const int mod = 1e9 + 7;
const ll inf = 2e9;
const ll INF = 2e18;
const ld EPS = 1e-7;
int a[N];
map<int, int> cnt;
void solve() {
int n, k;
cin >> n >> k;
ll sum = 0, psum = 0, pcn = 0, cn = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
cnt[a[i]]++;
sum += a[i];
cn++;
}
sort(a + 1, a + 1 + n);
n = unique(a + 1, a + 1 + n) - a - 1;
ll ans = INF;
for (int i = 1; i <= n; ++i) {
sum -= cnt[a[i]] * 1ll * a[i];
cn -= cnt[a[i]];
int l = k - cnt[a[i]];
if (l <= 0) {
cout << 0;
return;
}
if (l <= cn) {
ll s = sum - cn * 1ll * (a[i] + 1) + l;
ans = min(ans, s);
}
if (l <= pcn) {
ll s = pcn * 1ll * (a[i] - 1) - psum + l;
ans = min(ans, s);
}
if (l <= cn + pcn) {
ll s = pcn * 1ll * (a[i] - 1) - psum + sum - cn * 1ll * (a[i] + 1) + l;
ans = min(ans, s);
}
psum += cnt[a[i]] * 1ll * a[i];
pcn += cnt[a[i]];
}
cout << ans;
}
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;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, x, z, v, sum, total, ans = 1000000000000000000;
cin >> n >> k;
if (k == 1) {
ans = 0;
}
map<long long, long long> m;
for (long i = 0; i < n; i++) {
cin >> x;
m[x]++;
}
vector<long long> p, s;
p.push_back(0);
s.push_back(0);
sum = 0;
total = 0;
map<long long, long long>::iterator submarine = m.begin(),
helicopter = m.begin();
helicopter++;
for (long i = 0; i < m.size() - 1; i++) {
sum += submarine->second;
if (sum >= k) {
ans = min(ans, total - sum + k);
}
if (submarine->second >= k) {
ans = 0;
}
total += sum * (helicopter->first - submarine->first);
p.push_back(total);
submarine++;
helicopter++;
}
if (submarine->second >= k) {
ans = 0;
}
sum = 0;
total = 0;
helicopter--;
helicopter--;
for (long i = 0; i < m.size() - 1; i++) {
sum += submarine->second;
if (sum >= k) {
ans = min(ans, total - sum + k);
}
total += sum * (submarine->first - helicopter->first);
s.push_back(total);
submarine--;
helicopter--;
}
for (long i = 0; i < p.size(); i++) {
ans = min(ans, p[i] + s[p.size() - 1 - i] - n + k);
}
cout << max((long long)0, ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000000001;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
std::vector<int> v[200010];
for (int i = 0; i < n; i++) {
int temp = a[i];
int cnt = 0;
while (temp) {
v[temp].push_back(cnt);
temp /= 2;
cnt++;
}
}
int ans = INT_MAX;
for (int i = 0; i < 200001; i++) {
sort(v[i].begin(), v[i].end());
if (v[i].size() >= k) {
ans = min(ans, accumulate(v[i].begin(), v[i].begin() + k, 0));
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const long long LL_INF = (long long)2e18 + 5;
int N, K;
vector<int> A;
vector<long long> prefix_sum, suffix_sum;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> K;
A.resize(N);
for (int &a : A) cin >> a;
sort(A.begin(), A.end());
prefix_sum.assign(N + 1, 0);
suffix_sum.assign(N + 1, 0);
for (int i = 0; i < N; i++) prefix_sum[i + 1] = prefix_sum[i] + A[i];
for (int i = N - 1; i >= 0; i--) suffix_sum[i] = suffix_sum[i + 1] + A[i];
long long answer = LL_INF;
for (int i = 0, j = 0; i < N; i = j) {
long long value = A[i];
while (j < N && A[j] == value) j++;
if (j - i >= K) {
answer = 0;
break;
}
int need = K - (j - i);
int before = i;
int after = N - j;
long long before_cost = before * value - prefix_sum[i];
long long after_cost = suffix_sum[j] - after * value;
if (before >= need) answer = min(answer, before_cost - (before - need));
if (after >= need) answer = min(answer, after_cost - (after - need));
answer = min(answer, before_cost + after_cost - (before + after - need));
}
cout << answer << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, arr[400005], fac = 0, brr[400005] = {0}, min = LONG_MAX,
cost, initial, final, temp_ans, ans;
scanf("%lld%lld", &n, &k);
for (long long int i = 0; i < n; ++i) {
scanf("%lld", &arr[i]);
brr[arr[i]]++;
}
sort(arr, arr + n);
printf("\n");
for (long long int j = 0; j <= arr[n - 1]; ++j) {
fac = 0;
cost = 0;
temp_ans = 0;
ans = 0;
initial = j;
final = j;
while (ans < k && initial <= 2 * 100000 && final <= 200000) {
if (fac == 0) {
if (brr[initial] > 0) {
temp_ans = ans + brr[initial];
if (temp_ans < k) {
ans = temp_ans;
cost += (fac * brr[initial]);
} else {
ans = k;
cost += (fac * (k - ans));
break;
}
}
}
if (ans >= k) break;
fac++;
initial = initial * 2;
final = final * 2 + 1;
if (initial == 0) initial++;
for (long long int i = initial;
i <= final && initial <= 4 * 100000 && final <= 400000; ++i) {
if (brr[i] > 0) {
temp_ans = ans + brr[i];
if (temp_ans <= k) {
ans = temp_ans;
cost += (fac * brr[i]);
} else {
cost += (fac * (k - ans));
ans = k;
break;
}
}
if (ans >= k) break;
}
if (j == 2)
if (ans >= k) break;
}
if (ans >= k) {
if (cost <= min) {
min = cost;
}
}
}
printf("%lld\n", min);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
void err() { cout << "\033[39;0m" << endl; }
template <class T, class... Ts>
void err(const T& arg, const Ts&... args) {
cout << arg << " ";
err(args...);
}
const int N = 200000 + 5;
int n, k, a[N];
vector<int> v;
long long cnt[N], sum[N];
long long pre[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v.push_back(a[i]);
}
v.push_back(0);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; i++) {
int id = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
cnt[id]++;
}
n = v.size() - 1;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + cnt[i];
pre[i] = pre[i - 1] + cnt[i] * v[i];
}
long long res = pre[n];
for (int i = 1; i <= n; i++) {
long long need = max(0ll, k - cnt[i]);
{
long long tmp = 0;
int lnum = min(need, sum[i - 1]);
if (lnum) {
tmp = sum[i - 1] * (v[i] - 1) - pre[i - 1];
tmp += lnum;
}
int rnum = min(need - lnum, sum[n] - sum[i]);
if (rnum) {
tmp += (pre[n] - pre[i]) - (sum[n] - sum[i]) * (v[i] + 1);
tmp += rnum;
}
res = min(res, tmp);
}
{
long long tmp = 0;
int rnum = min(need, sum[n] - sum[i]);
if (rnum) {
tmp = (pre[n] - pre[i]) - (sum[n] - sum[i]) * (v[i] + 1);
tmp += rnum;
}
int lnum = min(need - rnum, sum[i - 1]);
if (lnum) {
tmp += sum[i - 1] * (v[i] - 1) - pre[i - 1];
tmp += lnum;
}
res = min(res, tmp);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long n, m, t, k;
int pos[200005], tmp[200005];
pair<pair<int, int>, int> a[200005];
class dsu {
public:
int fa[200005];
void init(int n) {
for (int i = 0; i <= n; i++) {
fa[i] = i;
}
}
int find(int u) {
while (u != fa[u]) u = fa[u] = fa[fa[u]];
fa[u] = u + 1;
return u;
}
} num;
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.second != b.first.second) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
set<int> mp;
vector<pair<pair<long long, long long>, int>> points;
void print(int p[200005]) {
for (int i = 1; i <= n; i++) cout << p[i] << " ";
cout << endl;
}
void swp(int a, int b) {
for (int i = 1; i <= n; i++) {
tmp[i] = pos[i];
if (tmp[i] == a) {
tmp[i] = b;
} else if (tmp[i] == b) {
tmp[i] = a;
}
}
}
bool cmp2(pair<pair<long long, long long>, int> a,
pair<pair<long long, long long>, int> b) {
if (a.first.first != b.first.first) return a.first.first < b.first.first;
return a.second < b.second;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i + 1;
}
sort(a, a + n, cmp);
num.init(n);
bool sud = 1;
for (int i = 0; i < n; i++) {
pos[a[i].second] = num.find(a[i].first.first);
points.push_back({make_pair(pos[a[i].second], a[i].first.first), 0});
points.push_back(
{make_pair(a[i].first.second, a[i].first.first), pos[a[i].second]});
}
sort(points.begin(), points.end(), cmp2);
for (auto point : points) {
if (point.second == 0) {
if (!mp.empty() && point.first.second <= (*mp.rbegin())) {
swp((*mp.rbegin()), point.first.first);
sud = 0;
break;
}
mp.insert(point.first.first);
} else {
mp.erase(point.second);
}
}
if (sud) {
cout << "YES\n";
print(pos);
} else {
cout << "NO\n";
print(pos);
print(tmp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 200;
int n, ai[MAX_N], bi[MAX_N], seq[MAX_N], pos[MAX_N];
vector<pair<int, int> > vec[MAX_N];
pair<int, int> nodes[MAX_N << 2];
pair<int, int> pushup(pair<int, int> ls, pair<int, int> rs) {
if (ls.first == -1) return rs;
if (rs.first == -1) return ls;
return min(ls, rs);
}
void build(int l, int r, int p) {
if (l == r) return (void)(nodes[p] = make_pair(ai[pos[l]], l));
build(l, ((l + r) >> 1), (p << 1)),
build(((l + r) >> 1) + 1, r, ((p << 1) | 1));
nodes[p] = pushup(nodes[(p << 1)], nodes[((p << 1) | 1)]);
}
pair<int, int> query(int ql, int qr, int l, int r, int p) {
if (ql <= l && r <= qr) return nodes[p];
pair<int, int> ls = make_pair(-1, -1), rs = make_pair(-1, -1);
if (ql <= ((l + r) >> 1)) ls = query(ql, qr, l, ((l + r) >> 1), (p << 1));
if (((l + r) >> 1) < qr)
rs = query(ql, qr, ((l + r) >> 1) + 1, r, ((p << 1) | 1));
return pushup(ls, rs);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &ai[i], &bi[i]), vec[ai[i]].push_back(make_pair(bi[i], i));
set<pair<int, int> > st;
for (int i = 1; i <= n; i++) {
st.insert(vec[i].begin(), vec[i].end());
seq[st.begin()->second] = i;
pos[i] = st.begin()->second;
st.erase(st.begin());
}
build(1, n, 1);
for (int i = 1; i <= n; i++) {
if (i + 1 > bi[pos[i]]) continue;
pair<int, int> res = query(i + 1, bi[pos[i]], 1, n, 1);
if (res.first <= i) {
puts("NO");
for (int i = 1; i <= n; i++) printf("%d ", seq[i]);
puts("");
swap(seq[pos[res.second]], seq[pos[i]]);
for (int i = 1; i <= n; i++) printf("%d ", seq[i]);
puts("");
exit(0);
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", seq[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
std::pair<std::pair<int, int>, int> a[262144], pq[262144];
int ans[262144];
std::pair<int, int> bit[262144];
void update(int k, std::pair<int, int> v) {
++k;
while (k) bit[k] = std::max(bit[k], v), k -= k & -k;
}
std::pair<int, int> qry(int k) {
std::pair<int, int> res(-1, -1);
++k;
while (k < 262144) res = std::max(res, bit[k]), k += k & -k;
return res;
}
bool cmp(const std::pair<std::pair<int, int>, int> &a,
const std::pair<std::pair<int, int>, int> &b) {
return a.first.second > b.first.second;
}
int main() {
int n, npq = 0;
memset(bit, -1, sizeof(bit));
scanf("%d", &n);
for (int i = 0; i < n; ++i)
scanf("%d%d", &a[i].first.first, &a[i].first.second), --a[i].first.first,
--a[i].first.second, a[i].second = i;
std::sort(a, a + n);
for (int i = 0, j = 0; i < n; ++i) {
while (j < n && a[j].first.first <= i)
pq[npq++] = a[j++], std::push_heap(pq, pq + npq, cmp);
std::pop_heap(pq, pq + npq, cmp), a[i] = pq[--npq];
}
for (int i = 0; i < n; ++i) ans[a[i].second] = i;
bool f = true;
for (int i = 0; i < n; ++i) {
std::pair<int, int> r = qry(a[i].first.first);
if (r.first >= i) {
std::swap(a[r.second], a[i]);
f = false;
break;
}
update(i, {a[i].first.second, i});
}
puts(f ? "YES" : "NO");
for (int i = 0; i < n; ++i) printf(" %d" + !i, ans[i] + 1);
printf("\n");
if (!f) {
for (int i = 0; i < n; ++i) ans[a[i].second] = i;
for (int i = 0; i < n; ++i) printf(" %d" + !i, ans[i] + 1);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double pi = acos(-1), eps = 1e-8;
const int maxn = 1 << 17;
const int N = 1e6 + 7, M = 1 << 16, mod = 1e9 + 7;
int n, m;
struct node {
int l, r;
int id;
bool operator<(const node &x) const {
if (l == x.l) return r < x.r;
return l < x.l;
}
} a[N];
struct nd {
int r, id;
bool operator<(const nd &x) const { return r > x.r; }
};
int l[N], r[N];
int pos[N];
int ans[N];
vector<int> v[N], w[N];
int s[N], flag[N];
void update(int a, int b, int x, int k, int l, int r) {
if (a == l && b == r) {
s[x] = max(s[x], k);
flag[x] = max(flag[x], k);
return;
}
int mid = l + r >> 1, ls = x << 1, rs = x << 1 | 1;
if (flag[x]) {
update(l, mid, ls, flag[x], l, mid);
update(mid + 1, r, rs, flag[x], mid + 1, r);
flag[x] = 0;
}
if (b <= mid)
update(a, b, ls, k, l, mid);
else if (a > mid)
update(a, b, rs, k, mid + 1, r);
else {
update(a, mid, ls, k, l, mid);
update(mid + 1, b, rs, k, mid + 1, r);
}
s[x] = max(s[ls], s[rs]);
}
int query(int loc, int x, int l, int r) {
if (l == r) return s[x];
int mid = l + r >> 1, ls = x << 1, rs = x << 1 | 1;
if (flag[x]) {
update(l, mid, ls, flag[x], l, mid);
update(mid + 1, r, rs, flag[x], mid + 1, r);
flag[x] = 0;
}
if (loc <= mid)
return query(loc, ls, l, mid);
else
return query(loc, rs, mid + 1, r);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].id = i;
l[i] = a[i].l, r[i] = a[i].r;
}
sort(a + 1, a + 1 + n);
int now = 1;
priority_queue<nd> q;
for (int i = 1; i <= n; i++) {
while (a[now].l <= i && now <= n) {
q.push(nd{a[now].r, a[now].id});
now++;
}
nd x = q.top();
q.pop();
ans[x.id] = i;
pos[i] = x.id;
}
int flag = 0, f = 0;
for (int i = 1; i <= n; i++) {
int x = pos[i];
int y = query(i, 1, 1, n);
if (l[x] <= y) {
flag = x, f = pos[y];
break;
}
update(i, r[x], 1, i, 1, n);
}
if (flag == 0) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
} else {
printf("NO\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
swap(ans[flag], ans[f]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x[200005], y[200005], z[200005], la = -1, lb;
vector<pair<int, int>> v[200005];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
q;
stack<pair<int, int>> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", y + i, z + i);
v[y[i]].emplace_back(z[i], i);
}
for (int i = 1; i <= n; i++) {
for (auto& j : v[i]) q.push(j);
int tmp = q.top().second;
q.pop();
while (!s.empty() && z[s.top().second] < i) s.pop();
if (!s.empty() && y[tmp] <= s.top().first) {
la = s.top().second;
lb = tmp;
}
s.emplace(i, tmp);
x[tmp] = i;
}
puts(la == -1 ? "YES" : "NO");
for (int i = 1; i <= n; i++) printf("%d%c", x[i], " \n"[i == n]);
if (la != -1)
for (int i = 1; i <= n; i++)
printf("%d%c", i == la ? x[lb] : i == lb ? x[la] : x[i], " \n"[i == n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n;
int l[N], r[N];
int v[N], loc[N];
vector<pair<int, int> > w[N];
int f[N * 4];
void ins(int l, int r, int s, int ll, int v) {
while (1) {
f[s] = v;
if (l == r) return;
if ((l + r) / 2 >= ll)
r = (l + r) / 2, s += s;
else
l = (l + r) / 2 + 1, s += s + 1;
}
}
int get(int l, int r, int s, int ll, int rr) {
if (!f[s] || r < ll || rr < l) return 0;
if (ll <= l && r <= rr) return f[s];
int x = get(l, (l + r) / 2, s + s, ll, rr);
return x ? x : get((l + r) / 2 + 1, r, s + s + 1, ll, rr);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &l[i], &r[i]);
w[l[i]].push_back({r[i], i});
}
priority_queue<pair<int, int> > h;
for (int i = 1; i <= n; i++) {
for (auto u : w[i]) h.push({-u.first, u.second});
loc[v[i] = h.top().second] = i;
h.pop();
}
for (int i = 1; i <= n; i++) w[i].clear();
for (int i = 1; i <= n; i++) w[r[i]].push_back({loc[i], i});
for (int i = n; i >= 1; i--) {
for (auto u : w[i]) ins(1, n, 1, u.first, u.second);
int x = get(1, n, 1, l[v[i]], i - 1);
if (x) {
puts("NO");
for (int i = 1; i <= n; i++) printf("%d%c", loc[i], " \n"[i == n]);
swap(loc[v[i]], loc[x]);
for (int i = 1; i <= n; i++) printf("%d%c", loc[i], " \n"[i == n]);
return 0;
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", loc[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
const int N = 2e5 + 1;
int pos[N];
struct Data {
int x, y, pos;
Data(int x, int y, int pos) : x(x), y(y), pos(pos) {}
};
int n;
vector<Data> F, G;
bool comp(Data A, Data B) { return (A.x == B.x) ? (A.y < B.y) : (A.x < B.x); }
vector<int> Solve(vector<Data> cur) {
vector<int> res(n);
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Pr;
int p = 0;
for (int i = 1; i <= n; i++) {
while (p < n && cur[p].x <= i) {
Pr.push(pair<int, int>(cur[p].y, cur[p].pos));
p++;
}
int p = Pr.top().second;
res[p] = i;
Pr.pop();
if (Pr.size()) {
pos[p] = Pr.top().second;
}
}
return res;
}
pair<int, int> memo[200001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) pos[i] = -1;
for (int i = 1; i <= n; i++) {
int u, v, x, y;
cin >> u >> v;
F.push_back(Data(u, v, i - 1));
memo[i - 1] = pair<int, int>(u, v);
}
sort(F.begin(), F.end(), comp);
vector<int> x = Solve(F);
int meow = -1;
auto Check = [&](int val, pair<int, int> cur) {
return cur.first <= val && val <= cur.second;
};
for (int i = 0; i < x.size(); i++) {
if (pos[i] == -1) continue;
int p = x[i];
int q = x[pos[i]];
if (i == pos[i]) continue;
if (Check(q, memo[i]) && Check(p, memo[pos[i]])) {
meow = i;
break;
}
}
if (meow == -1) {
cout << "YES\n";
for (int k : x) cout << k << ' ';
} else {
cout << "NO\n";
for (int k : x) cout << k << ' ';
cout << '\n';
swap(x[meow], x[pos[meow]]);
for (int k : x) cout << k << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, INF = 1e9 + 10;
int n;
int a[N], b[N];
int ans[N], pos[N];
pair<int, int> tree[N << 2];
vector<pair<int, int> > vec[N];
void build(int node, int l, int r) {
if (l == r) {
tree[node].first = a[pos[l]];
tree[node].second = l;
return;
}
int mid = l + r >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
tree[node] = min(tree[node << 1], tree[node << 1 | 1]);
}
pair<int, int> query(int node, int l, int r, int L, int R) {
if (L <= l && R >= r) return tree[node];
int mid = l + r >> 1;
pair<int, int> res1 = {INF, INF};
pair<int, int> res2 = {INF, INF};
if (L <= mid) res1 = query(node << 1, l, mid, L, R);
if (R > mid) res2 = query(node << 1 | 1, mid + 1, r, L, R);
return min(res1, res2);
}
void print() {
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
puts("");
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
vec[a[i]].push_back({b[i], i});
}
set<pair<int, int> > s;
for (int i = 1; i <= n; i++) {
s.insert(vec[i].begin(), vec[i].end());
ans[s.begin()->second] = i;
pos[i] = s.begin()->second;
s.erase(s.begin());
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
pair<int, int> tmp = query(1, 1, n, i + 1, b[pos[i]]);
if (tmp.first <= i) {
puts("NO");
print();
swap(ans[pos[i]], ans[pos[tmp.second]]);
print();
return 0;
}
}
puts("YES");
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
set<pair<int, int> > mp;
vector<pair<int, int> > vec[N];
int a[N], b[N];
int st[30][N];
int ans[N];
int where[N];
int lg2[N];
int main() {
int n;
cin >> n;
lg2[1] = 0;
for (int i = 2; i <= n; i++) lg2[i] = lg2[i >> 1] + 1;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
vec[a[i]].push_back({b[i], i});
}
set<pair<int, int> >::iterator it;
for (int i = 1; i <= n; i++) {
mp.insert(vec[i].begin(), vec[i].end());
it = mp.begin();
ans[it->second] = i;
where[i] = it->second;
mp.erase(mp.begin());
}
for (int i = 1; i <= n; i++) st[0][i] = a[where[i]];
for (int i = 1; i <= 29; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++)
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
for (int i = 1; i <= n; i++) {
int l = i + 1, r = b[where[i]];
if (l > r) continue;
int len = r - l + 1;
len = lg2[len];
int minv = min(st[len][l], st[len][r - (1 << len) + 1]);
if (minv <= i) {
cout << "NO" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
for (int k = l; k <= r; k++) {
if (a[where[k]] <= i) {
swap(ans[where[k]], ans[where[i]]);
break;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr static int MAXN = 2e5 + 10;
int n;
int a[MAXN], b[MAXN];
vector<pair<int, int>> cur[MAXN];
int pos[MAXN];
int r[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
cur[a[i]].push_back({b[i], i});
}
for (int i = 0; i < n; i++) pos[i] = -1;
int s1 = -1, s2 = -1;
priority_queue<pair<int, int>> pq;
for (int i = 1; i <= n; i++) {
for (auto p : cur[i]) pq.push({-p.first, p.second});
assert(pq.size() > 0);
auto t = pq.top();
pq.pop();
r[t.second] = i;
if (s1 != -1) continue;
if (pq.size() != 0 && pq.top().first == t.first) {
s1 = t.second;
s2 = pq.top().second;
continue;
}
int prv = pos[t.second];
if (prv != -1 && i <= b[prv] && i >= a[prv]) {
s1 = prv;
s2 = t.second;
continue;
}
if (pq.size() == 0 || -t.first == i) continue;
pos[pq.top().second] = t.second;
}
cout << (s1 == -1 ? "YES" : "NO") << endl;
for (int i = 0; i < n; i++) cout << r[i] << ' ';
cout << endl;
if (s1 != -1) {
swap(r[s1], r[s2]);
for (int i = 0; i < n; i++) cout << r[i] << ' ';
cout << endl;
}
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 5;
using namespace std;
int n, ans[N];
struct node {
int id, l, r, c;
} p[N], b[N];
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
set<int> S;
set<int>::iterator it1;
template <typename T>
inline T read() {
T x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * w;
}
bool cmp1(node a, node b) { return a.l < b.l; }
bool cmp2(node a, node b) { return a.c < b.c; }
int main() {
n = read<int>();
for (int i = 1; i <= n; i++)
p[i].id = i, p[i].l = read<int>(), p[i].r = read<int>();
sort(p + 1, p + n + 1, cmp1);
for (int pos = 1, i = 1; i <= n; i++) {
while (pos <= n && p[pos].l <= i)
s.insert(make_pair(p[pos].r, p[pos].id)), pos++;
it = s.begin(), ans[(*it).second] = i, s.erase(it);
}
while (s.size()) s.erase(s.begin());
for (int i = 1; i <= n; i++) p[i].c = ans[p[i].id];
for (int i = 1; i <= n; i++) b[i] = p[i];
sort(b + 1, b + n + 1, cmp1);
sort(p + 1, p + n + 1, cmp2);
for (int pos = 1, i = 1; i <= n; i++) {
while (pos <= n && b[pos].l <= i)
s.insert(make_pair(b[pos].r, b[pos].c)), S.insert(b[pos].c), pos++;
while (s.size()) {
it = s.begin();
if ((*it).first < i)
S.erase((*it).second), s.erase(it);
else
break;
}
s.erase(make_pair(p[i].r, p[i].c)), S.erase(p[i].c);
if (S.size()) {
it1 = S.lower_bound(p[i].l);
if (it1 != S.end() && (*it1) <= p[i].r) {
puts("NO");
for (int j = 1; j <= n; j++)
printf("%d%c", ans[j], j == n ? '\n' : ' ');
swap(ans[p[i].id], ans[p[(*it1)].id]);
for (int j = 1; j <= n; j++)
printf("%d%c", ans[j], j == n ? '\n' : ' ');
return 0;
}
}
s.insert(make_pair(p[i].r, p[i].c)), S.erase(p[i].c);
}
puts("YES");
for (int j = 1; j <= n; j++) printf("%d%c", ans[j], j == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int mxN = 2e5 + 1;
pair<pair<long long, long long>, long long> a[mxN];
int ans1[mxN], ans2[mxN];
int rev_ans[mxN];
long long n;
long long seg[4 * mxN] = {};
void upd(long long i, long long val, long long st = 1, long long en = n,
long long second = 0) {
if (st <= i && i <= en) seg[second] = max(seg[second], val);
if (i < st || i > en || st == en) return;
long long mid = (st + en) / 2;
upd(i, val, st, mid, 2 * second + 1);
upd(i, val, mid + 1, en, 2 * second + 2);
}
long long qry(long long qs, long long qe, long long st = 1, long long en = n,
long long second = 0) {
if (qe < st || en < qs) return -1e18;
if (qs <= st && en <= qe) return seg[second];
long long mid = (st + en) / 2;
return max(qry(qs, qe, st, mid, 2 * second + 1),
qry(qs, qe, mid + 1, en, 2 * second + 2));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i <= n - 1; i++)
cin >> a[i].first.second >> a[i].first.first, a[i].second = i;
sort(a, a + n);
bool ok = 1;
set<int> avail;
for (int i = 1; i <= n; i++) avail.insert(i);
for (int i = 0; i < n; i++) {
auto it = avail.lower_bound(a[i].first.second);
int cur = *it;
avail.erase(it);
ans1[a[i].second] = cur;
ans2[a[i].second] = cur;
rev_ans[cur] = i;
if (ok) upd(cur, a[i].first.first);
if (ok && cur != a[i].first.second &&
qry(a[i].first.second, cur - 1) >= cur) {
ok = 0;
for (int j = a[i].first.second; j < cur; j++) {
int i2 = rev_ans[j];
if (a[i2].first.first >= cur) {
ans2[a[i2].second] = cur;
ans2[a[i].second] = j;
break;
}
}
}
}
if (ok) {
cout << "YES\n";
for (int i = 0; i <= n - 1; i++) cout << ans1[i] << " ";
cout << '\n';
} else {
cout << "NO\n";
for (int i = 0; i <= n - 1; i++) cout << ans1[i] << " ";
cout << '\n';
for (int i = 0; i <= n - 1; i++) cout << ans2[i] << " ";
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > str[200005];
int a[200005];
int b[200005];
int ans[200005];
int p[200005];
pair<int, int> seg[400005];
int inf = 1e9;
void out() {
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
int q(int l, int r) {
l--;
pair<int, int> res{inf, inf};
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2 == 1) res = min(res, seg[l++]);
if (r % 2 == 1) res = min(res, seg[--r]);
}
return res.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
str[a[i]].push_back({b[i], i});
}
set<pair<int, int> > ac;
for (int i = 1; i <= n; i++) {
ac.insert(str[i].begin(), str[i].end());
ans[ac.begin()->second] = i;
p[i] = ac.begin()->second;
ac.erase(ac.begin());
}
for (int i = 0; i < n; i++) {
seg[i + n] = {a[p[i + 1]], i + 1};
}
for (int i = n - 1; i > 0; i--) {
seg[i] = min(seg[2 * i], seg[2 * i + 1]);
}
for (int i = 1; i <= n; i++) {
int j = q(i + 1, b[p[i]]);
if (j == inf) continue;
if (a[p[j]] <= i) {
cout << "NO\n";
out();
swap(ans[p[i]], ans[p[j]]);
out();
return 0;
}
}
cout << "YES\n";
out();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ld = long double;
template <typename T>
using mat = vector<vector<T> >;
template <int mod>
struct modint {
int x;
modint() : x(0) {}
modint(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
modint &operator+=(const modint &p) {
if ((x += p.x) >= mod) x -= mod;
return *this;
}
modint &operator-=(const modint &p) {
if ((x += mod - p.x) >= mod) x -= mod;
return *this;
}
modint &operator*=(const modint &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
modint &operator/=(const modint &p) {
*this *= p.inverse();
return *this;
}
modint operator-() const { return modint(-x); }
modint operator+(const modint &p) const { return modint(*this) += p; }
modint operator-(const modint &p) const { return modint(*this) -= p; }
modint operator*(const modint &p) const { return modint(*this) *= p; }
modint operator/(const modint &p) const { return modint(*this) /= p; }
bool operator==(const modint &p) const { return x == p.x; }
bool operator!=(const modint &p) const { return x != p.x; }
modint inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return modint(u);
}
modint pow(int64_t n) const {
modint ret(1), mul(x);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const modint &p) { return os << p.x; }
friend istream &operator>>(istream &is, modint &a) {
int64_t t;
is >> t;
a = modint<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T>
T mypow(T x, ll n) {
T ret = 1;
while (n > 0) {
if (n & 1) (ret *= x);
(x *= x);
n >>= 1;
}
return ret;
}
ll modpow(ll x, ll n, const ll mod) {
ll ret = 1;
while (n > 0) {
if (n & 1) (ret *= x);
(x *= x);
n >>= 1;
x %= mod;
ret %= mod;
}
return ret;
}
uint64_t my_rand(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 13);
x = x ^ (x >> 7);
return x = x ^ (x << 17);
}
template <typename T>
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T> >;
template <typename T>
using WeightedGraph = vector<Edges<T> >;
const long double eps = 0.001;
const long double PI = 3.141592653589793;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << setprecision(20);
int n;
cin >> n;
mat<pair<int, int> > event(n + 1);
for (int i = (0), max_i = (n); i < max_i; i++) {
int a, b;
cin >> a >> b;
a--;
event[a].emplace_back(make_pair(b, i));
}
multiset<pair<int, int> > R;
vector<int> cumsum(n + 1);
vector<int> ans(n, -1);
vector<int> girigiri(n);
for (int i = (0), max_i = (n); i < max_i; i++) {
for (pair<int, int> p : event[i]) {
R.insert(p);
}
pair<int, int> r = *R.begin();
ans[r.second] = i;
R.erase(R.begin());
if (r.first == i + 1) girigiri[i]++;
}
for (int i = (0), max_i = (n); i < max_i; i++)
cumsum[i + 1] = cumsum[i] + girigiri[i];
bool flag = true;
vector<int> ans2(n);
for (int i = (0), max_i = (n); i < max_i; i++) {
for (pair<int, int> p : event[i]) {
R.insert(p);
}
pair<int, int> r = *R.begin();
if (((int)(R).size()) == 1) {
R.erase(R.begin());
ans2[r.second] = i;
continue;
}
pair<int, int> r1 = *(++R.begin());
if (flag && girigiri[i] == 0 &&
cumsum[ans[r1.second]] - cumsum[r.first - 1] <= 0) {
R.erase(++R.begin());
ans2[r1.second] = i;
flag = false;
} else {
R.erase(R.begin());
ans2[r.second] = i;
}
}
if (flag) {
cout << "Yes" << '\n';
for (int i = (0), max_i = (n); i < max_i; i++) cout << ans[i] + 1 << ' ';
cout << '\n';
} else {
cout << "NO" << '\n';
for (int i = (0), max_i = (n); i < max_i; i++) cout << ans[i] + 1 << ' ';
cout << '\n';
for (int i = (0), max_i = (n); i < max_i; i++) cout << ans2[i] + 1 << ' ';
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > g[200005];
int xy[200005][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, u, v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> u >> v;
xy[i][0] = u;
xy[i][1] = v;
g[u].push_back(pair<long long, long long>(v, i));
}
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
vector<int> res;
vector<pair<long long, long long> > sw;
for (int i = 1; i <= n; i++) {
for (auto y : g[i]) pq.push(y);
if (pq.top().first > i && pq.size() > 1) {
pair<long long, long long> x = pq.top();
pq.pop();
sw.push_back(pair<long long, long long>(x.second, pq.top().second));
pq.push(x);
}
res.push_back(pq.top().second);
pq.pop();
}
if (!sw.size()) {
cout << ("YES") << '\n';
vector<int> rr(n);
for (int i = 0; i < n; i++) rr[res[i]] = i + 1;
for (auto y : rr) cout << y << ' ';
cout << '\n';
} else {
vector<pair<long long, long long> > sw_ok;
vector<int> rr(n);
for (int i = 0; i < n; i++) rr[res[i]] = i + 1;
for (auto y : sw)
if (rr[y.second] <= xy[y.first][1]) sw_ok.push_back(y);
if (sw_ok.size()) {
cout << ("NO") << '\n';
for (auto y : rr) cout << y << ' ';
cout << '\n';
for (int i = 0; i < n; i++) {
if (res[i] == sw_ok[0].first)
res[i] = sw_ok[0].second;
else if (res[i] == sw_ok[0].second)
res[i] = sw_ok[0].first;
}
for (int i = 0; i < n; i++) rr[res[i]] = i + 1;
for (auto y : rr) cout << y << ' ';
cout << '\n';
} else {
cout << ("YES") << '\n';
for (auto y : rr) cout << y << ' ';
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int L[MAXN], R[MAXN];
int pos[MAXN], ans[MAXN];
vector<pair<int, int> > E[MAXN];
set<pair<int, int> > sv;
int n;
struct seg {
int mi[MAXN << 2];
void push_up(int rt) { mi[rt] = min(mi[rt << 1], mi[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
mi[rt] = L[pos[l]];
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
push_up(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L > R) return 1e9;
if (L <= l && r <= R) return mi[rt];
int mid = (l + r) >> 1;
int ret = 1e9;
if (L <= mid) ret = min(ret, query(L, R, l, mid, rt << 1));
if (mid < R) ret = min(ret, query(L, R, mid + 1, r, rt << 1 | 1));
return ret;
}
} se;
void print() {
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &L[i], &R[i]);
E[L[i]].push_back(make_pair(R[i], i));
}
for (int i = 1; i <= n; i++) {
sv.insert(E[i].begin(), E[i].end());
int id = (*sv.begin()).second;
pos[i] = id;
ans[id] = i;
sv.erase(sv.begin());
}
se.build(1, n, 1);
for (int i = 1; i <= n; i++) {
int mi = se.query(i + 1, R[pos[i]], 1, n, 1);
if (mi <= i) {
puts("NO");
for (int j = i + 1; j <= R[pos[i]]; j++)
if (L[pos[j]] == mi) {
print();
swap(ans[pos[i]], ans[pos[j]]);
print();
return 0;
}
}
}
puts("YES");
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, res[200500], st1[200500][20], st2[200500][20];
int l2(int n) {
int r = 0;
while (n - 1) {
r++;
n >>= 1;
}
return r;
}
int chk1(int l, int r) {
int k = l2(r - l + 1);
return max(st1[l][k], st1[r - (1 << k) + 1][k]);
}
int chk2(int l, int r) {
int k = l2(r - l + 1);
return min(st2[l][k], st2[r - (1 << k) + 1][k]);
}
struct sb {
int id, l, r;
bool operator<(const sb x) const { return r > x.r; }
} tmp, s[200500];
vector<sb> v[200500];
priority_queue<sb> q;
void ans() {
for (int i = 1; i <= n; i++) {
printf("%d ", res[i]);
}
puts("");
}
int main() {
memset(st2, 0x3f, sizeof(st2));
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &j, &k);
s[i].id = i;
s[i].l = j;
s[i].r = k;
v[j].push_back(s[i]);
}
for (i = 1; i <= n; i++) {
for (auto j : v[i]) {
q.push(j);
}
s[i] = q.top();
q.pop();
res[s[i].id] = i;
st1[i][0] = s[i].r;
st2[i][0] = s[i].l;
}
for (j = 1; j <= 18; j++) {
for (i = 1; i + (1 << j) - 1 <= n; i++) {
st1[i][j] = max(st1[i][j - 1], st1[i + (1 << (j - 1))][j - 1]);
st2[i][j] = min(st2[i][j - 1], st2[i + (1 << (j - 1))][j - 1]);
}
}
for (i = 1; i <= n; i++) {
if (s[i].l < i && chk1(s[i].l, i - 1) >= i) {
puts("NO");
ans();
for (j = i - 1;; j--) {
if (s[j].r >= i) {
swap(res[s[i].id], res[s[j].id]);
break;
}
}
ans();
return 0;
}
if (s[i].r > i && chk2(i + 1, s[i].r) <= i) {
puts("NO");
ans();
for (j = i + 1;; j++) {
if (s[j].l <= i) {
swap(res[s[i].id], res[s[j].id]);
break;
}
}
ans();
return 0;
}
}
puts("YES");
ans();
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const long long INF = 8e18;
const int maxn = 2e5 + 5;
set<pair<int, int> > st[maxn];
struct node {
int l, r, ans, pos;
} nd[maxn];
int n;
int f[maxn][20], lg[maxn], ans[maxn];
bool cmp(node a, node b) { return a.ans < b.ans; }
bool cmp2(node a, node b) { return a.pos < b.pos; }
inline void init() {
lg[1] = 0, lg[2] = 1;
for (int i = 3; i <= maxn - 5; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; ++i) f[i][0] = nd[i].l;
for (int j = 1; j <= 18; ++j) {
for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
}
}
}
inline int Q(int l, int r) {
int len = r - l + 1;
len = lg[len];
return min(f[l][len], f[r - (1 << len) + 1][len]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
int x, y;
cin >> x >> y;
nd[i] = {x, y, 0, i};
st[x].insert({y, i});
}
set<pair<int, int> > cur;
for (int i = 1; i <= n; ++i) {
for (auto &x : st[i]) cur.insert(x);
auto x = *cur.begin();
nd[x.second].ans = i;
cur.erase(cur.begin());
}
sort(nd + 1, nd + 1 + n, cmp);
init();
int ok = -1;
for (int i = 1; i <= n; ++i) {
int l = nd[i].ans + 1, r = nd[i].r;
if (l > r) continue;
if (nd[i].ans >= Q(l, r)) {
ok = nd[i].pos;
break;
}
}
sort(nd + 1, nd + 1 + n, cmp2);
if (ok == -1) {
cout << "YES" << '\n';
for (int i = 1; i <= n; ++i) cout << nd[i].ans << ' ';
return 0;
}
cout << "NO" << '\n';
for (int i = 1; i <= n; ++i) cout << nd[i].ans << ' ';
cout << '\n';
int l = nd[ok].ans + 1, r = nd[ok].r;
for (int j = 1; j <= n; ++j) {
if (j == ok) continue;
if (nd[j].ans >= l && nd[j].ans <= r && nd[ok].ans >= nd[j].l) {
swap(nd[ok], nd[j]);
break;
}
}
for (int i = 1; i <= n; ++i) cout << nd[i].ans << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
struct SegmentTree {
int t[4 * N];
int get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[v];
int tm = (tl + tr) >> 1;
return max(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v] = val;
return;
}
int tm = (tl + tr) >> 1;
if (pos <= tm)
update(v * 2, tl, tm, pos, val);
else
update(v * 2 + 1, tm + 1, tr, pos, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
};
SegmentTree stree;
vector<pair<int, int> > scanline[N];
int place[N];
int pl[N], pr[N];
int perm[N];
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
scanline[l].push_back({r, i});
pl[i] = l, pr[i] = r;
}
set<pair<int, int> > st;
for (int l = 1; l <= n; l++) {
for (auto x : scanline[l]) {
st.insert(x);
}
int v = st.begin()->second;
st.erase(st.begin());
place[l] = v;
}
for (int i = 1; i <= n; i++) {
int id = place[i];
int getl = pl[id], getr = pr[id];
if (stree.get(1, 1, n, getl, i - 1) >= i) {
cout << "NO\n";
for (int j = 1; j <= n; j++) perm[place[j]] = j;
for (int j = 1; j <= n; j++) cout << perm[j] << " ";
cout << "\n";
for (int j = i - 1; j >= 1; j--) {
int ngetl = j, ngetr = pr[place[j]];
if (getl <= j && i <= ngetr) {
swap(place[i], place[j]);
break;
}
}
for (int j = 1; j <= n; j++) perm[place[j]] = j;
for (int j = 1; j <= n; j++) cout << perm[j] << " ";
return;
}
stree.update(1, 1, n, i, getr);
}
cout << "YES\n";
for (int i = 1; i <= n; i++) perm[place[i]] = i;
for (int i = 1; i <= n; i++) cout << perm[i] << " ";
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int inf = 1e9;
const int maxn = 1e6 + 5;
struct segtree {
pair<int, int> merge(pair<int, int> x, pair<int, int> y) { return min(x, y); }
int n;
vector<pair<int, int>> t;
void init(int n) {
n += 10;
this->n = n;
t.resize(n * 4, {inf, inf});
}
void upd(int v, int tl, int tr, int i, pair<int, int> val) {
if (tl == tr) {
t[v] = val;
} else {
int tm = (tl + tr) / 2;
if (i <= tm) {
upd(2 * v, tl, tm, i, val);
} else {
upd(2 * v + 1, tm + 1, tr, i, val);
}
t[v] = merge(t[2 * v], t[2 * v + 1]);
}
}
pair<int, int> qry(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) {
return {inf, inf};
}
if (l <= tl && tr <= r) {
return t[v];
}
int tm = (tl + tr) / 2;
return merge(qry(2 * v, tl, tm, l, r), qry(2 * v + 1, tm + 1, tr, l, r));
}
};
int n;
pair<int, int> iv[maxn];
int assigned[maxn];
vector<pair<int, int>> s[maxn];
int ans[maxn];
void print_ans() {
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> iv[i].first >> iv[i].second;
s[iv[i].first].push_back({iv[i].second, i});
}
set<pair<int, int>> act;
for (int i = 1; i <= n; i++) {
act.insert(s[i].begin(), s[i].end());
auto cur = *act.begin();
act.erase(act.begin());
assigned[i] = cur.second;
ans[cur.second] = i;
}
segtree t;
t.init(n + 10);
for (int i = 1; i <= n; i++) {
int idx = assigned[i];
t.upd(1, 1, n, i, make_pair(iv[idx].first, idx));
}
for (int i = 1; i <= n; i++) {
int idx = assigned[i];
int R = iv[idx].second;
auto cur = t.qry(1, 1, n, i + 1, R);
if (cur.first == inf) {
continue;
}
if (iv[cur.second].first <= i) {
cout << "NO\n";
print_ans();
swap(ans[idx], ans[cur.second]);
print_ans();
exit(0);
}
}
cout << "YES\n";
print_ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int N = 2e5 + 10;
int n;
int a[N], b[N], id[N], c[N], r[N];
int lab[N];
multiset<pair<int, int> > S;
int cmp(int first, int second) { return a[first] < a[second]; }
int ocmp(int first, int second) { return b[first] < b[second]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
id[i] = lab[i] = i;
}
sort(id + 1, id + n + 1, cmp);
sort(lab + 1, lab + n + 1, ocmp);
int now = 0;
for (int i = 1; i <= n; i++) {
while (now + 1 <= n && a[id[now + 1]] <= i)
now++, S.insert(make_pair(b[id[now]], id[now]));
int u = S.begin()->second;
c[u] = i, r[i] = u;
S.erase(S.begin());
}
int n1 = 0, n2 = 0;
for (int i = 1; i <= n; i++) {
while (n1 + 1 <= n && a[id[n1 + 1]] <= i)
n1++, S.insert(make_pair(c[id[n1]], id[n1]));
S.erase(S.find(make_pair(c[r[i]], r[i])));
multiset<pair<int, int> >::iterator it =
S.lower_bound(make_pair(a[r[i]], 0));
if (it != S.end() && it->first <= b[r[i]]) {
int u = it->second;
printf("NO\n");
for (int i = 1; i <= n; i++) printf("%d%c", c[i], " \n"[i == n]);
swap(c[r[i]], c[u]);
for (int i = 1; i <= n; i++) printf("%d%c", c[i], " \n"[i == n]);
return 0;
}
S.insert(make_pair(c[r[i]], r[i]));
while (n2 + 1 <= n && b[lab[n2 + 1]] <= i)
n2++, S.erase(S.find(make_pair(c[lab[n2]], lab[n2])));
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d%c", c[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 2e5 + 5;
tuple<int, int, int> P[N];
int tree[N * 4];
int delay[N * 4];
void push(int node) {
if (delay[node] == 0) return;
delay[2 * node + 1] += delay[node];
tree[2 * node + 1] += delay[node];
delay[2 * node + 2] += delay[node];
tree[2 * node + 2] += delay[node];
delay[node] = 0;
}
void add(int node, int ts, int te, int s, int e, int d) {
if (s > te || e < ts || s > e) return;
if (s <= ts && e >= te) {
delay[node] += d;
tree[node] += d;
return;
}
push(node);
int m = (ts + te) / 2;
add(node * 2 + 1, ts, m, s, e, d);
add(node * 2 + 2, m + 1, te, s, e, d);
tree[node] = min(tree[2 * node + 1], tree[2 * node + 2]);
}
int query(int node, int ts, int te, int s, int e) {
if (s > te || e < ts || s > e) return INT_MAX;
if (s <= ts && e >= te) {
return tree[node];
}
push(node);
int m = (ts + te) / 2;
int l1 = query(node * 2 + 1, ts, m, s, e);
int l2 = query(node * 2 + 2, m + 1, te, s, e);
return min(l1, l2);
}
void output(vector<int> &res, int n) {
vector<int> a(n);
for (int i = 0; i < res.size(); i++) {
a[res[i]] = i + 1;
}
for (int i = 0; i < n; i++) {
if (i != 0) cout << " ";
cout << a[i];
}
cout << "\n";
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
P[i] = {a - 1, b - 1, i};
}
sort(P, P + n);
int pos = 0;
int p = 0;
set<tuple<int, int, int>> ss;
vector<int> res;
while (pos < n) {
while (p < n && get<0>(P[p]) <= pos) {
ss.insert({get<1>(P[p]), get<2>(P[p]), get<0>(P[p])});
p++;
}
int l, r, idx;
tie(r, idx, l) = *ss.begin();
res.push_back(idx);
ss.erase(ss.begin());
pos++;
}
vector<int> res2 = res;
bool hasT = false;
ss.clear();
set<int> sa;
vector<int> idxToP(n);
for (int i = 0; i < n; i++) {
idxToP[get<2>(P[i])] = i;
};
for (int i = 0; i < n; i++) {
int p = idxToP[res[i]];
if (ss.size() > 0)
;
while (ss.size() > 0 && get<0>(*ss.begin()) < i) {
int t1 = get<2>(*ss.begin());
;
sa.erase(t1);
ss.erase(ss.begin());
}
if (sa.size() > 0 && *sa.rbegin() >= get<0>(P[p])) {
hasT = true;
int l = *sa.rbegin();
swap(res2[i], res2[l]);
break;
} else {
ss.insert({get<1>(P[p]), p, i});
sa.insert(i);
}
}
if (hasT) {
;
;
cout << "NO\n";
output(res, n);
output(res2, n);
} else {
cout << "YES\n";
output(res, n);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
int T = 1;
for (int i = 1; i <= T; i++) {
solve();
}
cout.flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int inf = 1e9 + 7;
int n, a[N], b[N], pos[N], ans[N];
vector<pair<int, int> > bs[N];
pair<int, int> seg[2 * N];
int query(int l, int r) {
l += n - 1;
r += n;
pair<int, int> res = {inf, inf};
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, seg[l++]);
if (r & 1) res = min(res, seg[--r]);
}
return res.second;
}
void show() {
for (int i = 1; i <= n; i++) ans[pos[i]] = i;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
bs[a[i]].push_back({b[i], i});
}
set<pair<int, int> > st;
for (int i = 1; i <= n; i++) {
st.insert(bs[i].begin(), bs[i].end());
auto bg = *st.begin();
pos[i] = bg.second;
st.erase(bg);
}
for (int i = 0; i < n; i++) {
seg[i + n] = {a[pos[i + 1]], i + 1};
}
for (int i = n - 1; i > 0; i--) {
seg[i] = min(seg[i << 1], seg[i << 1 | 1]);
}
for (int i = 1; i <= n; i++) {
int id = query(i + 1, b[pos[i]]);
if (id != inf && a[pos[id]] <= i) {
cout << "NO" << endl;
show();
swap(pos[i], pos[id]);
show();
exit(0);
}
}
cout << "YES" << endl;
show();
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr static int MAXN = 2e5 + 10;
int n;
int a[MAXN], b[MAXN];
vector<pair<int, int>> cur[MAXN];
int pos[MAXN];
int r[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
cur[a[i]].push_back({b[i], i});
}
for (int i = 0; i < n; i++) pos[i] = -1;
int s1 = -1, s2 = -1;
priority_queue<pair<int, int>> pq;
for (int i = 1; i <= n; i++) {
for (auto p : cur[i]) pq.push({-p.first, p.second});
assert(pq.size() > 0);
auto t = pq.top();
pq.pop();
r[t.second] = i;
if (s1 != -1) continue;
if (pq.size() != 0 && pq.top().first == t.first) {
s1 = t.second;
s2 = pq.top().second;
continue;
}
int prv = pos[t.second];
if (prv != -1 && i <= b[prv]) {
s1 = prv;
s2 = t.second;
continue;
}
if (pq.size() == 0 || -t.first == i) continue;
pos[pq.top().second] = t.second;
}
cout << (s1 == -1 ? "YES" : "NO") << endl;
for (int i = 0; i < n; i++) cout << r[i] << ' ';
cout << endl;
if (s1 != -1) {
swap(r[s1], r[s2]);
for (int i = 0; i < n; i++) cout << r[i] << ' ';
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, l[200005], r[200005], tree[800005];
pair<pair<int, int>, int> a[200005];
void c_tree(int l, int r, int p, int x, int y) {
if (l == r)
tree[p] = y;
else {
if (x <= ((l + r) / 2))
c_tree(l, ((l + r) / 2), p * 2, x, y);
else
c_tree(((l + r) / 2) + 1, r, p * 2 + 1, x, y);
tree[p] = max(tree[p * 2], tree[p * 2 + 1]);
}
}
int q_tree(int l, int r, int p, int a, int b) {
if (l == a && r == b)
return tree[p];
else {
if (b <= ((l + r) / 2))
return q_tree(l, ((l + r) / 2), p * 2, a, b);
else if (a >= ((l + r) / 2) + 1)
return q_tree(((l + r) / 2) + 1, r, p * 2 + 1, a, b);
else
return max(q_tree(l, ((l + r) / 2), p * 2, a, ((l + r) / 2)),
q_tree(((l + r) / 2) + 1, r, p * 2 + 1, ((l + r) / 2) + 1, b));
}
}
bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) {
return l[x.second] < l[y.second];
}
set<pair<int, int>> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d %d", &a[i].first.first, &a[i].first.second), a[i].second = i;
sort(a + 1, a + 1 + n);
for (int i = 1, i0 = 1; i <= n; i++) {
while (i0 <= n && a[i0].first.first <= i)
s.insert({a[i0].first.second, a[i0].second}), i0++;
int p = s.begin()->second;
s.erase(s.begin());
l[p] = r[p] = i;
}
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
if (q_tree(1, n, 1, a[i].first.first, i) >= i) {
for (int i0 = a[i].first.first; i0 < i; i0++) {
if (a[i0].first.second >= i) {
swap(r[a[i].second], r[a[i0].second]);
printf("NO\n");
for (int i = 1; i <= n; i++)
printf("%d%c", l[i], i == n ? '\n' : ' ');
for (int i = 1; i <= n; i++)
printf("%d%c", r[i], i == n ? '\n' : ' ');
return 0;
}
}
}
c_tree(1, n, 1, i, a[i].first.second);
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d%c", l[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[200003];
int n, ans[200003], a[200003], b[200003], res[262144];
pair<int, int> dat[524288];
pair<int, int> query(int x, int y, int a, int b, int k) {
if (x <= a && b <= y) return dat[k];
if (a > y || b < x) return make_pair(0, 233);
return max(query(x, y, a, (a + b) / 2, k * 2),
query(x, y, (a + b) / 2 + 1, b, k * 2 + 1));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d%d", a + i, b + i);
a[i]--;
b[i]--;
v[b[i]].push_back(make_pair(a[i], i));
}
priority_queue<pair<int, int> > q;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < v[i].size(); j++) q.push(v[i][j]);
ans[q.top().second] = i;
q.pop();
}
memset(res, -1, sizeof(res));
for (int i = 0; i < n; i++) res[ans[i]] = i;
for (int i = 0; i < n; i++) dat[i + 262144] = make_pair(b[res[i]], res[i]);
for (int i = 262143; i >= 1; i--) dat[i] = max(dat[i * 2], dat[i * 2 + 1]);
for (int i = 1; i < n; i++) {
if (a[res[i]] == i) continue;
pair<int, int> maxn = query(a[res[i]], i - 1, 0, 262143, 1);
if (maxn.first >= i) {
cout << "NO\n";
for (int j = 0; j < n; j++) printf("%d ", ans[j] + 1);
cout << endl;
swap(ans[res[i]], ans[maxn.second]);
for (int j = 0; j < n; j++) printf("%d ", ans[j] + 1);
return 0;
}
}
cout << "YES\n";
for (int j = 0; j < n; j++) printf("%d ", ans[j] + 1);
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename elemType>
inline void Read(elemType &T) {
elemType X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
T = (w ? -X : X);
}
multiset<pair<int, int> > S;
struct Node {
int a, b, ID;
};
struct SegTreeNode {
int val, ID;
};
Node Data[200010];
int Pos[200010], List[200010], a[200010], b[200010];
SegTreeNode SegTree[800010];
int N;
bool cmp(Node A, Node B) { return A.a < B.a; }
void Build_SegTree(int Root, int L, int R) {
if (L == R) {
SegTree[Root].val = a[Pos[L]];
SegTree[Root].ID = L;
return;
}
int mid = (L + R) >> 1;
Build_SegTree(Root << 1, L, mid);
Build_SegTree(Root << 1 | 1, mid + 1, R);
int ls = SegTree[Root << 1].ID, rs = SegTree[Root << 1 | 1].ID;
if (SegTree[Root << 1].val < SegTree[Root << 1 | 1].val) {
SegTree[Root].val = SegTree[Root << 1].val;
SegTree[Root].ID = ls;
} else {
SegTree[Root].val = SegTree[Root << 1 | 1].val;
SegTree[Root].ID = rs;
}
return;
}
pair<int, int> Query(int Root, int L, int R, int QL, int QR) {
if (R < QL || QR < L) return make_pair(2147483647, 0);
if (QL <= L && R <= QR) return make_pair(SegTree[Root].val, SegTree[Root].ID);
int mid = (L + R) >> 1;
auto ls = Query(Root << 1, L, mid, QL, QR);
auto rs = Query(Root << 1 | 1, mid + 1, R, QL, QR);
if (ls.first < rs.first) return ls;
return rs;
}
int main() {
Read(N);
for (register int i = 1; i <= N; ++i) {
Read(Data[i].a);
Read(Data[i].b);
a[i] = Data[i].a;
b[i] = Data[i].b;
Data[i].ID = i;
}
a[0] = 2147483647;
sort(Data + 1, Data + N + 1, cmp);
int p = 0;
for (register int i = 1; i <= N; ++i) {
while (p + 1 <= N && Data[p + 1].a <= i) {
++p;
S.insert(make_pair(Data[p].b, Data[p].ID));
}
Pos[i] = S.begin()->second;
S.erase(S.begin());
}
for (register int i = 1; i <= N; ++i) List[Pos[i]] = i;
Build_SegTree(1, 1, N);
bool flag = false;
int u, v;
for (register int i = 1; i <= N; ++i) {
if (i + 1 > b[Pos[i]]) continue;
auto tmp = Query(1, 1, N, i + 1, b[Pos[i]]);
if (tmp.first <= i) {
flag = true;
u = Pos[tmp.second], v = Pos[i];
break;
}
}
if (!flag) {
printf("YES\n");
for (register int i = 1; i <= N; ++i) printf("%d ", List[i]);
printf("\n");
return 0;
}
printf("NO\n");
for (register int i = 1; i <= N; ++i) printf("%d ", List[i]);
printf("\n");
swap(List[u], List[v]);
for (register int i = 1; i <= N; ++i) printf("%d ", List[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
int n;
int A[200003], B[200003];
int ans1[200003];
int ans2[200003];
vector<pair<int, int> > op[200003];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &A[i], &B[i]);
op[A[i]].push_back({B[i], i});
}
vector<pair<int, int> > vec;
bool bol = 1;
set<pair<int, int> > st;
for (int i = 1; i <= n; i++) {
for (pair<int, int> x : op[i]) st.insert(x);
while (vec.size() && B[vec.back().second] < i) {
ans1[vec.back().second] = vec.back().first;
ans2[vec.back().second] = vec.back().first;
vec.pop_back();
}
if (vec.size() && A[st.begin()->second] <= vec.back().first) {
pair<int, int> x = *st.begin();
bol = 0;
ans1[vec.back().second] = vec.back().first;
ans2[vec.back().second] = i;
ans2[x.second] = vec.back().first;
ans1[x.second] = i;
st.erase(x);
vec.pop_back();
} else if (st.size() == 1 || st.begin()->first == i) {
pair<int, int> x = *st.begin();
ans1[x.second] = i;
ans2[x.second] = i;
st.erase(x);
} else {
pair<int, int> x = *st.begin();
vec.push_back({i, x.second});
st.erase(x);
}
}
while (vec.size()) {
ans1[vec.back().second] = vec.back().first;
ans2[vec.back().second] = vec.back().first;
vec.pop_back();
}
if (bol) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d%c", ans1[i], (i == n) ? '\n' : ' ');
} else {
printf("NO\n");
for (int i = 1; i <= n; i++) printf("%d%c", ans1[i], (i == n) ? '\n' : ' ');
for (int i = 1; i <= n; i++) printf("%d%c", ans2[i], (i == n) ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
inline void wri(long long x) {
write(x);
putchar(' ');
}
const int maxn = 2e5 + 233;
struct P {
int l, r, id;
} p[maxn];
struct cmp {
bool operator()(P a, P b) { return a.r > b.r; }
};
bool cmp2(P a, P b) { return a.r > b.r; }
bool cmp1(P a, P b) { return a.l < b.l; }
priority_queue<P, vector<P>, cmp> q, q2;
multiset<int> ms;
int n, a[maxn], b[maxn], rev[maxn];
int main() {
n = read();
for (int i = (1); i <= int(n); ++i) {
p[i].l = read(), p[i].r = read();
p[i].id = i;
}
sort(p + 1, p + 1 + n, cmp1);
int cur = 1, flg = 0;
for (int i = (1); i <= int(n); ++i) {
for (; cur <= n && p[cur].l <= i; cur++) q.push(p[cur]);
P tmp = q.top();
q.pop();
a[tmp.id] = b[tmp.id] = i;
rev[i] = tmp.id;
q2.push(tmp);
while (!q2.empty() && q2.top().r < i) {
P tmp2 = q2.top();
q2.pop();
auto it = ms.find(a[tmp2.id]);
ms.erase(it);
}
if (!ms.empty() && !flg) {
auto it = ms.end();
it--;
if (*it >= tmp.l) {
flg = 1;
swap(b[tmp.id], b[rev[*it]]);
}
}
ms.insert(i);
}
if (flg) {
puts("NO");
for (int i = (1); i <= int(n); ++i) wri(a[i]);
puts("");
for (int i = (1); i <= int(n); ++i) wri(b[i]);
puts("");
} else {
puts("YES");
for (int i = (1); i <= int(n); ++i) wri(a[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
const long long maxn = 2e5 + 10, lg = 17, mod = 1e9 + 7, inf = 1e18;
long long n, a[maxn], b[maxn], we[maxn], ans[maxn];
vector<pair<long long, long long> > s[maxn];
pair<long long, long long> seg[maxn << 1];
void goz(long long i, pair<long long, long long> x) {
seg[i += n] = x;
for (; i > 1; i >>= 1) seg[i >> 1] = min(seg[i], seg[i ^ 1]);
}
long long get(long long l, long long r) {
pair<long long, long long> ret = {inf, inf};
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret = min(ret, seg[l++]);
if (r & 1) ret = min(ret, seg[--r]);
}
return ret.second;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (int i = 0; i < (maxn << 1); i++) seg[i] = {inf, inf};
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
s[a[i]].push_back({b[i], i});
}
set<pair<long long, long long> > nw;
for (int i = 1; i <= n; i++) {
for (auto x : s[i]) nw.insert(x);
long long xxx = (*nw.begin()).second;
ans[xxx] = i, we[i] = xxx;
nw.erase(nw.begin());
}
for (int i = 0; i < n; i++) goz(i, {a[we[i + 1]], i + 1});
for (int i = 1; i <= n; i++) {
long long j = get(i, b[we[i]]);
if (j == inf) continue;
if (a[we[j]] <= i) {
cout << "NO\n";
for (int k = 1; k <= n; k++) cout << ans[k] << ' ';
cout << endl;
swap(ans[we[i]], ans[we[j]]);
for (int k = 1; k <= n; k++) cout << ans[k] << ' ';
cout << endl;
return 0;
}
}
cout << "YES\n";
for (int k = 1; k <= n; k++) cout << ans[k] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> l[N], r[N];
int L[N], R[N], ans[N], pos[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> L[i] >> R[i];
l[L[i]].push_back(i);
r[R[i] + 1].push_back(i);
}
pair<int, int> w = {-1, -1};
set<pair<int, int> > st;
set<int> z;
for (int i = 1; i <= n; i++) {
for (auto it : r[i]) {
z.erase(pos[it]);
}
for (auto it : l[i]) {
st.insert({R[it], it});
}
auto it = *st.begin();
ans[i] = it.second;
pos[it.second] = i;
st.erase(st.begin());
if (z.size() && *z.rbegin() >= L[it.second]) {
w = {ans[*z.rbegin()], it.second};
}
z.insert(i);
}
cout << (w.first == -1 ? "YES\n" : "NO\n");
for (int i = 1; i <= n; i++) cout << pos[i] << ' ';
if (w.first != -1) {
cout << "\n";
swap(pos[w.first], pos[w.second]);
for (int i = 1; i <= n; i++) cout << pos[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> am[200010];
int p1[200010], p2[200010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<pair<int, int> > swp;
set<pair<int, int> > dnt;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> am[i].first >> am[i].second;
swp.push_back({am[i].first, i});
}
sort(swp.begin(), swp.end());
int j = 0;
bool existe = false;
for (int i = 1; i <= n; i++) {
while (swp[j].first == i && j < n) {
dnt.insert({am[swp[j].second].second, swp[j].second});
j++;
}
auto v = dnt.begin();
p1[(*v).second] = i;
p2[i] = (*v).second;
dnt.erase(v);
}
j = 0;
dnt.clear();
set<pair<int, int> > dnth;
pair<int, int> troca = make_pair(-1, -1);
for (int i = 1; i <= n; i++) {
while (swp[j].first == i && j < n) {
dnt.insert({am[swp[j].second].second, swp[j].second});
dnth.insert({p1[swp[j].second], swp[j].second});
j++;
}
auto v = dnt.begin();
p1[(*v).second] = i;
p2[i] = (*v).second;
dnt.erase(v);
auto w = dnth.lower_bound(make_pair(i + 1, 0));
if (w != dnth.end()) {
if ((*w).first <= am[p2[i]].second) {
troca.first = (*v).second;
troca.second = (*w).second;
}
}
}
if (troca.first == -1) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << p1[i] << ' ';
cout << endl;
} else {
cout << "NO" << endl;
for (int i = 1; i <= n; i++) cout << p1[i] << ' ';
cout << endl;
int svf = p1[troca.first], svs = p1[troca.second];
p1[troca.first] = svs, p1[troca.second] = svf;
for (int i = 1; i <= n; i++) cout << p1[i] << ' ';
cout << endl;
}
}
|
#include <bits/stdc++.h>
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template <typename T>
inline bool read(T &x) {
bool op = 0;
char ch = IO::myGetchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = IO::myGetchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = IO::myGetchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = IO::myGetchar();
for (; isspace(ch) && ch != EOF; ch = IO::myGetchar())
;
for (; !isspace(ch) && ch != EOF; ch = IO::myGetchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() { fwrite(pbuf, 1, pp - pbuf, stdout); }
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template <typename T>
inline void print_(T x) {
if (x == 0) {
IO::myPutchar('0');
return;
}
std::vector<int> num;
if (x < 0) {
IO::myPutchar('-');
x = -x;
}
for (; x; x /= 10) {
num.push_back(x % 10);
}
while (!num.empty()) {
IO::myPutchar(num.back() ^ '0');
num.pop_back();
}
}
template <typename T>
inline void print(T x, char ch = '\n') {
print_(x);
IO::myPutchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
IO::myPutchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
IO::myPutchar(ch);
}
} // namespace IO
using namespace IO;
const int N = 200005, LG = 18;
int n, l[N], r[N];
int p[N], a[N];
int Log[N], mn[N][LG];
std::vector<std::pair<int, int>> vec[N];
int my_min(int x, int y) { return l[p[x]] < l[p[y]] ? x : y; }
void initST() {
Log[1] = 0;
for (int i = 2; i <= n; ++i) {
Log[i] = Log[i >> 1] + 1;
}
for (int i = 1; i <= n; ++i) {
mn[i][0] = i;
}
for (int j = 1; j < LG; ++j) {
for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
mn[i][j] = my_min(mn[i][j - 1], mn[i + (1 << (j - 1))][j - 1]);
}
}
}
int query(int l, int r) {
int t = Log[r - l + 1];
return my_min(mn[l][t], mn[r - (1 << t) + 1][t]);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(l[i]), read(r[i]);
vec[r[i]].push_back({l[i], i});
}
std::priority_queue<std::pair<int, int>> Q;
for (int i = n; i; --i) {
for (auto v : vec[i]) {
Q.push(v);
}
p[i] = Q.top().second;
Q.pop();
a[p[i]] = i;
}
initST();
int x = 0, y = 0;
for (int i = 1; i <= n; ++i) {
if (i == r[p[i]]) {
continue;
}
int j = query(i + 1, r[p[i]]);
if (l[p[j]] <= i) {
x = i, y = j;
break;
}
}
if (!x) {
printStr("YES");
for (int i = 1; i <= n; ++i) {
print(a[i], ' ');
}
IO::myPutchar('\n');
} else {
printStr("NO");
for (int i = 1; i <= n; ++i) {
print(a[i], ' ');
}
IO::myPutchar('\n');
std::swap(a[p[x]], a[p[y]]);
for (int i = 1; i <= n; ++i) {
print(a[i], ' ');
}
IO::myPutchar('\n');
}
}
|
#include <bits/stdc++.h>
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
std::mt19937 rnd(time(NULL));
template <class T>
void cxk(T& a, T b) {
a = a > b ? a : b;
}
template <class T>
void cnk(T& a, T b) {
a = a < b ? a : b;
}
int n;
struct intv {
int l, r, i, _i;
} s[200010], A[200010];
bool operator<(const intv& a, const intv& b) { return a.r > b.r; }
std::priority_queue<intv> que;
intv seg[800010];
void build(int x, int l, int r) {
if (l == r) {
seg[x] = {n + 1, n + 1, 0};
return;
}
build(x << 1, l, ((l + r) >> 1)), build(x << 1 | 1, ((l + r) >> 1) + 1, r);
seg[x] = std::max(seg[x << 1], seg[x << 1 | 1]);
}
void update(int x, int l, int r, int p) {
if (l == r) {
seg[x] = A[l];
return;
}
if (p <= ((l + r) >> 1))
update(x << 1, l, ((l + r) >> 1), p);
else
update(x << 1 | 1, ((l + r) >> 1) + 1, r, p);
seg[x] = std::max(seg[x << 1], seg[x << 1 | 1]);
}
int nxt[200010], st[18][200010], sec[200010], pos[200010];
intv query(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return seg[x];
if (L <= ((l + r) >> 1))
if (((l + r) >> 1) < R)
return std::max(query(x << 1, l, ((l + r) >> 1), L, R),
query(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R));
else
return query(x << 1, l, ((l + r) >> 1), L, R);
else
return query(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
}
int main() {
n = gi();
for (int i = 1; i <= n; ++i) s[i].l = gi(), s[i].r = gi(), s[i]._i = i;
std::sort(s + 1, s + n + 1, [](intv a, intv b) { return a.l < b.l; });
for (int i = 1, j = 1; i <= n; ++i) {
while (j <= n && s[j].l == i) que.push(s[j++]);
A[i] = que.top(), que.pop();
if (!que.empty()) sec[i] = que.top()._i;
}
for (int i = 1; i <= n; ++i) pos[A[i]._i] = i;
for (int i = 1; i <= n; ++i) sec[i] = pos[sec[i]];
build(1, 1, n);
{
static int st[200010];
for (int i = 1; i <= n; ++i) A[i].i = i, st[i] = i;
std::sort(st + 1, st + n + 1,
[&](int a, int b) { return A[a].r > A[b].r; });
for (int l = 1, r = n; l <= n; l = r + 1) {
r = l;
while (A[st[r] + 1].r == A[st[r]].r) ++r;
for (int _ = l, i; _ <= r; ++_)
if (i = st[_], i < A[i].r) {
nxt[i] = query(1, 1, n, i + 1, A[i].r).i;
}
for (int i = l; i <= r; ++i) update(1, 1, n, st[i]);
}
}
static int perm[200010];
for (int j = 1; j <= n; ++j) st[0][j] = nxt[j];
for (int i = 1; i < 18; ++i)
for (int j = 1; j <= n; ++j) st[i][j] = st[i - 1][st[i - 1][j]];
for (int i = 1; i <= n; ++i) perm[A[i]._i] = i;
for (int i = 1; i <= n; ++i)
if (sec[i]) {
int x = i;
for (int j = 17; ~j; --j)
if (st[j][x] && st[j][x] < sec[i] && A[st[j][x]].r < A[sec[i]].r)
x = st[j][x];
if (A[x].r >= sec[i]) {
puts("NO");
for (int i = 1; i <= n; ++i) printf("%d ", perm[i]);
puts("");
std::vector<int> vi;
for (int j = i; j && j <= x; j = nxt[j]) vi.push_back(j);
vi.push_back(sec[i]);
intv _ = A[sec[i]];
int lst = 0;
std::reverse((vi).begin(), (vi).end());
for (int i : vi) A[lst] = A[i], lst = i;
A[i] = _;
for (int i = 1; i <= n; ++i) perm[A[i]._i] = i;
for (int i = 1; i <= n; ++i) printf("%d ", perm[i]);
puts("");
exit(0);
}
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", perm[i]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.