text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000007;
unsigned long long MOD = int(1e9 + 7);
int n, l;
unsigned long long dp[(int)(4e3 + 5)][(int)(2e2 + 5)];
int a[(int)(2e2 + 5)], b[(int)(2e2 + 5)];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> l;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
dp[a[i]][i]++;
if (a[i] != b[i]) {
a[n + i] = b[i];
b[n + i] = a[i];
dp[a[n + i]][n + i]++;
}
}
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n + n; j++) {
if (!dp[i][j]) continue;
dp[i][j] %= MOD;
for (int k = 0; k < n + n; k++) {
if (j % n != k % n && a[k] == b[j]) {
dp[i + a[k]][k] += dp[i][j];
}
}
}
}
unsigned long long ans = 0LL;
for (int i = 0; i < n + n; i++) ans = (ans + dp[l][i]) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, l;
cin >> n >> l;
vector<pair<long long, long long>> vec;
long long a, b;
long long dp[l + 1][n][2];
for (int i = 0; i <= l; i++) {
for (int j = 0; j < n; j++) {
dp[i][j][0] = 0;
dp[i][j][1] = 0;
}
}
for (int i = 0; i < n; i++) {
cin >> a >> b;
vec.push_back(make_pair(a, b));
if (a <= l) {
dp[a][i][0] += 1;
dp[a][i][0] %= 1000000007;
}
if (a != b && b <= l) {
dp[b][i][1] += 1;
dp[b][i][1] %= 1000000007;
}
}
long long ans = 0;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
long long ans1 = dp[i][j][0] % 1000000007,
ans2 = dp[i][j][1] % 1000000007;
for (int k = 0; k < n; k++) {
if (k != j) {
if (vec[j].first == vec[j].second) {
if (i >= vec[j].first && vec[k].second == vec[j].first) {
ans1 += dp[i - vec[j].first][k][0] % 1000000007;
}
if (i >= vec[j].first && vec[k].second != vec[k].first &&
vec[k].first == vec[j].first)
ans1 += dp[i - vec[j].first][k][1] % 1000000007;
ans1 %= 1000000007;
} else {
if (i >= vec[j].first && vec[k].second == vec[j].first)
ans1 += dp[i - vec[j].first][k][0] % 1000000007;
if (i >= vec[j].first && vec[k].second != vec[k].first &&
vec[k].first == vec[j].first)
ans1 += dp[i - vec[j].first][k][1] % 1000000007;
if (i >= vec[j].second && vec[k].second == vec[j].second)
ans2 += dp[i - vec[j].second][k][0] % 1000000007;
if (i >= vec[j].second && vec[k].second != vec[k].first &&
vec[k].first == vec[j].second)
ans2 += dp[i - vec[j].second][k][1] % 1000000007;
ans1 %= 1000000007;
ans2 %= 1000000007;
}
}
}
dp[i][j][0] = ans1;
dp[i][j][1] = ans2;
if (i == l) {
ans += dp[l][j][0] % 1000000007;
ans += dp[l][j][1] % 1000000007;
ans % 1000000007;
}
}
}
cout << ans % 1000000007 << endl;
}
int main() {
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans, n, l, cnt, a[210], x[210], y[210], z[210], f[3010][210];
int main() {
cin >> n >> l;
for (int i = 1; i <= n; i++) {
z[++cnt] = i;
cin >> x[cnt] >> y[cnt];
if (x[cnt] != y[cnt]) {
z[++cnt] = i;
x[cnt] = y[cnt - 1];
y[cnt] = x[cnt - 1];
}
}
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= cnt; j++) {
for (int k = 0; k <= cnt; k++) {
if (z[j] == z[k]) continue;
if (!k && x[j] == i)
f[i][j]++;
else if (x[j] == y[k] && i > x[j]) {
f[i][j] = (f[i][j] + f[i - x[j]][k]) % 1000000007;
}
}
}
}
for (int i = 1; i <= cnt; i++) ans = (ans + f[l][i]) % 1000000007;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void prepare() {}
int n, l;
int a[1001];
int b[1001];
int dp[3010][101][101];
int mod = 1000000007;
void readdata() {
scanf("%d %d", &n, &l);
for (int i = 0; i < (int)(n); i++) {
scanf("%d %d", a + i, b + i);
}
}
void writedata() {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 100; j++) {
ans = (ans + dp[l][i][j]) % mod;
}
}
printf("%d\n", ans);
}
void solve() {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < (int)(n); i++) {
dp[a[i]][i][b[i]] = 1;
dp[b[i]][i][a[i]] = 1;
}
for (int i = (int)(2); i <= (int)(l); i++) {
for (int j = 0; j < n; j++) {
int s1 = 0, s2 = 0;
for (int k = 0; k < n; k++) {
if (k == j) continue;
if (i - a[j] > 0) s1 = (s1 + dp[i - a[j]][k][a[j]]) % mod;
if (i - b[j] > 0) s2 = (s2 + dp[i - b[j]][k][b[j]]) % mod;
}
dp[i][j][b[j]] += s1;
if (a[j] != b[j]) dp[i][j][a[j]] += s2;
}
}
}
int main() {
prepare();
readdata();
solve();
writedata();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int *pa = new int[200005];
int *na = new int[200005];
int *p1 = new int[200005];
int *p2 = new int[200005];
int main() {
int m1 = 1, m2 = 1, c1, c2, fs[5005], ls[5005], n, k[5005], x[5005], y[5005],
m[5005], i, j;
long long all = 0, q, nn, xx, yy, ans = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> k[i] >> fs[i] >> x[i] >> y[i] >> m[i];
all += k[i];
}
q = fs[1];
p1[1] = fs[1];
for (i = 2; i <= k[1]; i++) {
xx = x[1];
yy = y[1];
nn = (q * xx + yy) % m[1];
p1[i] = nn;
q = nn;
}
q = fs[2];
p2[1] = fs[2];
for (i = 2; i <= k[2]; i++) {
xx = x[2];
yy = y[2];
nn = (q * xx + yy) % m[2];
p2[i] = nn;
q = nn;
}
q = -1;
for (i = 1; i <= all; i++) {
if (m1 <= k[1])
c1 = p1[m1];
else
c1 = 2000000000;
if (m2 <= k[2])
c2 = p2[m2];
else
c2 = 2000000000;
if ((c1 != 2000000000) &&
(((c1 >= c2) && (c1 >= q) && (c2 < q)) || (c2 == 2000000000) ||
((c1 <= c2) && (c1 >= q)) || ((c1 <= c2) && (c2 < q)))) {
if (c1 < q) ans++;
q = c1;
if (all <= 200000) {
pa[i] = p1[m1];
na[i] = 1;
}
m1++;
} else {
if (c2 < q) ans++;
q = c2;
if (all <= 200000) {
pa[i] = p2[m2];
na[i] = 2;
}
m2++;
}
}
cout << ans << endl;
if (all <= 200000) {
for (i = 1; i <= all; i++) cout << pa[i] << " " << na[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a, x, y, m;
int k[5005];
int ind[5005];
vector<int> problems[5005];
pair<int, int> ans[200001];
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%I64d%I64d%I64d%I64d", &k[i], &a, &x, &y, &m);
problems[i].push_back(a);
for (j = 1; j < k[i]; j++) {
a = (a * x + y) % m;
problems[i].push_back(a);
}
ind[i] = 0;
}
int bef = 0;
int last = 0;
int bad = 0;
int best, idx;
while (true) {
best = 1000000001;
for (i = 0; i < n; i++) {
if (ind[i] < k[i] && problems[i][ind[i]] < best &&
problems[i][ind[i]] >= bef) {
best = problems[i][ind[i]];
idx = i;
}
}
if (best == 1000000001) {
for (i = 0; i < n; i++) {
if (ind[i] < k[i] && problems[i][ind[i]] < best) {
best = problems[i][ind[i]];
idx = i;
}
}
bad++;
}
if (best == 1000000001) break;
bef = problems[idx][ind[idx]];
ind[idx]++;
if (last <= 200000) ans[last++] = make_pair(bef, idx);
}
printf("%d\n", --bad);
if (last <= 200000) {
for (i = 0; i < last; i++)
printf("%d %d\n", ans[i].first, ans[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > v;
int main() {
int i, j, k, a, x, y, m, p, b, n = 0, ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d%d%d%d", &k, &a, &x, &y, &m);
p = 0;
b = 0;
for (j = 1; j <= k; j++) {
if (a < b) p++;
if (v.size() <= 200000) v.push_back(make_pair(make_pair(p, a), i));
b = a;
a = ((long long)a * x + y) % m;
}
if (p > ans) ans = p;
}
printf("%d\n", ans);
if (v.size() <= 200000) {
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++)
printf("%d %d\n", v[i].first.second, v[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[3][200200], n, k[3], b[3], second = 0;
vector<pair<long long, long long> > p;
void read(void) {
cin >> n;
for (int i = 0, x, y, m; i < n; ++i) {
cin >> k[i];
second += k[i];
cin >> a[i][0];
cin >> x >> y >> m;
for (int j = 1; j < k[i]; ++j) a[i][j] = (a[i][j - 1] * x + y) % m;
}
}
void kill(void) {
long long ans = 0, la = -1;
for (int i = 0; i < second; ++i) {
long long ma = 2000200200123LL, mi = 2000200200123LL, ta = -1, ti = -1, m,
t;
for (int j = 0; j < n; ++j) {
if (b[j] < k[j] && a[j][b[j]] >= la && a[j][b[j]] < ma)
ta = j, ma = a[j][b[j]];
if (b[j] < k[j] && a[j][b[j]] < mi) mi = a[j][b[j]], ti = j;
}
if (ta >= 0)
t = ta, m = ma;
else
t = ti, m = mi;
if (la > m) ans++;
la = m;
if (second <= 200000) p.push_back(make_pair(m, t));
b[t]++;
}
cout << ans << "\n";
for (int i = 0; i < (int)p.size(); ++i)
cout << p[i].first << " " << p[i].second + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
read();
kill();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
tuple<long long, long long, long long> p[200010];
int n;
cin >> n;
long long k, a, x, y, m;
long long b;
long long ans = 0;
long long cnt = 0;
long long sm = 0;
for (int i = 0; i < n; i++) {
cin >> k >> a >> x >> y >> m;
long long t = 0;
sm += k;
for (int j = 0; j < k; j++) {
if (cnt <= 200000) p[cnt++] = {t, a, i};
b = (a * x + y) % m;
if (b < a && j != k - 1) t++;
a = b;
}
ans = max(ans, t);
}
cout << ans << endl;
if (cnt <= 200000) {
sort(p, p + cnt,
[](tuple<long long, long long, long long> &a,
tuple<long long, long long, long long> &b) -> bool {
if (get<0>(a) == get<0>(b)) {
return get<1>(a) < get<1>(b) ||
(get<1>(a) == get<1>(b) && get<2>(a) < get<2>(b));
}
return get<0>(a) < get<0>(b);
});
for (int i = 0; i < cnt; i++) {
cout << get<1>(p[i]) << " " << get<2>(p[i]) + 1 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
struct Node {
int id, cost, cnt;
Node(int _i, int _cost, int _cnt) {
id = _i;
cost = _cost;
cnt = _cnt;
}
bool operator<(const Node &n) const {
if (cnt != n.cnt)
return cnt < n.cnt;
else
return cost < n.cost;
}
};
vector<Node> ans;
int main() {
int ret = 0, n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k, v, x, y, m, pre = -1, idx = 1;
scanf("%d %d %d %d %d", &k, &v, &x, &y, &m);
for (int j = 0; j < k; j++) {
if (v < pre) idx++;
ans.push_back(Node(i + 1, v, idx));
pre = v;
v = (v * 1LL * x + y) % m;
}
ret = max(ret, idx - 1);
}
printf("%d\n", ret);
if (ans.size() <= 200000) {
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].cost, ans[i].id);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2036000;
const long long INF = 199999999999LL;
int n, m;
long long a[N], b[N];
long long first, second, mod;
long long w[N], t[N];
int nn;
void AddA(int &i) {
w[nn] = a[i++];
t[nn++] = 1;
}
void AddB(int &j) {
w[nn] = b[j++];
t[nn++] = 2;
}
int main() {
cin >> n;
cin >> n >> a[0] >> first >> second >> mod;
for (int i = (1); i < (int)(n); i++) a[i] = (a[i - 1] * first + second) % mod;
cin >> m >> b[0] >> first >> second >> mod;
for (int j = (1); j < (int)(m); j++) b[j] = (b[j - 1] * first + second) % mod;
int i = 0, j = 0;
nn = 0;
long long lt = -INF;
while (i < n || j < m) {
if (i == n) {
AddB(j);
} else if (j == m) {
AddA(i);
} else {
bool ga = a[i] >= lt;
bool gb = b[j] >= lt;
if (ga ^ gb) {
if (ga) {
AddA(i);
} else {
AddB(j);
}
} else {
if (a[i] < b[j]) {
AddA(i);
} else {
AddB(j);
}
}
}
lt = w[nn - 1];
}
int bad = 0;
for (int k = (1); k < (int)(nn); k++) bad += (w[k] < w[k - 1]);
cout << bad << endl;
if (n + m <= 200000) {
for (int k = (0); k < (int)(nn); k++) cout << w[k] << " " << t[k] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5;
const int inf = 1e9;
vector<pair<int, int> > basket[maxn];
int tmp[maxn];
int main() {
int n, cur, mxCur = 0, x, y, m, k, sumK = 0;
scanf("%d", &n);
for (int j = 0; j < n; j++) {
scanf("%d%d%d%d%d", &k, &tmp[0], &x, &y, &m);
sumK += k;
for (int i = 1; i < k; i++) {
tmp[i] = (tmp[i - 1] * 1ll * x + y) % m;
}
cur = 0;
for (int i = 0; i < k; i++) {
if (i > 0 && tmp[i - 1] > tmp[i]) cur++;
if (sumK <= 200000) basket[cur].push_back(make_pair(tmp[i], j));
}
mxCur = max(mxCur, cur);
}
printf("%d\n", mxCur);
for (int i = 0; i <= mxCur; i++) {
sort(basket[i].begin(), basket[i].end());
for (int j = 0; j < (int)basket[i].size(); j++)
if (sumK <= 200000)
printf("%d %d\n", basket[i][j].first, basket[i][j].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum { MAXN = 5050, MAXK = 200010 };
int cnum[MAXN], pval[MAXN], x[MAXN], y[MAXN], m[MAXN], ctot[MAXN];
pair<int, int> res[MAXK];
void solveA(int n, int sumk) {
set<pair<int, int> > snum;
int ans = 0;
for (int i = 0; i < n; i++) {
snum.insert(pair<int, int>(pval[i], i));
ctot[i] = 0;
}
for (int i = 0, lst = 0; i < sumk; i++) {
set<pair<int, int> >::iterator pos =
snum.lower_bound(pair<int, int>(lst, 0));
if (pos == snum.end()) {
pos = snum.begin();
++ans;
}
res[i] = *pos;
snum.erase(pos);
lst = res[i].first;
const int &p = res[i].second;
if (++ctot[p] < cnum[p]) {
snum.insert(
pair<int, int>(((long long)res[i].first * x[p] + y[p]) % m[p], p));
}
}
printf("%d\n", ans);
for (int i = 0; i < sumk; i++)
printf("%d %d\n", res[i].first, res[i].second + 1);
}
void solveB(int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 1, v = pval[i], nv; j < cnum[i]; j++) {
nv = ((long long)v * x[i] + y[i]) % m[i];
if (nv < v) ++cnt;
v = nv;
}
ans = max(cnt, ans);
}
printf("%d\n", ans);
}
int main() {
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d%d", &cnum[i], &pval[i], &x[i], &y[i], &m[i]);
sum += cnum[i];
}
if (sum <= 200000)
solveA(n, sum);
else
solveB(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 1, 0, 0, 0, 0, 0, 0};
int dy[] = {0, 0, 1, -1, 0, 0, 0, 0};
const long long inf = 100000007;
const double eps = 0.000000009;
long long mod = 1000000007;
map<char, int> m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long k1, a1, x1, y1, m1;
cin >> k1 >> a1 >> x1 >> y1 >> m1;
long long k2, a2, x2, y2, m2;
cin >> k2 >> a2 >> x2 >> y2 >> m2;
long long a[k1], b[k2];
a[0] = a1;
b[0] = a2;
for (int i = 1; i < k1; i++) {
a[i] = (a[i - 1] * x1 + y1) % m1;
}
for (int i = 1; i < k2; i++) {
b[i] = (b[i - 1] * x2 + y2) % m2;
}
vector<pair<long long, long long> > sol;
long long p1 = 0, p2 = 0;
while (p1 < k1 && p2 < k2) {
if (a[p1] < b[p2]) {
if (sol.size() == 0) {
sol.push_back(make_pair(a[p1], 1));
p1++;
continue;
}
if (a[p1] >= sol[sol.size() - 1].first ||
(sol.size() > 0 && b[p2] < sol[sol.size() - 1].first)) {
sol.push_back(make_pair(a[p1], 1));
p1++;
} else {
sol.push_back(make_pair(b[p2], 2));
p2++;
}
} else {
if (sol.size() == 0) {
sol.push_back(make_pair(b[p2], 2));
p2++;
continue;
}
if (b[p2] >= sol[sol.size() - 1].first ||
((sol.size() > 0) && a[p1] < sol[sol.size() - 1].first)) {
sol.push_back(make_pair(b[p2], 2));
p2++;
} else {
sol.push_back(make_pair(a[p1], 1));
p1++;
}
}
}
while (p1 < k1) {
sol.push_back(make_pair(a[p1], 1));
p1++;
}
while (p2 < k2) {
sol.push_back(make_pair(b[p2], 2));
p2++;
}
long long ans = 0;
for (int i = 1; i < k1 + k2; i++) {
if (sol[i - 1].first > sol[i].first) {
ans++;
}
}
cout << ans << endl;
if (k1 + k2 <= 200000) {
for (int i = 0; i < k1 + k2; i++)
cout << sol[i].first << " " << sol[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int prime = 1003800021;
const int MOD = 1103800039;
int n, k, sumk, maxk, cnt;
long long a, x, y, m;
vector<vector<long long> > vec;
vector<vector<unsigned long long> > h;
unsigned long long pw[1 << 18];
vector<pair<int, int> > ans;
int idx[1 << 13];
inline unsigned long long getHash(int row, int le, int ri) {
if (!le) return h[row][ri];
return (h[row][ri] - h[row][le - 1] * pw[ri - le + 1] % MOD + MOD) % MOD;
}
struct cmp {
bool operator()(pair<int, int> a, pair<int, int> b) {
int i = a.first, j = b.first;
int l1 = a.second, l2 = b.second;
int lo = 1, hi = min(vec[i].size() - l1, vec[j].size() - l2), mid;
int lcp = 0;
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (getHash(i, l1, l1 + mid - 1) == getHash(j, l2, l2 + mid - 1)) {
lcp = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
if (l1 + lcp >= vec[i].size()) return false;
if (l2 + lcp >= vec[j].size()) return true;
int num1 = vec[i][l1 + lcp], num2 = vec[j][l2 + lcp];
return num1 > num2;
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, cmp> pq;
void build(int idx) {
vec[idx].resize(k);
for (int i = 0; i < k; i++) {
vec[idx][i] = a;
a = (a * x + y) % m;
}
}
void read() {
scanf("%d", &n);
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> k >> a >> x >> y >> m;
build(i);
sumk += k;
if (maxk < k) maxk = k;
}
}
void solve() {
int last = -1;
int br = 0;
while (1) {
if (br == sumk) break;
br++;
int row = -1;
for (int i = 0; i < n; i++)
if (idx[i] < vec[i].size() && vec[i][idx[i]] >= last) {
if (row == -1)
row = i;
else {
if (vec[i][idx[i]] < vec[row][idx[row]]) row = i;
}
}
if (row == -1) {
cnt++;
for (int i = 0; i < n; i++)
if (idx[i] < vec[i].size()) {
if (row == -1)
row = i;
else {
if (vec[i][idx[i]] < vec[row][idx[row]]) row = i;
}
}
}
ans.push_back(make_pair(vec[row][idx[row]], row + 1));
last = vec[row][idx[row]];
idx[row]++;
}
printf("%d\n", cnt);
if (sumk <= 200000) {
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxSize = 200010;
int n, m;
vector<pair<int, int> > V[MaxSize];
int main() {
if (0) {
freopen("t.in", "r", stdin);
freopen("t.out", "w", stdout);
}
int K, a, x, y, P, t, i, j, c, ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d%d%d%d", &K, &a, &x, &y, &P);
if (c = 0, m < MaxSize) V[0].push_back(pair<int, int>(a, i)), ++m;
while (--K) {
if (t = ((long long)a * x + y) % P, t < a) ++c;
if (a = t, m < MaxSize) V[c].push_back(pair<int, int>(a, i)), ++m;
}
ans = max(ans, c);
}
printf("%d\n", ans);
if (m > 200000) return 0;
for (i = 0; i <= ans; ++i) {
vector<pair<int, int> >& V = ::V[i];
sort(V.begin(), V.end());
for (j = 0; j < V.size(); ++j) printf("%d %d\n", V[j].first, V[j].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll N = 2e5 + 5, MAX = 2e5;
struct node {
ll sci, cost, index;
explicit node(int s = 0, int c = 0, int i = 0) : sci(s), cost(c), index(i) {}
friend bool operator<(node& x, node& y) {
if (x.index == y.index) {
return x.cost < y.cost || (x.cost == y.cost && x.sci < y.sci);
} else {
return x.index < y.index;
}
}
} arr[N], tmp[N];
void merge(int l, int r) {
int mid = (l + r) / 2;
int i = l, j = mid + 1;
for (int k = l; k <= r; ++k) {
if (j > r || (i <= mid && arr[i] < arr[j])) {
tmp[k] = arr[i];
++i;
} else {
tmp[k] = arr[j];
++j;
}
}
for (int k = l; k <= r; ++k) {
arr[k] = tmp[k];
}
}
void merge_sort(int l, int r) {
if (l < r) {
int mid = (l + r) / 2;
merge_sort(l, mid);
merge_sort(mid + 1, r);
merge(l, r);
}
}
ll n, k, a, b, x, y, m, len, ans, t;
int main() {
ios::sync_with_stdio(false);
cin >> n;
ans = 0;
for (ll i = 1; i <= n; ++i) {
cin >> k >> a >> x >> y >> m;
t = 0;
for (ll j = 1; j <= k; ++j) {
if (len < MAX)
arr[++len] = node(i, a, t);
else
++len;
b = (a * x % m + y) % m;
if (a > b && j != k) ++t;
a = b;
}
ans = max(ans, t);
}
cout << ans << endl;
if (len <= MAX) {
merge_sort(1, len);
for (int i = 1; i <= len; ++i) {
cout << arr[i].cost << ' ' << arr[i].sci << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int n;
int a[3][200111], sz[3];
vector<pair<int, int> > save;
int main() {
while (scanf("%d", &n) == 1) {
for (int i = (1), _b = (n); i <= _b; i++) {
scanf("%d%d", &sz[i], &a[i][1]);
int x, y, m;
scanf("%d%d%d", &x, &y, &m);
for (int j = (2), _b = (sz[i]); j <= _b; j++) {
a[i][j] = (a[i][j - 1] * (long long)x + y) % m;
}
}
int x = 1, y = 1, res = 0, last = -1, type;
save.clear();
while (x <= sz[1] || y <= sz[2]) {
int cur;
if (x > sz[1])
cur = a[type = 2][y++];
else if (y > sz[2])
cur = a[type = 1][x++];
else if (a[1][x] >= last && a[2][y] >= last) {
if (a[1][x] < a[2][y])
cur = a[type = 1][x++];
else
cur = a[type = 2][y++];
} else if (a[1][x] >= last)
cur = a[type = 1][x++];
else if (a[2][y] >= last)
cur = a[type = 2][y++];
else {
if (a[1][x] < a[2][y])
cur = a[type = 1][x++];
else
cur = a[type = 2][y++];
}
if (cur < last) ++res;
last = cur;
save.push_back(make_pair(cur, type));
}
printf("%d\n", res);
if (save.size() <= 200000)
for (int i = 0, _a = (save.size()); i < _a; i++)
printf("%d %d\n", save[i].first, save[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a1, a2, n, k, second = 0, ans = 0, ans1;
vector<pair<long long, pair<long long, long long> > > h;
void read(void) {
cin >> n;
for (int i = 0, x, y, m; i < n; ++i) {
cin >> k;
second += k;
cin >> a1;
long long t = a1;
cin >> x >> y >> m;
h.push_back(make_pair(0, make_pair(a1, i + 1)));
ans1 = 0;
for (int j = 1; j < k; ++j) {
a2 = (a1 * x + y) % m;
if (a2 < a1) ans1++;
a1 = a2;
t = max(t, a1);
if (h.size() <= 200000)
h.push_back(make_pair(ans1, make_pair(a1, i + 1)));
}
ans = max(ans, ans1);
}
sort(h.begin(), h.end());
cout << ans << "\n";
if (second <= 200000)
for (int i = 0; i < second; ++i)
cout << h[i].second.first << " " << h[i].second.second << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
read();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int ki[(4)];
vector<int> A[(4)];
vector<int> sol;
int main() {
int i, j;
scanf("%d", &N);
for (i = 0; i < N; ++i) {
int a, b, c, d, e;
scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);
long long x, y, m;
A[i].resize(a);
ki[i] = a;
A[i][0] = b;
x = c;
y = d;
m = e;
for (j = 1; j < a; ++j) A[i][j] = ((long long)A[i][j - 1] * x + y) % m;
}
i = 0;
j = 0;
int last = 0;
int bad = 0;
int sa = ((ki[0] + ki[1]) <= 200000);
while (i < ki[0] || j < ki[1]) {
int a;
if (j == ki[1]) {
a = A[0][i++];
if (sa) sol.push_back(0);
} else if (i == ki[0]) {
a = A[1][j++];
if (sa) sol.push_back(1);
} else {
int b = A[0][i];
int c = A[1][j];
if (b >= last) {
if (c >= last) {
if (b <= c) {
a = b;
++i;
if (sa) sol.push_back(0);
} else {
a = c;
++j;
if (sa) sol.push_back(1);
}
} else {
a = b;
++i;
if (sa) sol.push_back(0);
}
} else {
if (c < last) {
if (b <= c) {
a = b;
++i;
if (sa) sol.push_back(0);
} else {
a = c;
++j;
if (sa) sol.push_back(1);
}
} else {
a = c;
++j;
if (sa) sol.push_back(1);
}
}
}
if (last > a) ++bad;
last = a;
}
printf("%d\n", bad);
if (sa) {
int sz = sol.size();
j = 0;
int k = 0;
for (i = 0; i < sz; ++i) {
if (sol[i] == 0)
printf("%d 1\n", A[0][j++]);
else
printf("%d 2\n", A[1][k++]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > v;
int main() {
int n, i, j, k, a, x, y, m, p, b, ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d%d%d%d", &k, &a, &x, &y, &m);
p = b = 0;
for (j = 1; j <= k; j++) {
if (a < b) p++;
if (v.size() <= 200000) v.push_back(make_pair(make_pair(p, a), i));
b = a;
a = ((long long)a * x + y) % m;
}
if (p > ans) ans = p;
}
printf("%d\n", ans);
if (v.size() <= 200000) {
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++)
printf("%d %d\n", v[i].first.second, v[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3, MAXM = 200005;
int l[MAXN], a[MAXN][MAXM];
int now[MAXN];
int ans[MAXN * MAXM][2], ansn = 0;
int sk;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &l[i]);
scanf("%d", &a[i][1]);
int x, y, m;
scanf("%d%d%d", &x, &y, &m);
for (int j = 2; j <= l[i]; j++)
a[i][j] = (a[i][j - 1] * (long long)x + y) % m;
sk += l[i];
}
int last = -1;
for (int i = 1; i <= sk; i++) {
int best = -1;
for (int j = 1; j <= n; j++)
if (now[j] < l[j] && a[j][now[j] + 1] >= last &&
(best == -1 || a[j][now[j] + 1] < a[best][now[best] + 1]))
best = j;
if (best == -1) {
ansn++;
for (int j = 1; j <= n; j++)
if (now[j] < l[j] &&
(best == -1 || a[j][now[j] + 1] < a[best][now[best] + 1]))
best = j;
}
last = a[best][now[best] + 1];
ans[i][0] = last;
ans[i][1] = best;
now[best]++;
}
printf("%d\n", ansn);
if (sk <= 200000)
for (int i = 1; i <= sk; i++) printf("%d %d\n", ans[i][0], ans[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> ans[200005];
int main() {
int n, mx = 0, cur = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k, c, x, y, m, cnt = 0;
scanf("%d%d%d%d%d", &k, &c, &x, &y, &m);
while (k--) {
if (cur <= 200000) ans[cur++] = make_pair(make_pair(cnt, c), i);
long long b = ((long long)c * x + y) % m;
if (b < c && k) cnt++;
mx = max(mx, cnt);
c = b;
}
}
printf("%d\n", mx);
if (cur <= 200000) {
sort(ans, ans + cur);
for (int i = 0; i < cur; i++)
printf("%d %d\n", ans[i].first.second, ans[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct mu {
int flo, cost, id;
} ans[200005];
int n;
long long k, a, x, y, m, b, endd = 0, sum = -1, t;
bool cmp(mu u, mu v) {
if (u.flo == v.flo)
return (u.cost < v.cost || (u.cost == v.cost && u.id < v.id));
return u.flo < v.flo;
}
int main() {
ios::sync_with_stdio(false);
int i = 0, j = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> k >> a >> x >> y >> m;
t = 0;
for (j = 1; j <= k; j++) {
if (endd <= 200000) {
ans[endd].flo = t;
ans[endd].cost = a;
ans[endd++].id = i;
}
b = (a * x + y) % m;
if (j != k && b < a) t++;
a = b;
sum = max(sum, t);
}
}
cout << sum << endl;
if (endd <= 200000) {
sort(ans, ans + endd, cmp);
for (i = 0; i < endd; i++) printf("%d %d\n", ans[i].cost, ans[i].id);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge>> adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
Graph() { adj.clear(); }
void resize(int n) { adj.resize(n + 5); }
void add(int s, edge e) { adj[s].push_back(e); }
void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
int deg(int v) { return adj[v].size(); }
vector<edge> &operator[](int t) { return adj[t]; }
};
const int maxn = 2200, lmt = 200000;
queue<int> vec[maxn];
int main() {
ios_base::sync_with_stdio(false);
int n, lx = -1, ans = 0;
cin >> n;
vector<pair<int, int>> out;
set<pair<int, int>> S;
for (int i = 1; i <= n; ++i) {
int k, a, x, y, m;
cin >> k >> a >> x >> y >> m;
S.insert(make_pair(a, i));
for (; --k;) vec[i].push(a = ((long long)a * x + y) % m);
}
for (; !S.empty();) {
auto it = S.lower_bound(make_pair(lx, 0));
if (it == S.end()) it = S.begin();
auto x = *it;
S.erase(it);
if ((int)((out).size()) <= lmt) out.push_back(x);
if (!vec[x.second].empty())
S.insert(make_pair(vec[x.second].front(), x.second)), vec[x.second].pop();
ans += lx > x.first, lx = x.first;
}
cout << ans << endl;
if ((int)((out).size()) <= lmt)
for (auto &x : out) cout << x.first << " " << x.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, N, Num, Sum, S, Ans, len, len1, size, K, X, Y, M;
int Q[5005], P[5005], C[200005], A[200005], B[200005];
int cmp(const int &i, const int &j) { return A[i] < A[j]; }
int main() {
scanf("%d", &N);
for (i = 1; i <= N; ++i) {
Num = Num % 200000 + 1, ++Sum;
scanf("%d%d%d%d%d", &K, &A[Num], &X, &Y, &M);
S = 0, P[i] = Num, B[Num] = i;
for (j = 2; j <= K; ++j) {
++Sum;
A[Num % 200000 + 1] =
((long long)A[Num] * (long long)X + (long long)Y) % (long long)M;
B[Num % 200000 + 1] = i;
if (A[Num % 200000 + 1] < A[Num]) ++S;
Num = Num % 200000 + 1;
}
if (S > Ans) Ans = S;
}
printf("%d\n", Ans);
if (Sum <= 200000) {
for (i = 1; i <= N; ++i) Q[i] = i;
len = N;
for (; Num != 0;) {
size = len1 = 0;
for (i = 1; i <= len; ++i) {
for (j = P[Q[i]]; B[j] == Q[i]; ++j) {
C[++size] = j;
if (A[j + 1] < A[j]) {
++j;
break;
}
}
P[Q[i]] = j;
if (B[j] == Q[i]) Q[++len1] = Q[i];
}
sort(C + 1, C + size + 1, cmp), Num -= size, len = len1;
for (i = 1; i <= size; ++i) printf("%d %d\n", A[C[i]], B[C[i]]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int cost, aut, ch;
} p[200005];
bool cmp(node a, node b) {
return (a.ch < b.ch || (a.ch == b.ch && a.cost < b.cost));
}
int main() {
int n, k;
long long c, cc, i, j, a, x, y, m, cha = 0, nn = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%I64d%I64d%I64d%I64d", &k, &a, &x, &y, &m);
for (j = 0, c = 0, cc = -1; j < k; ++j) {
if (a < cc) ++c;
if (nn <= 200000) {
p[nn].cost = a;
p[nn].aut = i;
p[nn++].ch = c;
}
cc = a;
a = (a * x + y) % m;
}
cha = max(cha, c);
}
printf("%I64d\n", cha);
if (nn <= 200000) {
sort(p, p + nn, cmp);
for (i = 0; i < nn; ++i) printf("%d %d\n", p[i].cost, p[i].aut);
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:256000000")
using namespace std;
const int N = 200100, M = 200500, INF = 1000 * 1000 * 1000 + 7;
const long double eps = 1e-9;
template <typename X>
X gcd(X a, X b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
template <typename V>
V dist(V x1, V y1, V x2, V y2) {
return ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int n;
vector<int> a[2];
bool read() {
if (scanf("%d", &n) != 1) {
return 0;
}
a[0].clear();
a[1].clear();
for (int i = 0; i < n; ++i) {
long long k, aa, x, y, m;
scanf("%I64d%I64d%I64d%I64d%I64d", &k, &aa, &x, &y, &m);
for (int j = 0; j < k; ++j) {
a[i].push_back(aa);
aa = (aa * x + y) % m;
}
}
return 1;
}
bool solve() {
if (!read()) return 0;
vector<pair<int, int>> ans;
int idx[2] = {0};
int prev = -1;
for (; idx[0] < a[0].size() && idx[1] < a[1].size();) {
set<pair<int, int>> k;
for (int i = 0; i < n; ++i)
if (a[i][idx[i]] >= prev) k.insert(make_pair(a[i][idx[i]], i));
if (k.size() != 0) {
ans.push_back(*k.begin());
idx[k.begin()->second]++;
prev = k.begin()->first;
} else {
for (int i = 0; i < n; ++i) k.insert(make_pair(a[i][idx[i]], i));
ans.push_back(*k.begin());
idx[k.begin()->second]++;
prev = k.begin()->first;
}
}
for (int i = 0; i < n; ++i)
for (; idx[i] < a[i].size(); idx[i]++) {
ans.push_back(make_pair(a[i][idx[i]], i));
}
int cnt = 0;
for (int i = 0; i < ans.size(); ++i) {
if (i + 1 < ans.size() && ans[i].first > ans[i + 1].first) {
cnt++;
}
}
printf("%d\n", cnt);
if (ans.size() <= 200000)
for (int i = 0; i < ans.size(); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second + 1);
}
return 1;
}
int main() {
while (solve())
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5;
pair<pair<long long, long long>, long long> a[MAX + 9];
long long n, k, a0, x, y, m, ans, cnt, t, tmp;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k >> a0 >> x >> y >> m, t = 0;
for (int j = 0; j < k; j++) {
if (cnt <= MAX) a[cnt++] = {{t, a0}, i};
tmp = (a0 * x + y) % m;
if (tmp < a0 && j != k - 1) t++;
a0 = tmp;
}
ans = max(ans, t);
}
cout << ans << '\n';
if (cnt <= MAX) {
sort(a, a + cnt);
for (int i = 0; i < cnt; i++)
cout << a[i].first.second << " " << a[i].second + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
int l[5010], r[5010], a[5010][5010], b[2][200010];
void solve() {
int sum = 0, i, j, m;
for (i = 0; i < 2; i++) {
int first, second;
scanf("%d%d%d%d%d", &l[i], &b[i][1], &first, &second, &m);
for (j = 2; j <= l[i]; j++)
b[i][j] = ((long long)b[i][j - 1] * first % m + second) % m;
sum += l[i];
}
int res = 0;
for (i = 0; i < 2; i++) {
m = 0;
for (j = 2; j <= l[i]; j++)
if (b[i][j] < b[i][j - 1]) m++;
res = max(res, m);
}
printf("%d\n", res);
if (sum > 200000) return;
s.clear();
for (i = 0; i < 2; i++) s.insert(make_pair(b[i][1], i)), r[i] = 1;
set<pair<int, int> >::iterator it;
int p = 0;
while (!s.empty()) {
it = s.lower_bound(make_pair(p, -1));
if (it == s.end()) it = s.begin();
s.erase(*it);
int first = it->first, second = it->second;
printf("%d %d\n", first, second + 1);
sum++;
p = first;
if (r[second] == l[second]) continue;
r[second]++;
s.insert(make_pair(b[second][r[second]], second));
}
}
int main() {
int i, j, k, n, m;
while (~scanf("%d", &n)) {
int sum = 0;
if (n == 2) {
solve();
continue;
}
for (i = 0; i < n; i++) {
int b, first, second;
scanf("%d%d%d%d%d", &l[i], &b, &first, &second, &m);
a[i][1] = b;
for (j = 2; j <= l[i]; j++)
a[i][j] = ((long long)a[i][j - 1] * first % m + second) % m;
sum += l[i];
}
int res = 0;
for (i = 0; i < n; i++) {
m = 0;
for (j = 2; j <= l[i]; j++)
if (a[i][j] < a[i][j - 1]) m++;
res = max(res, m);
}
printf("%d\n", res);
if (sum > 200000) continue;
s.clear();
for (i = 0; i < n; i++) s.insert(make_pair(a[i][1], i)), r[i] = 1;
set<pair<int, int> >::iterator it;
int p = 0;
while (!s.empty()) {
it = s.lower_bound(make_pair(p, -1));
if (it == s.end()) it = s.begin();
s.erase(*it);
int first = it->first, second = it->second;
printf("%d %d\n", first, second + 1);
sum++;
p = first;
if (r[second] == l[second]) continue;
r[second]++;
s.insert(make_pair(a[second][r[second]], second));
}
}
return 0;
}
|
#include <bits/stdc++.h>
int const maxscientists = 2;
int const maxprosize = 200000;
int scientists = 0;
int pro[maxscientists], x[maxscientists], y[maxscientists], m[maxscientists],
curindex[maxscientists];
long long a[maxscientists];
int bestmemindex[maxscientists * maxprosize];
int bestsciindex[maxscientists * maxprosize];
int main() {
int i, j, sciindex, k, totalpro = 0;
scanf("%d", &scientists);
for (i = 0; i < scientists; ++i) {
scanf("%d%I64d%d%d%d", &pro[i], &a[i], &x[i], &y[i], &m[i]);
totalpro += pro[i];
}
int pre = -1, result = 0, curtask = 0;
int leastindex = -1;
while (true) {
sciindex = -1;
leastindex = -1;
k = 1000000001;
for (i = 0; i < scientists; ++i) {
if (curindex[i] < pro[i]) {
if (leastindex == -1 || a[i] < a[leastindex]) leastindex = i;
if (a[i] >= pre && (sciindex == -1 || a[i] < a[sciindex])) sciindex = i;
}
}
if (sciindex == -1 && leastindex == -1) {
printf("%d\n", result);
if (totalpro <= 200000) {
for (i = 0; i < curtask; ++i)
printf("%d %d\n", bestmemindex[i], bestsciindex[i]);
}
return 0;
} else {
if (sciindex == -1) {
sciindex = leastindex;
if (sciindex == -1) {
printf("%d\n", result);
if (totalpro <= 200000) {
for (i = 0; i < curtask; ++i)
printf("%d %d\n", bestmemindex[i], bestsciindex[i]);
}
return 0;
}
}
k = a[sciindex];
bestmemindex[curtask] = k;
bestsciindex[curtask] = sciindex + 1;
a[sciindex] = (a[sciindex] * x[sciindex] + y[sciindex]) % m[sciindex];
++curtask;
if (pre > k) ++result;
pre = k;
++curindex[sciindex];
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5010;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
queue<long long> que[N];
struct data {
long long k;
int id;
data();
data(long long _k, int _id) : k(_k), id(_id) {}
bool operator<(const data &r) const {
if (k == r.k) return id < r.id;
return k < r.k;
}
};
vector<data> vt;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k;
long long a, x, y, m;
cin >> k >> a >> x >> y >> m;
for (int j = 0; j < k; j++) {
que[i].push(a);
a = (a * x + y) % m;
}
}
set<data> st;
for (int i = 0; i < n; i++) st.insert(data(que[i].front(), i));
long long pre = inf;
int ret = 0;
while (st.size()) {
set<data>::iterator it;
data tmp = data(pre, -1);
it = st.insert(tmp).first;
it++;
if (it == st.end()) {
set<data>::iterator bg = st.begin();
data hh = *bg;
vt.push_back(hh);
st.erase(*bg);
pre = hh.k;
ret++;
que[hh.id].pop();
if (que[hh.id].size()) st.insert(data(que[hh.id].front(), hh.id));
} else {
data hh = *it;
vt.push_back(hh);
st.erase(*it);
pre = hh.k;
que[hh.id].pop();
if (que[hh.id].size()) st.insert(data(que[hh.id].front(), hh.id));
}
st.erase(tmp);
}
cout << ret - 1 << endl;
int sz = vt.size();
if (sz <= 200000) {
for (int i = 0; i < sz; i++) cout << vt[i].k << " " << vt[i].id + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct scientist {
long long k, a, x, y, m, current_index;
bool change;
};
struct h {
long long value;
int index;
};
int N;
vector<scientist> scientists;
long long k, a, x, y, m;
long long answer = 0;
vector<h> heap1;
vector<h> heap2;
h prev_result;
vector<h> result;
void add(h value, vector<h>& heap) {
heap.push_back(value);
int n = (int)heap.size() - 1;
while (n > 0 && heap[(n - 1) / 2].value > heap[n].value) {
h tmp = heap[n];
heap[n] = heap[(n - 1) / 2];
heap[(n - 1) / 2] = tmp;
n = (n - 1) / 2;
}
}
void refresh(vector<h>& heap) {
int n = 0;
while ((2 * n + 1 < heap.size() && heap[n].value > heap[2 * n + 1].value) ||
(2 * n + 2 < heap.size() && heap[n].value > heap[2 * n + 2].value)) {
if (2 * n + 1 < heap.size() && heap[n].value > heap[2 * n + 1].value) {
h tmp = heap[n];
heap[n] = heap[2 * n + 1];
heap[2 * n + 1] = tmp;
n = 2 * n + 1;
} else {
h tmp = heap[n];
heap[n] = heap[2 * n + 2];
heap[2 * n + 2] = tmp;
n = 2 * n + 2;
}
}
}
int main(int argc, const char* argv[]) {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> k >> a >> x >> y >> m;
scientists.push_back({k, a, x, y, m, 0, false});
}
for (int i = 0; i < N; ++i) {
add({scientists[i].a, i}, heap1);
if (scientists[i].current_index < scientists[i].k) {
long long new_a = (scientists[i].a * scientists[i].x + scientists[i].y) %
scientists[i].m;
if (new_a < scientists[i].a)
scientists[i].change = true;
else
scientists[i].change = false;
scientists[i].a = new_a;
scientists[i].current_index++;
}
}
prev_result = {-1, -1};
while (heap1.size() > 0) {
while (heap1.size() > 0) {
h t = heap1[0];
heap1[0] = heap1.back();
heap1.pop_back();
if (result.size() <= 200000) {
result.push_back({t.value, t.index + 1});
}
if (prev_result.index != -1) {
if (prev_result.value > t.value) answer++;
}
prev_result = {t.value, t.index + 1};
refresh(heap1);
if (scientists[t.index].change) {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap2);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
} else {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap1);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
}
}
while (heap2.size() > 0) {
h t = heap2[0];
heap2[0] = heap2.back();
heap2.pop_back();
if (result.size() <= 200000) {
result.push_back({t.value, t.index + 1});
}
if (prev_result.index != -1) {
if (prev_result.value > t.value) answer++;
}
prev_result = {t.value, t.index + 1};
refresh(heap2);
if (scientists[t.index].change) {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap1);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
} else {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap2);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
}
}
}
cout << answer << endl;
if (result.size() <= 200000) {
for (int i = 0; i < result.size(); ++i) {
cout << result[i].value << " " << result[i].index << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2;
const int K = 400100;
int t[N][K];
int k[N];
int p[K][N];
int main() {
int n;
scanf("%d", &n);
int a, b, c;
for (int i = 0; i < n; i++) {
scanf("%d %d %d %d %d", &k[i], &t[i][1], &a, &b, &c);
for (int j = 2; j <= k[i]; j++) {
t[i][j] = (int)(((long long)t[i][j - 1] * (long long)a + (long long)b) %
(long long)c);
}
}
int ans = 0, cnt = 0;
int t1 = 1, t2 = 1;
int top = -1;
while (true) {
if (t1 <= k[0] && top <= t[0][t1]) {
if (t2 <= k[1] && top <= t[1][t2] && t[1][t2] < t[0][t1]) {
top = p[cnt][0] = t[1][t2++];
p[cnt++][1] = 2;
} else {
top = p[cnt][0] = t[0][t1++];
p[cnt++][1] = 1;
}
} else if (t2 <= k[1] && top <= t[1][t2]) {
top = p[cnt][0] = t[1][t2++];
p[cnt++][1] = 2;
} else if (t1 <= k[0] && t2 <= k[1]) {
ans++;
if (t[0][t1] <= t[1][t2]) {
top = p[cnt][0] = t[0][t1++];
p[cnt++][1] = 1;
} else {
top = p[cnt][0] = t[1][t2++];
p[cnt++][1] = 2;
}
} else if (t1 <= k[0]) {
ans++;
top = p[cnt][0] = t[0][t1++];
p[cnt++][1] = 1;
} else if (t2 <= k[1]) {
ans++;
top = p[cnt][0] = t[1][t2++];
p[cnt++][1] = 2;
} else
break;
}
printf("%d\n", ans);
if (cnt <= 200000) {
for (int i = 0; i < cnt; i++) {
printf("%d %d\n", p[i][0], p[i][1]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
priority_queue<pair<int, int> > q;
vector<int> a[200020];
int cnt[200020];
vector<pair<int, int> > vt;
int main() {
scanf("%d", &n);
int ans = 0;
int sum = 0;
for (int i = 1; i <= n; ++i) {
int k, a1, x, y, m;
scanf("%d%d%d%d%d", &k, &a1, &x, &y, &m);
a[i].resize(k);
sum += k;
a[i][0] = a1;
for (int j = 1; j < k; ++j) {
a[i][j] = (1LL * a[i][j - 1] * x + y) % m;
}
}
while (sum > 0) {
ans++;
for (int i = 1; i <= n; ++i) {
if (cnt[i] < a[i].size()) {
q.push(make_pair(-a[i][cnt[i]], i));
}
}
while (!q.empty()) {
int val = -q.top().first;
int id = q.top().second;
q.pop();
cnt[id]++;
if (cnt[id] < a[id].size() && a[id][cnt[id]] >= a[id][cnt[id] - 1]) {
q.push(make_pair(-a[id][cnt[id]], id));
}
vt.push_back(make_pair(val, id));
sum--;
}
}
printf("%d\n", ans - 1);
if (vt.size() > 200000) return 0;
for (auto v : vt) printf("%d %d\n", v.first, v.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > out;
vector<pair<int, int> >::iterator iter;
long long int a[3][200005];
int main() {
long long int x[3], y[3], m[3];
int k[3], i, j, bad = 0, prev = 0, n, u = 1, v = 1;
bool A, B;
scanf("%d", &n);
for (i = 1; i <= 2; i++) {
scanf("%d%I64d%I64d%I64d%I64d", &k[i], &a[i][1], &x[i], &y[i], &m[i]);
for (j = 2; j <= k[i]; j++) a[i][j] = (a[i][j - 1] * x[i] + y[i]) % m[i];
}
for (i = 1; i <= k[1] + k[2]; i++) {
A = B = false;
if (((u <= k[1] && a[1][u] < prev) && (v <= k[2] && a[2][v] < prev)) ||
(v > k[2] && a[1][u] < prev) || (u > k[1] && a[2][v] < prev)) {
bad++;
if ((u <= k[1] && a[1][u] < a[2][v]) || v > k[2])
A = true;
else
B = true;
}
if (u <= k[1] && !B &&
(((a[2][v] < prev) || A) ||
((v > k[2]) || (a[1][u] >= prev && a[1][u] < a[2][v])))) {
if (k[1] + k[2] <= 200000) out.push_back(make_pair(a[1][u], 1));
prev = a[1][u];
u++;
} else {
if (k[1] + k[2] <= 200000) out.push_back(make_pair(a[2][v], 2));
prev = a[2][v];
v++;
}
}
printf("%d\n", bad);
if (k[1] + k[2] <= 200000) {
for (iter = out.begin(); iter != out.end(); iter++)
printf("%d %d\n", iter->first, iter->second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
struct uz {
long long k, l, id, cnt;
long long x, y, m;
int i = 1;
void add() {
l = (l * x + y) % m;
i++;
}
} u[35];
vector<pair<long long, long long>> ans;
int main() {
scanf("%d", &n);
long long aa = 0, sumk = 0;
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%lld%lld%lld%lld%lld", &u[i].k, &u[i].l, &u[i].x, &u[i].y, &u[i].m);
sumk += u[i].k;
}
while (1) {
long long start = ans.size();
for (int(i) = 0; (i) < (int)(n); (i)++) {
while (u[i].i <= u[i].k) {
ans.push_back({u[i].l, i});
u[i].add();
if (ans.back().first > u[i].l) break;
}
}
if (start == ans.size()) break;
sort(ans.begin() + start, ans.end());
if (start != 0) aa++;
}
printf("%lld\n", aa);
if (sumk <= 200000) {
for (auto p : ans) printf("%lld %lld\n", p.first, p.second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int N;
int c[2][MAXN];
int idx[2];
pair<int, int> p[MAXN];
int pn;
long long solve() {
long long ret = 0;
int pre = -1;
for (int i = 0; i < N; ++i) idx[i] = 1;
while (1) {
int opt = 1000000007, x = -1;
for (int i = 0; i < N; ++i) {
if (idx[i] <= c[i][0]) {
if (c[i][idx[i]] < opt && c[i][idx[i]] >= pre) {
opt = c[i][idx[i]];
x = i;
}
}
}
if (x != -1) {
pre = opt;
if (pn < MAXN - 3) p[pn++] = make_pair(opt, x + 1);
++idx[x];
continue;
}
opt = 1000000007, x = -1;
for (int i = 0; i < N; ++i) {
if (idx[i] <= c[i][0]) {
if (c[i][idx[i]] < opt) {
opt = c[i][idx[i]];
x = i;
}
}
}
if (x == -1) return ret;
ret += opt < pre;
pre = opt;
if (pn < MAXN - 3) p[pn++] = make_pair(opt, x + 1);
++idx[x];
}
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> c[i][0] >> c[i][1];
int x, y, m;
cin >> x >> y >> m;
for (int j = 2; j <= c[i][0]; ++j) {
c[i][j] = (1LL * c[i][j - 1] * x + y) % m;
}
}
cout << solve() << endl;
for (int i = 0; pn <= 200000 && i < pn; ++i) {
printf("%d %d\n", p[i].first, p[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:100000000")
using namespace std;
const int MAX = 200000 + 10;
int a[2][MAX];
int main() {
int n;
scanf("%d", &n);
int k[2], p[2] = {0};
for (int(i) = 0; (i) < (n); (i)++) {
int s, x, y, m;
scanf("%d %d %d %d %d", &k[i], &s, &x, &y, &m);
a[i][0] = s;
for (int j = 1; j < k[i]; j++) {
a[i][j] = ((long long)a[i][j - 1] * x + y) % m;
}
}
vector<pair<int, int> > res;
int last = 0;
while (p[0] < k[0] && p[1] < k[1]) {
int j = -1;
for (int(i) = 0; (i) < (2); (i)++) {
if (a[i][p[i]] >= last && (j == -1 || a[i][p[i]] < a[j][p[j]])) {
j = i;
}
}
if (j == -1) {
if (a[0][p[0]] < a[1][p[1]]) {
res.push_back(make_pair(a[0][p[0]], 0));
last = a[0][p[0]];
p[0]++;
} else {
res.push_back(make_pair(a[1][p[1]], 1));
last = a[1][p[1]];
p[1]++;
}
} else {
res.push_back(make_pair(a[j][p[j]], j));
last = a[j][p[j]];
p[j]++;
}
}
for (int(i) = 0; (i) < (2); (i)++) {
while (p[i] < k[i]) {
res.push_back(make_pair(a[i][p[i]], i));
p[i]++;
}
}
int ans = 0;
for (int(i) = 0; (i) < ((int)(res).size() - 1); (i)++) {
if (res[i].first > res[i + 1].first) {
++ans;
}
}
printf("%d\n", ans);
if ((int)(res).size() <= 200000) {
for (int(i) = 0; (i) < ((int)(res).size()); (i)++) {
printf("%d %d\n", res[i].first, res[i].second + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e6) + 111;
int n;
struct Node {
int id, val, belong;
Node() {}
Node(int a, int b, int c) : id(a), val(b), belong(c) {}
bool operator<(const Node &rhs) const {
if (id != rhs.id) return id < rhs.id;
return val < rhs.val;
}
} node[maxn];
int top = 0;
int main() {
int k, x, y, moder;
scanf("%d", &n);
register int i, j;
int ans = 0;
for (i = 1; i <= n; ++i) {
int tmp = 0, last = 0, cur = 0;
scanf("%d%d%d%d%d", &k, &last, &x, &y, &moder);
node[++top] = Node(cur, last, i);
for (j = 2; j <= k; ++j) {
tmp = (1ll * last * x + y) % moder;
if (tmp < last) cur++;
node[++top] = Node(cur, tmp, i);
last = tmp;
}
ans = max(ans, cur);
}
printf("%d\n", ans);
sort(node + 1, node + 1 + top);
if (top > int(2e5)) return 0;
for (i = 1; i <= top; ++i) {
printf("%d %d\n", node[i].val, node[i].belong);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k[5000], a[5000], x[5000], y[5000], m[5000], pos[5000];
pair<int, int> ans[200000], l[200000];
int main() {
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d%d", &k[i], &a[i], &x[i], &y[i], &m[i]);
pos[i] = 0;
sum += k[i];
}
int tot = 0, bad = 0;
while (true) {
bool flag = true;
for (int i = 0; i < n; i++)
if (pos[i] < k[i]) {
flag = false;
break;
}
if (flag) break;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (pos[i] == k[i]) continue;
while (pos[i] < k[i]) {
if (sum <= 200000) l[cnt++] = make_pair(a[i], i);
pos[i]++;
if (pos[i] == k[i]) break;
int last = a[i];
a[i] = (int)(((long long)a[i] * x[i] + y[i]) % m[i]);
if (a[i] < last) break;
}
}
if (sum <= 200000) {
sort(l, l + cnt);
for (int i = 0; i < cnt; i++) ans[tot++] = l[i];
}
bad++;
}
bad--;
printf("%d\n", bad);
if (sum <= 200000) {
for (int i = 0; i < tot; i++)
printf("%d %d\n", ans[i].first, ans[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using std::cerr;
using std::cin;
using std::cos;
using std::cout;
using std::endl;
using std::make_pair;
using std::max;
using std::min;
using std::next_permutation;
using std::pair;
using std::priority_queue;
using std::queue;
using std::random_shuffle;
using std::set;
using std::sin;
using std::sort;
using std::sqrt;
using std::stack;
using std::string;
using std::stringstream;
using std::swap;
using std::vector;
const long double PI = 3.14159265358979323846;
const int INF = 1000;
int main() {
int n;
cin >> n;
int sum = 0;
vector<vector<int> > data(n);
int maxi = 0;
for (int i = 0; i < n; ++i) {
int k, a, x, y, m, cur = 0;
cin >> k >> a >> x >> y >> m;
sum += k;
data[i].resize(k);
data[i][0] = a;
for (int j = 1; j < k; ++j) {
data[i][j] = ((long long)(data[i][j - 1]) * x + y) % m;
if (data[i][j] < data[i][j - 1]) ++cur;
}
maxi = max(maxi, cur);
}
if (sum > 200000) {
cout << maxi << endl;
return 0;
}
vector<pair<int, int> > ans(sum);
int begin = 0, end = 0;
vector<int> b(n, 0);
while (end < sum) {
for (int i = 0; i < n; ++i) {
if (b[i] == data[i].size()) continue;
ans[end] = make_pair(data[i][b[i]], i);
++end;
int j = b[i] + 1;
while ((j < data[i].size()) && (data[i][j] >= data[i][j - 1])) {
ans[end] = make_pair(data[i][j], i);
++end;
++j;
}
b[i] = j;
}
sort(ans.begin() + begin, ans.begin() + end);
begin = end;
}
cout << maxi << endl;
for (int i = 0; i < sum; ++i)
cout << ans[i].first << " " << ans[i].second + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5010, M = 200010;
int tf = 0, tt = 0, b[N], k[N], h[N], x[N], y[N], m[N];
struct data {
int w, d, x;
} a[M], last[M], f[N], t[N];
void swap(data &a, data &b) {
data temp = a;
a = b;
b = temp;
}
void up() {
f[0] = f[tf];
int i = tf, k = i / 2;
while (k >= 1) {
if (f[k].w <= f[0].w) break;
f[i] = f[k];
i = k;
k = i / 2;
}
f[i] = f[0];
}
void down() {
f[0] = f[1];
int i = 1, k = i * 2;
while (k <= tf) {
if (k < tf && f[k].w > f[k + 1].w) k++;
if (f[k].w >= f[0].w) break;
f[i] = f[k];
i = k;
k = i * 2;
}
f[i] = f[0];
}
void add(data t) {
tf++;
f[tf] = t;
up();
}
void del() {
swap(f[1], f[tf]);
tf--;
down();
}
int main() {
int n, sum = 0, pos = 0, s, i, j, ans = 0;
long long temp, temp2;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d %d %d %d", &k[i], &h[i], &x[i], &y[i], &m[i]);
sum += k[i];
}
for (i = 1; i <= n; i++) {
temp = h[i];
s = 0;
for (j = 1; j <= k[i]; j++) {
if (sum <= 200000) {
pos++;
a[pos].w = temp;
a[pos].d = i;
a[pos].x = j;
if (j == 1) b[i] = pos;
}
if (j < k[i]) {
temp2 = (temp * x[i] + y[i]) % m[i];
if (temp > temp2) s++;
temp = temp2;
}
}
if (ans < s) ans = s;
}
printf("%d\n", ans);
if (sum <= 200000) {
for (i = 1; i <= n; i++) add(a[b[i]]);
s = 0;
while (s < sum) {
while (tf > 0) {
s++;
last[s] = f[1];
del();
if (last[s].x < k[last[s].d]) {
int temp = b[last[s].d] + last[s].x;
if (last[s].w <= a[temp].w)
add(a[temp]);
else {
tt++;
t[tt] = a[temp];
}
}
}
if (tt > 0) {
for (i = 1; i <= tt; i++) add(t[i]);
tt = 0;
}
}
for (i = 1; i <= sum; i++) printf("%d %d\n", last[i].w, last[i].d);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > bs[200020];
int main() {
int n;
int k, a, x, y, m;
cin >> n;
int res = 0;
for (int i = 0; i < n; i++) {
cin >> k >> a >> x >> y >> m;
vector<int> c(k);
for (int j = 0; j < k; ++j) {
c[j] = a;
a = (1LL * a * x + y) % m;
}
vector<int> cur;
int pr = -1;
for (int j = 0; j <= k; ++j) {
if (j >= k || pr > c[j]) {
bs[i].push_back(cur);
cur.clear();
}
if (j < k) {
cur.push_back(c[j]);
pr = c[j];
}
}
res += k;
}
bool can = false;
if (res <= 200000) can = true;
int ans = 0;
vector<pair<int, int> > as;
vector<int> ptrs(n, 0);
for (int bptr = 0;; bptr++) {
priority_queue<pair<int, int> > cps;
for (int i = 0; i < n; i++)
if (bs[i].size() > bptr) {
ptrs[i] = 0;
cps.push(make_pair(-bs[i][bptr][ptrs[i]], i));
}
if (cps.empty()) break;
while (!cps.empty()) {
pair<int, int> cur = cps.top();
cps.pop();
int i = cur.second;
int j = ++ptrs[i];
if (can) {
as.push_back(make_pair(bs[i][bptr][j - 1], i));
}
if (j < bs[i][bptr].size()) {
cps.push(make_pair(-bs[i][bptr][j], i));
}
}
if (bptr > 0) ans++;
}
printf("%d\n", ans);
if (can) {
for (int i = 0; i < as.size(); i++)
printf("%d %d\n", as[i].first, as[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
int v[N], x[N], y[N], m[N], len[N];
struct cmp {
inline bool operator()(const int &a, const int &b) {
return v[a] == v[b] ? a < b : v[a] < v[b];
}
};
pair<int, int> ans[N << 2];
int main() {
int n = gi(), i, k, all = 0, sum = 0, top = 0;
set<int, cmp> s;
set<int>::iterator it;
for (i = 1; i <= n; i++)
all += len[i] = gi(), v[i] = gi(), x[i] = gi(), y[i] = gi(), m[i] = gi(),
s.insert(i);
v[0] = 0;
while (all--) {
it = s.lower_bound(0);
k = it == s.end() ? (sum++, *s.begin()) : *it;
s.erase(k);
v[0] = v[k];
if (top <= 200000) ans[++top] = make_pair(v[k], k);
if (--len[k]) v[k] = (1LL * v[k] * x[k] + y[k]) % m[k], s.insert(k);
}
printf("%d\n", sum);
if (top <= 200000)
for (i = 1; i <= top; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
|
#include <bits/stdc++.h>
int n, k[3], x[3], y[3], m[3], ans[400010], rev;
long long a[3][200010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%I64d%d%d%d", &k[i], &a[i][1], &x[i], &y[i], &m[i]);
for (int i = 1; i <= n; ++i)
for (int j = 2; j <= k[i]; ++j)
a[i][j] = (a[i][j - 1] * x[i] + y[i]) % m[i];
int p = 0;
for (int i = 1, j = 1; i + j <= k[1] + k[2] + 1;)
if (i <= k[1] &&
(j > k[2] || (p <= a[1][i] || p > a[2][j]) && a[1][i] <= a[2][j] ||
a[1][i] >= p && p > a[2][j])) {
ans[i + j - 1] = 1;
if (a[1][i] < p) ++rev;
p = a[1][i];
++i;
} else {
ans[i + j - 1] = 2;
if (a[2][j] < p) ++rev;
p = a[2][j];
++j;
}
printf("%d\n", rev);
if (k[1] + k[2] <= 200000) {
for (int i = 1, p = 1, q = 1; i <= k[1] + k[2]; ++i)
printf("%I64d %d\n", ans[i] == 1 ? a[1][p++] : a[2][q++], ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, nProblem;
struct problem {
int who;
int block;
int costTime;
long long info;
problem() {}
problem(int _w, int _b, int _c) { who = _w, block = _b, costTime = _c; }
bool operator<(const problem &u) const {
if (block != u.block) return block < u.block;
return costTime < u.costTime;
}
} P[200001];
int MAIN() {
while (cin >> n) {
int maxBlock = 0;
nProblem = 0;
for (int i = 1; i <= n; i++) {
int k;
long long a, x, y, m;
cin >> k >> a >> x >> y >> m;
long long prev = -100;
int blockNumber = 1;
for (int j = 1; j <= k; j++) {
if (a < prev) blockNumber++;
prev = a;
if (nProblem + 1 <= 200000)
P[++nProblem] = problem(i, blockNumber, a);
else
nProblem++;
a = (a * x + y) % m;
}
maxBlock = max(maxBlock, blockNumber - 1);
}
if (nProblem <= 200000) sort(P + 1, P + 1 + nProblem);
cout << maxBlock << endl;
if (nProblem <= 200000) {
for (int i = 1; i <= nProblem; i++)
cout << P[i].costTime << " " << P[i].who << endl;
}
}
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int RUN_RESULT = MAIN();
return RUN_RESULT;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kNMax = 5005;
int n, tot;
int k[kNMax], a[kNMax], x[kNMax], y[kNMax], m[kNMax];
pair<int, int> out[200005];
int nOut;
struct cmp {
bool operator()(int i, int j) {
return a[i] < a[j] || (a[i] == a[j] && i < j);
}
};
set<int, cmp> S;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d%d", &k[i], &a[i], &x[i], &y[i], &m[i]);
tot += k[i];
S.insert(i);
}
int pre = 0, bad = 0;
for (int i = 0; i < tot; i++) {
a[0] = pre;
set<int>::iterator it = S.lower_bound(0);
if (it == S.end()) it = S.begin();
int t = *it;
if (tot <= 200000) {
out[nOut++] = make_pair(a[t], t);
}
bad += a[t] < pre;
pre = a[t];
S.erase(*it);
k[t]--;
if (k[t]) {
a[t] = ((long long)a[t] * x[t] + y[t]) % m[t];
S.insert(t);
}
}
printf("%d\n", bad);
if (tot <= 200000)
for (int i = 0; i < nOut; i++)
printf("%d %d\n", out[i].first, out[i].second);
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned _mod = 998244353;
const unsigned mod = 1e9 + 7;
const long long infi = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
long long ksm(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1ll) ret = ret * x % mod;
y >>= 1ll;
x = x * x % mod;
}
return ret;
}
long long qpow(long long x, long long y, long long m) {
long long ret = 1;
while (y) {
if (y & 1ll) ret = ret * x % m;
y >>= 1ll;
x = x * x % m;
}
return ret;
}
long long _gcd(long long x, long long y) { return y ? _gcd(y, x % y) : x; }
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
pair<pair<int, int>, int> a[200010];
long long n, k, c, x, y, m, z, g, t, b, l;
int main() {
int T;
cin >> T;
while (T--) {
cin >> k >> c >> x >> y >> m, t = 0;
while (k--) {
if (g <= 2e5) a[++g] = make_pair(pair<int, int>(t, c), l);
b = (c * x + y) % m;
if (b < c && k) t++;
c = b;
z = max(z, t);
}
l++;
}
cout << z << '\n';
if (g <= 2e5) {
sort(a + 1, a + g + 1);
for (register int i = 1; i <= g; ++i)
cout << a[i].first.second << " " << a[i].second + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans, n, i, j, sum, num;
long long ne, k, st, x, y, mo;
struct sw {
int x, y, z;
bool operator<(const sw& s) const {
return (x < s.x || (x == s.x && y < s.y) ||
(x == s.x && y == s.y && z < s.z));
}
} a[500000];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
sum = 0;
cin >> k >> st >> x >> y >> mo;
a[++num].x = sum;
a[num].y = st;
a[num].z = i;
for (j = 2; j <= k; j++) {
ne = (st * x + y) % mo;
if (ne < st) sum++;
a[++num].x = sum;
a[num].y = ne;
a[num].z = i;
st = ne;
}
if (sum > ans) ans = sum;
}
sort(a + 1, a + num + 1);
cout << ans << endl;
if (num <= 200000) {
for (i = 1; i <= num; i++) cout << a[i].y << ' ' << a[i].z << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int k[5010], a[5010], x[5010], y[5010], m[5010], n;
struct compare {
bool operator()(int i, int j) { return a[i] <= a[j]; }
};
vector<pair<int, int> > ans;
multiset<int, compare> q;
int main() {
scanf("%d", &n);
if (n == 2) {
int cnt = 0, bp = 0, last = -1, lv = -2147483647;
for (int i = 0; i < (n); i++) {
scanf("%d%d%d%d%d", &k[i], &a[i], &x[i], &y[i], &m[i]);
cnt += k[i]--;
q.insert(i);
}
while (!q.empty()) {
multiset<int, compare>::iterator i = q.end();
if (last == -1) i = q.upper_bound(n);
if (i == q.end()) i = q.begin();
int cur = *i;
q.erase(i);
if (a[cur] < lv) bp++;
a[n] = a[cur] - 1;
lv = a[cur];
if (cnt <= 200000) ans.push_back(pair<int, int>(cur, a[cur]));
if (k[cur]) {
k[cur]--;
a[cur] = (a[cur] * 1ll * x[cur] + y[cur]) % m[cur];
q.insert(cur);
}
}
printf("%d\n", bp);
for (int i = 0; i < (ans.size()); i++)
printf("%d %d\n", ans[i].second, ans[i].first + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5100, OP = 200000;
int n, M = 0, Q = 0;
int k[N], a[N], x[N], y[N], m[N];
struct PR {
int a, b;
} e[210000], A[210000];
bool cmp(const PR& A, const PR& B) { return A.a < B.a; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%d%d%d%d", &k[i], &a[i], &x[i], &y[i], &m[i]), M += k[i];
int P = n, ans = -1;
while (P > 0) {
int cp = 0;
for (int i = 1; i <= n; ++i)
if (k[i] > 0) {
for (int now = -123456789; k[i] > 0 && a[i] >= now; --k[i]) {
if (M <= OP) e[++cp].a = a[i], e[cp].b = i;
now = a[i], a[i] = ((long long)a[i] * x[i] + y[i]) % m[i];
}
if (k[i] <= 0) --P;
}
++ans;
if (M <= OP) {
sort(e + 1, e + 1 + cp, cmp);
for (int i = 1; i <= cp; ++i) A[++Q] = e[i];
}
}
cout << ans << endl;
if (M <= OP)
for (int i = 1; i <= M; ++i) printf("%d %d\n", A[i].a, A[i].b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct type {
long x, y, z;
} p[300000];
bool cmp(type x, type y) {
if (x.x == y.x)
return (x.y < y.y || (x.y == y.y && x.z < y.z));
else
return x.x < y.x;
}
long long n, k, a, x, y, m;
long long ans, tot, t, b;
long i, j;
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d%I64d%I64d", &k, &a, &x, &y, &m);
for (t = 0, j = 1; j <= k; j++) {
if (tot <= 2e5) p[++tot] = (type){t, a, i};
b = (a * x + y) % m;
if (b < a && j != k) t++;
a = b;
}
ans = max(ans, t);
}
printf("%I64d\n", ans);
if (tot <= 2e5) {
sort(p + 1, p + tot + 1, cmp);
for (i = 1; i <= tot; i++) printf("%ld %ld\n", p[i].y, p[i].z);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000;
int n, k, a, x, y, m, cnt, ans;
struct job {
int rev, a, i;
} T[maxn];
inline bool operator<(job a, job b) {
return (a.rev < b.rev || (a.rev == b.rev && a.i != b.i && a.a < b.a));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int cur = 0, pre = -1;
for (scanf("%d%d%d%d%d", &k, &a, &x, &y, &m); k--;) {
if (cnt < maxn) {
T[cnt].rev = cur;
T[cnt].a = a;
T[cnt++].i = i;
} else
cnt++;
pre = a;
a = ((long long)a * x + y) % m;
if (pre > a && k) cur++;
}
ans = max(ans, cur);
}
printf("%d\n", ans);
if (cnt <= maxn) {
stable_sort(T, T + cnt);
for (int i = 0; i < cnt; i++) printf("%d %d\n", T[i].a, T[i].i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void Rd(int& res) {
res = 0;
char c;
while (c = getchar(), c < 48)
;
do res = res * 10 + (c & 15);
while (c = getchar(), c > 47);
}
vector<int> num[5005], ans, id;
int n, k, a, x, y, m, tot;
int L[5005];
int main() {
Rd(n);
for (int i = 1; i <= n; i++) {
Rd(k), Rd(a), Rd(x), Rd(y), Rd(m);
tot += k;
num[i].push_back(a);
for (int j = 2; j <= k; j++) {
a = (1LL * a * x + y) % m;
num[i].push_back(a);
}
}
ans.push_back(-1);
id.push_back(-1);
while (tot--) {
int mi = 1e9 + 5, miid = -1;
for (int i = 1; i <= n; i++) {
if (L[i] < num[i].size() && num[i][L[i]] >= ans[ans.size() - 1] &&
num[i][L[i]] < mi) {
mi = num[i][L[i]];
miid = i;
}
}
if (~miid) {
id.push_back(miid);
ans.push_back(num[miid][L[miid]++]);
continue;
}
mi = 1e9 + 5, miid = -1;
for (int i = 1; i <= n; i++) {
if (L[i] < num[i].size() && num[i][L[i]] < mi) {
mi = num[i][L[i]];
miid = i;
}
}
id.push_back(miid);
ans.push_back(num[miid][L[miid]++]);
}
int allc = 0;
for (int i = 2; i < ans.size(); i++)
if (ans[i] < ans[i - 1]) allc++;
printf("%d\n", allc);
if (ans.size() <= 200001) {
for (int i = 1; i < ans.size(); i++) printf("%d %d\n", ans[i], id[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void input(T &x) {
char c = getchar();
x = 0;
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
}
inline long long bigmod(long long p, long long e, long long M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
const int N = 5005;
vector<long long> a[N];
int ptr[N];
int n;
int K[N];
long long x, y, m, k;
int main() {
input(n);
int sum = 0;
set<pair<long long, int> > pq;
for (int i = 0; i < n; i++) {
input(k);
a[i].resize(k);
input(a[i][0]);
input(x), input(y), input(m);
for (int j = 1; j < k; j++) {
a[i][j] = (x * a[i][j - 1] + y) % m;
}
K[i] = k;
sum += k;
pq.insert(make_pair(a[i][0], i));
ptr[i] = 1;
}
long long prv = -1;
vector<pair<long long, int> > sq;
long long ans = 0;
while (pq.size()) {
auto u = pq.lower_bound(make_pair(prv, -1));
if (u == pq.end()) {
ans++;
u = pq.begin();
}
prv = u->first;
sq.push_back(*u);
int now = u->second;
pq.erase(u);
if (ptr[now] < a[now].size())
pq.insert(make_pair(a[now][ptr[now]], now)), ptr[now]++;
}
cout << ans << endl;
if (sum <= 200000)
for (auto a : sq) printf("%lld %d\n", a.first, a.second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > a;
int n;
int main() {
vector<pair<pair<int, int>, int> > v;
cin >> n;
a.resize(n);
int ans = 0;
int K = 0;
for (int i = 0; i < n; i++) {
int k;
long long l;
cin >> k >> l;
long long x, y, m;
cin >> x >> y >> m;
a[i].resize(k);
a[i][0] = l;
for (int j = 1; j < k; j++) {
l = (l * x + y) % m;
if (l < 0) l += m;
a[i][j] = l;
}
int res = 0;
for (int j = 0; j < k; j++)
if (j && a[i][j - 1] > a[i][j]) res += 1;
ans = max(ans, res);
K += k;
}
printf("%d\n", ans);
if (K <= 200000) {
for (int i = 0; i < n; i++) {
int res = 0;
for (int j = 0; j < (int)a[i].size(); j++) {
if (j && a[i][j - 1] > a[i][j]) res += 1;
v.push_back(make_pair(make_pair(res, a[i][j]), i + 1));
}
}
sort(v.begin(), v.end());
for (int i = 0; i < (int)v.size(); i++)
printf("%d %d\n", v[i].first.second, v[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n;
vector<vector<long long int>> a;
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int>>,
greater<pair<long long int, long long int>>>
pq;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
a.resize(n);
long long int tot = 0;
for (int i = 0; i < n; ++i) {
long long int k, a1, x, y, m;
cin >> k >> a1 >> x >> y >> m;
a[i].resize(k);
a[i][0] = a1;
pq.push({a1, i + 1});
for (int j = 1; j < k; ++j) {
a[i][j] = (a[i][j - 1] * x + y) % m;
}
tot += k;
}
vector<long long int> ptr(n, 0);
vector<pair<long long int, long long int>> out;
long long int prev = 0, ans = 0;
while (true) {
vector<pair<long long int, long long int>> tmp;
while (!pq.empty()) {
pair<long long int, long long int> t = pq.top();
pq.pop();
if (t.first < prev) {
ans++;
}
prev = t.first;
if (tot <= 200000) {
out.push_back(t);
}
ptr[t.second - 1]++;
if (ptr[t.second - 1] < a[t.second - 1].size()) {
if (a[t.second - 1][ptr[t.second - 1]] < prev) {
tmp.push_back({a[t.second - 1][ptr[t.second - 1]], t.second});
} else {
pq.push({a[t.second - 1][ptr[t.second - 1]], t.second});
}
}
}
if (tmp.size() == 0) break;
for (int i = 0; i < tmp.size(); ++i) {
pq.push(tmp[i]);
}
}
cout << ans << endl;
if (tot <= 200000) {
for (int i = 0; i < out.size(); ++i) {
cout << out[i].first << " " << out[i].second << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000;
int K, c, x, y, m, n, cnt, t, mx;
pair<pair<int, int>, int> a[maxn + 5];
int main() {
scanf("%d", &n);
for (int i = (1); i <= int(n); i++) {
scanf("%d%d%d%d%d", &K, &c, &x, &y, &m);
t = 0;
for (int j = (1); j <= int(K); j++) {
if (cnt <= maxn) a[++cnt] = make_pair(make_pair(t, c), i);
if (j < K && c > (1LL * c * x + y) % m) t++;
c = (1LL * c * x + y) % m;
}
mx = max(mx, t);
}
sort(a + 1, a + cnt + 1);
printf("%d\n", mx);
if (cnt <= maxn)
for (int i = (1); i <= int(cnt); i++)
printf("%d %d\n", a[i].first.second, a[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct scientist {
long long k, a, x, y, m, current_index;
bool change;
};
struct h {
long long value;
int index;
};
int N;
vector<scientist> scientists;
long long k, a, x, y, m;
long long answer = 0;
vector<h> heap1;
vector<h> heap2;
h prev_result;
vector<h> result;
void add(h value, vector<h>& heap) {
heap.push_back(value);
int n = (int)heap.size() - 1;
while (n > 0 && heap[(n - 1) / 2].value > heap[n].value) {
h tmp = heap[n];
heap[n] = heap[(n - 1) / 2];
heap[(n - 1) / 2] = tmp;
n = (n - 1) / 2;
}
}
void refresh(vector<h>& heap) {
int n = 0;
while ((2 * n + 1 < heap.size() && heap[n].value > heap[2 * n + 1].value) ||
(2 * n + 2 < heap.size() && heap[n].value > heap[2 * n + 2].value)) {
if (2 * n + 1 < heap.size() && heap[n].value > heap[2 * n + 1].value) {
h tmp = heap[n];
heap[n] = heap[2 * n + 1];
heap[2 * n + 1] = tmp;
n = 2 * n + 1;
} else {
h tmp = heap[n];
heap[n] = heap[2 * n + 2];
heap[2 * n + 2] = tmp;
n = 2 * n + 2;
}
}
}
int main(int argc, const char* argv[]) {
cin >> N;
int max = 0;
long long sum = 0;
for (int i = 0; i < N; ++i) {
cin >> k >> a >> x >> y >> m;
scientists.push_back({k, a, x, y, m, 0, false});
int res = 0;
for (int j = 1; j < k; ++j) {
long long new_a = (a * x + y) % m;
if (new_a < a) {
res++;
}
a = new_a;
}
if (max < res) max = res;
sum += k;
}
cout << max << endl;
if (sum > 200000) {
return 0;
}
for (int i = 0; i < N; ++i) {
add({scientists[i].a, i}, heap1);
if (scientists[i].current_index < scientists[i].k) {
long long new_a = (scientists[i].a * scientists[i].x + scientists[i].y) %
scientists[i].m;
if (new_a < scientists[i].a)
scientists[i].change = true;
else
scientists[i].change = false;
scientists[i].a = new_a;
scientists[i].current_index++;
}
}
prev_result = {-1, -1};
while (heap1.size() > 0) {
while (heap1.size() > 0) {
h t = heap1[0];
heap1[0] = heap1.back();
heap1.pop_back();
if (result.size() <= 200000) {
result.push_back({t.value, t.index + 1});
}
if (prev_result.index != -1) {
if (prev_result.value > t.value) answer++;
}
prev_result = {t.value, t.index + 1};
refresh(heap1);
if (scientists[t.index].change) {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap2);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
} else {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap1);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
}
}
while (heap2.size() > 0) {
h t = heap2[0];
heap2[0] = heap2.back();
heap2.pop_back();
if (result.size() <= 200000) {
result.push_back({t.value, t.index + 1});
}
if (prev_result.index != -1) {
if (prev_result.value > t.value) answer++;
}
prev_result = {t.value, t.index + 1};
refresh(heap2);
if (scientists[t.index].change) {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap1);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
} else {
if (scientists[t.index].current_index < scientists[t.index].k) {
add({scientists[t.index].a, t.index}, heap2);
long long new_a = (scientists[t.index].a * scientists[t.index].x +
scientists[t.index].y) %
scientists[t.index].m;
if (new_a < scientists[t.index].a)
scientists[t.index].change = true;
else
scientists[t.index].change = false;
scientists[t.index].a = new_a;
scientists[t.index].current_index++;
}
}
}
}
if (result.size() <= 200000) {
for (int i = 0; i < result.size(); ++i) {
cout << result[i].value << " " << result[i].index << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, sum(0);
vector<pair<int, int> > y[200011];
int cy = 0, ccy;
bool flag;
int main() {
scanf("%d", &n);
for (int i = 1, k, a, X, Y, m; i <= n; ++i) {
scanf("%d%d%d%d%d", &k, &a, &X, &Y, &m);
sum += k;
ccy = 1;
y[ccy].push_back(pair<int, int>(a, i));
for (int j = 1; j < k; ++j) {
a = ((long long)a * (long long)X + (long long)Y) % m;
if (a < y[ccy].back().first) ++ccy;
y[ccy].push_back(pair<int, int>(a, i));
}
cy = max(cy, ccy);
}
printf("%d\n", cy - 1);
if (sum <= 200000)
for (int i = 1; i <= cy; ++i) {
sort(y[i].begin(), y[i].end());
for (unsigned int j = 0; j < y[i].size(); ++j)
printf("%d %d\n", y[i][j].first, y[i][j].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, pair<int, int> > g[200000 + 10];
int main() {
cin >> n;
int tot = 0, ans = 0;
for (int i = (1); i <= (n); i++) {
int k, a, x, y, m;
scanf("%d%d%d%d%d", &k, &a, &x, &y, &m);
int last = -1, now = 0;
for (int j = (1); j <= (k); j++) {
if (last > a) now++;
if (tot < 200000)
g[++tot] = make_pair(now, make_pair(a, i));
else
tot = 1 << 30;
last = a;
a = ((long long)a * x + y) % m;
}
ans = max(ans, now);
}
cout << ans << endl;
if (tot <= 200000) {
sort(g + 1, g + tot + 1);
for (int i = (1); i <= (tot); i++)
cout << g[i].second.first << " " << g[i].second.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int N = 2, K = 2e5;
int n, k_total;
int32_t k[N], a[N], x[N], y[N], m[N], p[N];
bool greater_by_a(int i, int j) { return a[i] > a[j]; }
priority_queue<int32_t, vector<int32_t>, decltype(&greater_by_a)> q(
greater_by_a);
vector<int32_t> q2;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k[i] >> a[i] >> x[i] >> y[i] >> m[i];
k_total += k[i];
q.push(i);
}
int ans = 0, a0 = 0;
vector<pii> ans2;
for (;;) {
while (!q.empty()) {
int i = q.top();
q.pop();
;
if (a[i] >= a0) {
if (k_total <= 2e5) ans2.emplace_back(a[i], i + 1);
a0 = a[i];
if (++p[i] < k[i]) {
a[i] = ((int64_t)a[i] * x[i] + y[i]) % m[i];
q.push(i);
}
} else {
q2.push_back(i);
}
}
if (q2.empty()) break;
for (int i : q2) q.push(i);
q2.clear();
ans++, a0 = 0;
}
cout << ans << endl;
if (k_total <= 2e5) {
for (auto ai : ans2) {
cout << ai.first << ' ' << ai.second << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005, MAXM = 200005;
int l[MAXN];
vector<int> a[MAXN];
int now[MAXN];
int ansn = 0;
int sk;
int n;
struct DATA {
int num, src;
};
inline bool operator<(const DATA &a, const DATA &b) {
if (a.num < b.num) return true;
return a.num == b.num && a.src < b.src;
}
set<DATA> bst;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &l[i]);
for (int j = 0; j <= l[i]; j++) a[i].push_back(0);
scanf("%d", &a[i][1]);
int x, y, m;
scanf("%d%d%d", &x, &y, &m);
for (int j = 2; j <= l[i]; j++)
a[i][j] = (a[i][j - 1] * (long long)x + y) % m;
sk += l[i];
}
for (int i = 1; i <= n; i++) {
int t = 0;
for (int j = 1; j < l[i]; j++)
if (a[i][j] > a[i][j + 1]) t++;
if (t > ansn) ansn = t;
}
printf("%d\n", ansn);
if (sk > 200000) return 0;
for (int i = 1; i <= n; i++) {
DATA t;
t.num = a[i][1];
t.src = i;
bst.insert(t);
}
int last = -1;
for (int i = 1; i <= sk; i++) {
DATA t;
t.num = last;
t.src = 0;
set<DATA>::iterator p = bst.lower_bound(t);
if (p == bst.end()) p = bst.begin();
int best = p->src;
last = p->num;
bst.erase(p);
printf("%d %d\n", last, best);
now[best]++;
if (now[best] < l[best]) {
t.num = a[best][now[best] + 1];
t.src = best;
bst.insert(t);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int prime = 1003800021;
const int MOD = 1103800039;
int n, k, sumk, maxk, cnt;
long long a, x, y, m;
vector<vector<long long> > vec;
vector<vector<unsigned long long> > h;
unsigned long long pw[1 << 18];
vector<pair<int, int> > ans;
int idx[1 << 13];
inline unsigned long long getHash(int row, int le, int ri) {
if (!le) return h[row][ri];
return (h[row][ri] - h[row][le - 1] * pw[ri - le + 1] % MOD + MOD) % MOD;
}
struct cmp {
bool operator()(pair<int, int> a, pair<int, int> b) {
int i = a.first, j = b.first;
int l1 = a.second, l2 = b.second;
int lo = 1, hi = min(vec[i].size() - l1, vec[j].size() - l2), mid;
int lcp = 0;
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (getHash(i, l1, l1 + mid - 1) == getHash(j, l2, l2 + mid - 1)) {
lcp = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
if (l1 + lcp >= vec[i].size()) return false;
if (l2 + lcp >= vec[j].size()) return true;
int num1 = vec[i][l1 + lcp], num2 = vec[j][l2 + lcp];
return num1 > num2;
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, cmp> pq;
void build(int idx) {
vec[idx].resize(k);
for (int i = 0; i < k; i++) {
vec[idx][i] = a;
a = (a * x + y) % m;
}
}
void read() {
scanf("%d", &n);
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> k >> a >> x >> y >> m;
build(i);
sumk += k;
if (maxk < k) maxk = k;
}
}
void solve() {
int last = -1;
int br = 0;
while (1) {
if (br == sumk) break;
br++;
int row = -1;
for (int i = 0; i < n; i++)
if (idx[i] < vec[i].size() && vec[i][idx[i]] >= last) {
if (row == -1)
row = i;
else {
if (vec[i][idx[i]] < vec[row][idx[row]]) row = i;
}
}
if (row == -1) {
cnt++;
for (int i = 0; i < n; i++)
if (idx[i] < vec[i].size()) {
if (row == -1)
row = i;
else {
if (vec[i][idx[i]] < vec[row][idx[row]]) row = i;
}
}
}
ans.push_back(make_pair(vec[row][idx[row]], row + 1));
last = vec[row][idx[row]];
idx[row]++;
}
printf("%d\n", cnt);
if (sumk <= 200000) {
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<queue<long long>> lst(n);
int tot = 0;
for (int i = 0; i < n; i++) {
long long k, a, x, y, m;
cin >> k >> a >> x >> y >> m;
tot += k;
while (k--) lst[i].push(a), a = (a * x + y) % m;
}
int ret = 0, val = 0;
vector<pair<long long, long long>> ans;
for (int c = 0; c < tot; c++) {
int mn = 2e9, idx = -1, glob = 2e9, rem = -1;
for (int i = 0; i < n; i++) {
if (lst[i].empty()) continue;
int cur = lst[i].front();
if (cur < glob) glob = cur, rem = i;
if (val > cur) continue;
if (cur < mn) mn = cur, idx = i;
}
if (idx != -1) {
val = lst[idx].front();
ans.push_back({val, idx + 1});
lst[idx].pop();
continue;
}
ret++;
val = lst[rem].front();
ans.push_back({val, rem + 1});
lst[rem].pop();
}
cout << ret << endl;
if (tot <= 200000)
for (auto it : ans) cout << it.first << " " << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline const int read() {
int r = 0, k = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') k = -1;
for (; c >= '0' && c <= '9'; c = getchar()) r = r * 10 + c - '0';
return k * r;
};
int x[5005];
int y[5005];
int m[5005];
int k[5005];
int nk[5005];
pair<int, int> ans[200005];
int anst = 0;
set<pair<int, int> > s;
int temp, tpp;
int main() {
ios::sync_with_stdio(false);
int n;
n = read();
s.clear();
int cnt = 0;
int cnnt = 0;
for (int i = 1; i <= n; i++) {
k[i] = read();
temp = read();
x[i] = read();
y[i] = read();
m[i] = read();
nk[i] = 0;
s.insert(pair<int, int>(temp, i));
cnnt = 0;
for (int j = 1; j < k[i]; j++) {
tpp = ((long long)x[i] * (long long)temp + (long long)y[i]) %
((long long)m[i]);
if (tpp < temp) cnnt++;
temp = tpp;
};
cnt = max(cnt, cnnt);
};
int nw = -1;
pair<int, int> tp;
set<pair<int, int> >::iterator it;
while (!s.empty()) {
it = s.upper_bound(pair<int, int>(nw, 0));
if (it == s.end()) {
nw = -1;
it = s.upper_bound(pair<int, int>(nw, 0));
};
tp = *it;
nw = tp.first;
temp = tp.second;
s.erase(it);
if (anst < 200001)
ans[anst++] = pair<int, int>(nw, temp);
else
break;
nk[temp]++;
if (nk[temp] < k[temp]) {
s.insert(pair<int, int>(
((long long)x[temp] * (long long)nw + (long long)y[temp]) %
((long long)m[temp]),
temp));
};
};
printf("%d\n", cnt);
if (anst < 200001)
for (int i = 0; i < anst; i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
};
|
#include <bits/stdc++.h>
const int N = 5010;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
queue<long long> que[N];
struct data {
long long k;
int id;
data();
data(long long _k, int _id) : k(_k), id(_id) {}
bool operator<(const data &r) const {
if (k == r.k) return id < r.id;
return k < r.k;
}
};
vector<data> vt;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k;
long long a, x, y, m;
cin >> k >> a >> x >> y >> m;
for (int j = 0; j < k; j++) {
que[i].push(a);
a = (a * x + y) % m;
}
}
set<data> st;
for (int i = 0; i < n; i++) st.insert(data(que[i].front(), i));
long long pre = inf;
int ret = 0, cnt = 0;
while (st.size()) {
set<data>::iterator it;
data tmp = data(pre, -1);
it = st.insert(tmp).first;
it++;
if (it == st.end()) {
set<data>::iterator bg = st.begin();
data hh = *bg;
vt.push_back(hh);
st.erase(*bg);
pre = hh.k;
ret++;
que[hh.id].pop();
if (que[hh.id].size()) st.insert(data(que[hh.id].front(), hh.id));
} else {
data hh = *it;
vt.push_back(hh);
st.erase(*it);
pre = hh.k;
que[hh.id].pop();
if (que[hh.id].size()) st.insert(data(que[hh.id].front(), hh.id));
}
st.erase(tmp);
cnt++;
}
cout << ret - 1 << endl;
if (cnt > 200000) return 0;
int sz = vt.size();
for (int i = 0; i < sz; i++) cout << vt[i].k << " " << vt[i].id + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 5e3 + 10;
vector<int> v[N];
int main() {
int n;
scanf("%d", &n);
set<pair<int, int>> sp;
int tot = 0;
for (int i = 1; i <= n; i++) {
int sz;
int a, x, y, m;
scanf("%d%d%d%d%d", &sz, &a, &x, &y, &m);
auto& vp = v[i];
vp.push_back(a);
tot += sz;
while (vp.size() < sz) {
a = (1LL * a * x + y) % m;
vp.push_back(a);
}
reverse(vp.begin(), vp.end());
sp.emplace(vp.back(), i);
}
int pre = -1;
int res = 0;
vector<pair<int, int>> ans;
while (!sp.empty()) {
auto iter = sp.lower_bound(make_pair(pre, -1));
if (iter == sp.end()) iter = sp.begin(), res++;
int val, o;
tie(val, o) = *iter;
sp.erase(iter);
if (tot <= 200000) ans.emplace_back(val, o);
pre = val;
v[o].pop_back();
if (v[o].empty()) continue;
sp.emplace(v[o].back(), o);
}
printf("%d\n", res);
for (auto& p : ans) printf("%d %d\n", p.first, p.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int ml = 200000;
int n, i, j, k, v, la, x, y, m, ans, p;
vector<pair<pair<int, int>, int> > a;
int main() {
scanf("%d", &n);
ans = 0;
for (i = 1; i <= n; ++i) {
p = la = 0;
scanf("%d%d%d%d%d", &k, &v, &x, &y, &m);
for (j = 1; j <= k; ++j) {
if (v < la) ++p;
if (a.size() <= ml) a.push_back(make_pair(make_pair(p, v), i));
la = v, v = ((long long)v * x + y) % m;
}
ans = max(ans, p);
}
printf("%d\n", ans);
if (a.size() <= ml) {
sort(a.begin(), a.end());
for (i = 0; i < a.size(); ++i)
printf("%d %d\n", a[i].first.second, a[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
long long int ans = 0, ans1, k, a1, a2, x, y, m, s = 0;
vector<pair<long, pair<long, long>>> r;
for (int i = 0; i < n; ++i) {
cin >> k;
s += k;
cin >> a1 >> x >> y >> m;
ans1 = 0;
r.push_back(make_pair(0, make_pair(a1, i + 1)));
for (int j = 1; j < k; ++j) {
a2 = ((a1 * x) % m + y % m) % m;
if (a2 < a1) ans1++;
a1 = a2;
if (r.size() <= 200000)
r.push_back(make_pair(ans1, (make_pair(a2, i + 1))));
}
ans = max(ans, ans1);
}
cout << ans << '\n';
sort(r.begin(), r.end());
if (s <= 200000)
for (int i = 0; i < s; ++i)
cout << r[i].second.first << " " << r[i].second.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LIMIT = 200000;
vector<pair<pair<int, int>, int> > v;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; ++i) {
int k, a, x, y, m;
cin >> k >> a >> x >> y >> m;
int p = 0, b = 0;
for (int j = 1; j <= k; ++j) {
if (a < b) ++p;
if (v.size() <= LIMIT) v.push_back(make_pair(make_pair(p, a), i));
b = a;
a = ((long long)a * x + y) % m;
}
ans = max(ans, p);
}
cout << ans << endl;
if (v.size() <= LIMIT) {
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i)
printf("%d %d\n", v[i].first.second, v[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int maxn = 200010;
int a[2][maxn];
int K[2] = {};
vector<pair<int, int> > ans;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int ki, ai1, xi, yi, mi;
scanf("%d%d%d%d%d", &ki, &ai1, &xi, &yi, &mi);
K[i] = ki;
a[i][0] = ai1;
for (int j = 1; j < ki; ++j) {
a[i][j] = ((long long)a[i][j - 1] * xi + yi) % mi;
}
}
int l = 0;
int r = 0;
while (l < K[0] && r < K[1]) {
int pred = 0;
if (int((ans).size())) pred = ans.back().first;
int lval = a[0][l];
int rval = a[1][r];
bool lll = false;
if (lval < pred && rval < pred) {
if (lval <= rval) lll = true;
} else if (lval >= pred && rval < pred) {
lll = true;
} else if (lval >= pred && rval >= pred) {
if (lval <= rval) lll = true;
}
if (lll)
ans.push_back(make_pair(lval, 1)), l++;
else
ans.push_back(make_pair(rval, 2)), r++;
}
while (l < K[0]) ans.push_back(make_pair(a[0][l++], 1));
while (r < K[1]) ans.push_back(make_pair(a[1][r++], 2));
int anscnt = 0;
for (int i = 1; i < int((ans).size()); ++i)
if (ans[i].first < ans[i - 1].first) anscnt++;
printf("%d\n", anscnt);
if (K[0] + K[1] <= 200000) {
for (int i = 0; i < int((ans).size()); ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
int n, Sum, _K[5100], K[5100], A[5100], X[5100], Y[5100], M[5100], Cnt, Ans, t,
Ai, _Ai;
struct pt {
int x, y, z;
} p[201000];
bool cmp(pt a, pt b) { return a.z < b.z; }
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; Sum += K[i++])
scanf("%d%d%d%d%d", K + i, A + i, X + i, Y + i, M + i);
for (i = 0; i < n; i++) {
Ai = A[i];
Cnt = 0;
for (j = 0; j < K[i]; j++) {
_Ai = (1ll * Ai * X[i] + Y[i]) % M[i];
if (j + 1 < K[i] && Ai > _Ai) Cnt++;
Ai = _Ai;
}
if (Cnt > Ans) Ans = Cnt;
}
printf("%d\n", Ans);
if (Sum > 200000) return 0;
for (Ans++; Ans--;) {
t = 0;
for (i = 0; i < n; i++) {
_Ai = Ai = A[i];
for (; _K[i] < K[i]; _K[i]++) {
p[t++] = (pt){i, _K[i], Ai};
_Ai = (1ll * Ai * X[i] + Y[i]) % M[i];
if (Ai > _Ai) {
_K[i]++;
break;
}
Ai = _Ai;
}
A[i] = _Ai;
}
std::sort(p, p + t, cmp);
for (i = 0; i < t; i++) printf("%d %d\n", p[i].z, p[i].x + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
register long long x = 0, f = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const int maxn = 2e5;
pair<pair<int, int>, int> a[maxn];
int K, c, x, y, m, n, cnt, t, mx;
int main() {
n = read();
for (register int i = (1); i <= int(n); ++i) {
int K = read(), c = read(), x = read(), y = read(), m = read();
t = 0;
for (register int j = (1); j <= int(K); ++j) {
if (cnt <= maxn) a[++cnt] = make_pair(make_pair(t, c), i);
if (j < K && c > (1ll * c * x + y) % m) t++;
c = (1ll * c * x + y) % m;
}
mx = max(mx, t);
}
sort(a + 1, a + 1 + cnt);
writeln(mx);
if (cnt <= maxn)
for (register int i = (1); i <= int(cnt); ++i)
printf("%d %d\n", a[i].first.second, a[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[25000010], sum, cnt, ans, n, k, x, y, m;
bool bo[25000010];
struct arr {
int x, y;
arr() {}
arr(int x1, int y1) { x = x1, y = y1; }
bool operator<(const arr &o) const {
return a[x] < a[o.x] || a[x] == a[o.x] && x < o.x;
}
};
set<arr> q;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
sum++;
scanf("%d%d%d%d%d", &k, &a[sum], &x, &y, &m);
q.insert(arr(sum, i));
for (int j = 2; j <= k; j++) {
a[sum + 1] = ((long long)a[sum] * x + y) % m;
sum++;
}
bo[sum] = 1;
}
for (int i = 1; i < sum; i++) {
while (bo[i]) i++, cnt = 0;
if (a[i] > a[i + 1]) cnt++;
ans = max(ans, cnt);
}
printf("%d\n", ans);
if (sum > 200000) return 0;
x = y = 0, a[0] = -1;
for (int i = 1; i <= sum; i++) {
set<arr>::iterator p = q.lower_bound(arr(x, y));
if (p == q.end()) p = q.begin();
x = (*p).x, y = (*p).y;
q.erase(p);
printf("%d %d\n", a[x], y);
if (bo[x] == 0) q.insert(arr(x + 1, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = std::numeric_limits<int>::max();
struct Cmp {
Cmp(const vector<deque<int>>& cont) : cont_(&cont) {}
bool operator()(int i, int j) const {
do {
if (!(!cont_->at(i).empty())) {
std::cerr << "empty deque" << std::endl;
assert(false);
}
} while (false);
do {
if (!(!cont_->at(j).empty())) {
std::cerr << "empty deque" << std::endl;
assert(false);
}
} while (false);
return cont_->at(i).front() < cont_->at(j).front() ||
(cont_->at(i).front() == cont_->at(j).front() && i > j);
}
const vector<deque<int>>* cont_;
};
void solve() {
int n;
cin >> n;
vector<deque<int>> a(n);
int numTasks = 0;
for (int i = 0; i < int(n); ++i) {
int k;
cin >> k;
numTasks += k;
{
int x;
cin >> x;
a[i].push_back(x);
}
long long x, y, m;
cin >> x >> y >> m;
for (int j = 0; j < int(k - 1); ++j) {
a[i].push_back((a[i].back() * x + y) % m);
}
}
a.push_back(deque<int>());
a.back().push_back(-1);
Cmp cmp(a);
std::set<int, Cmp> q(cmp);
for (int i = 0; i < int(n); ++i) q.insert(i);
int numDecs = 0;
bool print = numTasks <= 200 * 1000;
vector<pair<int, int>> output;
while (!q.empty()) {
auto it = q.lower_bound(n);
if (it == q.end()) {
it = q.begin();
}
q.erase(it);
int i = *it;
do {
if (!(!a[i].empty())) {
std::cerr << "empty deque" << std::endl;
assert(false);
}
} while (false);
if (a[i].front() < a.back().back()) {
++numDecs;
}
a.back().back() = a[i].front();
if (print) {
output.push_back(make_pair(a[i].front(), i + 1));
}
a[i].pop_front();
if (!a[i].empty()) {
q.insert(i);
}
}
cout << numDecs << endl;
for (int i = 0; i < int(output.size()); ++i) {
cout << output[i].first << " " << output[i].second << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int f, ch[2], x, y;
void Init(int _x, int _y, int _f) {
x = _x;
f = _f;
ch[0] = ch[1] = 0;
y = _y;
}
} pt[1020304];
int now = 0;
struct Splay {
int root;
void Init() { root = 0; }
void zig(int x, bool w) {
int y = pt[x].f;
if (root == y) root = x;
pt[y].ch[!w] = pt[x].ch[w];
if (pt[x].ch[w]) pt[pt[x].ch[w]].f = y;
pt[x].f = pt[y].f;
if (root != x) pt[pt[x].f].ch[y == pt[pt[y].f].ch[1]] = x;
pt[x].ch[w] = y;
pt[y].f = x;
}
void splay(int x) {
while (root != x) {
if (root == pt[x].f)
zig(x, x == pt[root].ch[0]);
else {
int y = pt[x].f, z = pt[y].f;
if (y == pt[z].ch[0])
if (x == pt[y].ch[0]) {
zig(y, 1);
zig(x, 1);
} else {
zig(x, 0);
zig(x, 1);
}
else if (x == pt[y].ch[0]) {
zig(x, 1);
zig(x, 0);
} else {
zig(y, 0);
zig(x, 0);
}
}
}
}
void Ins(int x, int y) {
if (root == 0) {
pt[root = ++now].Init(x, y, 0);
return;
}
int t = root;
bool s;
while (1) {
if (pt[t].ch[s = x > pt[t].x] == 0)
break;
else
t = pt[t].ch[s];
}
++now;
pt[now].Init(x, y, t);
pt[t].ch[s] = now;
splay(now);
}
void Del(int t) {
while (pt[t].ch[0] + pt[t].ch[1])
if (pt[t].ch[0])
zig(pt[t].ch[0], 1);
else
zig(pt[t].ch[1], 0);
if (root == t) {
root = 0;
return;
}
pt[pt[t].f].ch[t == pt[pt[t].f].ch[1]] = 0;
splay(pt[t].f);
}
int Ask(bool w) {
int t = root;
while (pt[t].ch[w]) t = pt[t].ch[w];
return t;
}
pair<int, int> lb(int t, int k) {
if (t == 0) return make_pair((0x3f3f3f3f), (0x3f3f3f3f));
pair<int, int> ret =
make_pair((k <= pt[t].x) ? pt[t].x : ((0x3f3f3f3f)), t);
if (k > pt[t].x)
return lb(pt[t].ch[1], k);
else
return min(ret, lb(pt[t].ch[0], k));
}
} T;
int n, x[1020304], a[1020304], y[1020304], k[1020304], m[1020304];
int cur[1020304];
pair<int, int> res[1020304];
int main() {
cin >> n;
int s = 0;
for (int i = 1; i <= n; ++i)
scanf("%d%d%d%d%d", &k[i], &a[i], &x[i], &y[i], &m[i]), s += k[i],
cur[i] = 1;
T.Init();
for (int i = 1; i <= n; ++i) T.Ins(a[i], i);
int p = 0;
int lst = -1;
int Tot = 0, ans = 0;
while (p < s) {
int t = T.lb(T.root, lst).second;
if (t == (0x3f3f3f3f)) t = T.Ask(0), ++ans;
lst = pt[t].x;
if (Tot <= 200000) res[++Tot] = make_pair(pt[t].x, pt[t].y);
++p;
if (cur[pt[t].y] < k[pt[t].y])
T.Ins(((long long)pt[t].x * x[pt[t].y] + y[pt[t].y]) % m[pt[t].y],
pt[t].y),
++cur[pt[t].y];
T.Del(t);
}
cout << ans << endl;
if (Tot <= 200000)
for (int i = 1; i <= Tot; ++i)
printf("%d %d\n", res[i].first, res[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
bool flag1, flag2;
int n, m, rb, x, y, mo, now, ans;
int a[N], b[N];
int main() {
scanf("%d", &rb);
scanf("%d %d %d %d %d", &n, a + 1, &x, &y, &mo);
for (int i = 2; i <= n; i++) {
a[i] = ((long long)a[i - 1] * x + y) % mo;
now += (a[i] < a[i - 1]);
}
ans = now;
now = 0;
scanf("%d %d %d %d %d", &m, b + 1, &x, &y, &mo);
for (int i = 2; i <= m; i++) {
b[i] = ((long long)b[i - 1] * x + y) % mo;
now += (b[i] < b[i - 1]);
}
if (now > ans) ans = now;
printf("%d\n", ans);
if (n + m > 200000) return 0;
int i = 1, j = 1;
flag1 = flag2 = false;
while (i <= n && j <= m) {
if (flag1 && flag2) {
flag1 = flag2 = false;
continue;
} else if (flag2 || (!flag1 && a[i] <= b[j])) {
printf("%d 1\n", a[i++]);
if (a[i] < a[i - 1]) flag1 = true;
} else {
printf("%d 2\n", b[j++]);
if (b[j] < b[j - 1]) flag2 = true;
}
}
for (; i <= n; printf("%d 1\n", a[i++]))
;
for (; j <= m; printf("%d 2\n", b[j++]))
;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[5010];
void solve(int l, int r, vector<pair<int, int> >& cur) {
if (l == r) {
for (int i = 0; i < (int)vec[l].size(); i++)
cur.push_back(make_pair(vec[l][i], l));
return;
}
int mid = (l + r) >> 1;
vector<pair<int, int> > lef, rig;
solve(l, mid, lef);
solve(mid + 1, r, rig);
int p1 = 0, p2 = 0;
while (p1 < (int)lef.size() || p2 < (int)rig.size()) {
if (p1 == (int)lef.size()) {
cur.insert(cur.end(), rig.begin() + p2, rig.end());
break;
} else if (p2 == (int)rig.size()) {
cur.insert(cur.end(), lef.begin() + p1, lef.end());
break;
} else {
int liml = p1 + 1, limr = p2 + 1;
for (; liml < (int)lef.size() && lef[liml] >= lef[liml - 1]; liml++)
;
for (; limr < (int)rig.size() && rig[limr] >= rig[limr - 1]; limr++)
;
while (p1 < liml && p2 < limr) {
if (lef[p1].first < rig[p2].first)
cur.push_back(lef[p1]), p1++;
else
cur.push_back(rig[p2]), p2++;
}
if (p1 < liml)
cur.insert(cur.end(), lef.begin() + p1, lef.begin() + liml), p1 = liml;
if (p2 < limr)
cur.insert(cur.end(), rig.begin() + p2, rig.begin() + limr), p2 = limr;
}
}
}
int main() {
int N;
scanf("%d", &N);
int sigmak = 0;
for (int i = 1; i <= N; i++) {
int k, a, x, y, m;
scanf("%d%d%d%d%d", &k, &a, &x, &y, &m);
vec[i].push_back(a);
for (int j = 2; j <= k; j++)
vec[i].push_back(a = ((long long)a * x + y) % m);
sigmak += k;
}
int ans1 = 0;
for (int i = 1; i <= N; i++) {
int cur = 0;
for (int j = 1; j < (int)vec[i].size(); j++)
cur += vec[i][j] < vec[i][j - 1];
ans1 = max(ans1, cur);
}
printf("%d\n", ans1);
if (sigmak <= 200000) {
vector<pair<int, int> > ans2;
solve(1, N, ans2);
for (int i = 0; i < (int)ans2.size(); i++)
printf("%d %d\n", ans2[i].first, ans2[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
const long double E = 1e-9;
unsigned char ccc;
bool _minus = false;
template <typename T>
inline T sqr(T t) {
return (t * t);
}
inline void read(long long &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
inline void read(int &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
char wwww[19];
int kkkk;
inline void write(long long y) {
long long x = y;
kkkk = 0;
if (x < 0) {
putchar('-');
x *= -1;
}
if (!x)
++kkkk, wwww[kkkk] = '0';
else
while (x) {
++kkkk;
wwww[kkkk] = char(x % 10 + '0');
x /= 10;
}
for (int i = kkkk; i >= 1; --i) putchar(wwww[i]);
}
int n;
const int MAX = 5000;
vector<int> vec[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
srand(time(NULL));
cout.precision(10);
cout << fixed;
int n;
cin >> n;
int s = 0;
for (int i = 0; i < n; i++) {
int k;
long long a, x, y, m;
cin >> k >> a >> x >> y >> m;
vec[i].push_back(a);
while ((int)vec[i].size() < k) {
a = (a * x + y) % m;
vec[i].push_back(a);
}
s += k;
reverse(vec[i].begin(), vec[i].end());
}
bool ok = true;
vector<pair<int, int> > ans;
int _ans = -1;
while (ok) {
_ans++;
vector<pair<int, int> > res;
ok = false;
for (int i = 0; i < n; i++) {
if (!vec[i].empty()) {
int val = vec[i].back();
res.push_back(make_pair(val, i + 1));
vec[i].pop_back();
while (!vec[i].empty() && vec[i].back() >= val) {
val = vec[i].back();
vec[i].pop_back();
res.push_back(make_pair(val, i + 1));
}
if (!vec[i].empty()) ok = true;
}
}
sort(res.begin(), res.end());
ans.insert(ans.end(), res.begin(), res.end());
}
cout << _ans << "\n";
if ((int)ans.size() <= 200000)
for (pair<int, int> a : ans) {
cout << a.first << " " << a.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, sumk, cnt;
long long a, x, y, m;
vector<vector<long long> > vec;
vector<pair<int, int> > ans;
int idx[1 << 13];
set<pair<int, int> > st;
set<pair<int, int> >::iterator it;
void build(int idx) {
vec[idx].resize(k);
for (int i = 0; i < k; i++) {
vec[idx][i] = a;
a = (a * x + y) % m;
}
}
void read() {
scanf("%d", &n);
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> k >> a >> x >> y >> m;
build(i);
sumk += k;
}
}
void solve() {
int last = -1;
int br = 0;
for (int i = 0; i < n; i++) st.insert(make_pair((int)vec[i][0], i));
while (1) {
if (br == sumk) break;
br++;
int row;
it = st.lower_bound(make_pair(last, -1));
if (it == st.end()) {
cnt++;
it = st.begin();
}
row = (*it).second;
st.erase(it);
ans.push_back(make_pair(vec[row][idx[row]], row + 1));
last = vec[row][idx[row]];
idx[row]++;
if (idx[row] < vec[row].size())
st.insert(make_pair(vec[row][idx[row]], row));
}
printf("%d\n", cnt);
if (sumk <= 200000) {
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1000000000000000000LL;
const double eps = 1e-9;
void prepare(string s) {}
const int MAXN = 10 * 1000 + 41;
const int CNTANS = 200 * 1000;
int nn[MAXN];
long long a00[MAXN];
long long xx[MAXN];
long long yy[MAXN];
long long MOD[MAXN];
bool solve() {
int N;
cin >> N;
int sum = 0;
set<pair<long long, int> > s;
for (int i = 0; i < N; ++i) {
cin >> nn[i] >> a00[i] >> xx[i] >> yy[i] >> MOD[i];
s.insert(pair<long long, int>(a00[i], i));
sum += nn[i];
}
vector<pair<int, int> > ans;
int prec = -1;
int res = 0;
while (!s.empty()) {
set<pair<long long, int> >::iterator it =
s.lower_bound(pair<long long, int>(prec, -1));
if (it == s.end()) {
it = s.begin();
++res;
}
if (sum <= CNTANS) ans.push_back(pair<int, int>(it->first, it->second));
prec = it->first;
int i = it->second;
s.erase(it);
if (--nn[i]) {
a00[i] = (a00[i] * xx[i] + yy[i]) % MOD[i];
s.insert(pair<long long, int>(a00[i], i));
}
}
cout << res << endl;
for (int i = 0; i < (int)ans.size(); ++i)
cout << ans[i].first << ' ' << ans[i].second + 1 << endl;
return false;
}
int main() {
prepare("");
while (solve()) {
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, i, j, k, x, y, m, curr, c, id, total = 0;
cin >> n;
vector<long long> ct(n), v(n, 0);
vector<vector<long long>> a(n);
for (i = 0; i < n; i++) {
cin >> ct[i];
total += ct[i];
a[i].resize(ct[i]);
cin >> a[i][0] >> x >> y >> m;
for (j = 1; j < ct[i]; j++) {
a[i][j] = (a[i][j - 1] * x + y) % m;
}
}
priority_queue<pair<long long, long long>> pq;
queue<pair<long long, long long>> q;
vector<pair<long long, long long>> ans;
c = 0;
curr = 0;
for (i = 0; i < n; i++) pq.push({-a[i][0], i});
while (!pq.empty() || !q.empty()) {
if (pq.empty()) {
c++;
curr = 0;
while (!q.empty()) {
pq.push(q.front());
q.pop();
}
}
while (!pq.empty()) {
x = -pq.top().first;
id = pq.top().second;
pq.pop();
if (total <= 200000) ans.push_back({x, id});
curr = x;
v[id]++;
if (v[id] < ct[id]) {
if (a[id][v[id]] < curr)
q.push({-a[id][v[id]], id});
else
pq.push({-a[id][v[id]], id});
}
}
}
cout << c << "\n";
for (auto p : ans) cout << p.first << " " << p.second + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int S, n;
cin >> S >> n;
pair<int, int> p[n];
bool f = 0;
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
if (S > p[i].first)
S += p[i].second;
else
f = 1;
}
if (f)
printf("NO");
else
printf("YES");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
multimap<int, int> m;
multimap<int, int>::iterator it;
long str, n, i, x, y, bp, s;
cin >> str >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
m.insert(make_pair(x, y));
}
for (it = m.begin(); it != m.end(); ++it) {
s = it->first;
bp = it->second;
if (str > s)
str += bp;
else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int swap(int &a, int &b) {
a ^= b;
b ^= a;
a ^= b;
return 0;
}
int main() {
int s, n;
cin >> s >> n;
int x[n], y[n];
int i, j;
for (i = 0; i < n; i++) cin >> x[i] >> y[i];
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (x[j] > x[j + 1]) {
swap(x[j], x[j + 1]);
swap(y[j], y[j + 1]);
}
}
}
for (i = 0; i < n; i++) {
if (s > x[i]) {
s = s + y[i];
} else {
cout << "NO";
break;
}
}
if (i == n) cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<pair<long long, long long> > v;
long long s, n, x, y;
cin >> s >> n;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, -y));
}
sort(v.begin(), v.end());
for (long long i = 0; i < n; i++) {
v[i].second *= -1;
}
for (long long i = 0; i < n; i++) {
if (s > v[i].first) {
s += v[i].second;
} else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > dragon;
int s;
int n;
int bonus;
int dueled = true;
int main() {
cin >> s >> n;
int count = 0;
dragon.resize(n);
for (int i = 0; i < n; ++i) cin >> dragon[i].second >> dragon[i].first;
while (dueled && count < dragon.size()) {
dueled = false;
for (int i = dragon.size() - 1; i >= 0; --i) {
if (dragon[i].second != -1)
if (s > dragon[i].second)
s += dragon[i].first, dragon[i].second = -1, dueled = true, count++;
}
}
if (count == dragon.size())
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, n;
cin >> s >> n;
int N = n;
vector<pair<int, int>> po;
while (N--) {
int a, b;
cin >> a >> b;
po.push_back(make_pair(a, b));
}
sort(po.begin(), po.end());
for (int i = 0; i < n; i++) {
if (s > po[i].first) {
s += po[i].second;
} else {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned power, n;
cin >> power >> n;
vector<unsigned> v[2];
for (unsigned i = 0; i < n; i++) {
unsigned a, b;
cin >> a >> b;
v[0].push_back(a);
v[1].push_back(b);
}
while (v[0].size() != 0) {
bool bb = false;
for (unsigned i = 0; i < v[0].size(); i++)
if (v[0][i] < power) {
bb = true;
power += v[1][i];
v[0].erase(v[0].begin() + i, v[0].begin() + i + 1);
v[1].erase(v[1].begin() + i, v[1].begin() + i + 1);
}
if (!bb) {
cout << "NO";
exit(0);
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, n;
cin >> s >> n;
pair<int, int> v[n];
for (int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
sort(v, v + n);
for (int i = 0; i < n; i++) {
if (s > v[i].first)
s += v[i].second;
else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[1001];
int main() {
int second, n, x, y;
cin >> second >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
a[i] = make_pair(x, y);
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i].first >= second) {
cout << "NO";
return 0;
}
second += a[i].second;
}
cout << "YES";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int kiritoStrength;
tuple<int, int> dragonInfo;
vector<tuple<int, int>> dragonArray;
int dragonStrength;
int dragonBonus;
cin >> kiritoStrength >> n;
for (int i = 0; i < n; i++) {
cin >> dragonStrength >> dragonBonus;
dragonInfo = make_tuple(dragonStrength, dragonBonus);
dragonArray.push_back(dragonInfo);
}
sort(dragonArray.begin(), dragonArray.end());
for (int i = 0; i < dragonArray.size(); i++) {
if (kiritoStrength > get<0>(dragonArray[i])) {
kiritoStrength += get<1>(dragonArray[i]);
} else if (kiritoStrength <= get<0>(dragonArray[i])) {
cout << "NO" << endl;
exit(0);
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
scanf("%d %d", &s, &n);
pair<int, int> A[100000];
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
A[i] = make_pair(x, y);
}
sort(A, A + n);
int ct = 0;
for (int i = 0; i < n; i++) {
if (A[i].first < s) {
s += A[i].second;
ct++;
} else
break;
}
if (ct == n)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const constexpr int INF = 1e9;
const constexpr long long MOD = 1e9 + 7;
const int BITSIZE = 100010;
struct Less {
bool operator()(const pair<int, int>& x, const pair<int, int>& y) const {
return x.first < y.first;
}
};
struct More {
bool operator()(const pair<int, int>& x, const pair<int, int>& y) const {
return x.first > y.first;
}
};
int bit[100010];
int bit_query(int i) {
int res = 0;
for (; i >= 1; i -= i & -i) res = max(res, bit[i]);
return res;
}
void bit_set(int x, int v) {
for (; x <= BITSIZE; x += x & -x) {
bit[x] = max(bit[x], v);
}
}
long long pow_mod(long long a, long long b) {
long long sum = 1;
while (b > 0) {
if (b & 1) {
sum *= a % MOD;
}
a = a * a % MOD;
b >>= 1;
}
return sum;
}
int N, M;
char a[51][51];
vector<pair<int, int> > vp;
int main() {
int s, n;
cin >> s >> n;
for (long long i = (long long)0; i < (long long)n; ++i) {
int x, y;
cin >> x >> y;
vp.push_back({x, y});
}
sort(vp.begin(), vp.end(), Less());
bool f = true;
for (int i = 0; i < n; ++i) {
if (s > vp[i].first) {
s += vp[i].second;
} else {
f = false;
break;
}
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> Arr[1000];
int main() {
int s, n, i = 0;
cin >> s >> n;
for (int i = 0; i < n; i++) cin >> Arr[i].first >> Arr[i].second;
sort(Arr, Arr + n);
for (int j = 0; j < n; j++) {
if (s <= Arr[j].first) {
cout << "NO\n";
return 0;
} else
s += Arr[j].second;
}
cout << "YES\n";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int s, n, i, temp, j, count = 0;
scanf("%d %d", &s, &n);
int a[n][2];
for (i = 0; i < n; i++) {
scanf("%d %d", &a[i][0], &a[i][1]);
}
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
if (a[j][0] < a[i][0]) {
temp = a[j][0];
a[j][0] = a[i][0];
a[i][0] = temp;
temp = a[j][1];
a[j][1] = a[i][1];
a[i][1] = temp;
}
}
}
if (s <= a[0][0]) {
printf("NO");
return 0;
}
for (i = 0; i < n; i++) {
if (s > a[i][0]) count++;
}
if (count > 1) {
for (i = 0; i < count; i++) {
for (j = i; j < count; j++) {
if (a[j][1] > a[i][1]) {
temp = a[j][0];
a[j][0] = a[i][0];
a[i][0] = temp;
temp = a[j][1];
a[j][1] = a[i][1];
a[i][1] = temp;
}
}
}
}
for (i = 0; i < n - 1; i++) {
s = s + a[i][1];
if (s <= a[i + 1][0]) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > pa;
int s, n;
cin >> s >> n;
bool can = true;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
pa.push_back(make_pair(x, y));
}
sort(pa.begin(), pa.end());
for (int i = 0; i < n; i++) {
if (s > pa[i].first) {
s += pa[i].second;
} else {
can = 0;
break;
}
}
if (can)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int x, y;
} B;
bool cmp(B b1, B b2) { return b1.x < b2.x; }
int main() {
B b[1100];
int i, j, n, s, k;
while (scanf("%d%d", &s, &n) != EOF) {
for (i = 0; i < n; i++) scanf("%d%d", &b[i].x, &b[i].y);
sort(b, b + n, cmp);
while (1) {
sort(b, b + n, cmp);
if (b[n - 1].x < s) {
printf("YES\n");
break;
}
k = 0;
while (!b[k].x && k < n) k++;
if (b[k].x >= s) {
printf("NO\n");
break;
}
int max = 0;
j = k;
for (i = k; i < n; i++) {
if (b[k].x < s) {
if (b[k].y > max) {
max = b[k].y;
j = k;
}
} else
break;
}
s = s + b[j].y;
getchar();
b[j].x = 0;
b[j].y = 0;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.