solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
int ctz(unsigned x) { return __builtin_ctz(x); }
int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
int clz(unsigned x) { return __builtin_clz(x); }
int clzll(unsigned long long x) { return __builtin_clzll(x); }
int popcnt(unsigned x) { return __builtin_popcount(x); }
int popcntll(unsigned long long x) { return __builtin_popcountll(x); }
int bsr(unsigned x) { return 31 ^ clz(x); }
int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int x[10000];
pair<int, int> nxt[10000];
int dist[10000][1008];
pair<int, int> q[1008 * 10000];
int bfs(int m, int k, int g, int r) {
int cnt = 0;
for (int i = 0; i < k; ++i) {
int u = q[i].first, tu = q[i].second;
int du = dist[u][tu];
if (tu == g) {
int v = u, tv = 0, dv = du + r;
if (dist[v][tv] > dv) {
dist[v][tv] = v;
nxt[cnt++] = {v, dv};
}
continue;
}
if (u > 0) {
int v = u - 1;
int tv = tu + x[u] - x[v];
int dv = du + x[u] - x[v];
if (tv <= g && dist[v][tv] > dv) {
dist[v][tv] = dv;
q[k++] = {v, tv};
}
}
if (u + 1 < m) {
int v = u + 1;
int tv = tu + x[v] - x[u];
int dv = du + x[v] - x[u];
if (tv <= g && dist[v][tv] > dv) {
dist[v][tv] = dv;
q[k++] = {v, tv};
}
}
}
return cnt;
}
int main() {
canhazfast();
int n, m, g, r, k = 0;
int ans = 200000000;
cin >> n >> m;
for (int i = 0; i < m; ++i) cin >> x[i];
cin >> g >> r;
sort(x, x + m);
for (int i = 0; i < m; ++i) fill_n(dist[i], g + 1, 200000000);
nxt[k++] = {0, 0};
while (k > 0) {
for (int i = 0; i < k; ++i) {
int u = nxt[i].first, du = nxt[i].second;
dist[u][0] = du;
q[i] = {u, 0};
}
k = bfs(m, k, g, r);
}
for (int i = 0; i <= g; ++i) ans = min(ans, dist[m - 1][i]);
if (ans >= 200000000) ans = -1;
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int i;
for (i = 1; i <= 100000; i++) a[i] = -1;
int n, x, k;
scanf("%d", &n);
int valid = 1;
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &k);
if (a[k] < x - 1)
valid = 0;
else
a[k] = max(a[k], x);
}
if (valid)
printf("YES\n");
else
printf("NO\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f3f;
const int maxn = 210;
int d[maxn][maxn], di[maxn][maxn];
int rk[maxn][maxn];
int main() {
int n, m, a, b, c;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
d[i][i] = 0;
di[i][i] = 0;
for (int j = i + 1; j <= n; j++) {
di[i][j] = di[j][i] = inf;
d[i][j] = d[j][i] = inf;
}
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
d[a][b] = d[b][a] = c;
di[a][b] = di[b][a] = c;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) rk[i][j] = j;
for (int j = 1; j <= n; j++) {
for (int k = j + 1; k <= n; k++) {
if (d[i][rk[i][j]] > d[i][rk[i][k]]) {
swap(rk[i][j], rk[i][k]);
}
}
}
}
int ans = inf;
for (int u = 1; u <= n; u++) {
for (int v = 1; v <= n; v++)
if (u != v) {
ans = min(ans, d[u][rk[u][n]] << 1);
ans = min(ans, d[v][rk[v][n]] << 1);
for (int cmp = n, i = n - 1; i >= 1; i--) {
if (d[v][rk[u][i]] > d[v][rk[u][cmp]]) {
ans = min(ans, d[u][rk[u][i]] + d[v][rk[u][cmp]] + di[u][v]);
cmp = i;
}
}
}
}
printf("%lf\n", (double)ans / 2);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
long long ans[222222];
int T[222222], D[222222];
int main(int argc, char *argv[]) {
int N, B;
scanf("%d%d", &N, &B);
for (int i = 0; i < (N); i++) scanf("%d%d", T + i, D + i);
int pos = 0;
long long last_t = 0;
while (pos != N || !q.empty()) {
if (q.empty()) {
q.push(pos++);
continue;
}
int id = q.front();
q.pop();
last_t = ans[id] = max(last_t, (long long)T[id]) + D[id];
while (pos < N && T[pos] < last_t) {
if (q.size() < B)
q.push(pos++);
else
ans[pos++] = -1;
}
}
for (int i = 0; i < (N); i++) {
if (i) printf(" ");
cout << ans[i];
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
map<pair<int, int>, vector<int> > Y;
const int MAXN = 101000;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int revMemo[MAXN];
int rev(int x) {
int& ret = revMemo[x];
if (ret != -1) return ret;
ret = 0;
while (x > 0) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
int add[MAXN];
bool cmp(const pair<int, int>& A, const pair<int, int>& B) {
return (long long)A.first * A.second < (long long)B.first * B.second;
}
int main() {
memset((revMemo), (-1), sizeof(revMemo));
for (int i = (1); i < (100010); ++i) {
int y = i;
int yrev = rev(y);
int d = gcd(y, yrev);
y /= d, yrev /= d;
Y[pair<int, int>(yrev, y)].push_back(i);
}
int maxX, maxY, w;
cin >> maxX >> maxY >> w;
pair<int, int> ans(inf, inf);
int cury = 0;
int cs = 0;
memset((add), (0), sizeof(add));
for (int i = (1); i < (maxX + 1); ++i) {
int x = i;
int xrev = rev(x);
int d = gcd(x, xrev);
x /= d, xrev /= d;
vector<int>& a = Y[pair<int, int>(x, xrev)];
for (int j = (0); j < ((int)a.size()); ++j) {
int y = a[j];
if (y <= cury) ++cs;
++add[y];
}
if (cs >= w) {
while (cs - add[cury] >= w) cs -= add[cury], --cury;
} else {
while (cury < maxY && cs < w) cs += add[++cury];
}
if (cs >= w) ans = min(ans, pair<int, int>(i, cury), cmp);
}
if (ans.first == inf)
printf("-1\n");
else
printf("%d %d\n", ans.first, ans.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[500 + 10];
int c[50];
int main() {
scanf("%d", &n);
int k = 0;
if (n == 0) {
printf("%c", 'a');
return 0;
}
for (int i = 1; (i + 1) * i / 2 <= n; i++) {
a[i] = (i + 1) * i / 2;
k = i;
}
int j = k;
int w = 0;
while (j) {
if (a[j] > n)
j--;
else {
n = n - a[j];
c[w++] = j;
}
}
for (int i = 0; i < w; i++) {
for (int j = 0; j <= c[i]; j++) {
printf("%c", 'a' + i);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int d, q, mx, a[(int)1e5 + 4];
int main() {
cin >> s >> d;
for (int i = 0; i < d; i++) {
scanf("%d", &q);
a[q - 1]++;
}
int y = s.size();
for (int i = 0; i < y / 2; i++) {
if (i != 0) a[i] += a[i - 1];
if (a[i] % 2 == 1) swap(s[i], s[y - 1 - i]);
}
cout << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, len;
long long sum, result;
struct xvlie {
long long s, h;
string str;
} ar[100005];
bool cmp(const xvlie &a, const xvlie &b) { return a.s * b.h > a.h * b.s; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> ar[i].str;
len = ar[i].str.length();
for (int j = 0; j < len; j++) {
if (ar[i].str[j] == 's') ar[i].s++;
if (ar[i].str[j] == 'h') ar[i].h++;
}
}
sort(ar + 1, ar + 1 + n, cmp);
for (int i = 2; i <= n; i++) ar[1].str += ar[i].str;
len = ar[1].str.length();
for (int i = 0; i < len; i++) {
if (ar[1].str[i] == 's') sum++;
if (ar[1].str[i] == 'h') result += sum;
}
cout << result << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 2e5 + 10;
long long n;
long long a[N];
vector<long long> g[N];
long long col[N];
long long dp[N][2];
long long res = 0;
void dfs(long long node, long long par = -1, long long cc = 0) {
col[node] = cc;
dp[node][0] = 1;
for (auto x : g[node])
if (x != par) {
dfs(x, node, cc ^ 1);
dp[node][1] += dp[x][0];
dp[node][0] += dp[x][1];
}
}
void dfs2(long long node, long long par = -1) {
long long temp = 0;
for (auto x : g[node]) {
if (x == par) continue;
dfs2(x, node);
temp += dp[x][1] * (n - dp[x][0] - dp[x][1]);
temp -= dp[x][0] * (n - dp[x][0] - dp[x][1]);
temp %= MOD;
if (temp < 0) temp += MOD;
}
if (col[1] == col[node]) {
temp += (dp[1][0] - dp[node][0]) * (dp[node][0] + dp[node][1]);
temp -= (dp[1][1] - dp[node][1]) * (dp[node][0] + dp[node][1]);
} else {
temp += (dp[1][1] - dp[node][0]) * (dp[node][0] + dp[node][1]);
temp -= (dp[1][0] - dp[node][1]) * (dp[node][0] + dp[node][1]);
}
temp += n;
temp %= MOD;
if (temp < 0) temp += MOD;
temp *= a[node];
temp %= MOD;
if (temp < 0) temp += MOD;
res += temp;
res %= MOD;
}
void solve() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i + 1];
long long u, v;
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
dfs2(1);
cout << res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int T, n, m, num[maxn];
vector<int> now[maxn];
void solve() {
scanf("%d%d", &n, &m);
int cnt = 0;
for (int i = 1; i <= n; i++) now[i].clear(), num[i] = 0;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
now[y].push_back(x);
}
for (int i = 1; i <= n; i++)
for (auto j : now[i])
if (num[j] < 2) num[i] = max(num[i], num[j] + 1);
for (int i = 1; i <= n; i++)
if (num[i] == 2) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (num[i] == 2) printf("%d ", i);
printf("\n");
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
char c[MAXN];
int g[MAXN][26], col[MAXN], is_f[MAXN];
int used[3];
void dfs(int s) {
int i, to, fl[4];
for (i = 0; i < 4; i++) {
fl[i] = 0;
}
for (i = 0; i < 26; i++) {
to = g[s][i];
if (to) {
dfs(to);
fl[col[to]] = 1;
}
}
if (fl[3] || fl[0] && fl[1]) {
col[s] = 2;
} else if (fl[0]) {
col[s] = 1;
} else if (fl[1]) {
col[s] = 0;
} else if (fl[2]) {
col[s] = 3;
}
}
void solve() {
int n, i, j, s, top = 1, k;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%s", &c[0]);
for (s = 0, j = 0; c[j]; j++) {
if (g[s][c[j] - 'a']) {
s = g[s][c[j] - 'a'];
} else {
g[s][c[j] - 'a'] = top;
s = top++;
}
}
}
dfs(0);
if (col[0] == 3 || col[0] == 0 || col[0] == 1 && k % 2 == 0) {
printf("Second\n");
} else {
printf("First\n");
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i = -1;
const int N = 101;
int cl[N], ja[N], jan = 0, jd[N], jdn = 0;
char buf[18];
while (++i < n) {
scanf("%s%d", buf, ja + jan);
if (buf[0] == 'A')
++jan;
else
jd[jdn++] = ja[jan];
}
i = -1;
int cl1[N];
while (++i < m) {
scanf("%d", cl + i);
}
sort(ja, ja + jan);
sort(jd, jd + jdn);
sort(cl, cl + m);
i = -1;
while (++i < m) cl1[i] = cl[i];
i = -1;
int j = 0;
while (++i < jdn) {
while (j < m && cl[j] <= jd[i]) ++j;
if (j == m)
break;
else {
cl[j] = -1;
}
}
int td = 0;
if (i == jdn) {
j = 0;
i = -1;
while (++i < jan) {
while (j < m && cl[j] < ja[i]) ++j;
if (j == m)
break;
else {
td += cl[j] - ja[i];
cl[j] = -1;
}
}
if (i == jan) {
i = -1;
while (++i < m) {
if (cl[i] > 0) td += cl[i];
}
}
}
i = -1;
j = m - 1;
int td2 = 0;
while (++i < jan) {
if (j > -1 && cl1[j] > ja[i]) {
td2 += cl1[j] - ja[i];
--j;
} else {
break;
}
}
printf("%d\n", td > td2 ? td : td2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b = 0;
cin >> n;
int arr[n];
set<int> s;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] > n) {
b++;
} else
s.insert(arr[i]);
}
cout << b + ((n - b) - s.size()) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, P[100006], S[100006], fst[100006], t, u, v, q, nr, NRA[100006];
bool R[100006];
struct edge {
int nod;
bool p, s;
};
vector<edge> V[100006];
vector<pair<int, int> > E;
pair<int, int> rmq[21][100006 * 2];
void dfs(int nod, int nr) {
NRA[nod] = nr;
for (auto it : V[nod]) {
P[it.nod] = P[nod] + it.p;
S[it.nod] = S[nod] + it.s;
dfs(it.nod, nr);
}
}
void euler(int nod, int niv) {
fst[nod] = E.size();
E.push_back({nod, niv});
for (auto it : V[nod]) {
euler(it.nod, niv + 1);
E.push_back({nod, niv});
}
}
int LCA(int a, int b) {
int x, y = abs(fst[b] - fst[a]);
x = log2(y);
if (rmq[x][min(fst[a], fst[b])].second <
rmq[x][max(fst[a], fst[b]) - (1 << x) + 1].second)
return rmq[x][min(fst[a], fst[b])].first;
return rmq[x][max(fst[a], fst[b]) - (1 << x) + 1].first;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
if (x == -1) {
R[i] = true;
continue;
}
V[x].push_back({i, (y == 1), (y == 0)});
}
for (int i = 1; i <= n; i++)
if (R[i] == true) {
dfs(i, ++nr);
euler(i, 1);
}
int mx = log2(E.size());
for (int i = 0; i <= mx; i++)
for (int j = 0; j < E.size() - (1 << i) + 1; j++) {
if (i == 0) {
rmq[i][j] = E[j];
continue;
}
if (rmq[i - 1][j].second > rmq[i - 1][j + (1 << (i - 1))].second)
rmq[i][j] = rmq[i - 1][j + (1 << (i - 1))];
else
rmq[i][j] = rmq[i - 1][j];
}
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> t >> u >> v;
if (t == 1) {
if (NRA[v] == NRA[u] && LCA(v, u) == u && v != u &&
S[u] - S[v] == E[fst[u]].second - E[fst[v]].second)
cout << "YES\n";
else
cout << "NO\n";
} else {
int x;
if (NRA[v] == NRA[u]) x = LCA(v, u);
if (NRA[v] == NRA[u] && v != u && x != v &&
P[x] - P[v] == E[fst[x]].second - E[fst[v]].second &&
S[x] - S[u] == E[fst[x]].second - E[fst[u]].second)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, k, t, w;
int ans;
string s[50];
int p[50];
void dfs(int x, int y, string ss) {
if (x == n) {
if (y < p[1]) return;
for (i = 1; i <= m; i++) {
int cnt = 0;
for (j = 0; j <= n - 1; j++) cnt += (ss[j] == s[i][j]);
if (cnt != p[i]) return;
}
ans++;
return;
}
if (y < p[1]) dfs(x + 1, y + 1, ss + s[1][x]);
dfs(x + 1, y, ss + char('0' + '1' - s[1][x]));
}
int main() {
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> s[i] >> p[i];
}
dfs(0, 0, "");
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
std::string to_base_26(int num) {
char alphabet[] = {'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y'};
std::string s = "";
bool sub = false;
while (num > 0) {
s += alphabet[num % 26];
if (num % 26 == 0) sub = true;
num /= 26;
if (sub == true) {
num--;
sub = false;
}
}
std::reverse(s.begin(), s.end());
return s;
}
int to_base_10(std::string s) {
int num = 0, size = s.size();
for (int i = 0, p = size - 1; i < size; i++, p--) {
num += ((((int)s[p]) - 64)) * ((int)std::pow(26.0, (float)i));
}
return num;
}
void convert_A_to_B(std::string a) {
int size = a.size();
std::vector<char> rows, col;
bool is_col = false;
for (int i = 1; i < size; i++) {
if (a[i] == 'C') {
is_col = true;
continue;
}
if (is_col)
col.push_back(a[i]);
else
rows.push_back(a[i]);
}
std::string r(rows.begin(), rows.end()), c(col.begin(), col.end());
int ri = std::stoi(c);
std::string ret = to_base_26(ri);
std::cout << ret << r << "\n";
}
void convert_B_to_A(std::string b) {
int size = b.size();
std::string rows = "", col = "";
bool is_col = true;
for (int i = 0; i < size; i++) {
if ((int)b[i] >= 48 && (int)b[i] <= 57) {
is_col = false;
}
if (is_col)
col += b[i];
else
rows += b[i];
}
int ret = to_base_10(col);
std::cout << "R" << rows << "C" << ret << "\n";
}
bool is_string_A(std::string s) {
bool b = false, a = false;
int size = s.size();
for (int i = 0; i < size; i++) {
if ((int)s[i] >= 65 && (int)s[i] <= 90) {
if (b && a) return true;
b = true;
} else
a = true;
}
return false;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> n;
for (int i = 0; i < n; i++) {
std::string s;
std::cin >> s;
if (is_string_A(s))
convert_A_to_B(s);
else
convert_B_to_A(s);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void solve(int num, std::istream& in, std::ostream& out) {
int n, k;
in >> n >> k;
vector<long long> arr(n);
for (int i = 0; i < n; i++) {
in >> arr[i];
}
sort(arr.begin(), arr.end());
long long mx = arr.back();
for (int i = n - 2; i >= 0 && k > 0; i--, k--) {
mx += arr[i];
}
out << mx << endl;
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
int T;
in >> T;
for (int i = 0; i < T; i++) solution.solve(i + 1, in, out);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int euler_totient(long long int n) {
long long int result = n;
for (long long int p = 2; p * p <= n; ++p) {
if (n % p == 0) {
while (n % p == 0) n /= p;
result -= result / p;
}
}
if (n > 1) result -= result / n;
return result;
}
vector<long long int> primes;
void ff() {
primes.push_back(2);
for (int i = 3; i < 31625; i += 2) {
for (int j = 0; j < primes.size(); j++) {
if (i % primes[j] == 0) break;
if (primes[j] * primes[j] > i) {
primes.push_back(i);
break;
}
}
}
}
long long int x, y;
long long int mm = 1000000007;
void ext_euclid(long long int m, long long int c) {
if (c == 0) {
x = 1;
y = 0;
} else {
ext_euclid(c, m % c);
int temp = x;
x = y;
y = temp - (m / c) * y;
}
}
long long int mod_exp(long long int x, long long int y, long long int mm) {
if (y == 0)
return 1;
else if (y % 2 == 0) {
return mod_exp((x * x) % mm, y / 2, mm);
} else
return (x * mod_exp((x * x) % mm, (y - 1) / 2, mm)) % mm;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int arr[n + 1];
memset(arr, 0, sizeof(arr));
map<long long int, long long int> index;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
index[arr[i]] = i;
}
int check[n + 1];
memset(check, 0, sizeof(check));
for (int i = 1; i <= n; i++) {
long long int x = index[i];
if (x == i) {
arr[x] = i;
continue;
}
for (int j = x - 1; j >= i; j--) {
if (check[j] != 1) {
if (arr[j] < arr[j + 1]) break;
int t = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = t;
index[arr[j + 1]] = j + 1;
index[arr[j]] = j;
check[j] = 1;
} else if (check[j] == 1)
break;
}
}
for (int i = 1; i <= n; i++) cout << arr[i] << ' ';
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int m = 1000000007;
long long int ans = 1;
while (y > 0) {
if (y & 1) ans = (ans * x) % m;
x = (x * x) % m;
y >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
string s, ans = "";
cin >> s;
for (int i = 0; i < s.length(); i++) {
ans += s[i];
if (i == s.length() - 2) continue;
i++;
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> t1(n);
vector<int> t2(m);
for (int i = 0; i < (int)n; i++) {
cin >> t1[i];
}
for (int i = 0; i < (int)m; i++) {
cin >> t2[i];
}
int idx1 = 0, idx2 = 0;
int sum1 = 0, sum2 = 0;
int nb = 0;
while (idx1 < n && idx2 < m) {
if (sum1 == sum2 && (sum1 && sum2)) {
sum1 = sum2 = 0;
nb++;
} else {
if (sum1 <= sum2) {
sum1 += t1[idx1];
idx1++;
} else {
sum2 += t2[idx2];
idx2++;
}
}
}
cout << nb + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pi = pair<int, int>;
using pii = pair<int, pi>;
const int MAXN = 125;
using bst = bitset<MAXN>;
template <typename T>
T read() {
T tmp;
cin >> tmp;
return tmp;
}
ll ans = 0, mod = 1000000007;
int n, m, k;
int cnt[MAXN];
inline bst mv(bst& x, int val, bool opt, int sz = m) {
if (opt) {
return (x << val) | (x >> (sz - val));
} else {
return (x >> val) | (x << (sz - val));
}
}
void dfs(bst nb, int n, ll mulv) {
ans = (ans + mulv) % mod;
for (int i = (n); i <= (m / 2); ++i) {
if (cnt[i] && !nb[i] && !nb[m - i]) {
dfs(nb | mv(nb, i, true) | mv(nb, i, false), i + 1, mulv * cnt[i] % mod);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
scanf("%d%d%d", &n, &m, &k);
memset((cnt), 0, sizeof(cnt));
for (int i = (0); i <= (k - 1); ++i) {
int tmp;
scanf("%d", &tmp);
tmp %= m;
cnt[min(tmp, m - tmp)]++;
}
bst tmp = 1;
dfs(tmp, 0, 1);
printf("%d\n", int(ans % mod));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int inf = 0x7FFFFFFF;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
void show(T a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
template <class T>
void show(T a, int r, int l) {
for (int i = 0; i < r; ++i) show(a[i], l);
cout << endl;
}
int dp[5005];
int beg[5005], lst[5005];
int main() {
int n, k;
while (cin >> n >> k) {
int ans = 0;
for (int i = 0; i < n; i++) cin >> beg[i] >> lst[i];
beg[n] = 86401;
lst[n] = 1;
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= n; i++) {
if (beg[i] > dp[k] + 1) checkmax(ans, beg[i] - dp[k] - 1);
int now = beg[i] + lst[i] - 1;
for (int j = k; j > 0; j--) {
if (dp[j] < beg[i])
dp[j] = now;
else
dp[j] += lst[i];
dp[j] = min(dp[j - 1], dp[j]);
}
if (dp[0] < beg[i])
dp[0] = now;
else
dp[0] += lst[i];
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v;
for (int i = 0, temp; i < n; i++) {
cin >> temp;
v.push_back(temp);
}
bool all1 = true;
for (int x : v)
if (x != 1) all1 = false;
if (all1) {
if (v.size() % 2 == 0)
cout << "Second" << endl;
else
cout << "First" << endl;
} else {
int i;
for (i = 0; i < v.size() && v[i] == 1; i++)
;
if (i % 2 == 0)
cout << "First" << endl;
else
cout << "Second" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int X, Y;
int cnt = 0;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
bool edge[maxn][maxn][4];
bool used[maxn][maxn];
void dfs(int x, int y) {
if (x < 0 || x >= X || y < 0 || y >= Y || used[x][y]) return;
used[x][y] = 1;
cnt++;
for (int i = 0; i < 4; i++)
if (!edge[x][y][i]) dfs(x + dx[i], y + dy[i]);
}
int main() {
int N;
int x1, y1, x2, y2;
cin >> X >> Y >> N;
for (int i = 0; i < N; i++) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2)
for (int j = y1; j < y2; j++) edge[x1 - 1][j][0] = edge[x1][j][1] = 1;
if (y1 == y2)
for (int j = x1; j < x2; j++) edge[j][y1 - 1][2] = edge[j][y1][3] = 1;
}
vector<int> ans;
for (int i = 0; i < X; i++)
for (int j = 0; j < Y; j++)
if (!used[i][j]) {
cnt = 0;
dfs(i, j);
ans.push_back(cnt);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < N + 1; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1e6 + 7;
vector<int> v[N];
int out[N], mn[N], dis[N], inf, is[N], Tavas[N];
int32_t main() {
int n = in(), m = in();
for (int i = 0; i < m; i++) {
int x = in(), y = in();
out[x]++;
v[y].push_back(x);
}
int now = in(), t = in();
memset(dis, 63, sizeof dis);
set<pair<int, int> > s;
inf = dis[0];
dis[t] = 0;
s.insert({0, t});
while (s.size()) {
int x = s.begin()->second;
s.erase(s.begin());
is[x] = false;
Tavas[x] = true;
for (auto i : v[x])
if (!Tavas[i]) {
if (dis[x] + 1 < dis[i])
dis[i] = dis[x] + 1, mn[i] = 1;
else if (dis[x] + 1 == dis[i])
mn[i]++;
if (mn[i] == out[i]) dis[i]--;
if (!is[i]) s.insert({dis[i], i}), is[i] = true;
}
}
if (dis[now] == inf)
cout << -1;
else
cout << dis[now] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1005, INF = (1e9);
int cnt[MAX], v, e, n, k, dis[MAX][MAX], ty[MAX];
namespace hc {
bool visited[MAX];
vector<int> adj[MAX];
int n, L[MAX], R[MAX], Q[MAX], len[MAX], dis[MAX], parent[MAX];
inline void init(int nodes) {
n = nodes, memset(len, 0, sizeof(len));
for (int i = 0; i < MAX; i++) adj[i].clear();
}
inline void add_edge(int u, int v) {
len[u]++;
adj[u].push_back(v);
}
bool dfs(int i) {
for (int j = 0; j < len[i]; j++) {
int x = adj[i][j];
if (L[x] == -1 || (parent[L[x]] == i)) {
if (L[x] == -1 || dfs(L[x])) {
L[x] = i, R[i] = x;
return true;
}
}
}
return false;
}
bool bfs() {
memset(visited, 0, sizeof(visited));
int i, j, x, d, f = 0, l = 0;
for (i = 0; i < n; i++) {
if (R[i] == -1) {
visited[i] = true;
Q[l++] = i, dis[i] = 0;
}
}
while (f < l) {
i = Q[f++];
for (j = 0; j < len[i]; j++) {
x = adj[i][j], d = L[x];
if (d == -1)
return true;
else if (!visited[d]) {
Q[l++] = d;
parent[d] = i, visited[d] = true, dis[d] = dis[i] + 1;
}
}
}
return false;
}
int hopcroft_karp() {
int res = 0;
memset(L, -1, sizeof(L));
memset(R, -1, sizeof(R));
while (bfs()) {
for (int i = 0; i < n; i++) {
if (R[i] == -1 && dfs(i)) res++;
}
}
return res;
}
} // namespace hc
int main() {
ios::sync_with_stdio(false);
int u, v, c;
cin >> v >> e >> n >> k;
for (int i = 1; i <= v; i++)
for (int j = 1; j <= v; j++) dis[i][j] = (i == j) ? 0 : INF;
for (int i = 1; i <= n; i++) cin >> ty[i];
for (int i = 0; i <= e - 1; i++) {
int u, v, c;
cin >> u >> v >> c;
dis[v][u] = dis[u][v] = min(dis[u][v], c);
}
for (int k = 1; k <= v; k++)
for (int i = 1; i <= v; i++)
for (int j = 1; j <= v; j++)
dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);
int st = 0, en = 1731311, mid, prin = -1;
while (st <= en) {
hc::init(n + v);
mid = (st + en) >> 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= v; j++)
if (dis[ty[i]][j] <= mid) hc::add_edge(i, j);
if (hc::hopcroft_karp() >= k) {
en = mid - 1;
if (prin == -1)
prin = mid;
else
prin = min(prin, mid);
} else
st = mid + 1;
}
cout << prin << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n;
vector<int> vv;
cin >> n;
int a[2 * n];
for (i = 0; i < 2 * n; i++) {
cin >> a[i];
}
sort(a, a + (2 * n));
if (a[n] > a[n - 1])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dfn[2005], low[2005], fg[2005], cnt, n, head[2005], cmp, te, num;
int sta[2005];
struct st {
int to, next;
} qe[4000005];
void addedge(int u, int v) {
cmp++;
qe[cmp].to = v;
qe[cmp].next = head[u];
head[u] = cmp;
}
void tarjan(int u) {
te++;
low[u] = dfn[u] = te;
fg[u] = 0;
num++;
sta[num] = u;
for (int i = head[u]; i != -1; i = qe[i].next) {
int j = qe[i].to;
if (!dfn[j]) {
tarjan(j);
low[u] = min(low[u], low[j]);
} else if (fg[j] == 0)
low[u] = min(low[u], dfn[j]);
}
if (dfn[u] == low[u]) {
cnt++;
while (sta[num] != u) {
fg[sta[num]] = cnt;
num--;
}
fg[u] = cnt;
num--;
}
}
int main() {
cin >> n;
int i, j, k;
memset(head, -1, sizeof(head));
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
scanf("%d", &k);
if (k != 0 && i != j) addedge(i, j);
}
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
if (cnt == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
long long int n, t, c;
long long int si = 0;
cin >> n >> t >> c;
long long int b[n];
for (long long int i = 0; i < n; i++) {
b[i] = 0;
}
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= t) {
si++;
}
if (a[i] > t || si == n || i == n - 1) {
b[i] = si;
si = 0;
}
}
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
if (b[i] >= c) {
cnt = cnt + (b[i] - c + 1);
}
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long double a, b, c, p1, p2;
long long int b1;
cin >> t;
while (t--) {
cin >> a >> b >> c;
p1 = a;
p2 = c / b;
if (p1 > p2) {
if (a >= c)
cout << "-1 ";
else
cout << "1 ";
b1 = b;
cout << b1 << "\n";
} else {
cout << "1 ";
cout << "-1\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int a[100001];
int f = 0;
int l = 0;
int t = 0;
int min = 1000000001;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] < min) {
t = i + 1;
min = a[i];
}
}
int time = 0;
for (int i = 1; i < n; ++i) {
if (a[i] < a[i - 1]) time++;
if (a[i] < a[i - 1] && a[i] != min) {
time = 2;
break;
}
}
if (time > 1)
cout << "-1" << endl;
else if (time == 0)
cout << "0" << endl;
else {
if (a[n - 1] == a[0] && a[0] == min) {
int i = 0;
for (i = n - 1; i >= 0; --i) {
if (a[i] != min) break;
}
cout << n - i - 1 << endl;
} else if (a[n - 1] > a[0])
cout << "-1" << endl;
else
cout << n - t + 1 << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e6 + 5;
const long long int modn = 1e9 + 7;
const double pi = acos(-1);
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 1; i < n; i++) {
if (a[i] == 0 && a[i - 1] == 0) {
cout << -1 << '\n';
return;
}
}
long long int ans = 1, l = 0;
for (long long int i = 0; i < n; i++) {
if (a[i] == 1) {
l++;
} else {
if (l == 0) continue;
ans += 5 * (l - 1) + 1;
l = 0;
}
}
if (l > 0) {
ans += 5 * (l - 1) + 1;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long int test_case = 1;
cin >> test_case;
for (long long int i = 1; i <= test_case; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
string s;
cin >> s;
long long i = 0;
float l = 0, r = 0;
long long pivot = 0;
while (pivot < s.size() && s[pivot] != '^') pivot++;
while (i < s.size() && s[i] != '^') {
if (s[i] >= '1' && s[i] <= '9') l += (s[i] - '0') * abs(i - pivot);
i++;
}
while (i < s.size()) {
if (s[i] >= '1' && s[i] <= '9') r += (s[i] - '0') * abs(i - pivot);
i++;
}
if (l == r)
cout << "balance" << endl;
else if (l > r)
cout << "left" << endl;
else
cout << "right" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200100];
int n, pr[200100], dpth[200100];
set<pair<int, int> > q;
int ans = 0l;
void dfs(int v, int deep, int p) {
pr[v] = p;
dpth[v] = deep;
if (deep > 2) q.insert({deep, v});
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) dfs(to, deep + 1, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0, 0);
while (!q.empty()) {
int v = prev(q.end())->second;
int ppr = pr[v];
q.erase({dpth[ppr], ppr});
for (int i = 0; i < g[ppr].size(); i++) {
int to = g[ppr][i];
q.erase({dpth[to], to});
}
++ans;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c == 0 && a == b) {
printf("YES\n");
return 0;
}
if (c == 0) {
printf("NO\n");
return 0;
}
if ((b - a) % c == 0 && (b - a) / c >= 0) {
printf("YES\n");
return 0;
}
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
int x[101000], y[101000], c[101000];
long long anss[101000];
int tempa[101000], tempb[101000], tempc[101000];
int l[101000][10];
int in[101000];
int he[2][101000], wh[2][101000];
int nhh[2];
int zhh[2] = {1, -1};
void mergesort(int *a, int *b, int *c, int n1, int n2);
int ya(int k) {
int z;
int tempk;
int i;
if (l[k][0]) {
z = 1;
for (i = 4; i <= 6; i++) {
tempk = l[k][i];
if ((l[tempk][0]) &&
(l[l[tempk][1]][0] + l[l[tempk][2]][0] + l[l[tempk][3]][0] == 1)) {
z = 0;
break;
}
}
return z;
} else {
z = 0;
}
return z;
}
void push(int k) {
int i;
int nh, zh;
int p;
for (i = 0; i <= 1; i++) {
zh = zhh[i];
nh = nhh[i];
p = ++nh;
while (p > 1) {
if (c[k] * zh < c[he[i][p >> 1]] * zh) {
he[i][p] = he[i][p >> 1];
wh[i][he[i][p]] = p;
p >>= 1;
} else {
break;
}
}
he[i][p] = k;
wh[i][k] = p;
nhh[i] = nh;
}
}
int pop(int k) {
int i, ii;
int k2;
int nh, zh;
int p;
if (k < 0) {
if (k == -1) {
i = 1;
ii = 0;
} else {
i = 0;
ii = 1;
}
k = he[i][1];
nh = nhh[i];
zh = zhh[i];
k2 = he[i][nh];
nh--;
p = 1;
while (p + p + 1 <= nh) {
if (c[he[i][p + p]] * zh <= c[he[i][p + p + 1]] * zh &&
c[he[i][p + p]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p];
wh[i][he[i][p]] = p;
p = p + p;
} else if (c[he[i][p + p]] * zh > c[he[i][p + p + 1]] * zh &&
c[he[i][p + p + 1]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p + 1];
wh[i][he[i][p]] = p;
p = p + p + 1;
} else {
break;
}
}
if (p + p <= nh && c[he[i][p + p]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p];
wh[i][he[i][p]] = p;
p = p + p;
}
he[i][p] = k2;
wh[i][k2] = p;
nhh[i] = nh;
i = ii;
p = wh[i][k];
zh = zhh[i];
nh = nhh[i];
k2 = he[i][nh];
nh--;
while (p > 1) {
if (c[k2] * zh < c[he[i][p >> 1]] * zh) {
he[i][p] = he[i][p >> 1];
wh[i][he[i][p]] = p;
p >>= 1;
} else {
break;
}
}
while (p + p + 1 <= nh) {
if (c[he[i][p + p]] * zh <= c[he[i][p + p + 1]] * zh &&
c[he[i][p + p]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p];
wh[i][he[i][p]] = p;
p = p + p;
} else if (c[he[i][p + p]] * zh > c[he[i][p + p + 1]] * zh &&
c[he[i][p + p + 1]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p + 1];
wh[i][he[i][p]] = p;
p = p + p + 1;
} else {
break;
}
}
if (p + p <= nh && c[he[i][p + p]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p];
wh[i][he[i][p]] = p;
p = p + p;
}
he[i][p] = k2;
wh[i][k2] = p;
nhh[i] = nh;
return k;
} else {
for (i = 0; i <= 1; i++) {
p = wh[i][k];
zh = zhh[i];
nh = nhh[i];
k2 = he[i][nh];
nh--;
while (p > 1) {
if (c[k2] * zh < c[he[i][p >> 1]] * zh) {
he[i][p] = he[i][p >> 1];
wh[i][he[i][p]] = p;
p >>= 1;
} else {
break;
}
}
while (p + p + 1 <= nh) {
if (c[he[i][p + p]] * zh <= c[he[i][p + p + 1]] * zh &&
c[he[i][p + p]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p];
wh[i][he[i][p]] = p;
p = p + p;
} else if (c[he[i][p + p]] * zh > c[he[i][p + p + 1]] * zh &&
c[he[i][p + p + 1]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p + 1];
wh[i][he[i][p]] = p;
p = p + p + 1;
} else {
break;
}
}
if (p + p <= nh && c[he[i][p + p]] * zh < c[k2] * zh) {
he[i][p] = he[i][p + p];
wh[i][he[i][p]] = p;
p = p + p;
}
he[i][p] = k2;
wh[i][k2] = p;
nhh[i] = nh;
}
}
}
int main(void) {
int n, i, j;
long long mod = 1000000009;
long long ans;
int p1, p2;
int k, tempk;
while (scanf("%d", &n) != EOF) {
anss[n] = 1;
for (i = n - 1; i; i--) {
anss[i] = (anss[i + 1] * n) % mod;
}
for (i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
c[i] = i - 1;
}
mergesort(y, x, c, 1, n);
for (j = 0; j <= 6; j++) {
l[0][j] = 0;
}
p1 = 1;
p2 = 1;
for (i = 1; i <= n; i++) {
l[i][0] = 1;
for (j = 1; j <= 6; j++) {
l[i][j] = 0;
}
for (j = p1; j <= n;) {
if (y[j] < y[i] - 1) {
j++;
} else if (y[j] == y[i] - 1) {
if (x[j] < x[i] - 1) {
j++;
} else if (x[j] == x[i] - 1) {
l[i][1] = j;
j++;
} else if (x[j] == x[i]) {
l[i][2] = j;
j++;
} else if (x[j] == x[i] + 1) {
l[i][3] = j;
j++;
} else {
break;
}
} else {
break;
}
}
p1 = j - 2;
if (p1 <= 0) {
p1 = 1;
}
for (j = p2; j <= n;) {
if (y[j] <= y[i]) {
j++;
} else if (y[j] == y[i] + 1) {
if (x[j] < x[i] - 1) {
j++;
} else if (x[j] == x[i] - 1) {
l[i][4] = j;
j++;
} else if (x[j] == x[i]) {
l[i][5] = j;
j++;
} else if (x[j] == x[i] + 1) {
l[i][6] = j;
j++;
} else {
break;
}
} else {
break;
}
}
p2 = j - 2;
if (p2 <= 0) {
p2 = 1;
}
}
nhh[0] = 0;
nhh[1] = 0;
for (i = 1; i <= n; i++) {
in[i] = 0;
if (ya(i)) {
push(i);
in[i] = 1;
}
}
ans = 0;
in[0] = 0;
for (i = 1; i <= n; i++) {
k = pop((i & 1) - 2);
in[k] = 0;
l[k][0] = 0;
ans = (ans + anss[i] * c[k]) % mod;
for (j = 1; j <= 3; j++) {
tempk = l[k][j];
if (ya(tempk) && !in[tempk]) {
push(tempk);
in[tempk] = 1;
}
}
tempk = l[l[k][4]][1];
if (!ya(tempk) && in[tempk]) {
pop(tempk);
in[tempk] = 0;
}
tempk = l[l[k][4]][2];
if (!ya(tempk) && in[tempk]) {
pop(tempk);
in[tempk] = 0;
}
tempk = l[l[k][6]][2];
if (!ya(tempk) && in[tempk]) {
pop(tempk);
in[tempk] = 0;
}
tempk = l[l[k][6]][3];
if (!ya(tempk) && in[tempk]) {
pop(tempk);
in[tempk] = 0;
}
if (!l[l[k][4]][0]) {
tempk = l[l[k][5]][1];
if (!ya(tempk) && in[tempk]) {
pop(tempk);
in[tempk] = 0;
}
}
if (!l[l[k][6]][0]) {
tempk = l[l[k][5]][3];
if (!ya(tempk) && in[tempk]) {
pop(tempk);
in[tempk] = 0;
}
}
}
printf("%I64d\n", ans);
}
return 0;
}
void mergesort(int *a, int *b, int *c, int n1, int n2) {
int a1, a2, n12;
int i, j;
if (n1 < n2) {
n12 = (n1 + n2) / 2;
mergesort(a, b, c, n1, n12);
mergesort(a, b, c, n12 + 1, n2);
for (i = n1; i <= n2; i++) {
tempa[i] = a[i];
tempb[i] = b[i];
tempc[i] = c[i];
}
a1 = n1;
a2 = n12 + 1;
for (i = n1; (a1 <= n12 && a2 <= n2); i++) {
if (tempa[a1] < tempa[a2] ||
(tempa[a1] == tempa[a2] && tempb[a1] <= tempb[a2])) {
a[i] = tempa[a1];
b[i] = tempb[a1];
c[i] = tempc[a1];
a1++;
} else {
a[i] = tempa[a2];
b[i] = tempb[a2];
c[i] = tempc[a2];
a2++;
}
}
if (a1 > n12) {
for (j = a2; j <= n2; j++, i++) {
a[i] = tempa[j];
b[i] = tempb[j];
c[i] = tempc[j];
}
} else {
for (j = a1; j <= n12; j++, i++) {
a[i] = tempa[j];
b[i] = tempb[j];
c[i] = tempc[j];
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int low_bit(int now) { return now & (-now); }
long long h(int l, int r) {
if (l & (r - low_bit(r))) return 0;
long long res = 1;
bool OK = 1;
while (OK) {
if (r & 1) break;
if (l & 1)
;
else
res <<= 1;
l >>= 1, r >>= 1;
}
return res;
}
long long g(int l, int r) {
if (r == 0) return 0;
if (l == 0) return r;
return h(l, r) + g(l, r - low_bit(r));
}
long long f(int l, int r) {
if (l >= r) return 0;
if (l == 0) return (long long)r * 2 - 1 + f(1, r);
if (l % 2 == r % 2 && l % 2 == 0) return f(l >> 1, r >> 1) * 3;
if (l & 1) {
return f(l + 1, r) + (long long)2 * g(l, r) - (long long)2 * g(l, l);
}
return f(l, r - 1) + (long long)2 * g(r - 1, r) - (long long)2 * g(r - 1, l);
}
int main() {
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
cout << f(l, r + 1) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> xx[N], yy[N], v[N], u[N];
int x1[N], x2[N], y2[N], y[N];
int ret[N], tree[N * 2], c, L, R;
void update(int pos, int l, int r, int v) {
if (c < l || r < c) return;
if (l == r && l == c) {
tree[pos] = v;
return;
}
int mid = (l + r) / 2;
update(pos << 1, l, mid, v);
update(pos << 1 | 1, mid + 1, r, v);
tree[pos] = min(tree[pos << 1], tree[pos << 1 | 1]);
}
int qq(int pos, int l, int r) {
if (r < L || R < l) return 1e9;
int mid = (l + r) / 2;
if (L <= l && r <= R) return tree[pos];
return min(qq(pos << 1, l, mid), qq(pos << 1 | 1, mid + 1, r));
}
int main() {
int n, m, k, q, i, j, a, b, x;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (i = 0; i < k; ++i) {
scanf("%d%d", &a, &b);
xx[a].push_back(b);
yy[b].push_back(a);
}
for (i = 0; i < q; ++i) {
scanf("%d%d%d%d", &x1[i], &y[i], &x2[i], &y2[i]);
u[x2[i]].push_back(i);
v[y2[i]].push_back(i);
}
for (i = 1; i <= n; ++i) {
for (j = 0; j < xx[i].size(); ++j) c = xx[i][j], update(1, 1, m, i);
for (j = 0; j < u[i].size(); ++j) {
x = u[i][j];
L = y[x], R = y2[x];
if (qq(1, 1, m) >= x1[x]) ret[x] |= 1;
}
}
memset(tree, 0, sizeof(tree));
for (i = 1; i <= m; ++i) {
for (j = 0; j < yy[i].size(); ++j) c = yy[i][j], update(1, 1, n, i);
for (j = 0; j < v[i].size(); ++j) {
x = v[i][j];
L = x1[x], R = x2[x];
if (qq(1, 1, n) >= y[x]) ret[x] |= 1;
}
}
for (i = 0; i < q; ++i)
if (ret[i])
printf("YES\n");
else
printf("NO\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int cnt = 0, n, ques, mark = 0, ans = 0;
queue<int> q[N];
bool vis[N];
int main() {
scanf("%d%d", &n, &ques);
memset(vis, false, sizeof(vis));
while (ques--) {
int op, x;
scanf("%d%d", &op, &x);
if (op == 1) {
q[x].push(++cnt);
ans++;
} else if (op == 2) {
while (!q[x].empty()) {
int u = q[x].front();
q[x].pop();
if (u > mark) {
ans--;
vis[u] = true;
}
}
} else {
for (int i = mark + 1; i <= x; i++) {
if (!vis[i]) ans--;
}
mark = max(mark, x);
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int MX = 2000000 + 10;
void solve() {
int n, k;
cin >> n >> k;
if (k >= n)
cout << k - n << '\n';
else
cout << (n % 2 == k % 2 ? 0 : 1) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int _;
cin >> _;
while (_--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
inline void debug_vi(vector<int> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void debug_vll(vector<long long> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void print_case(int tn) { cout << "Case #" << tn << ": "; }
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxpq = priority_queue<T>;
const int nax = 1001;
int mat[nax][nax], n, m;
set<int> s;
bitset<nax> bs[nax];
bool f(int x) {
for (long long i = (long long)(0); i < (long long)(n); i++) bs[i].reset();
for (long long i = (long long)(0); i < (long long)(n); i++) {
for (long long j = (long long)(0); j < (long long)(m); j++) {
if (mat[i][j] >= x) {
bs[i].set(j);
}
}
}
bitset<nax> tmp;
for (long long i = (long long)(0); i < (long long)(n); i++) {
if (bs[i].count() <= 1) continue;
for (long long j = (long long)(i + 1); j < (long long)(n); j++) {
if (bs[j].count() <= 1) continue;
tmp = bs[i] & bs[j];
if (tmp.count() > 1) return true;
}
}
return false;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (long long i = (long long)(0); i < (long long)(n); i++) {
for (long long j = (long long)(0); j < (long long)(m); j++) {
cin >> mat[i][j];
s.insert(mat[i][j]);
}
}
vector<int> vals((s).begin(), (s).end());
int lo = 0, hi = vals.size() - 1, res = -1;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (f(vals[mid])) {
res = max(res, mid);
lo = mid + 1;
} else
hi = mid - 1;
}
cout << vals[res];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int n, x[1002], y[1002], r[1002];
int xa, xb, ya, yb;
int main() {
scanf("%d %d %d %d", &xa, &ya, &xb, &yb);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &x[i], &y[i], &r[i]);
}
for (int i = min(xa, xb); i <= max(xa, xb); i++) {
v.push_back(make_pair(i, ya));
v.push_back(make_pair(i, yb));
}
for (int j = min(ya, yb) + 1; j < max(ya, yb); j++) {
v.push_back(make_pair(xa, j));
v.push_back(make_pair(xb, j));
}
int miss = 0;
for (int i = 0; i < v.size(); i++) {
int cx = v[i].first;
int cy = v[i].second;
int ok = 0;
for (int j = 1; j <= n; j++) {
if ((cx - x[j]) * (cx - x[j]) + (cy - y[j]) * (cy - y[j]) <=
r[j] * r[j]) {
ok = 1;
break;
}
}
if (ok == 0) miss++;
}
cout << miss << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100005];
long long c[100005];
int main() {
int n;
cin >> n;
memset(c, 0, sizeof(c));
int maxx = 0;
int aux;
for (int i = 0; i < n; i++) {
cin >> aux;
if (aux > maxx) maxx = aux;
c[aux]++;
}
dp[0] = 0;
dp[1] = c[1];
for (int i = 2; i <= maxx; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + i * c[i]);
}
cout << dp[maxx] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int n, m;
vector<pair<int, int> > g[60], v, ans;
vector<int> pass;
bool vis[60], vise[2510];
void dfs(int pos, int stp, int rt) {
vis[pos] = true;
pass.push_back(pos);
for (int i = 0; i < g[pos].size(); i++) {
if (vise[g[pos][i].second]) continue;
if (g[pos][i].first == rt) {
if (stp == n - 1)
puts("YES\n0");
else
puts("NO");
exit(0);
}
vise[g[pos][i].second] = true;
dfs(g[pos][i].first, stp + 1, rt);
}
}
pair<int, int> getL() {
int mn = 1e9, pos;
pair<int, int> ret;
for (int i = 0; i < v.size(); i++) {
if (mn > v[i].first) {
pos = i;
mn = v[i].first;
ret = v[i];
}
if (mn > v[i].second) {
pos = i;
mn = v[i].second;
ret = make_pair(v[i].second, v[i].first);
}
}
v.erase(v.begin() + pos);
return ret;
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(make_pair(y, i));
g[y].push_back(make_pair(x, i));
}
for (int i = 1; i <= n; i++) {
if (g[i].size() > 2) {
puts("NO");
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (vis[i] || g[i].size() == 2) continue;
pass.clear();
dfs(i, 0, i);
v.push_back(make_pair(pass[0], pass.back()));
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, 0, i);
while (v.size() > 1) {
pair<int, int> tmp1 = getL(), tmp2 = getL();
ans.push_back(make_pair(tmp1.first, tmp2.first));
v.push_back(make_pair(tmp1.second, tmp2.second));
}
if (v[0].first > v[0].second) swap(v[0].first, v[0].second);
ans.push_back(v[0]);
puts("YES");
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 7;
int p[MAX_N][2];
int dp[MAX_N][2][2];
pair<int, int> f[MAX_N][2][2];
bool g[MAX_N][2][2];
vector<int> ans;
int T, n;
void solve(int s, int k) {
for (int i = n; i; --i) {
ans.push_back(p[i][s]);
pair<int, int> p = f[i][s][k];
s = p.first, k = p.second;
}
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &p[i][0]), p[i][1] = -p[i][0];
for (int i = 1; i <= n; ++i) {
for (int s = 0; s < 2; ++s) {
for (int k = 0; k < 2; ++k) {
dp[i][s][k] = -(1e9 + 7);
g[i][s][k] = false;
}
}
}
g[1][0][0] = g[1][1][0] = true;
for (int i = 2; i <= n; ++i) {
for (int s1 = 0; s1 < 2; ++s1) {
for (int s2 = 0; s2 < 2; ++s2) {
if (p[i - 1][s1] < p[i][s2]) {
if (g[i - 1][s1][1]) {
if (p[i][s2] > dp[i - 1][s1][1] &&
(!g[i][s2][0] || dp[i][s2][0] > p[i - 1][s1])) {
dp[i][s2][0] = p[i - 1][s1];
f[i][s2][0] = pair<int, int>(s1, 1);
g[i][s2][0] = true;
}
if (p[i][s2] < dp[i - 1][s1][1] && p[i][s2] > p[i - 1][s1] &&
(!g[i][s2][1] || dp[i][s2][1] > dp[i - 1][s1][1])) {
dp[i][s2][1] = dp[i - 1][s1][1];
f[i][s2][1] = pair<int, int>(s1, 1);
g[i][s2][1] = true;
}
}
if (g[i - 1][s1][0]) {
if (dp[i][s2][0] > dp[i - 1][s1][0] || (!g[i][s2][0])) {
dp[i][s2][0] = dp[i - 1][s1][0];
g[i][s2][0] = true;
f[i][s2][0] = pair<int, int>(s1, 0);
}
}
} else {
if (g[i - 1][s1][0]) {
if (p[i][s2] > dp[i - 1][s1][0] &&
(!g[i][s2][1] || dp[i][s2][1] > p[i - 1][s1])) {
dp[i][s2][1] = p[i - 1][s1];
f[i][s2][1] = pair<int, int>(s1, 0);
g[i][s2][1] = true;
}
}
}
}
}
}
bool flag = true;
for (int s = 0; s < 2; ++s) {
for (int k = 0; k < 2; ++k) {
if (g[n][s][k]) {
solve(s, k);
flag = false;
break;
}
}
if (!flag) break;
}
if (flag) {
puts("NO");
} else {
puts("YES");
for (int i = ans.size() - 1; i >= 0; --i) printf("%d ", ans[i]);
puts("");
}
ans.clear();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct L {
int u, v;
int val;
bool operator<(const L &a) const { return a.val < val; }
} l[1500010];
int n, m;
struct node *NIL;
struct node {
node *ch[2], *fa;
int val;
int changed;
bool rev;
bool Dir() { return this == fa->ch[1]; }
bool Isroot() {
return fa == NIL || (this != fa->ch[0] && this != fa->ch[1]);
}
void setchild(node *x, int d) {
ch[d] = x;
if (x != NIL) x->fa = this;
}
void pushdown() {
if (rev) {
swap(ch[0], ch[1]);
if (ch[0] != NIL) ch[0]->rev ^= 1;
if (ch[1] != NIL) ch[1]->rev ^= 1;
rev = 0;
}
if (changed != 0) {
if (ch[0] != NIL) {
ch[0]->changed = changed;
ch[0]->val = val;
}
if (ch[1] != NIL) {
ch[1]->changed = changed;
ch[1]->val = val;
}
changed = 0;
}
}
} tree[1500010];
void Rotate(node *x) {
node *y = x->fa;
y->pushdown(), x->pushdown();
int d = x->Dir();
if (y->Isroot())
x->fa = y->fa;
else
y->fa->setchild(x, y->Dir());
y->setchild(x->ch[!d], d);
x->setchild(y, !d);
}
void Splay(node *x) {
x->pushdown();
while (!x->Isroot()) {
node *y = x->fa;
if (y->Isroot())
Rotate(x);
else {
if (x->Dir() == y->Dir())
Rotate(y);
else
Rotate(x);
Rotate(x);
}
}
}
void Access(node *x) {
node *c = NIL;
while (x != NIL) {
Splay(x);
x->setchild(c, 1);
c = x;
x = x->fa;
}
}
void MakeRoot(node *x) {
Access(x);
Splay(x);
x->rev ^= 1;
}
void Link(node *x, node *y) {
MakeRoot(x);
x->fa = y;
}
void Cut(node *x, node *y) {
MakeRoot(x);
Access(y);
Splay(y);
y->ch[0] = NIL;
x->fa = NIL;
}
node *FindRoot(node *x) {
Access(x);
Splay(x);
node *y = x;
while (y->ch[0] != NIL) y = y->ch[0];
Splay(y);
return y;
}
bool used[1500010];
int cnt;
void Change(int u, node *x, node *y, int val) {
if (FindRoot(x) == FindRoot(y)) {
MakeRoot(x);
Access(y);
Splay(y);
y->val = val;
y->changed = val;
} else {
Link(&tree[u + n], x);
Link(&tree[u + n], y);
}
}
void Newnode(node *x, int val) {
x->fa = x->ch[0] = x->ch[1] = NIL;
x->val = val;
x->changed = 0;
}
int k, u, v, val;
int main() {
NIL = &tree[0];
NIL->ch[0] = NIL->ch[1] = NIL->fa = NIL;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &k);
for (int i = 1; i <= n; i++) Newnode(&tree[i], 0);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
Newnode(&tree[i + n], 0x3FFFFFFF);
node *x = &tree[u];
node *y = &tree[v];
Link(&tree[i + n], x);
Link(&tree[i + n], y);
}
for (int i = 1; i <= k; i++) {
scanf("%d%d%d", &u, &v, &val);
l[i].u = u;
l[i].v = v;
l[i].val = val;
}
sort(l + 1, l + 1 + k);
for (int i = k; i >= 1; i--) {
Newnode(&tree[i + n + m], l[i].val);
node *x = &tree[l[i].u];
node *y = &tree[l[i].v];
if (FindRoot(x) != FindRoot(y)) {
Link(&tree[i + n + m], x);
Link(&tree[i + n + m], y);
}
}
for (int i = 1; i <= k; i++) {
node *x = &tree[l[i].u];
node *y = &tree[l[i].v];
MakeRoot(x);
Access(y);
Splay(y);
y->val = l[i].val;
y->changed = l[i].val;
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
node *x = &tree[i + n];
Access(x);
Splay(x);
if (x->val == 0x3FFFFFFF) {
printf("-1");
return 0;
}
ans += x->val;
}
printf("%I64d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ull = uint64_t;
using ll = int64_t;
using ld = long double;
const int N = 200228;
int n;
struct Val {
int fen[N];
set<int> s;
void ad(int x) {
s.insert(x);
for (int i = x; i < n; i |= (i + 1)) {
++fen[i];
}
}
void er(int x) {
s.erase(x);
for (int i = x; i < n; i |= (i + 1)) {
--fen[i];
}
}
int gt(int x) {
int ans = 0;
for (int i = x; --i >= 0; i &= (i + 1)) {
ans += fen[i];
}
return ans;
}
int gt(int l, int r) { return gt(r) - gt(l); }
};
Val f[3];
int g(char c) { return (c == 'P') + 2 * (c == 'S'); }
int a[N];
void print() {
int ans = 0;
for (int i = 0; i < 3; ++i) {
int bad = (i + 1) % 3;
int good = (i + 2) % 3;
if (f[bad].s.empty()) {
continue;
}
int low = *f[bad].s.begin();
int high = *f[bad].s.rbegin();
if (f[good].s.empty()) {
ans += f[i].s.size();
continue;
}
int glow = *f[good].s.begin();
if (glow > low) {
ans += f[i].gt(low, glow);
}
int ghigh = *f[good].s.rbegin();
if (ghigh < high) {
ans += f[i].gt(ghigh, high);
}
}
cout << n - ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(ios::fixed);
cout.precision(20);
int q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < n; ++i) {
a[i] = g(s[i]);
f[a[i]].ad(i);
}
print();
for (int i = 0; i < q; ++i) {
int x;
char c;
cin >> x >> c;
--x;
f[a[x]].er(x);
f[a[x] = g(c)].ad(x);
print();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
int N;
int X[MAXN][5];
int dot(int a, int b, int c) {
int d = 0;
for (int i = 0; i < 5; i++) {
d += (X[b][i] - X[a][i]) * (X[c][i] - X[a][i]);
}
return d;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
for (int j = 0; j < 5; j++) {
scanf("%d", &X[i][j]);
}
}
if (N >= 500) {
puts("0");
return 0;
}
vector<int> ans;
for (int i = 0; i < N; i++) {
bool good = true;
for (int j = 0; j < N; j++) {
if (j != i) {
for (int k = j + 1; k < N; k++) {
if (k != i && k != j) {
int d = dot(i, j, k);
if (d > 0) {
good = false;
break;
}
}
}
}
if (!good) {
break;
}
}
if (good) {
ans.push_back(i);
}
}
printf("%lu\n", ans.size());
for (int x : ans) {
printf("%d\n", x + 1);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct alphabet {
char ch;
int freq;
} alpha;
int main() {
int n, j, i, min_index = 0, min = 266, flag = 1;
string s;
cin >> n >> s;
if (n % 4 != 0) {
cout << "===" << endl;
return 0;
}
alpha u[4];
u[0].ch = 'A';
u[1].ch = 'C';
u[2].ch = 'G';
u[3].ch = 'T';
for (j = 0; j < 4; j++) u[j].freq = 0;
for (i = 0; i < n; i++) {
switch (s[i]) {
case 'A':
u[0].freq++;
break;
case 'C':
u[1].freq++;
break;
case 'G':
u[2].freq++;
break;
case 'T':
u[3].freq++;
break;
}
}
for (i = 0; i < n; i++) {
for (j = 3; j >= 0; j--)
if (u[j].freq <= min) {
min = u[j].freq;
min_index = j;
}
if (s[i] == '?') {
s[i] = u[min_index].ch;
u[min_index].freq++;
min++;
}
}
for (j = 1; j < 4; j++) {
if (u[0].freq != u[j].freq) {
flag = 0;
break;
}
}
cout << (flag ? s : "===") << endl;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int N, i, bir = 0, iki = 0, x, ans = 0;
scanf("%d", &N);
for (i = 0; i < N; i++) {
scanf("%d", &x);
if (x == 1)
bir++;
else
iki++;
}
ans += bir < iki ? bir : iki;
bir -= ans;
iki -= ans;
ans += (bir / 3);
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 107;
string st[maxn];
int n;
bool d[maxn] = {}, inv[maxn] = {}, is_c[maxn] = {};
vector<pair<int, int> > adj[maxn];
void dfs(int u, int pos) {
d[u] = 1;
for (int i = pos; i < (int)st[u].size(); ++i) cout << st[u][i];
for (auto v : adj[u])
if (!d[v.first]) dfs(v.first, v.second);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> st[i];
for (int i = 1; i <= n; ++i) {
if (inv[i]) continue;
for (int j = 1; j <= n; ++j)
if (i != j && !inv[j]) {
for (int k = 0; k < (int)st[i].size(); ++k)
if (st[i][k] == st[j][0]) {
int p1 = 0, p2 = k;
while (p1 < (int)st[j].size() && p2 < (int)st[i].size())
if (st[j][p1] == st[i][p2])
++p1, ++p2;
else
break;
if (p1 == (int)st[j].size()) inv[j] = 1;
break;
}
}
}
for (int i = 1; i <= n; ++i) {
if (inv[i]) continue;
for (int j = 1; j <= n; ++j) {
if (inv[j]) continue;
for (int k = (int)st[j].size() - 2; k >= 0; --k) {
bool ok = 1;
for (int p1 = (int)st[i].size() - 1, p2 = k; p1 >= 0; --p2, --p1)
if (p2 < 0 || st[i][p1] != st[j][p2]) {
ok = (p2 < 0);
break;
}
if (ok) {
if (adj[i].empty()) adj[i].push_back({j, k + 1});
is_c[j] = 1;
break;
}
}
}
}
for (int i = 1; i <= n; ++i)
if (!d[i] && !is_c[i] && !inv[i]) dfs(i, 0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ans;
ios::sync_with_stdio(false);
;
cin >> s;
char now = 'a' - 1;
reverse(s.begin(), s.end());
for (int i = 0; i < s.length(); i++) {
if (s[i] >= now) {
now = s[i];
ans += s[i];
}
}
reverse(ans.begin(), ans.end());
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long fast(unsigned long long a, unsigned long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
unsigned long long x = fast(a, b / 2) % 1000000007;
return ((x % 1000000007) * (x % 1000000007)) % 1000000007;
}
return ((a % 1000000007) * (fast(a, b - 1) % 1000000007)) % 1000000007;
}
int main() {
vector<unsigned long long> prime;
;
unsigned long long x;
unsigned long long n;
cin >> x >> n;
for (unsigned long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
prime.push_back(i);
}
while (x % i == 0) x /= i;
}
if (x != 1) {
prime.push_back(x);
}
unsigned long long ans = 1;
for (auto i : prime) {
unsigned long long z = 0;
unsigned long long o = 1;
for (unsigned long long j = 0; j <= n; j++) {
z = j;
if (n / o == 0) break;
if (log10(o) + log10(i) > 18) break;
o = o * i;
}
unsigned long long pass = 0;
while (z > 0) {
ans = (ans % 1000000007) * (fast(o, n / o - pass) % 1000000007) %
1000000007;
pass += n / o - pass;
z--;
o = o / i;
}
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[200005], arr1[200005], arr2[200005], arr3[200005], arr4[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, n1;
multiset<int> s1;
multiset<int> s2;
multiset<int> s3;
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> arr1[i];
}
for (int i = (0); i < (n); i++) {
cin >> arr3[i];
if (arr3[i] == 1)
s1.insert(arr1[i]);
else if (arr3[i] == 2)
s2.insert(arr1[i]);
else
s3.insert(arr1[i]);
}
for (int i = (0); i < (n); i++) {
cin >> arr4[i];
if (arr4[i] == 1 && arr4[i] != arr3[i])
s1.insert(arr1[i]);
else if (arr4[i] == 2 && arr4[i] != arr3[i])
s2.insert(arr1[i]);
else if (arr4[i] == 3 && arr4[i] != arr3[i])
s3.insert(arr1[i]);
}
multiset<int>::iterator it1;
multiset<int>::iterator it2;
multiset<int>::iterator it3;
it1 = s1.begin();
it2 = s2.begin();
it3 = s3.begin();
cin >> n1;
for (int i = (0); i < (n1); i++) {
cin >> arr[i];
if (arr[i] == 1) {
if (!s1.empty()) {
arr2[i] = *it1;
it2 = s2.find(arr2[i]);
if (it2 != s2.end()) s2.erase(it2);
if (!s2.empty()) it2 = s2.begin();
s1.erase(it1);
it3 = s3.find(arr2[i]);
if (it3 != s3.end()) {
s3.erase(it3);
}
if (!s3.empty()) it3 = s3.begin();
if (!s1.empty()) it1 = s1.begin();
} else
arr2[i] = -1;
} else if (arr[i] == 2) {
if (!s2.empty()) {
arr2[i] = *it2;
s2.erase(it2);
if (!s2.empty()) it2 = s2.begin();
it1 = s1.find(arr2[i]);
if (it1 != s1.end()) s1.erase(it1);
if (!s1.empty()) it1 = s1.begin();
it3 = s3.find(arr2[i]);
if (it3 != s3.end()) s3.erase(it3);
if (!s3.empty()) it3 = s3.begin();
} else
arr2[i] = -1;
} else {
if (!s3.empty()) {
arr2[i] = *it3;
s3.erase(it3);
if (!s3.empty()) it3 = s3.begin();
it1 = s1.find(arr2[i]);
if (it1 != s1.end()) s1.erase(it1);
if (!s1.empty()) it1 = s1.begin();
it2 = s2.find(arr2[i]);
if (it2 != s2.end()) s2.erase(it2);
if (!s2.empty()) it2 = s2.begin();
} else
arr2[i] = -1;
}
}
for (int i = (0); i < (n1); i++) cout << arr2[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510, M = 110;
int a[N], n, m;
double b[N][N], d[N];
double A[N][N], C[N][N];
inline double ab(double x) { return x < 0 ? -x : x; }
void build() {
for (int i = 1; i <= n; i++)
if (a[i])
A[i][i] = 1;
else {
A[i][i] = 1;
for (int j = 1; j <= n; j++)
if (j != i) A[i][j] = -b[i][j];
}
for (int j = 1; j <= n; j++)
for (int i = 1; i <= n; i++)
if (a[i]) C[i][j] = (i == j);
}
void solve(double a[][N], double c[][N]) {
for (int i = 1; i <= n; i++) {
int t = i;
for (int j = i + 1; j <= n; j++)
if (ab(a[j][i]) > ab(a[t][i])) t = j;
for (int j = 1; j <= n; j++) swap(a[i][j], a[t][j]), swap(c[i][j], c[t][j]);
for (int j = 1; j <= n; j++)
if (j != i) {
double f = a[j][i] / a[i][i];
for (int k = 1; k <= n; k++)
a[j][k] -= f * a[i][k], c[j][k] -= f * c[i][k];
}
double f = a[i][i];
for (int j = 1; j <= n; j++) a[i][j] /= f, c[i][j] /= f;
}
}
double f[M][M], g[M][M];
int id[N], l = 0;
void mult(double a[][M], const double b[][M]) {
static double c[M][M];
memset(c, 0, sizeof(c));
for (int i = 1; i <= l; i++)
for (int k = 1; k <= l; k++)
for (int j = 1; j <= l; j++) c[i][j] += a[i][k] * b[k][j];
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++) a[i][j] = c[i][j];
}
void pw(double a[][M], int b) {
static double w[M][M];
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++) w[i][j] = (i == j);
for (; b; b >>= 1, mult(a, a))
if (b & 1) mult(w, a);
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++) a[i][j] = w[i][j];
}
int main() {
int k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
b[x][y]++, b[y][x]++, d[x]++, d[y]++;
}
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++) b[x][y] /= d[x];
build(), solve(A, C);
for (int i = 1; i <= n; i++)
if (a[i]) id[i] = ++l;
for (int i = 1; i <= n; i++)
if (a[i])
for (int j = 1; j <= n; j++)
if (a[j]) {
f[id[i]][id[j]] = 0;
for (int k = 1; k <= n; k++) f[id[i]][id[j]] += b[i][k] * C[k][j];
}
pw(f, k - 2);
for (int i = 1; i <= n; i++)
if (a[i]) g[1][id[i]] = C[1][i];
mult(g, f);
printf("%.9lf\n", g[1][l]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, ANS;
bool D[105][105][105];
char s[105];
bool get(int i, int j, int k) {
if (!D[i][j][k]) return 0;
if (D[i - 1][j][k] && D[i + 1][j][k]) return 1;
if (D[i][j - 1][k] && D[i][j + 1][k]) return 1;
if (D[i][j][k - 1] && D[i][j][k + 1]) return 1;
if (D[i - 1][j][k] && (D[i][j + 1][k] && !D[i - 1][j + 1][k] ||
D[i][j][k + 1] && !D[i - 1][j][k + 1]))
return 1;
if (D[i + 1][j][k] && D[i][j - 1][k] && !D[i + 1][j - 1][k]) return 1;
if (D[i + 1][j][k] && D[i][j][k - 1] && !D[i + 1][j][k - 1]) return 1;
if (D[i][j][k - 1] && D[i][j + 1][k] && !D[i][j + 1][k - 1]) return 1;
if (D[i][j - 1][k] && D[i][j][k + 1] && !D[i][j - 1][k + 1]) return 1;
return 0;
}
int main() {
scanf("%d %d %d", &N, &M, &K);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
scanf("%s", s);
for (int k = 1; k <= K; k++) D[i][j][k] = (s[k - 1] == '1') ? 1 : 0;
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
for (int k = 1; k <= K; k++)
if (get(i, j, k)) ANS++;
printf("%d", ANS);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1 << 28;
double a, b, c, d, space;
int main() {
while (cin >> a >> b >> c >> d) {
a = a / b;
c = c / d;
space = a * c + a * (1 - c) + (1 - a) * c;
printf("%.12lf\n", a / space);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int Max, Min, len, ans;
};
node merge(node l, node r) {
node res;
res.Max = max(l.Max, r.Max + l.len);
res.Min = min(l.Min, r.Min + l.len);
res.len = l.len + r.len;
res.ans = min({l.ans, r.ans, r.Min + l.len - l.Max});
return res;
}
vector<node> tr[((1 << 20) + 10)];
int n, k, cnt[((1 << 20) + 10)];
void build(int p, int l, int r) {
tr[p].resize(r - l + 1);
if (l == r) {
tr[p][0].len = 1;
tr[p][0].ans = 0x3f3f3f3f;
if (cnt[l] > 0)
tr[p][0].Max = tr[p][0].Min = 0;
else
tr[p][0].Max = -0x3f3f3f3f, tr[p][0].Min = 0x3f3f3f3f;
return;
}
int mid = (l + r) >> 1;
build((p << 1), l, mid);
build((p << 1 | 1), mid + 1, r);
for (int i = (0); i <= (mid - l); i++) {
tr[p][i] = merge(tr[(p << 1)][i], tr[(p << 1 | 1)][i]);
tr[p][i + (mid - l + 1)] = merge(tr[(p << 1 | 1)][i], tr[(p << 1)][i]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (1); i <= (n); i++) {
int x;
scanf("%d", &x);
cnt[x]++;
}
build(1, 0, (1 << k) - 1);
for (int i = (0); i <= ((1 << k) - 1); i++) {
printf("%d ", tr[1][i].ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
struct Node {
int a, b, id;
bool operator<(const Node &tt) const {
if (b == tt.b) {
return a < tt.a;
}
return b > tt.b;
}
};
Node z[N];
set<pair<int, int> > st;
long long sum, l[N], r[N];
int n, p, K;
void ins(int val, int id, int lim) {
st.insert(make_pair(val, id));
sum += val;
if (st.size() > lim) {
sum -= st.begin()->first;
st.erase(st.begin());
}
}
void init() {
sum = 0;
st.clear();
}
int main() {
cin >> n >> p >> K;
for (int i = 0; i < n; i++) {
cin >> z[i].a >> z[i].b;
z[i].id = i + 1;
}
sort(z, z + n);
init();
for (int i = 0; i < n; i++) {
ins(z[i].a, z[i].id, K);
l[i] = sum;
}
init();
for (int i = n - 1; i >= 0; i--) {
ins(z[i].b, z[i].id, p - K);
r[i] = sum;
}
int xp = -1;
long long a = 0, b = 0;
for (int i = K - 1; i < n - (p - K); i++) {
if (l[i] > a || l[i] == a && r[i] > b) {
xp = i;
a = l[i];
b = r[i];
}
}
init();
for (int i = 0; i <= xp; i++) {
ins(z[i].a, z[i].id, K);
}
for (set<pair<int, int> >::iterator it = st.begin(); it != st.end(); it++) {
cout << it->second << " ";
}
init();
for (int i = n - 1; i > xp; i--) {
ins(z[i].b, z[i].id, p - K);
}
for (set<pair<int, int> >::iterator it = st.begin(); it != st.end(); it++) {
cout << it->second << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long rr[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long cc[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long mod = 1e9 + 7;
const long long N = 300050;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long test = 1;
while (test--) {
long long n, m;
cin >> n >> m;
long long a[n];
map<long long, long long> mp;
queue<long long> q;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]] = 0;
q.push(a[i]);
}
long long cnt = 0;
vector<long long> ans;
while (q.size()) {
if (ans.size() == m) {
break;
}
long long v = q.front();
q.pop();
if (mp[v] != 0) {
ans.push_back(v);
cnt += mp[v];
}
if (mp.count(v - 1) == 0) {
mp[v - 1] = mp[v] + 1;
q.push(v - 1);
}
if (mp.count(v + 1) == 0) {
mp[v + 1] = mp[v] + 1;
q.push(v + 1);
}
}
cout << cnt << '\n';
for (auto it : ans) cout << it << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline namespace Infinity {
const char CR = '\n';
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { cout << n; }
inline void write(const unsigned long long n) { cout << n; }
inline void writef(const double a, const int n = 15) { printf("%.*f", n, a); }
inline void writef(const long double a, const int n = 18) {
cout << setprecision(n) << fixed << a;
}
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[] = "") { printf("%s", s); }
inline void write(const string &s) { cout << s; }
inline void write(const pair<int, int> &p) {
printf("%d %d", p.first, p.second);
}
template <class T>
inline void write(const T a) {
for (auto i : a) write(i);
}
inline void writeln() { write(CR); }
template <typename T>
inline void writeln(const T &a) {
write(a);
write(CR);
}
inline void writefln(const double a, int n) {
printf("%.*f", n, a);
write(CR);
}
inline void writefln(const long double a, int n = 18) {
cout << setprecision(n) << fixed << a << endl;
}
inline void writesln(const int *a, const int l, const int r) {
for (int i = l; i <= r; i++) printf("%d ", a[i]);
writeln(CR);
}
template <class T>
inline void writelns(const T a) {
for (__typeof a.begin() i = a.begin(); i != a.end(); i++) writeln(*i);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
write(a);
write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
write(args...);
write(CR);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
inline int read(int &n) { return scanf("%d", &n); }
inline int read(long long &n) { return cin >> n ? 1 : -1; }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
read(n);
return read(args...);
}
inline char getcc() {
char c;
do c = getchar();
while (c == ' ' || c == '\n');
return c;
}
inline int getint() {
int n;
read(n);
return n;
}
inline long long getll() {
long long n;
read(n);
return n;
}
inline double getdouble() {
double n;
scanf("%lf", &n);
return n;
}
inline vector<int> getints(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) v[i] = getint();
return v;
}
inline vector<pair<int, int>> getpairs(int n) {
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
int a = getint(), b = getint();
v[i] = pair<int, int>(a, b);
}
return v;
}
inline void read(string &str, const unsigned size) {
char s[size];
scanf("%s", s);
str = string(s);
}
inline string getstr(const unsigned size = 1048576) {
string s;
read(s, size + 1);
return s;
}
inline string getln(const unsigned size = 1048576) {
char s[size + 1];
scanf("%[^\n]", s);
return string(s);
}
} // namespace Infinity
int main() {
bitset<32> n = getint();
for (int i = 31; i >= 0; i--)
if (n[i]) write(i + 1, ' ');
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int ui;
typedef long long ll;
typedef unsigned long long ull;
const int N=1e6+2,p=1e9+7;
int f[N],st[N],ed[N];
int n,c,i,t,m,j,k,tp,x,y,ans,z,w,la,s;
inline int ksm(register int x,register int y)
{
register int r=1;
while (y)
{
if (y&1) r=(ll)r*x%p;
x=(ll)x*x%p;
y>>=1;
}
return r;
}
inline void read(register int &x)
{
register int c=getchar(),fh=1;
while ((c<48)||(c>57))
{
if (c=='-') {c=getchar();fh=-1;break;}
c=getchar();
}
x=c^48;c=getchar();
while ((c>=48)&&(c<=57))
{
x=x*10+(c^48);
c=getchar();
}
x*=fh;
}
int getf(int x) {return f[x]==x?x:f[x]=getf(f[x]);}
int main()
{
read(m);read(n);
for (i=1;i<=n;i++) f[i]=i;
for (i=1;i<=m;i++)
{
read(z);
if (z==1) {read(x);x=getf(x);if (!ed[x]) ed[x]=1,st[++tp]=i;continue;}
read(x);read(y);
x=getf(x);y=getf(y);
if (x==y||ed[x]&&ed[y]) continue;
st[++tp]=i;f[x]=y;ed[y]|=ed[x];
}
printf("%d %d\n",ksm(2,tp),tp);
for (i=1;i<=tp;i++) printf("%d%c",st[i],i==tp?10:32);
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 20 | 1;
inline char gc() {
static char ibuf[RLEN], *ib, *ob;
(ib == ob) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ib == ob) ? EOF : *ib++;
}
inline int read() {
char ch = gc();
int res = 0;
bool f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
inline long long readll() {
char ch = gc();
long long res = 0;
bool f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
inline char readchar() {
char ch = gc();
while (isspace(ch)) ch = gc();
return ch;
}
inline int readstring(char *s) {
int top = 0;
char ch = gc();
while (isspace(ch)) ch = gc();
while (!isspace(ch) && ch != EOF) s[++top] = ch, ch = gc();
s[top + 1] = '\0';
return top;
}
template <typename tp>
inline void chemx(tp &a, tp b) {
a = max(a, b);
}
template <typename tp>
inline void chemn(tp &a, tp b) {
a = min(a, b);
}
const int mod = 1e9 + 7;
inline int add(int a, int b) {
return (a + b) >= mod ? (a + b - mod) : (a + b);
}
inline int dec(int a, int b) { return (a < b) ? (a - b + mod) : (a - b); }
inline int mul(int a, int b) {
static long long r;
r = (long long)a * b;
return (r >= mod) ? (r % mod) : r;
}
inline void Add(int &a, int b) { a = (a + b) >= mod ? (a + b - mod) : (a + b); }
inline void Dec(int &a, int b) { a = (a < b) ? (a - b + mod) : (a - b); }
inline void Mul(int &a, int b) {
static long long r;
r = (long long)a * b;
a = (r >= mod) ? (r % mod) : r;
}
inline int ksm(int a, int b, int res = 1) {
for (; b; b >>= 1, Mul(a, a)) (b & 1) && (Mul(res, a), 1);
return res;
}
inline int Inv(int x) { return ksm(x, mod - 2); }
inline int fix(long long x) {
x %= mod;
return (x < 0) ? x + mod : x;
}
const int N = 505;
int n, cnt[N];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read();
if (x != -1) cnt[x]++;
}
int res = dec(ksm(2, n - 1), 1);
for (int i = 1; i <= n; i++)
if (cnt[i]) Dec(res, dec(ksm(2, cnt[i]), 1));
cout << res << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
const int fmaxN = 3010, fmaxE = (3 * N + 10) * 2;
int fn, src, snk;
int head[fmaxN], from[fmaxE], nxt[fmaxE], to[fmaxE], cap[fmaxE], cost[fmaxE];
int edgeCnt, visID, vis[fmaxN];
void init() {
edgeCnt = 0;
memset(head, -1, sizeof head);
}
void addEdge(int f, int t, int cp, int cst) {
nxt[edgeCnt] = head[f];
to[edgeCnt] = t;
cap[edgeCnt] = cp;
cost[edgeCnt] = cst;
from[edgeCnt] = f;
head[f] = edgeCnt++;
}
void addBiEdge(int f, int t, int cp, int cst) {
addEdge(f, t, cp, cst);
addEdge(t, f, 0, -cst);
}
int dist[fmaxN], flow[fmaxN], parent[fmaxN];
int bellman() {
queue<int> Q;
visID++;
memset(dist, 0x3f, sizeof(dist[0]) * fn);
memset(flow, 0, sizeof(flow[0]) * fn);
dist[src] = 0;
flow[src] = 1e9;
Q.push(src);
vis[src] = visID;
for (int i = 0; i < fn; i++) {
int s = Q.size();
while (s--) {
int cur = Q.front();
Q.pop();
vis[cur] = 0;
for (int j = head[cur]; j != -1; j = nxt[j]) {
int node = to[j];
if (cap[j] && dist[node] > dist[cur] + cost[j]) {
dist[node] = dist[cur] + cost[j];
parent[node] = j;
flow[node] = min(flow[cur], cap[j]);
if (vis[node] != visID) Q.push(node), vis[node] = visID;
}
}
}
if (Q.empty()) {
if (flow[snk]) {
for (int i = snk; i != src; i = from[parent[i]]) {
int j = parent[i];
cap[j] -= flow[snk];
cap[j ^ 1] += flow[snk];
}
}
return flow[snk];
}
}
return 0;
}
pair<int, int> minCost_maxFlow() {
int cst = 0, flw = 0;
if (src == snk) return {0, 1e9};
while (bellman()) {
cst += dist[snk] * flow[snk];
flw += flow[snk];
}
return {cst, flw};
}
int n, p, s;
int a[N], b[N];
int main() {
scanf("%d", &n), scanf("%d", &p), scanf("%d", &s);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
init();
int prog = n, sport = prog + 1;
src = sport + 1, snk = src + 1;
fn = snk + 1;
for (int i = 0; i < n; ++i) {
addBiEdge(src, i, 1, 0);
addBiEdge(i, prog, 1, -a[i]);
addBiEdge(i, sport, 1, -b[i]);
}
addBiEdge(prog, snk, p, 0);
addBiEdge(sport, snk, s, 0);
pair<int, int> res = minCost_maxFlow();
printf("%d\n", -res.first);
for (int i = 0; i < n; ++i)
for (int j = head[i]; ~j; j = nxt[j]) {
if (to[j] == prog && !cap[j]) {
printf("%d ", i + 1);
break;
}
}
puts("");
for (int i = 0; i < n; ++i)
for (int j = head[i]; ~j; j = nxt[j]) {
if (to[j] == sport && !cap[j]) {
printf("%d ", i + 1);
break;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int dp[105][105] = {0};
int dpp[105][10005] = {0};
int num[105] = {0};
int main() {
int N, M, k, t;
cin >> N >> M;
for (int i = 1; i <= N; i++) {
cin >> num[i];
for (int j = 1; j <= num[i]; j++) {
cin >> a[j];
}
for (int s = 1; s <= num[i]; s++) {
for (int f = 0; f <= s; f++) {
int ans = 0;
for (int x = 1; x <= f; x++) ans += a[x];
for (int x = 1; x <= s - f; x++) ans += a[num[i] + 1 - x];
dp[i][s] = dp[i][s] > ans ? dp[i][s] : ans;
}
}
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
for (int z = 0; z <= num[i] && z <= j; z++) {
dpp[i][j] = dpp[i][j] > (dpp[i - 1][j - z] + dp[i][z])
? dpp[i][j]
: (dpp[i - 1][j - z] + dp[i][z]);
}
cout << dpp[N][M];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using pcc = pair<char, char>;
using pdd = pair<double, double>;
using pci = pair<char, int>;
using si = set<int>;
using s = string;
using seti = set<int>;
using useti = unordered_set<int>;
using mseti = multiset<int>;
using umseti = unordered_multiset<int>;
using vi = vector<int>;
using vc = vector<char>;
using vs = vector<string>;
using vd = vector<double>;
using vll = vector<ll>;
using vpii = vector<pii>;
using msi = map<string, int>;
using mii = map<int, int>;
using mci = map<char, int>;
using umsi = unordered_map<string, int>;
const int mod = (int)1e9 + 7;
const int maxn = (int)2e5 + 5;
const int inf = 1e9 + 9;
const ll INF = 1e18;
const double pi = 3.141592653589793;
int n, m;
int color[100005];
int a[3];
void solve() {
cin >> n >> m;
memset(color, 0, sizeof(color));
for (int i = 0; i < m; i++) {
cin >> a[0] >> a[1] >> a[2];
if (i == 0) {
color[a[0]] = 1;
color[a[1]] = 2;
color[a[2]] = 3;
} else {
if (color[a[0]] != 0) {
color[a[1]] = (color[a[0]] + 1);
color[a[2]] = (color[a[0]] + 2);
if (color[a[1]] > 3) color[a[1]] -= 3;
if (color[a[2]] > 3) color[a[2]] -= 3;
} else if (color[a[1]] != 0) {
color[a[0]] = (color[a[1]] + 1);
color[a[2]] = (color[a[1]] + 2);
if (color[a[0]] > 3) color[a[0]] -= 3;
if (color[a[2]] > 3) color[a[2]] -= 3;
} else if (color[a[2]] != 0) {
color[a[0]] = (color[a[2]] + 1);
color[a[1]] = (color[a[2]] + 2);
if (color[a[0]] > 3) color[a[0]] -= 3;
if (color[a[1]] > 3) color[a[1]] -= 3;
} else {
color[a[0]] = 1;
color[a[1]] = 2;
color[a[2]] = 3;
}
}
}
for (int i = 1; i <= n; i++) cout << color[i] << " ";
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e9 + 100;
const long long inf_ll = 1e18;
const double pi = 3.1415926535898;
template <class T1, class T2>
std::ostream &operator<<(std::ostream &out, const std::pair<T1, T2> &rhs) {
out << "( " << rhs.first << " , " << rhs.second << " )";
return out;
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A>
string to_string(vector<vector<A>> v) {
bool first = true;
string res = "\n{";
for (const auto &x : v) {
if (!first) {
res += ",\n ";
}
first = false;
res += to_string(x);
}
res += "}\n";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
bool debug = 0;
const int MAXN = 2e5 + 100;
const int LOG = 20;
const int mod = 998244353;
const int MX = (1e7 + 100);
vector<int> g_init[MAXN];
int tin[MAXN], tout[MAXN];
int timer;
int up[MAXN][LOG];
void init_dfs(int v, int p) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i < LOG; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (int to : g_init[v]) {
if (to == p) continue;
init_dfs(to, v);
}
tout[v] = timer;
}
inline bool is_parent(int a, int b) {
return tin[a] <= tin[b] && tout[b] <= tout[a];
}
int lca(int a, int b) {
if (is_parent(a, b)) return a;
if (is_parent(b, a)) return b;
for (int i = LOG - 1; i >= 0; --i) {
if (!is_parent(up[a][i], b)) {
a = up[a][i];
}
}
return up[a][0];
}
vector<int> g[MAXN];
int parent[MAXN];
int dp[MAXN][2];
bool bad[MAXN];
void dfs(int v) {
for (int to : g[v]) {
dfs(to);
}
if ((int(g[v].size())) == 0) {
dp[v][0] = 1;
dp[v][1] = 0;
return;
}
int sum = 0;
for (int to : g[v]) {
sum += dp[to][0];
}
if (bad[v]) {
dp[v][0] = sum + 1;
dp[v][1] = sum;
42;
return;
}
int val = 1;
for (int to : g[v]) {
val += min(dp[to][0], dp[to][1]);
}
dp[v][0] = min(val, sum);
dp[v][1] = inf_int;
for (int to : g[v]) {
dp[v][1] = min(dp[v][1], sum - dp[to][0] + dp[to][1]);
}
42;
}
void solve_query() {
int k;
cin >> k;
vector<int> a;
for (int i = 1; i <= k; ++i) {
int v;
cin >> v;
a.push_back(v);
}
sort(a.begin(), a.end(),
[](int a, int b) -> bool { return tin[a] < tin[b]; });
vector<int> spec = a;
for (int i = 1; i < (int(a.size())); ++i) {
spec.push_back(lca(a[i], a[i - 1]));
}
sort(spec.begin(), spec.end());
spec.resize(unique(spec.begin(), spec.end()) - spec.begin());
sort(spec.begin(), spec.end(),
[](int a, int b) -> bool { return tin[a] < tin[b]; });
for (int v : spec) {
g[v].clear();
parent[v] = -1;
bad[v] = false;
}
for (int v : a) {
bad[v] = true;
}
stack<int> st;
42;
42;
int root = spec[0];
for (int v : spec) {
while (!st.empty() && !is_parent(st.top(), v)) {
st.pop();
}
if (!st.empty()) {
parent[v] = st.top();
g[parent[v]].push_back(v);
}
st.push(v);
}
for (int v : spec) {
42;
if (parent[v] == up[v][0] && bad[v] && bad[up[v][0]]) {
cout << -1 << "\n";
return;
}
}
dfs(root);
cout << min(dp[root][0], dp[root][1]) << "\n";
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n - 1; ++i) {
int a, b;
cin >> a >> b;
g_init[a].push_back(b);
g_init[b].push_back(a);
}
init_dfs(1, 1);
int q;
cin >> q;
while (q--) solve_query();
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(15);
int t = 1;
while (t--) solve();
42;
}
| 10 |
#pragma GCC optimize (3)
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<iomanip>
#include<functional>
#include<cassert>
#include<numeric>
#include<algorithm>
#include<cctype>
#include<ctime>
#include<unordered_map>
/*#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/hash_policy.hpp>
#include<ext/pb_ds/trie_policy.hpp>
#include<ext/pb_ds/priority_queue.hpp>*/
//#include<ext/rope>
#define ll long long
#define ull unsigned long long
#define INFI 2147483647
#define INFL 9223372036854775807
#define INFU 18446744073709551615
#define maxn 200005
using namespace std;
//using namespace __gnu_pbds;
//using namespace __gnu_cxx;
const double PI=acos(-1.0);
const double eps=1e-6;
bool vis[2*maxn];
int a[maxn];
inline int read()
{
int x=0,f=1;
char ch=getchar();
while(ch<'0' || ch>'9'){
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0' && ch<='9'){
x=x*10+ch-'0';
ch=getchar();
}
return x*f;
}
signed main()
{
//ios_base::sync_with_stdio(false);
//cin.tie(0);
//cout.tie(0);
int T=read();
while(T--){
int n=read();
for(int i=0;i<=2*n+1;i++) vis[i]=0;
for(int i=1;i<=n;i++){
a[i]=read();
vis[a[i]]=1;
}
if(n==1){
cout<<1<<endl;
continue;
}
int s=0,mx=0,mn=0;
for(int i=1;i<=2*n;i++){
if(vis[i]) s++;
else s--;
mx=max(mx,s);
mn=min(mn,s);
}
cout<<n-(mx-mn)+1<<endl;
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
T t = bigmod(p, e / 2, M);
return (t * t) % M;
}
return (bigmod(p, e - 1, M) * p) % M;
}
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);
}
template <class T>
inline T multimod(T a, T b, T m) {
T res = 0;
a %= m, b %= m;
while (b) {
if (b & 1) res = m - res > a ? (res + a) : (res + a - m);
b >>= 1;
a = (m - a) > a ? a + a : a + a - m;
}
return (T)res;
}
void sc(int &a) { scanf("%d", &a); }
void sc(long long &a) { scanf("%lld", &a); }
void sc(double &a) { scanf("%lf", &a); }
void sc(int &a, int &b) { scanf("%d %d", &a, &b); }
void sc(long long &a, long long &b) { scanf("%lld %lld", &a, &b); }
void sc(int &a, int &b, int &c) { scanf("%d %d %d", &a, &b, &c); }
void sc(int &a, int &b, long long &c) { scanf("%d %d %lld", &a, &b, &c); }
void sc(long long &a, long long &b, long long &c) {
scanf("%lld %lld %lld", &a, &b, &c);
}
void sc(string &str) { cin >> str; }
void sc(char *(str)) { scanf(" %s", str); }
void sc(char &c) { scanf(" %c", &c); }
const long long MD = 998244353ll;
long long fact[(200000 + 7)];
long long C(int n, int c) {
long long upore = fact[n];
long long niche = (fact[c] * fact[n - c]) % MD;
return (upore * modinverse(niche, MD)) % MD;
}
long long P(int n, int c) {
long long upore = fact[n];
long long niche = (fact[c]) % MD;
return (upore * modinverse(niche, MD)) % MD;
}
int main() {
int i, t, cases = 1, j, pos;
long long n, k;
string str;
fact[0] = 1ll;
for (long long i = 1; i < (200000 + 7); i++) {
fact[i] = (fact[i - 1] * i) % MD;
}
sc(n, k);
long long c = n - k;
if (k == 0) {
cout << fact[n] << endl;
return 0;
}
if (c < 0) {
cout << 0 << endl;
return 0;
}
long long ans = 0;
for (long long i = 1; i <= c; i++) {
if (i % 2 == c % 2) {
ans = (ans + (bigmod(i, n, MD) * C(c, i)) % MD) % MD;
} else {
ans = (ans - (bigmod(i, n, MD) * C(c, i)) % MD) % MD;
}
}
ans = (ans + MD) % MD;
cout << ((ans * C(n, c)) % MD * 2ll) % MD << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
n--;
long long s = k + n - 1;
long long p = sqrt(2 * s + 2) + 2;
while (p * (p + 3) / 2 > s) p--;
printf("%lld\n", n - p);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
bool endmark;
node* next[26];
node() {
endmark = false;
for (int i = 0; i < 26; i++) {
next[i] = NULL;
}
}
} * root;
void insert(string s) {
node* cur = root;
int ln = s.size();
for (int i = 0; i < ln; i++) {
int id = s[i] - 'a';
if (cur->next[id] == NULL) {
cur->next[id] = new node();
}
cur = cur->next[id];
}
cur->endmark = true;
}
int win(node* cur) {
for (int i = 0; i < 26; i++) {
if (cur->next[i]) {
int a = win(cur->next[i]);
if (a == 0) return 1;
}
}
return 0;
}
int loose(node* cur) {
int cnt = 0;
for (int i = 0; i < 26; i++) {
if (cur->next[i]) {
int a = loose(cur->next[i]);
if (a == 0) return 1;
cnt++;
}
}
if (!cnt) return 1;
return 0;
}
void solve() {
root = new node();
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
insert(s);
}
int w = win(root), l = loose(root);
if (w == 1 and l == 1) {
cout << "First"
<< "\n";
} else if (w == 0) {
cout << "Second"
<< "\n";
} else {
if (k % 2) {
cout << "First"
<< "\n";
} else
cout << "Second"
<< "\n";
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
long long s[200005];
long long searchLower(long long left, long long right, long long val) {
long long mid = (left + right) / 2;
if (s[left] > val) return -1;
while (left <= right) {
if (s[mid] == val)
return mid;
else if (s[mid] < val)
left = mid;
else
right = mid - 1;
if (s[right] <= val) return right;
if (right - left == 1 and s[left] < val) return left;
mid = (left + right) / 2;
}
}
int main() {
long long n, q;
cin >> n >> q;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
s[i] = a[i];
else
s[i] = s[i - 1] + a[i];
}
for (long long i = 0; i < q; i++) {
long long b;
cin >> b;
long long ind = searchLower(0, n - 1, b);
long long c = b - s[ind];
if (ind == -1) {
c = b;
}
if (c == 0) {
c = a[ind];
ind--;
}
cout << ind + 2 << " " << c << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
const int mod = 1e9 + 7;
const int mod2 = 1e9 + 13;
char s[maxn];
int nx[maxn];
int dp[maxn][maxn], n;
int hs[maxn][maxn];
void Init() {
int id = n;
nx[n] = n;
for (int i = n - 1; i >= 0; i--) {
nx[i] = id;
if (s[i] != '0') id = i;
}
for (int i = 0; i <= n - 1; i++) {
hs[i][i] = s[i] - '0';
for (int j = i + 1; j <= n - 1; j++)
hs[i][j] = (10ll * hs[i][j - 1] % mod2 + s[j] - '0') % mod2;
}
}
int NX(int k) {
if (k >= n)
return n;
else
return nx[k];
}
bool Cmpr(int s1, int t1, int s2, int t2) {
if (t1 - s1 != t2 - s2)
return t1 - s1 < t2 - s2;
else {
if (hs[s1][t1] == hs[s2][t2]) return false;
for (int i = s1; i <= t1; i++) {
if (s[i] != s[s2 + i - s1]) return s[i] < s[s2 + i - s1];
}
return false;
}
}
void DP() {
memset(dp, 0, sizeof(dp));
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '0') continue;
dp[i][n - 1] = 1;
for (int j = i + 1; j <= n - 1; j++) {
if (s[j] == '0') continue;
int id = NX(2 * j - i - 1);
if (Cmpr(i, j - 1, j, id - 1))
dp[i][j - 1] = dp[j][id - 1];
else {
id = NX(id);
if (Cmpr(i, j - 1, j, id - 1)) dp[i][j - 1] = dp[j][id - 1];
}
}
for (int j = n - 1; j >= i; j--) {
dp[i][j] = (dp[i][j] + dp[i][j + 1]) % mod;
}
}
int id = nx[0];
cout << dp[0][id - 1] << endl;
}
int main() {
scanf("%d", &n);
scanf("%s", s);
Init();
DP();
return 0;
}
| 6 |
#include <bits/stdc++.h>
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main(int argc, char *argv[]) {
int tc;
scanf("%d", &tc);
while (tc--) {
int i, cs, cw, s, w, max = -10, p, f;
scanf("%d%d%d%d%d%d", &p, &f, &cs, &cw, &s, &w);
int mi = cs, ma = cw, ss = s, ww = w;
if (w < s) {
mi = cw, ma = cs, ss = w, ww = s;
}
for (i = 0; i <= mi; i++) {
int cntf = 0, cntp = 0, d;
cntp += min(i, p / ss);
d = (p - cntp * ss) / ww;
cntp += d;
cntf += min(mi - min(i, p / ss), f / ss);
cntf += min(ma - d, (f - cntf * ss) / ww);
if ((cntf + cntp) > max) max = cntf + cntp;
}
printf("%d\n", max);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
char c[5010][5010];
vector<int> v[5010];
bool vis[5010];
void dfs(int a, int b) {
vis[b] = 1;
for (int i = 0; i < v[b].size(); i++) {
if (c[v[b][i]][a] == '1') {
cout << a + 1 << " " << b + 1 << " " << v[b][i] + 1 << endl;
exit(0);
} else if (!vis[v[b][i]]) {
dfs(b, v[b][i]);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%s", &c[i]);
for (int j = 0; j < n; j++) {
if (c[i][j] == '1') {
v[i].push_back(j);
}
}
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(n, i);
}
}
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string rreplace(string s, string temp, string temp2) {
string t = temp + '#' + s;
vector<int> z(s.size() + 1 + temp.size(), 0);
int l = 0, r = 0;
for (int i = 1; i < t.size(); ++i) {
if (r >= i) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < t.size() && t[i + z[i]] == t[z[i]]) ++z[i];
if (i + z[i] - 1 > r) {
r = i + z[i] - 1;
l = i;
}
}
for (int i = 1; i < t.size(); ++i) {
if (z[i] == temp.size()) {
for (int j = 0; j < temp.size(); ++j)
s[i - temp.size() - 1 + j] = temp2[j];
return s;
}
}
return s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> a(n);
vector<string> b(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
string s, t;
int l, r, ll, rr;
bool f = true;
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
int l1, r1;
l1 = -1, r1 = a[i].size() - 1;
for (int j = 0; j < a[i].size(); ++j)
if (a[i][j] != b[i][j]) {
r1 = j;
if (l1 == -1) l1 = j;
}
if (f) {
ll = l1, rr = r1;
l = 0, r = a[i].size() - 1;
s = a[i], t = b[i];
f = false;
} else {
if (rr - ll != r1 - l1) {
cout << "NO\n";
return 0;
}
for (int j = 0; j < rr - ll + 1; ++j)
if (s[ll + j] != a[i][l1 + j] || t[ll + j] != b[i][l1 + j]) {
cout << "NO\n";
return 0;
}
int j = 1;
while (ll - j >= 0 && l1 - j >= 0 && s[ll - j] == a[i][l1 - j] &&
t[ll - j] == b[i][l1 - j])
++j;
l = max(ll - j + 1, l);
j = 1;
while (rr + j < s.size() && r1 + j < a[i].size() &&
s[rr + j] == a[i][r1 + j] && t[rr + j] == b[i][r1 + j])
++j;
r = min(r, rr + j - 1);
}
}
}
string s1, t1;
for (int i = l; i <= r; ++i) {
s1 += s[i];
t1 += t[i];
}
s = s1;
t = t1;
for (int i = 0; i < n; ++i) {
a[i] = rreplace(a[i], s, t);
if (a[i] != b[i]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
cout << s << '\n';
cout << t << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, k, l, Min = INT_MAX;
cin >> n >> m;
vector<int> v, a, b;
for (i = 0; i < n; i++) {
cin >> j;
v.push_back(j);
}
for (i = 0; i < n; i++) {
cin >> j;
a.push_back(j);
}
sort(a.begin(), a.end());
for (i = 0; i < n; i++) {
if (a[i] >= v[0])
k = a[i] - v[0];
else if (a[i] < v[0])
k = m - v[0] + a[i];
b.clear();
for (j = 0; j < n; j++) {
b.push_back((v[j] + k) % m);
}
sort(b.begin(), b.end());
long long flag = 0;
for (l = 0; l < n; l++) {
if (b[l] != a[l]) {
flag = 1;
break;
}
}
if (flag == 0 && k < Min) Min = k;
}
cout << Min;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int n;
set<int> s;
void work() {
n = read();
for (register int i = (int)(0); i <= (int)(n - 1); i++) s.insert(i);
for (register int i = (int)(1); i <= (int)(n); i++) {
int x = read();
if (x > (*s.begin())) {
printf("%d\n", i);
return;
}
if (s.find(x) != s.end()) s.erase(x);
}
puts("-1");
}
int main() { work(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, n;
string str = "NO";
int k = 2 * n;
cin >> k >> x >> y;
n = k / 2;
if ((x == n && y == n) || (x == n + 1 && y == n) || (x == n && y == n + 1) ||
(x == n + 1 && y == n + 1)) {
cout << str << endl;
} else {
str = "YES";
cout << str << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300009];
stack<int> mi, ma;
struct data {
int x, y;
data(int o = 1000000000, int z = 0) { x = o, y = z; }
data operator+(const data b) const {
data c;
c.x = min(x, b.x);
if (x == c.x) c.y += y;
if (b.x == c.x) c.y += b.y;
return c;
}
} s[300009 << 2];
int lazy[300009 << 2];
void mark(int now, int v) {
lazy[now] += v;
s[now].x += v;
}
void pushdown(int now) {
if (lazy[now]) {
mark(now << 1, lazy[now]);
mark(now << 1 | 1, lazy[now]);
lazy[now] = 0;
}
}
void modify(int l, int r, int now, int p, int v) {
if (l == r) {
s[now].x = v;
s[now].y = 1;
return;
}
pushdown(now);
int mid = (l + r) >> 1;
if (p <= mid)
modify(l, mid, now << 1, p, v);
else
modify(mid + 1, r, now << 1 | 1, p, v);
s[now] = s[now << 1] + s[now << 1 | 1];
}
void update(int l, int r, int now, int L, int R, int v) {
if (l >= L && r <= R) {
mark(now, v);
return;
}
pushdown(now);
int mid = (l + r) >> 1;
if (L <= mid) update(l, mid, now << 1, L, R, v);
if (R > mid) update(mid + 1, r, now << 1 | 1, L, R, v);
s[now] = s[now << 1] + s[now << 1 | 1];
}
data query(int l, int r, int now, int L, int R) {
if (l >= L && r <= R) {
return s[now];
}
pushdown(now);
int mid = (l + r) >> 1;
if (L <= mid && R > mid) {
return query(l, mid, now << 1, L, R) +
query(mid + 1, r, now << 1 | 1, L, R);
} else if (L <= mid)
return query(l, mid, now << 1, L, R);
else
return query(mid + 1, r, now << 1 | 1, L, R);
}
int pmi[300009], pma[300009];
int main() {
scanf("%d", &n);
int x, y, z;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x, &y);
a[y] = x;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
modify(1, n, 1, i, i);
z = i - 1;
while (!mi.empty() && a[i] < a[mi.top()]) {
update(1, n, 1, pmi[mi.top()], z, a[mi.top()] - a[i]);
z = mi.top() - 1;
mi.pop();
}
z = i - 1;
while (!ma.empty() && a[i] > a[ma.top()]) {
update(1, n, 1, pma[ma.top()], z, a[i] - a[ma.top()]);
z = ma.top() - 1;
ma.pop();
}
pmi[i] = mi.empty() ? 1 : mi.top() + 1;
pma[i] = ma.empty() ? 1 : ma.top() + 1;
mi.push(i);
ma.push(i);
ans += s[1].y;
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[8505];
int wh[8505];
int ans[8505];
int level[8505];
int nxt[9][8505];
int prv[9][8505];
pair<int, int> bros[9][8505];
int svd = 0, lsz, l;
inline void go(int &f) {
int id = f, t = 0;
f = nxt[l][f];
if (wh[f] < wh[id]) id = f, t = 1;
f = nxt[l][f];
if (wh[f] < wh[id]) id = f, t = 2;
f = nxt[l][f];
if (t == 2) bros[l - 1][id] = {prv[l][prv[l][id]], prv[l][id]};
if (t == 1) bros[l - 1][id] = {prv[l][id], nxt[l][id]};
if (t == 0) bros[l - 1][id] = {nxt[l][id], nxt[l][nxt[l][id]]};
level[id]--, lsz++, nxt[l - 1][svd] = id, nxt[l - 1][id] = n + 1,
prv[l - 1][id] = svd;
svd = id;
}
bool comp(int a, int b) { return wh[a] < wh[b]; }
struct genQ {
int lvl, pl, pr;
};
vector<genQ> s10;
void solve1() {
vector<int> pos;
int pl = s10.back().pl;
int pr = s10.back().pr;
int lvl = s10.back().lvl;
s10.pop_back();
if (pl != 0) {
if (bros[lvl][pl].first > pl) pos.push_back(bros[lvl][pl].first);
if (bros[lvl][pl].second > pl) pos.push_back(bros[lvl][pl].second);
}
if (pr != n + 1) {
if (bros[lvl][pr].first < pr) pos.push_back(bros[lvl][pr].first);
if (bros[lvl][pr].second < pr) pos.push_back(bros[lvl][pr].second);
}
int l = 3 * lvl + 1;
int t = 0;
for (int i = 0; i < pos.size(); i++) {
if (ans[pos[i]] == 0) t = 1;
}
if (!t) return;
if (pos.size() < 4) {
for (int i = 0; i < pos.size(); i++) {
if (ans[pos[i]] == 0) {
for (int j = l; j <= l + 2; j++) {
int t = 1;
for (int k = 0; k < pos.size(); k++)
if (ans[pos[k]] == j) t = 0;
if (t) {
ans[pos[i]] = j;
break;
}
}
}
}
return;
}
if (pos.size() == 4) {
int t = 0;
sort((pos).begin(), (pos).end(), comp);
for (int lc = l; lc <= l + 2; lc++) {
vector<int> perm = {l, l + 1, l + 2};
sort((perm).begin(), (perm).end());
while (1) {
int ok = 1;
for (int i = 0; i < 3; i++) {
if (ans[pos[i]] != 0 && ans[pos[i]] != perm[i]) {
ok = 0;
break;
}
}
if (ans[pos[3]] != 0 && ans[pos[3]] != lc) ok = 0;
int targ = 0;
for (int i = 0; i < 3; i++) {
if (perm[i] == lc) targ = i;
}
for (int i = 0; i < 3; i++) {
if (pos[i] > pos[targ] && pos[i] < pos[3]) {
targ = -1;
break;
}
if (pos[i] < pos[targ] && pos[i] > pos[3]) {
targ = -1;
break;
}
}
if (targ == -1 && ok) {
for (int i = 0; i < 3; i++) ans[pos[i]] = perm[i];
ans[pos[3]] = lc;
t = 1;
break;
}
if (!next_permutation(perm.begin(), perm.end())) break;
}
if (t) break;
}
return;
}
}
void solve2(vector<int> pos, int l, int r) {
if (pos.size() < 4) {
for (int i = 0; i < pos.size(); i++) {
if (ans[pos[i]] == 0) {
for (int j = l; j <= l + 2; j++) {
int t = 1;
for (int k = 0; k < pos.size(); k++)
if (ans[pos[k]] == j) t = 0;
if (t) {
ans[pos[i]] = j;
break;
}
}
}
}
return;
}
int lst = 0;
for (int i = 1; i < 4; i++)
if (wh[pos[i]] > wh[pos[lst]]) lst = i;
if (ans[pos[lst]] == 0) {
int x = pos[lst];
for (int i = lst; i + 1 < 4; i++) pos[i] = pos[i + 1];
pos[3] = x;
for (int i = 0; i < 3; i++) {
if (ans[pos[i]] == 0) {
for (int j = l; j <= l + 2; j++) {
int t = 1;
for (int k = 0; k < 3; k++)
if (ans[pos[k]] == j) t = 0;
if (t) {
ans[pos[i]] = j;
break;
}
}
}
}
if (lst == 0) ans[pos[3]] = l + 2;
if (lst == 1) ans[pos[3]] = l + 2;
if (lst == 2) ans[pos[3]] = l;
if (lst == 3) ans[pos[3]] = l;
return;
}
if (ans[pos[3 - lst]] != 0) return;
if (lst > 1) {
lst = 3 - lst;
reverse((pos).begin(), (pos).end());
}
if (lst == 1) {
if (wh[pos[2]] < wh[pos[3]] || wh[pos[2]] < wh[pos[0]]) {
ans[pos[3]] = ans[pos[0]];
ans[pos[2]] = 3 * l + 3 - ans[pos[0]] - ans[pos[1]];
}
} else {
ans[pos[2]] = ans[pos[1]] + 1;
if (ans[pos[2]] == l + 3) ans[pos[2]] -= 3;
ans[pos[3]] = ans[pos[2]] + 1;
if (ans[pos[3]] == l + 3) ans[pos[3]] -= 3;
}
}
void solve(int i, int gl) {
int LL = prv[gl][p[i]], RR = nxt[gl][p[i]];
s10.push_back({gl, LL, RR});
s10.push_back({gl, LL, p[i]});
s10.push_back({gl, p[i], RR});
prv[gl][RR] = LL;
nxt[gl][LL] = RR;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++)
wh[p[i]] = i, ans[i] = 0, nxt[8][i] = i + 1, level[i] = 8,
prv[8][i] = i - 1;
for (int i = 1; i <= 8; i++) nxt[i][0] = 1, nxt[i][n + 1] = n + 1;
wh[n + 1] = n + 1;
if (n > 4)
for (l = 8; l >= 1; l--) {
int f = nxt[l][0];
lsz = 0, svd = 0;
while (f != n + 1) go(f);
if (lsz <= 4) break;
}
vector<int> calls[8];
for (int i = n; i >= 1; i--) {
for (int gl = level[p[i]]; gl < 8; gl++) {
calls[gl].push_back(i);
}
}
for (int gl = 1; gl != 8; gl++) {
for (auto i : calls[gl]) solve(i, gl);
while (s10.size()) solve1();
}
for (int lvl = 1; lvl <= 8; lvl++) {
vector<int> ao;
for (int i = 1; i <= n; i++)
if (lvl == level[i] && ans[i] == 0) ao.push_back(i);
solve2(ao, lvl * 3 - 2, lvl * 3);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[500005];
long long b[500005];
struct Line {
long long a, b;
Line() {}
Line(long long a, long long b) : a(a), b(b) {}
long long get(long long x) { return a * x + b; }
};
struct ConvexHull {
vector<Line> a;
bool bad(Line l1, Line l2, Line l3) {
return (l2.a - l3.a) * (l2.b - l1.b) >= (l1.a - l2.a) * (l3.b - l2.b);
}
void add(Line l) {
while ((int(a.size())) >= 2 &&
bad(a[(int(a.size())) - 2], a[(int(a.size())) - 1], l))
a.pop_back();
a.push_back(l);
}
long long get(long long x) {
int l = -1, r = (int(a.size())) - 1;
while (l + 1 < r) {
int m = (l + r) / 2;
if (a[m].get(x) <= a[m + 1].get(x))
l = m;
else
r = m;
}
return a[r].get(x);
}
};
ConvexHull ch;
inline long long sum(int l, int r) {
if (l > r) return 0;
if (!l) return b[r];
return b[r] - b[l - 1];
}
int main() {
scanf("%d", &n);
long long second = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
second += 1LL * (i + 1) * a[i];
b[i] = a[i];
if (i) b[i] += b[i - 1];
}
long long ans = second;
for (int i = 0; i < n; ++i) {
ch.add(Line(i + 1, -sum(0, i - 1)));
ans =
max(ans, second + ch.get(a[i]) + sum(0, i - 1) - 1LL * (i + 1) * a[i]);
}
ch.a.clear();
for (int i = n - 1; i >= 0; --i) {
ch.add(Line(-(i + 1), -sum(0, i)));
ans = max(ans, second + ch.get(-a[i]) + sum(0, i) - 1LL * (i + 1) * a[i]);
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, w[200005] = {}, h[200005] = {};
int h1 = 0, h2 = 0, W = 0, H = 0;
int max1;
long long solve(int x);
int main() {
long long sum;
bool now = false;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w[i] >> h[i];
W += w[i];
if (h[i] > h1) {
h2 = h1;
h1 = h[i];
max1 = i;
now = true;
}
if (h[i] <= h1 && !now && h2 < h[i]) {
h2 = h[i];
}
now = false;
}
sum = W;
for (int i = 0; i < n; i++) {
W = sum;
cout << solve(i) << " ";
}
return 0;
}
long long solve(int x) {
W -= w[x];
if (x == max1)
H = h2;
else
H = h1;
return W * H;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> present;
map<int, string> st;
vector<int> adj[1000001];
vector<string> second;
int visited[1000001] = {0};
pair<int, long long> ans[1000001], cur;
vector<pair<pair<int, long long>, int> > v;
string norm(string h) {
int i, n = (int)h.size();
for (i = 0; i < n; i++) h[i] = tolower(h[i]);
return h;
}
pair<int, long long> c(string h) {
int n = (int)h.size(), i, j = 0;
pair<int, long long> p;
p.second = (long long)n;
for (i = 0; i < n; i++)
if (h[i] == 'r') j++;
p.first = j;
return p;
}
void dfs(int u) {
ans[u] = cur;
visited[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int k = adj[u][i];
if (!visited[k]) dfs(k);
}
}
int main() {
int n, m, i, j, sz;
long long ans1 = 0, ans2 = 0;
scanf("%d", &m);
for (i = 0; i < m; i++) {
string h;
cin >> h;
h = norm(h);
second.push_back(h);
}
scanf("%d", &n);
sz = 1;
for (i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
a = norm(a);
b = norm(b);
if (!present[a]) {
present[a] = sz;
st[sz] = a;
sz++;
}
if (!present[b]) {
present[b] = sz;
st[sz] = b;
sz++;
}
adj[present[b]].push_back(present[a]);
ans[present[a]] = c(a);
ans[present[b]] = c(b);
}
for (i = 1; i < sz; i++) v.push_back(make_pair(ans[i], i));
sort(v.begin(), v.end());
for (i = 0; i < sz - 1; i++) {
int id = v[i].second;
if (!visited[id]) {
cur = v[i].first;
dfs(id);
}
}
for (i = 0; i < second.size(); i++) {
if (present[second[i]]) {
int k = present[second[i]];
ans1 += ans[k].first;
ans2 += ans[k].second;
} else {
pair<int, long long> p = c(second[i]);
ans1 += p.first;
ans2 += p.second;
}
}
printf("%lld %lld\n", ans1, ans2);
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long max, target;
int base;
bool dfs(long long now, long long val) {
if (now == max) {
return val == target || val - now == target || val + now == target;
}
bool ok = false;
ok |= dfs(now * base, val);
ok |= dfs(now * base, val - now);
ok |= dfs(now * base, val + now);
return ok;
}
bool MAIN() {
scanf("%d%I64d", &base, &target);
for (max = 1; max < target; max *= base)
;
return base < 4 ? true : dfs(1, 0);
}
int main() {
puts(MAIN() ? "YES" : "NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(15);
}
string fun(string str) {
int i, l = str.length();
for (i = 0; i < l; i++) {
if (str[i] == '+')
str[i] = '*';
else
str[i] = '+';
}
return str;
}
string s[10][1000];
int main() {
FastIO();
int i, n, j;
cin >> n;
if (n == 0) {
cout << '+' << "\n";
return 0;
}
s[0][0] = "++";
s[0][1] = "+*";
if (n == 1) {
cout << s[0][0] << "\n";
cout << s[0][1] << "\n";
return 0;
}
for (i = 1; i < 9; i++) {
for (j = 0; j < (1 << i); j++) s[i][j] = s[i - 1][j] + s[i - 1][j];
for (j = (1 << i); j < (1 << (i + 1)); j++)
s[i][j] = s[i - 1][j - (1 << i)] + fun(s[i - 1][j - (1 << i)]);
if (i == (n - 1)) {
for (j = 0; j < (1 << n); j++) cout << s[i][j] << "\n";
return 0;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
inline T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
template <class T>
T gcd(T a, T b) {
return (b == (T)0 ? a : gcd(b, a % b));
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T mathround(T x) {
long long i64x = (long long)x;
if (x < i64x + 0.5) return (T)i64x;
return (T)i64x + 1;
}
template <class T>
bool isprime(T x) {
int till = (T)sqrt(x + .0);
if (x <= 1) return 0;
if (x == 2) return 1;
if (x % 2 == 0) return 0;
for (int i = 3; i <= till; i += 2)
if (x % i == 0) return 0;
return 1;
}
const int LRG = (int)1e9;
struct tpl {
int i, j, h;
tpl(int _i = 0, int _j = 0, int _h = 0) {
i = _i;
j = _j;
h = _h;
}
};
string a;
int lna;
string b;
int lnb;
string v;
int lnv;
int dp[105][105][105];
tpl pr[105][105][105];
int F[105];
void build_failure_function() {
F[0] = F[1] = 0;
for (int i = 2; i <= lnv; i++) {
int j = F[i - 1];
while (1) {
if (v[i - 1] == v[j]) {
F[i] = j + 1;
break;
} else if (j > 0) {
j = F[j];
} else {
F[i] = 0;
break;
}
}
}
}
int main() {
cin >> a;
lna = a.length();
cin >> b;
lnb = b.length();
cin >> v;
lnv = v.length();
build_failure_function();
for (int i = 0; i < 105; i++)
for (int j = 0; j < 105; j++)
for (int h = 0; h < 105; h++) dp[i][j][h] = -LRG;
for (int i = 0; i <= lna; i++) dp[i][0][0] = 0;
for (int i = 0; i <= lnb; i++) dp[0][i][0] = 0;
for (int i = 1; i <= lna; i++) {
for (int j = 1; j <= lnb; j++) {
for (int h = 0; h < lnv; h++) {
if (dp[i][j][h] < dp[i - 1][j][h]) {
dp[i][j][h] = dp[i - 1][j][h];
pr[i][j][h] = tpl(i - 1, j, h);
}
if (dp[i][j][h] < dp[i][j - 1][h]) {
dp[i][j][h] = dp[i][j - 1][h];
pr[i][j][h] = tpl(i, j - 1, h);
}
if (dp[i][j][h] < dp[i - 1][j - 1][h]) {
dp[i][j][h] = dp[i - 1][j - 1][h];
pr[i][j][h] = tpl(i - 1, j - 1, h);
}
if (a[i - 1] == b[j - 1]) {
int tmp = h;
while (tmp > 0 && a[i - 1] != v[tmp]) tmp = F[tmp];
if (a[i - 1] == v[tmp]) tmp++;
if (tmp < lnv && dp[i][j][tmp] < dp[i - 1][j - 1][h] + 1) {
dp[i][j][tmp] = dp[i - 1][j - 1][h] + 1;
pr[i][j][tmp] = tpl(i - 1, j - 1, h);
}
}
}
}
}
int x = lna;
int y = lnb;
int z = max_element(dp[lna][lnb], dp[lna][lnb] + 105) - dp[lna][lnb];
string res = "";
while (x > 0 && y > 0) {
int pri = pr[x][y][z].i;
int prj = pr[x][y][z].j;
int prh = pr[x][y][z].h;
if (pri == x - 1 && prj == y - 1) res += a[pri];
x = pri;
y = prj;
z = prh;
}
reverse(res.begin(), res.end());
if (res == "")
cout << 0;
else
cout << res;
return EXIT_SUCCESS;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL);
#define int long long
#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
#define endl '\n'
#define pi 3.141592653589793238
#define mp make_pair
#define pb push_back
#define precise cout << fixed << setprecision(20)
#define ff first
#define ss second
#define uniq(v) v.resize(distance(v.begin(), unique(all(v))))
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define vi vector<int>
#define vp vector<pair<int, int>>
#define vvi vector<vector<int>>
#define deb(x) cerr << #x << ' ' << '=' << ' ' << x << '\n'
const int mod = 1e9 + 7;
const int INF = 1e12;
const int MAXN = 300005;
template <typename T>
istream &operator>>(istream &in, vector<T> &v)
{
for (T &x : v)
in >> x;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &v)
{
for (T &x : v)
out << x << " ";
return out;
}
int min(int a, int b)
{
if (a < b)
return a;
else
return b;
}
int max(int a, int b)
{
if (a > b)
return a;
else
return b;
}
int power(int a, int b)
{
int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1)
{
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
int gcd(int p, int q)
{
if (p % q == 0)
return q;
else
{
return gcd(q, p % q);
}
}
bool isPrime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int mul(int a, int b) { return ((a % mod) * (b % mod)) % mod; }
int sub(int a, int b) { return (((a - b) % mod) + mod) % mod; }
struct node
{
int data;
struct node *left;
struct node *right;
};
node *new_node(int val)
{
node *x = (node *)malloc(sizeof(node));
x->data = val;
x->left = x->right = NULL;
return x;
}
int height(node *root)
{
if (root == NULL)
return 0;
else
return 1 + max(height(root->left), height(root->right));
}
int diameter(node *root, int *Height)
{
if (root == NULL)
{
return 0;
*Height = 0;
}
int l = 0, r = 0, ldia, rdia;
ldia = diameter(root->left, &l);
rdia = diameter(root->right, &r);
*Height = max(l, r) + 1;
return max(1 + l + r, max(ldia, rdia));
}
node *insert_new_node(node *root, int data)
{
if (root == NULL)
return new_node(data);
else
{
if (data <= root->data)
root->left = insert_new_node(root->left, data);
else
root->right = insert_new_node(root->right, data);
return root;
}
}
void Pre_order(node *root)
{
if (root)
{
cout << root->data << endl;
Pre_order(root->left);
Pre_order(root->right);
}
}
node *Search(node *root, int k)
{
if (root->data == k)
return root;
else if (root->data > k)
return Search(root->left, k);
else
return Search(root->right, k);
}
int n, m;
vector<pair<int, int>> adj[100001];
bool visited[100001], sptset[100001];
int dist[100001];
void addedge(int a, int b, int w)
{
adj[a].pb({b, w});
adj[b].pb({a, w});
}
signed main()
{
fastio;
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
int d[n], dp[n], ans;
for (int i = 0; i < n; i++)
cin >> d[i];
if (n == 1)
{
cout << 0 << endl;
continue;
}
sort(d, d + n);
ans = d[n - 1];
dp[0] = 0;
for (int i = 1; i < n; i++)
{
dp[i] = dp[i - 1] - i * (d[i] - d[i - 1]);
ans += dp[i];
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
const long long md = 1e9 + 7;
const int Inf = 1e9;
const long long Inf64 = 1e18;
const long long MaxN = 1e5 + 1;
const long long logN = 20;
const long long MaxM = 11;
const long double eps = 1e-15;
const long long dx[4] = {0, 1, 0, -1};
const long long dy[4] = {1, 0, -1, 0};
const long long ddx[4] = {1, 1, -1, -1};
const long long ddy[4] = {1, -1, 1, -1};
const long double Pi = acos(-1);
using namespace std;
long long gcd(long long a, long long b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
long long gcdex(long long a, long long mod = md) {
long long g = mod, r = a, x = 0, y = 1;
while (r != 0) {
long long q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + mod : x;
}
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= md;
}
a *= a;
a %= md;
n >>= 1;
}
return res % md;
}
long long Mp[MaxN];
struct el {
el() {}
el(long long a, long long b, long long c) {
l = a;
r = b;
id = c;
}
long long l, r;
long long id;
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cout << fixed, cout.precision(10);
long long N, M;
cin >> N >> M;
vector<long long> Mt(N);
for (int i = 0; i < N; i++) {
cin >> Mt[i];
}
vector<long long> Ans(M);
long long s = sqrt(N) + 1;
vector<vector<el> > Qr(s);
for (int i = 0; i < M; i++) {
long long l, r;
cin >> l >> r;
l--;
r--;
long long k = l / s;
Qr[k].push_back({l, r, i + 1});
}
for (int i = 0; i < s; i++) {
sort(Qr[i].begin(), Qr[i].end(), [=](el a, el b) { return a.r < b.r; });
}
long long l = 1;
long long r = 0;
long long Res = 0;
for (int i = 0; i < s; i++) {
for (el a : Qr[i]) {
while (l > a.l) {
l--;
if (Mt[l] <= N) {
Mp[Mt[l]]++;
if (Mp[Mt[l]] == Mt[l]) Res++;
if (Mp[Mt[l]] - 1 == Mt[l]) Res--;
}
}
while (l < a.l) {
if (Mt[l] <= N) {
Mp[Mt[l]]--;
if (Mp[Mt[l]] + 1 == Mt[l]) Res--;
if (Mp[Mt[l]] == Mt[l]) Res++;
}
l++;
}
while (r < a.r) {
r++;
if (Mt[r] <= N) {
Mp[Mt[r]]++;
if (Mp[Mt[r]] == Mt[r]) Res++;
if (Mp[Mt[r]] - 1 == Mt[r]) Res--;
}
}
while (r > a.r) {
if (Mt[r] <= N) {
Mp[Mt[r]]--;
if (Mp[Mt[r]] + 1 == Mt[r]) Res--;
if (Mp[Mt[r]] == Mt[r]) Res++;
}
r--;
}
Ans[a.id - 1] = Res;
}
}
for (long long a : Ans) cout << a << '\n';
cerr << '\n'
<< "Time execute: " << clock() / (double)CLOCKS_PER_SEC << " sec"
<< '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000000000;
vector<long long> fib;
void test() {
long long n;
cin >> n;
vector<int> a;
for (int i = fib.size() - 1; i >= 0; --i) {
if (fib[i] <= n) {
a.push_back(1);
n -= fib[i];
} else
a.push_back(0);
}
reverse(a.begin(), a.end());
vector<int> jed;
for (int i = 0; i < a.size(); ++i)
if (a[i] == 1) jed.push_back(i);
vector<vector<long long> > dp(2, vector<long long>(jed.size()));
dp[0][0] = 1;
dp[1][0] = jed[0] / 2;
for (int i = 1; i < jed.size(); ++i) {
long long zer = jed[i] - jed[i - 1] - 1;
dp[0][i] = dp[0][i - 1] + dp[1][i - 1];
dp[1][i] = (zer / 2) * dp[0][i - 1] + ((zer + 1) / 2) * dp[1][i - 1];
}
cout << dp[0].back() + dp[1].back() << endl;
}
int main() {
ios_base::sync_with_stdio(0);
fib.push_back(1);
fib.push_back(2);
while (fib[fib.size() - 1] + fib[fib.size() - 2] <= MAX)
fib.push_back(fib[fib.size() - 1] + fib[fib.size() - 2]);
int t;
cin >> t;
for (int i = 0; i < t; ++i) test();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double x[1234], y[1234];
int main(int argc, char const *argv[]) {
int n;
std::cin >> n;
double ans = 0.0;
for (int i = 0; i < n; i++) {
std::cin >> x[i] >> y[i];
ans += y[i];
}
printf("%.4f\n", ans / n + 5);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MAX = (long long)2e5;
long long inf = (long long)2e9;
long long mod = (long long)1e9;
long long n, m;
long long ok = 1;
int main() {
ios::sync_with_stdio(0);
long long n, k;
string s, t;
cin >> n >> k >> s >> t;
long long cur = 1;
long long ans = 0;
for (int i = 0; i < n; i++) {
cur *= 2;
if (s[i] == 'b') cur--;
if (t[i] == 'a') cur--;
if (cur >= k) {
ans += (n - i) * k;
break;
} else
ans += cur;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return w == 1 ? x : -x;
}
struct node {
int val, id;
} a[200005];
int ans[1005][1005];
inline bool cmp(node a, node b) { return a.val > b.val; }
int main() {
int n = read();
for (int i = 1; i <= n; i++) a[i].val = read(), a[i].id = i;
sort(a + 1, a + n + 1, cmp);
cout << n + 1 << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= a[i].val; j++)
ans[(i + j - 1) % (n + 1) + 1][a[i].id] = 1;
}
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= n; j++) printf("%d", ans[i][j]);
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TESTS = 1;
while (TESTS--) {
int i, n, j, k;
cin >> n >> k;
vector<int> v(n);
vector<vector<int> > a(200005);
for (i = 0; i < n; i++) cin >> v[i];
int ans = INT_MAX;
for (i = 0; i < n; i++) {
int t = v[i], s = 0;
while (t) {
a[t].push_back(s);
s++;
t /= 2;
}
}
for (i = 0; i < 200005; i++) {
if (a[i].size() >= k) {
sort((a[i]).begin(), (a[i]).end());
int sum = 0;
for (j = 0; j < k; j++) sum += a[i][j];
ans = min(ans, sum);
}
}
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1111111];
long long k;
long long get_ans(double t, long long M, int a) {
long long res = (long long)t;
res += 3;
while (a - 3LL * res * res + 3LL * res - 1 < M) res--;
return res;
}
int check(long long M) {
long long num = 0;
for (int i = 0; i < n; i++) {
if (a[i] - 1 < M) {
num += 0;
} else {
double t = a[i] - M - 1;
t = t / 3.0 + 0.25;
t = sqrt(t) + 0.5 + 1e-8;
long long res = min(get_ans(t, M, a[i]), (long long)a[i]);
num += res;
}
}
if (num >= k)
return 1;
else
return 0;
}
int calc(long long M) {
long long num = 0;
for (int i = 0; i < n; i++) {
if (a[i] - 1 < M) {
num += 0;
} else {
double t = a[i] - M - 1;
t = t / 3.0 + 0.25;
t = sqrt(t) + 0.5 + 1e-8;
long long res = min(get_ans(t, M, a[i]), (long long)a[i]);
num += res;
}
}
long long delta = num - k;
for (int i = 0; i < n; i++) {
if (a[i] - 1 < M) {
printf("0 ");
} else {
double t = a[i] - M - 1;
t = t / 3.0 + 0.25;
t = sqrt(t) + 0.5 + 1e-8;
long long res = min(get_ans(t, M, a[i]), (long long)a[i]);
if (delta > 0 && (a[i] - 3 * res * res + 3 * res - 1) == M) {
res--;
delta--;
}
printf("%d ", (int)res);
}
}
return 0;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) scanf("%d", a + i);
long long L =
(a[0] - 3LL * (long long)a[0] * (long long)a[0] + 3LL * a[0] - 2);
long long R = a[0] + 1;
for (int i = 1; i < n; i++) {
L = min(L,
(a[i] - 3LL * (long long)a[i] * (long long)a[i] + 3LL * a[i] - 2));
R = max(R, (long long)a[i] + 1);
}
while (L + 1 < R) {
long long M = (L + R) / 2;
if (check(M)) {
L = M;
} else {
R = M;
}
}
calc(L);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
string s1 = "", s2 = "";
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, a, b;
cin >> s >> a >> b;
bool ans1 = false, ans2 = false;
int p = (int)s.find(a), q = 0;
if (p >= 0 && p < (int)s.size()) {
s1.insert(s1.begin(), s.begin() + p + a.size(), s.end());
q = (int)s1.find(b);
if (q >= 0 && q < (int)s.size()) ans1 = true;
}
reverse(s.begin(), s.end());
p = (int)s.find(a);
q = 0;
if (p >= 0 && p < (int)s.size()) {
s2.insert(s2.begin(), s.begin() + p + a.size(), s.end());
q = (int)s2.find(b);
if (q >= 0 && q < (int)s.size()) ans2 = true;
}
if (ans1 && ans2)
cout << "both" << endl;
else {
if (!ans1 && !ans2)
cout << "fantasy" << endl;
else {
if (ans1)
cout << "forward" << endl;
else
cout << "backward" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
const long long mod = 1000000007;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int inf = 0x0FFFFFFF;
const int nil = -1;
const int root = nil + 1;
inline bool read(int& val) { return scanf("%d", &val) != -1; }
inline bool read(long long& val) { return scanf("%I64d", &val) != -1; }
inline bool read(double& val) { return scanf("%lf", &val) != -1; }
inline bool read(char* val) { return scanf("%s", val) != -1; }
template <class T1, class T2>
inline bool read(T1& a, T2& b) {
return read(a) && read(b);
}
template <class T1, class T2, class T3>
inline bool read(T1& a, T2& b, T3& c) {
return read(a) && read(b) && read(c);
}
template <class T1, class T2, class T3, class T4>
inline bool read(T1& a, T2& b, T3& c, T4& d) {
return read(a) && read(b) && read(c) && read(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline bool read(T1& a, T2& b, T3& c, T4& d, T5& e) {
return read(a) && read(b) && read(c) && read(d) && read(e);
}
template <class T>
T gcd(T a, T b) {
for (T r; b != 0; r = a % b, a = b, b = r)
;
return a;
}
template <class T>
T gcd(T a, T b, T& x, T& y) {
T xa = 1, xb = 0;
T ya = 0, yb = 1;
while (b != 0) {
x = xa - a / b * xb;
xa = xb;
xb = x;
y = ya - a / b * yb;
ya = yb;
yb = y;
T r = a % b;
a = b;
b = r;
}
x = xa;
y = ya;
return a;
}
void add(long long& a, long long b, long long mod) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
void mul(long long& a, long long b, long long mod) { a = a * b % mod; }
long long pow(long long a, long long b, long long mod) {
long long x = 1;
for (; b != 0; b >>= 1, mul(a, a, mod))
if (b & 1) mul(x, a, mod);
return x;
}
long long rev(long long a, long long mod) {
long long x, y;
gcd(a, mod, x, y);
while (x < 0) x += mod;
while (x >= mod) x -= mod;
return x;
}
long long china(long long r[], long long mod[], int n) {
long long x = 0, m = 1;
for (int i = 0, _ = (n); i < _; ++i) m *= mod[i];
for (int i = 0, _ = (n); i < _; ++i) {
long long mi = m / mod[i];
x += r[i] * rev(mi, mod[i]) * mi;
}
return x % m;
}
int cmp(double a, double b) {
if (fabs(a - b) < eps) return 0;
return a < b ? -1 : 1;
}
template <class T, class U>
int lower_bound(T f, int l, int r, U val) {
while (l < r) {
int m = (l + r) / 2;
if (f(m) < val)
l = m + 1;
else
r = m;
}
return l;
}
template <class T, int n, int m>
void calC(T (&C)[n][m]) {
for (int i = 0, _ = (n); i < _; ++i)
for (int j = 0, _ = (m); j < _; ++j) C[i][j] = 0;
for (int i = 0, _ = (n); i < _; ++i) C[i][0] = 1;
for (int i = (1), _ = (n); i < _; ++i)
for (int j = (1), _ = (min(i + 1, m)); j < _; ++j)
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
struct atype {
bool set0;
bool set1;
bool rev;
atype() : set0(false), set1(false), rev(false) {}
void operator+=(atype a) {
if (a.set0) rev = false, set1 = false, set0 = true;
if (a.set1) rev = false, set0 = false, set1 = true;
if (a.rev) rev = !rev;
}
};
struct stype {
int len, sum;
stype(int len = 0, int sum = 0) : len(len), sum(sum) {}
void operator+=(atype a) {
if (a.set0) sum = 0;
if (a.set1) sum = len;
if (a.rev) sum = len - sum;
}
friend stype operator+(stype a, stype b) {
return stype(a.len + b.len, a.sum + b.sum);
}
};
const int N = 111111;
struct segment_tree {
struct node {
int l, r, Ls, Rs;
atype a;
stype s;
node(int l = 0, int r = 0)
: l(l), r(r), Ls(nil), Rs(nil), a(), s(r - l + 1) {}
void add(atype val) {
a += val;
s += val;
}
} X[4 * N * 20];
int id, newid;
void atom() { newid = id; }
int copy(int i) {
if (i >= newid) return i;
int j = id++;
X[j] = X[i];
return j;
}
void trie(node& x) {
int m = (x.l + x.r) >> 1;
if (x.Ls == nil) X[x.Ls = id++] = node(x.l, m);
if (x.Rs == nil) X[x.Rs = id++] = node(m + 1, x.r);
}
void down(node& x) {
X[x.Ls = copy(x.Ls)].add(x.a);
X[x.Rs = copy(x.Rs)].add(x.a);
x.a = atype();
}
int l, r;
void add(node& x, atype a) {
if (l <= x.l && x.r <= r) {
x.add(a);
} else {
trie(x);
down(x);
if (l <= X[x.Ls].r) add(X[x.Ls], a);
if (r >= X[x.Rs].l) add(X[x.Rs], a);
x.s = X[x.Ls].s + X[x.Rs].s;
}
}
void sum(const node& x, stype& s) {
if (l <= x.l && x.r <= r)
s = x.s;
else {
if (x.Ls == nil) {
s = stype(min(r, x.r) - max(l, x.l));
} else if (l <= X[x.Ls].r && r >= X[x.Rs].l) {
stype a, b;
sum(X[x.Ls], a);
sum(X[x.Rs], b);
s = a + b;
} else {
sum(X[l <= X[x.Ls].r ? x.Ls : x.Rs], s);
}
s += x.a;
}
}
int init_one(int i, int l, int r) {
id = i;
X[i = id++] = node(l, r);
newid = id;
return i;
}
int init_all(int i, int l, int r) {
init_one(i, l, r);
if (l < r) {
int m = (l + r) >> 1;
init_all(id, l, m);
init_all(id, m + 1, r);
}
return i;
}
int add(int i, int l, int r, atype a) {
atom();
this->l = l;
this->r = r;
add(X[i = copy(i)], a);
return i;
}
int sum(int i, int l, int r, stype& s) {
atom();
this->l = l;
this->r = r;
sum(X[i], s);
return i;
}
} st;
atype adds[4];
int roots[N];
int main() {
int n, m, q;
read(n, m, q);
roots[0] = st.init_one(0, 0, n * m);
adds[1].set1 = true;
adds[2].set0 = true;
adds[3].rev = true;
for (int i = 0, _ = (q); i < _; ++i) {
int t;
read(t);
if (t == 1 || t == 2) {
int a, b;
read(a, b);
a--;
b--;
roots[i + 1] = st.add(roots[i], a * m + b, a * m + b, adds[t]);
} else if (t == 3) {
int a;
read(a);
a--;
roots[i + 1] = st.add(roots[i], a * m, a * m + m - 1, adds[t]);
} else {
int a;
read(a);
roots[i + 1] = roots[a];
}
stype ans = 0;
st.sum(roots[i + 1], 0, n * m, ans);
printf("%d\n", ans.sum);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long Getint() {
char ch = getchar();
long long x = 0, fh = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
(x *= 10) += ch ^ 48;
ch = getchar();
}
return x * fh;
}
const int N = 200005;
int n;
long long A[N], zh[N];
long long f[N];
inline void Ins(int x) {
for (; x <= zh[0]; x += (x & (-x))) f[x]++;
}
inline long long Ask(int x) {
long long su = 0;
for (; x > 0; x -= (x & (-x))) su += f[x];
return su;
}
int main() {
n = Getint();
for (int i = 1; i <= n; i++) {
A[i] = Getint();
if (A[i] > 0)
A[i] = 1;
else
A[i] = -1;
}
A[0] = 1;
for (int i = 1; i <= n; i++) A[i] *= A[i - 1];
int s0 = 0, s1 = 0;
s1++;
long long Ans = 0;
for (int i = 1; i <= n; i++) {
if (A[i] == 1) Ans += s0, s1++;
if (A[i] == -1) Ans += s1, s0++;
}
cout << Ans << ' ';
Ans = 0;
s0 = 0;
s1 = 0;
s1++;
for (int i = 1; i <= n; i++) {
if (A[i] == 1) Ans += s1, s1++;
if (A[i] == -1) Ans += s0, s0++;
}
cout << Ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, q;
cin >> n >> k >> q;
int a[k][n], p = k;
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
pair<int, int> mp[n][k];
bitset<1 << 12> c[k + q];
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) mp[i][j] = make_pair(a[j][i], j);
sort(mp[i], mp[i] + k);
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < (1 << 12); j++)
if (j & (1 << i)) c[i][j] = true;
}
for (int i = 0; i < q; i++) {
int t, x, y;
cin >> t >> x >> y;
x--;
y--;
if (t == 1)
c[p++] = c[x] & c[y];
else if (t == 2)
c[p++] = c[x] | c[y];
else {
int idx = 0;
for (int j = 0; j < k; j++) {
idx |= (1 << mp[y][j].second);
if (c[x][idx]) {
cout << mp[y][j].first << endl;
break;
}
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, c, x, i = 1, j = 1;
cin >> n >> m >> k;
x = k;
while (k) {
if (k > 1) {
c = (m * n) / x;
cout << c << " ";
} else {
c = (m * n) / x + (m * n) % x;
cout << c << " ";
}
while (c--) {
if (j == m + 1) {
i++;
j--;
}
if (j == 0) {
i++;
j++;
}
cout << i << " " << j << " ";
if (i & 1)
j++;
else
j--;
}
cout << endl;
k--;
}
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.