solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int dirx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int diry[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool compare(const pair<int, int>& i, const pair<int, int>& j) {
return i.second < j.second;
}
int main() {
long long n, k;
cin >> n >> k;
if (n == 1) {
if (k > 0)
cout << "-1";
else
cout << "1";
} else {
long long arr[n];
for (long long i = (2); i <= (n - 1); ++i) {
arr[i] = i + 1;
}
long long x = n / 2;
if (k < x)
cout << "-1";
else {
x = k + 1 - n / 2;
long long y = n / x;
long long z = (y + 1) * x;
long long q = z + x;
arr[0] = z;
arr[1] = q;
for (long long i = 0; i < n; i++) cout << arr[i] << " ";
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
scanf("%d%d", &n, &x);
int a[n + 5][2];
for (int i = 0; i <= n - 1; i++) scanf("%d %d", &a[i][0], &a[i][1]);
int prev = 1, view = 0;
for (int i = 0; i <= n - 1; i++) {
view = view - prev - (((a[i][0] - prev) / x) * x) + a[i][1] + 1;
prev = a[i][1] + 1;
}
printf("%d", view);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
int i = 1, j = n;
int cnt = 0;
vector<int> v;
for (int p = 1; p <= n; p++) {
if (p % 2 != 0) {
cout << i << " ";
i++;
cnt++;
if (cnt == k) {
for (int q = i; q <= j; q++) cout << q << " ";
break;
}
} else if (p % 2 == 0) {
cout << j << " ";
j--;
cnt++;
if (cnt == k) {
for (int q = j; q >= i; q--) cout << q << " ";
break;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int MAXN = 1e9 + 1;
const double PI = 3.14159265359;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
long long mn = 1e18;
for (int i = 1; i <= n; ++i) {
long long w = n / i;
if (n % i == 0 && w < k) {
long long z = k * i;
mn = min(mn, z + w);
}
}
cout << mn;
return 0;
}
| 3 |
/**
____ ____ ____ ____ ____
||a |||t |||o |||d |||o ||
||__|||__|||__|||__|||__||
|/__\|/__\|/__\|/__\|/__\|
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N_MAX = 100002;
const int M_MAX = 100002;
const int A_MAX = 100002;
const int A = 100000;
int n, m;
int arr[N_MAX];
int bucketSize;
struct Query
{
int l, r, k;
int cntUpdates;
int index;
};
bool operator < (const Query &a, const Query &b)
{
return make_pair(make_pair((a.l - 1) / bucketSize, (a.r - 1) / bucketSize), a.cntUpdates)
< make_pair(make_pair((b.l - 1) / bucketSize, (b.r - 1) / bucketSize), b.cntUpdates);
}
int aux[N_MAX];
struct Update
{
int pos, oldval, newval;
};
vector <Query> queries;
vector <Update> updates;
int answer[M_MAX];
int freq[A_MAX];
int sortedFreq[A_MAX];
int firstOcc[N_MAX], lastOcc[N_MAX], cntOcc[N_MAX];
void insertValue (int val)
{
sortedFreq[lastOcc[freq[val]]]++;
cntOcc[freq[val]]--;
cntOcc[freq[val] + 1]++;
firstOcc[freq[val] + 1] = lastOcc[freq[val]];
lastOcc[freq[val]]--;
if(cntOcc[freq[val] + 1] == 1)
lastOcc[freq[val] + 1] = firstOcc[freq[val] + 1];
freq[val]++;
}
void eraseValue (int val)
{
sortedFreq[firstOcc[freq[val]]]--;
cntOcc[freq[val]]--;
cntOcc[freq[val] - 1]++;
lastOcc[freq[val] - 1] = firstOcc[freq[val]];
firstOcc[freq[val]]++;
if(cntOcc[freq[val] - 1] == 1)
firstOcc[freq[val] - 1] = lastOcc[freq[val] - 1];
freq[val]--;
}
int getAnswer (int k)
{
int ans = INT_MAX;
for(int i = 1; i <= A; i++)
{
i = lastOcc[sortedFreq[i]];
if(i - k + 1 >= 1 && sortedFreq[i - k + 1] > 0)
ans = min(ans, sortedFreq[i] - sortedFreq[i - k + 1]);
}
if(ans == INT_MAX)
ans = -1;
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for(int i = 1; i <= n; i++)
cin >> arr[i];
bucketSize = pow(2.0 * n * n, 1.0 / 3.0);
for(int i = 1; i <= n; i++)
aux[i] = arr[i];
for(int i = 1; i <= m; i++)
{
int type;
cin >> type;
if(type == 1)
{
int l, r, k;
cin >> l >> r >> k;
queries.push_back(Query{l, r, k, (int)updates.size(), (int)queries.size() + 1});
}
else
{
int pos, newval;
cin >> pos >> newval;
updates.push_back(Update{pos, aux[pos], newval});
aux[pos] = newval;
}
}
sort(queries.begin(), queries.end());
int l = 1, r = 0, cntUpdates = 0;
cntOcc[0] = A;
firstOcc[0] = 1;
lastOcc[0] = A;
for(Query q : queries)
{
while(q.l < l)
{
l--;
insertValue(arr[l]);
}
while(r < q.r)
{
r++;
insertValue(arr[r]);
}
while(l < q.l)
{
eraseValue(arr[l]);
l++;
}
while(q.r < r)
{
eraseValue(arr[r]);
r--;
}
while(cntUpdates < q.cntUpdates)
{
cntUpdates++;
Update u = updates[cntUpdates - 1];
if(l <= u.pos && u.pos <= r)
{
eraseValue(u.oldval);
insertValue(u.newval);
}
arr[u.pos] = u.newval;
}
while(q.cntUpdates < cntUpdates)
{
Update u = updates[cntUpdates - 1];
if(l <= u.pos && u.pos <= r)
{
eraseValue(u.newval);
insertValue(u.oldval);
}
arr[u.pos] = u.oldval;
cntUpdates--;
}
answer[q.index] = getAnswer(q.k);
}
for(int i = 1; i <= (int)queries.size(); i++)
cout << answer[i] << "\n";
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int f[200200];
char P[200200], T[200200];
long long nump[200200], numt[200200];
int m, n;
long long ans = 0;
int test(char s[], char t[], int si, int ti, long long nums[],
long long numt[]) {
if (s[si] != t[ti] || numt[ti] < nums[si]) return 0;
if (si < 2) {
return 1;
} else {
if (numt[ti - 1] != nums[si - 1]) return 0;
return 1;
}
}
void getFail() {
f[0] = 0;
f[1] = 0;
for (int i = 1; i < m; i++) {
int j = f[i];
while (j && !test(P, P, j, i, nump, nump)) {
j = f[j];
}
f[i + 1] = test(P, P, j, i, nump, nump) ? j + 1 : 0;
}
}
long long find() {
getFail();
int j = 0;
for (int i = 0; i < n; i++) {
while (j && !test(P, T, j, i, nump, numt)) {
j = f[j];
}
if (test(P, T, j, i, nump, numt)) {
j++;
}
if (j == m) {
if (m == 1) {
ans += numt[i] - nump[0] + 1;
} else
ans++;
j = f[j];
}
}
return ans;
}
int main(int argc, const char* argv[]) {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int num;
char key;
scanf("%d-%c", &num, &key);
T[i] = key;
numt[i] = num;
}
for (int i = 0; i < m; i++) {
int num;
char key;
scanf("%d-%c", &num, &key);
P[i] = key;
nump[i] = num;
}
int tn = 1, tm = 1;
for (int i = 1; i < n; i++) {
if (T[i] == T[tn - 1]) {
numt[tn - 1] += numt[i];
} else {
T[tn] = T[i];
numt[tn] = numt[i];
tn++;
}
}
for (int i = 1; i < m; i++) {
if (P[i] == P[tm - 1]) {
nump[tm - 1] += nump[i];
} else {
P[tm] = P[i];
nump[tm] = nump[i];
tm++;
}
}
n = tn;
m = tm;
find();
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 0, n = 0, l = 0, r = 0, flag = 0, p = 0, my = 0;
cin >> t;
while (t--) {
cin >> n;
vector<tuple<int, int, int> > v;
for (int i = 0; i < n; ++i) {
cin >> l >> r;
v.emplace_back(l, r, i);
}
sort(v.begin(), v.end());
vector<int> res(n);
flag = 0;
p = 1;
my = 0;
for (auto i : v) {
int x, y, z;
tie(x, y, z) = i;
if (my < x) {
p ^= 1;
++flag;
}
res[z] = p + 1;
my = max(my, y);
}
if (flag == 1)
cout << "-1";
else {
for (auto i : res) {
cout << i << " ";
}
}
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long u, v;
scanf("%lld %lld", &u, &v);
auto p = (v - u) / 2;
if (u == 0 && v == 0)
printf("0");
else if (u == v)
printf("1\n%lld", u);
else if (u % 2 != v % 2 || u > v)
printf("-1");
else if (((u + p) ^ p) == u)
printf("2\n%lld %lld", u + p, p);
else
printf("3\n%lld %lld %lld", u, (v - u) / 2, (v - u) / 2);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005, M = 105;
int n, m, p;
int a[N], sum[N], tmp[N], ans;
int g[N], len = 1;
struct tree {
int c[M], d[M];
tree() {
memset(c, 0x3f, sizeof(c));
memset(d, 0x3f, sizeof(d));
}
void add1(int x, int k) {
x++;
for (; x <= p; x += x & (-x)) c[x] = min(k, c[x]);
}
void add2(int x, int k) {
x++;
for (; x; x -= x & (-x)) d[x] = min(k, d[x]);
}
int ask1(int x) {
x++;
int res = 0x3f3f3f3f;
for (; x; x -= x & (-x)) res = min(c[x], res);
return res;
}
int ask2(int x) {
x++;
int res = 0x3f3f3f3f;
for (; x <= p; x += x & (-x)) res = min(d[x], res);
return res;
}
} f[M];
void solve1() {
for (int i = 1; i <= n; i++) tmp[i] = sum[i];
for (int j = 2; j <= m; j++)
for (int i = j - 1; i <= n; i++) {
if (i >= j)
ans = min(f[j - 1].ask1(sum[i]) + sum[i],
f[j - 1].ask2(sum[i] + 1) + sum[i] + p);
f[j - 1].add1(sum[i], tmp[i] - sum[i]),
f[j - 1].add2(sum[i], tmp[i] - sum[i]);
if (i >= j) tmp[i] = ans;
}
}
void solve2() {
memset(g, 0x3f, sizeof(g));
ans = sum[n];
int j;
for (int i = 1; i <= n; i++) {
j = upper_bound(g + 1, g + 1 + n, sum[i]) - g;
g[j] = sum[i];
}
ans += (j < m) * p;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) sum[i] = (sum[i - 1] + a[i]) % p;
if (n <= m * p)
solve1();
else
solve2();
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, y = 0;
char f[1000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> f[i];
if (i % 2 == 0)
if (f[i] == '0')
x++;
else
y++;
else if (f[i] == '1')
x++;
else
y++;
}
if (x < y) y = x;
cout << y;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, a[505], f[505][505], g[505][505], ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) {
g[i][j] = n + 1;
}
for (int i = (1); i <= (n); i++) {
f[i][i] = a[i];
g[i][i] = 1;
}
ans = n;
for (int len = (2); len <= (n); len++) {
for (int i = (1); i <= (n - len + 1); i++) {
int j = i + len - 1;
for (int k = (i); k <= (j - 1); k++) {
if (g[i][j] == 1) break;
g[i][j] = min(g[i][j], g[i][k] + g[k + 1][j]);
if (f[i][k] > 0 && f[i][k] == f[k + 1][j]) {
f[i][j] = f[i][k] + 1;
g[i][j] = 1;
}
}
}
}
cout << g[1][n];
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, maxcount = 0, t, count = 0, last = 0;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> t;
if (last >= t) {
if (count > maxcount) maxcount = count;
count = 1;
} else
count++;
last = t;
}
if (maxcount > count)
cout << maxcount << endl;
else
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, k;
cin >> b >> k;
int l;
int odd = 0, even = 0;
for (int i = 0; i < k; i++) {
cin >> l;
if (l % 2 != 0 && (k - i - 1) == 0)
odd++;
else if (l % 2 != 0 && b % 2 != 0)
odd++;
else
even++;
}
if (odd % 2 == 0)
cout << "even" << endl;
else
cout << "odd" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, d[N];
inline int read() {
int x = 0, p = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * p;
}
void init() {
n = read();
for (int i = 1; i <= n; ++i) {
d[i] = read();
}
}
void solve() {
sort(d + 1, d + n + 1);
if (d[n] < d[1] + d[n - 1]) return;
if (n != 3 && d[n] < d[n - 1] + d[n - 2]) {
for (int i = n - 2; i > 1; --i) {
swap(d[i], d[i - 1]);
}
return;
}
puts("NO");
exit(0);
}
void putout() {
puts("YES");
for (int i = 1; i <= n; ++i) {
cout << d[i] << ' ';
}
puts("");
}
int main() {
init();
solve();
putout();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b >> c;
cout << c * 2 + min(a, b) * 2 + (a != b);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5004;
int memo[N][N], go[N], n, k;
int solve(int indx, int rem) {
if (indx == n) return 0;
int &ret = memo[indx][rem];
if (~ret) return ret;
ret = 0;
ret = max(ret, solve(indx + 1, rem));
if (rem) ret = max(ret, go[indx] - indx + solve(go[indx], rem - 1));
return ret;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
vector<int> a(n);
for (int &x : a) cin >> x;
sort((a).begin(), (a).end());
memset(memo, -1, sizeof memo);
for (int i = 0; i < n; ++i) {
auto it = upper_bound((a).begin(), (a).end(), a[i] + 5);
int indx = it - a.begin();
go[i] = indx;
}
cout << solve(0, k) << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100 * 2;
int s[N], p[N], a[N], b[N];
int cmp(int i, int j) { return s[i] < s[j]; }
int main() {
int n, m;
scanf("%d", &n);
m = (n + 2) / 3;
printf("YES\n");
for (int i = 0; i < n; i++) scanf("%d", &s[i]), p[i] = i;
sort(p, p + n, cmp);
for (int i = 0; i < m; i++) {
a[p[i]] = i;
b[p[i]] = s[p[i]] - i;
}
for (int i = m; i < n - m; i++) {
b[p[i]] = i;
a[p[i]] = s[p[i]] - i;
}
for (int i = n - m; i < n; i++) {
int tmp = n - i - 1;
b[p[i]] = tmp;
a[p[i]] = s[p[i]] - tmp;
}
for (int i = 0; i < n; i++) {
i == 0 ? printf("%d", a[i]) : printf(" %d", a[i]);
}
printf("\n");
for (int i = 0; i < n; i++) {
i == 0 ? printf("%d", b[i]) : printf(" %d", b[i]);
}
printf("\n");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c, d, k;
int ans = 0;
cin >> c >> d >> n >> m >> k;
if (n * m - k <= 0) {
ans = 0;
} else {
if (d * n > c) {
ans += (n * m - k) / n * c;
if ((n * m - k) % n * d > c) {
ans += c;
} else {
ans += (n * m - k) % n * d;
}
} else {
ans += (n * m - k) * d;
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int A = 1e3 + 10;
int k, n[15], a[15][A], x[15], sum;
int main() {
cin >> k;
for (int i = 0; i < k; i++) {
cin >> n[i];
for (int j = 0; j < n[i]; j++) {
cin >> a[i][j];
}
for (int j = n[i]; j > 0; j--) {
for (int h = 0; h < n[i]; h++) {
if (a[i][h] >= j) {
sum++;
}
}
if (sum >= j) {
x[i] = j;
sum = 0;
break;
}
sum = 0;
}
}
for (int i = 0; i < k; i++) {
cout << x[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.precision(15);
cout.setf(ios::floatfield, ios::fixed);
long t;
cin >> t;
while (t--) {
double a1, a2, b1, b2, c, r, d;
cin >> d;
r = d * d - 4 * d;
if (r < 0) {
cout << "N" << endl;
continue;
}
a1 = (d + sqrt(r)) / 2;
b1 = d - a1;
if (a1 >= 0 && b1 >= 0) {
cout << "Y"
<< " " << a1 << " " << b1 << endl;
continue;
}
a2 = (d - sqrt(r)) / 2;
b2 = d - a2;
if (a2 >= 0 && b2 >= 0) {
cout << "Y"
<< " " << a2 << " " << b2 << endl;
continue;
}
cout << "N" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, q;
long long mi[200010], ma[200010], cnt[200010];
vector<pair<long long, long long> > g[200010];
long long f[200010];
int main() {
for (int i = 0; i < 200010; i++) {
mi[i] = 1e17, ma[i] = -1e17, cnt[i] = 0;
}
cin >> n >> q;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
mi[a] = min(mi[a], i);
ma[a] = max(ma[a], i);
cnt[a]++;
}
vector<pair<long long, pair<long long, long long> > > v;
for (int i = 0; i < 200010; i++) {
if (cnt[i] > 0) {
v.push_back(make_pair(mi[i], make_pair(cnt[i], ma[i])));
}
}
v.push_back(make_pair(1e17, make_pair(0, 1e17)));
sort(v.begin(), v.end());
long long ans = 0;
long long ma = -1, tot = -1;
for (int i = 0; i < v.size(); i++) {
long long cost = v[i].second.first;
long long x = v[i].first, y = v[i].second.second;
if (ma < x) {
if (~tot) ans += tot;
ma = -1, tot = -1;
}
ma = max(ma, y);
tot = max(tot, cost);
}
cout << n - ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb emplace_back
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pq priority_queue<int>
#define pqs priority_queue<int,vi,greater<int>>
#define all(x) x.begin() , x.end()
#define sortall(x) sort(all(x));
#define clr(x) memset(x , 0 , sizeof(x))
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define sp(x,y) fixed<<setprecision(y)<<x
#define query int q; cin>>q; while(q--)
#define fo(a,n) for(int i = a ; i < n ; i++)
#define forev(n,a) for(int i = n ; i >= 0 ; i--)
#define deb(x) cout << #x << " = " << x << endl
#define debar(x) fo(i , x.size()) cout << x[i] <<" "
#define endl '\n'
#define FIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const int MOD = 1e9 + 7;
const int INF = 1e18;
const int N = 1e5 + 5;
void solve(){
int n;
cin >> n;
vi ar(n+2);
fo(0 , n + 2) cin >> ar[i];
sort(all(ar));
int mx = ar[n+1];
int smx = ar[n];
int s = 0;
for(int i = 0 ; i < n ; i++) s += ar[i];
if(s == mx || s == smx){
for(int i = 0; i < n ; i++){
cout << ar[i] << " ";
}
cout << endl;
return;
}
s += smx;
int i = 0;
for(; i < n + 1 ; i++){
if(s - ar[i] == mx){
break;
}
}
if(i == n + 1){
cout << -1 << endl;
return;
}
for(int j = 0 ; j < n + 1 ; j++){
if(j == i) continue;
else cout << ar[j] << " ";
}
cout << endl;
}
int32_t main() {
FIO;
int t = 1;
cin >> t;
while(t--){
solve();
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> edge;
vector<int> dist;
vector<int> et;
vector<int> first;
void inedge(int n, int m) {
edge.resize(n + 1);
dist.resize(n + 1, -1);
first.resize(n + 1);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
}
void dfs(int v, int p, int h) {
if (dist[v] != -1) return;
dist[v] = h;
first[v] = et.size();
et.push_back(h);
for (int i = 0; i < edge[v].size(); i++) {
if (p - edge[v][i]) {
dfs(edge[v][i], v, h + 1);
et.push_back(h);
}
}
}
vector<int> t;
int n;
void build(vector<int>& vv) {
n = vv.size();
t.resize(2 * n, INT_MAX);
for (int i = 0; i < n; i++) t[i + n] = vv[i];
for (int i = n - 1; i > 0; i--) {
t[i] = min(t[i << 1], t[i << 1 | 1]);
}
}
int rq(int l, int r) {
int res = INT_MAX;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(res, t[--r]);
}
return res;
}
int dt(int a, int b) {
if (first[a] > first[b]) swap(a, b);
int dlca = rq(first[a], first[b]);
return dist[a] + dist[b] - 2 * dlca;
}
int main() {
int n;
cin >> n;
inedge(n, n - 1);
dfs(1, -1, 0);
build(et);
int q, x, y, a, b, k;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
int d1 = dt(a, b);
int d2 = dt(a, x) + dt(y, b) + 1;
int d3 = dt(a, y) + dt(x, b) + 1;
if (d1 <= k && (d1 % 2 == k % 2)) {
cout << "YES\n";
} else if (d2 <= k && (d2 % 2 == k % 2)) {
cout << "YES\n";
} else if (d3 <= k && (d3 % 2 == k % 2)) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int atk[102], def[102], my[102];
int solve1(int m, int a) {
int ans = 0;
int j = 0;
for (int i = m - 1; i >= 0; --i) {
if (j < a && my[i] >= atk[j]) {
ans += my[i] - atk[j++];
} else {
break;
}
}
return ans;
}
int solv(int m, int a, int b) {
int k = 0, l = 0, sol2 = 0;
vector<int> del(m, 0);
while (k < b && l < m) {
if (def[k] < my[l]) {
k++;
del[l] = 1;
l++;
} else {
l++;
}
}
if (k != b) {
sol2 = 0;
return 0;
}
k = 0;
l = 0;
while (k < a && l < m) {
if (del[l] == 1) {
l++;
continue;
}
if (atk[k] <= my[l]) {
del[l] = 1;
sol2 += my[l] - atk[k];
k++;
l++;
} else {
l++;
}
}
if (k != a) {
return sol2;
}
for (int i = 0; i < m; i++) {
if (del[i] == 1) continue;
sol2 += my[i];
}
return sol2;
}
int solve2(int m, int a, int d) {
vector<int> del(m, 0);
int j = 0;
for (int i = 0; i < d; ++i) {
while (j < m && my[j] <= def[i]) {
j++;
}
if (j >= m) {
return -1;
} else {
del[j] = 1;
j++;
}
}
j = 0;
int ans = 0;
for (int i = 0; i < a; ++i) {
while (j < m && (del[j] || my[j] < atk[i])) {
j++;
}
if (j >= m) return ans;
ans += my[j] - atk[i];
del[j] = 1;
j++;
}
for (int i = 0; i < m; ++i) {
if (!del[i]) {
ans += my[i];
}
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
string s;
int a = 0, d = 0, x;
for (int i = 0; i < n; ++i) {
cin >> s;
cin >> x;
if (s[0] == 'A') {
atk[a++] = x;
} else {
def[d++] = x;
}
}
for (int i = 0; i < m; ++i) {
cin >> x;
my[i] = x;
}
sort(atk, atk + a);
sort(def, def + d);
sort(my, my + m);
int sol1 = solve1(m, a);
int sol2 = solve2(m, a, d);
cout << max(sol1, sol2) << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char a[1010], b[1010];
int main() {
int i, a1 = 0, b1 = 0;
scanf("%s%s", &a, &b);
i = 0;
while (a[i] == '0' || a[i] == '1') {
a1 = a1 + a[i] - '0';
i++;
}
i = 0;
while (b[i] == '0' || b[i] == '1') {
b1 = b1 + b[i] - '0';
i++;
}
if (a1 + a1 % 2 >= b1)
printf("YES");
else
printf("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 3e5 + 5;
int a[maxn];
int lef[maxn];
int righ[maxn];
int go[maxn];
void solve() {
int n, x;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
set<int> bb;
for (int i = 1; i <= n; ++i) {
bb.insert(a[i]);
}
vector<int> b;
for (auto key : bb) b.push_back(key);
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin() + 1;
int ans = n;
for (int i = 1; i <= n; ++i) {
lef[i] = n + 1;
righ[i] = -1;
}
for (int i = 1; i <= n; ++i)
lef[a[i]] = min(lef[a[i]], i), righ[a[i]] = max(righ[a[i]], i);
n = (int)b.size();
go[n + 1] = -1;
for (int i = n; i >= 1; --i) {
if (go[i + 1] == -1)
go[i] = i;
else {
int l1 = lef[i], r1 = righ[i], l2 = lef[i + 1], r2 = righ[i + 1];
if (r1 < l2)
go[i] = go[i + 1];
else
go[i] = i;
}
ans = min(ans, n - (go[i] - i + 1));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1), EPS = 1e-8;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
bool getBit(long long num, int idx) { return ((num >> idx) & 1); }
long long setBit(long long num, int idx, bool val) {
return val ? (num | (1LL << idx)) : (num & ~(1LL << idx));
}
long long flipBit(long long num, int idx) { return (num ^ (1LL << idx)); }
long long leastBit(long long num) { return (num & -num); }
long long Mod(long long num, long long mod) { return (num & mod - 1); }
bool isPowerOfTwo(int first) { return first && (!(first & (first - 1))); }
int turnOnLastZero(int S) { return S | S + 1; }
int turnOffLastBit(int S) { return S & S - 1; }
int turnOnLastConsecutiveZeroes(int S) { return S | S - 1; }
int turnOffLastConsecutiveBits(int S) { return S & S + 1; }
vector<int> genAllSubmask(int mask) {
vector<int> v;
for (int subMask = mask;; subMask = (subMask - 1) & mask) {
v.push_back(subMask);
if (subMask == 0) break;
}
return v;
}
long long fast_power(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 1) {
result = (result * base) % 1000000007;
}
base = (base * base) % 1000000007;
power = power / 2;
}
return result;
}
bool isprime(long long n) {
bool flag = true;
if (n <= 1) return false;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
flag = false;
break;
}
}
return flag;
}
long long n, m, k, ansl, ansr;
vector<long long> fre(26);
string s;
void slove() {
cin >> n;
vector<long long> v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = n; i >= 0; i--) {
for (int j = 1; j < i; j++) {
if (v[j] > v[j + 1]) {
swap(v[j], v[j + 1]);
cout << j << " " << j + 1 << "\n";
}
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
slove();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 42;
int n, m;
vector<int> dp;
const int mod = 1e9 + 7;
int main() {
cin >> n;
dp.resize(MAXN);
dp[1] = 1;
int maxi = 1;
char prv = 's';
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
if (c == 'f') ++maxi;
vector<int> newdp(maxi + 4);
if (prv == 'f') {
for (int j = maxi + 2; j >= 1; --j) {
newdp[j] = dp[j - 1];
}
swap(dp, newdp);
prv = c;
continue;
}
int tsum = 0;
for (int j = maxi + 2; j >= 1; --j) {
tsum += dp[j];
tsum %= mod;
newdp[j] += tsum;
newdp[j] %= mod;
if (c == 's') {
} else {
}
newdp[j] %= mod;
}
swap(newdp, dp);
prv = c;
}
int sum = 0;
for (int i = 0; i < dp.size(); ++i) {
sum += dp[i];
sum %= mod;
}
cout << sum;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7, RT = 200;
int p[N];
int fr[N];
bool dp[N];
int cnt[N];
int mn[N], mx[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
int odd = 0;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) {
if (p[i] == -1) continue;
int cur = i, cnt = 0;
while (true) {
cnt++;
int nw = p[cur];
p[cur] = -1;
cur = nw;
if (cur == i) break;
}
fr[cnt]++;
if (cnt % 2) odd++;
}
dp[0] = 1;
for (int i = 1; i <= RT; i++) {
if (fr[i] == 0) continue;
int y = (fr[i] + 1) * i;
for (int x = 0; x < N; x++) cnt[x] = dp[x];
for (int x = i; x < N; x++) {
cnt[x] += cnt[x - i];
int val = cnt[x];
if (x - y >= 0) val -= cnt[x - y];
dp[x] = val;
}
}
bitset<N> bs;
for (int i = 0; i < N; i++) bs[i] = dp[i];
for (int i = RT + 1; i <= n; i++) {
while (fr[i]) {
bs = bs | (bs << i);
fr[i]--;
}
}
int pr = n - odd;
assert(pr % 2 == 0);
for (int i = 0; i <= pr / 2; i++) mx[i] = 2 * i;
for (int i = pr / 2 + 1; i <= n; i++) mx[i] = min(n, mx[i - 1] + 1);
for (int i = 0; i <= n; i++) mn[i] = i + !bs[i];
cout << mn[k] << " " << mx[k] << endl;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int MAXN = 1000010;
long long a[MAXN];
long long pow2[MAXN];
void init() {
pow2[0] = 1;
for (int i = 1; i < MAXN; i++) pow2[i] = pow2[i - 1] << 1, pow2[i] %= MOD;
}
long long f(int n) {
if (n == 0) return 1;
long long N = n;
return ((N + 2) * pow2[N - 1]) % MOD;
}
long long inv(long long n) {
return n == 1 ? 1 : (MOD - MOD / n) * inv(MOD % n) % MOD;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
init();
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[n - 1 - i] * f(i) % MOD;
ans %= MOD;
}
ans += MOD;
ans %= MOD;
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1E-9;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double PI = 2 * acos(.0);
int n, m, k;
int dp[105][105][12];
char path[105][105][12];
char mapa[105][105];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0; i < (int)(n); i++) {
cin >> mapa[i];
}
memset(dp, -1, sizeof(dp));
for (int j = 0; j < (int)(m); j++)
dp[0][j][(mapa[0][j] - '0') % (k + 1)] = (mapa[0][j] - '0');
for (int i = 1; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
for (int p = 0; p < (int)(k + 2); p++) {
if (j > 0) {
if (dp[i - 1][j - 1][p] != -1) {
int sum = (mapa[i][j] - '0') + dp[i - 1][j - 1][p];
int modu = sum % (k + 1);
if (sum > dp[i][j][modu]) {
dp[i][j][modu] = sum;
path[i][j][modu] = 'L';
}
}
}
if (j < m - 1) {
if (dp[i - 1][j + 1][p] == -1) continue;
int sum = (mapa[i][j] - '0') + dp[i - 1][j + 1][p];
int modu = sum % (k + 1);
if (sum > dp[i][j][modu]) {
dp[i][j][modu] = sum;
path[i][j][modu] = 'R';
}
dp[i][j][modu] = max(sum, dp[i][j][modu]);
}
}
}
}
int maxi = -1;
int col = -1;
for (int i = 0; i < (int)(m); i++) {
if (maxi < dp[n - 1][i][0]) {
maxi = dp[n - 1][i][0];
col = i;
}
}
cout << maxi << endl;
if (maxi == -1) return 0;
cout << col + 1 << endl;
int modu = 0;
for (int i = n - 2; i >= 0; i--) {
char loc = path[i + 1][col][modu];
cout << loc;
if (loc == 'L') {
modu = (dp[i + 1][col][modu] - (mapa[i + 1][col] - '0')) % (k + 1);
col--;
} else {
modu = (dp[i + 1][col][modu] - (mapa[i + 1][col] - '0')) % (k + 1);
col++;
}
}
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string tostring(T x) {
ostringstream out;
out << x;
return out.str();
}
long long toint(string s) {
istringstream in(s);
long long x;
in >> x;
return x;
}
int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[8] = {1, -1, 0, 0, -1, 1, -1, 1};
int kx[8] = {1, 1, -1, -1, 2, 2, -2, -2};
int ky[8] = {2, -2, 2, -2, 1, -1, 1, -1};
int wash[1000];
int dry[1000];
int fold[1000];
int getMin(int *arr, int n) {
int mn = -1;
for (int i = 0; i < n; i++)
if (mn == -1 || arr[i] < arr[mn]) mn = i;
return mn;
}
int main() {
int k, n1, n2, n3, t1, t2, t3;
cin >> k >> n1 >> n2 >> n3 >> t1 >> t2 >> t3;
int cur = 0;
for (int i = 0; i < k; i++) {
int w = getMin(wash, n1);
int d = getMin(dry, n2);
int f = getMin(fold, n3);
if (wash[w] > cur) {
cur = wash[w];
}
if (dry[d] > cur + t1) {
cur = dry[d] - t1;
}
if (fold[f] > cur + t1 + t2) {
cur = fold[f] - t1 - t2;
}
wash[w] = cur + t1;
dry[d] = cur + t1 + t2;
fold[f] = cur + t1 + t2 + t3;
}
int res = 0;
for (int i = 0; i < n3; i++) res = max(res, fold[i]);
cout << res << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int p1 = -1000000001;
int p2 = -1000000001;
int n;
int q1, h, q2, a, b, c1, c2;
int main() {
cin >> n;
for (; n; n--) {
cin >> q1 >> h;
q2 = q1 + h;
a = -1;
if (q1 - h > p1) a = max(a, c1 + 1);
if (q1 > p1) a = max(a, c1);
if (q1 - h > p2) a = max(a, c2 + 1);
if (q1 > p2) a = max(a, c2);
b = -1;
if (q1 > p1) b = max(b, c1 + 1);
if (q1 > p2) b = max(b, c2 + 1);
p1 = q1;
c1 = a;
p2 = q2;
c2 = b;
}
cout << max(c1, c2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> adj(200000);
int a[200000];
int ans = 0;
void dfs(int v, int d) {
if (d > a[v]) {
return;
}
ans++;
for (int i = 0; i < adj[v].size(); ++i) {
dfs(adj[v][i].first, max(0, adj[v][i].second + d));
}
}
int main() {
int n, x, y;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y;
adj[x].push_back(make_pair(i + 1, y));
}
dfs(1, 0);
cout << n - ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, t;
cin >> n >> t;
long long sum = 0;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
long long x = 1, ans = 0;
long long div = t / sum;
ans += div * n;
t = t - sum * div;
while (x) {
x = 0;
long long curr = 0, tcurr = t;
vector<long long> b;
n = a.size();
for (long long i = 0; i < n; i++) {
if (a[i] <= tcurr) {
tcurr = tcurr - a[i];
x = 1;
b.push_back(a[i]);
curr += a[i];
}
}
if (curr == 0) break;
long long di = t / curr;
ans += di * ((long long)b.size());
t = t - di * curr;
a = b;
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int m = n / 3;
for (int i = 1; i <= m; i++) {
printf("%d %d\n", 2, i * 2);
printf("%d %d\n", 0, i * 2);
printf("%d %d\n", -2, i * 2);
}
int k = n % 3;
if (k) printf("%d %d\n", 2, (m + 1) * 2), k--;
if (k) printf("%d %d\n", -2, (m + 1) * 2), k--;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const long long N = 3e5 + 10;
const long long MOD = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<long long> cnt(26);
for (long long i = 0; i < 26; i++) {
cin >> cnt[i];
}
string s;
cin >> s;
long long n = (long long)s.size();
vector<long long> sum(n + 1);
vector<vector<long long>> pos(26);
for (long long i = 0; i < n; i++) {
sum[i + 1] = cnt[s[i] - 'a'];
sum[i + 1] += sum[i];
pos[s[i] - 'a'].push_back(i + 1);
}
long long ans = 0;
for (long long i = 0; i < 26; i++) {
map<long long, long long> mp;
for (long long j = 0; j < pos[i].size(); j++) {
long long p = pos[i][j];
ans += mp[sum[p - 1]];
mp[sum[p]]++;
}
mp.clear();
}
cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int mo = 1e9 + 7;
const int inf = 1e9;
int a[N];
char s[N];
int main() {
int n;
scanf("%d%s", &n, s + 1);
for (auto i = (1); i <= (n); ++i) a[i] = a[i - 1] + (s[i] == '(' ? 1 : -1);
if (a[n]) return printf("0\n1 1\n"), 0;
int mi = n + 1, ct = 0;
for (auto i = (1); i <= (n); ++i) {
if (a[i] < mi)
mi = a[i], ct = 1;
else if (a[i] == mi)
++ct;
}
int ans = ct, al = 1, ar = 1;
int l = 0, r = 0;
for (auto i = (1); i <= (n); ++i) {
if (s[i] == ')') l = i;
if (a[i] == mi) break;
}
for (auto i = (n); i >= (1); --i) {
if (a[i] == mi) break;
if (s[i] == '(') r = i;
}
if (l && r) {
int nm = mi, nc = ct;
for (auto i = (1); i <= (l - 1); ++i)
if (a[i] - 2 < nm)
nm = a[i] - 2, nc = 1;
else if (a[i] - 2 == nm)
++nc;
for (auto i = (r); i <= (n); ++i)
if (a[i] - 2 < nm)
nm = a[i] - 2, nc = 1;
else if (a[i] - 2 == nm)
++nc;
if (nc > ans) ans = nc, al = l, ar = r;
}
l = 0;
r = 0;
for (auto i = (1); i <= (n); ++i) {
if (s[i] == ')') l = i;
if (a[i] <= mi + 1) break;
}
for (auto i = (n); i >= (1); --i) {
if (a[i] <= mi + 1) break;
if (s[i] == '(') r = i;
}
if (l && r) {
int nm = mi, nc = ct;
for (auto i = (1); i <= (l - 1); ++i)
if (a[i] - 2 < nm)
nm = a[i] - 2, nc = 1;
else if (a[i] - 2 == nm)
++nc;
for (auto i = (r); i <= (n); ++i)
if (a[i] - 2 < nm)
nm = a[i] - 2, nc = 1;
else if (a[i] - 2 == nm)
++nc;
if (nc > ans) ans = nc, al = l, ar = r;
}
l = 0;
r = 0;
for (auto i = (1); i <= (n); ++i) {
if (s[i] == ')') r = i;
if (a[i] == mi) {
if (l && r) {
int nm = mi, nc = ct;
for (auto j = (l); j <= (r - 1); ++j)
if (a[j] - 2 < nm)
nm = a[j] - 2, nc = 1;
else if (a[j] - 2 == nm)
++nc;
if (nc > ans) ans = nc, al = l, ar = r;
}
l = r = 0;
} else if (!l && s[i] == '(')
l = i;
}
if (l && r) {
int nm = mi, nc = ct;
for (auto j = (l); j <= (r - 1); ++j)
if (a[j] - 2 < nm)
nm = a[j] - 2, nc = 1;
else if (a[j] - 2 == nm)
++nc;
if (nc > ans) ans = nc, al = l, ar = r;
}
l = r = 0;
for (auto i = (1); i <= (n); ++i) {
if (s[i] == ')') r = i;
if (a[i] <= mi + 1) {
if (l && r) {
int nm = mi, nc = ct;
for (auto j = (l); j <= (r - 1); ++j)
if (a[j] - 2 < nm)
nm = a[j] - 2, nc = 1;
else if (a[j] - 2 == nm)
++nc;
if (nc > ans) ans = nc, al = l, ar = r;
}
l = r = 0;
} else if (!l && s[i] == '(')
l = i;
}
if (l && r) {
int nm = mi, nc = ct;
for (auto j = (l); j <= (r - 1); ++j)
if (a[j] - 2 < nm)
nm = a[j] - 2, nc = 1;
else if (a[j] - 2 == nm)
++nc;
if (nc > ans) ans = nc, al = l, ar = r;
}
l = r = 0;
printf("%d\n%d %d\n", ans, al, ar);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int N = 1000, M = 10;
int n, m, hsh[200], et[M];
const int mod = 1e9 + 9;
void fmod(int &first) { first += first >> 31 & mod; }
const int aN = 101, C = 4;
int an, ch[aN][C], fa[aN], len[aN];
int trie() {
for (int c(0); c < (C); ++c) ch[an][c] = -1;
fa[an] = -1, len[an] = 0;
return an++;
}
int rt = trie();
void insert(int i, const string &str) {
int u = rt;
for (const char &c : str) {
if (!~ch[u][c]) ch[u][c] = trie();
u = ch[u][c];
}
len[u] = max(len[u], int((str).size()));
}
void ac_init() {
static queue<int> q;
for (int c(0); c < (C); ++c)
if (!~ch[rt][c])
ch[rt][c] = rt;
else
fa[ch[rt][c]] = rt, q.push(ch[rt][c]);
while (int((q).size())) {
int u = q.front();
q.pop(), len[u] = max(len[u], len[fa[u]]);
for (int c(0); c < (C); ++c)
if (!~ch[u][c])
ch[u][c] = ch[fa[u]][c];
else
fa[ch[u][c]] = ch[fa[u]][c], q.push(ch[u][c]);
}
}
int f[2][aN][M + 1];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m;
hsh['A'] = 0, hsh['C'] = 1, hsh['G'] = 2, hsh['T'] = 3;
string str;
for (int i(0); i < (m); ++i) {
cin >> str;
for (char &c : str) c = hsh[c];
insert(i, str);
}
ac_init();
int a = 0;
f[0][rt][0] = 1;
while (n--) {
a ^= 1;
for (int u(0); u < (an); ++u)
for (int j(0); j < (M + 1); ++j) f[a][u][j] = 0;
for (int u(0); u < (an); ++u)
for (int j(0); j < (M); ++j)
if (f[a ^ 1][u][j])
for (int c(0); c < (C); ++c)
fmod(f[a][ch[u][c]][len[ch[u][c]] >= j + 1 ? 0 : j + 1] +=
f[a ^ 1][u][j] - mod);
}
int ans = 0;
for (int u(0); u < (an); ++u) fmod(ans += f[a][u][0] - mod);
cout << ans << '\n';
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool isp(int k) {
if (k < 2) return false;
for (int i = 2; i * i <= k; i++)
if (k % i == 0) return false;
return true;
}
int main() {
scanf("%d", &n);
m = n * (n + 1) / 2;
int p2 = -1, p3 = -1;
if (!isp(m)) {
if (m % 2 == 1 && !isp(m - 2)) {
m -= 3;
p3 = 2;
}
for (int i = 2; i <= n; i++)
if (isp(i) && isp(m - i)) {
p2 = i - 1;
break;
}
}
for (int i = 0; i < n; i++) printf("%d ", i == p3 ? 3 : (i == p2 ? 2 : 1));
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, a, cnt[(int)1e5 + 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
while (n--) {
cin >> a;
cnt[a]++;
}
for (int i = 1; i <= 1e5; i++) {
if (cnt[i] & 1) {
cout << "Conan";
return 0;
}
}
cout << "Agasa";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
sum = sum + (x - 1);
sum %= 2;
puts(sum & 1 ? "1" : "2");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1005], sz;
bool flag = false;
pair<int, int> ans[5];
bool dfs(int dep) {
int i;
for (i = 1; i <= n && a[i] == i; i++)
;
if (i == n + 1) {
printf("%d\n", dep);
for (i = dep - 1; i >= 0; i--)
printf("%d %d\n", ans[i].first, ans[i].second);
return 1;
}
if (dep >= 3) return 0;
int l, r;
l = i;
for (r = n; r >= 1; r--)
if (a[r] == l) break;
ans[dep] = pair<int, int>(l, r);
reverse(a + l, a + r + 1);
if (dfs(dep + 1)) return 1;
reverse(a + l, a + r + 1);
for (r = n; r >= 1 && a[r] == r; r--)
;
for (l = 1; l <= n; l++)
if (a[l] == r) break;
ans[dep] = pair<int, int>(l, r);
reverse(a + l, a + r + 1);
if (dfs(dep + 1)) return 1;
reverse(a + l, a + r + 1);
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
dfs(0);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const long long INF = 1e10;
const int MAXH = 1e4;
const long long MOD = 1e9 + 7;
long long dp[2][MAXN];
void solve() {
long long r, g;
cin >> r >> g;
int fl;
if (r > 0) dp[1][1] = 1;
if (g > 0) dp[1][0] = 1;
int mx = 0;
long long s = 1;
int from = 1, to;
long long r2 = r, g2 = g;
long long h = 0;
s = 1;
for (int i = 2; i < MAXH; i++) {
to = 1 - from;
fl = 0;
for (int j = 0; j <= r; j++) {
if (dp[from][j] == 0) continue;
if (j + i <= r || s - j + i <= g) {
fl = 1;
break;
}
}
if (!fl) {
break;
}
for (int j = 0; j <= r; j++) {
dp[to][j] = 0;
}
for (int j = 0; j <= r; j++) {
if (dp[from][j] == 0) continue;
fl = 1;
if (j + i <= r) {
dp[to][j + i] = (dp[to][j + i] + dp[from][j] + MOD) % MOD;
mx = i;
}
if (s - j + i <= g) {
dp[to][j] = (dp[to][j] + dp[from][j] + MOD) % MOD;
mx = i;
}
}
if (!fl) break;
s += i;
from = to;
}
long long ans = 0;
for (int i = 0; i <= r; i++) {
ans = (ans + dp[from][i] + MOD) % MOD;
}
cout << ans;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, b, a[505];
long long mod, dp[505][505];
int main() {
cin >> n >> m >> b >> mod;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i <= m; i++)
for (int j = 0; j <= b; j++) dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = a[i]; k <= b; k++)
dp[j][k] = (dp[j][k] + dp[j - 1][k - a[i]]) % mod;
long long res = 0;
for (int j = 0; j <= b; j++) res = (res + dp[m][j]) % mod;
cout << res << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vi[300005];
int color[100005];
bool visited[1000005] = {false};
bool is[100005];
long long fac[10000001];
long long prime[1000000];
long long bit[100005];
void fact() {
fac[0] = 1;
for (int i = 1; i <= 10000000; i++) {
fac[i] = (fac[i - 1] * i) % 1000000007;
}
return;
}
void sieve() {
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i < 100000; i++) {
prime[i] = 1;
}
for (int i = 2; i * i < 1000000; i++) {
if (prime[i] == 1) {
for (int j = i * i; j < 1000000; j += i) {
prime[j] = 0;
}
}
}
}
long long power(long long n, long long p) {
if (p == 0) return 1;
long long res = power((n * n) % 1000000007, p / 2);
if (p % 2 == 1) res = (n * res) % 1000000007;
return res;
}
void upd(long long i, long long val, long long n) {
for (; i <= n; i += i & (-i)) bit[i] += val;
}
long long qry(long long i) {
long long sum = 0;
for (; i > 0; i -= i & (-i)) sum += bit[i];
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
map<long long, long long> f;
long long n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i <= 9; i++) {
long long k;
cin >> k;
f[i] = k;
}
long long i = 0;
string temp = s;
while (f[temp[i] - '0'] <= (temp[i] - '0') && i < temp.size()) i++;
if (i == temp.size()) {
cout << s;
return 0;
}
while (f[(temp[i] - '0')] >= (temp[i] - '0') && i < temp.size()) {
char c = f[temp[i] - '0'] + '0';
temp[i] = c;
i++;
}
cout << temp;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const double EPS = 1e-8;
using namespace std;
void _kill() {
cout << "NO";
exit(0);
}
int a[3];
int main() {
int n, m;
cin >> n >> m;
if (n == 1 && m == 2) {
cout << 0 << '\n' << "1 1\n1 2\n1 1";
return 0;
}
if (n == 2 && m == 1) {
cout << 0 << '\n' << "1 1\n2 1\n1 1";
return 0;
}
if (n == 1) {
cout << 1 << '\n';
cout << 1 << ' ' << m << ' ' << 1 << ' ' << 1 << '\n';
for (int i = 0; i < m; i++) cout << 1 << ' ' << i + 1 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
if (m == 1) {
cout << 1 << '\n';
cout << n << ' ' << 1 << ' ' << 1 << ' ' << 1 << '\n';
for (int i = 0; i < n; i++) cout << i + 1 << ' ' << 1 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
if (n % 2 == 0) {
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
for (int i = 0; i < n; i++)
if (i % 2 == 0)
for (int j = 2; j <= m; j++) cout << i + 1 << ' ' << j << '\n';
else
for (int j = m; j >= 2; j--) cout << i + 1 << ' ' << j << '\n';
for (int i = n; i >= 1; i--) cout << i << ' ' << 1 << '\n';
return 0;
}
if (m % 2 == 0) {
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
for (int i = 0; i < m; i++)
if (i % 2 == 0)
for (int j = 2; j <= n; j++) cout << j << ' ' << i + 1 << '\n';
else
for (int j = n; j >= 2; j--) cout << j << ' ' << i + 1 << '\n';
for (int i = m; i >= 1; i--) cout << 1 << ' ' << i << '\n';
return 0;
}
cout << 1 << '\n';
cout << n << ' ' << m << ' ' << 1 << ' ' << 1 << '\n';
for (int i = 0; i < m; i++)
if (i % 2 == 0)
for (int j = 1; j <= n; j++) cout << j << ' ' << i + 1 << '\n';
else
for (int j = n; j >= 1; j--) cout << j << ' ' << i + 1 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
vector<int> adj[n + 1];
int a, b;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int max = 0, root, count = 0;
for (int i = 1; i <= n; i++) {
if ((int)adj[i].size() > max) {
max = adj[i].size();
root = i;
}
if (adj[i].size() > 2) count++;
if (adj[i].size() == 1) v.push_back(i);
}
if (count > 1)
cout << "No\n";
else {
if (n == 2)
cout << "Yes\n"
<< "1\n"
<< a << " " << b;
else {
cout << "Yes\n";
cout << v.size() << "\n";
for (int i = 0; i < (int)v.size(); i++)
cout << root << " " << v[i] << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long M, X, ans, pri[1000100], tot, num, a[1001000];
bool vis[10000010];
void pre() {
for (long long i = 2; i <= 10000000; i++) {
if (!vis[i]) {
pri[++tot] = i;
}
for (long long j = 1; j <= tot && pri[j] * i <= 10000000; j++) {
vis[pri[j] * i] = 1;
if (i % pri[j] == 0) break;
}
}
}
long long phi(long long x) {
long long ans = 1;
for (long long i = 1; i <= tot && pri[i] * pri[i] <= x; i++) {
if (x % pri[i] == 0) {
ans *= (pri[i] - 1);
x /= pri[i];
while (x % pri[i] == 0) {
ans *= pri[i];
x /= pri[i];
}
}
}
if (x > 1) ans *= (x - 1);
return ans;
}
void div(long long x) {
for (long long i = 1; i <= tot && pri[i] * pri[i] <= x; i++) {
if (x % pri[i] == 0) {
a[++num] = pri[i];
while (x % pri[i] == 0) x /= pri[i];
}
}
if (x > 1) a[++num] = x;
}
long long mul(long long a, long long b, long long M) {
long long tmp = a * b - (long long)((long double)a * b / M) * M;
return (tmp % M + M) % M;
}
long long pw(long long x, long long b, long long M) {
long long res = 1;
for (; b; b >>= 1, x = mul(x, x, M))
if (b & 1) res = mul(res, x, M);
return res;
}
long long getans(long long X, long long M, long long d) {
long long t = phi(M);
num = 0;
div(t);
long long ans = 1;
for (register long long i = 1; i <= num; i++) {
while (t % a[i] == 0 && pw(X, t / a[i], M) == 1) {
ans *= a[i];
t /= a[i];
}
}
return ans;
}
signed main() {
pre();
scanf("%lld%lld", &M, &X);
for (register long long i = 1; i <= sqrt(M); i++) {
if (M % i == 0) {
ans += getans(X % (M / i), M / i, i);
if (i * i < M) ans += getans(X % i, i, M / i);
}
}
printf("%lld\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
bool isVowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return true;
return false;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int lastWasVowel = 0;
int i = 0;
string ans = "";
while (s[i]) {
if (lastWasVowel == 1 && isVowel(s[i])) {
i++;
continue;
} else {
lastWasVowel = 0;
ans += s[i];
if (isVowel(s[i])) lastWasVowel = 1;
i++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn], nex[maxn], b[maxn], pos[maxn];
int f[maxn][21], bin[maxn], c[maxn], mn[maxn][21];
char ans[maxn];
void build(int n) {
for (int i = 1; i <= n; i++) mn[i][0] = c[i];
for (int j = 1; j <= bin[n]; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
int t = i + (1 << (j - 1));
mn[i][j] = min(mn[i][j - 1], mn[t][j - 1]);
}
}
}
int query(int x, int y) {
int j = bin[y - x + 1];
int k = y - (1 << j) + 1;
return min(mn[x][j], mn[k][j]);
}
int main() {
int n, m, q, l, r;
scanf("%d%d%d", &n, &m, &q);
bin[0] = -1;
for (int i = 1; i <= m; i++) bin[i] = bin[i >> 1] + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (i > 1) nex[a[i - 1]] = a[i];
}
nex[a[n]] = a[1];
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
for (int i = m; i >= 1; i--) {
pos[b[i]] = i;
f[i][0] = pos[nex[b[i]]];
}
for (int j = 0; j <= 19; j++) {
for (int i = 1; i <= m; i++) f[i][j + 1] = f[f[i][j]][j];
}
for (int i = 1; i <= m; i++) {
int len = n - 1, p = i;
for (int j = 20; j >= 0; j--) {
if ((1 << j) <= len) len -= 1 << j, p = f[p][j];
}
if (!p)
c[i] = m + 1;
else
c[i] = p;
}
build(m);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
if (query(l, r) <= r)
ans[i] = '1';
else
ans[i] = '0';
}
printf("%s\n", ans + 1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int vis[200005];
char clr[200005];
int main() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
queue<pair<int, int> > q;
for (int i = 0; i < n; i++) {
if (s[i] == s[(i - 1 + n) % n] || s[i] == s[(i + 1) % n]) {
q.push(make_pair(i, 0));
vis[i] = 1;
clr[i] = s[i];
}
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
if (p.second >= k) break;
int i = p.first;
if (vis[(i + 1) % n] == 0) {
vis[(i + 1) % n] = 1;
clr[(i + 1) % n] = clr[p.first];
q.push(make_pair((i + 1) % n, p.second + 1));
}
if (vis[(i - 1 + n) % n] == 0) {
vis[(i - 1 + n) % n] = 1;
clr[(i - 1 + n) % n] = clr[p.first];
q.push(make_pair((i - 1 + n) % n, p.second + 1));
}
}
string ans = "";
for (int i = 0; i < n; i++) {
if (vis[i])
ans += clr[i];
else if (k % 2) {
if (s[i] == 'W')
ans += 'B';
else
ans += 'W';
} else
ans += s[i];
}
cout << ans << "\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
int main(int argc, char const *argv[]) {
int a, b, c;
while (scanf("%d%d%d", &a, &b, &c) != EOF) {
int mod = a % b * 10;
int counter = 1;
while (counter < b + 1) {
if (mod / b == c) {
printf("%d\n", counter);
break;
}
counter++;
mod = mod % b * 10;
if (counter == b + 1) {
printf("-1\n");
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
if (y > x) {
return gcd(y, x);
}
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
bool prime(long long int x) {
for (long long int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) {
return 0;
}
}
return 1;
}
long long int fact(long long int n) {
if (n == 0) {
return 1;
}
return n * fact(n - 1);
}
void solve() {
long long int n;
cin >> n;
long long int x = 0;
while (n--) {
string s;
cin >> s;
if (s == "X++" || s == "++X")
x++;
else
x--;
}
cout << x;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long int t = 1;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const int MAXN = 3000001;
int f[MAXN];
void ad(int x) {
for (int i = x; i < MAXN; i = (i | (i + 1))) f[i]++;
}
int gt(int x) {
int an = 0;
for (int i = x; i >= 0; i = ((i & (i + 1)) - 1)) an += f[i];
return an;
}
int main() {
int n, k;
cin >> n >> k;
if (n <= 3) {
cout << -1 << endl;
return 0;
}
if (k == 2) {
if (n == 4) {
cout << -1 << endl;
return 0;
}
cout << n - 1 << endl;
for (int i = 1; i < n; i++) {
cout << i << " " << i + 1 << endl;
}
return 0;
}
if (k == 3) {
cout << n - 1 << endl;
cout << "1 2" << endl;
cout << "1 3" << endl;
for (int i = 4; i <= n; i++) {
cout << "2 " << i << endl;
}
return 0;
}
cout << -1 << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 20, mod = 998244353;
int w[2][1111111], S[1111111], T[1111111], n, m, sz, cnt, rev[1111111], cur,
gg[1111111], G[1111111], K, a[333333], b[333333], crt, ans;
long long c[1111111];
const int maxn = 1000;
char buffer[maxn], *s, *t;
inline char Get_Char() {
if (s == t) {
t = (s = buffer) + fread(buffer, 1, maxn, stdin);
if (s == t) return EOF;
}
return *s++;
}
int read() {
char c;
int re = 0;
for (c = Get_Char(); c < '0' || c > '9'; c = Get_Char())
;
while (c >= '0' && c <= '9')
re = (re << 1) + (re << 3) + (c - '0'), c = Get_Char();
return re;
}
int binpow(int a, int t) {
int res = 1, p = a;
for (int i = t; i; i >>= 1) {
if (i & 1) res = (long long)res * p % mod;
p = (long long)p * p % mod;
}
return res;
}
void Init() {
w[0][0] = 1;
cur = binpow(3, (mod - 1) / MAXN);
for (int i = 1; i <= MAXN; i++) w[0][i] = (long long)w[0][i - 1] * cur % mod;
w[1][0] = 1;
cur = binpow(3, mod - 1 - (mod - 1) / MAXN);
for (int i = 1; i <= MAXN; i++) w[1][i] = (long long)w[1][i - 1] * cur % mod;
}
void ntt(int d[], int flag) {
for (int i = 0; i < sz; i++) c[i] = (long long)d[i];
for (int i = 0; i < sz; i++) {
if (rev[i] > i) swap(c[i], c[rev[i]]);
}
for (int i = 2; i <= sz; i <<= 1) {
int p = i >> 1, fu = MAXN / i;
for (int j = 0; j < p; j++) {
gg[j] = w[flag][j * fu];
}
for (int j = 0; j < sz; j += i) {
for (int k = j; k < j + p; k++) {
long long tmp1 = c[k];
long long tmp2 = c[k + p] % mod * gg[k - j];
c[k] = tmp1 + tmp2;
c[k + p] = tmp1 - tmp2;
}
}
}
for (int j = 0; j < sz; j++) c[j] %= mod;
if (flag) {
int wn = binpow(sz, mod - 2);
for (int i = 0; i < sz; i++) {
c[i] = c[i] * wn % mod;
}
}
for (int i = 0; i < sz; i++) d[i] = c[i];
}
void doit() {
rev[0] = 0;
for (int i = 1; i < sz; i++) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (cnt - 1));
}
S[0] = 1;
S[2] = 1;
S[1] = (K - 2) % mod;
ntt(S, 0);
for (int i = 0; i < sz; i++) S[i] = binpow(S[i], crt);
ntt(S, 1);
}
int main() {
Init();
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) b[i] = a[i + 1];
b[n] = a[1];
sz = 1;
while (sz < 2 * n) {
sz <<= 1;
cnt++;
}
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) continue;
crt++;
}
doit();
for (int i = crt + 1; i < sz; i++) ans = (ans + S[i]) % mod;
ans = 1ll * ans * binpow(K, n - crt) % mod;
printf("%d\n", (ans + mod) % mod);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, lst = -1, now = -1, ans = 0;
cin >> n;
cin >> now;
n--;
while (n--) {
lst = now;
cin >> now;
if (lst > now) ans += (lst - now);
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 9;
const long long oo = 1e15;
const long long mod = 1e9 + 7;
struct book {
long long u, v, val;
} eg[N];
long long n, m, sum = 0ll;
long long pr[N], child[N];
vector<vector<pair<long long, long long> > > vi;
void dfs(long long pre, long long u) {
pr[u] = pre;
child[u] = 1;
for (long long i = 0; i < vi[u].size(); ++i) {
long long v = vi[u][i].first;
if (v != pre) {
dfs(u, v);
child[u] += child[v];
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vi.resize(N);
for (long long i = 1; i <= n - 1; ++i) {
cin >> eg[i].u >> eg[i].v >> eg[i].val;
long long x = eg[i].u, y = eg[i].v, z = eg[i].val;
vi[x].push_back(make_pair(y, z));
vi[y].push_back(make_pair(x, z));
}
dfs(1, 1);
for (long long i = 1; i <= n - 1; ++i) {
long long u = eg[i].u, v = eg[i].v, val = eg[i].val;
if (pr[u] == v) swap(u, v);
sum += 1ll * child[v] * (n - child[v]) * val;
}
long long q;
cin >> q;
while (q--) {
long long x;
cin >> x;
long long u = eg[x].u, v = eg[x].v, val = eg[x].val;
if (pr[u] == v) swap(u, v);
long long nx;
cin >> nx;
eg[x].val = nx;
val;
sum -= 1ll * child[v] * (n - child[v]) * (val - nx);
long double tmp = (long double)(sum * 6.00) / (n * (n - 1) * 1ll);
cout << fixed << setprecision(10) << tmp << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, a[111][111], was[111][111], sz[111], m[111];
int main() {
ios_base ::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> m[i];
for (int j = 1; j <= m[i]; j++) cin >> a[i][j], was[i][a[i][j]] = 1;
}
for (int i = 1; i <= n; i++) {
memset(sz, 0, sizeof(sz));
bool err = false;
for (int j = 1; j <= m[i]; j++) {
for (int k = 1; k <= n; k++)
if (was[k][a[i][j]]) sz[k]++;
for (int k = 1; k <= n; k++)
if (sz[k] == m[k] && k != i) {
err = true;
cout << "NO\n";
break;
}
if (err) break;
}
if (!err) cout << "YES\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, a, b, t;
int curt;
int orit;
char arr[N];
int ans = 0;
int curans;
int sum[N];
int r;
int main() {
scanf("%d %d %d %d", &n, &a, &b, &t);
orit = t;
scanf("%s", arr + 1);
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + (arr[i] == 'w');
}
--t;
t -= sum[1] * b;
if (t < 0) {
printf("0\n");
return 0;
}
ans = 1;
curt = t;
curans = 1;
for (int i = n; i >= 2; --i) {
int cst = a + 1 + (b * int(arr[i] == 'w'));
if (cst > curt) {
break;
}
r = i;
curt -= cst;
++curans;
}
ans = max(ans, curans);
for (int i = 2; i < n; ++i) {
long long cst = 2LL * a * (i - 1LL) + 1LL * (sum[i] - sum[1]) * b + i - 1LL;
while (((cst > curt) || (r <= i)) && (r <= n)) {
curt += a + 1 + (b * int(arr[r] == 'w'));
++r;
--curans;
}
++curans;
if (curt >= cst) {
ans = max(ans, curans);
}
}
curt = t;
curans = 1;
r = 1;
for (int i = 2; i <= n; ++i) {
int cst = a + 1 + (b * int(arr[i] == 'w'));
if (cst > curt) {
break;
}
r = i;
curt -= cst;
++curans;
}
ans = max(ans, curans);
for (int i = n; i >= 2; --i) {
long long cst = 2LL * a * (n + 1LL - i) + 1LL * (sum[n] - sum[i - 1]) * b +
(n - i + 1LL);
while (((cst > curt) || (r >= i)) && (r >= 2)) {
curt += a + 1 + (b * int(arr[r] == 'w'));
--r;
--curans;
}
++curans;
if (curt >= cst) {
ans = max(ans, curans);
}
}
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007;
int arr[300005];
int rig[300005][21];
int last[21];
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 0; i <= 20; i++) {
last[i] = -1;
}
for (int i = n; i >= 1; i--) {
int j = 0;
while ((1 << j) <= 300005) {
if (((1 << j) & arr[i]) == (1 << j)) {
if (last[j] != -1) {
for (int k = 0; k < 21; k++) {
if (rig[last[j]][k] == 0) continue;
if (rig[i][k] == 0) {
rig[i][k] = rig[last[j]][k];
} else {
rig[i][k] = min(rig[last[j]][k], rig[i][k]);
}
}
rig[i][j] = last[j];
}
last[j] = i;
}
j++;
}
}
while (q--) {
int x, y;
cin >> x >> y;
bool is = false;
for (int j = 0; (1 << j) < 300005; j++) {
if (((1 << j) & arr[y]) == (1 << j)) {
if ((rig[x][j] != 0) && (rig[x][j] <= y)) {
is = true;
break;
}
}
}
string result = "Fou";
if (is) result = "Shi";
cout << result << '\n';
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char chess[8][8];
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) cin >> chess[i][j];
int min_a = 1e9, min_b = 1e9;
for (int j = 0; j < 8; j++) {
bool A = 0, B = 0;
int a = -1, b = -1, pre_a = min_a, pre_b = min_b;
for (int i = 0; i < 8; i++) {
if (chess[i][j] == 'W' && !B) {
A = 1, a = i;
min_a = min(min_a, a);
}
if (chess[i][j] == 'W') A = 1;
if (A && B) min_b = pre_b;
if (chess[i][j] == 'B') {
B = 1, b = 7 - i;
A = 0;
min_b = min(min_b, b);
}
}
}
if (min_a <= min_b)
cout << "A";
else
cout << "B";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long c = getchar(), Nig = 1, x = 0;
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') Nig = -1, c = getchar();
while (isdigit(c)) x = ((x << 1) + (x << 3)) + (c ^ '0'), c = getchar();
return Nig * x;
}
const int maxn = 3e6 + 7;
long long a[maxn];
int n;
struct node {
int gen;
int tree[maxn][2];
void init() { gen = 0; }
int left[maxn], right[maxn];
void _add(long long x, int id) {
int rt = 0;
for (int i = 32; i >= 0; i--) {
int op = (x >> i) & 1;
if (!tree[rt][op]) tree[rt][op] = ++gen;
rt = tree[rt][op];
if (!left[rt]) left[rt] = id;
right[rt] = id;
}
}
long long _RetPos(int rt, int pos, long long x) {
long long ret = 0;
for (int i = pos; i >= 0; i--) {
int op = (x >> i) & 1L;
if (tree[rt][op])
rt = tree[rt][op];
else {
rt = tree[rt][!op];
ret += (1L << i);
}
}
return ret;
}
long long _Divide(int rt, int pos) {
if (tree[rt][0] && tree[rt][1]) {
long long mi = 0x3f3f3f3f;
int x = tree[rt][0], y = tree[rt][1];
for (int j = left[x]; j <= right[x]; j++) {
mi = min(mi, _RetPos(y, pos - 1, a[j]) + (1L << pos));
}
return mi + _Divide(tree[rt][0], pos - 1) + _Divide(tree[rt][1], pos - 1);
} else if (tree[rt][0]) {
return _Divide(tree[rt][0], pos - 1);
} else if (tree[rt][1]) {
return _Divide(tree[rt][1], pos - 1);
}
return 0L;
}
} wuyt;
int main() {
wuyt.init();
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
wuyt._add(a[i], i);
}
printf("%lld\n", wuyt._Divide(0, 32));
return 0;
}
| 15 |
#include <bits/stdc++.h>
const int maxn = 0x3f3f3f3f;
const double EI =
2.71828182845904523536028747135266249775724709369995957496696762772407663035354594571382178525166427;
const double PI = 3.141592653589793238462643383279;
using namespace std;
struct s {
int a, b, f;
} z[110], zz[110];
inline bool comp(s a, s b) { return a.a < b.a; }
inline bool comp2(s a, s b) { return a.a < b.a; }
inline bool comp1(s a, s b) { return a.a + a.b > b.a + b.b; }
vector<int> ve;
int dp[1010][1010];
int main(void) {
int n, i, j;
int r, ans;
while (~scanf("%d %d", &n, &r)) {
ve.clear();
for (i = 0; i < n; i++) {
scanf("%d %d", &z[i].a, &z[i].b);
z[i].f = 1;
}
sort(z, z + n, comp);
ans = 0;
for (i = 0; i < n; i++) {
if (z[i].b >= 0 && r >= z[i].a) {
r += z[i].b;
ans++;
}
}
sort(z, z + n, comp1);
memset(dp, -1, sizeof(dp));
dp[0][0] = r;
int cnt = 0;
for (i = 0; i < n; i++) {
if (z[i].b < 0) {
zz[cnt++] = z[i];
}
}
sort(zz, zz + cnt, comp1);
for (i = 1; i <= cnt; i++) {
for (j = 0; j < i; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
if (dp[i - 1][j] >= zz[i - 1].a) {
dp[i][j + 1] = max(dp[i][j + 1], dp[i - 1][j] + zz[i - 1].b);
}
}
}
for (i = cnt; i >= 0; i--) {
if (dp[cnt][i] >= 0) {
ans += i;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
const int LOGN = 20;
int n;
long long dp[N], a[N], sum[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
sum[i] = a[i] + sum[i - 1];
}
dp[n] = sum[n];
for (int idx = n - 1; idx >= 2; idx--) {
dp[idx] = max(dp[idx + 1], sum[idx] - dp[idx + 1]);
}
printf("%lld\n", dp[2]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int n, m, dp[maxn][maxn];
char iomap[maxn][maxn];
long long ans = 0;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> iomap[i][j];
for (int i = 1; i <= m; i++) dp[n][i] = 1;
for (int i = n - 1; i >= 1; i--)
for (int j = 1; j <= m; j++)
dp[i][j] = iomap[i][j] == iomap[i + 1][j] ? dp[i + 1][j] + 1 : 1;
for (int i = 1; i <= n; i++) {
int pa = -1, pb = -1, pc = -1, pd = -1, cnt = 0;
for (int j = 1; j <= m; j++) {
int a = i;
int b = a + dp[a][j];
int c = b + dp[b][j];
int d = c + dp[c][j];
if (b - a == c - b && b - a <= d - c && c <= n) {
if (pc <= n && pa == a && pb == b && pc == c && pb - pa == pc - pb &&
pb - pa <= pd - pc && iomap[a][j] == iomap[a][j - 1] &&
iomap[b][j] == iomap[b][j - 1] && iomap[c][j] == iomap[c][j - 1]) {
++cnt;
} else {
ans += cnt * (cnt + 1) / 2;
cnt = 1;
}
}
pa = a;
pb = b;
pc = c;
pd = d;
}
ans += cnt * (cnt + 1) / 2;
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] < a[j]) {
swap(a[i], a[j]);
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] < 0 && m > 0) {
m--;
sum = sum + a[i];
}
}
cout << sum * -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string str;
cin >> str;
int len = str.length();
char c = str[0];
int cnt = 1;
for (int i = 1; i < len; i++) {
if (str[i] == c)
cnt += 1;
else {
c = str[i];
cnt = 1;
}
if (cnt >= 7) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, z, x, y, b, v, l;
string s;
cin >> t;
while (t--) {
z = 0;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '1') z++;
}
if (z == 0) {
cout << n << endl;
continue;
}
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
y = i;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
x = i;
break;
}
}
if (z == 1) {
cout << max(2 * (y + 1), 2 * (n - y)) << endl;
continue;
}
b = max(n + 2, 2 * x + 2);
v = x;
x = n - y - 1;
y = n - 1 - v;
l = max(n + 2, 2 * x + 2);
cout << max(b, l) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210000;
const int MAXK = 19;
const int INF = 1e9;
const long long MOD = 998244353;
vector<int> V[MAXN];
int N, a, b, Q;
vector<int> qry;
int RQ;
pair<int, int> ask() {
++RQ;
assert(RQ <= 13);
cout << "? " << (int)qry.size() << ' ';
for (auto i : qry) cout << i << ' ';
cout << '\n';
cout << flush;
int a, b;
cin >> a >> b;
return make_pair(a, b);
}
vector<int> layers[MAXN];
int d[MAXN];
void dfs(int x, int p) {
layers[d[x]].emplace_back(x);
for (auto v : V[x])
if (v != p) {
d[v] = d[x] + 1;
dfs(v, x);
}
}
void solve() {
qry.clear();
for (int i = 1; i <= N; ++i) qry.emplace_back(i);
for (int i = 1; i <= N; ++i) layers[i].clear();
pair<int, int> x = ask();
int rt = x.first;
int ds = x.second;
d[rt] = 0;
dfs(rt, -1);
int l = 0;
int u = *max_element(d, d + N + 1);
while (u > l) {
int m = (l + u + 1) / 2;
qry.clear();
for (auto t : layers[m]) qry.emplace_back(t);
pair<int, int> x = ask();
if (x.second == ds)
l = m;
else
u = m - 1;
}
qry.clear();
for (auto t : layers[l]) qry.emplace_back(t);
pair<int, int> t = ask();
for (int i = 1; i <= N; ++i) layers[i].clear();
d[t.first] = 0;
dfs(t.first, -1);
qry.clear();
for (auto t : layers[ds]) qry.emplace_back(t);
pair<int, int> r = ask();
cout << "! " << t.first << ' ' << r.first << '\n' << flush;
string S;
cin >> S;
}
int main() {
cin >> Q;
while (Q--) {
RQ = 0;
cin >> N;
for (int i = 1; i <= N; ++i) V[i].clear();
for (int i = 1; i < N; ++i) {
cin >> a >> b;
V[a].emplace_back(b);
V[b].emplace_back(a);
}
solve();
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
double dp[1 << 20];
double ans[21];
void solve(int K, vector<double> p) {
int N = p.size();
if (K >= N) {
for (int i = 0; i < N; i++) ans[i] = 1.0;
return;
}
dp[0] = 1.0;
for (int set = 0; set < (1 << N); set++) {
double q = 0;
for (int j = 0; j < N; j++)
if ((set >> j & 1) == 1) {
q += p[j];
}
for (int i = 0; i < N; i++)
if ((set >> i & 1) == 0) {
dp[set | (1 << i)] += dp[set] * p[i] / (1 - q);
}
}
for (int set = 0; set < (1 << N); set++)
if (__builtin_popcount(set) == K) {
for (int i = 0; i < N; i++)
if (set >> i & 1) {
ans[i] += dp[set];
}
}
}
int main() {
int N, K;
cin >> N >> K;
vector<double> p;
int map[N];
for (int i = 0; i < N; i++) {
double x;
cin >> x;
if (x < 1e-8) {
map[i] = 20;
} else {
map[i] = p.size();
p.push_back(x);
}
}
solve(K, p);
for (int i = 0; i < N; i++) printf("%.12f ", ans[map[i]]);
printf("\n");
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 3e5 + 10;
long long n, p, t;
long long A[MXN], dp[MXN];
bool bad[MXN];
vector<long long> ANS;
bool check(long long x) {
for (int i = 1; i <= n; i++) {
if (x < A[i]) return 0;
x++;
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
for (int i = 1; i <= n; i++) cin >> A[i];
sort(A + 1, A + n + 1), memset(dp, 63, sizeof dp);
for (int i = 1, val = A[n] - n + 1; val <= A[n] - 1 + (n - 1); i++, val++) {
long long ps = upper_bound(A + 1, A + n + 1, val) - A - 1;
ps %= p;
if (A[n] - n < val - ps) {
dp[(val - ps) - (A[n] - n)] = min(dp[(val - ps) - (A[n] - n)], ps + 1);
}
t = i;
}
for (int i = t, val = A[n] - 1 + (n - 1); val > A[n] - n; i--, val--) {
if (i + p <= t) dp[i] = min(dp[i], dp[i + p] + p);
bad[i] = (dp[i] <= n);
}
long long l = A[1] - 1, r = A[n];
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
for (int x = A[n] - n + 1, i = 1; x < A[n]; x++, i++) {
if (bad[i] || x <= l) continue;
ANS.push_back(x);
}
cout << ANS.size() << '\n';
for (auto X : ANS) cout << X << ' ';
cout << '\n';
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
void merge(int arr[][2], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1][2], R[n2][2];
for (i = 0; i < n1; i++) {
L[i][0] = arr[l + i][0];
L[i][1] = arr[l + i][1];
}
for (j = 0; j < n2; j++) {
R[j][0] = arr[m + 1 + j][0];
R[j][1] = arr[m + 1 + j][1];
}
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i][0] <= R[j][0]) {
arr[k][0] = L[i][0];
arr[k][1] = L[i][1];
i++;
} else {
arr[k][0] = R[j][0];
arr[k][1] = R[j][1];
j++;
}
k++;
}
while (i < n1) {
arr[k][0] = L[i][0];
arr[k][1] = L[i][1];
i++;
k++;
}
while (j < n2) {
arr[k][0] = R[j][0];
arr[k][1] = R[j][1];
j++;
k++;
}
}
void mergeSort(int arr[][2], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int main() {
int t, b, n, m;
cin >> t;
int ara[1001][2];
for (int it = 0; it < t; it++) {
cin >> n >> m;
long long int s = 0;
for (int i = 0; i < n; i++) {
cin >> ara[i][0];
s = s + (2 * ara[i][0]);
ara[i][1] = i + 1;
}
if (m < n) {
cout << -1 << endl;
continue;
}
mergeSort(ara, 0, n - 1);
if (n == 2) {
cout << -1 << endl;
continue;
}
int r = (m / n);
int g = m % n;
s = s + (g * (ara[0][0] + ara[1][0]));
cout << s << endl;
for (int i = 0; i < g; i++) {
cout << ara[0][1] << " " << ara[1][1] << endl;
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < n - 1; j++) {
cout << j + 1 << " " << j + 2 << endl;
}
cout << n << " " << 1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> a[5];
int main() {
int k, m;
static int pw[9];
pw[0] = 1;
for (int i = 1; i <= 8; i++) pw[i] = pw[i - 1] * 10;
cin >> k >> m;
for (int d = 0; d <= 9; d++) {
a[1].push_back(make_pair(d, d));
if (d) a[1].push_back(make_pair(d, -d));
}
for (int i = 2; i <= 4; i++) {
for (int j = 1; j < i; j++)
for (auto x : a[j])
for (auto y : a[i - j]) {
int b = x.first * pw[i - j] + y.first;
a[i].push_back(make_pair(b, x.second + y.second));
a[i].push_back(make_pair(b, x.second - y.second));
a[i].push_back(make_pair(b, x.second * y.second));
}
sort(a[i].begin(), a[i].end());
a[i].erase(unique(a[i].begin(), a[i].end()), a[i].end());
}
for (auto x : a[4]) {
if (m == 0) break;
int ans = k + x.second;
if (0 <= ans && ans <= 9999) printf("%04d%04d\n", x.first, ans), m--;
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, sum, res, c;
cin >> n >> k;
res = 240 - k, sum = 0, c = 0;
for (int i = 1; i <= n; i++) {
sum += 5 * i;
if (sum > res) break;
c = c + 1;
}
cout << c << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (cin >> n >> k) {
if (n < 4) {
cout << -1 << endl;
continue;
}
if (k != 2 && k != 3) {
cout << -1 << endl;
continue;
}
if (k == 2) {
if (n == 4) {
cout << -1 << endl;
continue;
}
cout << n - 1 << endl;
for (int i = 1; i < n; i++) cout << i << " " << i + 1 << endl;
continue;
}
cout << 3 + 2 * (n - 4) << endl;
printf("1 2\n2 3\n3 4\n");
for (int i = 5; i <= n; i++)
cout << 2 << " " << i << endl << 3 << " " << i << endl;
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[1001];
long long b[1001];
int main() {
cin >> n;
for (int c = 0; c < n; c++) {
cin >> a[c];
}
for (int c = 0; c < n; c++) {
cin >> b[c];
}
long long maxx = 0;
for (int c = 0; c < n; c++) {
maxx |= a[c];
}
long long maxx2 = 0;
for (int c = 0; c < n; c++) {
maxx2 |= b[c];
}
cout << maxx + maxx2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Circle {
pair<double, double> center;
int radius;
Circle() {}
Circle(pair<double, double> center, int radius)
: center(center), radius(radius) {}
};
const double PI = acos(-1);
pair<double, double> O;
Circle c[100005];
int v, T, n;
double reach;
vector<pair<double, double> > intervals;
vector<pair<double, int> > points;
double dist(pair<double, double> A, pair<double, double> B) {
double dx = A.first - B.first;
double dy = A.second - B.second;
return sqrt(dx * dx + dy * dy);
}
void addInterval(double left, double right) {
if (!(left < -PI || right > PI)) {
intervals.push_back(make_pair(left, right));
return;
}
if (left < -PI) {
left += 2 * PI;
assert(!(right > PI));
} else
right -= 2 * PI;
intervals.push_back(make_pair(left, PI));
intervals.push_back(make_pair(-PI, right));
}
int main() {
scanf("%lf %lf %d %d", &O.first, &O.second, &v, &T);
reach = ((double)v) * T;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lf %lf %d", &c[i].center.first, &c[i].center.second, &c[i].radius);
c[i].center.first -= O.first;
c[i].center.second -= O.second;
}
O = make_pair(0, 0);
for (int i = 1; i <= n; ++i) {
double d = dist(O, c[i].center);
double r = c[i].radius;
double minDist = d - r, maxDist = sqrt(d * d - r * r);
int x1 = c[i].center.first;
int y1 = c[i].center.second;
if (1LL * x1 * x1 + 1LL * y1 * y1 <= 1LL * c[i].radius * c[i].radius) {
printf("%.10f\n", 1.0);
return 0;
}
double beta = atan2(c[i].center.second, c[i].center.first);
if (reach - 1e-7 < minDist)
continue;
else if (reach + 1e-7 > maxDist) {
double alfa = asin(r / d);
addInterval(beta - alfa, beta + alfa);
} else {
double alfa = acos((reach * reach + d * d - r * r) / (2 * reach * d));
addInterval(beta - alfa, beta + alfa);
}
}
for (auto el : intervals) {
points.push_back(make_pair(el.first, 1));
points.push_back(make_pair(el.second, -1));
}
sort(points.begin(), points.end());
double sol = 0;
int cnt = 0;
for (int i = 0; i < (int)points.size() - 1; ++i) {
cnt += points[i].second;
if (cnt > 0) sol += points[i + 1].first - points[i].first;
}
sol /= 2 * PI;
printf("%.10f\n", sol);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > edges[2000 + 1];
bitset<2000> a[2000];
int parent[2000];
char s[2000 + 1];
int Find(int i) { return (parent[i] == i) ? i : parent[i] = Find(parent[i]); }
bool Union(int i, int j) {
i = Find(i), j = Find(j);
if (i == j) {
return 0;
}
if (i > j) {
swap(i, j);
}
parent[j] = i;
return 1;
}
void Reset() {
for (int i = 0; i < 2000; ++i) {
parent[i] = i;
a[i].reset();
}
for (int i = 0; i <= 2000; ++i) {
edges[i].clear();
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
Reset();
int targetMSTWeight = -m;
for (int x = 0; x < m; ++x) {
scanf("%s", s);
for (int i = 0; i < n; ++i) {
if (s[i] == '1') {
a[i].set(x);
++targetMSTWeight;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int k = (a[i] & a[j]).count();
edges[k].push_back(make_pair(i, j));
}
}
vector<pair<int, int> > ans;
int mstWeight = 0;
for (int k = m; k > -1 && mstWeight <= targetMSTWeight; --k) {
for (auto edge : edges[k]) {
int i, j;
tie(i, j) = edge;
if (Union(i, j)) {
mstWeight += k;
ans.push_back(make_pair(i, j));
if (mstWeight > targetMSTWeight) {
break;
}
}
}
}
if (mstWeight != targetMSTWeight) {
printf("NO\n");
} else {
printf("YES\n");
for (auto p : ans) {
int i, j;
tie(i, j) = p;
printf("%d %d\n", i + 1, j + 1);
}
}
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
void doit(int);
int main() {
int N;
scanf("%d", &N);
printf("%.0lf\n", (double)N * ((double)N + 1));
doit(N);
printf("\n");
return 0;
}
void doit(int n) {
int i = 0, p = 0;
while ((1 << (i + 1)) - 1 <= n) i++;
p = (1 << i) - 1;
if (p == n)
for (i = 0; i <= n; i++)
(i == 0) ? printf("%d", n - i) : printf(" %d", n - i);
else {
doit(2 * p - n);
for (i = 2 * p + 1 - n; i <= n; i++) printf(" %d", 2 * p + 1 - i);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int k = min(a, min(b / 2, c / 4));
cout << k + k * 2 + k * 4;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, w, c, nxt;
} e[2000005];
int n, m, h[100005], tot = 1, s, t, dis[100005], vis[100005], pt, p[100005],
las[100005][2];
int q[5000005], head, tail, g[105][105], f[105][105];
int add(int u, int v, int w, int c) {
e[++tot].v = v;
e[tot].w = w;
e[tot].c = c;
e[tot].nxt = h[u];
h[u] = tot;
e[++tot].v = u;
e[tot].w = 0;
e[tot].c = -c;
e[tot].nxt = h[v];
h[v] = tot;
return tot - 1;
}
bool spfa() {
for (int i = 1; i <= pt + 2; i++) vis[i] = 0, dis[i] = 1000000000;
vis[s] = 1;
dis[s] = 0;
head = 0, tail = 1;
q[1] = s;
p[s] = 1e9;
while (head < tail) {
head++;
int u = q[head];
vis[u] = 0;
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].v, w = e[i].w, c = e[i].c;
if (!w || dis[v] <= dis[u] + c) continue;
dis[v] = dis[u] + c;
p[v] = min(p[u], w);
las[v][1] = i;
las[v][0] = u;
if (!vis[v]) {
q[++tail] = v;
vis[v] = 1;
}
}
}
return dis[t] != 1000000000;
}
void ek() {
while (spfa()) {
for (int i = t; i != s; i = las[i][0]) {
e[las[i][1]].w -= p[t];
e[las[i][1] ^ 1].w += p[t];
}
}
}
int main() {
scanf("%d%d", &n, &m);
s = n + n * (n - 1) / 2 - m + 1;
t = s + 1;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u][v] = 1;
g[v][u] = -1;
add(s, u, 1, 0);
}
pt = n;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (!g[i][j]) {
pt++;
add(s, pt, 1, 0);
f[i][j] = add(pt, i, 1, 0);
f[j][i] = add(pt, j, 1, 0);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) add(i, t, 1, j * 2 - 1);
ek();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
printf("0");
else if (g[i][j] == 1)
printf("1");
else if (g[i][j] == -1)
printf("0");
else if (e[f[i][j]].w)
printf("0");
else
printf("1");
}
printf("\n");
}
return 0;
}
| 19 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
#define loop(i,a,n) for(int i=a;i<n;i++)
#define rloop(i,n,a) for(int i=n-1;i>=a;i--)
#define all(x) x.begin(),x.end()
#define ins insert
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define inf INT_MAX
#define ninf INT_MIN
const int mod = 1e9 + 7;
const int N = 1e5 + 4;
/*
bool cmp(const pair<string,int> &a, const pair<string,int> &b){
if(a.second < b.second)
return true;
if(a.second == b.second){
return (a.first >= b.first);
}
return false;
}
*/
/*SET
*set.rbegin()--> getting last element of set
it=--set.end()--> pointer to last element
*/
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int t;
cin>>t;
while(t--){
int w,h;
ll n;
cin>>w>>h>>n;
ll ans=1;
while(w%2==0){
ans=2*ans;
w=w/2;
}
while(h%2==0){
ans=2*ans;
h=h/2;
}
if(ans>=n){
cout<<"YES\n";
}
else{
cout<<"NO\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ta, tb, par[100005], anc[100005], cnt[100005], ans[100005];
vector<int> va[100005], vb[100005], vc[100005];
bool v[100005];
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
int dfs(int a, int b) {
par[a] = a;
anc[a] = a;
for (int c = 0; c < va[a].size(); c++)
if (va[a][c] != b) {
int tt = dfs(va[a][c], a);
cnt[a] += tt;
ans[vc[a][c]] = tt;
par[find(va[a][c])] = find(a);
anc[par[a]] = a;
}
v[a] = 1;
for (int c = 0; c < vb[a].size(); c++)
if (v[vb[a][c]]) cnt[anc[find(vb[a][c])]] -= 2;
return cnt[a];
}
int main() {
scanf("%d", &n);
for (int a = 1; a < n; a++) {
scanf("%d%d", &ta, &tb);
va[ta].push_back(tb);
va[tb].push_back(ta);
vc[ta].push_back(a);
vc[tb].push_back(a);
}
scanf("%d", &m);
while (m--) {
scanf("%d%d", &ta, &tb);
if (ta == tb) continue;
vb[ta].push_back(tb);
vb[tb].push_back(ta);
cnt[ta]++;
cnt[tb]++;
}
dfs(1, 0);
for (int a = 1; a < n; a++) printf("%d%c", ans[a], a == n - 1 ? '\n' : ' ');
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
int A[maxn], C[maxn];
struct P {
int first, second;
P(int a = 0, int b = 0) : first(a), second(b) {}
bool operator<(const P& p) const { return first < p.first; }
};
P B[maxn];
map<int, int> dp;
int res[maxn], res1[maxn];
queue<int> Q[maxn];
int main(void) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
dp[A[i]]++;
C[i] = A[i];
}
sort(C + 1, C + n + 1);
int cnt = unique(C + 1, C + n + 1) - C - 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &B[i].first);
B[i].second = i;
}
sort(B + 1, B + m + 1);
int tot = 0;
for (int i = 1; i <= m; i++) {
int ans = 0;
while (B[i].first) {
if (dp[B[i].first]) {
dp[B[i].first]--;
Q[lower_bound(C + 1, C + cnt + 1, B[i].first) - C].push(B[i].second);
res[B[i].second] = ans;
tot += ans;
break;
} else if (B[i].first != 1) {
ans++;
B[i].first = (B[i].first + 1) / 2;
} else if (B[i].first == 1)
break;
}
}
int num = 0;
for (int i = 1; i <= n; i++) {
int t = lower_bound(C + 1, C + cnt + 1, A[i]) - C;
if (Q[t].empty())
res1[i] = 0;
else {
num++;
res1[i] = Q[t].front();
Q[t].pop();
}
}
cout << num << " " << tot << endl;
for (int i = 1; i <= m; i++) printf("%d%c", res[i], i == m ? '\n' : ' ');
for (int i = 1; i <= n; i++) printf("%d%c", res1[i], i == n ? '\n' : ' ');
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
cout << (n / k + 1) * k << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[1000000];
int S[1000000];
int T[1000000];
int P[1000000];
long long N, K, L;
long long LN;
long long R = 0;
int TL = 0;
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
long long add(long long a, long long b) { return (a + b) % 1000000007; }
void addsol(long long x) { R = (R + x) % 1000000007; }
void addsol(long long x, int k) {
long long t = LN - k + 1;
if (t > 0) addsol(mul(x, t % 1000000007));
}
int main() {
scanf("%I64d%I64d%I64d", &N, &L, &K);
LN = L / N;
K = min(K, LN + 3);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
S[i] = A[i];
}
sort(S, S + N);
TL = 0;
T[0] = 1;
for (int i = 1; i < N; i++) {
if (S[i] == S[i - 1]) {
T[TL]++;
} else {
P[TL] += T[TL];
TL++;
P[TL] = P[TL - 1];
T[TL]++;
}
}
P[TL] += T[TL];
TL++;
long long D[TL][K];
long long PD[TL][K];
PD[0][0] = 0;
for (int i = 0; i < TL; i++) {
D[i][0] = T[i];
if (i != 0)
PD[i][0] = add(D[i][0], PD[i - 1][0]);
else
PD[i][0] = D[i][0];
addsol(D[i][0], 1);
}
for (int j = 1; j < K; j++) {
for (int i = 0; i < TL; i++) {
D[i][j] = mul(PD[i][j - 1], T[i]);
if (i != 0) {
PD[i][j] = add(PD[i - 1][j], D[i][j]);
} else
PD[0][j] = D[i][j];
addsol(D[i][j], j + 1);
}
}
long long rem = L % N;
addsol(rem);
for (int i = 0; i < rem; i++) {
int si = (lower_bound(S, S + N, A[i]) - S);
int di = (upper_bound(P, P + TL, si) - P);
for (int j = 1; j < min(K, LN + 1); j++) {
addsol(PD[di][j - 1]);
}
}
cout << R << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int aa[110];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &aa[i]);
}
sort(aa, aa + n);
int op;
for (int i = n - 1; i >= 0; i--) {
if (k % aa[i] == 0) {
op = k / aa[i];
break;
}
}
printf("%d\n", op);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int i, j, k, n, a, x, ans;
set<int> st;
vector<int> vec;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
vec.push_back(x);
}
sort(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
if (vec[i] == 0) continue;
for (j = i + 1; j < n; j++) {
if (vec[j] % vec[i] == 0) {
vec[j] = 0;
st.insert(vec[i]);
}
}
}
for (int i = 0; i < n; i++)
if (vec[i] != 0) st.insert(vec[i]);
ans = st.size();
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e9 + 5;
const long long int MOD = 998244353;
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<int> res;
int s = (int)sqrtl(n);
for (int i = 0; i <= s; ++i) {
res.push_back(i);
}
for (int i = 1; i <= s; ++i) {
res.push_back(n / i);
}
sort(res.begin(), res.end());
res.resize(unique(res.begin(), res.end()) - res.begin());
cout << res.size() << endl;
for (int &x : res) {
cout << x << " ";
}
cout << endl;
}
int main() {
int q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, M = 3010, mod = 998244353;
long long a[N], w[N];
long long dp[M][M];
long long inverse(long long x);
long long pwr(long long x, long long e);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
long long bad_wt = 0, good_wt = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> w[i];
if (a[i]) {
good_wt += w[i];
} else {
bad_wt += w[i];
}
}
for (int j = 0; j <= m and j <= bad_wt; ++j) {
dp[m][j] = j;
}
long long tot_wt = good_wt + bad_wt;
for (int i = m - 1; i >= 0; --i) {
for (int j = 0; j <= m and j <= bad_wt; ++j) {
long long p_bad = (bad_wt - j) * inverse(tot_wt - j + (i - j));
p_bad %= mod;
long long p_good = (mod + 1 - p_bad) % mod;
dp[i][j] = p_bad * dp[i + 1][j + 1] + p_good * dp[i + 1][j];
dp[i][j] %= mod;
}
}
long long bad_visits = dp[0][0], good_visits = (m - bad_visits + mod) % mod;
for (int i = 1; i <= n; ++i) {
long long ans = w[i];
if (a[i]) {
ans *= good_visits;
ans %= mod;
ans *= inverse(good_wt);
ans %= mod;
ans += w[i];
ans %= mod;
} else {
ans *= bad_visits;
ans %= mod;
ans *= inverse(bad_wt);
ans %= mod;
ans = (w[i] - ans + mod) % mod;
}
cout << ans << '\n';
}
}
long long inverse(long long x) { return pwr(x, mod - 2); }
long long pwr(long long x, long long e) {
long long res = 1;
while (e) {
if (e & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
e /= 2;
}
return res;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, a[N], sum, mx, ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (a[i] > mx) mx = a[i];
}
cout << max(mx, (long long)ceil((double)sum / (double)(n - 1)));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
cin >> n >> p;
string s;
cin >> s;
char c = 'a';
std::vector<char> allChars;
for (int i = 1; i <= p; ++i) {
allChars.push_back(c);
c++;
}
int ptr = s.size() - 1;
int end = s.size() - 1;
while (ptr >= 0) {
if (ptr == end) {
int index = s[ptr] - 'a';
for (int i = index + 1; i < allChars.size(); i++) {
if ((ptr >= 2 && allChars[i] != s[ptr - 1] &&
allChars[i] != s[ptr - 2]) ||
(ptr == 1 && allChars[i] != s[ptr - 1]) || (ptr == 0)) {
s[ptr] = allChars[i];
cout << s << endl;
return (0);
}
}
ptr--;
continue;
} else {
int index = s[ptr] - 'a';
bool flag = false;
for (int i = index + 1; i < allChars.size(); i++) {
if ((ptr >= 2 && allChars[i] != s[ptr - 1] &&
allChars[i] != s[ptr - 2]) ||
(ptr == 1 && allChars[i] != s[ptr - 1]) || (ptr == 0)) {
s[ptr] = allChars[i];
flag = true;
break;
}
}
if (!flag) {
ptr--;
continue;
} else {
bool flag = false;
for (int ind = ptr + 1; ind < s.size(); ind++) {
for (int i = 0; i < allChars.size(); i++) {
if ((ind >= 2 && allChars[i] != s[ind - 1] &&
allChars[i] != s[ind - 2]) ||
(ind == 1 && allChars[i] != s[ind - 1])) {
flag = true;
s[ind] = allChars[i];
break;
}
}
}
cout << s << endl;
return (0);
}
}
}
cout << "NO" << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &it : a) cin >> it;
int ans = 0;
ans += a[0] == 1;
for (int i = 1; i < n; ++i) {
if (a[i] == 0) {
continue;
}
int j = i;
while (j < n && a[j] == 1) {
++j;
}
ans += (j - i) / 3;
i = j - 1;
}
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 998244353;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 1e-10;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline void pr2(T x, int k = 64) {
long long i;
for (i = 0; i < k; i++) fprintf(stderr, "%d", (x >> i) & 1);
putchar(' ');
}
template <typename T>
inline void add_(T &A, int B, long long MOD = M) {
A += B;
(A >= MOD) && (A -= MOD);
}
template <typename T>
inline void mul_(T &A, long long B, long long MOD = M) {
A = (A * B) % MOD;
}
template <typename T>
inline void mod_(T &A, long long MOD = M) {
A %= MOD;
A += MOD;
A %= MOD;
}
template <typename T>
inline void max_(T &A, T B) {
(A < B) && (A = B);
}
template <typename T>
inline void min_(T &A, T B) {
(A > B) && (A = B);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
inline long long powMM(long long a, long long b, long long mod = M) {
long long ret = 1;
for (; b; b >>= 1ll, a = a * a % mod)
if (b & 1) ret = ret * a % mod;
return ret;
}
int startTime;
void startTimer() { startTime = clock(); }
void printTimer() {
fprintf(stderr, "/--- Time: %ld milliseconds ---/\n", clock() - startTime);
}
int f[107][10][10][1 << 8][3];
char s[maxn];
vector<pair<int, int> > now;
int n;
int X, Y;
int query(int pos, int more_x, int more_y, int mask, int more) {
int i;
for (i = 0; i < (int)now.size(); i++)
if (((mask >> (i * 2)) & 3) == 3) {
mask = 3;
break;
}
if (pos == n) return !more_x && !more_y && more && mask == 3;
if (f[pos][more_x][more_y][mask][more] != -1)
return f[pos][more_x][more_y][mask][more];
int ret = 0, k;
for (k = 0; k < 10; k++) {
int nowx = X * k + more_x, nowy = Y * k + more_y;
int ax = nowx % 10, ay = nowy % 10, nxtmask = mask, nxtmore = more;
for (i = 0; i < (int)now.size(); i++) {
if (ax == now[i].first) nxtmask |= 1 << (i * 2);
if (ay == now[i].second) nxtmask |= 1 << (i * 2 + 1);
}
if (ay > s[pos] - '0') nxtmore = 0;
if (ay < s[pos] - '0') nxtmore = 2;
add_(ret, query(pos + 1, nowx / 10, nowy / 10, nxtmask, nxtmore));
}
return f[pos][more_x][more_y][mask][more] = ret;
}
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
int i, j, k;
int ans = 0;
for (i = 1; i <= 9; i++)
for (j = i; j <= 9; j++)
if (gcd(i, j) == 1) {
X = i;
Y = j;
if (i == 1 && j == 1) {
int base = 1;
ans = 0;
for (k = 0; k < n; k++)
add_(ans, (long long)base * (s[k] - '0') % M), mul_(base, 10);
} else {
now.clear();
for (k = 1; k <= 10; k++)
if (k * i <= 9 && k * j <= 9)
now.push_back(make_pair(i * k, j * k));
int _l, _i, _j, _sta, _m;
for (_l = 0; _l < n; _l++)
for (_i = 0; _i < 10; _i++)
for (_j = 0; _j < 10; _j++)
for (_sta = 0; _sta < (1 << ((int)now.size() * 2)); _sta++)
for (_m = 0; _m < 3; _m++) {
f[_l][_i][_j][_sta][_m] = -1;
}
memset(f, 0xff, sizeof(f));
int base = query(0, 0, 0, 0, 1);
add_(ans, base);
if (i != j) add_(ans, base);
}
}
printf("%d\n", ans);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long f[710][11][710][2], r;
char s[710];
int main() {
cin >> s;
n = strlen(s);
for (int i = 0; i < 10; i++) f[0][i][0][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 1; j < 10; j++)
for (int k = 0; k <= i; k++)
for (int m = 0; m < 2; m++)
for (int t = 0; t <= (m ? 9 : s[i] - '0'); t++)
f[i + 1][j][k + (t >= j)][m | t < (s[i] - '0')] =
(f[i + 1][j][k + (t >= j)][m | t < (s[i] - '0')] +
f[i][j][k][m]) %
1000000007ll;
for (int k = 1; k <= 9; k++) {
long long cp = 1;
for (int i = 1; i <= n; i++) {
r = (r + cp * (f[n][k][i][0] + f[n][k][i][1]) % 1000000007ll) %
1000000007ll;
cp = (cp * 10 + 1) % 1000000007ll;
}
}
cout << r;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8;
int statue[N][N][N];
char mapa[N][N];
int dx[] = {1, 1, 1, 0, -1, 1, -1, 0, 0};
int dy[] = {1, 0, -1, 1, -1, 0, 1, 1, 0};
int ans = 0;
void dfs(int first, int second, int deep) {
if (deep >= N) {
ans = 1;
return;
}
if (first >= N || first < 0 || second < 0 || second >= N) return;
if (statue[first][second][deep]) return;
if (first == 0 && second == 7) {
ans = 1;
return;
}
for (int i = 0; i < 9; ++i)
if (first + dx[i] < N && first + dx[i] >= 0 && second + dy[i] < N &&
second + dy[i] >= 0)
if (statue[first + dx[i]][second + dy[i]][deep] != 1)
dfs(first + dx[i], second + dy[i], deep + 1);
}
int main() {
for (int i = 0; i < N; ++i) gets(mapa[i]);
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
if (mapa[i][j] == 'S') statue[i][j][0] = 1;
for (int i = 0; i < N - 1; ++i)
for (int j = 0; j < N; ++j)
for (int k = 0; k < N; ++k)
if (statue[j][k][i])
if (j + 1 < N) statue[j + 1][k][i + 1] = 1;
dfs(7, 0, 0);
printf("%s", ans ? "WIN" : "LOSE");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 163577857;
const long long linf = 1ll * inf * inf;
const int N = 1000000 + 7;
const int M = 20;
const int multipleTest = 0;
long long calc(long long index, long long n) {
if (index & 1) return (index + 1) / 2;
long long cur = (n + 1) / 2;
long long m = n / 2;
if (n % 2 == 1) {
index = index / 2 - 1;
if (!index) index = m;
} else {
index = index / 2;
}
return calc(index, m) + cur;
}
long long n;
int q;
void solve() {
cin >> n >> q;
while (q-- > 0) {
long long u;
cin >> u;
cout << calc(u, n) << '\n';
}
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[52];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
int p;
cin >> p;
a[i].push_back(p);
}
sort(a[i].begin(), a[i].end());
}
int cnt = 0;
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (a[i][0] < k) {
cnt++;
ans.push_back(i);
}
}
cout << cnt << '\n';
if (ans.size()) {
for (auto &it : ans) cout << it << ' ';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, k;
vector<vector<int>> E;
long long weight[200 + 10];
long long dp[200 + 10][200 + 10];
void dfs(int v, int bef) {
for (int i = 0; i < E[v].size(); i++) {
int son = E[v][i];
if (son == bef) continue;
dfs(son, v);
}
dp[v][0] += weight[v];
for (int i = 0; i < E[v].size(); i++) {
int son = E[v][i];
if (son == bef) continue;
dp[v][0] += dp[son][k];
}
for (int i = 1; i <= k; i++) {
long long sum = 0;
for (int j = 0; j < E[v].size(); j++) {
int son = E[v][j];
if (son == bef) continue;
sum += dp[son][max(k - i, i - 1)];
}
for (int j = 0; j < E[v].size(); j++) {
int son = E[v][j];
if (son == bef) continue;
dp[v][i] =
max(dp[v][i], dp[son][i - 1] + (sum - dp[son][max(k - i, i - 1)]));
}
}
for (int i = k - 1; i >= 0; i--) dp[v][i] = max(dp[v][i], dp[v][i + 1]);
}
int main() {
cin >> N >> k;
E.resize(N);
for (int i = 0; i < N; i++) cin >> weight[i];
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
E[a].push_back(b), E[b].push_back(a);
}
dfs(0, -1);
long long ans = 0;
for (int i = 0; i <= k + 1; i++) ans = max(ans, dp[0][i]);
cout << ans << endl;
return 0;
}
| 14 |
Subsets and Splits