solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int arr[1000000];
int vis[1000000];
int n;
void solve() {
fill_n(vis, n, -1);
int c = 0;
vis[0] = c++;
int k = -arr[0];
while (vis[k] == -1) {
vis[k] = c++;
k -= arr[k];
}
cout << c - vis[k] << '\n' << k + 1;
int x = k - arr[k];
while (x != k) {
cout << ' ' << x + 1;
x -= arr[x];
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
setvbuf(stdin, nullptr, _IOFBF, 1000000 * 8);
setvbuf(stdout, nullptr, _IOFBF, 1000000 * 8);
int tc;
cin >> tc;
for (int ct = 0; ct != tc; ++ct) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2222;
vector<int> graph[N];
vector<vector<int> > sccs;
stack<int> st;
bool inst[N];
int mini[N], ti;
int n;
int tarjan(int u) {
int cur = ++ti;
st.push(u);
inst[u] = true;
mini[u] = cur;
for (auto v : graph[u]) {
if (!mini[v]) {
mini[u] = min(mini[u], tarjan(v));
} else if (inst[v]) {
mini[u] = min(mini[u], mini[v]);
}
}
if (mini[u] == cur) {
vector<int> scc;
while (1) {
int x = st.top();
st.pop();
inst[x] = false;
scc.push_back(x);
if (x == u) {
break;
}
}
sccs.push_back(scc);
}
return mini[u];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (n); j++) {
int x;
scanf("%d", &x);
if (x && i != j) {
graph[i].push_back(j);
}
}
}
for (int i = (1); i <= (n); i++) {
if (!mini[i]) {
tarjan(i);
}
}
if ((int)(sccs).size() == 1) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int step;
if (n == 1 && arr[0] % 2 != 0)
step = -1;
else
step = 0;
for (int i = 0; i < n; i++) {
int v = i % 2;
if (v % 2 == 0) {
v++;
} else {
v--;
}
if (i % 2 != arr[i] % 2) {
for (int j = v; j < n; j += 2) {
int temp = j;
if (arr[j] % 2 == i % 2) {
swap(arr[j], arr[i]);
step++;
break;
} else if (arr[j] % 2 != i % 2 && (temp += 2) >= n) {
step = -1;
break;
}
}
}
if (step == -1) {
break;
}
}
cout << step << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long x[10];
int pcnt[10];
int p[10];
int prime_count(long long x) {
int ans = 0;
for (long long d = 2; d * d <= x; d++)
while (x % d == 0) {
x /= d;
++ans;
}
if (x > 1) ++ans;
return ans;
}
int calc(void) {
int i, j, ans = N;
int root = 0;
for ((i) = 0; (i) < (int)(N); (i)++)
if (p[i] == -1) root++;
if (root > 1) ans++;
for ((i) = 0; (i) < (int)(N); (i)++) {
long long prod = x[i];
for (j = i + 1; j < N; ++j)
if (p[j] == i) {
if (prod % x[j] != 0) return (1 << 29);
prod /= x[j];
}
if (pcnt[i] == 1) continue;
int tmp = pcnt[i];
for (j = i + 1; j < N; ++j)
if (p[j] == i) tmp -= pcnt[j];
ans += tmp;
}
return ans;
}
int dfs(int pos) {
if (pos == N) return calc();
int ans = (1 << 29);
int i;
for (i = -1; i < pos; i++) {
p[pos] = i;
ans = min(ans, dfs(pos + 1));
}
return ans;
}
int main(void) {
int i;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) cin >> x[i];
sort(x, x + N);
reverse(x, x + N);
for ((i) = 0; (i) < (int)(N); (i)++) pcnt[i] = prime_count(x[i]);
int ans = dfs(0);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int> > cuenta(m, vector<int>(n));
for (int i = 0; i < n; i++) {
string numstr;
cin >> numstr;
for (int j = m - 1; j >= 0; j--) {
int num = static_cast<int>(numstr[j] - '0');
if (j == m - 1) {
cuenta[j][i] = num;
} else {
cuenta[j][i] = (cuenta[j + 1][i] + 1) * num;
}
}
}
vector<int> B(n);
vector<int> C(m + 1);
for (int j = 0; j < m; j++) {
for (int i = 0; i <= m; i++) {
C[i] = 0;
}
for (int i = 0; i < n; i++) {
C[cuenta[j][i]]++;
}
for (int i = 1; i <= m; i++) {
C[i] += C[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
B[C[cuenta[j][i]] - 1] = cuenta[j][i];
C[cuenta[j][i]]--;
}
for (int i = 0; i < n; i++) {
cuenta[j][i] = B[i];
}
}
int area = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
area = max(area, cuenta[j][i] * (n - i));
}
}
cout << area << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int inf = (int)1e9;
const long long mod = (int)1e9 + 7;
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> t(n + 1);
for (long long i = 1; i <= n; ++i) cin >> t[i];
vector<long long> ans(n + 1);
long long last = 0;
for (long long i = 1; i <= n; ++i) {
long long val = last + 20;
if (i) {
long long tl = 0, tr = i;
while (tr - tl > 1) {
long long tm = (tl + tr) / 2;
if (t[tm] + 90 - 1 >= t[i]) {
if (tm - 1 >= 0)
val = min(ans[tm - 1] + 50, val);
else
val = min((long long)50, val);
tr = tm;
} else {
tl = tm;
}
}
tl = 0, tr = i;
while (tr - tl > 1) {
long long tm = (tl + tr) / 2;
if (t[tm] + 1440 - 1 >= t[i]) {
if (tm - 1 >= 0)
val = min(ans[tm - 1] + 120, val);
else
val = min((long long)120, val);
tr = tm;
} else {
tl = tm;
}
}
}
ans[i] = val;
cout << ans[i] - ans[i - 1] << endl;
last = val;
}
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int unia, unib;
int main() {
ios::sync_with_stdio(false);
cin >> a >> b;
for (int i = 0; i < (int)a.size(); i++)
if (a[i] == '1') unia++;
for (int i = 0; i < (int)b.size(); i++)
if (b[i] == '1') unib++;
if ((unia % 2 == 1 && unib > unia + 1) || (unia % 2 == 0 && unib > unia))
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int main() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
vector<int> b(n), ans(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
b[i] = a[i].first;
}
sort(a.begin(), a.end());
int cur = a[0].first;
ans[a[0].second] = cur;
for (int i = 1; i < n; i++) {
if (cur < a[i].first) {
cur = a[i].first;
ans[a[i].second] = cur;
} else if (cur == a[i].first) {
cur++;
ans[a[i].second] = cur;
} else {
cur++;
ans[a[i].second] = cur;
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m = 92;
long long int sum[92];
long long int fibb(long long int n) { return sum[n - 1] + sum[n - 2]; }
int main() {
long long int n;
cin >> n;
int k = m;
sum[0] = 1;
sum[1] = 1;
if (n == 2) {
cout << 1;
return 0;
}
if (n == 3) {
cout << 2;
return 0;
}
for (int i = 2; i < m; i++) {
sum[i] = fibb(i);
}
int count = 0;
while (true) {
if (sum[count] > n) {
cout << count - 2;
break;
};
count++;
}
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:336777216")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int MSK, N, owo[1 << 10];
int getoffon(int x) {
int sum = 0;
for (int i = 0; i < N; i++) {
if (x & (1 << i)) {
if (MSK & (1 << i))
sum++;
else
sum--;
}
}
return sum;
}
bool cmp(int a, int b) {
if (owo[a] == owo[b]) return a < b;
return owo[a] > owo[b];
}
vector<int> pos[1024];
int cnt[1024];
void solve() {
int n, m;
cin >> n >> m;
N = n;
vector<int> x(n);
for (int i = 0; i < n; i++) {
cin >> x[i];
}
memset(owo, 0, sizeof(owo));
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < m; i++) {
int msk = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == '1') msk |= (1 << j);
}
pos[msk].push_back(i);
cnt[msk]++;
}
vector<int> msks;
for (int i = 0; i < (1 << n); i++) {
msks.push_back(i);
}
long long ans = -1;
int best = 0;
for (int msk = 0; msk < (1 << n); msk++) {
long long tmp = 0;
for (int j = 0; j < n; j++) {
if (msk & (1 << j))
tmp -= x[j];
else
tmp += x[j];
}
MSK = msk;
vector<int> ccnt(21);
for (int i = 0; i < (1 << n); i++) {
if (cnt[i] == 0) continue;
ccnt[getoffon(i) + 10] += cnt[i];
}
int petr = 1;
for (int i = 0; i <= 20; i++) {
int mul = i - 10;
int cc = ccnt[i];
if (cc == 0) continue;
int l = petr - 1, r = petr + cc - 1;
long long tp = 1LL * r * (r + 1) / 2;
tp -= 1LL * l * (l + 1) / 2;
tmp += 1LL * tp * mul;
petr = r + 1;
}
if (tmp > ans) {
ans = tmp;
best = msk;
}
}
vector<int> p(m);
for (int msk = best; msk <= best; msk++) {
MSK = msk;
for (int i = 0; i < (1 << n); i++) {
owo[i] = getoffon(i);
}
sort(msks.begin(), msks.end(), cmp);
int petr = m;
for (int i = 0; i < (1 << n); i++) {
for (int j : pos[msks[i]]) {
p[j] = petr;
petr--;
}
}
}
for (int i : p) cout << i << ' ';
cout << '\n';
for (int i = 0; i < m; i++) {
int msk = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == '1') msk |= (1 << j);
}
pos[msk].clear();
cnt[msk] = 0;
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, flag = 0, tim;
struct dy {
int x, y;
} ans[100 * 100];
int a[100][100], vis[100][100];
int check(int x, int y) {
if (a[x + 1][y] && a[x][y + 1] && a[x + 1][y + 1]) return 1;
return 0;
}
void change(int x, int y) {
vis[x][y] = true;
vis[x + 1][y] = true;
vis[x][y + 1] = true;
vis[x + 1][y + 1] = true;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j]) flag = 1;
}
}
if (!flag) {
puts("0");
return 0;
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j]) {
if (check(i, j)) {
ans[++tim].x = i;
ans[tim].y = j;
change(i, j);
} else if (!vis[i][j]) {
puts("-1");
return 0;
}
}
}
}
}
cout << tim << endl;
for (int i = 1; i <= tim; i++) {
cout << ans[i].x << " " << ans[i].y << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
int row, col, K;
char input[305][305];
inline bool isValid(int x, int y) {
return (0 <= x and x < row and 0 <= y and y < col and input[x][y] == '*');
}
inline bool isConstellation(int cx, int cy, int rad) {
return isValid(cx, cy) and isValid(cx - rad, cy) and isValid(cx + rad, cy) and
isValid(cx, cy + rad) and isValid(cx, cy - rad);
}
int main() {
scanf("%d %d %d", &row, &col, &K);
for (int i = 0; i < row; i++) {
scanf("%s", input[i]);
}
int done = 0;
for (int rad = 1; rad <= min(row, col); rad++) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (isConstellation(i, j, rad)) {
done++;
if (done == K) {
i++;
j++;
cout << i << " " << j << endl;
cout << i - rad << " " << j << endl;
cout << i + rad << " " << j << endl;
cout << i << " " << j - rad << endl;
cout << i << " " << j + rad << endl;
return 0;
}
}
}
}
}
cout << "-1\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, cch[40][1 << 20], sc[26] = {1, -1};
char gr[22][22], s[40][1 << 20];
int dp(int di, int msk) {
if (di == 2 * n - 2) return 0;
if (s[di][msk]) return cch[di][msk];
s[di][msk] = 1;
int adv[26];
for (int i = 0; i < 26; i++) adv[i] = 0;
for (int i = 0; i < 20; i++)
if (msk & (1 << i)) {
int y = min(di, n - 1) - i, x = max(0, di - n + 1) + i;
if (y < n - 1) adv[gr[y + 1][x] - 'a'] |= (1 << (i - (di >= n - 1)));
if (x < n - 1) adv[gr[y][x + 1] - 'a'] |= (1 << (i + (di < n - 1)));
}
int ans = di % 2 ? -999 : 999;
for (int i = 0; i < 26; i++)
if (adv[i]) {
int mv = dp(di + 1, adv[i]) + sc[i];
if (di % 2)
ans = max(ans, mv);
else
ans = min(ans, mv);
}
return cch[di][msk] = ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", gr[i]);
int res = dp(0, 1) + sc[gr[0][0] - 'a'];
printf(res > 0 ? "FIRST\n" : res < 0 ? "SECOND\n" : "DRAW\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
const int SIZE = 100005;
int A[SIZE];
int res[SIZE];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
res[i] = A[i];
}
int now = 0;
for (int i = 1; i <= N; i++) {
int temp = now + 1;
now = res[i] = min(res[i], temp);
}
now = 0;
for (int i = N; i >= 1; i--) {
int temp = now + 1;
now = res[i] = min(res[i], temp);
}
now = 0;
for (int i = 1; i <= N; i++) {
int temp = now + 1;
now = res[i] = min(res[i], temp);
}
now = 0;
for (int i = N; i >= 1; i--) {
int temp = now + 1;
now = res[i] = min(res[i], temp);
}
int ans = 0;
for (int i = 1; i <= N; i++)
if (ans < res[i]) ans = res[i];
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-6;
const int maxn = 1e5 + 5;
const int maxm = 1e6 + 5;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
inline int scan(int &a) { return scanf("%d", &a); }
inline int scan(int &a, int &b) { return scanf("%d%d", &a, &b); }
inline int scan(int &a, int &b, int &c) { return scanf("%d%d%d", &a, &b, &c); }
inline int scan(long long &a) { return scanf("%I64d", &a); }
inline int scan(long long &a, long long &b) {
return scanf("%I64d%I64d", &a, &b);
}
inline int scan(long long &a, long long &b, long long &c) {
return scanf("%I64d%I64d%I64d", &a, &b, &c);
}
inline int scan(double &a) { return scanf("%lf", &a); }
inline int scan(double &a, double &b) { return scanf("%lf%lf", &a, &b); }
inline int scan(double &a, double &b, double &c) {
return scanf("%lf%lf%lf", &a, &b, &c);
}
inline int scan(char &a) { return scanf("%c", &a); }
inline int scan(char *a) { return scanf("%s", a); }
template <class T>
inline void mem(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T0, class T1>
inline void mem(T0 &A0, T1 &A1, int x) {
mem(A0, x), mem(A1, x);
}
template <class T0, class T1, class T2>
inline void mem(T0 &A0, T1 &A1, T2 &A2, int x) {
mem(A0, x), mem(A1, x), mem(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void mem(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
mem(A0, x), mem(A1, x), mem(A2, x), mem(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void mem(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
mem(A0, x), mem(A1, x), mem(A2, x), mem(A3, x), mem(A4, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void mem(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x) {
mem(A0, x), mem(A1, x), mem(A2, x), mem(A3, x), mem(A4, x), mem(A5, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void mem(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x) {
mem(A0, x), mem(A1, x), mem(A2, x), mem(A3, x), mem(A4, x), mem(A5, x),
mem(A6, x);
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T min(T a, T b, T c, T d, T e) {
return min(min(min(a, b), min(c, d)), e);
}
template <class T>
inline T max(T a, T b, T c, T d, T e) {
return max(max(max(a, b), max(c, d)), e);
}
int f[maxn], g[maxn], h[maxn], pos[maxn];
int main() {
int m;
while (~scan(m)) {
mem(g, pos, -1);
int n = 0;
for (int i = 1; i < m + 1; i++) {
scan(f[i]);
if (f[i] == i) h[++n] = i, g[i] = n, pos[i] = i;
}
if (!n)
puts("-1");
else {
int flag = 0;
for (int i = 1; i < m + 1; i++) {
if (g[i] == -1) {
if (pos[f[i]] == -1)
flag = 1;
else
g[i] = g[pos[f[i]]];
}
}
if (flag)
puts("-1");
else {
printf("%d\n", n);
for (int i = 1; i < m + 1; i++)
printf("%d%c", g[i], i == m ? '\n' : ' ');
for (int i = 1; i < n + 1; i++)
printf("%d%c", h[i], i == n ? '\n' : ' ');
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1010000], n, size, excnt, ex[1010000], x[1010000], y[1010000],
op[1010000], i, id, pos[1010000], bl, a[1010000];
char ch[1010000];
long long b[1010000][6];
void init() {
sort(ex + 1, ex + 1 + excnt);
size = unique(ex + 1, ex + 1 + excnt) - ex - 1;
for (i = 1; i <= n; i++) y[i] = lower_bound(ex + 1, ex + 1 + size, x[i]) - ex;
}
void update(int id) {
int l = (id - 1) * bl + 1, r = id * bl, t = 0;
memset(b[id], 0, sizeof(b[id]));
cnt[id] = 0;
for (int i = l; i <= r; i++)
if (a[i] > 0) {
t++;
if (t >= 5) t -= 5;
b[id][t] += a[i];
cnt[id]++;
}
}
long long calc() {
long long ret = 0, t = 0;
for (int i = 1; i <= size / bl + 1; i++) {
ret += b[i][(8 - t) % 5];
(t += cnt[i]) %= 5;
}
return ret;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%s", ch);
if (ch[0] == 's') {
op[i] = 2;
if (n == 1) {
cout << 0 << endl;
return 0;
}
} else {
scanf("%d", &x[i]);
ex[++excnt] = x[i];
op[i] = ch[0] == 'a' ? 0 : 1;
}
}
init();
bl = sqrt(size);
for (i = 1; i <= size; i++) pos[i] = (i - 1) / bl + 1;
for (i = 1; i <= n; i++) {
if (op[i] == 2)
printf("%I64d\n", calc());
else {
if (op[i] == 0)
a[y[i]] = x[i];
else
a[y[i]] = 0;
update(pos[y[i]]);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, N;
int a[16];
void gao() {
vector<int> p;
for (int i = 0; i < N; ++i) {
p.push_back(i);
}
do {
int s, sum = 0;
for (int i = 0; i < n; ++i) {
sum += a[p[i]];
}
bool succ = true;
for (int i = 0; i < n; ++i) {
s = 0;
for (int j = 0; j < n; ++j) {
s += a[p[i * n + j]];
}
if (s != sum) {
succ = false;
break;
}
s = 0;
for (int j = 0; j < n; ++j) {
s += a[p[j * n + i]];
}
if (s != sum) {
succ = false;
break;
}
}
if (succ) {
s = 0;
for (int i = 0; i < n; ++i) {
s += a[p[i * n + i]];
}
if (s != sum) {
succ = false;
}
}
if (succ) {
s = 0;
for (int i = 0; i < n; ++i) {
s += a[p[i * n + n - 1 - i]];
}
if (s != sum) {
succ = false;
}
}
if (succ) {
printf("%d\n", sum);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
printf("%d%c", a[p[i * n + j]], j + 1 == n ? '\n' : ' ');
}
}
break;
}
} while (next_permutation(p.begin(), p.end()));
}
int S;
map<int, int> avail;
map<int, int>::iterator it;
bool gao2() {
for (int i1 = 0; i1 < 16; ++i1) {
int j1 = a[i1];
it = avail.find(j1);
if (it == avail.end() || it->second == 0) continue;
--avail[j1];
for (int i2 = 0; i2 < 16; ++i2) {
int j2 = a[i2];
it = avail.find(j2);
if (it == avail.end() || it->second == 0) continue;
--avail[j2];
for (int i3 = 0; i3 < 16; ++i3) {
int j3 = a[i3];
it = avail.find(j3);
if (it == avail.end() || it->second == 0) continue;
--avail[j3];
int j14 = S - j1 - j2 - j3;
it = avail.find(j14);
if (it == avail.end() || it->second == 0) {
++avail[j3];
continue;
}
--avail[j14];
for (int i4 = 0; i4 < 16; ++i4) {
int j4 = a[i4];
it = avail.find(j4);
if (it == avail.end() || it->second == 0) continue;
--avail[j4];
for (int i5 = 0; i5 < 16; ++i5) {
int j5 = a[i5];
it = avail.find(j5);
if (it == avail.end() || it->second == 0) continue;
--avail[j5];
for (int i6 = 0; i6 < 16; ++i6) {
int j6 = a[i6];
it = avail.find(j6);
if (it == avail.end() || it->second == 0) continue;
--avail[j6];
int j24 = S - j4 - j5 - j6;
it = avail.find(j24);
if (it == avail.end() || it->second == 0) {
++avail[j6];
continue;
}
--avail[j24];
for (int i7 = 0; i7 < 16; ++i7) {
int j7 = a[i7];
it = avail.find(j7);
if (it == avail.end() || it->second == 0) continue;
--avail[j7];
int j41 = S - j14 - j6 - j7;
it = avail.find(j41);
if (it == avail.end() || it->second == 0) {
++avail[j7];
continue;
}
--avail[j41];
int j31 = S - j1 - j4 - j41;
it = avail.find(j31);
if (it == avail.end() || it->second == 0) {
++avail[j41];
++avail[j7];
continue;
}
--avail[j31];
int j42 = S - j2 - j5 - j7;
it = avail.find(j42);
if (it == avail.end() || it->second == 0) {
++avail[j31];
++avail[j41];
++avail[j7];
continue;
}
--avail[j42];
for (int i8 = 0; i8 < 16; ++i8) {
int j8 = a[i8];
it = avail.find(j8);
if (it == avail.end() || it->second == 0) continue;
--avail[j8];
int j43 = S - j3 - j6 - j8;
it = avail.find(j43);
if (it == avail.end() || it->second == 0) {
++avail[j8];
continue;
}
--avail[j43];
int j34 = S - j31 - j7 - j8;
it = avail.find(j34);
if (it == avail.end() || it->second == 0) {
++avail[j43];
++avail[j8];
continue;
}
--avail[j34];
int j44 = S - j14 - j24 - j34;
it = avail.find(j44);
if (it == avail.end() || it->second == 0) {
++avail[j34];
++avail[j43];
++avail[j8];
continue;
}
--avail[j44];
if (j1 + j5 + j8 + j44 == S && j41 + j42 + j43 + j44 == S) {
printf("%d\n", S);
printf("%d %d %d %d\n", j1, j2, j3, j14);
printf("%d %d %d %d\n", j4, j5, j6, j24);
printf("%d %d %d %d\n", j31, j7, j8, j34);
printf("%d %d %d %d\n", j41, j42, j43, j44);
return true;
}
++avail[j44];
++avail[j34];
++avail[j43];
++avail[j8];
}
++avail[j42];
++avail[j31];
++avail[j41];
++avail[j7];
}
++avail[j24];
++avail[j6];
}
++avail[j5];
}
++avail[j4];
}
++avail[j14];
++avail[j3];
}
++avail[j2];
}
++avail[j1];
}
return false;
}
void gao1() {
S /= 4;
avail.clear();
for (int j = 0; j < N; ++j) {
++avail[a[j]];
}
if (gao2()) {
return;
}
}
int main() {
scanf("%d", &n);
N = n * n;
S = 0;
for (int i = 0; i < N; ++i) {
scanf("%d", &a[i]);
S += a[i];
}
if (n <= 3) {
gao();
} else {
gao1();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
char c[2100][2100], d[2100][2100];
int gx[5000000], gy[5000000];
int i, j, k, l, m, n, x, y, tx, ty, head, tail;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%s", c[i] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (c[i][j] == '.')
for (k = 0; k < 4; k++) {
x = i + dx[k], y = j + dy[k];
if ((x > 0) && (x <= n) && (y > 0) && (y <= m) && (c[x][y] == '.'))
d[x][y]++;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (d[i][j] == 1) tail++, gx[tail] = i, gy[tail] = j;
for (head = 1; head <= tail; head++) {
if (c[gx[head]][gy[head]] != '.') continue;
for (k = 0; k < 4; k++) {
x = gx[head] + dx[k], y = gy[head] + dy[k];
if ((x > 0) && (x <= n) && (y > 0) && (y <= m) && (c[x][y] == '.')) {
d[gx[head]][gy[head]]--, d[x][y]--;
switch (k) {
case 0:
c[x][y] = '^', c[x + 1][y] = 'v';
break;
case 1:
c[x][y] = 'v', c[x - 1][y] = '^';
break;
case 2:
c[x][y] = '<', c[x][y + 1] = '>';
break;
case 3:
c[x][y] = '>', c[x][y - 1] = '<';
break;
}
for (k = 0; k < 4; k++) {
tx = x + dx[k], ty = y + dy[k];
if ((tx > 0) && (tx <= n) && (ty > 0) && (ty <= m) &&
(c[tx][ty] == '.')) {
d[x][y]--, d[tx][ty]--;
if (d[tx][ty] == 1) tail++, gx[tail] = tx, gy[tail] = ty;
}
}
break;
}
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (c[i][j] == '.') {
puts("Not unique");
return 0;
}
for (i = 1; i <= n; i++) printf("%s\n", c[i] + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int r, g, b, ans = 30, k;
int main() {
cin >> r >> g >> b;
while (r > 0 || g > 0 || b > 0) {
r -= 2;
if (r <= 0 && g <= 0 && b <= 0) k = 2;
g -= 2;
if (r <= 0 && g <= 0 && b <= 0)
if (k != 2) k = 1;
b -= 2;
ans += 3;
}
cout << ans - (k + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#pragma GCC optimize("-O2")
const int LIM = 5e5 + 5, MOD = 998244353;
int t, n, m, k, x, y;
vector<int> adj[LIM];
int mex[LIM];
int gogo(int node, int val) {
if (mex[node] + 1 != val) {
return 0;
}
for (auto v : adj[node]) {
if (mex[v] == val - 1) {
mex[v]++;
}
}
return 1;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
vector<int> order[n + 1];
vector<int> blog(n + 1);
for (int i = 1; i < n + 1; i++) {
cin >> x;
blog[i] = x;
order[x].push_back(i);
}
vector<int> ans;
for (int i = 1; i < n + 1; i++) {
for (auto j : order[i]) {
if (!gogo(j, i)) {
cout << -1 << "\n";
return;
}
ans.push_back(j);
}
}
copy(begin(ans), end(ans), ostream_iterator<int>(cout, " "));
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int o, O, f, z, i, d;
string t, s[6] = {"lios", "liala", "etr", "etra", "initis", "inites"};
int V['zz'];
int main() {
while (cin >> t) {
for (i = O = 0; i < 6; i++)
if ((d = t.size() - s[i].size()) < 0 ? 0 : t.substr(d) == s[i]) {
if (z && V[z - 1] > i) break;
O = 1;
V[z++] = i;
f += i / 2 == 1;
o += i % 2;
}
if (!O) {
cout << "NO\n";
return 0;
}
}
cout << (z != 1 && (o % z || f != 1) ? "NO\n" : "YES\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 0, i, j = 0, s = 0, t = 0, a[200001], b[200001];
double aver;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
s = s + a[i];
}
aver = s * 1.0 / n;
for (i = 0; i < n; i++) {
if (a[i] == aver) {
j = 1;
t++;
b[m++] = i + 1;
}
}
if (j) {
printf("%d\n", t);
for (i = 0; i < t; i++) printf("%d ", b[i]);
printf("\n");
} else
printf("0\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
long long quick_Mod(long long n) {
long long ans = 1;
long long x = 2;
while (n) {
if (n & 1) ans = ans * x % 1000000007;
n = n >> 1;
x = x * x % 1000000007;
}
return ans;
}
void ex_gcd(long long a, long long b, long long &gcd, long long &x,
long long &y) {
if (b == 0) {
gcd = a;
y = 0;
x = 1;
return;
} else {
ex_gcd(b, a % b, gcd, y, x);
y -= x * (a / b);
}
}
long long inverse(long long a) {
long long gcd, x, y;
ex_gcd(a, 1000000007, gcd, x, y);
if (gcd == 1)
return (x % 1000000007 + 1000000007) % 1000000007;
else
return -1;
}
int main() {
char s[MAX];
long long k;
scanf("%s", s);
scanf("%I64d", &k);
long long len = strlen(s);
long long ans = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '0' || s[i] == '5') {
ans += quick_Mod(i) * inverse(quick_Mod(len) - 1) % 1000000007 *
(quick_Mod(k * len) - 1) % 1000000007;
}
}
printf("%I64d\n", (ans % 1000000007 + 1000000007) % 1000000007);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int inline read() {
int num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const int maxn = 100010;
int n, head[maxn], cnt, dep[maxn];
double ans;
struct Edge {
int nxt, to;
} edge[maxn << 1];
void add_edge(int x, int y) {
edge[++cnt].nxt = head[x];
edge[cnt].to = y;
head[x] = cnt;
}
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
for (int i = head[x]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == fa) continue;
dfs(v, x);
}
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
add_edge(u, v);
add_edge(v, u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) ans += 1 / (double)dep[i];
printf("%.8lf", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
static const long long int mod = 998244353LL;
struct uset {
int rank;
std::pair<int, int> p;
} v[2003];
int n;
std::pair<int, int> getrep(int i) {
if (v[i].p.first == i) return v[i].p;
std::pair<int, int> p = getrep(v[i].p.first);
v[i].p = std::make_pair(p.first, p.second ^ v[i].p.second);
return v[i].p;
}
bool merge(int a, int b, int x) {
std::pair<int, int> p1 = getrep(a), p2 = getrep(b);
if (p1.first == p2.first) {
return (p1.second ^ p2.second) == x;
}
a = p1.first, b = p2.first;
if (v[a].rank < v[b].rank) std::swap(a, b);
v[b].p = std::make_pair(a, x ^ p1.second ^ p2.second);
if (v[a].rank == v[b].rank) ++v[a].rank;
return true;
}
char s[1003];
int main() {
scanf("%s", s);
n = strlen(s);
long long int sum = 0;
for (int i = 1; i <= n - 1; ++i) {
for (int j = 0; j < i + n + 1; ++j) {
v[j].rank = 0;
v[j].p = std::make_pair(j, 0);
}
bool conf = false;
for (int j = 0; j < n; ++j)
if (!merge(j, n - 1 - j, 0)) {
conf = true;
break;
}
for (int j = 0; j < i; ++j)
if (!merge(n + j, n + i - 1 - j, 0)) {
conf = true;
break;
}
if (!merge(n, n + i, 1)) {
conf = true;
break;
}
for (int j = 0; j < n; ++j)
if (s[j] != '?') {
if (j >= n - i) {
if (!merge(j, j + i, s[j] - '0')) {
conf = true;
break;
}
} else {
if (!merge(j, n + i, s[j] - '0')) {
conf = true;
break;
}
}
}
long long int ans;
if (conf) {
ans = 0;
} else {
ans = 1;
for (int j = 0; j < n + i; ++j) {
std::pair<int, int> q = getrep(j);
std::pair<int, int> p = getrep(n + i);
if (p.first == q.first) continue;
ans = ans * 2 % mod;
merge(p.first, q.first, 0);
}
}
sum += ans;
}
printf("%d\n", (int)(sum % mod));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
if (n == 1 && t == 10) {
cout << "-1";
return 0;
}
cout << t;
if (t == 10) {
n--;
}
for (int i = 0; i < n - 1; i++) {
cout << "0";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int MAXM = 3005;
const int INF = 0x3f3f3f3f;
struct Edge {
int to, next, cap, flow;
} edge[MAXM];
int tol, head[MAXN];
int gap[MAXN], dep[MAXN], pre[MAXN], cur[MAXN];
void init() {
tol = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int w, int rw = 0) {
edge[tol].to = v;
edge[tol].cap = w;
edge[tol].next = head[u];
edge[tol].flow = 0;
head[u] = tol++;
edge[tol].to = u;
edge[tol].cap = rw;
edge[tol].next = head[v];
edge[tol].flow = 0;
head[v] = tol++;
}
int sap(int st, int ed, int N) {
memset(gap, 0, sizeof(gap));
memset(dep, 0, sizeof(dep));
memcpy(cur, head, sizeof(head));
int u = st;
pre[u] = -1;
gap[0] = N;
int ans = 0;
while (dep[st] < N) {
if (u == ed) {
int Min = INF;
for (int i = pre[u]; i != -1; i = pre[edge[i ^ 1].to])
if (Min > edge[i].cap - edge[i].flow) Min = edge[i].cap - edge[i].flow;
for (int i = pre[u]; i != -1; i = pre[edge[i ^ 1].to]) {
edge[i].flow += Min;
edge[i ^ 1].flow -= Min;
}
u = st;
ans += Min;
continue;
}
bool flag = 0;
int v;
for (int i = cur[u]; i != -1; i = edge[i].next) {
v = edge[i].to;
if (edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]) {
flag = 1;
cur[u] = pre[v] = i;
break;
}
}
if (flag) {
u = v;
continue;
}
int Min = N;
for (int i = head[u]; i != -1; i = edge[i].next)
if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) {
Min = dep[edge[i].to];
cur[u] = i;
}
gap[dep[u]]--;
if (!gap[dep[u]]) return ans;
dep[u] = Min + 1;
gap[dep[u]]++;
if (u != st) u = edge[pre[u] ^ 1].to;
}
return ans;
}
int f[105][105];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int a, b, ta = 0, tb = 0;
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
addedge(0, i, a);
ta += a;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b);
addedge(i + n, 2 * n + 1, b);
tb += b;
}
for (int i = 1; i <= n; i++) {
addedge(i, i + n, INF);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
addedge(a, b + n, INF);
addedge(b, a + n, INF);
}
int mf = sap(0, 2 * n + 1, 2 * n + 2);
int u, v;
if (mf == ta && mf == tb) {
printf("YES\n");
for (int i = 0; i < tol; i += 2) {
v = edge[i].to;
u = edge[i ^ 1].to;
if (u >= 1 && u <= n) {
f[u][v - n] = edge[i].flow;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
printf("%s%d", (j == 1 ? "" : " "), f[i][j]);
}
printf("\n");
}
} else
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int Brute(int n, vector<int> a) {
set<int> all;
for (int i = 0; i < n; i++) {
set<int> s;
for (int j = i; j < n; j++) {
s.emplace(a[j]);
for (int k = 1; true; k++) {
if (s.count(k) == 0) {
all.emplace(k);
break;
}
}
}
}
for (int i = 1; true; i++) {
if (all.count(i) == 0) {
return i;
}
}
return -1;
}
int Solve(int n, vector<int> a) {
vector<vector<int>> occ(n + 1);
for (int i = 0; i <= n; i++) {
occ[i].emplace_back(-1);
}
for (int i = 0; i < n; i++) {
a[i]--;
occ[a[i]].emplace_back(i);
}
for (int i = 0; i <= n; i++) {
occ[i].emplace_back(n);
}
vector<int> in(n + 2);
vector<pair<int, int>> queries;
for (int val = 0; val <= n; val++) {
auto &pos = occ[val];
for (int i = 0; i + 1 < (int)pos.size(); i++) {
if (pos[i] + 1 <= pos[i + 1] - 1) {
queries.emplace_back(pos[i] + 1, pos[i + 1] - 1);
}
}
}
sort(begin(queries), end(queries),
[&](pair<int, int> x, pair<int, int> y) { return x.second < y.second; });
int sz = 1;
while (sz < 2 * n) {
sz *= 2;
}
vector<int> tree(2 * sz, -1);
const auto Update = [&](int pos, int val) {
tree[pos += sz] = val;
for (pos /= 2; pos > 0; pos /= 2) {
tree[pos] = min(tree[pos * 2], tree[pos * 2 + 1]);
}
};
const auto Query = [&](int lft) {
int node = 1;
while (node < sz) {
if (tree[node * 2] < lft) {
node = node * 2;
} else {
node = node * 2 + 1;
}
}
return node - sz;
};
int ptr = 0;
for (auto q : queries) {
while (ptr <= q.second) {
Update(a[ptr], ptr);
ptr++;
}
in[Query(q.first)] = 1;
}
for (int i = 0; i <= n + 1; i++) {
if (!in[i]) {
return i + 1;
}
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int LOCAL = 0;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int n;
if (LOCAL) {
n = 6;
} else {
cin >> n;
}
vector<int> a(n);
for (int i = 0; i < n; i++) {
if (LOCAL) {
a[i] = rnd() % (n / 2) + 1;
} else {
cin >> a[i];
}
}
if (LOCAL) {
cout << n << "\n";
for (auto i : a) {
cout << i << " ";
}
cout << "\n";
}
cout << Solve(n, a) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
pair<int, int> ans[N];
inline int qr() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, s, a, tot;
priority_queue<pair<int, int> > qs, qt;
int main() {
n = qr(), s = qr();
for (register int i = 1; i <= n; i++) {
a = qr();
qs.push(make_pair(a, i));
}
while (!qs.empty()) {
pair<int, int> p = qs.top();
qs.pop();
while (p.first != 0) {
if (!qs.size()) {
puts("No");
return 0;
}
pair<int, int> v = qs.top();
qs.pop();
ans[++tot] = make_pair(p.second, v.second);
p.first--;
v.first--;
if (v.first) qt.push(v);
}
while (!qt.empty()) {
qs.push(qt.top());
qt.pop();
}
}
puts("Yes");
printf("%d\n", tot);
for (register int i = 1; i <= tot; i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, long long int> chairTime;
chairTime['f'] = 1;
chairTime['e'] = 2;
chairTime['d'] = 3;
chairTime['a'] = 4;
chairTime['b'] = 5;
chairTime['c'] = 6;
long long int numRow;
char chair;
cin >> numRow;
cin >> chair;
numRow--;
long long int cycle = 16;
long long int rowsPerCylcle = 4;
long long int timeToGetRow = (numRow / rowsPerCylcle) * cycle;
long long int row = (numRow % 2) * 7;
long long int timeToChair = timeToGetRow + row + chairTime[chair];
cout << timeToChair;
}
| 2 |
#include <bits/stdc++.h>
int N, M, S, T, head[1000005], next[1000005], lk[1000005], f[1000005],
q[1000005 * 2], in[1000005];
bool b[1000005];
void add(int u, int v, int t) { lk[t] = v, next[t] = head[u], head[u] = t; }
void init() {
scanf("%d%d", &N, &M);
for (int i = 1, u, v; i <= M; i++)
scanf("%d%d", &u, &v), add(v, u, i), in[u]++;
scanf("%d%d", &S, &T);
}
void doit() {
memset(f, 63, sizeof(f)), f[T] = 0, q[N] = T;
for (int l = N, r = N, u; l <= r; l++) {
if (b[u = q[l]]) continue;
b[u] = 1;
for (int i = head[u], v; v = lk[i], i; i = next[i])
if (!--in[v])
if (f[u] < f[v])
f[v] = f[u], q[l--] = v;
else
;
else if (f[u] + 1 < f[v])
f[v] = f[u] + 1, q[++r] = v;
}
printf("%d\n", f[S] < 1e9 ? f[S] : -1);
}
int main() {
init();
doit();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
cout << "? " << 1 << endl;
cin >> a;
cout << "? " << 1 + n / 2 << endl;
cin >> b;
if (abs((b - a)) % 2 == 1) {
cout << "! -1" << endl;
return 0;
}
if (b == a) {
cout << "! " << 1 << endl;
return 0;
}
int l = 1, r = n / 2;
while (r - l > 1) {
int mid = (l + r) / 2, aa, bb;
cout << "? " << mid << endl;
cin >> aa;
cout << "? " << mid + n / 2 << endl;
cin >> bb;
if (a - b < 0) {
if (aa - bb < 0)
l = mid;
else if (aa - bb > 0)
r = mid;
else if (aa == bb) {
cout << "! " << mid << endl;
return 0;
}
} else {
if (aa - bb < 0)
r = mid;
else if (aa - bb > 0)
l = mid;
else if (aa == bb) {
cout << "! " << mid << endl;
return 0;
}
}
}
cout << "! " << r << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long p;
int c = 0;
cin >> p;
for (int i = 1; i < p; i++) {
bool ok = true;
int temp = i;
for (int j = 1; j <= p - 2; j++) {
if ((temp - 1) % p == 0) {
ok = false;
}
temp *= i;
temp %= p;
}
if (ok && (temp - 1) % p == 0) {
c++;
}
}
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct station {
int pos;
long long price;
} a[200003];
int T[800008], d, n, m;
long long cnt;
bool comp(station A, station B) { return (A.pos < B.pos); }
void Build_MinIT(int, int, int);
int Find_Min(int, int, int, int, int);
int main() {
scanf("%d %d %d", &d, &n, &m);
for (int i = 1; i <= m; i++) scanf("%d %d", &a[i].pos, &a[i].price);
sort(a + 1, a + 1 + m, comp);
a[++m].pos = d;
for (int i = 1; i <= m; i++) {
if (a[i].pos - a[i - 1].pos > n) {
cout << -1;
return 0;
}
}
if (n >= d) {
cout << 0;
return 0;
}
a[200002].price = 1E+9;
Build_MinIT(1, m, 1);
int i = 0, j = 1, t = n;
while (j <= m) {
while (a[i].price < a[j].price && a[j].pos - a[i].pos <= n && j <= m) j++;
if (a[j].pos - a[i].pos <= n) {
cnt += (a[j].pos - (a[i].pos + t)) * a[i].price;
t = 0;
i = j++;
} else {
int k = Find_Min(i + 1, j - 1, 1, m, 1);
cnt += (n - t) * a[i].price;
t = a[i].pos + n - a[k].pos;
i = k;
}
}
cout << cnt;
return 0;
}
void Build_MinIT(int L, int R, int v) {
if (L == R) {
T[v] = L;
return;
}
int m = (L + R) / 2;
Build_MinIT(L, m, v * 2);
Build_MinIT(m + 1, R, v * 2 + 1);
T[v] = (a[T[v * 2]].price < a[T[v * 2 + 1]].price ? T[v * 2] : T[v * 2 + 1]);
}
int Find_Min(int l, int r, int L, int R, int v) {
if (l > r) return 200002;
if (l == L && r == R) return T[v];
int m = (L + R) / 2;
int x = Find_Min(l, min(r, m), L, m, v * 2),
y = Find_Min(max(l, m + 1), r, m + 1, R, v * 2 + 1);
return (a[x].price < a[y].price ? x : y);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400 + 7;
const int INF = 1000 * 1000 * 1000;
vector<pair<int, int> > g[MAXN];
int dp[MAXN][MAXN];
vector<int> pr[MAXN][MAXN];
int pe[MAXN];
int pp[MAXN];
int sz[MAXN];
void cdp(int u) {
sz[u] = 1;
for (int i = 0; i < MAXN; i++) dp[u][i] = INF;
dp[u][1] = 1;
dp[u][0] = 1;
for (int i = 0; i < MAXN; i++) pr[u][i].resize(g[u].size(), -1);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == pp[u]) continue;
pe[v] = g[u][i].second;
pp[v] = u;
cdp(v);
for (int k = sz[u]; k >= 1; k--) {
for (int j = 1; j < sz[v] + 1; j++) {
if (k + j >= MAXN) continue;
if (dp[u][k + j] > dp[u][k] + dp[v][j] - 1) {
dp[u][k + j] = dp[u][k] + dp[v][j] - 1;
pr[u][k + j][i] = j;
}
}
dp[u][k]++;
}
sz[u] += sz[v];
}
}
vector<int> fans;
void dfs(int u, int x) {
if (!x) {
fans.push_back(pe[u]);
return;
}
int need[MAXN];
memset(need, 0, sizeof need);
int tof = g[u].size() - 1;
while (x > 1) {
while (pr[u][x][tof] == -1) tof--;
int p = pr[u][x][tof];
need[tof] = p;
x -= p;
tof--;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == pp[u]) continue;
dfs(v, need[i]);
}
}
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
}
cdp(0);
int ans = INF;
int rt = 0;
for (int i = 0; i < n; i++) {
if (ans > dp[i][k] + bool(i)) {
ans = dp[i][k] + bool(i);
rt = i;
}
}
if (rt) fans.push_back(pe[rt]);
dfs(rt, k);
if (fans.size() != ans - 1) assert(0);
cout << fans.size() << endl;
for (int i = 0; i < fans.size(); i++) cout << fans[i] << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> f[200005];
void sieve() {
for (long long i = 2; i < 200005; i++) {
if (f[i].size()) continue;
for (long long j = i; j < 200005; j += i) f[j].push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
sieve();
long long a[n + 1];
vector<long long> count[200005];
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
if (a[i] == 1) continue;
for (auto j : f[a[i]]) {
long long k = 0;
while (a[i] % j == 0) a[i] /= j, k++;
count[j].push_back(k);
}
}
for (long long i = 0; i < 200005; i++) sort(count[i].begin(), count[i].end());
long long ans = 1;
for (long long i = 2; i < 200005; i++) {
if (count[i].size() == (n - 1))
for (long long j = 0; j < count[i][0]; j++) ans *= i;
else if (count[i].size() == n)
for (long long j = 0; j < count[i][1]; j++) ans *= i;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace XDYIMCMI0LY {
const int N = 400 + 5;
int n;
int m;
int r;
int c;
char s[N][N];
char t[N][N];
bitset<N> b[26][N];
bitset<N> ans[N];
bitset<N> shift(bitset<N> x, int k) { return (x >> k) | (x << (m - k)); }
void solve() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int c = (int)s[i][j] - 'a';
b[c][i][j] = 1;
}
}
cin >> r >> c;
for (int i = 0; i < r; ++i) {
cin >> t[i];
}
for (int i = 0; i < n; ++i) {
ans[i] = ~ans[i];
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (t[i][j] == '?') {
continue;
}
int p = t[i][j] - 'a';
for (int k = 0; k < n; ++k) {
int x = (k + i) % n;
if (ans[k].count() == 0) {
continue;
}
if (b[p][x].count() == 0) {
ans[k].reset();
} else {
ans[k] &= shift(b[p][x], j % m);
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ans[i][j];
}
cout << endl;
}
}
} // namespace XDYIMCMI0LY
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
XDYIMCMI0LY::solve();
flush(cout);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
double P[MAXN];
int n;
void solve() {
double res = 0.0;
double sum = 0.0, cur = 0.0;
for (int i = 1; i <= n; ++i) {
sum *= P[i];
sum += cur * P[i] * 2;
sum += P[i] * (1.0 - P[i - 1]);
cur = cur * P[i] + P[i] * (1.0 - P[i - 1]);
res += sum;
}
printf("%.9f\n", res);
}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lf", P + i);
P[0] = 0.0;
}
int main() {
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define gap " "
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define ok cout<<"ok"<<endl
#define DBG(a) cerr<< "Line "<<__LINE__ <<" : "<< #a <<" = "<<(a)<<endl
#define fastio {ios_base::sync_with_stdio(false);cin.tie(NULL);}
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
const int N=200009;
int X[N],Y[N];
int main()
{
int t,n,i;
scanf("%d",&t);
while(t--){
vector<pii> vec;
scanf("%d",&n);
for(i=1; i<=n; i++) scanf("%d",&X[i]);
for(i=1; i<=n; i++) scanf("%d",&Y[i]);
for(i=1; i<=n; i++){
vec.pb({X[i],Y[i]});
}
sort(vec.begin(),vec.end());
int mncost=0;
pii pre,cur;
pre.ff=1; pre.ss=1;
for(i=0; i<n; i++){
cur=vec[i];
if(cur.ff-cur.ss == pre.ff-pre.ss){
int dif=cur.ff-pre.ff;
if((pre.ff+pre.ss)%2==0) mncost+=dif;
}
else {
if((pre.ff+pre.ss)%2==0) pre.ff++;
int dif=cur.ss-pre.ss;
pre.ff+=dif; pre.ss=cur.ss;
dif=cur.ff-pre.ff;
mncost+=(dif/2);
if(dif%2==1 && (pre.ff+pre.ss)%2==1) mncost++;
}
pre=cur;
}
printf("%d\n",mncost);
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, n, k;
cin >> t;
while (t--) {
cin >> n >> k;
vector<int> a(k);
for (int i = 0; i < k; i++) {
a[i] = n / k;
}
for (int i = 0; i < n % k; i++) {
a[i]++;
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < a[i]; j++) cout << (char)('a' + i);
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int inf = 1e9 + 1000;
struct node {
int x, y;
bool operator<(const node& b) const { return x == b.x ? y < b.y : x < b.x; }
} p1[200004], p2[200004];
multiset<int> Leftx;
multiset<int> Lefty;
multiset<int> Rightx;
multiset<int> Righty;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &p1[i].x, &p1[i].y, &p2[i].x, &p2[i].y);
Leftx.insert(p1[i].x);
Lefty.insert(p1[i].y);
Rightx.insert(p2[i].x);
Righty.insert(p2[i].y);
}
for (int i = 1; i <= n; i++) {
Leftx.erase(Leftx.find(p1[i].x));
Lefty.erase(Lefty.find(p1[i].y));
Rightx.erase(Rightx.find(p2[i].x));
Righty.erase(Righty.find(p2[i].y));
int lx = (*Leftx.rbegin());
int ly = (*Lefty.rbegin());
int rx = (*Rightx.begin());
int ry = (*Righty.begin());
if (lx <= rx && ly <= ry) {
cout << rx << ' ' << ry << endl;
return 0;
}
Leftx.insert(p1[i].x);
Lefty.insert(p1[i].y);
Rightx.insert(p2[i].x);
Righty.insert(p2[i].y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const int maxn = 2e5 + 100;
const int base = 29;
const int mod = 1e9 + 7;
const int INF = 2e9 + 100;
int nxt[maxn];
int sz[maxn];
int deg[maxn];
bool mark[maxn];
bool dp[maxn];
bool dp2[maxn];
inline int root(int x) { return (nxt[x] == 0 ? x : nxt[x] = root(nxt[x])); }
inline void dfs(int v) {
mark[v] = true;
sz[v] = 1;
if (nxt[v] == 0) return;
int u = nxt[v];
if (mark[u])
sz[v] += sz[u];
else {
dfs(u);
sz[v] += sz[u];
}
}
int32_t main() {
int n = in(), id = in();
for (int i = 1; i <= n; i++) nxt[i] = in(), deg[nxt[i]]++;
for (int i = 1; i <= n; i++) {
if (!mark[i]) dfs(i);
}
vector<int> vc;
for (int i = 1; i <= n; i++)
if (deg[i] == 0 && root(i) != root(id)) vc.push_back(sz[i]);
dp[0] = true;
for (int i = 0; i < vc.size(); i++) {
for (int j = 0; j + vc[i] <= 1000; j++) dp2[j + vc[i]] |= dp[j];
for (int j = 0; j <= 1000; j++) dp[j] |= dp2[j], dp2[j] = false;
}
for (int x = 0; x <= 1000; x++) {
if (dp[x]) {
cout << x + sz[id] << "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bitset<22505> a, b, c, d;
int main() {
int n, m, k, i, j;
string x;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
string x;
cin >> x;
for (j = 0; j < m; j++) {
if (x[j] == '#')
b.set(i * m + j);
else
a.set(i * m + j);
if (x[j] == 'E') c.set(i * m + j);
}
}
cin >> x;
d = a;
for (i = 0; i < k; i++) {
if (c == d) {
printf("%d\n", i);
return 0;
}
if (x[i] == 'D') d = ((d << m) & a) | (d & (b >> m));
if (x[i] == 'U') d = ((d >> m) & a) | (d & (b << m));
if (x[i] == 'R') d = ((d << 1) & a) | (d & (b >> 1));
if (x[i] == 'L') d = ((d >> 1) & a) | (d & (b << 1));
}
if (c == d)
printf("%d\n", k);
else
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000050;
long long st[N], ans;
int tot;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long a, b, d, w;
cin >> a >> b;
while (b) {
d = gcd(a, b), a /= d, b /= d;
if (a == b) {
cout << ans + 1;
return 0;
}
d = (2 > sqrt(a) ? 2 : sqrt(a)), w = a, tot = 0;
for (int i = 2; i <= d; ++i)
if (w % i == 0) {
while (w % i == 0) w /= i;
st[++tot] = i;
}
if (w > 1) st[++tot] = w;
long long m = b;
for (int i = 1; i <= tot; ++i)
if (m > b % st[i]) m = b % st[i];
ans += m, b -= m;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int cons;
long long int check(long long int a) {
if (a >= cons) a %= cons;
return a;
}
long long int check2(long long int a) {
a %= cons;
if (a < 0) a += cons;
return a;
}
long long int fast_check(long long int a) {
if (a >= cons) a -= cons;
return a;
}
long long int GCD(long long int a, long long int b) {
while (a && b) {
a = a % b;
if (a != 0) b = b % a;
}
return a + b;
}
long long int exp(long long int a, long long int n) {
long long int ans = 1;
a = check(a);
while (n) {
if (n & 1) ans = check(ans * a);
a = check(a * a);
n = (n >> 1);
}
return ans;
}
void print_pair(pair<int, int> p) {
cout << p.first << " " << p.second << endl;
}
long long int nc2(long long int a) { return (a * (a - 1)) / 2; }
const int N = 4e5;
long long int arr[N][2];
int sum[N];
int ones[N];
int count1(long long int first) {
int coun = 0;
while (first) {
coun++;
first = first & (first - 1);
}
return (coun);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cons = 1e9 + 7;
int n;
cin >> n;
arr[0][0] = 1;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
long long int first;
cin >> first;
first = count1(first);
sum[i] = sum[i - 1] + first;
ones[i] = first;
int cumu = sum[i] & 1;
arr[i][cumu] = arr[i - 1][cumu] + 1;
arr[i][1 - cumu] = arr[i - 1][1 - cumu];
int k = 1;
int maxy = ones[i];
while (k < 130 && i - k >= 0) {
int bit_sum = sum[i] - sum[i - k];
if (bit_sum % 2 == 0 && maxy * 2 <= bit_sum) {
ans++;
}
maxy = max(maxy, ones[i - k]);
k++;
if (bit_sum >= 130) break;
}
if (i - k >= 0) ans += arr[i - k][cumu];
}
cout << ans;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
void solve(){
int n, p, x;
scanf("%d", &n);
int ans = 0;
scanf("%d", &p);
for(int i=1; i<n; ++i){
scanf("%d", &x);
while(2*x < p){
p = ((p+1)>>1);
++ans;
}
while(2*p < x){
p = (p<<1);
++ans;
}
p = x;
}
printf("%d\n", ans);
}
int main(){
int T;
scanf("%d", &T);
while(T--){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int minimum(int n, int k);
char numbers[8][8];
int num[8];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
num[j] = j;
scanf(" %c", &numbers[i][j]);
numbers[i][j] -= '0';
}
}
int res = minimum(n, k);
printf("%d\n", res);
return 0;
}
int minimum(int n, int k) {
int m = 0x7fffffff;
int aux[8];
int ma, mi;
do {
for (int i = 0; i < n; i++) {
aux[i] = numbers[i][num[0]];
int pot = 10;
for (int j = 1; j < k; j++) {
aux[i] += (numbers[i][num[j]] * pot);
pot *= 10;
}
if (!i)
ma = mi = aux[i];
else if (aux[i] > ma)
ma = aux[i];
else if (aux[i] < mi)
mi = aux[i];
}
m = min(m, ma - mi);
} while (next_permutation(num, num + k));
return m;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int l[100005];
int r[100005];
map<int, int> ml;
map<int, int> mr;
int n, m;
int find_l(int p, int t) {
int ep = p - (m - t) - 1;
if (ml.find(ep) != ml.end()) {
return l[ml[ep]];
}
return max(1, ep);
}
int find_r(int p, int t) {
int ep = p + (m - t) + 1;
if (mr.find(ep) != mr.end()) {
return r[mr[ep]];
}
return min(n, ep);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
int i;
for (i = 0; i < m; i++) {
cin >> a[i + 1];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (i = m; i >= 1; i--) {
l[i] = find_l(a[i] + 1, i);
r[i] = find_r(a[i] - 1, i);
int ep = a[i] - (m - i) - 1;
ml[ep] = i;
ep = a[i] + (m - i) + 1;
mr[ep] = i;
}
long long ans = 0;
for (i = 1; i <= n; i++) {
ans += (find_r(i, 0) - find_l(i, 0) + 1);
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define umap unordered_map
#define deb(x) cout<<#x<<" = "<<x<<endl;
#define debarr(arr) for(auto x: arr) cout<<x<<" "; cout<<endl
#define debarr2(arr) for(auto v : arr){ for(auto x : v) cout<<x<<" "; cout<<endl; }
#define deb2(p, q) cout << #p << ": " << p << " | " << #q << ": " << q << endl;
#define deb3(p, q, r) cout << #p << ": " << p << " | " << #q << ": " << q << " | " << #r << ": " << r << endl;
#define deb4(p, q, r, s) cout << #p << ": " << p << " | " << #q << ": " << q << " | " << #r << ": " << r << " | " << #s << ": " << s << endl;
#define deb5(p, q, r, s, t) cout << #p << ": " << p << " | " << #q << ": " << q << " | " << #r << ": " << r << " | " << #s << ": " << s << " | " << #t << ": " << t << endl;
#define deb6(p, q, r, s, t, u) cout << #p << ": " << p << " | " << #q << ": " << q << " | " << #r << ": " << r << " | " << #s << ": " << s << " | " << #t << ": " << t << " | " << #u << ": " << u << endl;
#define fo(i, k, n) for(int i=k;i<n;i++)
#define loop(i, k, n) for(int i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define loopc(i, k, n) for(int i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)
#define vec(type) vector<type>
#define vec2(type,arr,a,b) vector<vector<int>> arr(a,vector<int>(b))
#define mp(a,b) make_pair(a,b)
#define pb push_back
int mod = 1e9 + 7;
int infinite = INT_MAX - 10;
template <typename T>
T power(T x, T y)
{
T temp;
if(y == 0)
return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
{
if(y > 0)
return x * temp * temp;
else
return (temp * temp) / x;
}
}
int countDigit(long long n)
{
return floor(log10(n) + 1);
}
ll gcd(ll a, ll b)
{
if(a==0)
return b;
return gcd(b%a,a);
}
void solve()
{
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vec(ll) arr(10000+1,-1);
for(ll i=1;i<=10000;i++)
{
arr[i] = i*i*i;
}
int t;
cin>>t;
while(t--)
{
ll x;
cin>>x;
bool flag = false;
for(ll i=1;i<arr.size();i++)
{
if(arr[i]> x) break;
if(binary_search(arr.begin(),arr.end(),x-arr[i]))
{
flag = true;
break;
}
}
if(flag) cout<<"YES\n";
else cout<<"NO\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1000010;
int n, X, Y, ans;
int sta[N], top = 0;
pair<int, int> a[N];
struct P {
int x, id, opt;
inline bool operator<(const P &yy) const {
return x == yy.x ? opt > yy.opt : x < yy.x;
}
};
P p[N];
int len = 0;
template <typename T>
void gi(T &x) {
x = 0;
register char c = getchar(), pre = 0;
for (; c < '0' || c > '9'; pre = c, c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10ll + (c ^ 48);
if (pre == '-') x = -x;
}
int main() {
gi(n), gi(X), gi(Y);
for (int i = (1); i <= (n); i++)
gi(a[i].first), gi(a[i].second), p[++len] = (P){a[i].first, i, 1},
p[++len] = (P){a[i].second, i, -1};
sort(p + 1, p + len + 1);
for (int i = (1); i <= (len); i++) {
if (p[i].opt == -1)
sta[++top] = p[i].x;
else {
int L = a[p[i].id].first, R = a[p[i].id].second;
if (!top)
ans = (ans + X + 1ll * (R - L) * Y % mod) % mod;
else {
int x = sta[top--];
if (1ll * Y * (R - x) <= X + 1ll * Y * (R - L))
ans = (ans + 1ll * (R - x) * Y % mod) % mod;
else
++top, ans = (ans + X + 1ll * (R - L) * Y % mod) % mod;
}
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> d(n);
string all(n, 'O');
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
--d[i];
}
printf("1");
int last = 0;
for (int i = 0; i < n; i++) {
all[d[i]] = 'X';
while (last < n && all[n - 1 - last] == 'X') last++;
int cnt = (i + 1) - last;
cnt++;
printf(" %d", cnt);
}
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, k;
long long mx = -1e18;
vector<int> a, v[300001];
long long dfs(int node, int pnode) {
long long dp = a[node];
for (auto &i : v[node])
if (i != pnode) dp += max(0LL, dfs(i, node));
mx = max(mx, dp);
return dp;
}
long long dfs2(int node, int pnode) {
long long dp = a[node];
for (auto &i : v[node])
if (i != pnode) dp += max(0LL, dfs2(i, node));
if (dp == mx) {
k++;
return 0;
}
return dp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
a.push_back(0);
cin >> n;
for (int i = 0; i < n && cin >> x; i++) a.push_back(x);
for (int i = 0; i < n - 1 && cin >> x >> y; i++) {
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
dfs2(1, 0);
cout << k * mx << " " << k << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18;
const int N = 2 * 1e5 + 5;
const double eps = 1e-5;
bool vis[N] = {0};
vector<int> ans;
vector<vector<int>> g;
int goal[N], init[N];
void dfs(int u, int even, int odd, int lvl) {
vis[u] = 1;
if (lvl % 2 && odd % 2 || !(lvl % 2) && even % 2) init[u] ^= 1;
if (init[u] != goal[u]) {
ans.push_back(u);
if (lvl % 2 == 0) {
for (int i = 0; i < g[u].size(); i++)
if (!vis[g[u][i]]) dfs(g[u][i], even + 1, odd, lvl + 1);
} else {
for (int i = 0; i < g[u].size(); i++)
if (!vis[g[u][i]]) dfs(g[u][i], even, odd + 1, lvl + 1);
}
} else
for (int i = 0; i < g[u].size(); i++)
if (!vis[g[u][i]]) dfs(g[u][i], even, odd, lvl + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
g.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) cin >> init[i];
for (int i = 1; i <= n; i++) cin >> goal[i];
dfs(1, 0, 0, 1);
cout << ans.size() << endl;
for (auto it : ans) cout << it << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100012;
int n;
double p[N], f[N], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lf", &p[i]);
f[1] = p[1];
for (int i = 1; i <= n; ++i) f[i] = f[i - 1] * p[i] + p[i], ans += f[i];
ans *= 2;
for (int i = 1; i <= n; ++i) ans -= p[i];
printf("%.8lf\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c[111], a[111], b[111], minn = 111111, sum = 0, ans1 = 0, ans2 = 0,
it = 0;
cin >> n;
for (int j = 1; j < n; j++) cin >> a[j];
for (int j = 1; j < n; j++) cin >> c[j];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
for (int j = 1; j <= i; j++) sum += a[j];
for (int j = i + 1; j < n; j++) sum += c[j];
sum += b[i];
if (minn > sum) {
minn = sum;
it = i;
}
sum = 0;
}
ans1 = minn;
minn = 111111;
sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= i; j++) sum += a[j];
for (int j = i + 1; j < n; j++) sum += c[j];
sum += b[i];
if (minn > sum && it != i) minn = sum;
sum = 0;
}
ans2 = minn;
cout << ans1 + ans2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 10000;
long long Func(long long n) {
long long tmp = n;
long long cnt = 0;
while (tmp / 10) {
tmp /= 10;
cnt++;
}
long long v = 1;
for (int i = 0; i < cnt; i++) v *= 10;
long long sum = 0;
while (v >= 1) {
long long d = n / v;
long long rev = 9 - d;
rev *= v;
sum += rev;
n %= v;
v /= 10;
}
return sum;
}
void solve() {
long long l, r;
cin >> l >> r;
vector<long long> ls;
vector<long long> rs;
long long maxN = 0;
long long kurai = 1;
while (1) {
if (kurai > r) break;
if (kurai * 10 >= l) {
int cl = max(kurai, l);
int cr = min(kurai * 10 - 1, r);
int med = kurai * 10 / 2;
int med2 = kurai * 10 / 2 - 1;
if (med >= cl && med <= cr) {
maxN = max(maxN, (med)*Func(med));
} else {
maxN = max(maxN, max(cl * Func(cl), cr * Func(cr)));
}
}
kurai *= 10;
}
cout << maxN << endl;
}
int main() {
solve();
int x;
cin >> x;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)2e5 + 5;
const long long mod = (long long)1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
long long rev = (1 << k) - 1LL;
map<long long, long long> mp;
long long pre = 0, res = 0;
mp[0] = 1;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
long long pre1 = x ^ pre;
long long pre2 = pre1 ^ rev;
long long cur = -1;
if (mp[pre1] < mp[pre2])
cur = pre1;
else
cur = pre2;
pre = cur;
res += (i + 1 - mp[pre]);
mp[pre]++;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[100010];
int query(int a, int b) {
printf("? %d %d\n", a, b);
fflush(stdout);
int ret;
scanf("%d", &ret);
if (ret == -1) exit(0);
return ret;
}
bool vis[100010];
int low[100010], dfn[100010], tim, stk[100010], top;
vector<int> blk[100010];
int bel[100010], bcnt = 0, s[100010];
void dfs(int np) {
dfn[np] = low[np] = ++tim;
vis[np] = 1;
stk[++top] = np;
for (int i = 0; i < v[np].size(); i++) {
int x = v[np][i];
if (!dfn[x]) {
dfs(x);
low[np] = min(low[np], low[x]);
} else if (vis[x])
low[np] = min(low[np], dfn[x]);
}
if (low[np] == dfn[np]) {
++bcnt;
int tmp;
while ((tmp = stk[top--])) {
bel[tmp] = bcnt;
blk[bcnt].push_back(tmp);
vis[tmp] = 0;
if (tmp == np) break;
}
s[bcnt] = blk[bcnt].size();
}
}
int a[100010], b[100010], deg[100010];
set<pair<int, int> > st;
int pos[100010], pcnt;
vector<int> v2[100010];
void add(int id) {
for (int i = 0; i < blk[id].size(); i++) {
int x = blk[id][i];
pos[x] = ++pcnt;
st.insert(make_pair(pos[x], x));
}
}
void del(int id) {
st.erase(make_pair(pos[id], id));
id = bel[id];
s[id]--;
if (!s[id]) {
for (int i = 0; i < v2[id].size(); i++) {
int x = v2[id][i];
deg[x]--;
if (!deg[x]) add(x);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
v[a[i]].push_back(b[i]);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= m; i++) {
if (bel[a[i]] != bel[b[i]]) {
v2[bel[a[i]]].push_back(bel[b[i]]);
deg[bel[b[i]]]++;
}
}
int tp = 0;
for (int i = 1; i <= n; i++) {
if (!deg[bel[i]]) {
tp = i;
break;
}
}
for (int i = 1; i <= bcnt; i++)
if (!deg[i]) add(i);
while (1) {
set<pair<int, int> >::iterator c = st.end();
c--;
if (bel[st.begin()->second] == bel[tp] && bel[c->second] == bel[tp]) {
printf("! %d\n", tp);
return 0;
}
if (bel[st.begin()->second] != bel[tp]) {
int y = st.begin()->second;
if (query(tp, y))
del(y);
else
del(tp), tp = y;
} else {
int y = c->second;
if (query(tp, y))
del(y);
else
del(tp), tp = y;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[102];
scanf("%d", &n);
int mmax = 0;
int mmin = 100000;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] > mmax) mmax = a[i];
if (a[i] < mmin) mmin = a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
if (i == 0)
printf("%d", a[n - 1]);
else if (i == n - 1)
printf("%d", a[0]);
else
printf("%d", a[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, i, j, res1, res2, x, ans, ans2, pos;
bool a[1000][1000];
int main() {
cin >> n >> m >> k;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
for (j = 0; j < m; j++) {
res1 = 0;
for (i = 0; i < n; i++)
if (a[i][j] == 1) {
res2 = 0;
for (x = i; x < i + k; x++)
if (a[x][j] == 1) res2++;
if (res1 < res2) pos = i;
res1 = max(res1, res2);
}
if (res1 != 0)
for (i = pos - 1; i >= 0; i--)
if (a[i][j] == 1) ans2++;
ans += res1;
}
cout << ans << ' ' << ans2;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 61, inf = 2e9;
int dis[maxn][maxn][maxn], dp[maxn][maxn][maxn], D[maxn][maxn];
int main() {
ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) cin >> dis[i][j][k];
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++)
for (int k = 0; k < maxn; k++) {
D[i][j] = inf;
dp[i][j][k] = inf;
}
for (int c = 1; c <= m; c++)
for (int u = 1; u <= n; u++)
for (int l = 1; l <= n; l++)
for (int r = 1; r <= n; D[l][r] = min(D[l][r], dis[c][l][r]), r++)
dis[c][l][r] = min(dis[c][l][r], dis[c][l][u] + dis[c][u][r]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dp[i][j][0] = min(dp[i][j][0], D[i][j]);
for (int k = 1; k < n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int u = 1; u <= n; u++)
dp[i][j][k] = min(dp[i][j][k], dp[i][u][k - 1] + D[u][j]);
while (q--) {
int st, en, k;
cin >> st >> en >> k;
k = min(n - 1, k);
cout << dp[st][en][k] << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, mod = 1e9 + 7;
int p, alpha, n, len, A[N], x[N], f[N][N][2][2], res;
char str[N];
inline void qmo(int &x) { x += (x >> 31) & mod; }
int main() {
scanf("%d%d%s", &p, &alpha, str);
n = strlen(str);
for (register int i = 1; i <= n; ++i) A[i] = str[n - i] - '0';
while (n) {
long long t = 0;
for (register int i = n; i; --i) {
t = 10 * t + A[i];
A[i] = t / p;
t %= p;
if (!A[i] && i == n) --n;
}
x[++len] = t;
}
f[len + 1][0][0][1] = 1;
int c1 = p * (p + 1ll) / 2 % mod, c3 = p * (p - 1ll) / 2 % mod;
for (register int i = len; i; --i) {
int c2 = x[i] * (x[i] + 1ll) / 2 % mod,
c4 = x[i] * ((p << 1) - x[i] - 1ll) / 2 % mod,
c5 = x[i] * (x[i] - 1ll) / 2 % mod,
c6 = x[i] * ((p << 1) - x[i] + 1ll) / 2 % mod;
for (register int j = 0; j <= len - i + 1; ++j) {
int f0 = f[i + 1][j][0][0], f1 = f[i + 1][j][0][1],
f2 = f[i + 1][j][1][0], f3 = f[i + 1][j][1][1];
if (f0 || f1 || f2 || f3) {
f[i][j][0][0] = ((long long)c1 * f0 % mod + (long long)c2 * f1 % mod +
(long long)c3 * f2 % mod + (long long)c4 * f3 % mod) %
mod;
f[i][j][0][1] =
(f1 * (x[i] + 1ll) % mod + f3 * (p - x[i] - 1ll) % mod) % mod;
f[i][j + 1][1][0] =
((long long)c3 * f0 % mod + (long long)c5 * f1 % mod +
(long long)c1 * f2 % mod + (long long)c6 * f3 % mod) %
mod;
f[i][j + 1][1][1] =
((long long)f1 * x[i] % mod + (long long)f3 * (p - x[i]) % mod) %
mod;
}
}
}
for (register int i = alpha; i <= len; ++i)
qmo(res += f[1][i][0][1] - mod), qmo(res += f[1][i][0][0] - mod);
printf("%d\n", res);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int x, int y) { return x < y; }
int gcd(int x, int y) { return 0; }
long long quick_mod() { return 0; }
string S;
int ans;
char s[10] = {'a', 'e', 'i', 'o', 'u'};
bool f;
int main() {
cin >> S;
ans = 0;
for (int i = 0; i < S.size(); i++)
for (int j = 0; j < 5; j++)
if (S[i] == s[j] || (S[i] == '1' || S[i] == '3' || S[i] == '5' ||
S[i] == '7' || S[i] == '9')) {
ans++;
break;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int num = min(a, min(b, c));
if (num > 3) {
cout << "NO"
<< "\n";
} else {
if (num == 1) {
cout << "YES";
} else {
int sec, tir;
if (a == num) {
sec = min(b, c);
tir = max(b, c);
} else if (b == num) {
sec = min(a, c);
tir = max(a, c);
} else {
sec = min(a, b);
tir = max(a, b);
}
if (num == 2 && sec == 2) {
cout << "YES";
} else if ((num == 3 && sec == 3) && (tir == 3)) {
cout << "YES";
} else if ((num == 2 && sec == 4) && (tir == 4)) {
cout << "YES";
} else {
cout << "NO";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int toInt(string s) {
istringstream sin(s);
int t;
sin >> t;
return t;
}
template <class T>
string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int A[100010], B[100010], L[100010];
double dist(double x, double y) { return sqrt(x * x + y * y); }
int main() {
int n, m, a, b;
cin >> n >> m >> a >> b;
int i, j;
for (i = (0); i < (n); i++) scanf("%d", A + i);
for (i = (0); i < (m); i++) scanf("%d", B + i);
for (i = (0); i < (m); i++) scanf("%d", L + i);
double ans = 1e18;
int px, py;
for (i = (0); i < (m); i++) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (1ll * A[mid] * b > 1ll * a * B[i])
hi = mid - 1;
else
lo = mid + 1;
}
for (j = hi - 2; j < hi + 4; j++)
if (j >= 0 && j < n) {
double d = dist(a, A[j]) + dist(b - a, B[i] - A[j]) + L[i];
if (ans > d) {
ans = d;
px = j;
py = i;
}
}
}
printf("%d %d\n", px + 1, py + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int dp[maxn], pre[maxn];
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++) cin >> A[i];
dp[0] = 20, pre[0] = 20;
for (int i = 1; i < n; i++) {
int a = lower_bound(A.begin(), A.end(), A[i] - 89) - A.begin();
int b = lower_bound(A.begin(), A.end(), A[i] - 1439) - A.begin();
int val = ((a == 0) ? 0 : pre[a - 1]) + 50;
val = min(val, ((b == 0) ? 0 : pre[b - 1]) + 120);
val -= pre[i - 1];
dp[i] = max(0, min(20, val));
pre[i] = pre[i - 1] + dp[i];
}
for (int i = 0; i < n; i++) cout << dp[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int> goodX;
set<pair<int, int> > can;
const int MAXN = 1000 * 1000 + 10;
int id[MAXN];
pair<int, int> pnts[MAXN];
vector<int> blocks[MAXN];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
goodX.insert(1);
goodX.insert(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> y >> x;
if (x > 1) goodX.insert(x - 1);
goodX.insert(x);
pnts[i] = pair<int, int>(x, y);
}
int cntx = 0;
for (set<int>::iterator it = goodX.begin(); it != goodX.end(); it++)
id[cntx++] = *it;
sort(pnts, pnts + m);
int ind = 0;
for (int i = 0; i < cntx; i++) blocks[i].push_back(0);
for (int i = 0; i < m; i++) {
while (pnts[i].first > id[ind]) ind++;
blocks[ind].push_back(pnts[i].second);
}
for (int i = 0; i < cntx; i++) blocks[i].push_back(n + 1);
can.insert(pair<int, int>(blocks[0][1], 1));
for (int i = 1; i < cntx; i++) {
if (can.size() == 0) {
cout << -1 << endl;
return 0;
}
for (int j = 0; j < blocks[i].size(); j++) {
if (can.lower_bound(pair<int, int>(blocks[i][j], -1)) == can.end())
continue;
pair<int, int> match = *can.lower_bound(pair<int, int>(blocks[i][j], -1));
if (match.second <= blocks[i][j] && blocks[i][j] < match.first) {
can.erase(match);
if (blocks[i][j] - match.second > 0)
can.insert(pair<int, int>(blocks[i][j], match.second));
if (match.first - (blocks[i][j] + 1) > 0)
can.insert(pair<int, int>(match.first, blocks[i][j] + 1));
}
}
if (can.size() == 0) {
cout << -1 << endl;
return 0;
}
for (int j = 1; j < blocks[i].size(); j++) {
set<pair<int, int> >::iterator loit =
can.lower_bound(pair<int, int>(blocks[i][j - 1] + 1, -1));
set<pair<int, int> >::iterator hiit =
can.lower_bound(pair<int, int>(blocks[i][j] + 1, -1));
if (loit == can.end()) break;
pair<int, int> fi = *loit;
pair<int, int> newOne = pair<int, int>(blocks[i][j], fi.second);
can.erase(loit, hiit);
if (newOne.first > newOne.second) can.insert(newOne);
}
}
if (can.size() == 0) {
cout << -1 << endl;
return 0;
}
if (can.rbegin()->first == n + 1)
cout << (n + n - 2) << endl;
else
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[5001];
int output[100001];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
arr[t]++;
}
int count = 0;
int flag = 0;
int max = 0;
for (int i = 5000; i >= 0; i--) {
if ((flag == 0) && (arr[i])) {
max = i;
flag = 1;
count++;
} else {
if (arr[i] == 1)
count++;
else if (arr[i] >= 2)
count = count + 2;
}
}
printf("%d\n", count);
for (int i = 0; i <= 5000; i++) {
if (arr[i] == 1)
output[100000 - i] = i;
else if (max == i)
output[100000 - i] = i;
else if (arr[i] >= 2) {
output[i] = i;
output[100000 - i] = i;
}
}
for (int i = 0; i <= 100000; i++) {
if (output[i]) {
printf("%d ", output[i]);
}
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
void solve() {
long long n;
cin >> n;
long long fact = 1, unimodal = 1;
for (long long i = 2; i <= n; i++) {
fact = (fact * i) % MOD;
unimodal = (unimodal * 2) % MOD;
}
cout << (fact - unimodal + MOD) % MOD << endl;
}
signed main() {
int t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, d, k;
cin >> n >> t >> k >> d;
int a;
a = (d + t) / t;
if (a * k < n) cout << "YES";
if (a * k >= n) cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long P = 1e9 + 7;
long long P1 = 1e9 + 9;
const int sqr = 500;
const int arrn = 5e5 + 5;
const int arrn2 = 6e3 + 5;
void solve() {
int n;
cin >> n;
vector<int> in(n);
for (int i = 0; i < n; i++) cin >> in[i];
vector<vector<long long>> proc(n, vector<long long>(20001, 0));
long long tot = 0;
for (int i = 0; i < n; i++) {
proc[i][10000 + in[i]] = 1;
proc[i][10000 - in[i]] = 1;
if (i > 0) {
for (int j = in[i]; j < 20001 - in[i]; j++) {
proc[i][j + in[i]] += proc[i - 1][j];
proc[i][j + in[i]] %= P;
proc[i][j - in[i]] += proc[i - 1][j];
proc[i][j - in[i]] %= P;
}
}
tot += proc[i][10000];
tot %= P;
}
if (tot < 0) tot += P;
cout << tot;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long mod = 1e9 + 7;
const long long nax = 300006;
const long long inf = 2e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct rect {
long long a, b, c, d;
void read() { cin >> a >> b >> c >> d; }
rect inter(const rect &other) const {
pair<long long, long long> ox;
ox = make_pair(max(a, other.a), min(c, other.c));
pair<long long, long long> oy;
oy = make_pair(max(b, other.b), min(d, other.d));
if (ox.second < ox.first || oy.second < oy.first) {
return rect{inf, inf, inf, inf};
}
return {ox.first, oy.first, ox.second, oy.second};
}
void print() { cout << a << ' ' << b << '\n'; }
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<rect> a(n);
for (rect &x : a) {
x.read();
}
vector<rect> pref(n), suff(n);
pref[0] = a[0], suff[n - 1] = a[n - 1];
for (long long i = 1; i < n; ++i) {
pref[i] = pref[i - 1].inter(a[i]);
}
for (long long i = n - 2; i >= 0; i--) {
suff[i] = suff[i + 1].inter(a[i]);
}
if (suff[1].a != inf) {
suff[1].print();
return 0;
}
if (pref[n - 2].a != inf) {
pref[n - 2].print();
return 0;
}
for (long long i = 1; i < n - 1; ++i) {
rect ans = pref[i - 1].inter(suff[i + 1]);
if (ans.a != inf) {
ans.print();
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111;
int g[N][3][3];
int getg(int n, int m1, int m2) {
if (n == 0) return 0;
if (g[n][m1][m2] >= 0) return g[n][m1][m2];
int &res = g[n][m1][m2];
bool used[n][2];
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) used[i][j] = 0;
if (m1 == 1) used[0][0] = 1;
if (m1 == 2) used[0][1] = 1;
if (m2 == 1) used[n - 1][0] = 1;
if (m2 == 2) used[n - 1][1] = 1;
set<int> was;
res = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) {
if (used[i][j]) continue;
int upn = i;
int upm1 = 2 - j;
int upm2 = m1;
int lon = n - i - 1;
int lom1 = 2 - j;
int lom2 = m2;
was.insert(getg(upn, upm1, upm2) ^ getg(lon, lom1, lom2));
}
while (was.count(res)) res++;
return res;
}
bool field[N][2];
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < N; i++)
for (int m1 = 0; m1 < 3; m1++)
for (int m2 = 0; m2 < 3; m2++) g[i][m1][m2] = -1;
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) field[i][j] = 0;
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
field[a][b] = 1;
for (int j = max(0, a - 1); j <= min(a + 1, n - 1); j++)
field[j][1 - b] = 1;
}
int res = 0;
for (int i = 0; i < n;) {
if (field[i][0] == 1 && field[i][1] == 1) {
i++;
continue;
}
int upm = 0;
if (field[i][0]) upm = 1;
if (field[i][1]) upm = 2;
int s = i;
while (i < n && (field[i][0] == 0 || field[i][1] == 0)) i++;
i--;
int size = i - s + 1;
int lom = 0;
if (field[i][0]) lom = 1;
if (field[i][1]) lom = 2;
cerr << getg(size, upm, lom) << endl;
res ^= getg(size, upm, lom);
i++;
}
if (res)
cout << "WIN";
else
cout << "LOSE";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Tree {
int fr, v;
inline void pair(int a, int b) { v = a, fr = b; }
} Tr[524288];
struct node {
int x, y;
} D[100005];
class Array {
public:
int v0, v1;
Array() { v0 = 0, v1 = 0; }
Array(int a, int b) { v0 = a, v1 = b; }
} f[100005];
int E[100005][2], H, M, n, Q, root, ar[100005];
inline Tree max(Tree a, Tree b) {
if (a.v > b.v)
return a;
else
return b;
}
inline int Question_Max(int s, int t) {
Tree re;
for (re.v = -1000000010; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (!(s & 1)) re = max(re, Tr[s ^ 1]);
if (t & 1) re = max(re, Tr[t ^ 1]);
}
return re.fr;
}
inline void Modify(Array &p, Array p1) {
if (p1.v1 < 0) return;
p.v1 = max(p.v1 + max(p1.v1, p1.v0), p.v0 + p1.v0 + 1);
p.v0 += max(p1.v1, p1.v0);
}
inline void Build_Tree(int l, int r, int fa, int dir) {
int p = Question_Max(l + M - 1, r + M + 1);
E[fa][dir] = p;
if (l < p) {
Build_Tree(l, p - 1, p, 0);
Modify(f[p], f[E[p][0]]);
}
if (p < r) {
Build_Tree(p + 1, r, p, 1);
Modify(f[p], f[E[p][1]]);
}
}
inline Array Question(int p, int l, int r, int L, int R) {
int ll[2], rr[2];
Array re;
ll[0] = l, rr[0] = p - 1, ll[1] = p + 1, rr[1] = r;
if (l > r || L > R)
return Array(0, -1000000010);
else if (l == L && r == R)
return f[p];
else if (p < L)
return Question(E[p][1], ll[1], rr[1], L, R);
else if (p > R)
return Question(E[p][0], ll[0], rr[0], L, R);
else {
if (E[p][0]) Modify(re, Question(E[p][0], ll[0], rr[0], L, rr[0]));
if (E[p][1]) Modify(re, Question(E[p][1], ll[1], rr[1], ll[1], R));
return re;
}
}
inline bool cmp(node a, node b) { return (a.x < b.x); }
int main() {
int i, a, b, c, d, K, l, r;
Array tmp;
scanf("%d%d", &n, &K);
for (i = 1; i <= K; ++i) scanf("%d%d", &D[i].x, &D[i].y);
scanf("%d%d%d%d", &a, &b, &c, &d);
for (i = K + 1; i <= n; ++i) {
D[i].x = (int)(((long long)D[i - 1].x * a + b) % 1000000009);
D[i].y = (int)(((long long)D[i - 1].y * c + d) % 1000000009);
}
sort(D + 1, D + 1 + n, cmp);
for (H = 1; (n + 1) >> H; ++H)
;
M = 1 << H;
for (i = 1; i <= n; ++i) {
Tr[i + M].pair(D[i].y, i);
ar[i] = D[i].x;
}
for (i = M - 1; i >= 1; --i) Tr[i] = max(Tr[i << 1], Tr[(i << 1) ^ 1]);
Build_Tree(1, n, 0, 0);
for (root = Question_Max(M, n + M + 1), scanf("%d", &Q); Q--;) {
scanf("%d%d", &l, &r);
l = lower_bound(ar + 1, ar + 1 + n, l) - ar;
r = upper_bound(ar + 1, ar + 1 + n, r) - ar - 1;
tmp = Question(root, 1, n, l, r);
printf("%d\n", max(tmp.v0, tmp.v1));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
class RTree {
public:
vector<int> data;
vector<int> lft;
vector<int> rgt;
int sz;
int tsz;
void Init(int size) {
sz = size;
tsz = 2;
while (tsz < sz) tsz *= 2;
data.resize(1 + tsz - 1 + tsz);
lft.resize(1 + tsz - 1 + tsz);
rgt.resize(1 + tsz - 1 + tsz);
int i;
for (i = 1; i <= 2 * tsz - 1; i++) data[i] = 0;
for (i = tsz; i < 2 * tsz; i++) {
lft[i] = i - tsz;
rgt[i] = i - tsz;
}
for (i = tsz - 1; i >= 1; i--) {
lft[i] = lft[2 * i];
rgt[i] = rgt[2 * i + 1];
}
}
int Sum(int l, int r) {
l += tsz;
r += tsz;
int res = 0;
while (l <= r) {
if (l & 1) {
res += data[l];
l++;
}
if (!(r & 1)) {
res += data[r];
r--;
}
l >>= 1;
r >>= 1;
}
return res;
}
int FF0(int pos) {
int ll = pos;
int rr = sz - 1;
int opt = sz;
while (ll <= rr) {
int mid = (ll + rr) / 2;
int s = Sum(pos, mid);
if (s == mid - pos + 1) {
ll = mid + 1;
} else {
if (mid < opt) opt = mid;
rr = mid - 1;
}
}
if (opt == sz) return FF0(0);
return opt;
}
void Add(int p, int d) {
p += tsz;
while (p >= 1) {
data[p] += d;
p >>= 1;
}
}
};
int h, m, n;
vector<RTree> trees;
int wtree[110000];
int wpos[110000];
void Load() {
scanf("%d%d%d", &h, &m, &n);
memset(wtree, 0xFF, sizeof(wtree));
int i;
for (i = 0; i < h; i++) {
if (wtree[i] != -1) continue;
int j;
int cnt = 0;
j = i;
while (wtree[j] == -1) {
wtree[j] = trees.size();
wpos[j] = cnt;
cnt++;
j = (j + m) % h;
}
RTree a;
trees.push_back(a);
trees.back().Init(cnt);
}
}
map<int, int> whereidt;
map<int, int> whereidpos;
void Solve() {
int i;
long long res = 0;
for (i = 0; i < n; i++) {
char c = getchar();
while (!((c == '+') || (c == '-'))) c = getchar();
int id, hash;
if (c == '+') {
scanf("%d%d", &id, &hash);
int t = wtree[hash];
int pos = wpos[hash];
int rp = trees[t].FF0(pos);
if (rp >= pos)
res += (rp - pos);
else {
res += rp + (trees[t].sz - pos);
}
trees[t].Add(rp, 1);
whereidt[id] = t;
whereidpos[id] = rp;
} else {
scanf("%d", &id);
trees[whereidt[id]].Add(whereidpos[id], -1);
}
}
cout << res;
}
int main() {
Load();
Solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
int p = 1;
while (true) {
if (n <= 3) {
if (n == 2) {
cout << p << ' ' << 2 * p;
} else {
cout << p << ' ' << p << ' ' << 3 * p;
}
break;
} else {
int t = n - n / 2;
for (int i = (0); i < (t); i += (1)) {
cout << p << ' ';
}
n /= 2;
p *= 2;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[8][8];
int r = 0, c = 0;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < 8; i++) {
int k = 0;
for (int j = 0; j < 8; j++) {
if (a[i][j] == 'B') k++;
}
if (k == 8) r++;
}
if (r != 8) {
for (int i = 0; i < 8; i++) {
int k = 0;
for (int j = 0; j < 8; j++) {
if (a[j][i] == 'B') k++;
}
if (k == 8) c++;
}
}
cout << (r + c) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5, MOD = 1e9 + 7;
int add(int first, int second) {
first += second;
if (first >= MOD) first -= MOD;
return first;
}
int mult(long long first, long long second) { return first * second % MOD; }
int pot(int n, int k) {
if (k < 0) return pot(pot(n, abs(k)), MOD - 2);
if (k == 0) return 1;
int ret = pot(n, k / 2);
ret = mult(ret, ret);
if (k % 2) ret = mult(ret, n);
return ret;
}
int divide(int first, int second) { return mult(first, pot(second, MOD - 2)); }
int n, w, a, b;
int F[maxn];
int choose(int n, int k) {
if (n < k) return 0;
return divide(F[n], mult(F[k], F[n - k]));
}
int main() {
scanf("%d %d %d %d", &n, &w, &a, &b);
F[0] = 1;
for (int i = 1; i < maxn; i++) F[i] = mult(F[i - 1], i);
int ans = 0;
for (int k = 2; k <= n; k++) {
int sum = mult(k, pot(n, n - k - 1));
sum = mult(sum, pot(w, n - k));
sum = mult(sum, divide(F[n - 2], F[n - k]));
sum = mult(sum, choose(w - 1, k - 2));
ans = add(ans, sum);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
long long a[N], dp[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 2; i++) {
if (a[i] == 1 && a[i + 1] == 0 && a[i + 2] == 1) {
if (dp[i] == 0) {
dp[i + 2] = 1;
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (dp[i] == 1) ans++;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using i32 = int32_t;
using ui32 = uint32_t;
using i64 = int64_t;
using ui64 = uint64_t;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
static int constexpr dbg = 0;
ll constexpr NM = 1e5 + 9, Mo = 1e9 + 9;
struct C {
bool rmed;
int pre, post;
ll x, y;
} cubs[NM];
int m;
map<pll, int> mp;
bool free(int i) {
if (cubs[i].rmed) return false;
if (!cubs[i].post) return true;
auto x = cubs[i].x, y = cubs[i].y;
for (int i = -1; i <= 1; ++i) {
if (mp.count(make_pair(x + i, y + 1))) {
auto idx = mp[make_pair(x + i, y + 1)];
if (cubs[idx].pre <= 1) return false;
}
}
return true;
}
int main(int argc, char *argv[]) {
if (!dbg) {
std::ios::sync_with_stdio(false);
}
cin >> m;
for (int i = 1; i <= (int)(m); ++i) {
ll x, y;
cin >> x >> y;
cubs[i].x = x;
cubs[i].y = y;
mp[make_pair(x, y)] = i;
}
for (int i = 1; i <= (int)(m); ++i) {
ll x, y;
x = cubs[i].x;
y = cubs[i].y;
if (!y) continue;
for (int j = -1; j <= 1; ++j) {
if (mp.count(make_pair(x + j, y - 1))) {
++cubs[mp[make_pair(x + j, y - 1)]].post;
++cubs[i].pre;
}
}
}
set<int> q;
for (int i = 1; i <= (int)(m); ++i) {
if (free(i)) q.insert(i);
}
ll res = 0;
bool mx = true;
while (!q.empty()) {
int i;
if (mx) {
i = *q.rbegin();
} else {
i = *q.begin();
}
q.erase(i);
if (!free(i)) continue;
mx = !mx;
do {
if (dbg) printf("D: %d\n", i);
} while (0);
res = (res * m + (i - 1)) % Mo;
ll x, y;
x = cubs[i].x, y = cubs[i].y;
mp.erase(make_pair(x, y));
cubs[i].rmed = true;
for (int j = -1; j <= 1; ++j) {
if (mp.count(make_pair(x + j, y + 1))) {
auto idx = mp[make_pair(x + j, y + 1)];
if (cubs[idx].rmed) continue;
--cubs[idx].pre;
--cubs[i].post;
if (free(idx)) q.insert(idx);
}
}
if (!y) continue;
for (int j = -1; j <= 1; ++j) {
if (mp.count(make_pair(x + j, y - 1))) {
auto idx = mp[make_pair(x + j, y - 1)];
if (cubs[idx].rmed) continue;
--cubs[idx].post;
--cubs[i].pre;
if (free(idx)) q.insert(idx);
}
}
}
cout << res << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
int A[1002][1002];
long long S1[1002][1002], S2[1002][1002], H[1002][1002];
long long P1[1002][1002], P2[1002][1002];
long long maxres = -1, ri, rj;
inline int mabs(int x) { return x < 0 ? -x : x; }
int main() {
cin >> N >> M >> K;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
cin >> A[i][j];
S1[i][j] = S1[i - 1][j - 1] + A[i][j];
S2[i][j] = S2[i - 1][j + 1] + A[i][j];
H[i][j] = H[i - 1][j] + A[i][j];
}
for (int i = K; i <= N - K + 1; ++i) {
for (int j = K; j <= M - K + 1; ++j) {
if (j == K) {
for (int k = j - K + 1; k <= j; ++k)
for (int l = i - mabs(k - (j - K + 1));
l <= i + mabs(k - (j - K + 1)); ++l)
P1[i][j] += A[l][k];
continue;
}
P1[i][j] = P1[i][j - 1] - (S2[i][j - K] - S2[i - K][j]) -
(S1[i + K - 1][j - 1] - S1[i - 1][j - K - 1]) + A[i][j - K] +
H[i + K - 1][j] - H[i - K][j];
}
for (int j = M - K + 1; j >= K; --j) {
if (j == M - K + 1) {
for (int k = j; k <= j + K - 1; ++k)
for (int l = i - mabs(k - (j + K - 1));
l <= i + mabs(k - (j + K - 1)); ++l)
P2[i][j] += A[l][k];
continue;
}
P2[i][j] = P2[i][j + 1] - (S1[i][j + K] - S1[i - K][j]) -
(S2[i + K - 1][j + 1] - S2[i - 1][j + K + 1]) + A[i][j + K] +
H[i + K - 1][j] - H[i - K][j];
}
}
for (int i = K; i <= N - K + 1; ++i) {
long long resnow = 0;
for (int j = K; j <= M - K + 1; ++j) {
if (j == K) {
for (int k = j - K + 1; k <= j; ++k)
for (int l = i - mabs(k - (j - K + 1));
l <= i + mabs(k - (j - K + 1)); ++l)
resnow += 1LL * A[l][k] * max(0, K - mabs(i - l) - mabs(j - k));
for (int k = j + 1; k <= j + K - 1; ++k)
for (int l = i - mabs(k - (j + K - 1));
l <= i + mabs(k - (j + K - 1)); ++l)
resnow += 1LL * A[l][k] * max(0, K - mabs(i - l) - mabs(j - k));
if (resnow > maxres) {
maxres = resnow;
ri = i, rj = j;
}
continue;
}
resnow -= P1[i][j - 1];
resnow += P2[i][j];
if (resnow > maxres) {
maxres = resnow;
ri = i, rj = j;
}
}
}
cout << ri << ' ' << rj << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> x[110000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i].first >> x[i].second;
}
sort(x, x + n);
for (int i = 1; i < n; i++) {
if (x[i].second < x[i - 1].second && x[i - 1].first < x[i].first) {
cout << "Happy Alex" << endl;
return 0;
}
}
cout << "Poor Alex" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> ans;
for (int i = 0; i < n; i++) {
bool tr = 1;
for (int j = 0; j < n; j++) {
int x;
cin >> x;
if (x == 1 || x == 3) tr = 0;
}
if (tr) ans.push_back(i + 1);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int G[100005], start[100005], ans[100005];
int main() {
int n, m, tmp;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) ans[i] = i;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < m; j++) {
if (i != n)
scanf("%d", &tmp);
else
tmp = -1;
if (tmp >= G[j])
G[j] = tmp;
else {
for (int k = start[j]; k < i; k++)
if (i > ans[k]) ans[k] = i - 1;
start[j] = i;
G[j] = tmp;
}
}
}
int h, l, r;
scanf("%d", &h);
for (int i = 0; i < h; i++) {
scanf("%d%d", &l, &r);
if (ans[l - 1] >= r - 1)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 3e5 + 5;
int a[maxn], p[maxn], n;
pair<int, int> val[maxn << 2], s[maxn << 2];
void push_up(int rt) { val[rt] = max(val[rt << 1], val[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
val[rt].first = a[l];
val[rt].second = l;
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
push_up(rt);
}
pair<int, int> query(int l, int r, int rt, int L, int R) {
if (L <= l && R >= r) return val[rt];
int m = l + r >> 1;
pair<int, int> res = {0, 0};
if (L <= m) res = max(res, query(l, m, rt << 1, L, R));
if (m < R) res = max(res, query(m + 1, r, rt << 1 | 1, L, R));
return res;
}
void update(int l, int r, int rt, int x, int v) {
if (l == r) {
val[rt].first = v;
return;
}
int m = l + r >> 1;
if (x <= m)
update(l, m, rt << 1, x, v);
else
update(m + 1, r, rt << 1 | 1, x, v);
push_up(rt);
}
void update2(int l, int r, int rt, int x, int v) {
if (l == r) {
s[rt] = {v, x};
return;
}
int m = l + r >> 1;
if (x <= m)
update2(l, m, rt << 1, x, v);
else
update2(m + 1, r, rt << 1 | 1, x, v);
s[rt] = max(s[rt << 1], s[rt << 1 | 1]);
}
pair<int, int> query2(int l, int r, int rt, int L, int R) {
if (L <= l && R >= r) return s[rt];
int m = l + r >> 1;
pair<int, int> res = {0, 0};
if (L <= m) res = max(res, query2(l, m, rt << 1, L, R));
if (m < R) res = max(res, query2(m + 1, r, rt << 1 | 1, L, R));
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) scanf("%d", p + i);
build(1, n, 1);
printf("%d", val[1].first);
for (int i = 1; i < n; ++i) {
pair<int, int> lst = query2(1, n, 1, 1, p[i]), t;
while (lst.first > p[i]) {
update2(1, n, 1, lst.second, p[i]);
p[i] = lst.first;
lst = query2(1, n, 1, 1, p[i]);
}
t = query(1, n, 1, 1, p[i]);
update2(1, n, 1, t.second, p[i]);
update(1, n, 1, t.second, 0);
printf(" %d", val[1].first);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("input", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const long long N = (long long)2e5 + 7;
const long long B = 30;
long long n, q, a[N], b[N];
long long lazy[4 * N];
void push(long long v, long long tl, long long tr) {
if (!lazy[v]) return;
if (tl == tr) {
a[tl] ^= lazy[v];
} else {
lazy[2 * v] ^= lazy[v];
lazy[2 * v + 1] ^= lazy[v];
}
lazy[v] = 0;
}
void xor_range(long long v, long long tl, long long tr, long long l,
long long r, long long x) {
push(v, tl, tr);
if (tr < l || r < tl) return;
if (l <= tl && tr <= r) {
lazy[v] ^= x;
push(v, tl, tr);
} else {
long long tm = (tl + tr) / 2;
xor_range(2 * v, tl, tm, l, r, x);
xor_range(2 * v + 1, tm + 1, tr, l, r, x);
}
}
void xor_range(long long l, long long r, long long x) {
xor_range(1, 1, n, l, r, x);
}
long long get_a(long long v, long long tl, long long tr, long long i) {
push(v, tl, tr);
if (tl == tr) return a[tl];
long long tm = (tl + tr) / 2;
if (i <= tm) return get_a(2 * v, tl, tm, i);
return get_a(2 * v + 1, tm + 1, tr, i);
}
long long get_a(long long i) { return get_a(1, 1, n, i); }
struct T {
long long val[B];
T() {
for (long long i = 0; i < B; i++) val[i] = 0;
}
};
T operator+(T ret, T b) {
for (long long j = 0; j < B; j++) {
if (!b.val[j]) continue;
long long x = b.val[j];
for (long long bit = 0; bit < B; bit++) {
if (x & (1 << bit)) x ^= ret.val[bit];
}
if (x) {
for (long long bit = 0; bit < B; bit++) {
if (x & (1 << bit)) {
assert(ret.val[bit] == 0);
ret.val[bit] = x;
break;
}
}
}
}
return ret;
}
T t[4 * N];
void build(long long v, long long tl, long long tr) {
if (tl == tr) {
if (b[tl]) {
for (long long bit = 0; bit < B; bit++) {
if (b[tl] & (1 << bit)) {
t[v].val[bit] = b[tl];
break;
}
}
}
} else {
long long tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
t[v] = t[2 * v] + t[2 * v + 1];
}
}
void upd(long long v, long long tl, long long tr, long long i, long long x) {
if (tr < i || i < tl) {
assert(0);
}
if (tl == tr) {
b[tl] ^= x;
for (long long bit = 0; bit < B; bit++) t[v].val[bit] = 0;
if (b[tl]) {
for (long long bit = 0; bit < B; bit++) {
if (b[tl] & (1 << bit)) {
t[v].val[bit] = b[tl];
break;
}
}
}
return;
}
long long tm = (tl + tr) / 2;
if (i <= tm) {
upd(2 * v, tl, tm, i, x);
} else {
upd(2 * v + 1, tm + 1, tr, i, x);
}
t[v] = t[2 * v] + t[2 * v + 1];
}
void upd(long long i, long long x) { upd(1, 1, n, i, x); }
T get(long long v, long long tl, long long tr, long long l, long long r) {
if (tr < l || r < tl) {
assert(0);
}
if (l <= tl && tr <= r) {
return t[v];
}
long long tm = (tl + tr) / 2;
if (r <= tm) return get(2 * v, tl, tm, l, r);
if (tm + 1 <= l) return get(2 * v + 1, tm + 1, tr, l, r);
return get(2 * v, tl, tm, l, r) + get(2 * v + 1, tm + 1, tr, l, r);
}
T get(long long l, long long r) { return get(1, 1, n, l, r); }
signed realMain() {
cin >> n >> q;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
b[i] = a[i - 1] ^ a[i];
}
build(1, 1, n);
while (q--) {
long long type;
cin >> type;
if (type == 1) {
long long l, r, x;
cin >> l >> r >> x;
xor_range(l, r, x);
upd(l, x);
if (r + 1 <= n) {
upd(r + 1, x);
}
} else {
long long l, r, x;
cin >> l >> r;
x = get_a(l);
if (l == r) {
if (x == 0) {
cout << "1\n";
} else {
cout << "2\n";
}
continue;
}
T ret = get(l + 1, r);
for (long long bit = 0; bit < B; bit++) {
if (x & (1 << bit)) x ^= ret.val[bit];
}
if (x) {
for (long long bit = 0; bit < B; bit++) {
if (x & (1 << bit)) {
ret.val[bit] = x;
break;
}
}
}
long long cnt = 0;
for (long long bit = 0; bit < B; bit++) {
cnt += (ret.val[bit] > 0);
}
cout << (1 << cnt) << "\n";
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
const int inf = 0x3f3f3f3f;
int n, m, q, col;
int x, y, z, a[N << 1];
char S[5];
inline int min(int u, int v) { return u < v ? u : v; }
inline int max(int u, int v) { return u > v ? u : v; }
int to[N << 1], las[N << 1], fir[N << 1], cnt;
inline void add_edge(int u, int v) {
to[++cnt] = v;
las[cnt] = fir[u];
fir[u] = cnt;
to[++cnt] = u;
las[cnt] = fir[v];
fir[v] = cnt;
}
int _to[N << 2], _las[N << 2], _fir[N << 2], _cnt;
inline void Add_edge(int u, int v) {
_to[++_cnt] = v;
_las[_cnt] = _fir[u];
_fir[u] = _cnt;
_to[++_cnt] = u;
_las[_cnt] = _fir[v];
_fir[v] = _cnt;
}
int dfn[N], low[N], Cnt;
int zn[N], Tot;
multiset<int> s[N << 1];
void tj(int u) {
dfn[u] = low[u] = ++Cnt;
zn[++Tot] = u;
for (int i = fir[u]; i; i = las[i]) {
if (!dfn[to[i]]) {
tj(to[i]);
low[u] = min(low[u], low[to[i]]);
if (dfn[u] <= low[to[i]]) {
++col;
do {
z = zn[Tot];
Add_edge(col, z);
s[col].insert(a[z]);
--Tot;
} while (z != to[i]);
Add_edge(col, u);
s[col].insert(a[u]);
}
} else
low[u] = min(low[u], dfn[to[i]]);
}
}
int fa[N << 1], dep[N << 1], siz[N << 1], son[N << 1];
void dfs1(int u, int v) {
fa[u] = v;
dep[u] = dep[v] + 1;
siz[u] = 1;
for (int i = _fir[u]; i; i = _las[i])
if (_to[i] != v) {
dfs1(_to[i], u);
siz[u] += siz[_to[i]];
if (siz[son[u]] < siz[_to[i]]) son[u] = _to[i];
}
}
int top[N << 1], bh[N << 1], rnk[N << 1], BH;
void dfs2(int u, int v) {
top[u] = v;
bh[u] = ++BH;
rnk[BH] = u;
if (son[u]) dfs2(son[u], v);
for (int i = _fir[u]; i; i = _las[i])
if (_to[i] != fa[u] && _to[i] != son[u]) dfs2(_to[i], _to[i]);
}
int tre[N << 4];
void mktree(int now, int ls, int rs) {
if (ls == rs) {
tre[now] = a[rnk[ls]];
return;
}
int noww = now << 1, nrs = ls + rs >> 1;
mktree(noww, ls, nrs);
mktree(noww | 1, nrs + 1, rs);
tre[now] = min(tre[noww], tre[noww | 1]);
}
int qmin(int now, int ls, int rs, int zuo, int you) {
if (ls > you || rs < zuo) return inf;
if (ls >= zuo && rs <= you) return tre[now];
int noww = now << 1, nrs = ls + rs >> 1;
return min(qmin(noww, ls, nrs, zuo, you),
qmin(noww | 1, nrs + 1, rs, zuo, you));
}
void Qmin(int u, int v) {
int ret = inf;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) z = u, u = v, v = z;
ret = min(ret, qmin(1, 1, col, bh[top[u]], bh[u]));
u = fa[top[u]];
}
if (dep[u] < dep[v]) z = u, u = v, v = z;
ret = min(ret, qmin(1, 1, col, bh[v], bh[u]));
if (v > n) ret = min(ret, a[fa[v]]);
printf("%d\n", ret);
}
void change(int now, int ls, int rs, int mb, int val) {
if (ls > mb || rs < mb) return;
if (ls == rs) {
z = tre[now];
tre[now] = a[rnk[ls]] = val;
return;
}
int noww = now << 1, nrs = ls + rs >> 1;
change(noww, ls, nrs, mb, val);
change(noww | 1, nrs + 1, rs, mb, val);
tre[now] = min(tre[noww], tre[noww | 1]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add_edge(x, y);
}
col = n;
tj(1);
dfs1(1, 0);
dfs2(1, 1);
for (int i = n + 1; i <= col; i++) {
s[i].erase(s[i].find(a[fa[i]]));
a[i] = *s[i].begin();
}
mktree(1, 1, col);
for (int i = 1; i <= q; i++) {
scanf("%s%d%d", S, &x, &y);
if (S[0] == 'A') {
Qmin(x, y);
} else {
change(1, 1, col, bh[x], y);
if (x == 1) continue;
s[fa[x]].erase(s[fa[x]].find(z));
s[fa[x]].insert(y);
change(1, 1, col, bh[fa[x]], *s[fa[x]].begin());
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
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;
}
int n, sz, k, mn = 1 << 30;
int tr[2000200][26];
int ans[2000200], val;
int merge(int u, int v) {
if (!(u * v)) return u + v;
val++;
int now = ++sz;
for (int i = 0; i < 26; i++) tr[now][i] = merge(tr[u][i], tr[v][i]);
return now;
}
void dfs(int u, int dep) {
int now = ++sz;
val = 0;
for (int i = 0; i < 26; i++) now = merge(now, tr[u][i]);
ans[dep] += val;
for (int i = 0; i < 26; i++)
if (tr[u][i]) dfs(tr[u][i], dep + 1);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int a = read(), b = read();
char s[10];
scanf("%s", s);
int c = s[0] - 'a';
tr[a][c] = b;
}
sz = n;
dfs(1, 1);
for (int i = 1; i <= n; i++)
if (n - ans[i] < mn) mn = n - ans[i], k = i;
printf("%d\n%d\n", mn, k);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ch[4200000][2], cnt;
long long get(long long n) {
int i, t = 0, j;
long long ans = 0;
for (i = 40; i >= 0; i--) {
if (n & (1ll << i))
j = 1;
else
j = 0;
if (ch[t][!j])
t = ch[t][!j], ans += (1ll << i);
else
t = ch[t][j];
}
return ans;
}
void ins(long long n) {
int i, t = 0, j;
for (i = 40; i >= 0; i--) {
if (n & (1ll << i))
j = 1;
else
j = 0;
if (ch[t][j])
t = ch[t][j];
else
ch[t][j] = ++cnt, t = cnt;
}
}
long long a[110000];
int main() {
int n, i, j;
cin >> n;
long long s = 0;
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
s ^= a[i];
}
ins(s);
long long tmp, ans = 0, now = 0;
for (i = 1; i <= n; i++) {
now ^= a[i];
tmp = get(now);
if (tmp > ans) ans = tmp;
ins(now ^ s);
}
if (s > ans) ans = s;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class _T>
inline _T low(_T n) {
return n & (-n);
}
template <class _T>
inline void swapp(_T &x, _T &y) {
_T t;
t = x, x = y, y = t;
}
template <class _T>
inline _T minn(_T i, _T j) {
return i > j ? j : i;
}
template <class _T>
inline _T maxx(_T i, _T j) {
return i > j ? i : j;
}
template <class _T>
inline _T gcd(_T b, _T c) {
return b && c ? (c ? gcd(c, b % c) : b) : b | c;
}
template <class _T>
inline _T abss(_T b) {
return b > 0 ? b : -b;
}
bool dp[2002][2002] = {0};
bool a[2002][2002];
char c[2002];
int n;
void RE(int x, int y) {
if (dp[x][y])
dp[x][y] = false;
else
dp[x][y] = true;
}
void A(int x, int y) {
if (x == y)
RE(x, y);
else if (abss(x - y) == 1) {
RE(x, y);
a[x][x] = !a[x][x];
a[y][y] = !a[y][y];
} else {
RE(x, y);
if (x > y) {
RE(x - 1, y);
RE(x, y + 1);
RE(x - 1, y + 1);
a[x - 1][y + 1] = !a[x - 1][y + 1];
} else {
RE(x + 1, y);
RE(x, y - 1);
RE(x + 1, y - 1);
a[x + 1][y - 1] = !a[x + 1][y - 1];
}
}
}
int main() {
int i, j, s = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", c);
for (j = 0; j < n; j++)
if (c[j] == '0')
a[i][j] = false;
else
a[i][j] = true;
}
for (i = n - 1; i > 0; i--) {
for (j = 0; j + i < n; j++) {
if (a[j][i + j]) A(j, i + j);
if (a[i + j][j]) A(i + j, j);
}
}
for (i = 0; i < n; i++)
if (a[i][i]) A(i, i);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (dp[i][j]) s++;
printf("%d\n", s);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
const int MAXN = 2e5 + 10, MAXQ = 3e5 + 10, MAXL = 18, ALP = 26, MOD = 1e9 + 7,
MAXK = 1e2 + 10, MAXA = 10, MAXB = 24, MAXBB = (1 << MAXB);
const string no = "NO\n", yes = "YES\n";
const int hA[4] = {1, 0, -1, 0}, kA[4] = {0, 1, 0, -1};
const long long INF = 1e9 + 10;
long long po(long long b, long long p) {
long long r = 1;
for (; p; b = b * b % MOD, p >>= 1)
if (p & 1) r = r * b % MOD;
return r;
}
void solve() {
int n;
cin >> n;
vector<int> deg(n);
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (c != -1) deg[c - 1]++;
}
long long ans = po(2, n - 1) - 1;
for (int i = 0; i < n; i++) {
if (deg[i]) {
ans -= po(2, deg[i]) - 1;
ans %= MOD, ans += MOD, ans %= MOD;
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t_c = 1;
while (t_c--) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 51;
const int M = 123;
const double Pi = acos(-1);
const long long Inf = 1e18;
const int inf = 1e9;
const int mod = 1000200013;
const int Sz = 501;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int mult(int a, int b) { return 1ll * a * b % mod; }
int sum(int a, int b) {
add(a, b);
return a;
}
int n, m;
char a[N][N];
vector<pair<int, int> > ans[2], moves;
void rotate(int x, int y) {
if (a[x][y] == 'U') {
if (a[x][y + 1] != 'U') {
rotate(x, y + 1);
}
moves.push_back({x, y});
a[x][y] = a[x + 1][y] = 'L';
a[x][y + 1] = a[x + 1][y + 1] = 'R';
} else {
if (a[x + 1][y] != 'L') {
rotate(x + 1, y);
}
moves.push_back({x, y});
a[x][y] = a[x][y + 1] = 'U';
a[x + 1][y] = a[x + 1][y + 1] = 'D';
}
}
void solve() {
if (m % 2 == 0) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'U') {
rotate(i, j);
}
}
}
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'L') {
rotate(i, j);
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int t = 0; t < 2; t++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
solve();
ans[t] = moves;
moves.clear();
}
reverse(ans[1].begin(), ans[1].end());
cout << ans[0].size() + ans[1].size() << endl;
for (int t = 0; t < 2; t++) {
for (auto i : ans[t]) {
cout << i.first << " " << i.second << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int tab[N];
char slo[N];
void zmien(int i) {
if (slo[i] == '.' && slo[i - 1] == '.')
tab[i] = 1;
else
tab[i] = 0;
}
int main() {
int suma = 0;
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", slo + 1);
for (int i = 1; i <= n; i++) {
zmien(i);
suma += tab[i];
}
for (int i = 0; i < k; i++) {
char x;
int a;
scanf("%d %c", &a, &x);
suma -= tab[a];
suma -= tab[a + 1];
slo[a] = x;
zmien(a);
zmien(a + 1);
suma += tab[a];
suma += tab[a + 1];
printf("%d\n", suma);
}
}
| 4 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::map;
using std::max;
using std::min;
using std::multiset;
using std::pair;
using std::queue;
using std::set;
using std::sort;
using std::stack;
using std::string;
using std::vector;
int n, m, k;
int capital[1001] = {
0,
};
int color[1001] = {
0,
};
int cnt[1001] = {
0,
};
vector<int> g[1001];
int MAXindex;
int MAX = -1;
void dfs(int from, int curCOLOR) {
color[from] = curCOLOR;
for (int i = 0; i < g[from].size(); i++) {
int to = g[from][i];
if (color[to] == 0) {
dfs(to, curCOLOR);
}
}
cnt[curCOLOR]++;
if (cnt[curCOLOR] > MAX) {
MAXindex = from;
MAX = cnt[curCOLOR];
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
capital[x] = 1;
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (capital[i]) {
dfs(i, i);
}
}
int answer = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == 0) {
color[i] = MAXindex;
cnt[MAXindex]++;
MAX++;
}
}
for (int i = 1; i <= n; i++) {
answer += cnt[color[i]] - 1 - g[i].size();
}
cout << answer / 2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<int> v;
int i = 0;
while (i < s.length()) {
if (s[i] == '.') {
v.push_back(0);
i++;
} else if (s[i] == '-' && s[i + 1] == '.') {
v.push_back(1);
i += 2;
} else if (s[i] == '-' && s[i + 1] == '-') {
v.push_back(2);
i += 2;
}
}
for (int x : v) {
cout << x;
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u >> 2;
char s[55][55];
int a[55][55][4], n, k;
int judge(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= k) return 0;
if (s[x][y] == '0') return 0;
return 1;
}
int main() {
int i, j, m, g;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> s[i];
k = strlen(s[1]);
for (i = 0; i < n; i++) {
for (j = 0; j < k; j++) {
for (g = j; g >= 0; g--)
if (s[i][g] != s[i][j]) break;
a[i][j][3] = g + 1;
for (g = i; g >= 0; g--)
if (s[g][j] != s[i][j]) break;
a[i][j][0] = g + 1;
for (g = j; g < k; g++)
if (s[i][g] != s[i][j]) break;
a[i][j][1] = g - 1;
for (g = i; g < n; g++)
if (s[g][j] != s[i][j]) break;
a[i][j][2] = g - 1;
}
}
int d1 = 1, d2 = 0, x = 0, y = 0;
char c = s[0][0];
int k1 = 1;
while (k1 <= m) {
if (d1 == 0 || d1 == 2)
x = a[x][y][d1];
else
y = a[x][y][d1];
if (d2 == 0 || d2 == 2)
x = a[x][y][d2];
else
y = a[x][y][d2];
int tx, ty;
if (d1 == 0) {
tx = x - 1;
ty = y;
} else if (d1 == 1) {
tx = x;
ty = y + 1;
} else if (d1 == 2) {
tx = x + 1;
ty = y;
} else {
tx = x;
ty = y - 1;
}
if (!judge(tx, ty)) {
if ((d2 + 1) % 4 == d1)
d2 = (d1 + 1) % 4;
else {
d1 = (d1 + 1) % 4;
d2 = (d1 - 1 + 4) % 4;
}
} else {
c = s[tx][ty];
x = tx, y = ty;
}
k1++;
}
cout << c << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, res = 0, x, k, l, a[10100];
bool b[10100] = {false};
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
k = 0;
while (x > 0) {
k += x % 10;
x = x / 10;
}
a[i] = k;
}
for (i = 1; i < n; i++)
if (b[i] == false) {
for (j = i + 1; j <= n; j++)
if ((a[i] + a[j]) % 3 == 0 && b[j] == false) {
b[i] = true;
b[j] = true;
res++;
break;
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 2e5 + 10;
int n, a[N], pos, cnt[N];
int pre[N << 1];
inline int calc(int x) {
for (register int i = (0); i <= (2 * n); i++) pre[i] = -1;
pre[n] = 0;
int s = 0, ans = 0;
for (register int i = (1); i <= (n); i++) {
if (a[i] == pos) ++s;
if (a[i] == x) --s;
if (pre[s + n] == -1)
pre[s + n] = i;
else
ans = max(ans, i - pre[s + n]);
}
return ans;
}
int main() {
n = read();
for (register int i = (1); i <= (n); i++) a[i] = read(), cnt[a[i]]++;
int mx = 0, tot = 0;
for (register int i = (1); i <= (n); i++) {
if (cnt[i] > mx)
mx = cnt[i], pos = i, tot = 1;
else if (cnt[i] == mx)
++tot;
}
if (tot > 1) return printf("%d\n", n), 0;
int ans = 0;
for (register int i = (1); i <= (n); i++)
if (cnt[i] && i != pos) ans = max(ans, calc(i));
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= (n - i); j++) {
if (i * 4 + j * 7 == n) {
for (int k = 1; k <= i; k++) printf("4");
for (int k = 1; k <= j; k++) printf("7");
return 0;
}
}
puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int min1(int a, int b) {
if (a > b)
return b;
else
return a;
}
int a[100];
int b[100];
int p[100][100];
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 0; i < m; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> p[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (p[i][j] == 1) p[i][j] = min1(a[j], b[i]);
cout << p[i][j];
if (j == (m - 1))
cout << endl;
else
cout << " ";
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.