solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const LL mod = 1E9 + 7;
const int maxn = 100100;
int n;
char s[maxn];
map<char, LL> vis;
LL mul(LL x, LL n) {
LL ret = 1;
while (n) {
if (n & 1) {
ret = ret * x % mod;
}
n >>= 1;
x = x * x % mod;
}
return ret;
}
signed main() {
while (~scanf("%d", &n)) {
scanf("%s", s);
LL ret = 0;
vis.clear();
for (int i = 0; i < n; i++) {
vis[s[i]]++;
}
LL hi = -1E12;
for (auto x : vis) {
hi = max(hi, x.second);
}
for (auto x : vis) {
if (x.second == hi) {
ret++;
}
}
cout << mul(ret, n) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, n, m, a;
while (cin >> n) {
long long t[100005] = {0};
long long dp[100005] = {0};
m = 0;
for (i = 1; i <= n; i++) {
cin >> a;
if (a > m) m = a;
t[a]++;
}
dp[0] = 0;
dp[1] = t[1];
for (i = 2; i <= m; i++) {
dp[i] = max(dp[i - 2] + i * t[i], dp[i - 1]);
}
cout << dp[m] << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string scale, right, left, input;
int target;
cin >> scale;
cin >> input;
target = scale.find("|");
left = scale.substr(0, target);
right = scale.substr(target + 1);
for (auto pointer : input)
if (left.size() <= right.size())
left += pointer;
else
right += pointer;
cout << (left.size() == right.size() ? left + "|" + right : "Impossible");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
vector<long long> pow2, preSum;
void power() {
for (long long i = 1, j = 0; j < 63; i *= 2, j++) {
pow2.push_back(i);
}
preSum.push_back(1);
long long total_sum = 1;
for (long long i = 2; i < 64; i++) {
preSum.push_back(i + 2 * total_sum);
total_sum = preSum[i - 1];
}
}
void solve() {
long long n;
cin >> n;
long long res = 0;
while (n > 0) {
if (n == 1) {
res++;
break;
}
long long l = 0, h = 64;
long long m = (l + h) / 2;
while (l < h) {
if (pow2[m] > n)
h = m - 1;
else if (pow2[m] < n)
l = m + 1;
else
break;
m = (l + h) / 2;
}
if (pow2[m] > n) {
m--;
}
n -= pow2[m];
res += m + 1;
res += preSum[m - 1];
}
cout << res << endl;
}
int32_t main() {
long long t;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
power();
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1000;
struct item {
int d, w, pos;
bool operator<(const item &e) const {
return w > e.w || (w == e.w && d > e.d);
}
} a[maxn];
multiset<item> ss;
vector<int> in[maxn], out[maxn];
long long dp[maxn][300];
long long nxt[maxn], val[maxn];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int s, t, w, d;
cin >> s >> t >> d >> w;
in[s].push_back(i), out[t + 1].push_back(i);
a[i] = (item){d, w, i};
}
for (int i = 1; i <= n; i++) {
for (int &x : in[i]) ss.insert(a[x]);
for (int &x : out[i]) ss.erase(ss.lower_bound(a[x]));
if (ss.size()) {
nxt[i] = ss.begin()->d + 1;
val[i] = ss.begin()->w;
} else
nxt[i] = i + 1;
}
for (int i = 2; i <= n + 1; i++)
for (int j = 0; j <= m; j++) dp[i][j] = 1E18;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
dp[nxt[i]][j] = min(dp[nxt[i]][j], dp[i][j] + val[i]);
if (j) dp[i + 1][j - 1] = min(dp[i][j], dp[i + 1][j - 1]);
}
}
cout << *min_element(dp[n + 1], dp[n + 1] + m + 1);
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18;
template <typename T>
void read(T &x) {
x = 0;
int s = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') s = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
x *= s;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
int n, m, k;
char s[105];
int ans, val[105];
bool flag1, flag2;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> s;
val[i] = -1;
int f1 = -1, f2 = -1, tmp = 0;
for (int j = 0; j <= m - 1; j++)
if (s[j] == 'G')
f1 = j;
else if (s[j] == 'R')
f2 = j;
else
tmp++;
if (tmp == 0 || tmp == m) continue;
if (f1 >= 0 && f2 >= 0) {
val[i] = abs(f2 - f1) - 1;
} else if (f1 < 0) {
flag2 = 1;
} else
flag1 = 1;
}
if (!flag1 && !flag2) {
int tmp[10] = {0};
for (int i = 1; i <= n; i++)
if (val[i] > 0) {
int cnt = 0;
for (int j = val[i]; j; j >>= 1) tmp[cnt++] += j % 2;
}
for (int i = 0; i <= 9; i++)
if (tmp[i] % (k + 1) != 0) {
flag1 = 1;
}
cout << (flag1 ? "First\n" : "Second\n");
} else if (flag1 && flag2) {
cout << "Draw\n";
} else
cout << (flag1 ? "First\n" : "Second\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 10;
int A, B;
long long sum(int x) {
return (long long)A * x + (long long)B * ((long long)x * (x - 1) / 2);
}
long long sum(int x, int y) { return sum(y) - sum(x - 1); }
bool check(int l, int r, int m, int t) {
long long s = sum(l, r);
if (s > (long long)m * t) return 0;
if (A + (long long)(r - 1) * B > t) return 0;
return 1;
}
int main() {
int Q;
scanf("%d%d%d", &A, &B, &Q);
while (Q--) {
int x, t, m;
scanf("%d%d%d", &x, &t, &m);
if (t < A + (long long)(x - 1) * B) {
printf("-1\n");
continue;
}
int l = x, r = (t - A) / B + 3;
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(x, mid, m, t))
l = mid;
else
r = mid;
}
printf("%d\n", l);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int st[200001];
long long int a[200001];
long long int et[200001];
long long int parent[200001];
long long int w[200001];
long long int A[200001];
vector<int> graph[200001];
bool visit[200001] = {0};
long long int indexs = 0;
long long dist[200001] = {0};
vector<long long int> tree[1000001];
void merge(long long int x, long long int a, long long int b) {
long long int i = 0, j = 0, idx = -1;
while (i < tree[a].size() && j < tree[b].size()) {
if (tree[a][i] <= tree[b][j])
tree[x].push_back(tree[a][i++]);
else
tree[x].push_back(tree[b][j++]);
}
while (i < tree[a].size()) tree[x].push_back(tree[a][i++]);
while (j < tree[b].size()) tree[x].push_back(tree[b][j++]);
}
void build(long long int node, long long int i, long long int j) {
if (i > j) return;
if (i == j) {
tree[node].push_back(A[j]);
return;
}
long long int mid = (i + j) / 2;
build(2 * node, i, mid);
build(2 * node + 1, mid + 1, j);
merge(node, 2 * node, 2 * node + 1);
}
vector<long long int>::iterator srch;
long long int query(long long int node, long long int i, long long int j,
long long int l, long long int r, long long int val) {
if (i > r || j < l || i > j) return 0LL;
assert(tree[node].size() > 0);
if (i >= l && j <= r) {
srch = upper_bound(tree[node].begin(), tree[node].end(), val);
if (srch == tree[node].end()) return tree[node].size();
if (*srch > val && srch == tree[node].begin()) return 0LL;
if (*srch > val) --srch;
return (long long int)(srch - tree[node].begin() + 1);
}
long long int mid = (i + j) / 2;
return query(2 * node, i, mid, l, r, val) +
query(2 * node + 1, mid + 1, j, l, r, val);
}
void dfs(long long int node) {
visit[node] = 1;
st[node] = ++indexs;
for (long long int i : graph[node]) {
if (visit[i] == 0) {
dist[i] = w[i] + dist[node];
dfs(i);
}
}
et[node] = indexs;
}
int main() {
long long int n;
scanf("%lld", &n);
for (long long int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long int i = 2; i <= n; i++) {
scanf("%lld%lld", &parent[i], &w[i]);
graph[parent[i]].push_back(i);
graph[i].push_back(parent[i]);
}
dfs(1);
for (long long int i = 1; i <= n; i++) {
A[st[i]] = dist[i] - a[i];
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (st[i] + 1 > et[i])
printf("0 ");
else
printf("%lld ", query(1, 1, n, st[i] + 1, et[i], dist[i]));
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int INF = 1e9;
int const N = 1e5 + 16;
int const M = 1e9 + 7;
int n, k, p;
int a[2][N];
int cnt[2];
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
a[x & 1][cnt[x & 1]++] = x;
}
int odd = k - p;
if (cnt[1] < odd || ((cnt[1] - odd) & 1) || cnt[0] + (cnt[1] - odd) / 2 < p)
puts("NO"), exit(0);
puts("YES");
if (p) {
while (odd--) printf("1 %d\n", a[1][--cnt[1]]);
} else {
while (odd--) {
if (odd == 0) {
int z = cnt[0];
printf("%d", cnt[1] + cnt[0]);
while (cnt[1]) printf(" %d", a[1][--cnt[1]]);
while (cnt[0]) printf(" %d", a[0][--cnt[0]]);
} else {
printf("1 %d\n", a[1][--cnt[1]]);
}
}
}
while (p--) {
if (p == 0) {
printf("%d", cnt[0] + cnt[1]);
while (cnt[0]) printf(" %d", a[0][--cnt[0]]);
while (cnt[1]) printf(" %d", a[1][--cnt[1]]);
} else if (cnt[1] >= 2) {
printf("2 %d %d\n", a[1][cnt[1] - 1], a[1][cnt[1] - 2]);
cnt[1] -= 2;
} else {
printf("1 %d\n", a[0][--cnt[0]]);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 1e5 + 1;
const int TMXN = 1e5 * 8 + 1;
const long long INF = pow(2, 64);
const long long INFL = 1e18;
long long n, a, b, c, x, s, f;
bool check(long long big, long long small) { return big >= small; }
long long solve() {
long long x = max(n - b, 0LL) / (b - c);
if (check(n, b)) {
x++;
}
long long maxk = 0;
maxk = max(maxk, x);
maxk = max(maxk, (n - ((b - c) * x)) / a + x);
maxk = max(maxk, n / a);
x = n / a + (max(((n - ((n / a) * a)) - b), 0LL) / (b - c));
if (check((n - ((n / a) * a)), b)) {
x++;
}
maxk = max(maxk, x);
return maxk;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &a, &b, &c);
cout << solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 209;
std::pair<int, int> a[N], last;
int ans = 0x3f3f3f3f, n, c[N][N], f[N][N], m;
int main() {
scanf("%d%d", &n, &m);
memset(c, 0x3f, sizeof c);
memset(f, 0x3f, sizeof f);
for (int i = 1; i <= n; ++i) f[i][i] = 0;
for (int i = 1, x, y, z; i <= m; ++i) {
scanf("%d%d%d", &x, &y, &z);
z *= 2;
if (c[x][y] > z) f[x][y] = f[y][x] = c[x][y] = c[y][x] = z;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k)
f[j][k] = std::min(f[j][k], f[j][i] + f[i][k]);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) a[j] = std::pair<int, int>(f[i][j], j);
std::sort(a + 1, a + 1 + n, std::greater<std::pair<int, int> >());
ans = std::min(ans, a[1].first);
for (int j = i + 1; j <= n; ++j) {
if (c[i][j] == 0x3f3f3f3f) continue;
last = std::pair<int, int>(
a[1].first, (f[j][a[1].second] + c[i][j] - f[i][a[1].second]) / 2);
for (int k = 2; k <= n; ++k) {
int x = (f[j][a[k].second] + c[i][j] - f[i][a[k].second]) / 2;
if (x <= (last.first - a[k].first) / 2 + last.second) continue;
ans = std::min(
ans, (last.first - a[k].first) / 2 + last.second + a[k].first);
last = std::pair<int, int>(a[k].first, x);
}
ans = std::min(ans, last.first + last.second - c[i][j] + last.second);
}
}
printf("%.6f\n", ans / 2.0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
scanf("%d%d%d", &n, &x, &y);
if (x >= n / 2 && x <= n / 2 + 1 && y >= n / 2 && y <= n / 2 + 1)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
char** M = new char*[n];
for (int i = 0; i < n; ++i) {
M[i] = new char[n + 1];
std::cin >> M[i];
}
unsigned long count = 0;
for (int i = 1; i < n - 1; ++i) {
for (int j = 1; j < n - 1; ++j) {
if (M[i][j] == 'X' && M[i - 1][j - 1] == 'X' && M[i - 1][j + 1] == 'X' &&
M[i + 1][j - 1] == 'X' && M[i + 1][j + 1] == 'X') {
++count;
}
}
}
for (int i = 0; i < n; ++i) {
delete[] M[i];
}
delete[] M;
std::cout << count << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[100009][2];
int n;
long long int ar[100009], d[100009];
long long int func(int i, bool tp) {
if (i == n)
return 0ll;
else if (~dp[i][tp])
return dp[i][tp];
if (tp)
return dp[i][tp] = d[i] + max(func(i + 1, !tp), 0ll);
else
return dp[i][tp] = -d[i] + max(func(i + 1, !tp), 0ll);
}
int main() {
int m, a, b, i, j;
long long int r = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &ar[i]);
}
n--;
for (i = 0; i < n; i++) {
d[i] = abs(ar[i] - ar[i + 1]);
}
memset(dp, -1ll, sizeof(dp));
for (i = 0; i < n; i++) {
r = max(r, func(i, 1));
}
printf("%I64d\n", r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long p = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long mx = 2 * 1e5;
vector<long long> a(mx);
a[0] = 1;
a[1] = 1;
a[2] = 2;
for (int i = 3; i < mx; i++) {
a[i] = a[i - 1] + a[i - 2];
a[i] %= p;
}
string s;
cin >> s;
long long n = s.size();
char lst = 'A';
long long cur = 0;
long long ans = 1;
for (int i = 0; i < n; i++) {
if (s[i] == 'm' || s[i] == 'w') {
cout << 0;
return 0;
}
if (s[i] == lst) {
cur++;
} else {
if (lst == 'n' || lst == 'u') {
ans = (ans * a[cur]) % p;
}
cur = 1;
lst = s[i];
}
}
if (lst == 'n' || lst == 'u') {
ans = (ans * a[cur]) % p;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dat[105][105];
vector<int> grf[105];
int dp[2][105][105][30];
int fun(int trn, int apos, int bpos, int c) {
int& ret = dp[trn][apos][bpos][c];
if (ret != -1) return ret;
if (trn == 0) {
bool ok = 0;
for (int i = 0; i < grf[apos].size(); i++) {
int now = grf[apos][i];
int val = dat[apos][now];
if (val >= c) {
int vvv = fun(1, now, bpos, val);
if (vvv == 1) ok = 1;
}
}
if (ok)
ret = 1;
else
ret = 2;
}
if (trn == 1) {
bool ok = 0;
for (int i = 0; i < grf[bpos].size(); i++) {
int now = grf[bpos][i];
int val = dat[bpos][now];
if (val >= c) {
int vvv = fun(0, apos, now, val);
if (vvv == 2) ok = 1;
}
}
if (ok)
ret = 2;
else
ret = 1;
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
char c;
cin >> a >> b >> c;
dat[a][b] = (c - 'a') + 1;
grf[a].push_back(b);
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int ans = fun(0, i, j, 0);
if (ans == 1)
cout << 'A';
else if (ans == 2)
cout << 'B';
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, cc[100001] = {0}, cnt = 0, max = 0, i;
cin >> n;
for (i = 0; i < 2 * n; i++) {
cin >> a;
cc[a]++;
if (cc[a] == 1)
cnt++;
else
cnt--;
if (cnt > max) max = cnt;
}
cout << max << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long expo(long long x, long long y) {
if (y == 1) return x;
if (y % 2 == 1)
return (x * (expo((x * x) % 1000000007, (y - 1) / 2)) % 1000000007) %
1000000007;
else
return (expo((x * x) % 1000000007, y / 2)) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
cin >> t;
while (t--) {
long long a, b, c, d, p;
cin >> a >> b >> c >> d;
string e, f, g, h, x = "Ya", y = "Tidak";
p = a + b;
if (p % 2 == 1) {
g = h = y;
if ((a > 0) || (d > 0))
e = x;
else
e = y;
if ((b > 0) || (c > 0))
f = x;
else
f = y;
} else {
e = f = y;
if ((d > 0) || (a > 0))
h = x;
else
h = y;
if ((c > 0) || (b > 0))
g = x;
else
g = y;
}
cout << e << " " << f << " " << g << " " << h << endl;
}
}
| 2 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int cnt[3];
int32_t main(){
int tt;
cin>>tt;
while(tt--){
// int cnt[3]={0,0,0};
for(int i=0;i<3;i++)cnt[i]=0;
int n;
cin>>n;
char arr[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>arr[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(arr[i][j]=='X')
cnt[(i+j)%3]++;
}
}
int res=min_element(cnt,cnt+3)-cnt;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(arr[i][j]=='X' && (i+j)%3==res)
arr[i][j]='O';
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<arr[i][j];
}
cout<<endl;
}
cout<<endl;
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a;
cin >> a;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '-' && a[i + 1] == '.') {
cout << 1;
i++;
} else if (a[i] == '-' && a[i + 1] == '-') {
cout << 2;
i++;
} else
cout << 0;
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, ans = 0, x;
long long int num = pow(2, 32) - 1;
string s;
stack<long long int> st;
cin >> t;
while (t--) {
if (ans > num) {
cout << "OVERFLOW!!!\n";
return 0;
}
cin >> s;
if (s == "end" && st.empty() == false)
st.pop();
else if (s == "add") {
if (st.empty())
ans += 1;
else {
if (st.top() == -1) {
cout << "OVERFLOW!!!\n";
return 0;
}
ans += st.top();
}
} else if (s == "for") {
cin >> x;
if (!st.empty()) {
long long int y = st.top();
if (y == -1)
x = -1;
else if (y * x > num)
x = -1;
else
x *= y;
}
st.push(x);
}
}
if (ans > num) {
cout << "OVERFLOW!!!\n";
return 0;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int op[] = {-1, 1};
int a[30005], f[30005][205][2][2][2];
void upd(int &x, int y) { x = max(x, y); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
memset(f, -69, sizeof f);
for (int i = 0; i <= n; ++i) f[i][0][1][0][0] = f[i][0][1][0][1] = 0;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int pos = 1; pos <= n; ++pos)
for (int num = 1; num <= k; ++num)
for (int prev = 0; prev <= 1; ++prev)
for (int nxt = 0; nxt <= 1; ++nxt) {
int opprev = op[prev], opnxt = op[nxt];
if (num == 1) opprev = 0;
if (num == k) opnxt = 0;
f[pos][num][0][prev][nxt] =
max(f[pos][num][0][prev][nxt],
f[pos - 1][num][0][prev][nxt] + a[pos] * (opprev + opnxt));
f[pos][num][0][prev][nxt] = max(
f[pos][num][0][prev][nxt],
f[pos - 1][num - 1][1][0][1 - prev] + a[pos] * (opprev + opnxt));
f[pos][num][0][prev][nxt] = max(
f[pos][num][0][prev][nxt],
f[pos - 1][num - 1][1][1][1 - prev] + a[pos] * (opprev + opnxt));
f[pos][num][1][prev][nxt] =
max(f[pos][num][1][prev][nxt], f[pos][num][0][prev][nxt]);
f[pos][num][1][prev][nxt] =
max(f[pos][num][1][prev][nxt], f[pos - 1][num][1][prev][nxt]);
}
cout << max(f[n][k][1][0][0], f[n][k][1][1][0]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int sz(const T &a) {
return (int)a.size();
}
set<int> use[26];
int col[(int)2e5 + 1];
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
string a;
cin >> a;
for (int i = 0; i < 26; i++)
for (int j = 1; j <= 26; j++) use[i].insert(j);
int ans = 0;
for (int i = 0; i < n; i++) {
int c = *use[a[i] - 'a'].begin();
ans = max(ans, c);
col[i] = c;
for (int j = 0; j < a[i] - 'a'; j++) use[j].erase(c);
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) printf("%d ", col[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, m, a, a1 = 0, a2 = 0, b1 = 0, b2 = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a;
if (a & 1)
a1++;
else
b1++;
}
for (int i = 1; i <= m; i++) {
cin >> a;
if (a & 1)
a2++;
else
b2++;
}
cout << min(a1, b2) + min(a2, b1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, left, right;
while (cin >> left >> right) {
long long num = 1, shuwei = 0;
while (num * 10 <= right) num = num * 10;
long long Num = num;
num = min(5 * Num, right);
if (5 * Num <= left) num = max(5 * Num, left);
long long shu[10];
Num = num;
while (Num != 0) {
shu[++shuwei] = 9 - Num % 10;
Num = Num / 10;
}
long long sum = 0;
for (i = shuwei; i >= 1; i--) sum = sum * 10 + shu[i];
cout << (long long)sum * (long long)num << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int INF = 1000000009;
using namespace std;
char ch[105][10004];
int a;
vector<int> v[105];
int main() {
int n, m, i, j, cor = 1, mn = -1;
cin >> n >> m;
for (i = 1; i <= n; i++) {
int tr = 0;
for (j = 1; j <= m; j++) {
cin >> ch[i][j];
if (ch[i][j] == '1') tr = 1, v[i].push_back(j);
}
if (!tr) cor = 0;
}
if (!cor)
cout << -1 << endl;
else {
for (j = 1; j <= m; j++) {
int c = 0;
for (i = 1; i <= n; i++) {
a = 10005;
int it = upper_bound(v[i].begin(), v[i].end(), j) - v[i].begin();
if (it != v[i].size()) {
int pos = v[i][it];
a = min(a, min(pos - j, m - pos + j));
} else {
int pos = v[i][0];
a = min(a, min(j - pos, m - j + pos));
}
if (it > 0) {
int pos = v[i][it - 1];
a = min(a, min(j - pos, m - j + pos));
} else {
int pos = v[i][v[i].size() - 1];
a = min(a, min(pos - j, m - pos + j));
}
c += a;
}
if (mn == -1 || mn > c) mn = c;
}
cout << mn << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, x, c0 = 0, c1 = 0, m = 10001, ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
if (x % 2 == 0)
c0++;
else {
c1++;
m = min(x, m);
}
ans += x;
}
if (c1 % 2 == 0) ans -= m;
ans = max(ans, 0);
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int *a;
struct cmp {
bool operator()(const int &i1, const int &i2) const { return a[i1] < a[i2]; }
};
void fk() {
cout << -1;
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size(), b, o = 0;
long long t = 0;
a = new int[n];
priority_queue<int, vector<int>, cmp> pq;
for (int i = 0; i < n; ++i) {
if (s[i] == '?') {
cin >> b >> a[i];
t += a[i];
a[i] -= b;
pq.push(i);
s[i] = ')';
}
o += (s[i] == '(') - (s[i] == ')');
if (o < 0) {
if (pq.empty()) fk();
t -= a[pq.top()];
s[pq.top()] = '(';
pq.pop();
o += 2;
}
}
if (o != 0) fk();
cout << t << "\n" << s;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> dyst(n);
for (int i = 0; i < n; i++) cin >> dyst[i];
sort(dyst.begin(), dyst.end());
int malo = 1000000042;
for (int i = 0; i < n / 2; i++) malo = min(dyst[i + n / 2] - dyst[i], malo);
cout << malo;
return 0;
}
| 7 |
#include<bits/stdc++.h>
#include<math.h>
using namespace std;
#include<string.h>
#define maxn 50005
#define ll long long
int a[6]={1,2,1,1,2,1};
int main()
{
int T;
cin>>T;
while(T--)
{
int n,x;
cin>>n;
for(int i=1;i<=n;i++)
cin>>x;
cout<<n*3<<endl;
for(int i=1;i<=n;i+=2)
for(int j=0;j<6;j++)
printf("%d %d %d\n",a[j],i,i+1);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
int get();
int main() {
int x[4] = {0, 0, 0, 0};
for (int i(get()); 0 < i--; ++x[get() - 1])
;
*x -= std::min(*x, x[2]);
x[3] += x[2] + x[1] / 2;
if (x[1] & 1) ++x[3], *x = std::max(0, *x - 2);
std::printf("%d\n", x[3] + (*x + 3) / 4);
return (0);
}
int get() {
int var;
std::scanf("%d\n", &var);
return (var);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100;
long long n;
char str[maxn];
bool solve() {
for (long long i = 2; i <= n; i++) {
long long x2 = str[i] - '0';
long long x1 = str[i - 1] - '0';
if (!(x2 * 2 == x1 + x2 || x2 * 2 == x1 + x2 - 1 || x2 * 2 == x1 + x2 + 1))
return false;
}
return true;
}
long long dp[maxn][10];
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
long long ans = 0;
memset(dp, 0, sizeof(dp));
for (long long i = 0; i <= 9; i++) {
dp[1][i] = 1;
}
for (long long i = 2; i <= n; i++) {
for (long long j = 0; j <= 9; j++) {
long long x1 = j * 2 - (str[i] - '0');
if (x1 >= 0 && x1 <= 9) dp[i][j] += dp[i - 1][x1];
long long x2 = j * 2 + 1 - (str[i] - '0');
if (x2 >= 0 && x2 <= 9) dp[i][j] += dp[i - 1][x2];
long long x3 = j * 2 - 1 - (str[i] - '0');
if (x3 >= 0 && x3 <= 9) dp[i][j] += dp[i - 1][x3];
}
}
for (long long i = 0; i <= 9; i++) {
ans += dp[n][i];
}
if (solve()) ans--;
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ask(int k) {
printf("? %d\n", k + 1);
fflush(stdout);
int r;
scanf("%d", &r);
return r;
}
bool compare(int k) {
int a = ask(k), b = ask((k + n / 2) % n);
if (a == b) {
printf("! %d\n", k + 1);
exit(0);
}
return a < b;
}
int main() {
scanf("%d", &n);
if (n % 4) {
puts("! -1");
fflush(stdout);
return 0;
}
int a = 0, b = n / 2;
if (!compare(a)) swap(a, b);
while (true) {
int c = (a + b) / 2;
if (compare(c))
a = c;
else
b = c;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
bool lala = 0;
vector<string> name(n);
vector<string> last(n);
vector<long long> ord(n);
string temp, temp2;
for (long long i = 0; i < n; i++) {
cin >> name[i] >> last[i];
}
for (long long i = 0; i < n; i++) {
cin >> ord[i];
}
temp = name[ord[0] - 1];
if (name[ord[0] - 1] > last[ord[0] - 1]) {
temp = last[ord[0] - 1];
}
for (long long i = 1; i < n; i++) {
if (name[ord[i] - 1] > temp || last[ord[i] - 1] > temp) {
if (name[ord[i] - 1] > temp) {
temp2 = name[ord[i] - 1];
} else {
temp2 = last[ord[i] - 1];
}
if (last[ord[i] - 1] > temp && last[ord[i] - 1] < name[ord[i] - 1]) {
temp2 = last[ord[i] - 1];
}
temp = temp2;
} else {
lala = 1;
break;
}
}
if (lala) {
cout << "NO\n";
} else {
cout << "YES\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <typename T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
using ll = long long;
using ld = long double;
const int MX = 1e5 + 10;
const int MN = 1e5 + 10;
const ld EPS = 1e-12;
struct vec {
public:
int x, y;
void in() { scanf("%d%d", &x, &y), x += MX; }
ll operator/(vec o) { return (ll)x * o.y - (ll)o.x * y; }
vec& operator+=(vec o) { return x += o.x, y += o.y, *this; }
vec& operator-=(vec o) { return x -= o.x, y -= o.y, *this; }
friend vec operator+(vec a, vec b) { return a += b; }
friend vec operator-(vec a, vec b) { return a -= b; }
} a[MN], b[MN];
int N, M, Q, q[MX * 2];
ld f[MN];
struct qua : public std::array<ld, 3> {
public:
qua(ld a = 0, ld b = 0, ld c = 0) { at(0) = a, at(1) = b, at(2) = c; }
ld operator()(ld t) { return at(0) + (at(1) + at(2) * t) * t; }
qua& operator+=(const qua& o) {
return at(0) += o[0], at(1) += o[1], at(2) += o[2], *this;
}
qua& operator-=(const qua& o) {
return at(0) -= o[0], at(1) -= o[1], at(2) -= o[2], *this;
}
qua& operator*=(ld x) { return at(0) *= x, at(1) *= x, at(2) *= x, *this; }
friend qua operator+(qua a, const qua& b) { return a += b; }
friend qua operator-(qua a, const qua& b) { return a -= b; }
friend qua operator*(qua a, ld b) { return a *= b; }
} p[MX * 2], cur;
bool equ(ld a, ld b) { return std::abs(a - b) < EPS; }
void add(int x0, int x1, ld y0, ld y1, ld z0, ld z1) {
{
qua v0((y0 + y1) * (x1 - x0) / 2, x0 - x1);
qua v2((z0 + z1) * (x0 - x1) / 2, x1 - x0);
p[0] += v0;
ld t0 = (y0 + z0) / 2;
ld t1 = (y1 + z1) / 2;
if (equ(t0, t1))
p[(int)std::ceil(t0)] += v2 - v0;
else {
if (t0 > t1) std::swap(t0, t1);
qua v1 = v2 + qua(t1 * t1, -2 * t1, 1) * ((x1 - x0) / (t1 - t0));
p[(int)std::ceil(t0)] += v1 - v0;
p[(int)std::ceil(t1)] += v2 - v1;
}
}
{
qua v0((z0 + z1) * (x1 - x0) / 2, x0 - x1);
if (equ(z0, z1))
p[0] -= v0, p[(int)std::ceil(z0)] += v0;
else {
if (z0 > z1) std::swap(z0, z1);
qua v1 = qua(z1 * z1, -2 * z1, 1) * (0.5 * (x1 - x0) / (z1 - z0));
p[0] -= v0;
p[(int)std::ceil(z0)] -= v1 - v0;
p[(int)std::ceil(z1)] += v1;
}
}
{
qua v2((y0 + y1) * (x0 - x1) / 2, x1 - x0);
if (equ(y0, y1))
p[(int)std::ceil(y0)] -= v2;
else {
if (y0 > y1) std::swap(y0, y1);
qua v1 = qua(y0 * y0, -2 * y0, 1) * (0.5 * (x1 - x0) / (y1 - y0));
p[(int)std::ceil(y0)] -= v1;
p[(int)std::ceil(y1)] -= v2 - v1;
}
}
}
void add(int i, int j, int t1) {
int t0 = std::max(a[i].y, b[j].y);
add(t0, t1,
a[i].x +
(ld)(a[i + 1].x - a[i].x) * (t0 - a[i].y) / (a[i + 1].y - a[i].y),
a[i].x +
(ld)(a[i + 1].x - a[i].x) * (t1 - a[i].y) / (a[i + 1].y - a[i].y),
b[j].x +
(ld)(b[j + 1].x - b[j].x) * (t0 - b[j].y) / (b[j + 1].y - b[j].y),
b[j].x +
(ld)(b[j + 1].x - b[j].x) * (t1 - b[j].y) / (b[j + 1].y - b[j].y));
}
int main() {
memset(q, -1, sizeof q);
scanf("%d%d", &N, &Q);
for (int i = 0; i < N; ++i) a[i].in();
for (int i = 0, x; i < Q; ++i) scanf("%d", &x), q[x + MX] = i;
{
int m = MX, x;
for (int i = 0; i < N; ++i)
if (ckmin(m, a[i].y)) x = i;
std::rotate(a, a + x, a + N);
if ((a[1] - a[0]) / (a[N - 1] - a[0]) < 0) std::reverse(a + 1, a + N);
m = -MX;
for (int i = 0; i < N; ++i)
if (ckmax(m, a[i].y)) x = i;
memcpy(b, a + x, (N - x) * sizeof *a);
b[N - x] = a[0];
M = N - x + 1;
N = x + 1;
std::reverse(b, b + M);
}
for (int i = 0, j = 0, t; i + 1 < N;) {
t = std::min(a[i + 1].y, b[j + 1].y);
add(i, j, t);
if (t == a[i + 1].y) ++i;
if (t == b[j + 1].y) ++j;
assert(!(i + 1 == N ^ j + 1 == M));
}
for (int i = 0; i < MX * 2; ++i) {
cur += p[i];
if (~q[i]) f[q[i]] = cur(i);
}
for (int i = 0; i < Q; ++i) printf("%.12lf\n", (double)f[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
char s[N], t[N];
int vis[N], vs[N];
int main() {
cin >> s + 1 >> t + 1;
int j = 1;
int n = strlen(s + 1);
int m = strlen(t + 1);
for (int i = 1; i <= n && j <= m; ++i) {
if (s[i] == t[j]) {
vis[j] = i;
++j;
}
}
j = m;
for (int i = n; i >= 1 && j >= 1; --i) {
if (s[i] == t[j]) {
vs[j] = i;
--j;
}
}
int ans = max(vis[1] - 1, n - vis[m]);
ans = max(ans, vs[1] - 1);
ans = max(ans, n - vs[m]);
for (int i = 1; i <= m; ++i) {
ans = max(ans, vs[i] - vis[i - 1] - 1);
}
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
char str[MAXN];
int dx[MAXN], dy[MAXN], n, sx, sy, tx, ty;
int check(long long mid) {
long long x = mid / n * dx[n] + dx[mid % n] + sx;
long long y = mid / n * dy[n] + dy[mid % n] + sy;
return abs(tx - x) + abs(ty - y) <= mid;
}
int main() {
scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
scanf("%d%s", &n, str + 1);
long long l = -1, r = 1E18;
for (int i = 1; i <= n; i++) {
dx[i] = dx[i - 1], dy[i] = dy[i - 1];
switch (str[i]) {
case 'U':
++dy[i];
break;
case 'D':
--dy[i];
break;
case 'L':
--dx[i];
break;
case 'R':
++dx[i];
break;
}
}
while (l + 1 < r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%lld\n", r > 1E18 * 0.99 ? -1 : r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n--;
vector<int> val1(n);
vector<int> val2(n);
for (int i = 0; i < n; i++) cin >> val1[i];
for (int i = 0; i < n; i++) cin >> val2[i];
vector<int> ans(n + 1);
bool same = false;
ans[0] = 0;
for (int i = 1; i <= n; i++) {
if (val2[i - 1] % 2 == 1) {
if (ans[i - 1] == 0 && same == false) {
for (int j = 0; j < i; j++) {
int ost = ans[j] % 2;
ans[j] = ans[j] - ost + (ost + 1) % 2;
}
}
if (ans[i - 1] == 0 && same == true) {
cout << "NO";
return 0;
}
ans[i] += 1;
same = true;
} else if (val1[i - 1] % 2 == 0) {
if (ans[i - 1] == 1 && same == false) {
for (int j = 0; j < i; j++) {
int ost = ans[j] % 2;
ans[j] = ans[j] - ost + (ost + 1) % 2;
}
}
if (ans[i - 1] == 1 && same == true) {
cout << "NO";
return 0;
}
same = true;
} else {
ans[i] += (ans[i - 1] % 2 + 1) % 2;
}
}
same = false;
for (int i = 1; i <= n; i++) {
if ((val2[i - 1] / 2) % 2 == 1) {
if (ans[i - 1] / 2 == 0 && same == false) {
for (int j = 0; j < i; j++) {
int ost = (ans[j] / 2) % 2;
ans[j] = ans[j] - 2 * ost + 2 * ((ost + 1) % 2);
}
}
if (ans[i - 1] / 2 == 0 && same == true) {
cout << "NO";
return 0;
}
ans[i] += 2;
same = true;
} else if ((val1[i - 1] / 2) % 2 == 0) {
if (ans[i - 1] / 2 == 1 && same == false) {
for (int j = 0; j < i; j++) {
int ost = (ans[j] / 2) % 2;
ans[j] = ans[j] - 2 * ost + 2 * ((ost + 1) % 2);
}
}
if (ans[i - 1] / 2 == 1 && same == true) {
cout << "NO";
return 0;
}
same = true;
} else {
ans[i] += 2 * (((ans[i - 1] / 2) % 2 + 1) % 2);
}
}
for (int i = 1; i < n + 1; i++) {
if ((ans[i] | ans[i - 1]) != val1[i - 1]) {
cout << "NO";
return 0;
}
if ((ans[i] & ans[i - 1]) != val2[i - 1]) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n + 1; i++) {
cout << ans[i] << " ";
}
cin >> n;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
string s[h];
for (int i = 0; i < h; i++) {
cin >> s[i];
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (i == 0 || j == 0 || i == h - 1 || j == w - 1) continue;
if (s[i][j] == '*' && s[i - 1][j] == '*' && s[i + 1][j] == '*' &&
s[i][j - 1] == '*' && s[i][j + 1] == '*') {
for (int p = j; p < w; p++) {
if (s[i][p] != '*') break;
s[i][p] = '1';
}
for (int p = j - 1; p >= 0; p--) {
if (s[i][p] != '*') break;
s[i][p] = '1';
}
for (int p = i + 1; p < h; p++) {
if (s[p][j] != '*') break;
s[p][j] = '1';
}
for (int p = i - 1; p >= 0; p--) {
if (s[p][j] != '*') break;
s[p][j] = '1';
}
for (int p = 0; p < h; p++) {
for (int q = 0; q < w; q++) {
if (s[p][q] == '*') {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void mian() {
int n;
cin >> n;
vector<int> a(n + 1), b(n + 1), c(n + 1), ans(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
if (i == 1)
ans[i] = a[i];
else if (i < n)
ans[i] = a[i] == ans[i - 1] ? b[i] : a[i];
else
ans[i] = a[i] == ans[i - 1] || a[i] == ans[1]
? b[i] == ans[i - 1] || b[i] == ans[1] ? c[i] : b[i]
: a[i];
printf("%d ", ans[i]);
}
puts("");
}
int main() {
int testnum;
cin >> testnum;
while (testnum--) mian();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300300];
int sobe[20];
int desce[20];
int qt0[20];
int qt1[20];
long long fat[300300];
long long exp(long long a, long long b) {
if (b == 0) return 1;
long long r = exp(a, b / 2);
r = (r * r) % 1000000007;
if (b % 2) r = (r * a) % 1000000007;
return r;
}
long long inv(long long a) { return exp(a % 1000000007, 1000000007 - 2); }
long long C(int n, int k) {
if (n < 0 || k < 0 || k > n) return 0;
long long r = (fat[n] * inv(fat[k] * fat[n - k])) % 1000000007;
return r;
}
long long mul(long long a, long long b) {
;
a %= 1000000007;
if (a < 0) a += 1000000007;
b %= 1000000007;
if (b < 0) b += 1000000007;
return (a * b) % 1000000007;
}
long long s[300300];
long long ps[300300];
long long get(int a, int b) {
if (a > b) return 0;
long long r = ps[b];
if (a) r -= ps[a - 1];
;
return r;
}
int main() {
int n;
scanf("%d", &n);
fat[0] = 1;
for (int i = 1; i < 300300; i++) fat[i] = (fat[i - 1] * i) % 1000000007;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
for (int j = 2; j * j <= a; j++)
if (a % j == 0) {
int q = 0;
while (a % j == 0) {
a /= j;
q++;
}
v[j].push_back(q);
}
if (a != 1) v[a].push_back(1);
}
long long ans = 0;
for (int i = 0; i < 300300; i++) {
sort(v[i].begin(), v[i].end());
int u = n - 1;
for (int j = (int)v[i].size() - 1; j >= 0; j--) {
s[u] += v[i][j];
s[u] %= 1000000007;
u--;
}
}
ps[0] = s[0];
for (int i = 1; i < 300300; i++) ps[i] = (ps[i - 1] + s[i]) % 1000000007;
for (int i = 0; i < n; i++) {
;
int A = i;
int B = n - i - 1;
ans += mul(get(i + 1, n - 1) - (long long)B * get(i, i), C(n - 2, B));
ans %= 1000000007;
ans += mul((long long)A * get(i, i) - get(0, i - 1), C(n - 2, A));
ans %= 1000000007;
ans += mul(get(i + 1, n - 1) - (long long)B * get(i, i), C(n - 2, B - 1));
ans %= 1000000007;
ans += mul((long long)A * get(i, i) - get(0, i - 1), C(n - 2, B - 2));
ans %= 1000000007;
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
bool incorrect = false;
int arr[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
int n, m;
char z;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> z;
z -= 48;
if (j == 0) {
if (arr[z] == -1 || arr[z] != i - 1) {
arr[z] = i;
} else {
incorrect = true;
}
} else if (arr[z] != i) {
incorrect = true;
}
}
}
if (incorrect) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int pos[20];
int tree[20][250000];
int main() {
int n;
int m;
cin >> n >> m;
pos[0] = 1, pos[1] = 2;
for (int k = 2; k < 20; ++k) {
pos[k] = pos[k - 1] * 2;
}
int last = pos[n];
for (int i = 0; i < last; ++i) {
int x;
cin >> x;
tree[n][i] = x;
}
int state = n % 2;
for (int j = n - 1; j >= 0; --j) {
for (int i = 0; i < pos[j]; ++i) {
if (j % 2 == state) {
tree[j][i] = tree[j + 1][2 * i] ^ tree[j + 1][2 * i + 1];
} else {
tree[j][i] = tree[j + 1][2 * i] | tree[j + 1][2 * i + 1];
}
}
}
for (int l = 0; l < m; ++l) {
int p, b;
cin >> p >> b;
tree[n][p - 1] = b;
int now = p - 1;
for (int j = n - 1; j >= 0; j--) {
now = now / 2;
if (j % 2 == state)
tree[j][now] = tree[j + 1][now * 2] ^ tree[j + 1][now * 2 + 1];
else
tree[j][now] = tree[j + 1][now * 2] | tree[j + 1][now * 2 + 1];
}
cout << tree[0][0] << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ar[5][51], tmp[5][51], cnt = 0;
struct st {
int car, r, c;
};
vector<st> ans;
void Rotate() {
int r, c;
for (int i = 2; i < 4; i++) {
for (int j = 1; j <= n; j++) {
tmp[i][j] = ar[i][j];
if (ar[i][j] == 0) {
r = i;
c = j;
}
}
}
int val = 2 * n;
while (val--) {
if (r == 3) {
if (c == 1) {
ar[r][c] = tmp[2][1];
if (tmp[2][1] != 0) ans.push_back({tmp[2][1], r, c});
r = 2, c = 1;
} else {
ar[r][c] = tmp[r][c - 1];
if (tmp[r][c - 1] != 0) ans.push_back({tmp[r][c - 1], r, c});
c--;
}
} else {
if (c == n) {
ar[r][c] = tmp[3][n];
if (tmp[3][n] != 0) ans.push_back({tmp[3][n], r, c});
r = 3;
} else {
ar[r][c] = tmp[r][c + 1];
if (tmp[r][c + 1] != 0) ans.push_back({tmp[r][c + 1], r, c});
c++;
}
}
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &ar[i][j]);
}
}
if (k == 2 * n) {
bool flag = false;
for (int i = 1; i <= n; i++) {
if (ar[1][i] == ar[2][i] || ar[3][i] == ar[4][i]) flag = true;
}
if (!flag) {
printf("-1\n");
return 0;
}
}
while (cnt < k) {
for (int i = 1; i <= n; i++) {
if (ar[1][i] == ar[2][i] && ar[1][i] != 0) {
ans.push_back({ar[1][i], 1, i});
ar[1][i] = ar[2][i] = 0;
cnt++;
}
if (ar[3][i] == ar[4][i] && ar[3][i] != 0) {
ans.push_back({ar[3][i], 4, i});
ar[3][i] = ar[4][i] = 0;
cnt++;
}
}
Rotate();
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d %d\n", ans[i].car, ans[i].r, ans[i].c);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, m, p;
int a[305][305];
vector<pair<int, int> > v[90004];
int bit[5][305][305];
int dp[305][305];
void update0(int i, int j, int v, int t) {
for (int x = i; x <= 300; x += (x & (-x))) {
for (int y = j; y <= 300; y += (y & -y))
bit[0][x][y] = t ? max(bit[0][x][y], v) : min(bit[0][x][y], v);
}
}
int query0(int i, int j) {
int ret = inf;
for (int x = i; x > 0; x -= (x & -x))
for (int y = j; y > 0; y -= (y & -y)) ret = min(ret, bit[0][x][y]);
return ret;
}
void update1(int i, int j, int v, int t) {
for (int x = i; x <= 300; x += x & -x)
for (int y = j; y > 0; y -= y & -y)
bit[1][x][y] = t ? max(bit[1][x][y], v) : min(bit[1][x][y], v);
}
int query1(int i, int j) {
int ret = inf;
for (int x = i; x > 0; x -= x & -x)
for (int y = j; y <= 300; y += y & -y) ret = min(ret, bit[1][x][y]);
return ret;
}
void update2(int i, int j, int v, int t) {
for (int x = i; x > 0; x -= x & -x)
for (int y = j; y <= 300; y += y & -y)
bit[2][x][y] = t ? max(bit[2][x][y], v) : min(bit[2][x][y], v);
}
int query2(int i, int j) {
int ret = inf;
for (int x = i; x <= 300; x += x & -x)
for (int y = j; y > 0; y -= y & -y) ret = min(ret, bit[2][x][y]);
return ret;
}
void update3(int i, int j, int v, int t) {
for (int x = i; x > 0; x -= x & -x)
for (int y = j; y > 0; y -= y & -y)
bit[3][x][y] = t ? max(bit[3][x][y], v) : min(bit[3][x][y], v);
}
int query3(int i, int j) {
int ret = inf;
for (int x = i; x <= 300; x += x & -x)
for (int y = j; y <= 300; y += y & -y) ret = min(ret, bit[3][x][y]);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
v[a[i][j]].push_back(make_pair(i, j));
}
}
for (int i = 0; i <= 3; i++) {
for (int j = 0; j <= 300; j++) {
for (int k = 0; k <= 300; k++) bit[i][j][k] = inf;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1) {
dp[i][j] = i - 1 + j - 1;
update0(i, j, dp[i][j] - i - j, 0);
update1(i, j, dp[i][j] - i + j, 0);
update2(i, j, dp[i][j] + i - j, 0);
update3(i, j, dp[i][j] + i + j, 0);
}
}
}
for (int key = 2; key <= p; key++) {
for (pair<int, int> p : v[key]) {
int x = p.first, y = p.second;
int q0 = query0(x, y);
int q1 = query1(x, y);
int q2 = query2(x, y);
int q3 = query3(x, y);
int dist = q0 + x + y;
dist = min(dist, q1 + x - y);
dist = min(dist, q2 - x + y);
dist = min(dist, q3 - x - y);
dp[x][y] = dist;
}
for (pair<int, int> p : v[key - 1]) {
int x = p.first, y = p.second;
update0(x, y, inf, 1);
update1(x, y, inf, 1);
update2(x, y, inf, 1);
update3(x, y, inf, 1);
}
for (pair<int, int> p : v[key]) {
int x = p.first, y = p.second;
update0(x, y, dp[x][y] - x - y, 0);
update1(x, y, dp[x][y] - x + y, 0);
update2(x, y, dp[x][y] + x - y, 0);
update3(x, y, dp[x][y] + x + y, 0);
}
}
int x = v[p][0].first, y = v[p][0].second;
cout << dp[x][y] << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long c1 = 0, c0 = 0;
long long k = 1;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
c1++;
else if (a[i] == 0)
c0++;
}
long long ans = c1 * (k << c0);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[400009];
bool pos[400009];
int main() {
scanf("%s", str);
int l = 0, len = strlen(str);
int last = l;
while (str[l] != '.' && str[l]) l++;
if (str[0] == '.' || l == len || l > 8) {
puts("NO");
return 0;
}
last = l;
for (int i = l + 1; i < len; i++)
if (str[i] == '.') {
if (i - last - 1 >= 2 && i - last - 1 <= 11) {
if (i - last - 1 < 4)
pos[last + 1] = 1;
else
pos[last + 3] = 1;
} else {
puts("NO");
return 0;
}
last = i;
}
if (len - last > 4 || len == last + 1) {
puts("NO");
return 0;
} else {
puts("YES");
for (int i = 0; i < len; i++) {
printf("%c", str[i]);
if (pos[i]) puts("");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
if (n % 2)
cout << v[n / 2] << "\n";
else
cout << v[n / 2 - 1] << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
string s[3];
char dif(char a, char b) {
if (a != 'a' and b != 'a') return 'a';
if (a != 'b' and b != 'b') return 'b';
return 'c';
}
int main() {
cin >> n >> t >> s[0] >> s[1];
int x = 0;
int p = 0;
for (int i = 0; i < n; ++i)
if (s[0][i] == s[1][i]) p++;
for (x = (n - p) % 2; x < n - p + 1; x += 2) {
if (t == (x + ((n - p - x) / 2))) break;
if (t < (x + ((n - p - x) / 2))) return cout << -1, 0;
}
if (x > (n - p)) x -= 2;
int help = 0;
int i;
for (i = 0; (i < n) and (help < x); ++i) {
if (s[0][i] == s[1][i]) {
s[2] += s[0][i];
continue;
}
s[2] += dif(s[0][i], s[1][i]);
help++;
}
int flag = 1;
for (; i < n; ++i) {
if (s[0][i] == s[1][i]) {
s[2] += s[0][i];
continue;
}
s[2] += s[flag][i];
flag = 1 - flag;
}
t -= (x + ((n - p - x) / 2));
for (int j = 0; (j < n) and (t); ++j)
if (s[0][j] == s[1][j]) {
s[2][j] = dif(s[0][j], s[1][j]);
t--;
}
cout << s[2];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, x = 0, y = 0, z = 0;
cin >> a >> b;
for (int i = 1; i <= 6; i++) {
if (a - i > 0) {
c = a - i;
} else {
c = i - a;
}
if (b - i > 0) {
d = b - i;
} else {
d = i - b;
}
if (d > c) {
y++;
} else if (c > d) {
x++;
} else {
z++;
}
}
cout << y << " " << z << " " << x;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s, int m) {
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (s[i] != s[j]) {
return false;
}
}
}
return true;
}
int main() {
int m, n;
bool f = true;
cin >> n >> m;
string a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (check(a[i], m)) {
} else {
cout << "NO";
f = false;
break;
}
}
if (f) {
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
cout << "NO";
f = false;
break;
}
}
}
if (f) {
cout << "YES";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LLINF = numeric_limits<long long>::max();
const unsigned long long ULLINF = numeric_limits<unsigned long long>::max();
const double PI = acos(-1.0);
long long n, a, b;
long long d[1000010];
set<long long> fs;
vector<long long> primes;
bool sieve[1000010];
long long dp[1000010][3];
void factor(long long m) {
while (m > 1) {
bool prime = 1;
for (long long p : primes) {
if (p * p > m) break;
if (m % p == 0) {
fs.insert(p);
m /= p;
prime = 0;
break;
}
}
if (prime) fs.insert(m), m = 1;
}
}
long long add(long long a, long long b) {
if (a == -1) return -1;
return a + b;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> d[i];
for (int i = 2; i * i <= 1000000; i++)
if (!sieve[i])
for (int j = i * i; j <= 1000000; j += i) sieve[j] = 1;
for (int i = 2; i <= 1000000; i++)
if (!sieve[i]) primes.push_back(i);
factor(d[0]);
factor(d[n - 1]);
factor(d[0] - 1);
factor(d[0] + 1);
factor(d[n - 1] - 1);
factor(d[n - 1] + 1);
long long ans = LLINF;
for (long long p : fs) {
for (int i = 0; i < n; i++) dp[i][0] = dp[i][1] = dp[i][2] = -1;
if (d[0] % p && (d[0] - 1) % p && (d[0] + 1) % p)
dp[0][1] = a;
else {
dp[0][0] = (d[0] % p == 0 ? 0 : b);
dp[0][1] = a;
dp[0][2] = -1;
}
for (int i = 1; i < n; i++) {
if (d[i] % p && (d[i] - 1) % p && (d[i] + 1) % p) {
dp[i][1] = add(dp[i - 1][0], a);
if (dp[i][1] == -1)
dp[i][1] = add(dp[i - 1][1], a);
else
dp[i][1] = min(dp[i][1], add(dp[i - 1][1], a));
} else {
dp[i][0] = add(dp[i - 1][0], (d[i] % p == 0 ? 0 : b));
dp[i][1] = add(dp[i - 1][0], a);
if (dp[i][1] == -1)
dp[i][1] = add(dp[i - 1][1], a);
else
dp[i][1] = min(dp[i][1], add(dp[i - 1][1], a));
dp[i][2] = add(dp[i - 1][2], (d[i] % p == 0 ? 0 : b));
if (dp[i][2] == -1)
dp[i][2] = add(dp[i - 1][1], (d[i] % p == 0 ? 0 : b));
else
dp[i][2] = min(dp[i][2], add(dp[i - 1][1], (d[i] % p == 0 ? 0 : b)));
}
}
if (dp[n - 1][0] != -1) ans = min(ans, dp[n - 1][0]);
if (dp[n - 1][1] != -1) ans = min(ans, dp[n - 1][1]);
if (dp[n - 1][2] != -1) ans = min(ans, dp[n - 1][2]);
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[2000005];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
int l = 0;
int r = 0;
for (char c : s) {
if (c == 'L')
l++;
else
r++;
}
if (l == n || r == n) {
cout << (n + 2) / 3 << "\n";
} else {
long long ans = 0;
deque<char> x;
for (char c : s) x.push_back(c);
if (x.size() && x.front() == x.back()) {
int cnt = 0;
char c = x.front();
while (x.size() && x.front() == c) {
cnt++;
x.pop_front();
}
while (x.size() && x.back() == c) {
cnt++;
x.pop_back();
}
ans += cnt / 3;
}
while (x.size()) {
int cnt = 0;
char c = x.front();
while (x.size() && x.front() == c) {
cnt++;
x.pop_front();
}
ans += cnt / 3;
}
cout << ans << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
int32_t main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
unsigned shops_number;
std::cin >> shops_number;
std::vector<int> prices(shops_number);
for (auto &price : prices) std::cin >> price;
std::sort(prices.begin(), prices.end());
unsigned days_number;
std::cin >> days_number;
while (days_number--) {
int coins_to_spend;
std::cin >> coins_to_spend;
std::vector<int>::iterator up =
std::upper_bound(prices.begin(), prices.end(), coins_to_spend);
std::cout << (up - prices.begin()) << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void read() {}
template <typename T, typename... Ts>
inline void read(T& A, Ts&... As) {
T 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 << 1) + (x << 3) + (ch ^ 48), ch = getchar();
A = x * f, read(As...);
}
inline void write(char a) { putchar(a); }
template <typename T>
inline void write(T a) {
if (a < 0ll) putchar('-'), a = -a;
if (a > 9ll) write(a / 10ll);
putchar(a % 10ll + '0');
}
template <typename T, typename... Ts>
inline void write(T A, Ts... As) {
write(A), write(As...);
}
const long long N = 600010, inf = 1e18, maxn = 30;
long long n, k, p[N], cnt, len = inf;
long long l[N], r[N];
struct bign {
long long d[maxn], len;
void clean() {
while (len > 1 && !d[len - 1]) len--;
}
bign() {
memset(d, 0, sizeof(d));
len = 1;
}
bign(long long num) { *this = num; }
bign(char* num) { *this = num; }
bign operator=(const char* num) {
memset(d, 0, sizeof(d));
len = strlen(num);
for (long long i = 0; i < len; i++) d[i] = num[len - 1 - i] - '0';
clean();
return *this;
}
bign operator=(long long num) {
char s[maxn];
sprintf(s, "%lld", num);
*this = s;
return *this;
}
bign operator+(const bign& b) {
bign c = *this;
long long i;
for (i = 0; i < b.len; i++) {
c.d[i] += b.d[i];
if (c.d[i] > 9) c.d[i] %= 10, c.d[i + 1]++;
}
while (c.d[i] > 9) c.d[i++] %= 10, c.d[i]++;
c.len = max(len, b.len);
if (c.d[i] && c.len <= i) c.len = i + 1;
return c;
}
bign operator-(const bign& b) {
bign c = *this;
long long i;
for (i = 0; i < b.len; i++) {
c.d[i] -= b.d[i];
if (c.d[i] < 0) c.d[i] += 10, c.d[i + 1]--;
}
while (c.d[i] < 0) c.d[i++] += 10, c.d[i]--;
c.clean();
return c;
}
bign operator*(const bign& b) const {
long long i, j;
bign c;
c.len = len + b.len;
for (j = 0; j < b.len; j++)
for (i = 0; i < len; i++) c.d[i + j] += d[i] * b.d[j];
for (i = 0; i < c.len - 1; i++) c.d[i + 1] += c.d[i] / 10, c.d[i] %= 10;
c.clean();
return c;
}
bign operator+=(const bign& b) {
*this = *this + b;
return *this;
}
bool operator<(const bign& b) const {
if (len != b.len) return len < b.len;
for (long long i = len - 1; i >= 0; i--)
if (d[i] != b.d[i]) return d[i] < b.d[i];
return false;
}
bool operator>(const bign& b) const { return b < *this; }
bool operator<=(const bign& b) const { return !(b < *this); }
bool operator>=(const bign& b) const { return !(*this < b); }
bool operator!=(const bign& b) const { return b < *this || *this < b; }
bool operator==(const bign& b) const { return !(b < *this) && !(b > *this); }
string str() const {
char s[maxn] = {};
for (long long i = 0; i < len; i++) s[len - 1 - i] = d[i] + '0';
return s;
}
};
double suml, sumr;
long long ans;
void dfs(long long x) {
if (x > inf) return;
p[++cnt] = x, dfs(x * 10 + 4), dfs(x * 10 + 7);
}
struct cmpl {
bool operator()(long long x, long long y) {
return l[x] == l[y] ? x < y : l[x] < l[y];
}
};
struct cmpr {
bool operator()(long long x, long long y) {
return r[x] == r[y] ? x < y : r[x] < r[y];
}
};
multiset<long long, cmpr> s1;
multiset<long long, cmpl> s2;
bool calc(long long L, long long R) {
double sz2 = s2.size(), sz1 = double(n) - sz2 - s1.size();
return (sumr - sz2 * L + sz1 * R - suml) <= double(k);
}
signed main() {
read(n, k), dfs(4), dfs(7), sort(p + 1, p + cnt + 1);
for (register long long i = 1; i <= n; ++i)
read(l[i], r[i]), len = min(len, r[i] - l[i]), s2.insert(i);
s1.clear(), s2.clear();
for (register long long i = 1; i <= n; ++i) s2.insert(i), sumr += l[i];
long long j = 0;
for (register long long i = 1; i <= cnt; ++i) {
while (p[j + 1] - p[i] <= len && j < cnt) {
++j;
while (s2.size()) {
long long k = *s2.begin();
if (l[k] > p[j]) break;
s2.erase(k);
sumr = sumr - l[k];
s1.insert(k);
}
while (s1.size()) {
long long k = *s1.begin();
if (r[k] >= p[j]) break;
s1.erase(k);
suml = suml + r[k];
}
if (calc(p[i], p[j]))
ans = max(ans, j - i + 1);
else
break;
}
}
write(ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct fenwick_tree {
vector<int> t;
int n;
fenwick_tree(int nn) : t(nn) { n = nn; }
fenwick_tree(const vector<int>& a) : fenwick_tree((int)a.size()) {
for (unsigned i = 0; i < a.size(); i++) inc(i, a[i]);
}
int sum(int r) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, int delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
};
int dr[3001][3001] = {};
int dl[3001][3001] = {};
int dld[3001][3001] = {};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == 'z') a[i][j] = 1;
}
}
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = m - 1; j >= 0; j--) {
if (a[i][j])
cnt++;
else
cnt = 0;
dr[i][j] = cnt;
}
cnt = 0;
for (int j = 0; j < m; j++) {
if (a[i][j])
cnt++;
else
cnt = 0;
dl[i][j] = cnt;
}
}
for (int i = 0; i <= (n - 1) + (m - 1); i++) {
int l = min(n - 1, i);
int cnt = 0;
for (int j = l; j >= 0; j--) {
int col = i - j;
if (col >= m) break;
if (a[j][col])
cnt++;
else
cnt = 0;
dld[j][col] = cnt;
}
}
vector<fenwick_tree> ft(n + m, fenwick_tree(max(n, m)));
long long ans = 0;
struct pt {
int l;
int c;
};
vector<vector<pt>> ev(m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dr[i][j]) ev[j + dr[i][j] - 1].push_back({i, j});
}
}
for (int i = m - 1; i >= 0; i--) {
for (auto e : ev[i]) {
ft[e.l + e.c].inc(e.l, +1);
}
for (int j = 0; j < n; j++) {
int c = min(dl[j][i], dld[j][i]);
if (c) ans += ft[i + j].sum(j, j + c - 1);
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int MOD = 1000000009;
struct Trie {
Trie *fail, *next[26];
int end = 0;
void init() {
memset(next, NULL, sizeof(next));
fail = NULL;
end = 0;
}
} * q[N], *root, node[N];
int dp[1005][N][15], n, m;
int tot;
char str[N];
inline void update(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
void insert(char *str) {
Trie *cur = root;
for (int i = 0; str[i]; i++) {
int idx = str[i] - 'A';
if (cur->next[idx] == NULL) {
node[tot].init();
cur->next[idx] = &node[tot++];
}
cur = cur->next[idx];
}
cur->end = strlen(str);
}
void init() {
tot = 0;
node[tot].init();
root = &node[tot++];
}
void build() {
int head, tail;
head = tail = 0;
q[0] = root;
root->fail = NULL;
while (head <= tail) {
Trie *cur = q[head++];
for (int i = 0; i < 26; i++) {
if (cur->next[i]) {
if (cur == root)
cur->next[i]->fail = root;
else {
Trie *p = cur->fail;
while (p) {
if (p->next[i]) {
cur->next[i]->fail = p->next[i];
break;
}
p = p->fail;
}
if (p == NULL) cur->next[i]->fail = root;
cur->next[i]->end = max(cur->next[i]->end, cur->next[i]->fail->end);
}
q[++tail] = cur->next[i];
} else
cur->next[i] = (cur == root) ? root : cur->fail->next[i];
}
}
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 0; i < m; i++) {
scanf("%s", str);
insert(str);
}
build();
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < tot; j++)
for (int k = 0; k <= 10; k++) {
for (int a = 0; a < 26; a++) {
int newJ = node[j].next[a] - node;
if (node[newJ].end >= k + 1) {
update(dp[i + 1][newJ][0], dp[i][j][k]);
} else
update(dp[i + 1][newJ][k + 1], dp[i][j][k]);
}
}
int ans = 0;
for (int j = 0; j < tot; j++) update(ans, dp[n][j][0]);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T>
using vec = std::vector<T>;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
struct Input {
Input(istream &in) : in(&in) {}
template <class T>
T next() const {
T x;
*in >> x;
return x;
}
int ni() const { return next<int>(); }
template <class T>
vec<T> nVec(int n) const {
vec<T> v(n);
for (int i = 0; i < n; ++i) {
v[i] = next<T>();
}
return v;
}
vec<int> nvi(int n) const { return nVec<int>(n); }
istream *in;
};
Input in(cin);
class Output {
private:
ostream *out;
template <typename T>
void printSingle(const T &value) {
*out << value;
}
public:
Output(ostream &out) : out(&out) {}
inline void print() {}
template <typename T, typename... Ts>
inline void print(const T &f, const Ts &...args) {
printSingle(f);
if (sizeof...(args) != 0) {
*out << ' ';
print(args...);
}
}
template <typename... Ts>
inline void println(const Ts &...args) {
print(args...);
*out << '\n';
}
template <typename... Ts>
inline void operator()(const Ts &...args) {
println(args...);
}
};
Output out(cout);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
void solve(istream &inStream, ostream &outStream) {
in = Input(inStream);
out = Output(outStream);
auto n = in.ni();
auto q = in.ni();
auto xs = in.nvi(n);
sort(xs.begin(), xs.end());
multiset<int> piles;
set<int> points(xs.begin(), xs.end());
for (int i = (1); i < (n); ++i) piles.insert(xs[i] - xs[i - 1]);
auto get = [&]() -> int {
if (n <= 2) {
return 0;
}
int mi = *points.begin(), ma = *points.rbegin();
int mx = *piles.rbegin();
return ma - mi - mx;
};
auto remove = [&](int x) {
--n;
auto it = points.find(x);
int xPrev = -1;
int xNext = -1;
if (it != points.begin()) {
--it;
xPrev = *it;
++it;
piles.erase(piles.find(x - xPrev));
}
++it;
if (it != points.end()) {
xNext = *it;
--it;
piles.erase(piles.find(xNext - x));
}
points.erase(x);
if (xPrev != -1 && xNext != -1) {
piles.insert(xNext - xPrev);
}
};
auto add = [&](int x) {
++n;
points.insert(x);
auto it = points.find(x);
int xPrev = -1;
int xNext = -1;
if (it != points.begin()) {
--it;
xPrev = *it;
++it;
piles.insert(x - xPrev);
}
++it;
if (it != points.end()) {
xNext = *it;
--it;
piles.insert(xNext - x);
}
if (xPrev != -1 && xNext != -1) {
piles.erase(piles.find(xNext - xPrev));
}
};
out(get());
while (q--) {
auto t = in.ni();
auto x = in.ni();
if (t == 0) {
remove(x);
} else {
add(x);
}
out(get());
}
}
int main() {
solve(cin, cout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r1, r2, ansa, ansb, ct, w;
vector<int> v[100005];
bool b = false, hv[100005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &r1, &r2);
v[r1].push_back(r2);
v[r2].push_back(r1);
}
for (int i = 1; i <= n; i++) {
if (v[i].size() == n - 1) continue;
b = true;
ansa = i;
hv[i] = true;
for (int j = 0; j < v[i].size(); j++) {
hv[v[i][j]] = true;
}
for (int j = 1; j <= n; j++) {
if (!hv[j]) {
ansb = j;
break;
}
}
break;
}
if (!b) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
if (i == ansa)
w = n - 1;
else if (i == ansb)
w = n;
else {
ct++;
w = ct;
}
printf(i == n ? "%d\n" : "%d ", w);
}
ct = 0;
for (int i = 1; i <= n; i++) {
if (i == ansa)
w = n - 1;
else if (i == ansb)
w = n - 1;
else {
ct++;
w = ct;
}
printf(i == n ? "%d\n" : "%d ", w);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 200010;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
bool cmp(long long x, long long y) { return x > y; }
int main() {
long long a, b, c[MAXN], ans;
int n;
while (cin >> n) {
a = 0;
b = 0;
for (int i = 0; i < n; i++) {
cin >> c[i];
}
sort(c, c + n, cmp);
for (int i = 0; i < n; i++) {
if (a <= b)
a += c[i];
else
b += c[i];
}
ans = abs(a - b) + 1;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool p[4000010], h[4000010];
long long a, b, pi[4000010], rub[4000010];
int main() {
scanf("%I64d%I64d", &a, &b);
for (int i = 2; i <= 4000000; i++) p[i] = 1;
memset(h, 0, sizeof(h));
p[1] = 0;
for (int i = 2; i <= 2000; i++)
if (p[i])
for (int j = i * i; j <= 4000000; j += i) p[j] = 0;
for (int i = 1; i <= 3999; i++) {
int t = i, k = 0, c[15], n = 0;
while (t > 0) {
c[++k] = t % 10;
t /= 10;
}
for (int j = k; j >= 1; j--) n = n * 10 + c[j];
for (int j = 1; j <= k; j++) n = n * 10 + c[j];
if (n <= 4000000) h[n] = 1;
n = 0;
for (int j = k; j >= 2; j--) n = n * 10 + c[j];
for (int j = 1; j <= k; j++) n = n * 10 + c[j];
if (n <= 4000000) h[n] = 1;
}
pi[0] = 0;
rub[0] = 0;
for (int i = 1; i <= 4000000; i++) {
if (p[i])
pi[i] = pi[i - 1] + 1;
else
pi[i] = pi[i - 1];
if (h[i])
rub[i] = rub[i - 1] + 1;
else
rub[i] = rub[i - 1];
}
for (int i = 4000000; i >= 1; i--)
if (pi[i] * b <= rub[i] * a) {
printf("%d", i);
return 0;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e4 + 1;
const long long INF = 1e18;
long long n, m, l, k, x, y, z, cnt, ans, sum, mx, mn = INF, u[N];
vector<long long> v;
deque<long long> d;
string s, t;
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n;
for (int i = 0; i < n; i++) cin >> l, v.push_back(l);
for (int i = 0; i < n - 1; i++) {
if (v[i] * 2 >= v[i + 1])
cnt++, mx = max(mx, cnt);
else
cnt = 0;
}
cout << mx + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
char l, r, t;
cin >> s;
int n = s.size(), k;
for (int i = 1; i < n - 1; i++) {
k = 0;
for (int j = 0; j < 3; j++) {
if (s[i + j - 1] == '.') break;
k = k | (1 << (s[i + j - 1] - 'A'));
}
if (k == 7) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n;
char a[300000], b[300000];
long long lnum[26], rnum[26];
int main() {
scanf("%d", &n);
gets(a);
gets(a);
gets(b);
long long ans = 0, nn = 0;
for (int i = 0; i < n; i++) {
long long ii = i + 1;
nn += ii * ii;
if (a[i] == b[i]) {
long long l = i + 1, r = (n - i);
ans += l * r;
}
{
long long tmp = n - i;
rnum[b[i] - 'A'] += tmp;
}
}
double sum = 0;
double aa = ans, na = nn;
aa /= na;
sum += aa;
for (int i = 0; i < n; i++) {
long long nl = i + 1, nr = n - i;
rnum[b[i] - 'A'] -= nr;
ans = nr * lnum[a[i] - 'A'] + nl * rnum[a[i] - 'A'];
lnum[b[i] - 'A'] += nl;
double aa = ans, na = nn;
aa /= na;
sum += aa;
}
printf("%.6f\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
template <typename T>
void drop(const T &x) {
cout << x << endl;
exit(0);
}
signed main() {
Int n, k, x;
cin >> n >> k >> x;
vector<Int> as(n);
for (Int i = 0; i < n; i++) cin >> as[i];
Int po = 1;
for (Int j = 0; j < k; j++) po *= x;
vector<Int> dp(n + 1, 0), pd(n + 1, 0);
for (Int i = 0; i < n; i++) dp[i + 1] = dp[i] | as[i];
for (Int i = n - 1; i > 0; i--) pd[i - 1] = pd[i] | as[i];
Int ans = 0;
for (Int i = 0; i < n; i++) chmax(ans, dp[i] | pd[i] | (as[i] * po));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> codigo;
int large[100000], cant = 1000, pos = 0;
vector<int> Q;
int main() {
codigo["<td>"] = 2;
codigo["<table>"] = 1;
codigo["</table>"] = -1;
string in, aux;
while (cin >> aux) in = in + aux;
aux = "";
int L = in.size();
for (int i = 0; i < 999; i++) Q.push_back(i);
for (int i = 0; i < L; i++) {
aux += in[i];
if (in[i] == '>') {
int c = codigo[aux];
aux = "";
if (c == -1) {
Q.pop_back();
pos = Q.back();
} else if (c == 1) {
Q.push_back(cant);
pos = cant;
cant++;
} else if (c == 2) {
large[pos]++;
}
}
}
sort(large + 1000, large + cant);
for (int i = 1000; i < cant; i++) printf("%d ", large[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
string s;
int main() {
cin >> n >> a >> b;
cin >> s;
if (s[a - 1] != s[b - 1])
cout << "1" << endl;
else
cout << "0" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
getline(cin, s1);
getline(cin, s2);
map<char, int> m1, m2;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] != ' ') {
m1[s1[i]]++;
}
}
bool flag = true;
for (int i = 0; i < s2.length(); i++) {
if (s2[i] != ' ') {
m2[s2[i]]++;
if (m1[s2[i]] == 0) {
flag = false;
break;
}
}
}
if (flag) {
map<char, int>::iterator it;
for (it = m2.begin(); it != m2.end(); it++) {
if (it->second > m1[it->first]) {
cout << "NO";
exit(0);
}
}
cout << "YES";
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 100 * 1000 + 20, M = 1000 + 20;
int n, m, a[N], cnt[M], ans = 1;
int sum(int a, int b) { return ((a + b) % m + m) % m; }
int mul(int a, int b) { return ((a * b) % m + m) % m; }
int pw(int a, int b) {
int res = 1, tmp = a;
while (b) {
if (b & 1) res = mul(res, tmp);
tmp = mul(tmp, tmp);
b >>= 1;
}
return res;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
if (n > m) return cout << 0 << "\n", 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) ans = mul(ans, (abs(a[i] - a[j]) % m + m) % m);
return cout << ans << "\n", 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:300000000")
#pragma warning(disable : 4800)
using namespace std;
const double pi = 3.1415926535897932384626433832795;
template <class T>
T abs(const T &a) {
return a >= 0 ? a : -a;
};
template <class T>
T sqr(const T &x) {
return x * x;
}
int a[10][100], b[10][100], c[10][100];
int k, n, m;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (n); i++) {
string s;
cin >> s;
for (int j = 0; j < (m); j++) cin >> a[i][j] >> b[i][j] >> c[i][j];
}
int ans = 0;
for (int p1 = 0; p1 < (n); p1++)
for (int p2 = 0; p2 < (n); p2++)
if (p1 != p2) {
vector<pair<int, int> > v(m);
for (int t = 0; t < (m); t++) {
v[t].first = b[p2][t] - a[p1][t];
v[t].second = c[p1][t];
}
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
int s = k;
int curAns = 0;
for (int i = 0; i < (m); i++) {
if (v[i].first < 0) break;
int d = min(v[i].second, s);
curAns += d * v[i].first;
s -= d;
if (s == 0) break;
}
ans = max(ans, curAns);
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
void fun(long long k, long long tt, long long ed) {
if (tt == ed) {
if (k <= 10000000000) v.push_back(k);
return;
}
long long x = k * 10 + 4;
fun(x, tt + 1, ed);
x = k * 10 + 7;
fun(x, tt + 1, ed);
}
int32_t main() {
for (long long i = 1; i <= 10; i++) {
fun(0, 0, i);
}
sort(v.begin(), v.end());
long long l, r, ans = 0;
cin >> l >> r;
for (long long i = 0; i < v.size(); i++) {
if (l > r) break;
long long x = v[i];
long long rr = min(r, x);
if (rr >= l) {
long long k = rr - l + 1;
ans += (k * x);
l = rr + 1;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool sudah[10000];
int n, m, x, y;
int sum;
int main() {
memset(sudah, false, sizeof sudah);
cin >> n >> m;
if (n >= m) {
}
sum = 0;
sudah[0] = true;
vector<int> vi;
while (n--) {
cin >> x;
for (int i = 0; i <= m; i++) {
y = (i + x) % m;
if (sudah[i]) {
if (y == 0) {
cout << "YES\n";
return 0;
}
vi.push_back(y);
}
}
for (int i = 0; i < vi.size(); i++) sudah[vi[i]] = true;
vi.clear();
}
cout << "NO\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
double a[200005];
int main() {
cin >> n >> k;
double s;
for (int i = 1; i <= n; i++) {
cin >> s;
a[i] = a[i - 1] + s;
}
double res = 0;
for (int i = k; i <= n; i++) {
res = res + double(a[i] - a[i - k]) / (n - k + 1);
int j;
}
std::cout.setf(std::ios::fixed, std::ios::floatfield);
std::cout.precision(10);
std::cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0, k;
string s, p[20], p1;
map<string, bool> a;
int main() {
cin >> s;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> p[i];
a[p[i]] = true;
p1 = p[i][1] + p[i][0];
a[p1] = true;
}
int n = s.length();
for (int j = 0; j < k; j++) {
char b1 = p[j][0], b2 = p[j][1];
int kol1 = 0, kol2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == b1)
kol1++;
else if (s[i] == b2)
kol2++;
else
ans += min(kol1, kol2), kol1 = 0, kol2 = 0;
}
ans += min(kol1, kol2);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
istream& operator>>(istream& is, pair<S, T>& p) {
return is >> p.first >> p.second;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N;
cin >> N;
int mx = 0;
pair<int, int> ans(-1, -1);
map<pair<int, int>, pair<int, int> > memo;
for (int i = (0); i < (N); ++i) {
int x, y, z;
cin >> x >> y >> z;
if (x > y) swap(x, y);
if (y > z) swap(y, z);
if (x > y) swap(x, y);
if (memo.count(make_pair(x, y))) {
int tmp = min(min(x, y), z + memo[make_pair(x, y)].first);
if (mx < tmp) {
mx = tmp;
ans = make_pair(memo[make_pair(x, y)].second, i + 1);
}
}
if (memo.count(make_pair(x, z))) {
int tmp = min(min(x, z), y + memo[make_pair(x, z)].first);
if (mx < tmp) {
mx = tmp;
ans = make_pair(memo[make_pair(x, z)].second, i + 1);
}
}
if (memo.count(make_pair(y, z))) {
int tmp = min(min(y, z), x + memo[make_pair(y, z)].first);
if (mx < tmp) {
mx = tmp;
ans = make_pair(memo[make_pair(y, z)].second, i + 1);
}
}
if (memo[make_pair(x, y)].first < z)
memo[make_pair(x, y)] = make_pair(z, i + 1);
if (memo[make_pair(x, z)].first < y)
memo[make_pair(x, z)] = make_pair(y, i + 1);
if (memo[make_pair(y, z)].first < x)
memo[make_pair(y, z)] = make_pair(x, i + 1);
if (mx < x) {
mx = x;
ans = make_pair(i + 1, -1);
}
}
cout << (ans.second != -1 ? 2 : 1) << endl;
cout << ans.first;
if (ans.second != -1) cout << " " << ans.second;
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long Q;
double n, a, b;
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(15) << fixed;
cin >> Q;
while (Q--) {
cin >> n;
a = (n + sqrt(n * n - 4 * n)) / 2;
b = (n - sqrt(n * n - 4 * n)) / 2;
if (n > 0 && n < 4)
cout << "N\n";
else
cout << "Y " << a << " " << b << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct H {
long long a;
int w, c;
bool operator<(const H &cmp) const { return cmp.a * w > a * cmp.w; }
} hh[500001];
long long ans1;
double ans2;
void qs(int l, int r, int W) {
if (l > r) return;
if (l == r) {
ans1 += (hh[l].a * W) / hh[l].w;
ans2 += ((hh[l].a * W) % hh[l].w + 0.0) / hh[l].w;
return;
}
H cmp = hh[l + rand() % (r - l + 1)];
int i = l, j = r;
long long sw = 0, sa = 0;
while (i <= j) {
while (hh[i] < cmp) {
sw += hh[i].w;
sa += hh[i].a;
i++;
}
while (cmp < hh[j]) {
j--;
}
if (i <= j) {
sw += hh[j].w;
sa += hh[j].a;
swap(hh[i++], hh[j--]);
}
}
if (sw <= W) {
ans1 += sa;
qs(i, r, W - sw);
} else {
qs(l, i - 1, W);
}
}
int main() {
int n, m, W;
while (~scanf("%d%d%d", &n, &m, &W)) {
for (int i = 0; i < m; i++) {
scanf("%d", &hh[i].w);
}
for (int i = 0; i < m; i++) {
scanf("%I64d", &hh[i].a);
}
for (int i = 0; i < m; i++) {
scanf("%d", &hh[i].c);
}
ans1 = 0;
ans2 = 0;
for (int i = 0; i < n; i++) {
qs(0, m - 1, W);
for (int j = 0; j < m; j++) {
hh[j].a -= hh[j].c;
}
}
ans1 += (long long)ans2;
ans2 -= (long long)ans2;
printf("%I64d%.15lf\n", ans1 / 10, ans1 % 10 + ans2);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
long long pw(long long b, long long p) {
if (!p) return 1;
long long sq = pw(b, p / 2);
sq *= sq;
if (p % 2) sq *= b;
return sq;
}
vector<long long> vec;
void gen(long long x, int cnt4, int cnt7, int n) {
if (cnt4 == cnt7 && x >= n) vec.push_back(x);
if (x >= 1e10) return;
gen(x * 10 + 4, cnt4 + 1, cnt7, n);
gen(x * 10 + 7, cnt4, cnt7 + 1, n);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
gen(0, 0, 0, n);
sort(vec.begin(), vec.end());
vector<long long>::iterator it = lower_bound(vec.begin(), vec.end(), n);
cout << *it << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mara = (int)(1e6) + 5;
vector<long long> v(mara), prime(mara);
map<long long, bool> flag;
long long bigmod(long long a, long long b, long long m) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % m;
b--;
} else {
b /= 2;
a = (a * a) % m;
}
}
return res;
}
void is_prime() {
prime.push_back(2);
for (long long i = 3; i * i <= mara; i += 2) {
if (!v[i]) {
for (long long j = i * i; j <= mara; j += i + i) v[j] = 1;
}
}
for (long long i = 3; i <= mara; i += 2) {
if (!v[i]) prime.push_back(i);
}
}
void lucky(int x, int y, int z) {
if (x == y) {
v.push_back(z);
return;
}
lucky(x + 1, y, 10 * z + 4);
lucky(x + 1, y, 10 * z + 7);
}
void solve() {
long long n, k;
cin >> n >> k;
long long rem = n % k;
n += (k - rem);
cout << n << endl;
}
int main() {
{ solve(); }
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> q[maxn];
int vis[maxn];
int dp[maxn][2];
int n, k;
int ans;
int sum[maxn];
void dfs(int u, int fa) {
int len = q[u].size();
if (vis[u]) sum[u] = 1;
for (int i = 0; i < len; i++) {
int v = q[u][i];
if (v == fa) continue;
dfs(v, u);
if (dp[v][0] + 1 > dp[u][0]) {
swap(dp[u][0], dp[u][1]);
dp[u][0] = dp[v][0] + 1;
} else
dp[u][1] = max(dp[u][1], dp[v][0] + 1);
}
ans = max(dp[u][0] + dp[u][1], ans);
}
void dfs2(int u, int fa) {
int len = q[u].size();
for (int i = 0; i < len; i++) {
int v = q[u][i];
if (v == fa) continue;
if (dp[v][0] + 1 == dp[u][0]) {
dp[v][1] = max(dp[v][1], dp[u][1]);
} else {
swap(dp[v][0], dp[v][1]);
dp[v][0] = dp[u][0];
}
dfs2(v, u);
ans = max(ans, dp[v][0] + dp[v][1]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
q[u].push_back(v);
q[v].push_back(u);
}
dfs(1, -1);
dfs2(1, -1);
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int M = 8e3 + 1;
const int MD = 998244353;
long double a[M], ans = 0, pre = 1, s = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = n - 1; i >= 0 && s < 1; i--) {
ans += pre * a[i] * (1 - s);
pre = pre * (1 - a[i]);
s += a[i] / (1 - a[i]);
}
cout << fixed << setprecision(12);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int base = 1e9 + 7;
const int sz = 1e6;
int n, b, k, x, a[55000];
struct matrix {
long long a[111][111], c[111][111];
void const operator*=(matrix b) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) {
c[i][j] = 0;
for (int k = 0; k < x; k++)
c[i][j] = (c[i][j] + a[i][k] * b.a[k][j]) % base;
}
}
for (int i = 0; i < x; i++)
for (int j = 0; j < x; j++) a[i][j] = c[i][j];
}
} d, res;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> b >> k >> x;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < x; i++) {
for (int j = 1; j <= n; j++) d.a[i][(i * 10 + a[j]) % x]++;
res.a[i][i] = 1;
}
while (b) {
if (b & 1) res *= d;
d *= d;
b >>= 1;
}
cout << res.a[0][k];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e3 + 5;
int dist(pair<int, int> &x, pair<int, int> &y) {
int dx = x.first - y.first, dy = x.second - y.second;
return dx * dx + dy * dy;
}
bool right(pair<int, int> &x, pair<int, int> &y, pair<int, int> &z) {
return dist(x, y) + dist(x, z) == dist(y, z);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> a >> b;
pair<int, int> x = make_pair(0, 0), y = make_pair(-1, -1),
z = make_pair(-1, -1);
vector<pair<int, int> > ys;
for (int i = 1; i < mx; i++) {
for (int j = 1; j < mx; j++) {
if (i * i + j * j == a * a) {
ys.push_back(make_pair(i, j));
}
}
}
if (ys.empty()) {
cout << "NO" << endl;
return 0;
}
bool ok = false;
int k = ys.size();
for (int c = 0; c < k; c++) {
pair<int, int> t = ys[c];
for (int i = 1; i < mx; i++) {
for (int j = 1; j < mx; j++) {
pair<int, int> u = make_pair(-i, j);
if (i * i + j * j == b * b && right(x, t, u) && u.second != t.second) {
y = t;
z = u;
ok = true;
break;
}
if (ok) break;
}
if (ok) break;
}
if (ok) break;
}
if (z == make_pair(-1, -1)) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
cout << x.first << " " << x.second << endl;
cout << y.first << " " << y.second << endl;
cout << z.first << " " << z.second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
unsigned long long sum = 0;
for (int i = 2; i <= n; i += 2) {
for (int j = 2; j <= m; j += 2) {
sum += (n - i + 1) * (m - j + 1);
}
}
cout << sum << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long Det(long long a11, long long a12, long long a21, long long a22) {
return a11 * a22 - a12 * a21;
}
bool HasSolution(long long Ax, long long Ay, long long Bx, long long By,
long long Cx, long long Cy) {
long long d = Det(Cx, Cy, Cy, -Cx);
long long d1 = Det(Bx - Ax, Cy, By - Ay, -Cx);
long long d2 = Det(Cx, Bx - Ax, Cy, By - Ay);
if (d != 0) return d1 % d == 0 && d2 % d == 0;
return Ax == Bx && Ay == By;
}
int main() {
int Ax, Ay, Bx, By, Cx, Cy;
cin >> Ax >> Ay >> Bx >> By >> Cx >> Cy;
bool t = HasSolution(Ax, Ay, Bx, By, Cx, Cy) ||
HasSolution(Ay, -Ax, Bx, By, Cx, Cy) ||
HasSolution(-Ax, -Ay, Bx, By, Cx, Cy) ||
HasSolution(-Ay, Ax, Bx, By, Cx, Cy);
cout << (t ? "YES" : "NO") << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long k, b, n, a[100005], s[100005], ans = 0, mo;
map<long long, long long> S;
int main() {
cin >> k >> b >> n;
mo = k - 1;
for (int i = 1; i <= n; i++) cin >> a[i], s[i] = (s[i - 1] + a[i]) % mo;
S[0]++;
for (int i = 1; i <= n; i++) {
long long tmp = S[s[i] - b] + S[s[i] + k - 1 - b];
if (tmp >= i) tmp = i;
ans += tmp;
S[s[i]]++;
}
long long pos = 0, i = 1, tmp = 0;
while (i <= n) {
while (a[i] != 0 && i <= n) i++;
if (i <= n) {
pos = i + 1;
while (a[pos] == 0 && pos <= n) pos++;
tmp += (pos - i + 1) * (pos - i) / 2;
i = pos;
}
}
if (b == 0)
ans = tmp;
else if (b == mo)
ans -= tmp;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void read(long long &number) {
bool negative = false;
long long c;
number = 0;
c = getchar();
while (c == ' ' || c == '\n') c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number = -number;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << '(' << a.first << ", " << a.second << ')';
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
for (unsigned long long i = 0; i < a.size(); i++)
os << a[i] << (i < a.size() - 1 ? ", " : "");
os << ']';
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &a) {
os << '{';
for (typename set<T>::iterator it = a.begin(); it != a.end(); it++) {
typename set<T>::iterator jt = it;
os << *it << (++jt != a.end() ? ", " : "");
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &a) {
os << "{\n";
for (typename map<T1, T2>::iterator it = a.begin(); it != a.end(); it++) {
typename map<T1, T2>::iterator jt = it;
os << " " << it->first << ": " << it->second
<< (++jt != a.end() ? ",\n" : "\n");
}
os << '}';
return os;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
string s;
cin >> n >> s;
for (long long i = (long long)0; i <= (long long)s.size() - 2; i++) {
if (s[i] != s[i + 1]) {
cout << "YES" << '\n';
cout << s[i] << s[i + 1] << '\n';
return 0;
}
}
cout << "NO" << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
string b[4][110];
string board[210];
vector<int> perm;
void clean_board() {
for (int i = 0; i < 2 * n; ++i) board[i] = "";
}
void form_board() {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < n; ++j) {
board[(i > 1 ? n : 0) + j] += b[perm[i]][j];
}
}
}
int calc_change(int flag) {
string mask1 = "";
string mask2 = "";
for (int i = 0; i < n; ++i) {
mask1 += "10";
mask2 += "01";
}
if (flag) swap(mask1, mask2);
int change = 0;
for (int i = 0; i < 2 * n; ++i) {
for (int j = 0; j < 2 * n; ++j) {
if (i % 2) {
if (board[i][j] != mask1[j]) change++;
} else {
if (board[i][j] != mask2[j]) change++;
}
}
}
return change;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int a = 0; a < 4; ++a) {
for (int i = 0; i < n; ++i) {
cin >> b[a][i];
}
}
int mini = 1e5;
perm = {0, 1, 2, 3};
do {
clean_board();
form_board();
mini = min(mini, min(calc_change(1), calc_change(0)));
} while (next_permutation(perm.begin(), perm.end()));
cout << mini << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int fa[N];
bool ans, ansf = true;
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void unionn(int x, int y) { fa[y] = x; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
int fx = find(x);
int fy = find(y);
if (fx == fy)
ans = true;
else
unionn(fx, fy);
}
int x = find(1);
for (int i = 2; i <= n; ++i)
if (find(i) != x) {
ansf = false;
break;
}
if (ans && ansf && n == m)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005][2];
int main() {
int n, neg = 0, pos = 0;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
cin >> arr[i][j];
}
if (arr[i][0] > 0)
pos++;
else
neg++;
}
if (pos == 1 || neg == 1)
cout << "Yes";
else if (pos > 1 && neg > 1)
cout << "No";
else
cout << "Yes";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void sort(int& a, int& b, int& c) {
if (a < b) swap(a, b);
if (b < c) swap(b, c);
if (a < b) swap(a, b);
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int n, max_left = 0, min_right = 1e9;
cin >> n;
for (int j = 0; j < n; ++j) {
int x1, x2;
cin >> x1 >> x2;
max_left = max(max_left, x1);
min_right = min(min_right, x2);
}
if (max_left - min_right < 0)
cout << 0 << endl;
else
cout << max_left - min_right << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[6] = {-2, 1, 3, 2, -1, -3};
int main() {
cin >> n;
if (n < 3)
cout << -1;
else {
if (n == 3)
cout << 210;
else {
int t = n % 6;
int x = a[t];
for (int i = 0; i <= 9; ++i)
for (int j = 0; j <= 9; ++j) {
if ((a[3] * i + a[2] * j + x) % 7 == 0 && (1 + i + j) % 3 == 0) {
cout << 1;
for (int i = 1; i < n - 3; ++i) cout << 0;
cout << i << j << 0;
return 0;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> v[200010];
long long n;
pair<long double, long double> preff[200010], suff[200010];
pair<long double, long double> intersect(pair<long double, long double> a,
pair<long double, long double> b) {
return make_pair(max(a.first, b.first), min(a.second, b.second));
}
bool empty(pair<long double, long double> x) { return x.first > x.second; }
bool check(long double d) {
pair<long double, long double> segm = make_pair(-1e+9, 1e+9);
for (long long i = 0; i < n; i++) {
preff[i] = segm;
segm = intersect(make_pair(v[i].second - d, v[i].second + d), segm);
}
segm = make_pair(-1e+9, 1e+9);
suff[n] = segm;
for (long long i = n - 1; i >= 0; i--) {
segm = intersect(make_pair(v[i].second - d, v[i].second + d), segm);
suff[i] = segm;
}
long long jj = 0;
for (long long ii = 0; ii < n; ii++) {
while (jj < n && v[ii].first + 2 * d >= v[jj].first) jj++;
if (!empty(intersect(preff[ii], suff[jj]))) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v[i] = make_pair(x + y, x - y);
}
sort(v, v + n);
long double l = 0, r = 1e+9;
for (long long i = 0; i < 200; i++) {
long double m = (l + r) / 2;
if (check(m))
r = m;
else
l = m;
}
cout.precision(100);
cout << (l + r) / 2;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
long long p, y;
void chick(long long v) {
int k = v;
for (int i = 2; 1LL * i * i <= v && i <= p; i++) {
if (v % i == 0) return;
}
cout << v << endl;
exit(0);
}
int main() {
cin >> p;
cin >> y;
for (long long i = y; i > p; i--) chick(i);
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2 + 1 << "\n";
} else {
cout << n / 2 + 1 << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int v[26], dp[1004], n, x, y, i, nr;
char s[1004];
int main() {
scanf("%d\n%s", &n, &s);
for (i = 1; i <= 26; i++) scanf("%d", &v[i]);
dp[0] = 1;
for (i = 1; i <= n; i++) {
y = 0;
for (x = i - 1; x >= 0; x--) {
if (y < i - v[s[x] - 'a' + 1]) y = i - v[s[x] - 'a' + 1];
if (y <= x) {
dp[i] = (dp[i] + dp[x]) % 1000000007;
if (nr < i - x) nr = i - x;
}
}
}
printf("%d\n%d\n", dp[n], nr);
x = nr = 0;
y = v[s[0] - 'a' + 1];
x = 1;
for (i = 1; i < n; i++) {
y = min(y, v[s[i] - 'a' + 1]);
if (y < x + 1) {
x = 1;
y = v[s[i] - 'a' + 1];
nr++;
} else {
x++;
}
}
printf("%d", nr + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double A[107], B[107];
int main() {
int n;
double v;
cin >> n >> v;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= n; i++) cin >> B[i];
double mins = 1e9 + 7;
for (int i = 1; i <= n; i++)
if ((B[i] / A[i]) < mins) mins = B[i] / A[i];
double ans = 0;
for (int i = 1; i <= n; i++) ans += (mins * A[i]);
cout << fixed << setprecision(5) << min(ans, v) << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char ch;
int read() {
int n = 0, p = 1;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') p = -1;
for (; '0' <= ch && ch <= '9'; ch = getchar()) n = n * 10 + ch - '0';
return n * p;
}
const int N = 1e5 + 5;
const long long INF = 1e16;
int n, m, BB[N];
long long B[N][3];
struct node {
int x;
long long d;
friend bool operator<(node a, node b) { return a.d > b.d; }
};
priority_queue<node> pq;
queue<int> q[N];
long long dis[N], f[N];
int main() {
n = read(), m = read();
int Q = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read(), z = read();
B[i][1] = y, B[i][0] = BB[x], B[i][2] = z, BB[x] = i;
}
for (int i = 2; i <= n; ++i) dis[i] = INF;
for (pq.push((node){1, dis[1] = 0}); !pq.empty();) {
node now = pq.top();
pq.pop();
int u = now.x;
if (now.d > dis[u]) continue;
for (int i = BB[u], v = B[BB[u]][1]; i; v = B[i = B[i][0]][1])
if (dis[u] + B[i][2] < dis[v])
pq.push((node){v, dis[v] = dis[u] + B[i][2]});
}
while (Q--) {
int tp = read();
if (tp == 1) {
int x = read();
if (dis[x] >= INF)
puts("-1");
else
printf("%I64d\n", dis[x]);
} else {
int k = read();
for (int i = 1; i <= k; ++i) ++B[read()][2];
k = ((k) < (n - 1) ? (k) : (n - 1));
for (int i = 2; i <= n; ++i) f[i] = n + 1;
q[f[1] = 0].push(1);
for (int h = 0; h <= k; ++h)
while (!q[h].empty()) {
int u = q[h].front();
q[h].pop();
if (h > f[u]) continue;
for (int i = BB[u], v = B[BB[u]][1]; i; v = B[i = B[i][0]][1])
if (h + dis[u] + B[i][2] - dis[v] < f[v]) {
f[v] = h + dis[u] + B[i][2] - dis[v];
if (f[v] <= k) q[f[v]].push(v);
}
}
for (int i = 2; i <= n; ++i)
dis[i] = ((INF) < (dis[i] + f[i]) ? (INF) : (dis[i] + f[i]));
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T> >;
template <class T>
struct PrimalDual {
struct Edge {
int to, rev;
T cap, cost;
};
const T inf = numeric_limits<T>::max();
const int n;
VV<Edge> g;
V<T> pot, dist;
V<> pv, pe;
PrimalDual(int n) : n(n), g(n), pot(n), dist(n), pv(n), pe(n) {}
void add_edge(int from, int to, T cap, T cost) {
assert(from != to);
assert(cap >= 0);
if (!cap) return;
assert(cost >= 0);
g[from].emplace_back(Edge{to, (int)g[to].size(), cap, cost});
g[to].emplace_back(Edge{from, (int)g[from].size() - 1, 0, -cost});
}
void dijkstra(int s) {
using P = pair<T, int>;
priority_queue<P, V<P>, greater<P> > pque;
fill(begin(dist), end(dist), inf);
pque.emplace(dist[s] = 0, s);
while (!pque.empty()) {
T d;
int v;
tie(d, v) = pque.top();
pque.pop();
if (d > dist[v]) continue;
for (int i = 0; i < (int)g[v].size(); ++i) {
const Edge& e = g[v][i];
if (!e.cap or dist[e.to] <= dist[v] + e.cost - (pot[e.to] - pot[v]))
continue;
pv[e.to] = v, pe[e.to] = i;
pque.emplace(dist[e.to] = dist[v] + e.cost - (pot[e.to] - pot[v]),
e.to);
}
}
}
T min_cost_flow(int s, int t, T f) {
assert(s != t);
assert(f >= 0);
T res = 0;
fill(begin(pot), end(pot), 0);
while (f > 0) {
dijkstra(s);
if (dist[t] == inf) return -1;
for (int v = 0; v < n; ++v) pot[v] += dist[v];
T d = f;
for (int v = t; v != s; v = pv[v]) {
d = min(d, g[pv[v]][pe[v]].cap);
}
f -= d;
res += d * pot[t];
for (int v = t; v != s; v = pv[v]) {
Edge& e = g[pv[v]][pe[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m, k, c, d;
cin >> n >> m >> k >> c >> d;
V<> a(k);
for (auto&& e : a) cin >> e, --e;
auto _ = [&](int t, int v) -> int { return t * n + v; };
int S = 100 * n, T = S + 1;
PrimalDual<int> g(T + 1);
for (int t = 0; t + 1 < 100; ++t)
for (int v = 0; v < n; ++v) {
g.add_edge(_(t, v), _(t + 1, v), g.inf, 0);
}
while (m--) {
int u, v;
cin >> u >> v, --u, --v;
for (int t = 0; t + 1 < 100; ++t) {
for (int x = 0; x < k; ++x) {
g.add_edge(_(t, u), _(t + 1, v), 1, d * (2 * x + 1));
g.add_edge(_(t, v), _(t + 1, u), 1, d * (2 * x + 1));
}
}
}
for (int i = 0; i < k; ++i) {
g.add_edge(S, _(0, a[i]), 1, 0);
}
for (int t = 0; t < 100; ++t) {
g.add_edge(_(t, 0), T, g.inf, c * t);
}
cout << g.min_cost_flow(S, T, k) << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
long long M;
cin >> N >> M;
vector<pair<long long, long long>> v(M);
for (long long i = 0; i < M; i++) {
cin >> v[i].first >> v[i].second;
if (v[i].second < v[i].first) swap(v[i].first, v[i].second);
}
sort(v.begin(), v.end());
vector<pair<long long, long long>> ar;
ar.push_back(v[0]);
for (long long i = 1; i < M; i++) {
if (v[i] != v[i - 1]) ar.push_back(v[i]);
}
long long X = ar[0].first;
long long Y = ar[0].second;
vector<pair<long long, long long>> d;
vector<pair<long long, long long>> r;
for (long long i = 0; i < ar.size(); i++) {
if (ar[i].first != X && ar[i].second != X) d.push_back(ar[i]);
if (ar[i].first != Y && ar[i].second != Y) r.push_back(ar[i]);
}
if (d.size() == 0 || r.size() == 0) {
cout << "YES";
return 0;
}
long long xx = d[0].first;
long long yx = d[0].second;
long long xy = r[0].first;
long long yy = r[0].second;
long long cx = 0, cy = 0, dx = 0, dy = 0;
for (long long i = 0; i < d.size(); i++) {
if (d[i].first != xx && d[i].second != xx) cx++;
if (d[i].first != yx && d[i].second != yx) cy++;
}
for (long long i = 0; i < r.size(); i++) {
if (r[i].first != xy && r[i].second != xy) dx++;
if (r[i].first != yy && r[i].second != yy) dy++;
}
if (cx == 0 || cy == 0 || dx == 0 || dy == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.