text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
void func() {
int n;
cin >> n;
vector<int> arr(n), acop(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
acop[i] = arr[i];
}
sort(acop.begin(), acop.end(), greater<int>());
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int k, pos, cnt = 0;
cin >> k >> pos;
for (int i = 0; i < n; ++i) {
if (arr[i] > acop[k - 1]) {
++cnt;
}
}
int cnt1 = k - cnt;
cnt = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] >= acop[k - 1]) {
if (arr[i] > acop[k - 1]) {
++cnt;
} else if (cnt1 > 0 && arr[i] == acop[k - 1]) {
++cnt;
--cnt1;
}
if (cnt == pos) {
cout << arr[i] << "\n";
break;
}
}
}
}
}
int main() {
int t = 1;
int cnt = 0;
while (t--) {
func();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
inline void debug_vi(vector<int> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void debug_vll(vector<long long> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void print_case(int tn) { cout << "Case #" << tn << ": "; }
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxpq = priority_queue<T>;
const int N = 2e5 + 5;
int a[N], arr[N];
vector<pair<int, int>> vals;
int n;
struct SegmentTreeNode {
int sm;
void assignLeaf(int value) { sm = value; }
void merge(SegmentTreeNode& left, SegmentTreeNode& right) {
sm = left.sm + right.sm;
}
int getValue() { return sm; }
};
template <class T, class V>
class SegmentTree {
SegmentTreeNode* nodes;
int N;
public:
SegmentTree(T arr[], int N) {
this->N = N;
nodes = new SegmentTreeNode[getSegmentTreeSize(N)];
buildTree(arr, 1, 0, N - 1);
}
~SegmentTree() { delete[] nodes; }
V getValue(int pos) { return getValue(1, 0, N - 1, pos); }
void update(int index, T value) { update(1, 0, N - 1, index, value); }
private:
void buildTree(T arr[], int stIndex, int lo, int hi) {
if (lo == hi) {
nodes[stIndex].assignLeaf(arr[lo]);
return;
}
int left = 2 * stIndex, right = left + 1, mid = lo + (hi - lo) / 2;
buildTree(arr, left, lo, mid);
buildTree(arr, right, mid + 1, hi);
nodes[stIndex].merge(nodes[left], nodes[right]);
}
int getValue(int stIndex, int left, int right, int pos) {
if (left == right) {
return left;
}
int mid = (left + right) / 2;
if (nodes[2 * stIndex].getValue() >= pos)
return getValue(2 * stIndex, left, mid, pos);
return getValue(2 * stIndex + 1, mid + 1, right,
pos - nodes[2 * stIndex].getValue());
}
int getSegmentTreeSize(int N) { return 4 * N; }
void update(int stIndex, int lo, int hi, int index, T value) {
if (lo == hi) {
nodes[stIndex].assignLeaf(value);
return;
}
int left = 2 * stIndex, right = left + 1, mid = lo + (hi - lo) / 2;
if (index <= mid)
update(left, lo, mid, index, value);
else
update(right, mid + 1, hi, index, value);
nodes[stIndex].merge(nodes[left], nodes[right]);
}
};
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t clk = clock();
cin >> n;
vals.resize(n);
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> a[i];
vals[i] = {a[i], i};
arr[i] = 1;
}
sort((vals).begin(), (vals).end(), cmp);
SegmentTree<int, int> st(arr, n);
int m;
cin >> m;
vector<tuple<int, int, int>> reqs(m);
int k, pos, idx;
for (long long i = (long long)(0); i < (long long)(m); i++) {
cin >> k >> pos;
reqs[i] = make_tuple(k, pos, i);
}
sort((reqs).begin(), (reqs).end());
vector<int> res(m);
int curr = n;
for (long long i = (long long)(m - 1); i >= (long long)(0); i--) {
tie(k, pos, idx) = reqs[i];
while (curr > k) {
st.update(vals[curr - 1].second, 0);
curr--;
}
res[idx] = a[st.getValue(pos)];
}
for (int a : res) {
cout << a << "\n";
}
cerr << "\n"
<< "Time (in ms): " << double(clock() - clk) * 1000.0 / CLOCKS_PER_SEC
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2, typename T3>
struct pair3 {
T1 first;
T2 second;
T3 third;
};
template <typename T1, typename T2, typename T3, typename T4>
struct pair4 {
T1 first;
T2 second;
T3 third;
T4 fourth;
};
const long long MOD = 1000000007;
const long double PI = acos(-1.0);
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n;
vector<long long> ar(n);
for (long long i = 0; i < n; ++i) {
cin >> ar[i];
}
vector<vector<long long>> ans(n + 1);
for (long long len = 1; len <= n; ++len) {
vector<long long> temp;
long long mx = -1, mn = INT_MAX;
multiset<long long> st;
auto del = [&](long long val) {
auto it = temp.end();
--it;
while (1) {
if (*it == val) {
temp.erase(it);
break;
}
it -= 1;
}
};
for (long long start = 0; start < n; ++start) {
if (temp.size() < len) {
temp.push_back(ar[start]);
st.insert(ar[start]);
} else {
if (ar[start] > *st.begin()) {
del(*st.begin());
st.erase(st.begin());
st.insert(ar[start]);
temp.push_back(ar[start]);
}
}
ans[len] = temp;
}
}
cin >> m;
long long l, idx;
while (m--) {
cin >> l >> idx;
cout << ans[l][idx - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct eq {
long long si, f, s, r;
};
bool compare(eq a, eq b) {
if (a.f == b.f) return a.s < b.s;
return a.f < b.f;
}
bool comp(eq a, eq b) { return a.si < b.si; }
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
long long t;
cin >> t;
v.push_back({t, -(i + 1)});
}
sort(v.begin(), v.end());
long long m;
cin >> m;
while (m--) {
long long k, p;
cin >> k >> p;
vector<pair<long long, long long> > temp;
for (long long i = n - 1; i > n - 1 - k; i--) {
temp.push_back({-(v[i].second), v[i].first});
}
sort(temp.begin(), temp.end());
cout << temp[p - 1].second << endl;
}
return;
}
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;
bool comp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first) {
return a.second < b.second;
}
return a.first > b.first;
}
int main() {
int n;
cin >> n;
vector<long long int> arr(n);
vector<pair<long long int, long long int>> temp(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
temp[i] = {arr[i], i};
}
sort(temp.begin(), temp.end(), comp);
int m, k, pos;
cin >> m;
while (m--) {
cin >> k >> pos;
vector<pair<long long int, long long int>> curr;
for (int i = 0; i < k; i++) {
curr.push_back({temp[i].second, temp[i].first});
}
sort(curr.begin(), curr.end());
cout << curr[pos - 1].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
b[i] = a[i];
}
sort(a.begin(), a.end(), greater<long long>());
long long m;
cin >> m;
vector<long long> result;
while (m--) {
long long k, pos;
cin >> k >> pos;
map<long long, long long> adj;
for (int i = 0; i < k; i++) {
adj[a[i]]++;
}
int ind = 1;
long long ans = -1;
for (int i = 0; i < n; i++) {
auto x = adj.find(b[i]);
if (x == adj.end() || (adj[b[i]] == 0)) {
continue;
}
if (ind == pos) {
ans = b[i];
break;
}
adj[b[i]]--;
ind++;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ar[n];
long long br[n];
for (auto x = 0; x < n; x++) {
cin >> ar[x];
br[x] = ar[x];
}
sort(br, br + n);
long long m;
cin >> m;
while (m--) {
long long pos, k;
set<long long> s;
cin >> k >> pos;
long long bound = br[n - k];
vector<long long> q;
for (int x = 0; x < n; x++) {
if (bound <= ar[x]) {
q.push_back(ar[x]);
}
}
long long sub = q.size() - k;
for (int x = q.size() - 1; x >= 0 && sub != 0; x--) {
if (bound == q[x]) {
q[x] = -1;
sub--;
}
if (sub == 0) {
break;
}
}
for (int x = 0; x < q.size(); x++) {
if (q[x] == -1) {
continue;
}
pos--;
if (pos == 0) cout << q[x] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> v(n);
map<long long, vector<long long>> def;
for (long long i = 0; i < n; i++) {
cin >> v[i];
def[v[i]].push_back(i);
}
vector<long long> g;
for (auto p : def) {
long long a = p.first;
vector<long long> b = p.second;
for (long long i = 0; i < b.size(); i++) {
g.push_back(b[b.size() * 1ll - i - 1]);
}
}
reverse(g.begin(), g.end());
long long m;
cin >> m;
for (long long i = 0; i < m; i++) {
long long k, pos;
cin >> k >> pos;
vector<long long> f;
for (long long j = 0; j < k; j++) {
f.push_back(g[j]);
}
sort(f.begin(), f.end());
cout << v[f[pos - 1]] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bin_pow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long t = bin_pow(a, b / 2);
return t * t % 1000000007;
} else
return a * bin_pow(a, b - 1) % 1000000007;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1, n, m, k = 0, x = 0, y = 0, z = 0, sum = 0, l = 0, r = 0,
ans = 0, mn = LLONG_MAX, mx = LLONG_MIN;
cin >> n;
vector<long long> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i], b[i] = a[i];
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
cin >> m;
while (m--) {
map<long long, long long> mp, mp1, mp2;
cin >> k >> x;
vector<long long> c, d;
for (int i = 0; i < k; i++) c.push_back(b[i]), mp[b[i]]++;
for (int i = 0; i < n; i++) mp1[a[i]]++;
reverse(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
l = 0;
for (int i = 0; i < n; i++) {
if (mp[a[i]] == 0) continue;
mp2[a[i]]++;
if (a[i] == c[l]) {
d.push_back(a[i]);
mp[a[i]]--;
if (mp[a[i]] == 0) l++;
continue;
}
if (mp[a[i]] > mp1[a[i]] - mp2[a[i]]) {
d.push_back(a[i]);
mp[a[i]]--;
}
}
ans = d[x - 1];
cout << ans;
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> srr;
map<int, int> occ;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int arr[200], n, m, pj, k, fast = 1, last;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
srr.push_back(arr[i]);
}
sort(srr.begin(), srr.end(), greater<int>());
cin >> m;
last = n;
while (m--) {
vector<int> vec;
cin >> k >> pj;
for (int i = 0; i < k; ++i) vec.push_back(srr[i]);
vector<int> ans;
sort(vec.begin(), vec.end());
fast = 1;
for (int s = 1; s <= k; ++s) {
for (int i = 0; i < k; ++i) {
if (vec[i] != -1) {
for (int j = fast; j <= last; ++j) {
if (arr[j] == vec[i]) {
occ.clear();
for (int p = 0; p < k; ++p) {
if (vec[p] != -1) occ[vec[p]]++;
}
for (int p = j; p <= last; ++p) {
if (occ[arr[p]]) occ[arr[p]]--;
}
bool pos = true;
for (int p = 0; p < k && pos; ++p)
if (vec[p] > 0 && occ[vec[p]] > 0) pos = false;
if (pos) fast = j + 1;
if (pos) {
ans.push_back(vec[i]);
vec[i] = -1;
i = k;
}
break;
}
}
}
}
}
cout << ans[pj - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, m, k;
cin >> n;
vector<int> v[n + 1];
vector<long long int> s;
for (int i = 0; i < n; i++) {
cin >> t;
v[n].push_back(t);
s.push_back(t);
}
sort(s.begin(), s.end());
int l = n - 1, x = 0, y;
while (l > 0) {
for (int i = v[l + 1].size() - 1; i >= 0; i--) {
if (v[l + 1][i] == s[x]) {
y = i;
break;
}
}
for (int i = 0; i < v[l + 1].size(); i++) {
if (i == y) continue;
v[l].push_back(v[l + 1][i]);
}
x++;
l--;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
cout << v[x][y - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr(n);
set<pair<int, int>> left;
for (int i = 0; i < arr.size(); i++) {
cin >> arr[i];
left.insert(make_pair(arr[i], i * -1));
}
int m;
cin >> m;
while (m--) {
int k, j;
cin >> k >> j;
j--;
set<pair<int, int>> test = left;
while (test.size() > k) {
auto t = test.begin();
test.erase(t);
}
vector<pair<int, int>> fil;
for (auto a : test) {
fil.push_back(make_pair(a.second * -1, a.first));
}
sort(fil.begin(), fil.end());
cout << fil[j].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long N = 1234567891, M = 31;
long long n, m, t, k, f, mi = 2e9, x, y, z, ma, x3, x2, y2, l, r, i, j, ans, vv,
a2[410000], d[410000], dp[810000];
string s, s2, s3;
vector<long long> v, v2, v3;
struct pos {
long long x, y, z;
};
pos a[410000], b[410000];
bool cmp(pos l, pos r) {
if (l.x == r.x) return l.y > r.y;
return l.x < r.x;
}
void upd(int l, int r, int x, int ve) {
if (l == r) {
dp[ve] = 1;
return;
}
int t = (l + r) / 2;
if (t >= x)
upd(l, t, x, ve * 2);
else
upd(t + 1, r, x, ve * 2 + 1);
dp[ve] = dp[ve * 2] + dp[ve * 2 + 1];
}
int sum(int l, int r, int x, int ve) {
if (l == r) return l;
int t = (l + r) / 2;
if (dp[ve * 2] >= x) return sum(l, t, x, ve * 2);
return sum(t + 1, r, x - dp[ve * 2], ve * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i].x;
a2[i] = a[i].x;
a[i].y = i;
}
sort(a + 1, a + n + 1, cmp);
cin >> m;
for (i = 1; i <= m; i++) {
cin >> b[i].x >> b[i].y;
b[i].z = i;
}
sort(b + 1, b + m + 1, cmp);
for (i = 1; i <= m; i++) {
for (j = b[i - 1].x + 1; j <= b[i].x; j++) {
l = a[n - j + 1].y;
upd(1, n, l, 1);
}
d[b[i].z] = a2[sum(1, n, b[i].y, 1)];
}
for (i = 1; i <= m; i++) {
cout << d[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
void ct(vector<int> &a) {
for (auto &i : a) cout << i << ' ';
cout << '\n';
}
void ct(vector<pair<int, int>> &a) {
for (auto &i : a) cout << i.first << ":" << i.second << ' ';
cout << '\n';
}
void ct(vector<vector<pair<int, int>>> &a) {
for (auto &i : a) ct(i);
}
void ct(vector<vector<int>> &a) {
for (auto &i : a) ct(i);
}
void ct(vector<set<int>> &a) {
for (auto &i : a) {
for (auto &j : i) cout << j << ' ';
cout << '\n';
}
}
void ct(set<pair<int, int>> &a) {
for (auto &i : a) cout << i.first << ':' << i.second << ' ';
cout << '\n';
}
void ct(pair<int, int> &a) { cout << a.first << ':' << a.second << '\n'; }
void ci(vector<int> &a) {
for (int i = 0; i < a.size(); ++i) cin >> a[i];
}
void ci(vector<vector<int>> &a) {
for (int i = 0; i < a.size(); ++i) ci(a[i]);
}
void think() {}
signed main() {
int n, m;
cin >> n;
vector<pair<int, int>> a;
for (int i = 0; i < n; ++i) {
int c;
cin >> c;
a.push_back(make_pair(c, -i));
}
sort(a.begin(), a.end());
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
vector<pair<int, int>> ans;
cin >> k >> pos;
for (int i = n - k; i < n; ++i) {
ans.push_back(make_pair(-a[i].second, a[i].first));
}
sort(ans.begin(), ans.end());
cout << ans[pos - 1].second << '\n';
ans.clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> a[112];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
a[i] = {-num, i};
}
sort(a, a + n);
cin >> m;
for (int i = 1; i <= m; i++) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > sub;
for (int j = 0; j < k; j++) {
sub.push_back({a[j].second, -a[j].first});
}
sort(sub.begin(), sub.end());
cout << sub[pos - 1].second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 9;
struct node {
int x, y;
} a[maxn];
int b[maxn];
bool cmp(node a, node b) { return a.x == b.x ? a.y < b.y : a.x > b.x; }
map<int, int> A;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].x);
b[i] = a[i].x;
a[i].y = i;
}
sort(a + 1, a + 1 + n, cmp);
int m;
scanf("%d", &m);
while (m--) {
int k, pos;
scanf("%d%d", &k, &pos);
for (int i = 1; i <= k; ++i) {
A[a[i].y] = 1;
}
int r = 1;
for (int j = 1; j <= n; ++j) {
if (A[j]) {
if (r == pos) {
printf("%d\n", b[j]);
break;
}
r++;
}
}
A.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100;
int arr[N];
multimap<int, int, greater<int>> l;
map<int, int> mp;
vector<int> ans[N];
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", arr + i);
int m;
scanf("%d", &m);
for (int i = 0; i < n; ++i) {
l.insert(make_pair(arr[i], i));
}
for (int i = 0; i < n; ++i) {
map<int, int> temp;
int j = 0;
for (auto t = l.begin(); j <= i; ++j, ++t) {
temp[t->second] = t->first;
}
for (auto t : temp) {
ans[i].emplace_back(t.second);
}
}
for (int i = 0; i < m; ++i) {
int k, pos;
scanf("%d%d", &k, &pos);
--k, --pos;
printf("%d\n", ans[k][pos]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int bsl(vector<pair<int, int>> &A, int val) {
int left = -1;
int right = (int)A.size();
while (right - left > 1) {
int mid = (left + right) / 2;
if (A[mid].first >= val) {
right = mid;
} else {
left = mid;
}
}
return right;
}
int bsr(vector<pair<int, int>> &A, int val) {
int left = 0;
int right = (int)A.size() + 1;
while (right - left > 1) {
int mid = (left + right) / 2;
if (A[mid].first <= val) {
left = mid;
} else {
right = mid;
}
}
return left;
}
int main() {
int n;
cin >> n;
vector<int> N(n);
vector<pair<int, int>> A(n);
for (int i = 0; i < n; ++i) {
cin >> N[i];
A[i] = {N[i], i};
}
sort(A.begin(), A.end());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
cin >> k >> pos;
int val = A[n - k].first;
set<int> S;
int r = bsr(A, val);
int l = bsl(A, val);
int val1 = n - r - 1;
int val2 = k - val1;
for (int j = l; j < l + val2; ++j) {
S.insert(A[j].second);
}
for (int j = r + 1; j < n; ++j) {
S.insert(A[j].second);
}
auto itr = S.begin();
advance(itr, pos - 1);
cout << N[*itr] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, x, i, ma = 0;
cin >> n;
vector<pair<long long int, long long int>> v1;
for (i = 1; i <= n; i++) cin >> x, v1.push_back(make_pair(-x, i));
sort(v1.begin(), v1.end());
cin >> m;
while (m--) {
long long int k, pos, j = 0;
cin >> k >> pos;
vector<pair<long long int, long long int>> v;
while (j < k) {
v.push_back(make_pair(v1[j].second, -v1[j].first));
j++;
}
sort(v.begin(), v.end());
cout << v[pos - 1].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int inf = 1e9 + 7;
bool compA(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
bool comp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
void run() {
int n, m, k, pos;
cin >> n;
vector<pair<int, int> > A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i].first;
A[i].second = i;
}
cin >> m;
sort(A.begin(), A.end(), compA);
vector<vector<pair<int, int> > > B(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i + 1; ++j) B[i].push_back(A[j]);
sort(B[i].begin(), B[i].end(), comp);
}
for (int i = 0; i < m; ++i) {
cin >> k >> pos;
cout << B[--k][--pos].first << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 0; i < t; ++i) {
run();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const long long MOD = 1e9 + 7;
const long long mxN = 2e5 + 3;
bool cmp(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.first > p2.first)
return true;
else if (p1.first == p2.first) {
if (p1.second < p2.second) return true;
return false;
}
return false;
}
void solve() {
long long n;
cin >> n;
long long a[n + 1];
pair<long long, long long> b[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i + 1];
b[i].first = a[i + 1];
b[i].second = (i + 1);
}
sort(b, b + n, cmp);
long long m;
cin >> m;
long long kj, pos_j;
vector<vector<long long> > ve(n);
for (long long i = 0; i < n; ++i) {
for (long long j = i; j < n; ++j) {
ve[j].push_back(b[i].second);
}
}
for (long long i = 0; i < n; ++i) sort((ve[i]).begin(), (ve[i]).end());
while (m--) {
cin >> kj >> pos_j;
kj--;
(pos_j)--;
cout << a[ve[kj][pos_j]] << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long nT = 1;
for (long long i = (long long)1; i <= (long long)nT; ++i) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
struct node {
int id;
int num;
};
node s[maxn];
int b[maxn];
int num[maxn];
bool cmp(node a, node b) {
if (a.num != b.num)
return a.num > b.num;
else
return a.id < b.id;
}
struct ask {
int id;
int L = 0;
int pos;
};
ask A[maxn];
bool cmp2(ask a, ask b) { return a.L < b.L; }
int ans[maxn];
int main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
for (int i = 1; i <= N; i++) cin >> num[i];
for (int i = 1; i <= N; i++) s[i].num = num[i], s[i].id = i;
sort(s + 1, s + 1 + N, cmp);
for (int i = 1; i <= N; i++) b[i] = s[i].id;
int Q;
cin >> Q;
for (int i = 1; i <= Q; i++) {
cin >> A[i].L;
A[i].id = i;
cin >> A[i].pos;
}
sort(A + 1, A + 1 + Q, cmp2);
for (int i = 1; i <= Q; i++) {
if (A[i].L != A[i - 1].L) sort(b + 1, b + 1 + A[i].L);
ans[A[i].id] = b[A[i].pos];
}
for (int i = 1; i <= Q; i++) cout << num[ans[i]] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
mt19937 rnd(time(0));
const long long INF = 1e9;
struct Point {
Point() {
cin >> x;
cin >> y;
}
Point(long double x, long double y) : x(x), y(y) {}
long double x, y;
};
void solve() {
int n, m, k, pos;
cin >> n;
vector<int> v(n), b(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
b[i] = v[i];
}
sort(b.begin(), b.end());
cin >> m;
while (m-- > 0) {
cin >> k >> pos;
int needDEL = n - k;
map<int, int> mp;
for (int i = 0; i < needDEL; i++) {
mp[b[i]]++;
}
vector<bool> used(n, 0);
for (int i = n - 1; i >= 0 && needDEL != 0; i--) {
if (mp[v[i]] != 0) {
mp[v[i]]--;
used[i] = 1;
needDEL--;
}
}
vector<int> newV;
for (int i = 0; i < n; i++) {
if (!used[i]) {
newV.push_back(v[i]);
}
}
cout << newV[pos - 1] << '\n';
}
}
void jafdj(int aijf, int akfka) {
cout << "0" << '\n';
long double o = 1 * 10;
long long p = (int)o << 2;
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const long long num = 1000000000;
bool check1(pair<long long, long long> a, pair<long long, long long> b) {
return a.first == b.first ? (a.second > b.second) : (a.first < b.first);
}
bool check2(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
int main() {
long long q = 1;
while (q--) {
long long n, m;
cin >> n;
vector<pair<long long, long long> > vec(n);
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
vec[i].first = a;
vec[i].second = i;
}
cin >> m;
sort(vec.begin(), vec.end(), check1);
auto v1 = vec;
for (int i = 0; i < m; i++) {
vec = v1;
long long k, p;
cin >> k >> p;
sort(vec.begin() + n - k, vec.end(), check2);
cout << vec[n - k + p - 1].first << endl;
;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powMod(long long int x, long long int y) {
long long int p = 1;
while (y) {
if (y % 2) {
p = (p * x) % 1000000007;
}
y /= 2;
x = (x * x) % 1000000007;
}
return p;
}
long long int invMod(long long int x) { return powMod(x, 1000000007 - 2); }
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first) {
return (a.second < b.second);
}
return (a.first > b.first);
}
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > v;
long long int k[n];
for (long long int i = 0; i < n; i++) {
cin >> k[i];
v.push_back(make_pair(k[i], i));
}
sort(v.begin(), v.end(), sortbysec);
long long int m;
cin >> m;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
long long int ans[a];
for (long long int j = 0; j < a; j++) {
ans[j] = v[j].second;
}
sort(ans, ans + a);
cout << k[ans[b - 1]] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long double PI = acos(-1.0);
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isPalindrome(string s) {
string t = s;
reverse(t.begin(), t.end());
return s == t;
}
void solve() {
long long int n;
cin >> n;
long long int arr[n];
map<long long int, set<long long int> > mm;
vector<long long int> v;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mm[arr[i]].insert(i);
v.push_back(arr[i]);
}
sort(v.begin(), v.end());
;
long long int q;
cin >> q;
while (q--) {
long long int x, y;
cin >> x >> y;
vector<pair<long long int, long long int> > vec;
map<long long int, long long int> temp;
long long int i = n - 1;
while (vec.size() != x) {
long long int key = v[i];
;
vec.push_back(make_pair(*mm[key].begin(), key));
mm[key].erase(*mm[key].begin());
i--;
}
sort(vec.begin(), vec.end());
;
for (auto it : vec) mm[it.second].insert(it.first);
cout << vec[y - 1].second << endl;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e5 + 7;
const int inf = INT_MAX / 2;
const long long INF = LLONG_MAX / 3;
const int MOD = 1e9 + 7;
const double eps = 1e-6;
const string cars[] = {"🚗", "🚕", "🚙"};
signed main() {
cout << fixed << setprecision(4);
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int n;
cin >> n;
vector<int> a(n);
for (int& x : a) {
cin >> x;
}
auto b = a;
sort(a.rbegin(), a.rend());
int q;
cin >> q;
while (q--) {
int k, d;
cin >> k >> d;
multiset<int> s;
for (int i = 0; i < k; i++) {
s.insert(s.begin(), a[i]);
}
int l = 0;
for (int i = 0; i < n; i++) {
if (s.find(b[i]) != s.end()) {
if (++l == d) {
cout << b[i] << "\n";
break;
}
s.erase(s.find(b[i]));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
bool cmp2(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end(), cmp);
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > res;
for (int i = 0; i < k; i++) {
res.push_back(v[i]);
}
sort(res.begin(), res.end(), cmp2);
cout << res[pos - 1].first << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second > b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > v;
for (long long int i = 0; i < n; i++) {
long long int k;
cin >> k;
v.push_back({k, i});
}
sort(v.begin(), v.end(), comp);
long long int m;
cin >> m;
while (m--) {
long long int k, pos;
cin >> k >> pos;
vector<pair<long long int, long long int> > a;
for (long long int i = n - k; i < n; i++)
a.push_back({v[i].second, v[i].first});
sort(a.begin(), a.end());
cout << a[pos - 1].second << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> graph[200007];
long long int visited[200007] = {0};
long long int mx = 0, cnt = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, i, j;
cin >> n;
long long int a[n + 10];
vector<pair<long long int, long long int> > v, s, g;
vector<long long int> b;
for (i = 0; i < n; i++) {
cin >> a[i];
s.push_back(make_pair(a[i], i));
}
sort(s.begin(), s.end());
for (i = 0; i < n - 1; i++) {
if (s[i].first != s[i + 1].first) {
g.push_back(make_pair(s[i].first, s[i].second));
for (j = g.size() - 1; j >= 0; j--) {
v.push_back(make_pair(g[j].first, g[j].second));
}
g.clear();
} else {
g.push_back(make_pair(s[i].first, s[i].second));
}
}
g.push_back(make_pair(s[i].first, s[i].second));
for (j = g.size() - 1; j >= 0; j--) {
v.push_back(make_pair(g[j].first, g[j].second));
}
cin >> m;
while (m--) {
long long int k, p;
cin >> k >> p;
cnt = 0;
for (i = n - 1; i >= 0; i--) {
cnt++;
b.push_back(v[i].second);
if (cnt == k) {
break;
}
}
sort(b.begin(), b.end());
cout << a[b[p - 1]] << endl;
b.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first < b.first;
return a.second > b.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int>> a;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a.emplace_back(x, i);
}
sort(a.begin(), a.end(), cmp);
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int>> now;
for (int i = n - k; i < n; ++i) {
now.emplace_back(a[i].second, a[i].first);
}
sort(now.begin(), now.end());
cout << now[pos - 1].second << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
using namespace std;
int a[1000], b[1000];
map<int, bool> mk;
int main() {
iostream::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + n);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
mk.clear();
int pos, k;
cin >> k >> pos;
vector<int> g;
g.clear();
for (int j = n - 1; j >= n - k; j--) {
int p;
for (int u = 0; u < n; u++)
if (!mk[u] && b[u] == a[j]) {
p = u;
mk[u] = 1;
break;
}
g.push_back(p);
}
sort(g.begin(), g.end());
cout << b[g[pos - 1]] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
istream &operator>>(istream &in, vector<T> &ans) {
for (auto &d : ans) in >> d;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &ans) {
for (auto &d : ans) out << d << " ";
return out;
}
signed main() {
fast();
solve();
}
struct node {
int key;
long long y;
int sz;
node *left, *right;
node(int _key) : key(_key) {
key = _key;
y = rand();
sz = 1;
left = nullptr;
right = nullptr;
}
};
int size(node *v) { return (v == nullptr) ? 0 : v->sz; }
void upd(node *v) { v->sz = size(v->left) + size(v->right) + 1; }
pair<node *, node *> split_key(node *root, int c) {
if (root == nullptr) return {nullptr, nullptr};
if (root->key > c) {
auto p = split_key(root->left, c);
root->left = p.second;
upd(root);
return {p.first, root};
} else {
auto p = split_key(root->right, c);
root->right = p.first;
upd(root);
return {root, p.second};
}
}
pair<node *, node *> split_size(node *root, int c) {
if (root == nullptr) return {nullptr, nullptr};
if (size(root->left) >= c) {
auto p = split_size(root->left, c);
root->left = p.second;
upd(root);
return {p.first, root};
} else {
auto p = split_size(root->right, c - size(root->left) - 1);
root->right = p.first;
upd(root);
return {root, p.second};
}
}
node *merge(node *a, node *b) {
if (a == nullptr) return b;
if (b == nullptr) return a;
if (a->y > b->key) {
a->right = merge(a->right, b);
upd(a);
return a;
} else {
b->left = merge(a, b->left);
upd(b);
return b;
}
}
node *insert(node *root, int ke) {
auto p = split_key(root, ke);
return merge(merge(p.first, new node(ke)), p.second);
}
struct qur {
int k, pos, numb;
};
bool operator<(qur a, qur b) { return a.k < b.k; }
void print(node *root) {
if (root == nullptr) return;
print(root->left);
cout << root->key << " ";
print(root->right);
}
void solve() {
int n;
cin >> n;
srand(time(0));
vector<pair<int, int>> ans(n), pas;
for (int i = 0; i < n; ++i) cin >> ans[i].first, ans[i].second = i;
int m;
cin >> m;
vector<qur> kes(m);
pas = ans;
for (int i = 0; i < m; ++i) cin >> kes[i].k >> kes[i].pos, kes[i].numb = i;
auto cmp = [](pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
};
sort(kes.begin(), kes.end());
sort(ans.begin(), ans.end(), cmp);
int cnt = 0;
vector<int> otv(m);
node *root = nullptr;
for (auto &[k, pos, numb] : kes) {
while (cnt < k) root = insert(root, ans[cnt].second), cnt++;
auto p = split_size(root, pos - 1);
auto c = split_size(p.second, 1);
otv[numb] = pas[c.first->key].first;
root = merge(p.first, merge(c.first, c.second));
}
for (auto &d : otv) cout << d << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[101];
bool comp(pair<int, int> x, pair<int, int> y) {
if (x.first == y.first) {
return x.second < y.second;
}
return x.first > y.first;
}
bool comp2(pair<int, int> x, pair<int, int> y) { return x.second < y.second; }
int d[101][101];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back({a[i], i});
}
sort(v.begin(), v.end(), comp);
int m;
cin >> m;
while (m--) {
int x, y;
cin >> x >> y;
vector<pair<int, int>> v2;
for (int i = 0; i < x; i++) {
v2.push_back(v[i]);
}
sort(v2.begin(), v2.end(), comp2);
cout << v2[y - 1].first << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
map<int, vector<int> > mp;
for (int i = 0; i < n; ++i) {
mp[a[i]].push_back(i);
}
vector<int> szs(0);
vector<int> ind(0);
for (auto i : mp) {
szs.push_back((int)i.second.size());
ind.push_back((int)i.first);
}
reverse(szs.begin(), szs.end());
reverse(ind.begin(), ind.end());
vector<int> ps = {szs[0]};
for (int i = 1; i < szs.size(); ++i) {
ps.push_back(ps.back() + szs[i]);
}
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
pos--;
set<int> psps;
int nowind = 0;
int nowel = 0;
for (int i = 0; i < k; ++i) {
psps.insert(mp[ind[nowind]][nowel]);
nowel++;
if (nowel == mp[ind[nowind]].size()) {
nowel = 0;
nowind++;
}
}
vector<int> v;
for (auto i : psps) {
v.push_back(i);
}
cout << a[v[pos]] << "\n";
}
}
signed main() {
fastio();
solve();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast")
using namespace std;
bool compare(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second < b.second;
}
}
int32_t main() {
long long n;
cin >> n;
long long arr[n];
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
v.push_back({arr[i], i});
}
sort(v.begin(), v.end(), compare);
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
vector<pair<long long, long long> > cur;
for (long long i = 0; i < k; i++) {
cur.push_back({v[i].second, v[i].first});
}
sort(cur.begin(), cur.end());
cout << cur[pos - 1].second << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i + 1;
v[i].first *= -1;
}
sort(v.begin(), v.end());
int t;
cin >> t;
for (; t; t--) {
int x, y;
cin >> x >> y;
vector<pair<int, int>> z;
for (int i = 0; i < x; i++) {
z.push_back({v[i].second, v[i].first});
}
sort(z.begin(), z.end());
cout << -z[y - 1].second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dv(pair<int, int> p1, pair<int, int> p2) {
if (p1.first < p2.first) return 0;
if (p1.first > p2.first) return 1;
if (p1.second > p2.second) return 0;
return 1;
}
int main() {
int t, n, m, p, k, a, b, c, l, r;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) cin >> A[i];
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) v.push_back({A[i], i});
sort(v.begin(), v.end(), dv);
cin >> m;
for (int i = 0; i < m; i++) {
vector<int> pos;
cin >> k >> p;
for (int i = 0; i < k; i++) {
pos.push_back(v[i].second);
}
sort(pos.begin(), pos.end());
cout << A[pos[p - 1]] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> adj;
map<long, bool> vis, viss;
vector<long long> rnk, parent, sz;
int spf[1000000 + 1];
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
vector<long long> v;
bool yg(long long a, long long b) {
return (v[a] > v[b] || ((v[a] == v[b]) && a < b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(nullptr);
long long t, temp;
long long n, m;
cin >> n;
vector<long long> indx;
for (long long i = 0; i < n; i++) {
cin >> temp;
v.push_back(temp);
indx.push_back(i);
}
sort(indx.begin(), indx.end(), yg);
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
vector<long long> arr;
for (long long i = 0; i < k; i++) arr.push_back(indx[i]);
sort(arr.begin(), arr.end());
cout << v[arr[pos - 1]] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool kmp(int a, int b) { return a < b; }
int main() {
int n, m;
int x = 0;
int y = 0;
int z = 0;
cin >> n;
int a[n];
int d[n][n];
int c[n];
int an[100003];
int k = 0;
int p = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
c[i] = 1;
}
cin >> m;
int b[m];
int f[m];
for (int i = 0; i < m; i++) {
cin >> b[i] >> f[i];
}
for (int i = 0; i < n; i++) {
p = 0;
k = 0;
for (int j = 0; j < n; j++) {
if (a[j] > p && c[j] == 1) {
p = a[j];
x = j;
}
}
c[x] = 0;
for (int j = 0; j < x; j++) {
if (c[j] == 0) {
k++;
}
}
for (int j = 0; j < i + 1; j++) {
if (j < k) {
d[i][j] = d[i - 1][j];
} else if (j == k) {
d[i][j] = p;
} else {
d[i][j] = d[i - 1][j - 1];
}
}
}
for (int i = 0; i < m; i++) {
cout << d[b[i] - 1][f[i] - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int getrnd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
template <typename T1, typename T2>
bool relax(T1& a, const T2& b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
bool strain(T1& a, const T2& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) cin >> a[i], b[i] = a[i];
sort(b.rbegin(), b.rend());
int q;
cin >> q;
while (q--) {
int k, pos;
cin >> k >> pos;
--pos;
vector<int> was(n, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j) {
if (a[i] == b[j]) was[i] = 1;
}
}
int c = 1;
for (int i = k - 2; i >= 0; --i) {
if (b[i] == b[i + 1])
++c;
else
break;
}
vector<int> temp;
for (int i = 0; i < n; ++i) {
if (a[i] == b[k - 1]) {
if (c > 0 && was[i]) {
temp.emplace_back(a[i]);
--c;
}
} else if (was[i]) {
temp.emplace_back(a[i]);
}
}
cout << temp[pos] << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
srand(time(0));
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e5 + 5;
using namespace std;
int n, q;
struct node {
int x, y, z;
} a[maxn], b[maxn], c[maxn];
int tot = 1, ans[maxn];
bool tmp(const node &u, const node &v) {
if (u.x != v.x) return u.x > v.x;
return u.y < v.y;
}
bool cc(const node &u, const node &v) {
if (u.x != v.x) return u.x < v.x;
return u.y < v.y;
}
bool cmp(const node &u, const node &v) { return u.y < v.y; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x), a[i].y = i;
sort(a + 1, a + n + 1, tmp);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d %d", &b[i].x, &b[i].y), b[i].z = i;
sort(b + 1, b + q + 1, cc);
for (int i = 1; i <= q;) {
int m = b[i].x;
for (; tot <= m; tot++) c[tot].x = a[tot].x, c[tot].y = a[tot].y;
sort(c + 1, c + tot, cmp);
for (; b[i].x == m; i++) ans[b[i].z] = c[b[i].y].x;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Update(const long &);
long FindSum(const long &);
long N, M, K = 0;
vector<long> BIT;
int main() {
cin >> N;
vector<pair<long, long>> A(N + 1);
vector<long> X(N + 1);
for (long i = 1; i <= N; ++i) {
cin >> A[i].first;
A[i].second = i;
X[i] = A[i].first;
}
cin >> M;
vector<pair<pair<long, long>, long>> Q(M);
for (long i = 0; i < M; ++i) {
cin >> Q[i].first.first >> Q[i].first.second;
Q[i].second = i;
}
sort(A.begin() + 1, A.end(),
[&](const pair<long, long> &X, const pair<long, long> &Y) -> bool {
if (X.first != Y.first)
return X.first > Y.first;
else
return X.second < Y.second;
});
sort(Q.begin(), Q.end());
BIT.resize(N + 1, 0);
vector<long> Answer(M);
for (long i = 0; i < M; ++i) {
while (K < Q[i].first.first) {
++K;
Update(A[K].second);
}
Answer[Q[i].second] = X[FindSum(Q[i].first.second)];
}
for (long &x : Answer) cout << x << '\n';
flush(cout);
}
void Update(const long &I) {
for (long i = I; i <= N; i += (i & -i)) ++BIT[i];
}
long FindSum(const long &S) {
long pos = 0, sum = 0, next;
for (long i = 17; i >= 0; --i) {
next = pos + (1 << i);
if ((next <= N) && (sum + BIT[next] < S)) {
pos = next;
sum += BIT[pos];
}
}
return pos + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<bool> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = prime[1] = false;
for (long long i = 2; i <= n; ++i) {
if (prime[i] && (i * i) <= n)
for (long long j = i * i; j <= n; j += i) prime[j] = false;
}
return prime;
}
long long power(long long a, long long b, long long m = 1000000007) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < (long long)n; ++i) cin >> a[i];
map<long long, vector<long long> > mp;
for (long long i = 0; i < (long long)n; ++i) mp[a[i]].push_back(i);
long long t;
cin >> t;
while (t--) {
long long k, idx;
cin >> k >> idx;
auto it = mp.rbegin();
vector<long long> b;
while (k > 0) {
vector<long long> temp = it->second;
if (k >= (long long)temp.size()) {
k -= temp.size();
for (long long i = 0; i < (long long)temp.size(); ++i) {
b.push_back(temp[i]);
}
} else {
long long i = 0;
while (k--) {
b.push_back(temp[i]);
i++;
}
}
it++;
}
sort(b.begin(), b.end());
cout << a[b[idx - 1]] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long MOD = 1e9 + 7;
const long long N = 1e7 + 10;
const long long INF = 1e18 + 10;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<long long> v(n);
map<long long, vector<long long> > mp;
for (long long i = 0; i < n; i++) {
cin >> v[i];
mp[v[i]].push_back(i);
}
vector<long long> t = v;
sort(t.begin(), t.end());
long long q;
cin >> q;
while (q--) {
long long k, pos;
cin >> k >> pos;
pos--;
vector<pair<long long, long long> > ans;
map<long long, long long> cnt;
for (long long i = n - k; i < n; i++) {
ans.push_back(make_pair(mp[t[i]][cnt[t[i]]], t[i]));
cnt[t[i]]++;
}
sort(ans.begin(), ans.end());
cout << ans[pos].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
long long n = 0;
cin >> n;
deque<long long> posl(n);
for (auto& p : posl) cin >> p;
map<long long, long long> al;
for (auto& p : posl) al[p]++;
long long m = 0;
cin >> m;
for (long long k = 0; k < m; k++) {
long long q = 0, pos = 0, sum = 0, num = 0, need = 0;
cin >> q >> pos;
auto it = al.end(), ed = al.begin();
it--, ed--;
for (it; it != ed; it--) {
if (sum + it->second < q)
sum += it->second;
else {
need = q - sum;
num = it->first;
break;
}
}
deque<long long> ans;
for (auto& p : posl) {
if (p == num && need > 0)
ans.push_back(p), need--;
else if (p > num)
ans.push_back(p);
}
cout << ans[pos - 1] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, l, m, n;
cin >> n;
long long int a[n];
vector<long long int> v;
for (i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
sort(v.begin(), v.end());
long long int var;
cin >> var;
while (var--) {
cin >> k >> l;
map<long long int, long long int> mp;
for (i = n - k; i < n; i++) mp[v[i]]++;
long long int it = 0;
for (i = 0; i < n; i++) {
if (mp[a[i]]) {
if (it == l - 1) {
cout << a[i] << endl;
break;
} else
it++;
mp[a[i]]--;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first || a.first == b.first && a.second < b.second;
}
bool comp2(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long a[n];
pair<long long, long long> s[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
s[i] = {a[i], i};
}
sort(s, s + n, comp);
vector<pair<long long, long long> > ans;
long long m;
cin >> m;
for (long long j = 0; j < m; j++) {
long long k, p;
cin >> k >> p;
ans.clear();
for (long long i = 0; i < k; i++) ans.push_back(s[i]);
sort(ans.begin(), ans.end(), comp2);
cout << ans[p - 1].first << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
void solve() {
int n, k, m, pos;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int _ = 0; _ < m; _++) {
cin >> k >> pos;
vector<int> ind;
set<int> s;
for (int i = 0; i < k; i++) {
int maxi = -1;
for (int j = 0; j < n; j++) {
if (s.find(j) != s.end()) continue;
if (maxi == -1)
maxi = j;
else if (a[maxi] < a[j]) {
maxi = j;
}
}
s.insert(maxi);
}
int h = 1;
for (auto i : s) {
if (h == pos) cout << a[i] << endl;
h++;
}
}
exit(0);
}
int main() {
int t = 1;
for (int i = 0; i < t; i++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first)
return true;
else if (a.first == b.first) {
if (a.second < b.second) return true;
return false;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int i, j, k, l, m, n, p, x, t;
vector<pair<int, int> > v, c;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end(), cmp);
cin >> m;
for (i = 1; i <= m; i++) {
cin >> k >> p;
for (j = 0; j < k; j++) c.push_back({v[j].second, v[j].first});
sort(c.begin(), c.end());
cout << c[p - 1].second << endl;
c.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
const double pi = 3.141592653589793238;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const int N = 3e5 + 5;
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first) return (a.first > b.first);
return (a.second < b.second);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n = 0;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort((a).begin(), (a).end(), cmp);
long long q = 0;
cin >> q;
while (q--) {
long long k, pos;
cin >> k >> pos;
set<pair<long long, long long>> s;
for (long long i = 0; i < k; i++) {
s.insert({a[i].second, a[i].first});
}
while (--pos) s.erase(s.begin());
auto m = *(s.begin());
cout << m.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)2e18 + 77;
void solve() {
int n;
cin >> n;
int a[n], i;
for (i = 0; i < n; i++) cin >> a[i];
map<int, int> N;
int M[n][n];
for (i = 0; i < n; i++) {
N[a[i]]++;
M[n - 1][i] = a[i];
}
for (i = n - 2; i >= 0; i--) {
int mn = (*N.begin()).first;
N[mn]--;
if (N[mn] == 0) N.erase(mn);
int j, k = i;
for (j = i + 1; j >= 0; j--) {
if (mn == M[i + 1][j])
mn = -1;
else
M[i][k--] = M[i + 1][j];
}
}
int m, len;
cin >> m;
while (m--) {
cin >> len >> i;
len--;
i--;
cout << M[len][i] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m;
cin >> m;
for (int e = 0; e < m; e++) {
int k, p;
cin >> k >> p;
vector<int> b;
for (int i = 0; i < k; i++) {
b.push_back(a[i]);
}
for (int i = k; i < n; i++) {
int MIN = 1000000007, pos = 0;
for (int j = 0; j < k; j++) {
if (b[j] <= MIN) {
MIN = b[j];
pos = j;
}
}
if (a[i] > MIN) {
b.erase(b.begin() + pos);
b.push_back(a[i]);
}
}
cout << b[p - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long pw(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 1)
return (a * pw((a * a) % 1000000007, b / 2)) % 1000000007;
else
return (1 * pw((a * a) % 1000000007, b / 2)) % 1000000007;
}
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
bool comp2(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
void solve() {
int n;
cin >> n;
vector<pair<long long, long long> > v;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end(), comp);
vector<vector<pair<long long, long long> > > ans;
for (int k = 0; k < n + 1; k++) {
vector<pair<long long, long long> > temp;
for (int j = 0; j < k; j++) temp.push_back(v[j]);
sort(temp.begin(), temp.end(), comp2);
ans.push_back(temp);
}
long long m;
cin >> m;
while (m--) {
long long k, p;
cin >> k >> p;
cout << ans[k][p - 1].first << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 1;
const int INF = 2e9 + 1;
const int MOD = (1e9 + 7);
void bye(string s = "") {
cout << s << '\n';
exit(0);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> arr(n);
set<pair<int, int> > kek;
for (int i = 0; i < n; i++) {
cin >> arr[i];
kek.emplace(-arr[i], i);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
auto e = kek.begin();
vector<pair<int, int> > mem;
for (int i = 0; i < k; i++) {
mem.emplace_back(e->second, e->first);
e++;
}
sort((mem).begin(), (mem).end());
cout << mem[pos - 1].second * -1 << '\n';
}
bye();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
ll t = 1;
while (t--) {
int n;
cin >> n;
vector<int> v(n), temp(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
temp[i] = v[i];
}
sort(temp.begin(), temp.end(), greater<int>());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
map<int, int> mp;
for (int i = 0; i < k; i++) {
mp[temp[i]]++;
}
vector<int> v1(k);
int j = 0;
for (int i = 0; i < n && j < k; i++) {
if (mp[v[i]] > 0) {
mp[v[i]]--;
v1[j] = v[i];
j++;
}
}
cout << v1[pos - 1] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, x;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> x;
a[i] = {-x, i};
}
sort(a.begin(), a.end());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > v;
for (int i = 0; i < k; i++) v.push_back({a[i].second, -a[i].first});
sort(v.begin(), v.end());
cout << v[pos - 1].second << "\n";
v.clear();
}
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mo = 1e9 + 7;
long long sx, sy, ex, ey, dx[6] = {0, 1, 0, -1, 0, 0},
dy[6] = {1, 0, -1, 0, 0, 0}, m, n, k,
dz[6]{0, 0, 0, 0, -1, 1}, sg;
long long p, no, v, ans, w;
int par[550000];
long long a[500005], b[400005], c[500006], d1[400006], ma[500006], mi[500006];
int lg[200005], mi2[50], mn[25][200005];
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
set<int> se;
struct node {
long long u, v, w;
};
vector<node> eg;
long long qu(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans % m * a % m;
}
b >>= 1;
a = a % m * a % m;
}
return ans;
}
int su(int n) {
if (n == 1 || n == 0) return 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int fi(int a) {
if (a == par[a])
return a;
else
return par[a] = fi(par[a]);
}
map<int, long long> mp, mp1;
map<pair<long long, int>, int> mp2;
priority_queue<pair<long long, int> > que;
pair<long long, int> a1[400000], a2[400000];
int vis[400055], vis1[400055], vis2[400055];
long long dp[55][1005];
char maze[505][505];
vector<int> g[400000], g1[400000];
vector<pair<long long, int> > ve, ve1, ve2;
int cmp1(pair<long long, int> a, pair<long long, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
int cmp(pair<long long, int> a, pair<long long, int> b) {
return a.second < b.second;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
string ans1;
int main() {
int t, p2, p3;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, ss, sss;
long long l, r, n1, u, l1, r1;
int tot = 1;
char ch;
while (cin >> n) {
for (int i = 1; i <= n; i++) {
cin >> a[i];
a1[i] = pair<long long, int>{a[i], i};
}
sort(a1 + 1, a1 + n + 1, cmp1);
cin >> m;
vector<int> tmp;
while (m--) {
cin >> k >> p;
no = 0;
for (int i = 1; i <= k; i++) ve.push_back(a1[i]);
sort(ve.begin(), ve.end(), cmp);
cout << ve[p - 1].first << endl;
ve.clear();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using mii = map<int, int>;
const double Eps = 1e-8;
const int Inf = 1e9 + 9;
const int Mod = 1e9 + 7;
const int N = 1e5 + 9;
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
constexpr double pi = 3.141592653589793238462643383279502884L;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void prime_siever(long long p) {
bool prime[p + 9];
for (long long i = 2; i * i <= p; i++)
if (prime[i] == 0)
for (long long j = i * i; j <= p; j += i) prime[j] = 1;
}
int mul(int a, int b) { return (1LL * a * b) % Mod; }
int add(int a, int b) {
a += b;
if (a >= Mod) a -= Mod;
if (a < 0) a += Mod;
return a;
}
long long bin_power(long long a, long long n) {
if (a == 0) return 0;
long long res = 1;
while (n) {
if (n % 2) {
res = (res * a) % Mod;
n--;
} else {
a = (a * a) % Mod;
n /= 2;
}
}
return res;
}
vector<int> a;
vector<pair<int, int> > b, c;
priority_queue<int, vector<int>, greater<int> > qi;
map<pair<int, int>, int> mp;
void solve() {
int q, n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
qi.push(a[i]);
}
cin >> q;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
b.push_back({x, y});
}
c = b;
sort(b.rbegin(), b.rend());
for (int i = 0; i < q; i++) {
int siz = b[i].first, idx = b[i].second - 1;
while (qi.size() != siz) {
reverse(a.begin(), a.end());
a.erase(find(a.begin(), a.end(), qi.top()));
reverse(a.begin(), a.end());
qi.pop();
}
mp[{siz, idx + 1}] = a[idx];
}
for (int i = 0; i < q; i++) {
cout << mp[c[i]] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = LLONG_MAX - 100000;
void IO() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed);
}
long long pw(long long x, long long y, long long p = inf) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long invmod(long long a, long long m = mod) { return pw(a, m - 2, m); }
long long cl(long long a, long long x) {
return a % x == 0 ? a / x : a / x + 1;
}
void run_time_terror(long long case_no = 0) {
long long n, x;
cin >> n;
set<pair<long long, long long> > s;
for (long long i = 0; i < n; ++i) {
cin >> x;
s.insert({-x, i});
}
long long q;
cin >> q;
while (q--) {
long long sz, k;
cin >> sz >> k;
vector<pair<long long, long long> > seq;
for (auto &it : s) {
if (seq.size() >= sz) break;
seq.push_back({it.second, -it.first});
}
sort(seq.begin(), seq.end());
k--;
cout << seq[k].second << "\n";
}
}
int32_t main() {
cout << setprecision(0);
IO();
long long tt = 1;
for (long long case_no = 1; case_no <= tt; case_no++) {
run_time_terror(case_no);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
long long int n, m, k, i, j, a[101];
cin >> n;
vector<long long int> pr;
for (i = 0; i < n; i++) {
cin >> a[i];
pr.push_back(a[i]);
}
sort(pr.rbegin(), pr.rend());
cin >> m;
while (m--) {
long long int k, pos, last = -1;
cin >> k >> pos;
pos--;
for (i = k - 1; i >= 0; i--) {
if (pr[i] == pr[i - 1])
;
else
break;
}
int y = k - i, z = -1;
for (i = 0; i < n; i++) {
if (a[i] > pr[k - 1]) {
z++;
} else if (a[i] == pr[k - 1] && y) {
z++, y--;
}
if (z == pos) break;
}
cout << a[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n, 0), b(n, 0);
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = a[i];
}
sort(b.begin(), b.end());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
cin >> k >> pos;
int x = b[n - k];
vector<int> c;
for (int j = 0; j < n && c.size() < pos && k > 0; ++j) {
if (a[j] == x) {
--k;
if (k > 0) x = b[n - k];
c.push_back(a[j]);
} else if (a[j] > x) {
c.push_back(a[j]);
}
}
cout << c[pos - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> ar(n), br(n);
for (long long i = 0; i < n; i++) {
cin >> ar[i];
br[i] = ar[i];
}
sort(br.begin(), br.end(), greater<long long>());
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
vector<long long> seq, arr;
arr = ar;
for (long long i = 0; i < k; i++) {
for (long long j = 0; j < n; j++) {
if (arr[j] == br[i]) {
seq.push_back(j);
arr[j] = -1;
break;
}
}
}
sort(seq.begin(), seq.end());
cout << ar[seq[pos - 1]] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12;
long long a_s, b_s;
vector<long long> best(vector<long long> a, vector<long long> b) {
a_s = 0;
b_s = 0;
bool flaga = true;
bool flagb = true;
for (long long i = 0; i < a.size(); ++i)
if (a[i] < 0) flaga = false;
for (long long i = 0; i < b.size(); ++i)
if (b[i] < 0) flagb = false;
if ((!flaga) && flagb) return b;
if ((!flagb) && flaga) return a;
if ((!flaga) && (!flagb)) {
vector<long long> bad = {};
for (long long i = 0; i < a.size(); ++i) bad.push_back(-INF);
return bad;
}
for (long long i = 0; i < a.size(); ++i) a_s += a[i];
for (long long i = 0; i < a.size(); ++i) b_s += b[i];
if (a_s > b_s) return a;
if (b_s > a_s) return b;
for (long long i = 0; i < a.size(); ++i) {
if (a[i] < b[i]) return a;
if (b[i] < a[i]) return b;
}
return a;
}
signed main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
long long m;
cin >> m;
vector<long long> k(m);
vector<long long> pos(m);
for (long long j = 0; j < m; ++j) cin >> k[j] >> pos[j];
vector<vector<vector<long long>>> dp(
n + 1, vector<vector<long long>>(n + 1, vector<long long>()));
dp[0][0] = {};
for (long long i = 1; i <= n; ++i)
for (long long j = 0; j < i; ++j) dp[0][i].push_back(-INF);
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
vector<long long> dp11 = dp[i - 1][j - 1];
dp11.push_back(a[i - 1]);
dp[i][j] = best(dp[i - 1][j], dp11);
}
}
for (long long i = 0; i < m; ++i) cout << dp[n][k[i]][pos[i] - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100];
int ind[100];
bool cmp(int i, int j) {
if (a[i].first == a[j].first) return a[i].second < a[j].second;
return a[i].first > a[j].first;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i, ind[i] = i;
}
sort(ind, ind + n, cmp);
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<int> chosen(k);
for (int i = 0; i < k; ++i) chosen[i] = a[ind[i]].second;
sort(chosen.begin(), chosen.end());
cout << a[chosen[pos - 1]].first << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, l, r, i, j, a[1000001], d[10000001], ans[1000001];
bool tt[1000001];
vector<pair<long long, long long> > v;
string s;
void build(long long h, long long l, long long r) {
if (l == r) {
d[h] = 0;
return;
}
long long w = (l + r) / 2;
build(h * 2, l, w);
build(h * 2 + 1, w + 1, r);
}
void update(long long h, long long l, long long r, long long x) {
if (l == r) {
d[h] = 1;
return;
}
long long w = (l + r) / 2;
if (x <= w)
update(h * 2, l, w, x);
else
update(h * 2 + 1, w + 1, r, x);
d[h] = d[h * 2] + d[h * 2 + 1];
}
long long get(long long h, long long l, long long r, long long x) {
if (l == r) return a[l];
long long w = (l + r) / 2;
if (x <= d[h * 2])
return get(h * 2, l, w, x);
else
return get(h * 2 + 1, w + 1, r, x - d[h * 2]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.push_back(make_pair(a[i], n - i));
}
build(1, 1, n);
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < n; i++) v[i].second = n - v[i].second;
vector<pair<pair<long long, long long>, long long> > z;
cin >> m;
for (int i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
z.push_back(make_pair(make_pair(x, y), i));
}
sort(z.begin(), z.end());
long long l = -1;
for (int i = 0; i < z.size(); i++) {
while (z[i].first.first - 1 > l) {
l++;
update(1, 1, n, v[l].second);
}
ans[z[i].second] = get(1, 1, n, z[i].first.second);
}
for (int i = 1; i <= m; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> a(n), v1(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
v1 = a;
sort(a.begin(), a.end(), greater<long long int>());
long long int q;
cin >> q;
while (q--) {
long long int k, p;
cin >> k >> p;
vector<long long int> v;
long long int sum = 0;
for (long long int i = 0; i < k; i++) sum += a[i];
long long int l1 = 0;
for (long long int i = 0; i < k; i++) {
if (a[i] == a[k - 1]) l1++;
}
for (long long int i = 0; i < n; i++) {
if (v1[i] >= a[k - 1]) v.push_back(v1[i]);
}
vector<long long int> v2, v3;
for (long long int i = 0; i < v.size(); i++) {
if (a[k - 1] == v[i] && l1 > 0)
v3.push_back(v[i]), l1--;
else if (v[i] > a[k - 1])
v3.push_back(v[i]);
}
v2 = v3;
cout << v2[p - 1] << endl;
v.clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, A[111];
map<int, set<int>> idxs;
set<int> app;
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
app.insert(A[i]);
idxs[A[i]].insert(i);
}
int q;
scanf("%d", &q);
while (q--) {
int k, pos;
scanf("%d%d", &k, &pos);
int cnt = 0;
set<int> ii;
for (auto it = app.rbegin(); it != app.rend(); ++it) {
int now = *it;
cnt += idxs[now].size();
if (cnt >= k) {
cnt -= idxs[now].size();
cnt = k - cnt;
auto it = idxs[now].begin();
while (cnt--) {
ii.insert(*it);
++it;
}
break;
}
for (int i : idxs[now]) ii.insert(i);
}
auto it = ii.begin();
while (--pos) ++it;
printf("%d\n", A[*it]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios ::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long arr[n];
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
vector<long long> vrr(arr, arr + n);
sort(vrr.rbegin(), vrr.rend());
long long Q;
cin >> Q;
while (Q--) {
long long k, pos;
cin >> k >> pos;
long long d = 0;
mp = {};
for (long long i = 0; i < k; i++) {
mp[vrr[i]] += 1;
d = vrr[i];
}
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if (arr[i] == d && mp[d] > 0) {
ans.push_back(arr[i]);
mp[d] = mp[d] - 1;
}
if (arr[i] > d) {
ans.push_back(arr[i]);
}
}
pos = pos - 1;
cout << ans[pos] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 62;
const long long MOD = 1e9 + 7;
const int iINF = 1 << 30;
const double PI = 3.14159265359;
int main() {
int n;
vector<pair<int, int> > a;
cin >> n;
a.assign(n, {0, 0});
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = -i;
}
sort(a.rbegin(), a.rend());
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > tmp;
for (int j = 0; j < k; j++) {
tmp.push_back({-a[j].second, a[j].first});
}
sort(tmp.begin(), tmp.end());
cout << tmp[pos - 1].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool mycomparator(pair<long long int, int> p1, pair<long long int, int> p2) {
if (p1.first == p2.first) {
if (p1.second > p2.second) {
return true;
} else {
return false;
}
}
if (p1.first < p2.first) {
return true;
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<long long int, int> > a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(make_pair(x, i));
}
sort(a.begin(), a.end(), mycomparator);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
map<long long int, long long int> p;
vector<long long int> l;
for (int i = n - 1; i >= n - k; i--) {
p[a[i].second] = a[i].first;
l.push_back(a[i].second);
}
sort(l.begin(), l.end());
cout << p[l[pos - 1]] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
void jakos() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
const int mod = 1e9 + 7;
const int base = 179;
const int INF = 1e9;
const int N = 1e5;
signed main() {
jakos();
int n;
cin >> n;
vector<pair<int, int>> a;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
a.emplace_back(b, -i);
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
int q;
cin >> q;
while (q--) {
vector<pair<int, int>> ans;
int k, pos;
cin >> k >> pos;
for (int i = 0; i < k; i++) {
ans.emplace_back(-a[i].second, a[i].first);
}
sort(ans.begin(), ans.end());
cout << ans[pos - 1].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 105, inf = 0x3f3f3f3f;
int n;
int a[maxn], vis[maxn], b[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int k, pos;
cin >> k >> pos;
int cnt = 0;
memset(vis, 0, sizeof vis);
for (int j = 1; j <= k; j++) {
int res = 0;
for (int d = 1; d <= n; d++) {
if (vis[d]) continue;
res = max(res, a[d]);
}
for (int d = 1; d <= n; d++) {
if (res == a[d] && !vis[d]) {
vis[d] = 1;
b[++cnt] = d;
break;
}
}
}
sort(b + 1, b + 1 + cnt);
printf("%d\n", a[b[pos]]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n;
long long x[n + 5];
for (long long i = 0; i < n; i++) {
cin >> x[i];
}
cin >> m;
long long ans = 1e+18;
deque<long long> y, z;
for (long long j = 0; j < m; j++) {
long long k, pos;
cin >> k >> pos;
y.clear();
z.clear();
for (long long i = 0; i < n; i++) {
if (i < k) {
y.push_back(x[i]);
z.push_back(x[i]);
} else {
sort(z.begin(), z.end());
if (x[i] > z[0]) {
for (long long r = k - 1; r >= 0; r--) {
if (y[r] == z[0]) {
y.erase(y.begin() + r);
break;
}
}
z.pop_front();
z.push_back(x[i]);
y.push_back(x[i]);
}
}
}
cout << y[pos - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long int, int> p, pair<long long int, int> q) {
if (p.first > q.first)
return 1;
else if (p.first < q.first)
return 0;
else {
if (p.second < q.second)
return 1;
else
return 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long int a[n];
vector<pair<long long int, int> > v;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back({a[i], i});
}
sort(v.begin(), v.end(), cmp);
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<int> temp;
for (int i = 0; i < k; i++) temp.push_back(v[i].second);
sort(temp.begin(), temp.end());
cout << a[temp[pos - 1]] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first < b.first) return true;
if (a.first > b.first) return false;
if (a.second < b.second) return false;
return true;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
vector<pair<long long, long long> > b;
for (long long i = 0; i < n; i++) {
cin >> a[i];
b.push_back({a[i], i});
}
sort(b.begin(), b.end(), comp);
long long t;
cin >> t;
while (t--) {
long long k, pos;
cin >> k >> pos;
vector<pair<long long, long long> > c;
long long cnt = 0;
for (long long i = n - 1; i >= 0; i--) {
c.push_back({b[i].second, b[i].first});
cnt++;
if (cnt == k) break;
}
sort(c.begin(), c.end());
cout << c[pos - 1].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int head[N];
int dis[N], ecnt;
int fa[N];
int cat[2005][2005];
long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
long long qpow(long long base, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * base) % mod;
n >>= 1;
base = base * base % mod;
}
return ans;
}
struct Node {
long long x, y;
} nd[N];
long long m, n, x, k, y;
struct EDGE {
int u, v, nxt;
long long w;
} e[N];
bool cmp(EDGE a, EDGE b) { return a.w < b.w; }
void add_edge(int u, int v, long long w) {
e[ecnt].u = u;
e[ecnt].v = v;
e[ecnt].w = w;
e[ecnt].nxt = head[u];
head[u] = ecnt++;
}
int fd(int x) { return -1 == fa[x] ? x : fa[x] = fd(fa[x]); }
int c[N];
int lowbit(int x) { return x & (-x); }
void add(long long *c, int x, int y) {
while (x <= n) {
c[x] += y;
x += lowbit(x);
}
}
long long getsum(long long *c, int x) {
long long res = 0;
while (x > 0) {
res += c[x];
x -= lowbit(x);
}
return res;
}
int vis[N];
int p[N];
long long ans;
int C[55][55];
int dp[150][150];
long long posar[N], smar[N];
struct H {
int p, s;
friend bool operator<(H a, H b) { return a.p < b.p; }
} he[N];
bool cmp(int a, int b) { return a > b; }
priority_queue<int> q;
vector<int> v[30];
map<vector<int>, int> mp;
int ar[N];
int br[N];
vector<int> vv[10];
int main() {
{
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
p[ar[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
inv += i - 1 - getsum(smar, p[i]);
add(smar, p[i], 1);
add(posar, p[i], p[i]);
int l = 1;
int r = n;
int mid;
while (l < r) {
mid = 1 + l + r >> 1;
if (getsum(smar, mid - 1) * 2 <= i)
l = mid;
else
r = mid - 1;
}
mid = l;
long long pre_cnt_sum = getsum(smar, mid),
pre_pos_sum = getsum(posar, mid);
long long mov =
pre_cnt_sum * mid - pre_pos_sum - pre_cnt_sum * (pre_cnt_sum - 1) / 2;
long long aft_cnt_sum = i - pre_cnt_sum;
mov += getsum(posar, n) - pre_pos_sum - aft_cnt_sum * mid -
aft_cnt_sum * (aft_cnt_sum + 1) / 2;
cout << inv + mov << " \n"[i == n];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 62;
const long long MOD = 1e9 + 7;
const int iINF = 1 << 30;
const double PI = 3.14159265359;
int LSOne(int n) { return n & (-n); }
class FenwickTree {
private:
vector<int> ft;
public:
FenwickTree(int n) { ft.assign(n + 1, 0); }
int rsq(int b) {
int sum = 0;
for (; b; b -= LSOne(b)) {
sum += ft[b];
}
return sum;
}
int rsq(int a, int b) { return rsq(b) - (a == 1 ? 0 : rsq(a - 1)); }
void adjust(int k, int v) {
for (; k < (int)ft.size(); k += LSOne(k)) {
ft[k] += v;
}
}
};
long long nsum(int x, int y) {
long long s = (long long)y * (y + 1) / 2;
s -= (long long)x * (x - 1) / 2;
return s;
}
void solve() {
int n;
cin >> n;
vector<int> a(n), pos(n + 1), less(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
FenwickTree ft(n);
long long inv = 0;
set<int> mintree, maxtree;
long long minsum = 0, maxsum = 0;
cout << "0 ";
ft.adjust(pos[1] + 1, 1);
mintree.insert(pos[1]);
minsum += pos[1];
for (int i = 2; i <= n; i++) {
auto it1 = mintree.end();
it1--;
if (pos[i] < *it1) {
maxsum += *it1;
maxtree.insert(*it1);
minsum -= *it1;
mintree.erase(it1);
minsum += pos[i];
mintree.insert(pos[i]);
} else {
maxsum += pos[i];
maxtree.insert(pos[i]);
}
if (maxtree.size() > mintree.size()) {
int val = *maxtree.begin();
maxsum -= val;
maxtree.erase(maxtree.begin());
minsum += val;
mintree.insert(val);
}
inv += ft.rsq(pos[i] + 1, n);
it1 = mintree.end();
it1--;
int med = *it1;
int x = med - mintree.size() + 1;
int y = med + maxtree.size();
long long push = nsum(x, med) - minsum;
push += maxsum - nsum(med + 1, y);
cout << inv + push << " ";
ft.adjust(pos[i] + 1, 1);
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
long long a[N], id[N];
pair<long long, long long> G[N];
void Upd(int x, int y) {
while (x <= n) {
G[x].first++;
G[x].second += y;
x += (x & -x);
}
}
pair<long long, long long> Get(int x) {
pair<long long, long long> res;
res.first = res.second = 0;
while (x > 0) {
res.first += G[x].first;
res.second += G[x].second;
x -= (x & -x);
}
return res;
}
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
id[a[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
long long idx = id[i], ans = 0;
inv += Get(n).first - Get(idx).first;
ans = inv;
Upd(idx, idx);
long long l = 1, r = n, mid, res = -1;
while (l <= r) {
mid = (l + r) / 2;
if (Get(mid).first >= (i + 1) / 2) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long totR = res + Get(n).first - Get(res).first;
ans += Get(n).second - Get(res).second -
(totR * (totR + 1) / 2 - res * (res + 1) / 2);
long long totL = res - Get(res - 1).first;
ans += (res - 1) * res / 2 - (totL - 1) * totL / 2 - Get(res - 1).second;
printf("%lld ", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int N;
int position[maxn];
long long sum1[maxn << 2], sum2[maxn << 2];
void add(long long* bit, int pos, long long val) {
while (pos <= N) {
bit[pos] += val;
pos += pos & (-pos);
}
}
long long query(long long* bit, int pos) {
long long ret = 0;
while (pos) {
ret += bit[pos];
pos -= pos & (-pos);
}
return ret;
}
int search(long long* bit, int val) {
int i = 0;
for (int j = 20; j >= 0; --j) {
if ((i | (1 << j)) <= N && bit[i | (1 << j)] <= val) {
val -= bit[i |= (1 << j)];
}
}
return i;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 1; i <= N; ++i) {
int p;
cin >> p;
position[p] = i;
}
long long cnt = 0;
for (int i = 1; i <= N; ++i) {
int p = position[i];
add(sum1, p, 1);
cnt += i - query(sum1, p);
add(sum2, p, p);
long long pos = search(sum1, i / 2) + 1;
long long sum = 0;
long long a = i / 2, b = i - a - 1;
sum += pos * a - a * (a + 1) / 2 - query(sum2, pos - 1);
sum += (query(sum2, N) - query(sum2, pos)) - b * pos - b * (b + 1) / 2;
cout << cnt + sum << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int a[maxn];
class BIT {
public:
long long a[maxn];
void add(int x, long long c) {
for (int i = x; i < maxn; i += i & -i) a[i] += c;
}
long long sum(int x) {
long long res = 0;
for (int i = x; i > 0; i -= i & -i) res += a[i];
return res;
}
} b1, b2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
a[x] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
b1.add(a[i], 1);
inv += i - b1.sum(a[i]);
b2.add(a[i], a[i]);
x = i / 2 + 1;
long long res = b2.sum(n);
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (b1.sum(mid) >= x)
r = mid;
else
l = mid + 1;
}
long long pos = l;
long long s = b2.sum(pos);
long long lans = pos * (pos + 1) / 2 - s - (pos - x) * (pos - x + 1) / 2;
long long rans = res - s - (i - x) * (pos + 1 + i - x + pos) / 2;
cout << lans + rans + inv << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N], p[N], inv[N], n;
int f[N + 1];
int read(int idx) {
int sum = 0;
idx++;
while (idx > 0) {
sum += f[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
idx++;
while (idx <= n) {
f[idx] += val;
idx += (idx & -idx);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
for (int i = 0; i < n; i++) p[a[i]] = i;
for (int i = n - 1; i >= 0; i--) {
inv[a[i]] = read(a[i]);
update(a[i], 1);
}
long long ans = 0;
int l = p[0], r = l;
update(p[0], -1);
cout << ans << " ";
for (int i = 1; i < n; i++) {
int lc = p[i] + 1 - read(p[i]), rc = i - lc;
update(p[i], -1);
if (lc > rc) {
int lb = 0, rb = p[i] - 1;
while (lb <= rb) {
int m = (lb + rb) / 2;
int mc = m + 1 - read(m);
if (mc >= i + 1 - mc) {
rb = m - 1;
} else {
lb = m + 1;
}
}
ans += read(p[i]) - read(lb);
} else if (lc < rc) {
ans += rc - lc;
int lb = p[i] + 1, rb = n - 1;
while (lb <= rb) {
int m = (lb + rb) / 2;
int mc = m + 1 - read(m);
if (mc <= i + 1 - mc) {
lb = m + 1;
} else {
rb = m - 1;
}
}
ans += read(rb) - read(p[i]);
}
cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fenwick {
int N;
vector<int> bit;
fenwick(int n = 1e5) {
N = n + 5;
bit.assign(N, 0);
}
void resize(int n) {
N = n + 5;
bit.assign(N, 0);
}
void update(int x, int val) {
while (x < N) {
bit[x] += val;
x += x & -x;
}
}
int sum(int x) {
int ret = 0;
while (x > 0) {
ret += bit[x];
x -= x & -x;
}
return ret;
}
};
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
vector<int> idx(n + 5);
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
idx[x] = i;
}
fenwick bit(n);
set<long long, greater<long long>> l;
set<long long> r;
long long lsum = 0, rsum = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
bit.update(idx[i], 1);
ans += i - bit.sum(idx[i]);
if (l.size() == 0 || idx[i] < *l.begin())
l.insert(idx[i]), lsum += idx[i];
else
r.insert(idx[i]), rsum += idx[i];
if (l.size() > r.size() + 1) {
int x = *l.begin();
lsum -= x;
rsum += x;
l.erase(l.begin());
r.insert(x);
} else if (r.size() > l.size()) {
int x = *r.begin();
lsum += x;
rsum -= x;
l.insert(x);
r.erase(r.begin());
}
long long lcnt = (l.size() * (*l.begin())) - lsum -
(1ll * l.size() * (l.size() - 1)) / 2;
long long rcnt = (rsum - r.size() * (*l.begin())) -
(1ll * r.size() * (r.size() + 1)) / 2;
cout << ans + lcnt + rcnt << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
long long sum1[maxn];
long long sum2[maxn];
long long n;
long long lowbit(long long x) { return x & -x; }
void add(long long *sum, long long x, long long v) {
while (x <= n) {
sum[x] += v;
x += lowbit(x);
}
}
long long query(long long *sum, long long x) {
long long res = 0;
while (x > 0) {
res += sum[x];
x -= lowbit(x);
}
return res;
}
long long a[maxn];
long long pos[maxn];
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pos[a[i]] = i;
}
long long ans1 = 0;
for (long long i = 1; i <= n; i++) {
ans1 += i - 1 - query(sum1, pos[i]);
add(sum1, pos[i], 1);
add(sum2, pos[i], pos[i]);
long long mid, l = 1, r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query(sum1, mid) * 2 <= i) {
l = mid + 1;
} else {
r = mid - 1;
}
}
long long ans2 = 0;
long long cnt = query(sum1, mid), sum = query(sum2, mid);
ans2 += mid * cnt - sum - cnt * (cnt - 1) / 2;
cnt = i - cnt, sum = query(sum2, n) - sum;
ans2 += sum - cnt * (mid + 1) - cnt * (cnt - 1) / 2;
printf("%lld ", ans1 + ans2);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long c[maxn], d[maxn];
long long n;
long long lowbit(long long x) { return x & (-x); }
void update(long long i, long long k) {
while (i <= n) {
c[i] += k;
i += lowbit(i);
}
}
long long getsum(long long i) {
long long res = 0;
while (i > 0) {
res += c[i];
i -= lowbit(i);
}
return res;
}
void update2(long long i, long long k) {
while (i <= n) {
d[i] += k;
i += lowbit(i);
}
}
long long getsum2(long long i) {
long long res = 0;
while (i > 0) {
res += d[i];
i -= lowbit(i);
}
return res;
}
long long f[maxn], where[maxn];
long long bs(long long sum) {
long long l = 0, r = n;
while (l <= r) {
long long mid = (l + r) >> 1;
if (getsum2(mid) >= sum)
r = mid - 1;
else
l = mid + 1;
}
return l;
}
long long dc(long long x, long long y) {
long long len = y - x + 1;
return (x + y) * len / 2;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> f[i];
where[f[i]] = i;
}
long long cnt = 0;
for (long long i = 1; i <= n; ++i) {
long long pos = where[i];
update2(pos, 1);
cnt += i - getsum2(pos);
update(pos, pos);
long long base = bs(i / 2 + 1);
long long lmost = base - i / 2;
long long rmost = base + i / 2 - ((i + 1) % 2);
long long t = dc(lmost, base) - dc(base + 1, rmost);
long long sum = 0;
sum -= getsum(base);
sum += getsum(n) - getsum(base);
cout << sum + t + cnt << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int oo = 1e9 + 7;
int a[maxn], c[maxn], n;
int pos[maxn];
long long ans[maxn];
void update(int x) {
for (int i = x; i <= n && i; i += i & (-i)) c[i]++;
}
long long query(int x) {
long long ans = 0;
while (x) ans = ans + 1ll * c[x], x -= x & (-x);
return ans;
}
priority_queue<int> q1, q2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
long long a1 = 0, ln = 0, rn = 0;
for (long long i = 1; i <= n; i++) {
update(pos[i]);
a1 = a1 + i - query(pos[i]);
if (q1.size() && pos[i] < q1.top()) {
ln += pos[i];
q1.push(pos[i]);
} else {
rn += pos[i];
q2.push(-pos[i]);
}
while (q1.size() < q2.size()) {
long long c = -q2.top();
ln += c;
rn -= c;
q2.pop();
q1.push(c);
}
while (q1.size() > q2.size() + 1) {
long long c = q1.top();
ln -= c;
rn += c;
q1.pop();
q2.push(-c);
}
long long top = q1.top();
ans[i] = a1 + 1ll * top * q1.size() - ln -
1ll * q1.size() * (q1.size() - 1) / 2 + rn - top * q2.size() -
1ll * q2.size() * (q2.size() + 1) / 2;
;
;
}
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%lld", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *l, *r;
int count;
long long sum;
int ask(int k, int ll, int rr) {
if (ll == rr) {
return count;
}
int mid = (ll + rr) >> 1;
if (k <= mid) {
return l ? l->ask(k, ll, mid) : 0;
} else {
return (l ? l->count : 0) + (r ? r->ask(k, mid + 1, rr) : 0);
}
}
long long asksum(int k, int ll, int rr) {
if (ll == rr) {
return sum;
}
int mid = (ll + rr) >> 1;
if (k <= mid) {
return l ? l->asksum(k, ll, mid) : 0;
} else {
return (l ? l->sum : 0) + (r ? r->asksum(k, mid + 1, rr) : 0);
}
}
void add(int, int, int, int);
} node[200005 * 25];
int cnt;
Node *getNode() {
++cnt;
return node + cnt;
}
void Node::add(int k, int w, int ll, int rr) {
++count;
sum += w;
if (ll == rr) {
return;
}
int mid = (ll + rr) >> 1;
if (k <= mid) {
if (l) {
Node tmp = *l;
l = getNode();
(*l) = tmp;
} else {
l = getNode();
}
l->add(k, w, ll, mid);
} else {
if (r) {
Node tmp = *r;
r = getNode();
(*r) = tmp;
} else {
r = getNode();
}
r->add(k, w, mid + 1, rr);
}
}
int n;
Node root[200005];
int rf(int a, int b) {
int l = 0, r = n, mid;
while (l + 1 != r) {
mid = (l + r) >> 1;
if (root[mid].ask(a, 0, n) < b) {
l = mid;
} else {
r = mid;
}
}
return r;
}
int a[200005], b[200005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
b[a[i]] = i;
root[i] = root[i - 1];
root[i].add(a[i], i, 0, n);
}
long long sum = 0;
for (int i = 1; i <= n; ++i) {
int d = rf(i, (i >> 1) + (i & 1));
long long ans = 0;
ans += root[d].asksum(n, 0, n) - root[d].asksum(i, 0, n);
long long tmp = d - (i >> 1) - (i & 1);
ans -= tmp * (tmp + 1) / 2;
tmp = d + (i >> 1) + 1;
ans += (n + tmp) * (n - tmp + 1) / 2;
ans -= (root[n].asksum(n, 0, n) - root[n].asksum(i, 0, n)) -
(root[d].asksum(n, 0, n) - root[d].asksum(i, 0, n));
sum += i - root[b[i]].ask(i, 0, n);
ans += sum;
printf("%lld ", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long const inf = 1e9;
long long const mod = 1e9 + 7;
long double const eps = 1e-9;
long long bit[200005];
long long bit2[200005];
long long sumbit[200005];
long long n;
void update(long long k) {
while (k <= 200000) {
bit[k] += 1;
k += k & -k;
}
}
long long sum(long long k) {
long long s = 0;
while (k > 0) {
s += bit[k];
k -= k & -k;
}
return s;
}
void update2(long long k) {
while (k <= 200000) {
bit2[k] += 1;
k += k & -k;
}
}
long long sum2(long long k) {
long long s = 0;
while (k > 0) {
s += bit2[k];
k -= k & -k;
}
return s;
}
void update3(long long k, long long val) {
while (k <= 200000) {
sumbit[k] += val;
k += k & -k;
}
}
long long sum3(long long k) {
long long s = 0;
while (k > 0) {
s += sumbit[k];
k -= k & -k;
}
return s;
}
long long cinv(long long pos, long long num) {
long long SUM = num - 1;
SUM -= sum2(pos);
update2(pos);
return SUM;
}
int main() {
cin >> n;
long long a[n];
long long pos[n + 1];
for (int i = (0); i < (n); i++) {
cin >> a[i];
pos[a[i]] = i + 1;
}
long long inversions = 0;
for (int i = (1); i < (n + 1); i++) {
inversions += cinv(pos[i], i);
update(pos[i]);
update3(pos[i], pos[i]);
long long k = 0;
for (long long b = n / 2; b >= 1; b /= 2) {
while (k + b <= n && sum(k + b) <= i / 2) k += b;
}
k++;
long long l = sum(k - 1);
long long r = sum(n) - sum(k);
long long suml = sum3(k - 1);
long long sumr = sum3(n) - sum3(k);
long long ans = inversions + (long long)l * k - suml + sumr -
(long long)r * k - (long long)(l * (l + 1)) / 2 -
(long long)(r * (r + 1)) / 2;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int a[MAX], p[MAX], n;
long long c1[MAX], c2[MAX];
set<int> st;
void add(long long *c, int x, int k) {
for (; x <= n; x += x & -x) c[x] += k;
}
long long query(long long *c, int x) {
long long sum = 0;
for (; x; x -= x & -x) sum += c[x];
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
st.insert(p[1]);
auto it = st.begin();
printf("0 ");
add(c1, p[1], 1);
add(c2, p[1], p[1]);
long long res = 0;
for (int i = 2; i <= n; i++) {
st.insert(p[i]);
if (p[i] < (*it) && i % 2 == 0) it--;
if (p[i] > (*it) && i % 2 == 1) it++;
add(c1, p[i], 1);
res += (i * 1ll - query(c1, p[i]));
add(c2, p[i], p[i]);
int midpos = *it;
long long sum = 0, k = i / 2;
sum += i & 1 ? k * 1ll * (midpos - 1 + midpos - k) / 2
: (k - 1) * 1ll * (midpos + midpos - k) / 2;
sum -= k * 1ll * (midpos + 1 + midpos + k) / 2;
sum -= query(c2, midpos - 1);
sum += query(c2, n) - query(c2, midpos);
printf("%I64d ", res + sum);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long pos[N], s1[N], s2[N];
int a[N];
int n;
void add(long long s[], int pos, long long v) {
while (pos <= n) {
s[pos] += v;
pos += pos & (-pos);
}
}
long long query(long long s[], int pos) {
long long res = 0;
while (pos) {
res += s[pos];
pos -= pos & (-pos);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += i - 1 - query(s1, pos[i]);
add(s1, pos[i], 1);
add(s2, pos[i], pos[i]);
int l = 1, r = n, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (query(s1, mid) * 2 <= i)
l = mid + 1;
else
r = mid - 1;
}
long long ans2 = 0;
long long cnt = query(s1, mid), sum = query(s2, mid);
ans2 += mid * cnt - sum - cnt * (cnt - 1) / 2;
cnt = i - cnt;
sum = query(s2, n) - sum;
ans2 += sum - cnt * (mid + 1) - cnt * (cnt - 1) / 2;
printf("%lld ", ans + ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long sum1[maxn << 2], sum2[maxn << 2];
int N, pos[maxn], a[maxn];
void update(long long* tree, int pos, int l, int r, int id, long long val) {
if (l > r || pos < l || pos > r) return;
if (pos == l && pos == r) {
tree[id] += val;
} else {
int mid = (l + r) >> 1;
update(tree, pos, l, mid, id << 1, val);
update(tree, pos, mid + 1, r, id << 1 | 1, val);
tree[id] = tree[id << 1] + tree[id << 1 | 1];
}
}
long long query(long long* tree, int l, int r, int x, int y, int id) {
if (l > r || x > y || x > r || y < l) return 0;
if (l <= x && y <= r) {
return tree[id];
}
int mid = (x + y) >> 1;
if (mid < l) return query(tree, l, r, mid + 1, y, id << 1 | 1);
if (mid >= r) return query(tree, l, r, x, mid, id << 1);
return query(tree, l, r, x, mid, id << 1) +
query(tree, l, r, mid + 1, y, id << 1 | 1);
}
int search(long long* tree, long long val) {
int l = 1, r = N, ret = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(tree, 1, mid, 1, N, 1) < val) {
l = mid + 1;
} else {
ret = mid;
r = mid - 1;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 1; i <= N; ++i) cin >> a[i], pos[a[i]] = i;
long long cnt = 0;
for (int i = 1; i <= N; ++i) {
int p = pos[i];
update(sum1, p, 1, N, 1, 1);
cnt += i - query(sum1, 1, p, 1, N, 1);
update(sum2, p, 1, N, 1, p);
long long a = i / 2, b = i - a - 1, pos = search(sum1, i / 2 + 1), sum = 0;
sum += -query(sum2, 1, pos - 1, 1, N, 1) + query(sum2, pos + 1, N, 1, N, 1);
sum += (a * pos - a * (a + 1) / 2) - (b * pos + b * (b + 1) / 2);
cout << cnt + sum << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, fwk[2][200001], ps[200001] = {}, pv[200001] = {}, to1 = 0, to2 = 0;
set<long long> s;
set<long long>::iterator it;
void upd(int x, int t, long long v) {
for (; x <= n; x += x & (-x)) {
fwk[t][x] += v;
}
}
long long qry(int x, int t) {
long long to = 0;
for (; x; x -= x & (-x)) {
to += fwk[t][x];
}
return to;
}
long long sm(long long n) { return n * (n + 1) / 2; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ps[x] = i;
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
it = s.insert(ps[i]).first;
} else if (i % 2) {
s.insert(ps[i]);
if (ps[i] > *it) {
it = next(it);
}
} else {
s.insert(ps[i]);
if (ps[i] < *it) {
it = prev(it);
}
}
upd(ps[i] + 1, 0, 1);
upd(ps[i] + 1, 1, ps[i]);
to1 = (i % 2) * (*it) -
(2 * sm((i - 1) / 2) + ((i % 2 == 0) ? (i / 2) : 0)) -
2 * qry((*it) + 1, 1) + qry(n, 1);
to2 += (long long)(i - qry(ps[i] + 1, 0));
cout << to1 + to2;
if (i < n) {
cout << " ";
}
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N];
struct fenwick {
long long fen[N];
fenwick() { memset(fen, 0, sizeof fen); }
void add(int x, int d) {
for (int i = x + 1; i < N; i += i & -i) {
fen[i] += d;
}
}
long long sum(int x) {
long long ans = 0;
for (int i = x; i; i -= i & -i) {
ans += fen[i];
}
return ans;
}
long long sum(int l, int r) { return sum(r) - sum(l); }
int kth(int k) {
int x = 0;
for (int i = 17; ~i; i--) {
if ((x | 1 << i) < N && fen[x | 1 << i] <= k) {
x |= 1 << i;
k -= fen[x];
}
}
return x;
}
} t1, t2;
int solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x] = i;
}
long long rev = 0;
for (int i = 1; i <= n; i++) {
t1.add(a[i], 1);
t2.add(a[i], a[i]);
rev += t1.sum(a[i] + 1, 2e5 + 1);
int t = i - 1 >> 1;
int m = t1.kth(t);
long long mv = 0;
++t;
mv += t2.sum(m + 1, 2e5 + 1) - 1ll * (m + 1) * (i - t) -
1ll * (i - t) * (i - t - 1) / 2;
mv += 1ll * m * t - t2.sum(m + 1) - 1ll * t * (t - 1) / 2;
printf("%lld ", mv + rev);
}
puts("");
return 0;
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long INF = 1LL << 60;
const long long mod = 1e9 + 7;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class Abel>
struct BIT {
private:
vector<Abel> node;
long long n;
Abel UNITY_SUM = 0;
public:
BIT(long long n_) {
n = n_;
node.resize(n, UNITY_SUM);
}
void add(long long a, Abel w) {
for (long long i = a; i < n; i |= i + 1) node[i] += w;
}
Abel sum(long long a) {
Abel ret = UNITY_SUM;
for (long long i = a - 1; i >= 0; i = (i & (i + 1)) - 1) ret += node[i];
return ret;
}
Abel sum(long long a, long long b) { return sum(b) - sum(a); }
long long get(long long k) {
++k;
long long res = 0;
long long n = 1;
while (n < (long long)node.size()) n *= 2;
for (long long i = n / 2; i > 0; i /= 2) {
if (res + i < (long long)node.size() && node[res + i - 1] < k) {
k -= node[res + i - 1];
res += i;
}
}
return res;
}
void print() {
for (long long i = 0; i < n; ++i) cout << sum(i, i + 1) << ",";
cout << endl;
}
};
void solve() {
long long n;
cin >> n;
vector<long long> p(n);
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> p[i];
mp[p[i]] = i;
}
BIT<long long> bit(n + 1);
BIT<long long> bit2(n + 1);
long long now = 0;
for (long long i = 1; i <= n; ++i) {
long long ans = 0;
bit.add(mp[i], 1);
bit2.add(mp[i], mp[i]);
long long j1 = bit.get((i + 1) / 2 - 1);
long long j2 = j1 + 1;
if (i & 1) {
ans += j1 * bit.sum(0, j1) - bit2.sum(0, j1);
ans += bit2.sum(j1 + 1, n) - j1 * bit.sum(j1 + 1, n);
long long k = i / 2;
ans -= k * (k + 1);
} else {
ans += j1 * bit.sum(0, j1) - bit2.sum(0, j1);
ans += bit2.sum(j2 + 1, n) - j2 * bit.sum(j2 + 1, n);
long long k = (i - 2) / 2;
ans -= k * (k + 1);
}
now += bit.sum(mp[i] + 1, n);
ans += now;
cout << ans << " ";
}
cout << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
const long long MAXN = 1e6 + 5;
long long n, m, t;
long long a[MAXN];
long long tree1[MAXN], tree2[MAXN];
long long pos[MAXN];
void add(long long *tree, long long x, long long xx) {
while (x <= n) tree[x] += xx, x += (x & (-x));
}
long long query(long long *tree, long long x) {
long long sum = 0;
while (x > 0) sum += tree[x], x -= (x & (-x));
return sum;
}
long long bs(long long x) {
long long l = 1, r = n;
long long ans;
while (l <= r) {
long long mid = l + r >> 1;
if (query(tree1, mid) > x / 2)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
long long ans = 0;
add(tree1, pos[i], 1);
add(tree2, pos[i], pos[i]);
cnt += query(tree1, n) - query(tree1, pos[i]);
long long tmp = bs(i);
long long a = i / 2, b = i - a - 1;
ans += a * tmp - query(tree2, tmp - 1) - (a + 1) * a / 2;
long long tmpp = query(tree2, n) - query(tree2, tmp);
ans += tmpp - b * tmp - (b + 1) * b / 2;
cout << ans + cnt << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, fwk[2][200001], ps[200001] = {}, pv[200001] = {}, to1 = 0, to2 = 0;
set<long long> s;
set<long long>::iterator it;
void upd(int x, int t, long long v) {
for (; x <= n; x += x & (-x)) {
fwk[t][x] += v;
}
}
long long qry(int x, int t) {
long long to = 0;
for (; x; x -= x & (-x)) {
to += fwk[t][x];
}
return to;
}
long long sm(long long n) { return n * (n + 1) / 2; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ps[x] = i;
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
it = s.insert(ps[i]).first;
} else if (i % 2) {
s.insert(ps[i]);
if (ps[i] > *it) {
it = next(it);
}
} else {
s.insert(ps[i]);
if (ps[i] < *it) {
it = prev(it);
}
}
upd(ps[i] + 1, 0, 1);
upd(ps[i] + 1, 1, ps[i]);
to1 = (i % 2) * (*it) -
(2 * sm((i - 1) / 2) + ((i % 2 == 0) ? (i / 2) : 0)) -
2 * qry((*it) + 1, 1) + qry(n, 1);
to2 += (long long)(i - qry(ps[i] + 1, 0));
cout << to1 + to2;
if (i < n) {
cout << " ";
}
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200005];
long long ret[200005];
long long inv[200005], sum[200005];
void update(long long *pen, int ind, int val) {
while (ind < 200005) {
pen[ind] += val;
ind += ind & (-ind);
}
}
long long query(long long *pen, int ind) {
long long ret = 0;
while (ind > 0) {
ret += pen[ind];
ind = ind & (ind - 1);
}
return ret;
}
int getIndex(int target, int n) {
int l = 0, r = n - 1, mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (query(inv, mid) < target) {
l = mid;
} else {
r = mid - 1;
}
}
return l + 1;
}
long long getSum(int n) {
long long ret = (long long)n * (n + 1);
return ret / 2;
}
void solve() {
int n;
scanf("%d ", &n);
pair<int, int> in[200005];
int pos = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d ", &p[i]);
in[pos++] = make_pair(p[i], i);
}
sort(in, in + n);
int maxi = 0;
long long invSum = 0;
for (int i = 0; i < n; ++i) {
invSum = invSum + i - query(inv, in[i].second);
update(inv, in[i].second, 1);
update(sum, in[i].second, in[i].second);
int k = i + 1;
maxi = max(maxi, in[i].second);
int mInd = getIndex(k / 2, n);
long long R = 1e18;
if (k == 1) {
continue;
}
for (int j = 0; j < 2; ++j) {
int mid = getIndex(k / 2 + j, n);
long long prefix = getSum(mid) - getSum(mid - k / 2 - j);
long long suffix = getSum(mid + k - (k / 2 + j)) - getSum(mid);
long long tmp = prefix - query(sum, mid) * 2 - suffix + query(sum, n);
R = min(R, tmp);
}
ret[i + 1] = invSum + R;
}
for (int i = 1; i <= n; ++i) {
printf("%lld ", ret[i]);
}
putchar('\n');
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = (int)2e5 + 5;
int A[NN];
int pos[NN];
int n;
long long tree_cnt[NN];
long long tree_sum[NN];
long long read(long long* tree, int idx) {
idx++;
long long res = 0;
while (idx > 0) {
res += tree[idx];
idx -= (idx & (-idx));
}
return res;
}
void update(long long* tree, int idx, long long val) {
idx++;
while (idx < NN) {
tree[idx] += val;
idx += (idx & (-idx));
}
}
int find_median(int len) {
int lo = 0, hi = n;
int half = (len + 1) / 2;
while (lo < hi) {
int mid = (lo + hi) >> 1;
int r = read(tree_cnt, mid);
if (r < half)
lo = mid + 1;
else
hi = mid;
}
return lo;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
A[i]--;
pos[A[i]] = i;
}
memset(tree_cnt, 0, sizeof(tree_cnt));
memset(tree_sum, 0, sizeof(tree_sum));
long long tot = 0;
long long rev = 0;
for (int i = 0; i < n; i++) {
rev += i - read(tree_cnt, pos[i]);
update(tree_cnt, pos[i], +1);
update(tree_sum, pos[i], pos[i]);
int len = i + 1;
int med = find_median(len);
tot += pos[i];
long long sum_down = read(tree_sum, med);
long long sum_up = tot - sum_down;
long long down_cnt = (len + 1) / 2;
long long up_cnt = len - down_cnt;
long long res = 0;
res += sum_up - med * up_cnt - (up_cnt * (up_cnt + 1)) / 2;
res += med * down_cnt - sum_down - (down_cnt * (down_cnt - 1)) / 2;
res += rev;
if (i > 0) printf(" ");
printf("%lld", res);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, a[200010], p[200010], c[200010];
long long inv[200010];
set<int> st;
set<int>::iterator it;
int Lowbit(int x) { return x & (-x); }
void Update(int x, int d) {
while (x <= n) {
c[x] += d;
x += Lowbit(x);
}
}
int Getsum(int x) {
int res = 0;
while (x) {
res += c[x];
x -= Lowbit(x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[a[i]] = i;
}
cout << "0 ";
int center = p[1], lnum = 0, rnum = 0;
long long sum = 0;
st.insert(p[1]);
Update(p[1], 1);
for (int i = 2; i <= n; ++i) {
inv[i] = Getsum(n) - Getsum(p[i]);
Update(p[i], 1);
st.insert(p[i]);
long long nxt_sum =
sum + inv[i] + abs(p[i] - center) - abs(Getsum(center) - Getsum(p[i]));
if (center < p[i])
nxt_sum -= inv[i];
else
nxt_sum -= Getsum(p[i] - 1);
if (p[i] > center)
rnum++;
else
lnum++;
if (lnum == rnum + 1) {
it = st.find(center);
it--;
center = (*it);
lnum--;
rnum++;
}
if (rnum == lnum + 2) {
it = st.find(center);
it++;
nxt_sum -= ((*it) - center - 1);
center = (*it);
lnum++;
rnum--;
}
sum = nxt_sum;
cout << sum << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 200000 + 10;
class BIT {
private:
int n;
int bit[maxn];
public:
BIT(int size) {
n = size;
std::fill(bit, bit + size + 1, 0);
}
void add(int x, int v) {
while (x <= this->n) {
bit[x] += v;
x += ((x) & (-x));
}
}
int query(int x) {
int ans = 0;
while (x) {
ans += bit[x];
x -= ((x) & (-x));
}
return ans;
}
int find_k(int k) {
int bits = 0;
int n = this->n;
while (n) {
n >>= 1;
bits++;
}
int mask = 0;
int cnt = 0;
for (int i = bits - 1; i >= 0; i--) {
mask += 1 << i;
if (mask > this->n || cnt + bit[mask] >= k)
mask -= (1 << i);
else
cnt += bit[mask];
}
return mask + 1;
}
};
int n, pos[maxn];
struct TreeNode {
int zeros, preadd, sufadd;
long long presum, sufsum;
};
TreeNode seg[maxn << 2];
void build_tree(int node, int L, int R) {
seg[node].zeros = R - L + 1;
if (L == R) return;
int M = L + (R - L) / 2;
build_tree(node << 1, L, M);
build_tree(node << 1 | 1, M + 1, R);
}
void push_down(int node, int L, int R) {
int lch = node << 1;
int rch = node << 1 | 1;
int M = L + (R - L) / 2;
if (seg[node].preadd) {
seg[lch].preadd += seg[node].preadd;
seg[rch].preadd += seg[node].preadd;
seg[lch].presum += 1LL * seg[lch].zeros * seg[node].preadd;
seg[rch].presum += 1LL * seg[rch].zeros * seg[node].preadd;
seg[node].preadd = 0;
}
if (seg[node].sufadd) {
seg[lch].sufadd += seg[node].sufadd;
seg[rch].sufadd += seg[node].sufadd;
seg[lch].sufsum += 1LL * seg[lch].zeros * seg[node].sufadd;
seg[rch].sufsum += 1LL * seg[rch].zeros * seg[node].sufadd;
seg[node].sufadd = 0;
}
}
int qL, qR;
void add(int node, int L, int R, int type) {
if (qL <= L && R <= qR) {
if (type == 0) {
seg[node].preadd += 1;
seg[node].presum += seg[node].zeros;
} else {
seg[node].sufadd += 1;
seg[node].sufsum += seg[node].zeros;
}
return;
}
push_down(node, L, R);
int M = L + (R - L) / 2;
if (qL <= M) add(node << 1, L, M, type);
if (qR > M) add(node << 1 | 1, M + 1, R, type);
int lch = node << 1;
int rch = node << 1 | 1;
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
void erase(int node, int L, int R, int p) {
if (L == R) {
memset(seg + node, 0, sizeof(TreeNode));
return;
}
int M = L + (R - L) / 2;
int lch = node << 1;
int rch = node << 1 | 1;
push_down(node, L, R);
if (p <= M)
erase(lch, L, M, p);
else
erase(rch, M + 1, R, p);
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
long long query(int node, int L, int R, int type) {
if (qL <= L && R <= qR) {
if (type == 0)
return seg[node].presum;
else
return seg[node].sufsum;
}
push_down(node, L, R);
long long ans = 0;
int M = L + (R - L) / 2;
if (qL <= M) ans += query(node << 1, L, M, type);
if (qR > M) ans += query(node << 1 | 1, M + 1, R, type);
return ans;
}
int main() {
scanf("%d", &n);
BIT bit(n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
pos[a] = i;
}
build_tree(1, 1, n);
long long inversion = 0;
for (int i = 1; i <= n; i++) {
const int &p = pos[i];
inversion += i - 1 - bit.query(p);
bit.add(p, 1);
qL = p + 1;
qR = n;
if (qL <= qR) add(1, 1, n, 0);
qL = 1;
qR = p - 1;
if (qL <= qR) add(1, 1, n, 1);
erase(1, 1, n, p);
long long ans = 0;
int median = bit.find_k((i + 1) / 2);
qL = 1;
qR = median - 1;
if (qL <= qR) {
ans += query(1, 1, n, 0);
}
qL = median + 1;
qR = n;
if (qL <= qR) {
ans += query(1, 1, n, 1);
}
printf("%lld ", inversion + ans);
}
printf("\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.