solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n;
int a[n];int x=0;
for(int i=0;i<n;++i){
cin>>a[i];
x =a[i]^x;
}
for(int i=0;i<n;++i){
k=x^a[i];
cout<<k<<" ";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
using namespace std;
bool Solve(int n, vector<int> &val, int mid, vector<bool> &ans) {
int last0 = 0, last1 = mid;
for (int i = 0; i < n; i++) {
if (val[i] >= last1) {
ans[i] = true;
last1 = val[i];
} else {
if (val[i] > mid || val[i] < last0) {
return false;
}
ans[i] = false;
last0 = val[i];
}
}
return true;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
int test_c;
cin >> test_c;
while (test_c--) {
int n;
cin >> n;
vector<int> val(n);
for (int i = 0; i < n; i++) {
char a;
cin >> a;
val[i] = (a - '0');
}
vector<bool> ans(n);
bool can = false;
for (int i = 0; i < 10; i++) {
if (Solve(n, val, i, ans)) {
can = true;
break;
}
}
if (can) {
for (int a : ans) {
cout << a + 1;
}
cout << '\n';
} else {
cout << '-' << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void Code_780A_AndryushaAndSocks();
void Code_625A_GuestFromThePast();
void Code_799A_CarrotCakes();
void Code_222A_ShooshunsAndSequence();
void Code_336A_VasilyTheBearAndTriangle();
void Code_157A_GameOutcome();
void Code_485A_Factory();
void Code_16A_Flag();
void Code_382A_KseniaAndPanScales();
void Code_408A_LineToCashier();
void Code_143A_HelpVasilisaTheWise2();
void Code_363A_Soroban();
void Code_5A_ChatServersOutgoingTraffic();
void Code_215A_BicycleChain();
void Code_259A_LittleElephantAndChess();
void Code_365A_GoodNumber();
void Code_689A_MikeAndCellphone();
void Code_242A_HeadsOrTails();
void Code_355A_VasyaAndDigitalRoot();
void Code_373A_CollectingBeatsIsFun();
void Code_108A_PalindromicTimes();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
Code_108A_PalindromicTimes();
return 0;
}
inline void Code_108A_PalindromicTimes() {
string s;
cin >> s;
int hour = (s[0] - '0') * 10 + (s[1] - '0');
int min = (s[3] - '0') * 10 + (s[4] - '0');
if (min < (hour % 10) * 10 + hour / 10 && !(hour >= 16 && hour <= 19) &&
!(hour >= 6 && hour <= 9)) {
if (hour <= 9)
cout << 0 << hour << ":" << hour << 0;
else
cout << hour << ":" << (hour % 10) * 10 + hour / 10;
return;
}
++hour;
hour %= 24;
if (hour >= 16 && hour <= 19)
cout << "20:02";
else if (hour >= 6 && hour <= 9)
cout << "10:01";
else {
if (hour <= 9)
cout << 0 << hour << ":" << hour << 0;
else
cout << hour << ":" << (hour % 10) << hour / 10;
}
}
inline void Code_373A_CollectingBeatsIsFun() {
int k;
cin >> k;
k *= 2;
int count[10];
memset(count, 0, sizeof(count));
for (int i = 1; i <= 16; ++i) {
char c;
cin >> c;
if (c == '.') continue;
++count[c - '0'];
}
bool isOK = true;
for (int i = 1; i <= 9; ++i) {
if (count[i] > k) {
isOK = false;
break;
}
}
if (isOK)
cout << "YES";
else
cout << "NO";
}
inline void Code_355A_VasyaAndDigitalRoot() {
int k, d;
cin >> k >> d;
if (d == 0 && k > 1) {
cout << "No solution";
return;
}
--k;
cout << d;
while (k--) cout << 0;
}
inline void Code_242A_HeadsOrTails() {
int x, y, a, b;
cin >> x >> y >> a >> b;
int total = 0;
if (a <= b) a = b + 1;
for (int i = a; i <= x; ++i)
for (int j = b; j <= min(y, i - 1); ++j) ++total;
cout << total << endl;
for (int i = a; i <= x; ++i)
for (int j = b; j <= min(y, i - 1); ++j) cout << i << " " << j << endl;
}
inline void Code_689A_MikeAndCellphone() {
int n;
cin >> n;
int number[n];
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
number[i] = c - '0';
}
int positions[10][9] = {
{7, 8, 9, -1, 0, -1, -1, -1, -1}, {-1, -1, -1, -1, 1, 2, -1, 4, 5},
{-1, -1, -1, 1, 2, 3, 4, 5, 6}, {-1, -1, -1, 2, 3, -1, 5, 6, -1},
{-1, 1, 2, -1, 4, 5, -1, 7, 8}, {1, 2, 3, 4, 5, 6, 7, 8, 9},
{2, 3, -1, 5, 6, -1, 8, 9, -1}, {-1, 4, 5, -1, 7, 8, -1, -1, 0},
{4, 5, 6, 7, 8, 9, -1, 0, -1}, {5, 6, -1, 8, 9, -1, 0, -1, -1}};
int possibilities = 0;
for (int i = 0; i < 9; ++i) {
bool isOK = true;
for (int j = 0; j < n; ++j) {
if (positions[number[j]][i] == -1) {
isOK = false;
break;
}
}
if (isOK) ++possibilities;
}
if (possibilities > 1)
cout << "NO";
else
cout << "YES";
}
inline void Code_365A_GoodNumber() {
int n, k, good = 0;
cin >> n >> k;
while (n--) {
string number;
cin >> number;
int size = number.size();
bool goodNumber[k + 1];
memset(goodNumber, false, sizeof(goodNumber));
++good;
for (int i = 0; i < size; ++i) goodNumber[number[i] - '0'] = true;
for (int i = 0; i <= k; ++i) {
if (!goodNumber[i]) {
--good;
break;
}
}
}
cout << good;
}
inline void Code_259A_LittleElephantAndChess() {
string WBWBWBWB = "WBWBWBWB", BWBWBWBW = "BWBWBWBW", row[8];
for (int i = 0; i < 8; ++i) cin >> row[i];
for (int i = 0; i < 8; ++i) {
if (row[i] != WBWBWBWB && row[i] != BWBWBWBW) {
cout << "NO";
return;
}
}
cout << "YES";
}
inline void Code_215A_BicycleChain() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
int m;
cin >> m;
int b[m];
for (int i = 0; i < m; ++i) cin >> b[i];
int maxRatio = 0, total = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (b[j] % a[i] == 0) maxRatio = max(maxRatio, b[j] / a[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (b[j] % a[i] == 0 && b[j] / a[i] == maxRatio) ++total;
cout << total;
}
inline void Code_5A_ChatServersOutgoingTraffic() {
string line;
int users = 0, bytes = 0;
while (getline(cin, line)) {
if (line[0] == '+')
++users;
else if (line[0] == '-')
--users;
else
bytes += (line.size() - line.find(':') - 1) * users;
}
cout << bytes;
}
inline void Code_363A_Soroban() {
string s;
cin >> s;
int size = s.size();
for (int i = size - 1; i >= 0; --i) {
int get = s[i] - '0';
if (get >= 5) {
cout << "-O|";
get -= 5;
} else
cout << "O-|";
for (int i = 1; i <= get; ++i) cout << "O";
cout << "-";
for (int i = get + 1; i <= 4; ++i) cout << "O";
cout << endl;
}
}
inline void Code_143A_HelpVasilisaTheWise2() {
int r1, r2, c1, c2, d1, d2;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
for (int a = 1; a <= 9; ++a) {
int b = r1 - a, c = c1 - a, d = d1 - a;
if (b <= 0 || c <= 0 || d <= 0 || b > 9 || c > 9 || d > 9) continue;
if (a == b || a == c || a == d || b == c || b == d || c == d) continue;
if (b + d != c2 || c + d != r2 || b + c != d2) continue;
cout << a << " " << b << endl;
cout << c << " " << d << endl;
return;
}
cout << -1;
}
inline void Code_408A_LineToCashier() {
int n;
cin >> n;
int k[n];
long long minTime = 999999999, counter, get;
for (int i = 0; i < n; ++i) cin >> k[i];
for (int i = 0; i < n; ++i) {
counter = 15 * k[i];
while (k[i]--) {
cin >> get;
counter += 5 * get;
}
minTime = min(minTime, counter);
}
cout << minTime;
}
inline void Code_382A_KseniaAndPanScales() {
string line1, line2;
cin >> line1 >> line2;
int left = 0, right = 0, i = 0, residual = line2.size(), limit = line1.size();
while (i < limit && line1[i] != '|') {
++left;
++i;
}
++i;
while (i < limit) {
++right;
++i;
}
int required = abs(left - right);
if (residual - required < 0 || (residual - required) % 2)
cout << "Impossible";
else {
if (left <= right) {
cout << line2.substr(0, required + (residual - required) / 2);
cout << line1;
cout << line2.substr(required + (residual - required) / 2);
} else {
cout << line2.substr(required + (residual - required) / 2);
cout << line1;
cout << line2.substr(0, required + (residual - required) / 2);
}
}
}
inline void Code_16A_Flag() {
int row, col;
cin >> row >> col;
char flag[row][col];
for (int i = 0; i < row; ++i)
for (int j = 0; j < col; ++j) cin >> flag[i][j];
bool isISO = true;
for (int j = 0; j < col; ++j) {
if (flag[0][j] != flag[0][0]) {
isISO = false;
break;
}
}
for (int i = 1; i < row && isISO; ++i) {
if (flag[i - 1][0] == flag[i][0]) {
isISO = false;
break;
}
for (int j = 0; j < col; ++j) {
if (flag[i][j] != flag[i][0]) {
isISO = false;
break;
}
}
}
if (isISO)
cout << "YES";
else
cout << "NO";
}
inline void Code_485A_Factory() {
long long a, m;
cin >> a >> m;
if (a % m == 0) {
cout << "Yes" << endl;
return;
}
int limit = log2(m);
for (int i = 1; i <= limit; ++i) {
a *= 2;
if (a % m == 0) {
cout << "Yes" << endl;
return;
}
}
cout << "No" << endl;
}
inline void Code_157A_GameOutcome() {
int n;
cin >> n;
int square[n][n];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> square[i][j];
int row[n], col[n];
for (int i = 0; i < n; ++i) {
row[i] = 0;
for (int j = 0; j < n; ++j) row[i] += square[i][j];
}
for (int j = 0; j < n; ++j) {
col[j] = 0;
for (int i = 0; i < n; ++i) col[j] += square[i][j];
}
int winning = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (row[i] < col[j]) ++winning;
cout << winning;
}
inline void Code_336A_VasilyTheBearAndTriangle() {
long x, y;
cin >> x >> y;
if (x > 0 && y > 0)
cout << 0 << " " << x + y << " " << x + y << " " << 0;
else if (x > 0 && y < 0)
cout << 0 << " " << y - x << " " << x - y << " " << 0;
else if (x < 0 && y < 0)
cout << x + y << " " << 0 << " " << 0 << " " << x + y;
else if (x < 0 && y > 0)
cout << x - y << " " << 0 << " " << 0 << " " << y - x;
}
inline void Code_222A_ShooshunsAndSequence() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; ++i) cin >> a[i];
int pivot = a[k], operations = 0;
for (int i = k; i <= n; ++i) {
if (a[i] != pivot) {
cout << "-1";
return;
}
}
for (int i = k - 1; i >= 1; --i) {
if (a[i] != pivot) {
operations = i;
break;
}
}
cout << operations;
}
inline void Code_799A_CarrotCakes() {
int n, t, k, d;
cin >> n >> t >> k >> d;
int withoutOven = (n % k == 0 ? t * (n / k) : t * (n / k + 1));
if (d + t >= withoutOven)
cout << "NO";
else
cout << "YES";
}
inline void Code_625A_GuestFromThePast() {
long long int n, a, b, c, netCost;
cin >> n >> a >> b >> c;
netCost = b - c;
if (netCost >= a || n < b)
cout << n / a;
else
cout << (n - b) / netCost + 1 + (n - netCost * ((n - b) / netCost + 1)) / a;
}
inline void Code_780A_AndryushaAndSocks() {
int n;
cin >> n;
int x[2 * n + 1];
int count[n + 1];
for (int i = 0; i <= n; ++i) count[i] = 0;
for (int i = 1; i <= 2 * n; ++i) cin >> x[i];
int onTable = 0, maxOnTable = 0;
for (int i = 1; i <= 2 * n; ++i) {
if (!count[x[i]]) {
++count[x[i]];
++onTable;
maxOnTable = max(maxOnTable, onTable);
} else
--onTable;
}
cout << maxOnTable;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int nx;
long int x;
long int y;
long int z;
long int px = 1;
long int py = 1;
long int pz = 1;
long int k;
cin >> x;
cin >> y;
cin >> z;
cin >> k;
long int maxk = x + y + z - 3;
if (k > maxk) {
nx = (long long int)x * y * z;
cout << nx;
return 0;
}
while (k - 3 >= 0) {
if (px + 1 <= x) {
px++;
k--;
}
if (py + 1 <= y) {
py++;
k--;
}
if (pz + 1 <= z) {
pz++;
k--;
}
}
while (k > 0) {
if ((k - 1 >= 0) && (px + 1 <= x)) {
px++;
k--;
}
if (k == 0) break;
if (k - 1 >= 0 && py + 1 <= y) {
py++;
k--;
}
if (k == 0) break;
if (k - 1 >= 0 && pz + 1 <= z) {
pz++;
k--;
}
if (k == 0) break;
}
nx = (long long int)px * py * pz;
cout << nx;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void ans(vector<string>& a, int n) {
int size = 0;
vector<string> b;
string c = "";
int k;
for (int i = 0; i < n; i++) {
c += a[i][0];
c += a[i][1];
k = 2;
size = a[i].length();
for (int j = 3; j < size; j += 2) {
c += a[i][j];
}
b.push_back(c);
c = "";
}
for (int i = 0; i < n; i++) {
cout << b[i] << "\n";
}
return;
}
int main() {
int n;
vector<string> a;
cin >> n;
string x;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
ans(a, n);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int inf = 1e9 + 143;
const long long longinf = 1e18 + 143;
inline int read() {
int x;
scanf(" %d", &x);
return x;
}
const int N = int(1e5) + 100;
const int K = 700;
const int NK = N / K + 10;
int a[N];
int big_id[N], ptr = 0;
vector<int> loc[N];
struct node {
node *l, *r;
int *cnt;
int x, y, sz;
node(int _x = 0);
};
node *null;
node::node(int _x) {
x = _x;
y = rand() << 16 ^ rand();
cnt = new int[NK];
for (int i = 0; i < NK; i++) cnt[i] = 0;
if (big_id[x] != -1) cnt[big_id[x]] = 1;
sz = 1;
l = r = null;
}
inline void relax(node *p) {
p->sz = 1 + p->l->sz + p->r->sz;
for (int i = 0; i < NK; i++) p->cnt[i] = p->l->cnt[i] + p->r->cnt[i];
if (big_id[p->x] != -1) p->cnt[big_id[p->x]]++;
}
node *merge(node *l, node *r) {
if (l == null) return r;
if (r == null) return l;
if (l->y > r->y) {
l->r = merge(l->r, r);
relax(l);
return l;
} else {
r->l = merge(l, r->l);
relax(r);
return r;
}
}
void split(node *root, node *&l, node *&r, int from) {
if (root == null) {
l = r = null;
return;
}
if (from <= root->l->sz) {
split(root->l, l, r, from);
root->l = r;
relax(root);
r = root;
} else {
split(root->r, l, r, from - root->l->sz - 1);
root->r = l;
relax(root);
l = root;
}
}
node *rotate1(node *root, int x1, int x2) {
node *l, *m, *r;
split(root, l, r, x1 - 1);
split(r, m, r, x2 - x1 + 1);
{
node *T1, *T2;
split(m, T1, T2, x2 - x1);
m = merge(T2, T1);
}
return merge(l, merge(m, r));
}
int get_ans(node *&root, int x1, int x2, int k) {
node *l, *m, *r;
split(root, l, r, x1 - 1);
split(r, m, r, x2 - x1 + 1);
int t = m->cnt[big_id[k]];
root = merge(l, merge(m, r));
return t;
}
namespace TA2 {
struct treap {
treap *l, *r, *par;
int x, y, sz;
treap(int _x = 0);
};
treap *null2;
treap *pos[N];
treap::treap(int _x) {
x = _x;
y = rand() << 16 ^ rand();
sz = 1;
l = r = par = null2;
}
inline void relax(treap *&p) {
p->sz = 1 + p->l->sz + p->r->sz;
if (p->l != null2) p->l->par = p;
if (p->r != null2) p->r->par = p;
}
treap *merge(treap *l, treap *r) {
if (l == null2) return r;
if (r == null2) return l;
if (l->y > r->y) {
l->r = merge(l->r, r);
relax(l);
return l;
} else {
r->l = merge(l, r->l);
relax(r);
return r;
}
}
void split(treap *root, treap *&l, treap *&r, int from) {
if (root == null2) {
l = r = null2;
return;
}
if (from <= root->l->sz) {
split(root->l, l, r, from);
root->l = r;
relax(root);
r = root;
} else {
split(root->r, l, r, from - root->l->sz - 1);
root->r = l;
relax(root);
l = root;
}
}
treap *rotate2(treap *root, int x1, int x2) {
treap *l, *m, *r;
split(root, l, r, x1 - 1);
split(r, m, r, x2 - x1 + 1);
{
treap *T1, *T2;
split(m, T1, T2, x2 - x1);
m = merge(T2, T1);
}
return merge(l, merge(m, r));
}
inline int get_pos(treap *&root, int x) {
treap *p = pos[x];
int ans = p->l->sz;
while (p != root) {
treap *next = p->par;
if (next->r == p) ans += next->l->sz + 1;
assert(next->l == p || next->r == p);
p = next;
}
return ans + 1;
}
int get_ans2(treap *&root, int x1, int x2, int k) {
int ans = 0;
for (__typeof((loc[k]).begin()) it = (loc[k]).begin(); it != (loc[k]).end();
it++) {
int x = *it;
int y = get_pos(root, x);
if (y <= x2 && y >= x1) ++ans;
}
return ans;
}
}; // namespace TA2
int main() {
srand(time(0));
null = new node();
null->sz = 0;
null->x = null->y = 0;
null->cnt = new int[NK];
for (int i = 0; i < NK; i++) null->cnt[i] = 0;
null->l = null->r = null;
TA2::null2 = new TA2::treap();
TA2::null2->sz = TA2::null2->x = TA2::null2->y = 0;
TA2::null2->l = TA2::null2->r = TA2::null2->par = TA2::null2;
int n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
loc[a[i]].push_back(i);
}
for (int i = 0; i < N; i++) {
if (loc[i].size() > K) {
big_id[i] = ptr++;
} else {
big_id[i] = -1;
}
}
node *root = null;
TA2::treap *root2 = TA2::null2;
for (int i = 1; i <= n; i++) {
root = merge(root, new node(a[i]));
TA2::pos[i] = new TA2::treap(a[i]);
root2 = TA2::merge(root2, TA2::pos[i]);
}
int q = read();
int lastans = 0;
for (int i = 0; i < q; i++) {
int t = read();
if (t == 1) {
int l = read(), r = read();
l = (l + lastans - 1) % n + 1;
r = (r + lastans - 1) % n + 1;
if (l > r) swap(l, r);
root = rotate1(root, l, r);
root2 = TA2::rotate2(root2, l, r);
} else {
int l = read(), r = read(), k = read();
l = (l + lastans - 1) % n + 1;
r = (r + lastans - 1) % n + 1;
k = (k + lastans - 1) % n + 1;
if (l > r) swap(l, r);
if (big_id[k] != -1) {
lastans = get_ans(root, l, r, k);
} else {
lastans = TA2::get_ans2(root2, l, r, k);
}
printf("%d\n", lastans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
int flag = 0;
for (int j = i - 1; j >= i - x; j--) {
if (j < 0) break;
if (v[j] <= v[i]) {
flag = 1;
break;
}
}
if (flag == 1) continue;
for (int k = i + 1; k <= i + y; k++) {
if (k >= n) break;
if (v[k] <= v[i]) {
flag = 1;
break;
}
}
if (flag == 0) {
cout << i + 1 << endl;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int prim[maxn], vis[maxn], cnt;
void sprim() {
for (int i = 2; i < maxn; i++) {
if (!vis[i]) prim[++cnt] = i;
for (int j = 1; j <= cnt && i * prim[j] < maxn; j++) {
vis[i * prim[j]] = 1;
if (i % prim[j] == 0) break;
}
}
}
struct Node {
vector<pair<int, int>> vec;
bool operator<(const Node &T) const {
int i = 0, j = 0;
while (i < vec.size() && j < T.vec.size()) {
if (vec[i] != T.vec[j]) return vec[i] < T.vec[j];
i++, j++;
}
return (i == vec.size()) && (j != T.vec.size());
}
bool operator==(const Node &T) const {
if (vec.size() != T.vec.size()) return 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] != T.vec[i]) return 0;
}
return 1;
}
};
map<Node, int> Last;
int Preprim[maxn], n, x, k;
long long ans;
int main() {
sprim();
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
Node Fid, Add;
Fid.vec.clear();
Add.vec.clear();
for (int j = 1; x != 1; j++) {
if (x % prim[j] == 0) {
int cnt = 0;
while (x % prim[j] == 0) {
x /= prim[j];
cnt++;
}
if (cnt % k == 0) continue;
Add.vec.push_back({prim[j], cnt % k});
Fid.vec.push_back({prim[j], (k - (cnt % k)) % k});
}
}
ans += Last[Fid];
Last[Add]++;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[n + 1];
for (int i = 1; i <= n; i++) cin >> arr[i];
int c = 0;
for (int i = 0; i < m; i++) {
int ch;
cin >> ch;
if (ch == 1) {
int y;
int z;
cin >> y >> z;
arr[y] = z;
arr[y] -= c;
} else if (ch == 2) {
int y;
cin >> y;
c += y;
} else {
int y;
cin >> y;
cout << arr[y] + c << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 69;
const long long LOGN = 20;
struct edge {
long long u, v, w;
bool operator<(const edge& oth) const { return w < oth.w; }
};
struct vl {
long long x, y;
};
struct node {
long long p, ma;
};
long long n, m;
vector<edge> e;
vector<vl> a[MAXN];
vector<edge> trash;
long long root[MAXN];
node up[MAXN][LOGN];
long long tin[MAXN], tout[MAXN], ti;
long long Find(long long u) {
return root[u] >= 0 ? root[u] = Find(root[u]) : u;
}
bool Union(long long u, long long v) {
u = Find(u);
v = Find(v);
if (u == v) return 0;
if (root[u] > root[v]) swap(u, v);
root[u] += root[v];
root[v] = u;
return 1;
}
void dfs(long long u, long long p, long long w) {
tin[u] = ++ti;
up[u][0] = {p, w};
for (long long i = 1; i < LOGN; i++) {
node half = up[u][i - 1];
node all = up[half.p][i - 1];
up[u][i].p = all.p;
up[u][i].ma = max(half.ma, all.ma);
}
for (vl i : a[u]) {
long long v = i.x, w = i.y;
if (v != p) dfs(v, u, w);
}
tout[u] = ++ti;
}
bool is_anc(long long u, long long v) {
return tin[u] <= tin[v] && tout[v] <= tout[u];
}
long long lca(long long u, long long v) {
if (is_anc(u, v)) return u;
if (is_anc(v, u)) return v;
for (long long i = LOGN - 1; i >= 0; i--)
if (!is_anc(up[u][i].p, v)) u = up[u][i].p;
return up[u][0].p;
}
long long max_edge(long long p, long long u) {
long long res = 0;
for (long long i = LOGN - 1; i >= 0; i--)
if (is_anc(p, up[u][i].p)) {
res = max(res, up[u][i].ma);
u = up[u][i].p;
}
return res;
}
long long max_edge_on_path(long long u, long long v) {
long long p = lca(u, v);
return max(max_edge(p, u), max_edge(p, v));
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1, u, v, w; i <= m; i++) {
cin >> u >> v >> w;
e.push_back({u, v, w});
}
fill(root + 1, root + 1 + n, -1);
sort(e.begin(), e.end());
for (edge i : e) {
if (Union(i.u, i.v)) {
a[i.u].push_back({i.v, i.w});
a[i.v].push_back({i.u, i.w});
} else
trash.push_back(i);
}
dfs(1, 1, 0);
long long ans = 0;
for (edge i : trash) {
if (max_edge_on_path(i.u, i.v) == i.w) ans++;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int cases;
cin >> cases;
while (cases > 0) {
cases -= 1;
int a;
cin >> a;
if (a < 31) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
if (a - 30 == 6) {
cout << 5 << ' ' << 6 << ' ' << 10 << ' ' << 15 << '\n';
} else if (a - 30 == 10) {
cout << 10 << ' ' << 14 << ' ' << 15 << ' ' << 1 << '\n';
} else if (a - 30 == 14) {
cout << 10 << ' ' << 14 << ' ' << 15 << ' ' << 5 << '\n';
} else {
cout << 6 << ' ' << 10 << ' ' << 14 << ' ' << a - 30 << '\n';
}
}
}
}
| 1 |
#include<deque>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<cmath>
#include<cstdio>
#include<cstring>
using namespace std;
#define dis(p,q) ((p)*(p)+(q)*(q))
int main(){
int i,j,k;
int n;
while(cin>>n,n){
double x[300],y[300];
for(i=0;i<n;++i)
cin>>x[i]>>y[i];
int mx=1;
for(i=0;i<n-1;++i){
for(j=i+1;j<n;++j){
double d=dis(x[i]-x[j],y[i]-y[j]);
if(d<=4){
double cx[2],cy[2],a=atan2(y[i]-y[j],x[i]-x[j]);
int sm[2]={2,2};
d=sqrt(1-d/4);
cx[0]=(x[i]+x[j])/2+cos(a+M_PI/2)*d;
cy[0]=(y[i]+y[j])/2+sin(a+M_PI/2)*d;
cx[1]=(x[i]+x[j])/2+cos(a-M_PI/2)*d;
cy[1]=(y[i]+y[j])/2+sin(a-M_PI/2)*d;
for(k=0;k<n;++k){
if(k!=i&&k!=j){
if(dis(x[k]-cx[0],y[k]-cy[0])<=1)
++sm[0];
if(dis(x[k]-cx[1],y[k]-cy[1])<=1)
++sm[1];
}
}
mx=max(max(mx,sm[0]),sm[1]);
}
}
}
cout<<mx<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
const int MAXP = 20;
int par[MAXP][MAXN];
int depth[MAXN];
int n, m;
vector<int> G[MAXN];
void dfs(int u, int p, int d) {
par[0][u] = p;
depth[u] = d;
for (auto v : G[u])
if (v != p) dfs(v, u, d + 1);
}
void calc_par(void) {
for (int p(1); p < MAXP; ++p)
for (int i(0); i < n; ++i) par[p][i] = par[p - 1][par[p - 1][i]];
}
int go_up(int u, int dis) {
for (int p(0); p < MAXP; ++p)
if ((1 << p) & dis) u = par[p][u];
return u;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i(1); i < n; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(0, 0, 0);
calc_par();
while (m--) {
int sz_query;
cin >> sz_query;
vector<int> vertices(sz_query);
for (auto &v : vertices) {
cin >> v;
--v;
}
int lowest(0);
for (int i(1); i < sz_query; ++i)
if (depth[vertices[lowest]] < depth[vertices[i]]) lowest = i;
bool ok = true;
for (int i(0); i < sz_query; ++i)
if (lowest != i) {
int diff = depth[vertices[lowest]] - depth[vertices[i]];
if (go_up(vertices[lowest], diff) != vertices[i] and
go_up(vertices[lowest], diff + 1) != par[0][vertices[i]])
ok = false;
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool exists[1 << 22] = {false};
bool visited[1 << 22];
void dfs1(int u, stack<int> &st) {
assert(u >= 0 && u < (1 << n));
visited[u] = true;
if (exists[u]) {
const int v = ((1 << n) - 1) ^ u;
assert(v >= 0 && v < (1 << n));
if (!visited[v]) dfs1(v, st);
}
for (int mask = 1; mask < (1 << n); mask <<= 1)
if (u & mask) {
const int v = u ^ mask;
assert(v >= 0 && v < (1 << n));
if (!visited[v]) dfs1(v, st);
}
st.push(u);
}
int test = 0;
bool dfs2(int u) {
assert(u >= 0 && u < (1 << n));
visited[u] = true;
bool res = exists[u];
const int v = ((1 << n) - 1) ^ u;
assert(v >= 0 && v < (1 << n));
if (exists[v] && !visited[v]) res = dfs2(v) || res;
for (int mask = 1; mask < (1 << n); mask <<= 1)
if (!(u & mask)) {
const int v = u ^ mask;
assert(v >= 0 && v < (1 << n));
if (!visited[v]) res = dfs2(v) || res;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
exists[a] = true;
}
stack<int> st;
for (int i = 0; i < (1 << n); ++i)
if (!visited[i]) dfs1(i, st);
assert(st.size() == (1 << n));
memset(visited, 0, sizeof visited);
int ans = 0;
while (!st.empty()) {
const int u = st.top();
st.pop();
ans += !visited[u] && dfs2(u);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
set<long long> divs;
vector<long long> vecDivs;
void allDiv(long long a) {
long long sqA = sqrt(a) + 1;
for (int i = 1; i < sqA; i++) {
if (a % i == 0) {
divs.insert(i);
divs.insert(a / i);
}
}
set<long long>::iterator it;
for (it = divs.begin(); it != divs.end(); it++) vecDivs.push_back(*it);
}
long long BS(long long srchLow, long long srchHigh) {
long long high = vecDivs.size();
long long low = 0;
long long mid;
long long ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (vecDivs[mid] > srchHigh) {
high = mid - 1;
} else if (vecDivs[mid] < srchLow) {
low = mid + 1;
} else if (vecDivs[mid] >= srchLow && vecDivs[mid] <= srchHigh) {
ans = vecDivs[mid];
low = mid + 1;
}
}
return ans;
}
int main() {
long long a, b;
scanf("%lld", &a);
scanf("%lld", &b);
allDiv(gcd(a, b));
int n;
scanf("%d", &n);
while (n--) {
long long low, high;
scanf("%lld", &low);
scanf("%lld", &high);
if (low == high) {
if (gcd(a, b) % low == 0)
printf("%lld\n", low);
else
printf("-1\n");
} else
printf("%lld\n", BS(low, high));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int frsti, lsti, frstj, lstj, n, m, le, ri, ans, mid;
vector<int> dp[N], dp1[N], a[N], fix[N];
char ch;
int sz(int i, int j, int i1, int j1) {
int len = (i1 - i + 1);
int height = (j1 - j + 1);
return len * height;
}
int cnt(int i, int j, int i1, int j1) {
return dp[i1][j1] - dp[i1][j - 1] - dp[i - 1][j1] + dp[i - 1][j - 1];
}
int getans(int i, int j, int i1, int j1) {
return dp1[i1][j1] - dp1[i1][j - 1] - dp1[i - 1][j1] + dp1[i - 1][j - 1];
}
int check(int t, int ty) {
for (int i = 0; i <= n + 3; i++) {
fix[i].resize(m + 5);
dp1[i].resize(m + 5);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
fix[i][j] = 0;
dp1[i][j] = 0;
if (i - t + 1 < 1 || i + t - 1 > n || j - t + 1 < 1 || j + t - 1 > m)
continue;
frsti = i - t + 1;
frstj = j - t + 1;
lsti = i + t - 1;
lstj = j + t - 1;
if (cnt(frsti, frstj, lsti, lstj) == sz(frsti, frstj, lsti, lstj)) {
fix[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp1[i][j] = dp1[i - 1][j] + dp1[i][j - 1] + fix[i][j] - dp1[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1) {
frsti = max(1, i - t + 1);
frstj = max(1, j - t + 1);
lsti = min(n, i + t - 1);
lstj = min(m, j + t - 1);
if (getans(frsti, frstj, lsti, lstj) == 0) return 0;
}
}
}
if (ty == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (fix[i][j])
cout << "X";
else
cout << ".";
}
cout << "\n";
}
}
return 1;
}
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i <= n + 3; i++) {
a[i].resize(m + 5);
dp[i].resize(m + 5);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch;
if (ch == 'X')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + a[i][j];
}
}
le = 1;
ri = min(n, m);
while (le <= ri) {
mid = (le + ri) / 2;
if (check(mid, 0)) {
ans = mid;
le = mid + 1;
} else
ri = mid - 1;
}
cout << ans - 1 << "\n";
int ff = check(ans, 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, p = 1e9 + 7;
int n, ans = 0;
long long jc[N];
long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % p;
a = a * a % p;
b >>= 1;
}
return r;
}
long long C(long long m, long long n) {
long long a = jc[m];
long long b = jc[n] * jc[m - n] % p;
long long c = qpow(b, p - 2);
long long r = a * c % p;
return r;
}
int main() {
scanf("%d", &n);
jc[0] = 1;
for (int i = 1; i <= n * 2; i++) jc[i] = jc[i - 1] * i % p;
printf("%lld", C(2 * n, n) - n);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
void getmax(int &x,int y){x=max(x,y);}
void getmin(int &x,int y){x=min(x,y);}
int n,q,l,r;
int b[200100],dat[524288],mx=262144,dp[200100];
int w[200100],pre[200100];
vector<int> opr[200100];
void update(int l,int r,int delta){
l+=mx;r+=mx;
while(l<=r){
getmin(dat[l],delta);
getmin(dat[r],delta);
l=(l+1)>>1;
r=(r-1)>>1;
}
}
int get(int p){
p+=mx;
int ret=1e9;
while(p){
getmin(ret,dat[p]);
p>>=1;
}
return ret;
}
int main(){
#ifdef FILIN
#ifndef LOCAL
freopen(FILIN,"r",stdin);
freopen(FILOUT,"w",stdout);
#endif
#endif
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
for(int i=1;i<mx*2;i++)
dat[i]=1e9;
cin>>n;
for(int i=1;i<=n;i++){
cin>>w[i];
pre[i]=pre[i-1]+(1-w[i]);
}
cin>>q;
for(int i=1;i<=q;i++){
cin>>l>>r;
opr[r].push_back(l);
}
for(int i=1;i<=n;i++){
update(i-1,i-1,dp[i-1]-pre[i-1]);
dp[i]=dp[i-1]+w[i];
for(int j:opr[i]){
update(j,i,get(j-1));
}
getmin(dp[i],get(i)+pre[i]);
}
cout<<dp[n]<<endl;
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
using namespace std;
int login(int a, int b, int c){
int count = 0;
while( c > 0 ){
c -= a;
count++;
if(count % 7 == 0) c -= b;
}
return count;
}
int main(){
int a, b, c;
scanf("%d %d %d",&a, &b, &c);
printf("%d\n",login(a, b, c));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
const int mod = 1e9 + 7;
int cnt1[N], cnt2[N];
int main() {
string s;
cin >> s;
int i;
s = " " + s;
int n = (int)s.size() - 1;
for (i = 1; i < (int)s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z')
cnt1[i] = cnt1[i - 1] + 1;
else
cnt1[i] = cnt1[i - 1];
if (s[i] >= 'A' && s[i] <= 'Z')
cnt2[i] = cnt2[i - 1] + 1;
else
cnt2[i] = cnt2[i - 1];
}
int ans = 1e9;
for (i = 0; i <= n; i++) {
ans = min(ans, cnt1[i] + cnt2[n] - cnt2[i]);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, temp, arr[1005];
scanf("%lld", &n);
for (i = 0; i < n; i++) scanf("%lld", &arr[i]);
for (i = 0; i < n - 1; i++) {
if (i % 2 == 0) {
if (arr[i] > arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
} else {
if (arr[i] < arr[i + 1]) {
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
}
for (i = 0; i < n; i++) printf("%lld ", arr[i]);
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, a;
vector<int> v;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (a != 0 && a <= k) {
v.push_back(10 * abs(i + 1 - m));
}
}
sort(v.begin(), v.end());
printf("%d\n", v[0]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b, lo = 0, hi = m, res;
scanf("%I64d %I64d", &a, &b);
m = (b - 1) / a;
m++;
printf("%I64d\n", m);
return 0;
}
| 1 |
#include <iostream>
#include <math.h>
#include <cstdio>
using namespace std;
int main(){
double a,b,c,s,l,h;
cin >> a >> b >> c;
s=0.5*a*b*sin((M_PI*c*1.0)/180);
l=a+b+sqrt(pow(a,2.0)+pow(b,2.0)-2*a*b*cos((M_PI*c*1.0)/180));
h=b*sin((M_PI*c*1.0)/180);
printf("%.8f\n%.8f\n%.8f\n",s,l,h);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt = 0;
void insertionSort(int a[], int n, int g) {
for (int i=g; i<n; i++) {
int v = a[i];
int j = i - g;
while (j >= 0 && a[j] > v) {
a[j+g] = a[j];
j -= g;
cnt++;
}
a[j+g] = v;
}
}
void shellSort(int a[], int n) {
vector<int> G;
int h = 1;
while (h <= n) {
G.push_back(h);
h = 3 * h + 1;
}
for (int i=G.size()-1; i>=0; i--)
insertionSort(a, n, G[i]);
// print info
cout << G.size() << endl;
if (G.size() > 0) {
for (int i=G.size()-1; i>0; i--)
cout << G[i] << " ";
cout << G[0] << endl;
}
}
int main() {
int n;
cin >> n;
int a[n];
for (int i=0; i<n; i++) cin >> a[i];
shellSort(a, n);
cout << cnt << endl;
for (int i=0; i<n; i++) cout << a[i] << endl;;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.14159265359;
vector<long long> primes;
void GeneratingPrimes(int top) {
vector<bool> p(top + 1, 1);
p[0] = p[1] = 0;
for (int i = 2; i <= sqrt(top); i++) {
if (p[i]) {
for (int j = i * i; j <= top; j += i) {
p[j] = 0;
}
}
}
for (int i = 0; i < top + 1; i++)
if (p[i]) primes.push_back(i);
}
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void EXTgcd(long long a, long long b, long long& x0, long long& y0) {
if (b == 0) {
x0 = 1, y0 = 0;
return;
}
EXTgcd(b, a % b, x0, y0);
long long x1 = y0;
long long y1 = x0 - (a / b) * (y0);
y1 = y1;
x0 = x1;
y0 = y1;
}
long long power(long long n, long long p, long long mod) {
if (!p) return 1;
long long ans = 1;
while (p > 1) {
if (p & 1) ans = (ans * n) % mod;
n = (n * n) % mod;
p /= 2;
}
return (ans * n) % mod;
}
double dist(double a, double b, double x, double y) {
return sqrt(pow(a - x, 2) + pow(b - y, 2));
}
double dist3(double a, double b, double c, double x, double y, double z) {
return sqrt(pow(a - x, 2) + pow(b - y, 2) + pow(c - z, 2));
}
int xadd[9] = {1, -1, 0, 1, -1, 0, 1, -1, 0};
int yadd[9] = {1, -1, 0, -1, 0, 1, 0, 1, -1};
int xx[4] = {0, 1, 0, -1};
int yy[4] = {1, 0, -1, 0};
long long const N = 4e5 + 10;
long long const INF = 1e18;
long long const mod = 1e9 + 7;
long long n, k, ans, a[N];
map<int, int> m;
multiset<int> s;
void add(int x) {
auto it = s.find(m[x]);
if (it != s.end()) s.erase(it);
s.insert(++m[x]);
}
void del(int x) {
auto it = s.find(m[x]);
if (it != s.end()) s.erase(it);
if (--m[x]) s.insert(m[x]);
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
int l = 0, r = 0, cnt = 1;
m[a[0]]++;
s.insert(1);
while (1) {
bool out = 0;
while (*(--s.end()) < k) {
if (r == n - 1) {
out = 1;
break;
}
add(a[++r]);
}
while (*(--s.end()) >= k) {
ans += n - r;
del(a[l++]);
if (l == n) {
out = 1;
break;
}
if (l > r) {
add(a[++r]);
}
}
if (out) break;
}
cout << ans;
return 0;
}
| 4 |
#include <iostream>
#include<cstdlib>
#include<queue>
#include<set>
#include<vector>
#include<string>
#include<algorithm>
#include<sstream>
#include<cmath>
#include<stack>
#include<map>
#include<cstdio>
using namespace std;
#define rep(i,a) for(int i=0;i<a;i++)
#define mp make_pair
#define pb push_back
#define P pair<int,int>
#define ll __int64
int n;
int G[101][101];
const int INF=100000000;
int dist[101];
bool used[101];
int main(){
cin>>n;
rep(i,n)rep(j,n)cin>>G[i][j];
long long ans=0;
for(int i=0;i<n;i++){
int ret=INF;
for(int j=i;j<n;j++){
ans+=min(G[i][j],G[j][i]);
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_m = 55;
const int inv = 1000000007;
long long n;
int m, k;
long long a[max_m][max_m], b[max_m][max_m], c[max_m][max_m], d[max_m][max_m];
void mult() {
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
a[i][j] = 0;
for (int k = 0; k < m; k++) {
a[i][j] += (c[i][k] * b[k][j]) % inv;
a[i][j] %= inv;
}
}
}
void exp(long long no) {
if (no == 1) return;
exp(no / 2);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
c[i][j] = a[i][j];
b[i][j] = a[i][j];
}
mult();
if (no % 2 == 1) {
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
c[i][j] = a[i][j];
b[i][j] = d[i][j];
}
mult();
}
}
int main() {
cin >> n;
scanf("%d%d", &m, &k);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) a[i][j] = 1;
char c[2];
for (int i = 0; i < k; i++) {
scanf("%s", c);
int a1 = c[0];
int a2 = c[1];
if (a1 >= 97)
a1 -= 97;
else
a1 -= 39;
if (a2 >= 97)
a2 -= 97;
else
a2 -= 39;
a[a1][a2] = 0;
}
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
b[i][j] = a[i][j];
d[i][j] = a[i][j];
}
long long res = 0;
if (n == 1) res = m;
if (n > 1) {
exp(n - 1);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
res += a[i][j];
res %= inv;
}
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m, k, t, mx;
cin >> t;
while (t--) {
cin >> n >> m >> k;
mx = min(n / k, m);
cout << (m >= mx ? mx - ceil((long double)(m - mx) / (k - 1)) : mx) << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100], dis[100][50], l, r, num, ans, down, tot;
long long dfs(long long book, long long go, bool to) {
if (book == -1) {
return 1;
}
if (to == 0 && dis[book][go] != -1) {
return dis[book][go];
}
long long down = to ? a[book] : 9;
long long ans = 0;
for (long long i = 0; i <= down; i++) {
if (i == 0) {
ans = ans + dfs(book - 1, go, to && a[book] == i);
} else if (go != 3) {
ans = ans + dfs(book - 1, go + 1, to && a[book] == i);
}
}
if (to == 0) {
dis[book][go] = ans;
}
return ans;
}
long long run(long long x) {
tot = 0;
while (x > 0) {
a[tot++] = x % 10;
x = x / 10;
}
return dfs(tot - 1, 0, true);
}
int main() {
memset(dis, -1, sizeof(dis));
cin >> num;
while (num--) {
cin >> l >> r;
cout << run(r) - run(l - 1) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, d, m;
int main() {
cin >> n >> d;
vector<int> a(n);
for (auto i(0); i < n; ++i) cin >> a[i];
cin >> m;
sort(begin(a), end(a));
;
long long sum = 0;
for (auto i(0); i < min(n, m); ++i) sum += a[i];
cout << sum - (n < m) * d * (m - n);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int e = 0, o = 0;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] & 1)
o++;
else
e++;
}
if (e % 2 == 0 && o % 2 == 0)
cout << "YES\n";
else {
int f = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (abs(a[i] - a[j]) == 1) f = 1;
if (f)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007;
void solve() {
long long x;
cin >> x;
string s;
cin >> s;
long long l = s.size();
vector<char> v(s.begin(), s.end());
for (int i = 1; i <= x; i++) {
int c = v[i - 1] - '1';
if (v.size() < x) {
vector<char> tmp(v.begin() + i, v.end());
for (int j = 0; j < c; j++) v.insert(v.end(), tmp.begin(), tmp.end());
}
l = (l + (l - i) * c) % M;
}
cout << (l + M) % M << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct room {
int x, y, z;
};
struct s {
int x, y, cost;
};
room a[500 + 1];
s b[500 + 1];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i].x >> a[i].y >> a[i].z;
int m;
cin >> m;
for (int i = 0; i < m; ++i) cin >> b[i].x >> b[i].y >> b[i].cost;
int ans = 0;
for (int i = 0; i < n; ++i) {
int sum = (int)1e9;
int p = 2 * (a[i].x + a[i].y);
for (int j = 0; j < m; ++j) {
int k = b[j].x / a[i].z;
if (!k) continue;
int t = k * b[j].y;
int d = p % t ? p / t + 1 : p / t;
sum = min(sum, d * b[j].cost);
}
ans += sum;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000006, INF = 1e18, MOD = 1e9 + 7;
long long n, w, nn, m, a[20][20], b[N], f[20][26], c[20], dp[1 << 20], d[20],
e[20], x, y, t, u, o, h, ans, Ans = INF;
pair<int, pair<int, int> > p[20];
string second;
vector<string> s;
vector<long long> v[N];
vector<pair<int, int> > q;
int main() {
cin >> n >> m;
nn = n;
for (int i = 0; i < n; i++) {
cin >> second;
s.push_back(second);
for (int j = 0; j < m; j++) f[j][s[i][j] - 'a']++;
}
for (int i = 0; i < n; i++) {
u = 0;
for (int j = 0; j < m; j++)
if (f[j][s[i][j] - 'a'] < 2) u = 1;
if (u) w |= (1 << i);
}
for (int i = 0; i < n; i++) {
b[i] = INF;
for (int j = 0; j < m; j++) cin >> a[i][j], b[i] = min(a[i][j], b[i]);
}
for (int i = 0; i < (1 << n); i++)
if ((i & w) != i) dp[i] = INF;
for (int i = 0; i < m; i++) {
q.clear();
for (int j = 0; j < n; j++) p[j] = {s[j][i] - 'a', {-a[j][i], j}};
sort(p, p + n);
for (int j = 0; j < n; j++) {
t = x = y = 0;
x |= (1 << p[j].second.second);
while (j + 1 < n && p[j + 1].first == p[j].first)
j++, x |= (1 << p[j].second.second), y -= p[j].second.first, t++;
if (t) q.push_back({x, y});
}
for (int j = 0; j < q.size(); j++)
for (int r = 0; r < (1 << n); r++)
dp[r | q[j].first] = min(dp[r | q[j].first], dp[r] + q[j].second);
}
for (int r = 0; r < (1 << n); r++) {
x = r;
ans = 0;
o = n;
while (o--) ans += (x & 1 ^ 1) * b[n - o - 1], x = (x >> 1);
Ans = min(Ans, ans + dp[r]);
}
cout << Ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int ans = 0, a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if (e < f) {
int now = min(d, min(b, c));
ans += now * f;
b -= now;
c -= now;
d -= now;
} else {
int now = min(d, a);
ans += now * e;
a -= now;
d -= now;
}
ans += e * min(a, d);
ans += f * min(d, min(b, c));
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char enl = '\n';
int n;
int fx1, fy1, fx2, fy2;
int sx1, sy1, sx2, sy2;
bool lr1(int l, int r) {
if (l == r) return false;
int m = (l + r) / 2;
int ls, rs;
cout << "? 1 1 " << n << " " << m << endl;
cin >> ls;
cout << "? 1 " << (m + 1) << " " << n << " " << n << endl;
cin >> rs;
if (ls == 1 && rs == 1) {
fx1 = 1;
fy1 = 1;
fx2 = n;
fy2 = m;
sx1 = 1;
sy1 = m + 1;
sx2 = n;
sy2 = n;
return true;
} else if (l == r)
return false;
if (ls > rs) {
return lr1(l, m);
} else if (rs > ls) {
return lr1(m + 1, r);
} else if (ls == 0 && rs == 0) {
return false;
}
}
bool ud1(int l, int r) {
if (l == r) return false;
int m = (l + r) / 2;
int ls, rs;
cout << "? 1 1 " << m << " " << n << endl;
cin >> ls;
cout << "? " << (m + 1) << " 1 " << n << " " << n << endl;
cin >> rs;
if (ls == 1 && rs == 1) {
fx1 = 1;
fy1 = 1;
fx2 = m;
fy2 = n;
sx1 = m + 1;
sy1 = 1;
sx2 = n;
sy2 = n;
return true;
} else if (l == r)
return false;
if (ls > rs) {
return ud1(l, m);
} else if (rs > ls) {
return ud1(m + 1, r);
} else if (ls == 0 && rs == 0) {
return false;
}
}
vector<int> ans;
int fl(int x1, int y1, int x2, int y2, int l, int r) {
if (r == l) return r;
int m = (l + r) / 2;
cout << "? " << x1 << " " << (m + 1) << " " << x2 << " " << y2 << endl;
int s;
cin >> s;
if (r - l <= 1) {
if (s == 1) {
return m + 1;
} else {
return m;
}
}
if (s == 1) {
return fl(x1, y1, x2, y2, m + 1, r);
} else {
return fl(x1, y1, x2, y2, l, m);
}
}
int fr(int x1, int y1, int x2, int y2, int l, int r) {
if (r == l) return r;
int m = (l + r) / 2;
cout << "? " << x1 << " " << y1 << " " << x2 << " " << m << endl;
int s;
cin >> s;
if (r - l <= 1) {
if (s == 1) {
return m;
} else {
return m + 1;
}
}
if (s == 1) {
return fr(x1, y1, x2, y2, l, m);
} else {
return fr(x1, y1, x2, y2, m + 1, r);
}
}
int fd(int x1, int y1, int x2, int y2, int l, int r) {
if (r == l) return r;
int m = (l + r) / 2;
cout << "? " << (m + 1) << " " << y1 << " " << x2 << " " << y2 << endl;
int s;
cin >> s;
if (r - l <= 1) {
if (s == 1) {
return m + 1;
} else {
return m;
}
}
if (s == 1) {
return fd(x1, y1, x2, y2, m + 1, r);
} else {
return fd(x1, y1, x2, y2, l, m);
}
}
int fu(int x1, int y1, int x2, int y2, int l, int r) {
if (r == l) return r;
int m = (l + r) / 2;
cout << "? " << x1 << " " << y1 << " " << m << " " << y2 << endl;
int s;
cin >> s;
if (r - l <= 1) {
if (s == 1) {
return m;
} else {
return m + 1;
}
}
if (s == 1) {
return fu(x1, y1, x2, y2, l, m);
} else {
return fu(x1, y1, x2, y2, m + 1, r);
}
}
void f(int x1, int y1, int x2, int y2) {
int lb = fl(x1, y1, x2, y2, y1, y2);
int rb = fr(x1, y1, x2, y2, y1, y2);
int ub = fu(x1, y1, x2, y2, x1, x2);
int db = fd(x1, y1, x2, y2, x1, x2);
ans.push_back(db);
ans.push_back(lb);
ans.push_back(ub);
ans.push_back(rb);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
ans.reserve(8);
if (!ud1(1, n)) lr1(1, n);
f(fx1, fy1, fx2, fy2);
f(sx1, sy1, sx2, sy2);
cout << "!";
for (auto x : ans) {
cout << " " << x;
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline const int getint() {
int r = 0, k = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') k = -1;
for (; c >= '0' && c <= '9'; c = getchar()) r = r * 10 + c - '0';
return k * r;
}
inline const int max(const int &a, const int &b) { return a > b ? a : b; }
inline const int min(const int &a, const int &b) { return a < b ? a : b; }
const int N = 500005;
string tp;
map<string, int> mp;
char rdin[N];
int n, m, tot, d[N], ln[N], cnt, ihead[N], vis[N], mn[N], essay[N], FF[N],
LL[N], scc, tm, top, q[N], len[N], belongs[N], U[N], V[N];
struct ED {
int next, to;
} e[N * 4];
void add(int u, int v) {
e[++cnt].next = ihead[u];
ihead[u] = cnt;
e[cnt].to = v;
}
int cal(char *s) {
int len = strlen(s), ret = 0;
for (int j = 0; j < (len); ++j)
if (s[j] == 'r') ++ret;
return ret;
}
int readin() {
scanf("%s", rdin);
int len = strlen(rdin);
for (int j = 0; j < (len); ++j)
if (rdin[j] >= 'A' && rdin[j] <= 'Z') rdin[j] = rdin[j] - 'A' + 'a';
tp = rdin;
if (mp[tp]) return mp[tp];
mp[tp] = ++tot;
ln[tot] = strlen(rdin);
d[tot] = cal(rdin);
return tot;
}
void dfs(int u) {
vis[u] = 1;
int v;
for (int i = ihead[u]; i; i = e[i].next) {
if (!vis[v = e[i].to]) dfs(v);
if (mn[v] < mn[u] || (mn[v] == mn[u] && len[v] < len[u])) {
mn[u] = mn[v];
len[u] = len[v];
}
}
}
void tarjan(int u) {
LL[u] = FF[u] = ++tm;
vis[u] = 1;
q[++top] = u;
int v;
for (int i = ihead[u]; i; i = e[i].next) {
v = e[i].to;
if (!FF[v])
tarjan(v), LL[u] = min(LL[u], LL[v]);
else if (vis[v])
LL[u] = min(LL[u], FF[v]);
}
if (FF[u] == LL[u]) {
++scc;
int x;
do {
x = q[top--];
vis[x] = 0;
belongs[x] = scc;
if (d[x] < mn[scc] || (d[x] == mn[scc] && ln[x] < len[scc]))
mn[scc] = d[x], len[scc] = ln[x];
} while (x != u);
}
}
void rebuild() {
memset(vis, 0, sizeof(vis));
memset(ihead, 0, sizeof(ihead));
cnt = 0;
for (int i = (1); i <= (m); ++i)
if (belongs[U[i]] != belongs[V[i]]) add(belongs[U[i]], belongs[V[i]]);
}
int main() {
n = getint();
for (int i = (1); i <= (n); ++i) essay[i] = readin();
m = getint();
for (int i = (1); i <= (m); ++i) {
int pos1 = readin(), pos2 = readin();
add(pos1, pos2);
U[i] = pos1, V[i] = pos2;
}
memset(mn, 0x3f, sizeof(mn));
memset(len, 0x3f, sizeof(len));
for (int i = (1); i <= (tot); ++i)
if (!FF[i]) tarjan(i);
rebuild();
for (int i = (1); i <= (scc); ++i) dfs(i);
long long ans1 = 0, ans2 = 0;
for (int i = (1); i <= (n); ++i) {
int pos = belongs[essay[i]];
ans1 += mn[pos];
ans2 += len[pos];
}
printf("%I64d %I64d\n", ans1, ans2);
return 0;
}
| 4 |
#include<iostream>
#include<vector>
#include<unordered_set>
#include<cstdio>
using namespace std;
vector<int>e[100005]{};
int par[100005];
int Rank[100005];
int find(int x) {
if (par[x] == x)return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)return;
if (Rank[x] < Rank[y]) {
par[x] = y;
}
else {
par[y] = x;
}
if (Rank[x] == Rank[y])Rank[x]++;
}
int main() {
int a, b;
scanf("%d%d", &a, &b);
for (int x = 0; x < a; x++) {
par[x] = x;
Rank[x] = 0;
}
for (int c = 0; c < a; c++) {
int d;
scanf("%d", &d);
for (int f = 0; f < d; f++) {
int g;
scanf("%d", &g);
g--;
e[g].push_back(c);
}
}
for (int x = 0; x < b; x++) {
if (e[x].size() >= 2) {
for (int p = 1; p < e[x].size(); p++)unite(e[x][0], e[x][p]);
}
}
unordered_set<int>k;
for (int i = 0; i < a; i++) {
k.insert(find(i));
}
if (k.size() == 1)puts("YES");
else puts("NO");
} | 0 |
#include <iostream>
using namespace std;
int main() {
int h, hh, k, kk;
int a, b, c, d;
cin >> h >> hh;
cin >> k >> kk;
cin >> a >> b >> c >> d;
int sum1 = h * a + hh * b + (h / 10) * c + (hh / 20) * d;
int sum2 = k * a + kk * b + (k / 10) * c + (kk / 20) * d;
if(sum1 > sum2) cout << "hiroshi" << endl;
else if(sum2 > sum1) cout << "kenjiro" << endl;
else cout << "even" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
int ans = a[0];
for (int i = 1; i < n; ++i) ans = max(ans, a[i] - a[i - 1]);
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int answer(int a, int b, int n, int i) {
if (a + b <= n) {
cout << i << ' ' << a << ' ' << n - a << endl;
return 1;
}
return 0;
}
int main() {
int n, a1, a2, b1, b2;
int na = -1, fa, sa;
cin >> n;
for (int i = 0; i < 4; ++i) {
cin >> a1 >> b1 >> a2 >> b2;
if (answer(a1, a2, n, i + 1)) return 0;
if (answer(a1, b2, n, i + 1)) return 0;
if (answer(b1, a2, n, i + 1)) return 0;
if (answer(b1, b2, n, i + 1)) return 0;
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
long long N, M;
long long A[1 << 18], B[1 << 18];
vector<int> X[1 << 18], Y[1 << 18];
long long Q;
long long P[1 << 18];
long long dist[1 << 18];
int main() {
scanf("%lld%lld", &N, &M);
for (int i = 1; i <= M; i++) {
scanf("%lld%lld", &A[i], &B[i]);
X[A[i]].push_back(B[i]);
Y[B[i]].push_back(A[i]);
}
scanf("%lld", &Q);
for (int i = 1; i <= Q; i++) scanf("%lld", &P[i]);
for (int i = 1; i <= N; i++) dist[i] = (1 << 30);
dist[P[Q]] = 0;
queue<int> Que;
Que.push(P[Q]);
while (!Que.empty()) {
int pos = Que.front();
Que.pop();
for (int i : Y[pos]) {
if (dist[i] > dist[pos] + 1) {
dist[i] = dist[pos] + 1;
Que.push(i);
}
}
}
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= Q - 1; i++) {
if (dist[P[i]] - 1 != dist[P[i + 1]]) cnt1++;
int flag = 0;
for (int j : X[P[i]]) {
if (dist[P[i]] - 1 == dist[j]) flag++;
}
if (dist[P[i]] - 1 != dist[P[i + 1]] || flag >= 2) cnt2++;
}
printf("%d %d\n", cnt1, cnt2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, i;
cin >> n >> k;
string s;
cin >> s;
int ns = 1, ls = n, p = n - 1;
stack<string> st;
st.push(s);
while (ns < k && p >= 0) {
set<string> se;
while (!st.empty()) {
s = st.top();
st.pop();
se.insert(s.substr(1, s.length() - 1));
if (se.size() + ns == k) break;
for (i = 1; i < s.length() - 1; ++i) {
se.insert(s.substr(0, i) + s.substr(i + 1, s.length() - 1 - i));
if (se.size() + ns == k) break;
}
if (se.size() + ns == k) break;
se.insert(s.substr(0, s.length() - 1));
if (se.size() + ns == k) break;
}
ls += p * se.size();
p--;
if (se.size() + ns == k) {
cout << n * k - ls;
return (0);
}
ns += se.size();
for (auto it : se) {
st.push(it);
}
}
if (ns == k) {
cout << n * k - ls;
return (0);
}
cout << -1;
}
| 5 |
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
using P = pair<int, int>;
constexpr int INF = 1e9;
int main() {
int N;
while(cin >> N, N) {
vector<int> hp(N);
int max_hp = 0;
for(int i=0; i<N; ++i) {
cin >> hp[i];
max_hp = max(max_hp, hp[i]);
}
int M;
cin >> M;
vector<vector<P>> s(2);
for(int i=0; i<M; ++i) {
string name, target;
int mp, dam;
cin >> name >> mp >> target >> dam;
if(dam == 0) {
continue;
}
s[target == "All"].emplace_back(mp, dam);
}
vector<vector<int>> cost(2, vector<int>(max_hp+1, INF));
cost[0][0] = cost[1][0] = 0;
for(int k=0; k<2; ++k) {
for(int i=0; i<s[k].size(); ++i) {
for(int j=0; j<=max_hp; ++j) {
int t = min(max_hp, j+s[k][i].second);
cost[k][t] = min(cost[k][t], cost[k][j] + s[k][i].first);
}
}
}
for(int j=max_hp; j>=1; --j) {
cost[0][j-1] = min(cost[0][j-1], cost[0][j]);
}
if(s[0].size() == 0) {
cout << cost[1][max_hp] << endl;
} else {
int res = INF;
for(int i=0; i<=max_hp; ++i) {
if(cost[1][i] == INF) {
continue;
}
int t = cost[1][i];
for(int j=0; j<N; ++j) {
int rest_hp = hp[j] - i;
if(rest_hp <= 0 || cost[0][rest_hp] == INF) {
continue;
}
t += cost[0][rest_hp];
}
res = min(res, t);
}
cout << res << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool a[33340][320], as[33340][320];
int n, m, k, ty, tl, t, z, M;
void dfs(int x, int y, int s) {
if (tl) return;
if ((x != 1 || y != 1) && s == k) {
tl = 1;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) as[i][j] = a[i][j];
return;
}
if (x > n) return;
if (y > m) return dfs(x + 1, 1, s);
if (++z > M) return;
t = 0;
if (a[x - 1][y]) t += a[x][y + 1] + a[x - 1][y - 1] + a[x - 1][y + 1];
if (a[x + 1][y]) t += a[x][y - 1] + a[x + 1][y - 1] + a[x + 1][y + 1];
if (a[x][y - 1]) t += a[x - 1][y] + a[x - 1][y - 1] + a[x + 1][y - 1];
if (a[x][y + 1]) t += a[x - 1][y + 1] + a[x + 1][y] + a[x + 1][y + 1];
if (s + t <= k && (x < 2 || y < 2 || a[x - 1][y] || a[x][y - 1])) {
a[x][y] = 1;
dfs(x, y + 1, s + t);
a[x][y] = 0;
}
dfs(x, y + 1, s);
}
int main() {
int t;
cin >> t;
while (t--) {
scanf("%d%d%d", &n, &m, &k);
z = tl = ty = 0;
if (n < m) ty = 1, swap(n, m);
M = 8 * n * m, dfs(1, 1, 0);
if (!tl)
puts("-1");
else if (ty)
for (int j = (1); j <= (m); j++) {
for (int i = (1); i <= (n); i++) putchar(as[i][j] ? '*' : '.');
puts("");
}
else
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (m); j++) putchar(as[i][j] ? '*' : '.');
puts("");
}
puts("");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 1 << 30;
int T, N;
int t[30], D[110], M[110];
int getup[110];
int dp[110][30];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
while (cin >> T, T) {
fill(getup, getup + 110, 24);
for (int i = 0; i < T; i++) {
cin >> t[i];
}
cin >> N;
for (int i = 0; i < N; i++) {
cin >> D[i] >> M[i];
getup[D[i]] = min(getup[D[i]], M[i]);
}
int D_max = *max_element(D, D + N);
fill((int *)dp[0], (int *)(dp[0] + 30), INF);
dp[0][T - 1] = 0;
for (int i = 0; i < D_max; i++) {
for (int j = 0; j < T; j++) {
dp[i + 1][j] = INF;
if (t[j] > getup[i + 1]) continue;
if (j == 0) {
for (int k = 0; k < T; k++) {
if (dp[i][k] == INF) continue;
if (k == (j + T - 1) % T) dp[i + 1][j] = min(dp[i + 1][j], dp[i][k]);
else dp[i + 1][j] = min(dp[i + 1][j], dp[i][k] + 1);
}
} else {
dp[i + 1][j] = dp[i][(j + T - 1) % T];
}
}
}
int ans = INF;
for (int i = 0; i < T; i++) {
ans = min(ans, dp[D_max][i]);
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int H, W;
std::cin >> H >> W;
std::vector<std::vector<int>> tiles_hist(H, std::vector<int>(W, 0));
for (int y = 0; y < H; y++) {
for (int x = 0; x < W; x++) {
int val;
std::cin >> val;
if (val == 1) {
tiles_hist[y][x] = 0;
} else {
if (y > 0) {
tiles_hist[y][x] = tiles_hist[y - 1][x] + 1;
} else {
tiles_hist[y][x] = 1;
}
}
}
}
int max_area = 0;
for (int y = 0; y < H; y++) {
std::stack<std::pair<int, int>> stack;
for (int x = 0; x < W; x++) {
int min_x = x;
while (!stack.empty() && stack.top().second > tiles_hist[y][x]) {
int area = (x - stack.top().first) * stack.top().second;
max_area = std::max(area, max_area);
min_x = stack.top().first;
stack.pop();
}
stack.push(std::make_pair(min_x, tiles_hist[y][x]));
}
while (!stack.empty()) {
int area = (W - stack.top().first) * stack.top().second;
max_area = std::max(area, max_area);
stack.pop();
}
}
std::cout << max_area << std::endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
char buf[100000], *buff = buf + 100000;
inline long long read() {
long long x = 0, y = 0,
c = (buff == buf + 100000
? (fread(buf, 1, 100000, stdin), buff = buf)
: 0,
*buff++);
while (!isdigit(c))
y = c,
c = (buff == buf + 100000 ? (fread(buf, 1, 100000, stdin), buff = buf) : 0,
*buff++);
while (isdigit(c))
x = (x << 1) + (x << 3) + (c ^ '0'),
c = (buff == buf + 100000 ? (fread(buf, 1, 100000, stdin), buff = buf) : 0,
*buff++);
return y == '-' ? -x : x;
}
inline void print(long long q) {
if (q < 0) putchar('-'), q = -q;
if (q >= 10) print(q / 10);
putchar(q % 10 + '0');
}
int n, m, a[500010];
struct edge {
int to, nxt;
} e[1000010];
int cnt, fir[500010];
inline void ins(int u, int v) {
e[++cnt].to = v;
e[cnt].nxt = fir[u];
fir[u] = cnt;
e[++cnt].to = u;
e[cnt].nxt = fir[v];
fir[v] = cnt;
}
struct cz {
int x, y;
bool fg;
cz(int _x = 0, int _y = 0, bool _z = 0) {
x = _x;
y = _y;
fg = _z;
}
};
vector<cz> cc[500010];
int f[500010], l[500010], r[500010];
bool ys[500010], p6[500010];
long long as[500010], p0[500010], p1[500010], p2[500010], p3[500010],
p4[500010], p5[500010];
inline void ud(int q) {
p6[q] = p6[l[q]] | p6[r[q]] | ys[q];
if (ys[q]) {
p0[q] = p0[l[q]] + p0[r[q]] + p5[q];
p1[q] = p1[l[q]];
p2[q] = p2[r[q]];
} else {
p0[q] = p0[l[q]] + p0[r[q]] + p5[q] + p3[q] * p3[q] - p4[q] +
2 * (p3[q] + p2[l[q]] + p1[r[q]] + p3[q] * p2[l[q]] +
p3[q] * p1[r[q]] + p2[l[q]] * p1[r[q]]) +
1;
if (!p6[l[q]])
p1[q] = p1[l[q]] + 1 + p3[q] + p1[r[q]];
else
p1[q] = p1[l[q]];
if (!p6[r[q]])
p2[q] = p2[r[q]] + 1 + p3[q] + p2[l[q]];
else
p2[q] = p2[r[q]];
}
}
inline bool is(int q) { return l[f[q]] != q && r[f[q]] != q; }
int dx[500010], hv[500010], fa[500010], rt, vl[500010];
inline void dfs(int q) {
dx[q] = 1;
for (int i = fir[q]; i; i = e[i].nxt)
if (e[i].to != fa[q]) {
fa[e[i].to] = q;
dfs(e[i].to);
dx[q] += dx[e[i].to];
if (dx[hv[q]] < dx[e[i].to]) hv[q] = e[i].to;
}
vl[q] = 1;
for (int i = fir[q]; i; i = e[i].nxt)
if (e[i].to != fa[q] && e[i].to != hv[q]) vl[q] += dx[e[i].to];
}
int st[500010], ft;
inline int wk(int ll, int rr) {
if (ll > rr) return 0;
int i, tt = 0, p = 0, mn, t2 = 0;
for (i = ll; i <= rr; ++i) tt += vl[st[i]];
mn = tt + 1;
for (i = ll; i <= rr; ++i) {
if (abs(t2 - (tt - t2 - vl[st[i]])) < mn)
mn = abs(t2 - (tt - t2 - vl[st[i]])), p = i;
t2 += vl[st[i]];
}
l[st[p]] = wk(ll, p - 1);
if (l[st[p]]) f[l[st[p]]] = st[p];
r[st[p]] = wk(p + 1, rr);
if (r[st[p]]) f[r[st[p]]] = st[p];
ud(st[p]);
return st[p];
}
inline void dfs2(int q) {
for (int i = fir[q]; i; i = e[i].nxt)
if (e[i].to != fa[q]) dfs2(e[i].to);
if (hv[fa[q]] != q) {
ft = 0;
for (int i = q; i; i = hv[i]) st[++ft] = i;
if (!fa[q])
rt = wk(1, ft);
else {
int tp = wk(1, ft);
f[tp] = fa[q];
p3[f[tp]] += p1[tp];
p4[f[tp]] += p1[tp] * p1[tp];
p5[f[tp]] += p0[tp];
}
}
}
int main() {
int i, j, k, u, v, mx = 0;
n = read();
m = read();
for (i = 1; i <= n; ++i) {
a[i] = read();
cc[a[i]].push_back(cz(0, i, 1));
mx = max(mx, a[i]);
}
for (i = 1; i < n; ++i) ins(read(), read());
for (i = 1; i <= m; ++i) {
u = read();
v = read();
mx = max(mx, v);
if (a[u] == v) continue;
cc[a[u]].push_back(cz(i, u, 0));
a[u] = v;
cc[v].push_back(cz(i, u, 1));
}
for (i = 1; i <= n; ++i) cc[a[i]].push_back(cz(m + 1, i, 0));
for (i = 1; i <= n; ++i) p0[i] = p1[i] = p2[i] = 1;
dfs(1);
dfs2(1);
for (i = 1; i <= mx; ++i) {
int lst = 0;
for (j = 0; j < cc[i].size(); ++j) {
cz tp = cc[i][j];
as[lst] += p0[rt];
as[tp.x] -= p0[rt];
lst = tp.x;
ys[k = tp.y] ^= 1;
while (k) {
if (is(k) && k != rt) {
p3[f[k]] -= p1[k];
p4[f[k]] -= p1[k] * p1[k];
p5[f[k]] -= p0[k];
ud(k);
p3[f[k]] += p1[k];
p4[f[k]] += p1[k] * p1[k];
p5[f[k]] += p0[k];
} else
ud(k);
k = f[k];
}
}
as[lst] += 1ll * n * n;
}
for (i = 1; i <= m; ++i) as[i] += as[i - 1];
for (i = 0; i <= m; ++i) print(1ll * mx * n * n - as[i]), putchar('\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 610;
const int M = 200010;
const int M2 = 1000010;
const int MX = 1731311;
int S, T;
struct Dinic {
struct edge {
int v, nxt, cap, flow;
} E[M2];
int tot = 1;
int head[M], dis1[M], cur[M];
queue<int> q;
void add(int u, int v, int cap, int flow) {
E[++tot].v = v;
E[tot].cap = cap;
E[tot].flow = flow;
E[tot].nxt = head[u];
head[u] = tot;
return;
}
void ADD(int u, int v, int cap) {
add(u, v, cap, 0);
add(v, u, 0, 0);
return;
}
bool BFS() {
memset(dis1, 0, sizeof(dis1));
dis1[S] = 1;
q.push(S);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].v, c = E[i].cap, f = E[i].flow;
if (!dis1[v] && c > f) {
dis1[v] = dis1[u] + 1;
q.push(v);
}
}
}
return dis1[T];
}
int DFS(int x, int flow) {
if (x == T) return flow;
int fl = 0;
for (int i = cur[x]; i; i = E[i].nxt) {
cur[x] = i;
int v = E[i].v, c = E[i].cap, f = E[i].flow;
if (dis1[x] + 1 == dis1[v] && c > f) {
int k = DFS(v, min(flow, c - f));
if (k) {
E[i].flow += k;
E[i ^ 1].flow -= k;
flow -= k;
fl += k;
if (!flow) break;
}
}
}
if (!fl)
return dis1[x] = 0;
else
return fl;
}
int dinic() {
int flow = 0;
while (BFS()) {
memcpy(cur, head, sizeof(head));
int tmp;
while (tmp = DFS(S, 1e9)) flow += tmp;
}
return flow;
}
void Memset() {
memset(head, -1, sizeof(head));
tot = 1;
}
} A;
int V, n, e, K, u, v, w, tmp;
int X[N];
int dis[N][N];
void FLOYD() {
for (int k = 1; k <= V; k++)
for (int i = 1; i <= V; i++)
for (int j = 1; j <= V; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
return;
}
bool check(int x) {
A.Memset();
for (int i = 1; i <= V; i++) A.ADD(i + V, T, 1);
for (int i = 1; i <= V; i++) {
if (X[i]) A.ADD(S, i, X[i]);
for (int j = 1; j <= V; j++)
if (dis[i][j] <= x) A.ADD(i, j + V, 1e9);
}
return A.dinic() >= K;
}
int main() {
memset(dis, 0x3f, sizeof(dis));
scanf("%d%d%d%d", &V, &e, &n, &K);
S = 0;
T = V * 2 + 2;
for (int i = 1; i <= n; i++) scanf("%d", &tmp), X[tmp]++;
for (int i = 1; i <= V; i++) dis[i][i] = 0;
for (int i = 1; i <= e; i++) {
scanf("%d%d%d", &u, &v, &w);
dis[u][v] = dis[v][u] = min(dis[u][v], w);
}
FLOYD();
int l = 0, r = MX, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define meow(args...) fprintf(stderr, args)
template<class T1, class T2> inline bool cmin(T1 &a, const T2 &b) {return b<a?(a=b, true):false;}
template<class T1, class T2> inline bool cmax(T1 &a, const T2 &b) {return a<b?(a=b, true):false;}
template<class Type> Type read() {
Type a;
bool b;
unsigned char c;
while(c=getchar()-48, (c>9)&(c!=253));
for(a=(b=c==253)?0:c; (c=getchar()-48)<=9; a=a*10+c);
return b?-a:a;
}
int (*rd)()=read<int>;
typedef unsigned u32;
typedef long long s64;
typedef unsigned long long u64;
const u32 P=998244353;
u32 &inc(u32 &a, u32 b) {return (a+=b)<P?a:(a-=P);}
u32 &dec(u32 &a, u32 b) {return (a-=b)&0x80000000?(a+=P):a;}
u32 sum(u32 a, u32 b) {return inc(a, b);}
u32 dif(u32 a, u32 b) {return dec(a, b);}
u64 power(u64 a, int b) {
u64 ans=1;
for(; b; a=a*a%P, b/=2) if(b&1) ans=ans*a%P;
return ans;
}
const int N=5e5+5;
u32 fac[N], ifac[N];
u64 com(int n, int r) {
return n<0||r<0||r>n?0:(u64)fac[n]*ifac[r]%P*ifac[n-r]%P;
}
u64 sol(int x, int y, int l) {
return com(x+y, x)-com(x+y, x+l)+P;
}
int main() {
int n=rd(), k=rd();
u32 ans=0;
fac[0]=1;
for(int i=1; i<=k; ++i) fac[i]=(u64)fac[i-1]*i%P;
ifac[k]=power(fac[k], P-2);
for(int i=k; i--; ) ifac[i]=ifac[i+1]*(i+1llu)%P;
for(int r=std::max(n, (k+1)/2); r<=k; ++r)
ans=(ans+sol(r, k-r-(r==k-r), r-n+1))%P;
printf("%u\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, s[50005], ans[50005];
pair<int, int> t[50005];
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%d", &s[i]);
s[n + 1] = s[1];
for (int i = (1); i <= (n); i++) t[i] = make_pair(s[i] + s[i + 1], i);
sort(t + 1, t + n + 1);
for (int i = (1); i <= (n); i++) ans[t[i].second] = i;
for (int i = (1); i <= (n); i++)
printf("%d%c", ans[i] - 1, i == n ? '\n' : ' ');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i;
scanf("%d %d", &k, &n);
if (n * 3 > k || n == 1)
printf("-1\n");
else {
for (i = 2; i <= n; i++) printf("%d ", i);
printf("1");
for (i = n; i < k; i++) printf(" %d", i % n + 1);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N;
string S;
cin >> N >> S;
int count = 1;
for (int i = 1; i < N; ++i)
{
if (S[i] != S[i-1])
count++;
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
#define x first
#define y second
#define ndl '\n'
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define up_b upper_bound
#define low_b lower_bound
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
using namespace std;
//using namespace __gnu_pbds;
//template<typename T> using indexed_set = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());//uniform_int_distribution<int> (l, r)
typedef long long ll;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<int, ull> piu;
typedef vector<vector<int>> matrix;
const ll INF = 1e18 + 123;
const ld EPS = 1e-9;
const int inf = 1e9 + 123;
const int MOD = 1e9 + 7;
const int N = 1e5 + 123;
const int M = 1e6 + 123;
const double pi = 3.14159265359;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int cnt[N], a[N], z[N];
void solve(){
int n;
cin >> n;
for (int i = 0; i <= n; i++){
cnt[i] = z[i] = 0;
}
for (int i = 1; i <= n; i++){
cin >> a[i];
z[a[i]]++;
}
a[n+1] = a[n];
for (int i = 2, j = 1; i <= n+1; i++){
if (a[i] == a[i-1]){
cnt[a[j]]++;
cnt[a[i-1]]++;
//cout << j << " " << i-1 << ndl;
j = i;
}
}
set<pii> s;
int mx = 0, sum = 0;
for (int i = 1; i <= n; i++){
if (z[i] > (n+1)/2){
cout << -1 << ndl;
return;
}
mx = max(mx, cnt[i]);
sum += cnt[i];
}
if (mx+mx > sum+2){
cout << mx-2 << ndl;
}
else{
cout << sum/2-1 << ndl;
}
//cout << ans + max(0, sum-2) << ndl;
return;
}
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++){
//cout << "Case #" << i << ": ";
solve();
}
#ifdef KAZAKH
// cout << endl << 1.0 * clock() / CLOCKS_PER_SEC << endl;
#endif
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int CalGoodness(vector<int>& left, vector<int> right, int h) {
vector<int> s1;
for (int i = 0; i < left.size(); i++)
for (int j = 0; j < left.size(); j++)
if (i != j) {
s1.push_back(left[i] + left[j]);
}
for (int i = 0; i < right.size(); i++)
for (int j = 0; j < right.size(); j++)
if (i != j) {
s1.push_back(right[i] + right[j]);
}
for (int i = 0; i < left.size(); i++)
for (int j = 0; j < right.size(); j++) {
s1.push_back(left[i] + right[j] + h);
}
sort(s1.begin(), s1.end());
return s1[s1.size() - 1] - s1[0];
}
int main() {
vector<int> d, od;
int n, h;
cin >> n >> h;
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
d.push_back(tmp);
}
od = d;
sort(d.begin(), d.end());
vector<int> cal;
int e = (n > 4) ? 4 : n;
int s = (e > n - 4) ? e : n - 4;
for (int i = 0; i < e; ++i) {
cal.push_back(d[i]);
}
for (int i = s; i < n; ++i) {
cal.push_back(d[i]);
}
n = cal.size();
vector<int> bestL;
int best = -1;
for (long long k = 0; k < (1 << n); ++k) {
vector<int> left, right;
for (int i = 0; i < n; ++i) {
if (((1 << i) & k) > 0)
left.push_back(cal[i]);
else
right.push_back(cal[i]);
}
int tmp = CalGoodness(left, right, h);
if (best < 0 || tmp < best) {
best = tmp;
bestL = left;
}
}
cout << best << endl;
for (int i = 0; i < od.size(); i++) {
int found = -1;
for (int p = 0; p < bestL.size(); p++)
if (od[i] == bestL[p]) found = p;
if (found >= 0)
cout << 1 << ' ';
else
cout << 2 << ' ';
if (found >= 0) bestL.erase(bestL.begin() + found);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool qf = false;
map<char, long long> a;
long long i, j;
long long power(long long a, long long b) {
long long i, p = 1;
for (i = 1; i <= b; i++) p *= a;
return p;
}
long long len, ans = 1, cnt, num, t;
char c[100001];
int main() {
for (i = 0; i < 10; i++) a[i + '0'] = i;
for (i = 0; i < 26; i++) a[i + 'A'] = i + 10;
for (i = 0; i < 26; i++) a[i + 'a'] = i + 36;
a['-'] = 62;
a['_'] = 63;
scanf(" %s", c);
len = strlen(c);
for (i = 0; i < len; i++) {
cnt = t = 0;
num = a[c[i]];
while (cnt < 6) t += (num % 2 == 0 ? 1 : 0), num /= 2, cnt++;
ans *= power(3, t);
ans %= 1000000007;
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, m, t, k;
long long ans;
int v[3010], s[3010], pre[3010], nxt[3010];
vector<int> ve[3010];
int main() {
read(n), read(m), read(t), read(k);
for (int i = 1; i <= t; ++i) {
int x, y;
read(x), read(y), ve[x].push_back(y);
}
for (int u = n; u; --u) {
for (int i = 0; i < ve[u].size(); ++i) v[ve[u][i]]++;
int l = 1, r = 0, sum = 0;
long long val = 0;
while (true) {
while (r + 1 <= m && sum < k) sum += v[++r];
if (sum < k) break;
while (l <= r && sum >= k) sum -= v[l++], val += m - r + 1;
}
for (int i = 0; i <= m + 1; ++i) pre[i] = i - 1, nxt[i] = i + 1;
for (int i = 1; i <= m; ++i) {
if (!v[i]) nxt[pre[i]] = nxt[i], pre[nxt[i]] = pre[i];
s[i] = v[i];
}
for (int d = n; d >= u; --d) {
ans += val;
for (int i = 0; i < ve[d].size(); ++i) {
int p = ve[d][i], ls = s[p], rs = 0;
l = r = p;
while (nxt[r] <= m && ls + rs + s[nxt[r]] <= k) rs += s[r = nxt[r]];
while (true) {
if (ls + rs == k) val -= (l - pre[l]) * (nxt[r] - r);
ls += s[l = pre[l]];
if (!l || ls > k) break;
while (ls + rs > k) rs -= s[r], r = pre[r];
}
s[p]--;
if (!s[p]) nxt[pre[p]] = nxt[p], pre[nxt[p]] = pre[p];
}
}
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[1005][6];
vector<int> ans;
int cal(int i, int j, int k) {
int ans = 0;
for (int q = 1; q <= 5; q++) {
int x = p[j][q] - p[i][q];
int y = p[k][q] - p[i][q];
ans += x * y;
}
return ans;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i][1] >> p[i][2] >> p[i][3] >> p[i][4] >> p[i][5];
}
for (int i = 1; i <= n; i++) {
int tag = 1;
for (int j = 1; j <= n; j++) {
if (j == i) continue;
for (int k = 1; k <= n; k++) {
if (k == j || k == i) continue;
if (cal(i, j, k) > 0) {
tag = 0;
break;
}
}
if (!tag) break;
}
if (tag) ans.push_back(i);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> l[1000000];
void solve() {
int n;
int a, b;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
l[i] = {t, i + 1};
}
sort(l, l + n);
for (int i = 0; i < n; i++) {
{
int aNeed = (a + l[i].first - 1) / l[i].first;
if (i + aNeed < n) {
int start = i + aNeed;
int bNeed = (b + l[start].first - 1) / l[start].first;
if (start + bNeed <= n) {
cout << "Yes\n";
cout << aNeed << " " << bNeed << "\n";
for (int x = 0; x < aNeed; x++) {
cout << l[i + x].second << " ";
}
cout << "\n";
for (int x = 0; x < bNeed; x++) {
cout << l[start + x].second << " ";
}
cout << "\n";
return;
}
}
}
{
int bNeed = (b + l[i].first - 1) / l[i].first;
if (i + bNeed < n) {
int start = i + bNeed;
int aNeed = (a + l[start].first - 1) / l[start].first;
if (start + aNeed <= n) {
cout << "Yes\n";
cout << aNeed << " " << bNeed << "\n";
for (int x = 0; x < aNeed; x++) {
cout << l[start + x].second << " ";
}
cout << "\n";
for (int x = 0; x < bNeed; x++) {
cout << l[i + x].second << " ";
}
cout << "\n";
return;
}
}
}
}
cout << "No\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], sum1[100005], sum2[100005];
char p[100005], tmp1[100005], tmp2[100005];
void jia1() {
int i, t = 0, tmp;
for (i = 0; i < 100005; i++) sum1[i] = a[i] + b[i];
for (i = 0; i < 100005; i++) {
tmp = t;
t = (sum1[i] + t) / 10;
sum1[i] = (sum1[i] + tmp) % 10;
}
}
void jia2() {
int i, t = 0, tmp;
for (i = 0; i < 100005; i++) sum2[i] = a[i] + b[i];
for (i = 0; i < 100005; i++) {
tmp = t;
t = (sum2[i] + t) / 10;
sum2[i] = (sum2[i] + tmp) % 10;
}
}
int main() {
int n, sign, t = 0, i, j;
scanf("%d", &n);
scanf("%s", p);
for (i = 0; i < 100005; i++) a[i] = 0, b[i] = 0, sum1[i] = 0, sum2[i] = 0;
if (n % 2 == 0) {
int tmp = n / 2;
while (1) {
if (p[tmp] != '0') {
sign = 0;
break;
}
if (p[tmp + t] != '0' && p[tmp - t] == '0') {
sign = 1;
break;
}
if (p[tmp + t] == '0' && p[tmp - t] != '0') {
sign = 2;
break;
}
if (p[tmp + t] != '0' && p[tmp - t] != '0') {
sign = 3;
break;
}
t++;
}
if (sign == 1) {
tmp = tmp + t;
for (i = n - 1, j = 0; i >= tmp; i--) a[j] = p[i] - '0', j++;
for (i = tmp - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (; i >= 0; i--) printf("%d", sum1[i]);
}
if (sign == 2) {
tmp = tmp - t;
for (i = n - 1, j = 0; i >= tmp; i--) a[j] = p[i] - '0', j++;
for (i = tmp - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia2();
for (i = 100004;; i--) {
if (sum2[i] != 0) break;
}
for (; i >= 0; i--) printf("%d", sum2[i]);
}
if (sign == 3) {
int h = tmp + t;
for (i = n - 1, j = 0; i >= h; i--) a[j] = p[i] - '0', j++;
for (i = h - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (j = 0; i >= 0; i--) tmp1[j] = sum1[i] + '0', j++;
tmp1[j] = '\0';
for (i = 0; i < 100005; i++) a[i] = 0, b[i] = 0;
h = tmp - t;
for (i = n - 1, j = 0; i >= h; i--) a[j] = p[i] - '0', j++;
for (i = h - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia2();
for (i = 100004;; i--) {
if (sum2[i] != 0) break;
}
for (j = 0; i >= 0; i--) tmp2[j] = sum2[i] + '0', j++;
tmp2[j] = '\0';
if (strcmp(tmp1, tmp2) > 0)
printf("%s", tmp2);
else
printf("%s", tmp1);
}
if (sign == 0) {
for (i = n - 1, j = 0; i >= tmp; i--) a[j] = p[i] - '0', j++;
for (i = tmp - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (; i >= 0; i--) printf("%d", sum1[i]);
}
}
if (n % 2 == 1) {
int tmp = n / 2;
t = 0;
while (1) {
if (p[tmp] != '0') {
sign = 0;
break;
}
if (p[tmp + t] != '0' && p[tmp - t] == '0') {
sign = 1;
break;
}
if (p[tmp + t] == '0' && p[tmp - t] != '0') {
sign = 2;
break;
}
if (p[tmp + t] != '0' && p[tmp - t] != '0') {
sign = 3;
break;
}
t++;
}
if (sign == 0) {
int h = tmp;
for (i = n - 1, j = 0; i >= h; i--) a[j] = p[i] - '0', j++;
for (i = h - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (j = 0; i >= 0; i--) tmp1[j] = sum1[i] + '0', j++;
tmp1[j] = '\0';
for (i = 0; i < 100005; i++) a[i] = 0, b[i] = 0;
h = tmp + 1;
for (i = n - 1, j = 0; i >= h; i--) a[j] = p[i] - '0', j++;
for (i = h - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia2();
for (i = 100004;; i--) {
if (sum2[i] != 0) break;
}
for (j = 0; i >= 0; i--) tmp2[j] = sum2[i] + '0', j++;
tmp2[j] = '\0';
if (strcmp(tmp1, tmp2) > 0)
printf("%s", tmp2);
else
printf("%s", tmp1);
}
if (sign == 1) {
tmp = tmp + t;
for (i = n - 1, j = 0; i >= tmp; i--) a[j] = p[i] - '0', j++;
for (i = tmp - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (; i >= 0; i--) printf("%d", sum1[i]);
}
if (sign == 2) {
int h = tmp - t;
for (i = n - 1, j = 0; i >= h; i--) a[j] = p[i] - '0', j++;
for (i = h - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (j = 0; i >= 0; i--) tmp1[j] = sum1[i] + '0', j++;
tmp1[j] = '\0';
if (p[tmp + t + 1] == '0')
printf("%s", tmp1);
else {
for (i = 0; i < 100005; i++) a[i] = 0, b[i] = 0;
h = tmp + t + 1;
for (i = n - 1, j = 0; i >= h; i--) a[j] = p[i] - '0', j++;
for (i = h - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia2();
for (i = 100004;; i--) {
if (sum2[i] != 0) break;
}
for (j = 0; i >= 0; i--) tmp2[j] = sum2[i] + '0', j++;
tmp2[j] = '\0';
if (strcmp(tmp1, tmp2) > 0)
printf("%s", tmp2);
else
printf("%s", tmp1);
}
}
if (sign == 3) {
tmp = tmp + t;
for (i = n - 1, j = 0; i >= tmp; i--) a[j] = p[i] - '0', j++;
for (i = tmp - 1, j = 0; i >= 0; i--) b[j] = p[i] - '0', j++;
jia1();
for (i = 100004;; i--) {
if (sum1[i] != 0) break;
}
for (; i >= 0; i--) printf("%d", sum1[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
const int N = 5000 + 20;
long long v[N], cum[N];
long long dp[N][N];
int n, m;
long long solve(int i, int k) {
if (!k) return 0;
if (k < 0 || i + m - 1 > n) {
return -1e9;
}
long long &ret = dp[i][k];
if (ret != -1) return ret;
ret = solve(i + 1, k);
ret = max(ret, solve(i + m, k - 1) + cum[i + m - 1] - cum[i - 1]);
return ret;
}
int main() {
file();
fast();
int k;
cin >> n >> m >> k;
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
cum[0] = 0;
for (int i = 1; i <= n; i++) {
cum[i] = (v[i] + cum[i - 1]);
}
cout << solve(1, k) << endl;
}
| 3 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<ll> a(n);
REP(i, n) cin >> a[i];
string s;
cin >> s;
int ans = 0;
vector<ll> dp;
for (int i = n - 1; i >= 0; i--) {
for (ll p : dp)
a[i] = min(a[i], a[i]^p);
if (a[i]) {
if (s[i] == '0') dp.push_back(a[i]);
else ans = 1;
}
}
cout << ans << '\n';
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, c;
cin >> t;
while (t--) {
c = 0;
cin >> a >> b;
if (b > a) {
if ((b - a) & 1)
c = 1;
else
c = 2;
} else if (b == a) {
c = 0;
} else {
if ((a - b) & 1)
c = 2;
else
c = 1;
}
cout << c << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[b].push_back(a);
}
vector<int> t(n), ans;
for (int i = 0; i < n; i++) {
bool tem0 = 0, tem1 = 0;
for (int j : g[i]) {
if (t[j] == 0) tem0 = 1;
if (t[j] == 1) tem1 = 1;
}
if (tem1)
t[i] = 2;
else if (tem0)
t[i] = 1;
if (t[i] == 2) ans.push_back(i);
}
cout << ans.size() << '\n';
for (int i : ans) cout << i + 1 << " ";
cout << '\n';
}
exit(0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> V(n), T(n);
for (int i = 0; i < n; i++) cin >> V[i];
for (int i = 0; i < n; i++) cin >> T[i];
multiset<long long> A;
long long t = 0;
for (int i = 0; i < n; i++) {
long long melted = 0;
A.insert(V[i] + t);
while (!A.empty() && ((*A.begin()) <= t + T[i])) {
melted += (*A.begin() - t);
A.erase(A.begin());
}
melted += T[i] * A.size();
t += T[i];
cout << melted << ' ';
}
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<cstring>
typedef long long ll;
const int N=201000,MOD=998244353;
ll qpow(ll a,ll b){ll c=1;for(;b;b>>=1,a=a*a%MOD)if(b&1)c=c*a%MOD;return c;}
void inc(int a,int &b){b=(a+b)%MOD;}
int s[N];
int n;
namespace bf
{
bool vis[N];
int ans;
void dfs(int state)
{
if(vis[state])return;
vis[state]=1,ans++;
int t[4],dt[4];
for(int i=n;i;i--)t[i]=state%3,state/=3;
for(int i=1;i<n;i++)
if(t[i]!=t[i+1])
{
for(int j=1;j<=n;j++)dt[j]=t[j];
int tmp=((t[i]+1)^(t[i+1]+1))-1,dk=0;
dt[i]=dt[i+1]=tmp;
for(int i=1;i<=n;i++)
dk=dk*3+dt[i];
dfs(dk);
}
}
void solve()
{
int k=0;
for(int i=1;i<=n;i++)k=k*3+s[i];
ans=0,dfs(k);
printf("%d\n",ans);
}
}
namespace qwq
{
int f[N][3][3];
bool spj()
{
for(int i=1;i<n;i++)
if(s[i]==s[i+1])return 0;
return 1;
}
bool equal()
{
for(int i=1;i<n;i++)
if(s[i]!=s[i+1])return 0;
return 1;
}
void solve()
{
if(equal()){printf("1\n");return;}
int tmp=0;
for(int i=1;i<=n;i++)tmp=(tmp+s[i])%3;
for(int i=0;i<3;i++)f[1][i][i]=1;
for(int i=1;i<n;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
for(int l=0;l<3;l++)
if(l!=j)inc(f[i][j][k],f[i+1][l][(k+l)%3]);
int ans=qpow(3,n-1);
for(int i=0;i<3;i++)
ans=(ans-f[n][i][tmp])%MOD;
ans=(ans+spj()+MOD)%MOD;
printf("%d\n",ans);
}
}
char tmp[N];
int main()
{
scanf("%s",tmp+1);
n=strlen(tmp+1);
for(int i=1;i<=n;i++)
s[i]=tmp[i]-'a';
if(n<=3)bf::solve();
else qwq::solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int a, s, d, f, g, h, j, k;
cin >> a >> s >> d >> f >> g >> h >> j >> k;
cout << (min(s * d / j, min(f * g, h / k))) / a << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int LCM = 2520;
int a[20];
int b[LCM + 5];
long long dp[20][50][LCM + 5];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
long long dfs(int i, int prelcm, int presum, bool e) {
if (i < 0) return presum % prelcm == 0;
if (!e && dp[i][b[prelcm]][presum] != -1) return dp[i][b[prelcm]][presum];
int u = e ? a[i] : 9;
long long res = 0;
for (int d = 0; d <= u; ++d) {
int nowlcm = prelcm, nowsum = (presum * 10 + d) % LCM;
if (d) nowlcm = (prelcm * d) / gcd(prelcm, d);
res += dfs(i - 1, nowlcm, nowsum, e && d == u);
}
return e ? res : dp[i][b[prelcm]][presum] = res;
}
long long solve(long long n) {
int i = 0;
while (n) {
a[i++] = n % 10;
n /= 10;
}
return dfs(i - 1, 1, 0, 1);
}
int main() {
long long n, l, r;
int cnt = 0;
for (int i = 1; i <= LCM; ++i)
if (LCM % i == 0) b[i] = cnt++;
memset(dp, -1, sizeof(dp));
while (scanf("%I64d", &n) == 1) {
while (n--) {
scanf("%I64d%I64d", &l, &r);
long long a = solve(l - 1);
long long b = solve(r);
cout << b - a << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
namespace _buff {
const size_t BUFF = 1 << 19;
char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
char getc() {
if (ib == ie) {
ib = ibuf;
ie = ibuf + fread(ibuf, 1, BUFF, stdin);
}
return ib == ie ? -1 : *ib++;
}
} // namespace _buff
LL read() {
using namespace _buff;
LL ret = 0;
bool pos = true;
char c = getc();
for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
assert(~c);
}
if (c == '-') {
pos = false;
c = getc();
}
for (; c >= '0' && c <= '9'; c = getc()) {
ret = (ret << 3) + (ret << 1) + (c ^ 48);
}
return pos ? ret : -ret;
}
const size_t N = 1e6 + 5;
const int MOD = 998244353;
void iadd(int &dp, const int &val) {
dp += val;
if (dp >= MOD) {
dp -= MOD;
}
}
void ladd(int &dp, const LL &val) { dp = (dp + val) % MOD; }
int qpow(int base, int e) {
int ret = 1;
for (; e; e >>= 1) {
if (e & 1) {
ret = (LL)ret * base % MOD;
}
base = (LL)base * base % MOD;
}
return ret;
}
char s[N];
int fac[N], inv[N], pw2[N];
int sum[2][N];
int main() {
scanf("%s", s);
int n = strlen(s);
int ques = count(s, s + n, '?');
fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = (LL)fac[i - 1] * i % MOD;
}
inv[n] = qpow(fac[n], MOD - 2);
for (int i = n; i >= 1; --i) {
inv[i - 1] = (LL)inv[i] * i % MOD;
}
pw2[0] = 1;
for (int i = 1; i <= n; ++i) {
pw2[i] = pw2[i - 1];
iadd(pw2[i], pw2[i]);
}
for (int j = 0; j < 2; ++j) {
int cur = 0;
for (int i = 0; i <= ques; ++i) {
if (i <= ques - j) {
ladd(cur, (LL)fac[ques - j] * inv[i] % MOD * inv[ques - j - i]);
}
sum[j][i] = cur;
}
}
auto get_sum = [&](int k, int i) {
return i >= 0 ? sum[k][min(i, ques)] : 0;
};
int ans = 0;
int a = 0, b = count(s, s + n, ')');
int c = 0, d = ques;
for (int i = 0; i < n; ++i) {
int tmp = MOD - ans;
if (s[i] != ')') {
++a;
} else {
--b;
}
if (s[i] == '?') {
--d;
}
if (s[i] != ')') {
iadd(ans, get_sum(ques - c - d, b + d - a));
}
if (s[i] == '?') {
--a;
++c;
}
iadd(tmp, ans);
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
char pos[10 * 9 * 8 * 7][5];
int valid[10 * 9 * 8 * 7];
void fillPos() {
int posi = 0;
for (int i = 0; i < 10000; i++) {
char temp[5];
int val = 1;
sprintf(temp, "%04d", i);
for (int j = 0; j < 4; j++) {
for (int k = j + 1; k < 4; k++) {
if (temp[j] == temp[k]) {
val = 0;
break;
}
}
}
if (val) {
strcpy(pos[posi], temp);
posi++;
}
}
}
void testaVal(char* a, int b, int c) {
int nb, nc;
for (int i = 0; i < 10 * 9 * 8 * 7; i++) {
nb = 0;
nc = 0;
if (valid[i] == 0) continue;
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
if (pos[i][j] == a[k]) j == k ? nb++ : nc++;
}
}
if (nb != b || nc != c) valid[i] = 0;
}
}
int main() {
int n, b, c;
char num[5];
fillPos();
for (int i = 0; i < 10 * 9 * 8 * 7; i++) valid[i] = 1;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s %d %d", num, &b, &c);
testaVal(num, b, c);
}
int cont = 0;
char maybe[5];
for (int i = 0; i < 10 * 9 * 8 * 7; i++) {
if (valid[i]) {
if (cont == 0) strcpy(maybe, pos[i]);
cont++;
}
}
if (cont == 0)
printf("Incorrect data\n");
else if (cont == 1)
printf("%s\n", maybe);
else if (cont > 1)
printf("Need more data\n");
return 0;
}
| 3 |
//56
#include<iostream>
#include<map>
#include<vector>
#include<cstdlib>
#include<string>
#include<algorithm>
using namespace std;
struct P{
int x,y,t;
};
int main(){
for(int w,h;cin>>w>>h,w|h;){
int gx,gy;
map<int,vector<P> > m;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
string s;
cin>>s;
if(s=="S"){
P s={j,i,0};
m[0].push_back(s);
}else if(s=="G"){
gx=j;
gy=i;
}else if(s!="."){
P p={j,i,0};
m[atoi(s.c_str())].push_back(p);
}
}
}
int l=m.rbegin()->first+1;
P lp={gx,gy,0};
m[l].push_back(lp);
for(int i=1;i<=l;i++){
for(int j=0;j<m[i].size();j++){
int mt=1<<30;
for(int k=0;k<m[i-1].size();k++){
mt=min(mt,m[i-1][k].t+abs(m[i-1][k].x-m[i][j].x)+abs(m[i-1][k].y-m[i][j].y));
}
m[i][j].t=mt;
}
}
cout<<m[l][0].t<<endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <string>
int main(int argc, char const *argv[]) {
std::string s;
std::cin >> s;
std::cout <<s.find_last_of('Z') - s.find_first_of('A') + 1 << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, m;
cin >> t;
for (long long i = 0; i < t; i++) {
cin >> n >> m;
if (n == 1)
cout << 0 << endl;
else if (n == 2)
cout << m << endl;
else
cout << m * 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, ans;
while (cin >> n) {
ans = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1')
ans++;
else {
ans++;
break;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("Sisend.txt");
int n, c, d, a, b;
char s;
int vaata(vector<pair<int, int>> cc, int c, int &ma) {
vector<int> il;
int m = 0, n = cc.size();
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
m = max(m, cc[i].second);
il.emplace_back(m);
}
int in = 0, it = 0, vas = 0;
while (in < n and cc[in].first <= c) {
int p = c - cc[in].first;
while (it < in - 1 and cc[it + 1].first <= p) it++;
while ((it >= 0 and cc[it].first > p) or it == in) it--;
if (it > -1) vas = max(vas, il[it] + cc[in].second);
ma = max(ma, cc[in].second);
in++;
}
return vas;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> c >> d;
vector<pair<int, int>> cc, dd;
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
cin >> a >> b >> s;
if (s == 'C') {
cc.emplace_back(b, a);
}
if (s == 'D') {
dd.emplace_back(b, a);
}
}
sort(cc.begin(), cc.end());
sort(dd.begin(), dd.end());
int vas = 0, ma1 = 0, ma2 = 0;
if (cc.size() and cc[0].first <= c) vas = vaata(cc, c, ma1);
if (dd.size() and dd[0].first <= d) vas = max(vas, vaata(dd, d, ma2));
if (ma1 and ma2) vas = max(vas, ma1 + ma2);
cout << vas;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int i, j, n, a = 0, g = 0, c = 0, t = 0, q = 0, k, af = 0, gf = 0, cf = 0,
tf = 0;
scanf("%d", &n);
k = n / 4;
char name[n];
scanf("%s", name);
if (n % 4 != 0) {
printf("===");
return 0;
}
for (i = 0; i < n; i++) {
if (name[i] == 'A') {
a += 1;
if (a > k) {
printf("===");
return 0;
}
if (a == k) af = 1;
}
if (name[i] == 'C') {
c += 1;
if (c > k) {
printf("===");
return 0;
}
if (c == k) cf = 1;
}
if (name[i] == 'G') {
g += 1;
if (g > k) {
printf("===");
return 0;
}
if (g == k) gf = 1;
}
if (name[i] == 'T') {
t += 1;
if (t > k) {
printf("===");
return 0;
}
if (t == k) tf = 1;
} else {
q += 1;
}
}
char left[q];
a = (af == 1) ? 0 : (k - a);
c = (cf == 1) ? 0 : (k - c);
g = (gf == 1) ? 0 : (k - g);
t = (tf == 1) ? 0 : (k - t);
for (j = 0; j < n; j++) {
if (name[j] == '?') {
if (a != 0) {
name[j] = 'A';
a -= 1;
continue;
}
if (c != 0) {
name[j] = 'C';
c -= 1;
continue;
}
if (g != 0) {
name[j] = 'G';
g -= 1;
continue;
}
if (t != 0) {
name[j] = 'T';
t -= 1;
continue;
}
}
}
printf("%s\n", name);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int dp[N][N];
queue<int> q;
vector<int> adj[N];
void bfs(int s) {
dp[s][s] = 0;
q.push(s);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto it : adj[x]) {
if (dp[s][it] == -1) {
dp[s][it] = dp[s][x] + 1;
q.push(it);
}
}
}
}
int main() {
int n, m, i, j;
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
for (i = 0; i < n; i++) bfs(i);
int s1, t1, l1, s2, t2, l2;
scanf("%d%d%d%d%d%d", &s1, &t1, &l1, &s2, &t2, &l2);
s1--;
t1--;
s2--;
t2--;
if (dp[s1][t1] > l1 || dp[s2][t2] > l2) {
printf("-1");
return 0;
}
int ans = dp[s1][t1] + dp[s2][t2];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
int x = dp[s1][i] + dp[i][j] + dp[j][t1],
y = dp[s2][i] + dp[i][j] + dp[j][t2];
if (x <= l1 && y <= l2)
ans =
min(ans, dp[s1][i] + dp[s2][i] + dp[i][j] + dp[j][t1] + dp[j][t2]);
y = dp[t2][i] + dp[i][j] + dp[j][s2];
if (x <= l1 && y <= l2)
ans =
min(ans, dp[s1][i] + dp[t2][i] + dp[i][j] + dp[j][t1] + dp[j][s2]);
}
}
printf("%d", m - ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[5050];
int judge(int len) {
for (int i = 0; i < len / 2; i++)
if (s[i] != s[len - 1 - i]) return -1;
if (len & 1) {
bool aaabaaa = true;
for (int i = 1; i < len / 2; i++) aaabaaa &= s[i] == s[i - 1];
return aaabaaa ? 0 : 2;
} else {
int stat = judge(len / 2);
if (stat == -1)
return 1;
else if (stat == 1)
return 1;
else if (stat == 2)
return 2;
else {
if ((len / 2) & 1) {
if (s[(len / 2) / 2] != s[0])
return 2;
else
return 0;
} else {
return 0;
}
}
}
}
int main() {
scanf("%s", s);
int len = strlen(s);
int stat = judge(len);
if (stat == 0)
printf("Impossible\n");
else
printf("%d\n", judge(len));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int maxx;
char s[2100000];
char t[2100000];
int n, k, x;
set<int> S;
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2010000; i++) S.insert(i);
while (n--) {
scanf("%s", t + 1);
int l = strlen(t + 1);
scanf("%d", &k);
while (k--) {
scanf("%d", &x);
int now = x;
while (1) {
now = *(S.lower_bound(now));
if (now - x + 1 <= l)
s[now] = t[now - x + 1];
else
break;
maxx = max(maxx, now);
S.erase(now);
}
}
}
for (int i = 1; i <= maxx; i++)
if (s[i] == 0) s[i] = 'a';
printf("%s", s + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
const long long N = 2e5 + 10;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto& x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
void solve() {
long long n;
cin >> n;
string s[n];
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
for (long long i = 1; i < n - 1; i++) {
for (long long j = 1; j < n - 1; j++) {
if (s[i][j] == '.' && s[i - 1][j] == '.' && s[i][j - 1] == '.' &&
s[i + 1][j] == '.' && s[i][j + 1] == '.') {
s[i][j] = '#';
s[i - 1][j] = '#';
s[i][j - 1] = '#';
s[i + 1][j] = '#';
s[i][j + 1] = '#';
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (s[i][j] == '.') {
cout << "NO" << '\n';
return;
}
}
}
cout << "YES" << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T = 1;
long long t1 = 1;
while (true) {
solve();
t1++;
if (t1 > T) break;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5 + 1);
const int inf = int(2e9);
int n, l, r;
int a[N], p_c[N];
int main() {
cin >> n >> l >> r;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> p_c[i];
int np_c[N];
for (int i = 0; i < n; i++) np_c[p_c[i] - 1] = i;
int res[N], L, R, ind, last = -inf;
for (int i = 0; i < n; i++) {
ind = np_c[i];
L = l - a[ind];
R = r - a[ind];
if (last + 1 <= R && R >= L) {
res[ind] = max(last + 1, L);
last = res[ind];
} else {
cout << -1;
return 0;
}
}
for (int i = 0; i < n; i++) cout << res[i] + a[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > a;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
a.push_back(make_pair(x, y));
}
sort(a.begin(), a.end());
int k = 0, sz = 102;
int floor = -1, nrf = 0;
for (int i = 1; i < 101; i++) {
bool ok = true;
for (int j = 0; j < a.size(); j++) {
if (a[j].second != (a[j].first - 1) / i + 1) ok = false;
}
if (ok) {
if ((n - 1) / i + 1 != floor) nrf++;
if (nrf > 1) break;
floor = (n - 1) / i + 1;
}
}
if (nrf == 1)
cout << floor;
else
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define INF (ll)(1e10)
int main(){
int n, m;
cin >> n >> m;
vector<ll> cost(1<<n, INF);
cost[0]=0;
for(int i=0; i<m; i++){
int a, b;
cin >> a >> b;
int c=0;
for(int j=0; j<b; j++){
int t;
cin >> t;
t--;
c+=(1<<t);
}
for(int j=0; j<(1<<n); j++){
cost[j|c]=min(cost[j|c], cost[j]+a);
}
}
if(cost[(1<<n)-1]!=INF) cout << cost[(1<<n)-1] << endl;
else cout << -1 << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string a, b, c, r[10], s, rr;
int n;
string nrm(string s) {
string r = "";
for (int i = 0; i < s.length(); i++)
if ((s[i] != '-') && (s[i] != ';') && (s[i] != '_')) r += tolower(s[i]);
return r;
}
int main() {
cin >> a >> b >> c;
a = nrm(a);
b = nrm(b);
c = nrm(c);
r[1] = a + b + c;
r[2] = a + c + b;
r[3] = b + a + c;
r[4] = b + c + a;
r[5] = c + a + b;
r[6] = c + b + a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
s = nrm(s);
if ((s == r[1]) || (s == r[2]) || (s == r[3]) || (s == r[4]) ||
(s == r[5]) || (s == r[6]))
rr += "ACC\n";
else
rr += "WA\n";
}
cout << rr;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using uint8 = unsigned char;
using uint16 = unsigned short int;
using uint32 = unsigned int;
using uint64 = unsigned long long;
using int8 = signed char;
using int16 = short int;
using int32 = int;
using int64 = long long;
using pi32 = std::pair<int32, int32>;
using vi32 = std::vector<int32>;
using qi32 = std::queue<int32>;
using spi32 = std::set<pi32>;
namespace oct {
const int tn4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int tn8[8][2] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1},
{-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
void sync();
template <typename _Tp>
_Tp &mad(_Tp &x, _Tp y);
template <typename _Tp>
_Tp &mid(_Tp &x, _Tp y);
template <typename _Tp>
bool in(_Tp x, _Tp l, _Tp r);
template <typename _Tp>
_Tp sqr(_Tp x);
inline void sync() {
std::ios::sync_with_stdio(0);
std::cin.tie(0), std::cout.tie(0);
}
template <typename _Tp>
inline _Tp &mad(_Tp &x, _Tp y) {
return x = std::max(x, y);
}
template <typename _Tp>
inline _Tp &mid(_Tp &x, _Tp y) {
return x = std::min(x, y);
}
template <typename _Tp>
inline bool in(_Tp x, _Tp l, _Tp r) {
return l <= x && x <= r;
}
template <typename _Tp>
inline _Tp sqr(_Tp x) {
return x * x;
}
} // namespace oct
const int N = 100005;
double f(double x);
int n, p, q, max;
int a[N], b[N];
inline double f(double x) {
double y = 1;
for (int i = 1; i <= n; ++i) oct::mid(y, (1.0 - x * b[i]) / a[i]);
return y * p + x * q;
}
int main() {
oct::sync();
std::cin >> n >> p >> q;
for (int i = 1; i <= n; ++i) std::cin >> a[i] >> b[i], oct::mad(max, b[i]);
double l = 0, r = 1.0 / max, midl, midr;
for (int i = 1; i <= 100; ++i) {
midl = (l * 2 + r) / 3, midr = (l + r * 2) / 3;
if (f(midl) <= f(midr)) {
l = midl;
} else {
r = midr;
}
}
double ans = f((l + r) / 2);
std::cout << int(ans) << '.';
ans -= int(ans);
for (int i = 1; i <= 15; ++i) {
ans *= 10;
std::cout << int(ans);
ans -= int(ans);
}
std::cout << std::endl;
return 0;
}
| 3 |
#include <iostream>
using namespace std;
using ll = long long;
ll h, w;
ll solve(ll x, ll y){
ll ans = h * w;
for(int i = 1; i < x; i++){
ll s1 = i * y;
ll s2 = (x - i) / 2 * y;
ll s3 = x * y - s1 - s2;
ll smax = max(s1, max(s2, s3));
ll smin = min(s1, min(s2, s3));
ans = min(ans, smax - smin);
s2 = (x - i) * (y / 2);
s3 = x * y - s1 - s2;
smax = max(s1, max(s2, s3));
smin = min(s1, min(s2, s3));
ans = min(ans, smax - smin);
}
return ans;
}
int main(){
cin >> h >> w;
cout << min(solve(h, w), solve(w, h)) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, w, h, m, max_height = INT_MIN, landing;
cin >> n;
vector<long long> stairs(n, 0);
for (i = 0; i < n; i++) {
cin >> stairs[i];
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> w >> h;
landing = (stairs[w - 1] > max_height) ? stairs[w - 1] : max_height;
cout << landing << endl;
max_height = landing + h;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, arr[300001], ans[300001];
long long tot;
priority_queue<pair<int, int> > q;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = 1; i <= k; ++i) q.push(pair<int, int>(arr[i], i));
for (int i = k + 1; i <= k + n; ++i) {
if (i <= n) q.push(pair<int, int>(arr[i], i));
tot += 1LL * q.top().first * (i - q.top().second);
ans[q.top().second] = i;
q.pop();
}
cout << tot << endl;
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int64_t n;
cin >> n;
vector<pair<int64_t, int64_t>> v;
for (int64_t i = 0; i < n; i += 1) {
int64_t t;
cin >> t;
v.push_back(make_pair(t, i + 1));
}
sort(v.begin(), v.end());
if (v[0].first == v[1].first)
cout << "Still Rozdil";
else
cout << v[0].second;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t t = 1;
while (t--) {
solve();
cout << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
int i,j,cnt;
int n;
cin>>n;
ll a[n+1],b[n];
for(i=0;i<n+1;i++)cin>>a[i];
for(i=0;i<n;i++)cin>>b[i];
ll sum=0;
for(i=0;i<n;i++){
if(a[i]>=b[i])sum+=b[i];
else if(b[i]-a[i]<=a[i+1]){
a[i+1]-=(b[i]-a[i]);
sum+=b[i];
}else{
sum+=a[i]+a[i+1];
a[i+1]=0;
}
}
cout<<sum;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f;
const int N = 100000 + 10;
const double eps = 1e-15;
int n, m, num, a1, b1, z;
char s1[100100], s2[100100];
int main() {
int t, ans = 0;
scanf("%d", &n);
scanf("%s", s1);
scanf("%s", s2);
for (int i = 0, j = n - 1; i <= j; i++, j--) {
if (i == j) {
if (s1[i] != s2[i]) ans++;
break;
}
if (s1[i] == s1[j] && s2[i] == s2[j])
continue;
else if (s1[i] == s2[j] && s1[j] == s2[i])
continue;
else if (s1[i] == s2[i] && s1[j] == s2[j])
continue;
else if (s1[i] == s2[i] && s1[j] != s2[j])
ans++;
else if (s1[i] != s2[i] && s1[j] == s2[j])
ans++;
else if (s1[i] == s2[j] && s1[j] != s2[i])
ans++;
else if (s1[i] != s2[j] && s1[j] == s2[i])
ans++;
else if (s1[i] != s1[j] && s2[i] == s2[j])
ans++;
else
ans += 2;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505000;
int n;
string str;
long long p[maxn], pre[maxn], suf[maxn];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> p[i];
cin >> str;
long long init = 0, now;
for (int i = 0; i < n; ++i)
if (str[i] == 'B') init += p[i];
now = init;
for (int i = 0; i < n; ++i) {
if (str[i] == 'A') now += p[i];
if (str[i] == 'B') now -= p[i];
pre[i] = now;
}
now = init;
for (int i = n - 1; i >= 0; --i) {
if (str[i] == 'A') now += p[i];
if (str[i] == 'B') now -= p[i];
suf[i] = now;
}
long long ans = init;
for (int i = 0; i < n; ++i) ans = max(ans, max(pre[i], suf[i]));
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1000010], t[5000000], n, m;
int create(int u, int l, int h, int& ch) {
if (l == h) {
ch = 2;
t[u] = a[l];
return t[u];
}
int z, zz;
int c = create(2 * u, l, (l + h) / 2, z);
int d = create(2 * u + 1, (l + h) / 2 + 1, h, zz);
if (z == 1) {
ch = 2;
return t[u] = c ^ d;
}
ch = 1;
return t[u] = c | d;
}
int query(int u, int l, int h, int y, int val, int& ch) {
if (y > h || y < l) {
return t[u];
}
if (l == h) {
ch = 2;
t[u] = val;
return t[u];
}
int z;
int c = query(2 * u, l, (l + h) / 2, y, val, z);
int d = query(2 * u + 1, (l + h) / 2 + 1, h, y, val, z);
if (z == 1) {
ch = 2;
t[u] = c ^ d;
return t[u];
}
ch = 1;
t[u] = c | d;
return t[u];
}
int main() {
scanf("%d%d", &n, &m);
int zz, x, y;
for (int i = 1; i <= (1 << n); i++) scanf("%d", &a[i]);
create(1, 1, 1 << n, zz);
while (m--) {
scanf("%d%d", &x, &y);
int zz;
printf("%d\n", query(1, 1, 1 << n, x, y, zz));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 111111;
int A[maxn];
using namespace std;
int main() {
int n, k;
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
int m = n - k;
int ans = 0;
for (int i = 0; i < m; i++) {
ans = max(ans, A[i] + A[2 * m - 1 - i]);
}
ans = max(ans, A[n - 1]);
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g, comps;
const int N = 1e5 + 1;
int m, n;
bool vis[N];
vector<int> res;
int main() {
string s;
cin >> s;
int i;
i = (s.size() * 25);
i = i + 26;
cout << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, u;
long long cap, cost;
Edge() : v(), u(), cap(), cost() {}
Edge(int _v, int _u, long long _cap, long long _cost)
: v(_v), u(_u), cap(_cap), cost(_cost) {}
};
const long long INF1 = (long long)1e9;
const long long INF2 = (long long)1e15;
const int E = (int)4e4;
const int V = 200;
int S, T;
int n, k;
int a[V];
long long c[V];
Edge ed[E];
int edSz;
long long dist[V];
int par[V];
void addEdge(int v, int u, long long cap, long long cost) {
ed[edSz++] = Edge(v, u, cap, cost);
ed[edSz++] = Edge(u, v, 0, -cost);
}
long long flow() {
for (int i = 0; i <= S; i++) dist[i] = INF2;
dist[S] = 0;
bool ch = true;
while (ch) {
ch = false;
for (int i = 0; i < edSz; i++) {
Edge e = ed[i];
if (e.cap <= 0) continue;
if (dist[e.v] == INF2) continue;
long long w = dist[e.v] + e.cost;
if (w >= dist[e.u]) continue;
dist[e.u] = w;
par[e.u] = i;
ch = true;
}
}
long long res = 0;
int v = T;
while (v != S) {
int id = par[v];
ed[id].cap--;
ed[id ^ 1].cap++;
res += ed[id].cost;
v = ed[id].v;
}
return res;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
for (int i = 0; i < n; i++) scanf("%lld", &c[i]);
S = 2 * n;
T = 2 * n - 1;
for (int i = 0; i < n; i++) addEdge(2 * i, 2 * i + 1, 1, -INF1);
for (int i = 0; i < 2 * n - 1; i++) addEdge(i, T, INF1, 0);
addEdge(S, T, INF1, 0);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
long long w = (a[i] == a[j] ? 0 : c[a[j]]);
addEdge(2 * i + 1, 2 * j, INF1, w);
}
addEdge(S, 2 * i, INF1, c[a[i]]);
}
long long ans = INF1 * n;
for (int i = 0; i < k; i++) ans += flow();
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[101];
if (n % 2 == 1) {
cout << "-1";
} else {
for (int i = 0; i <= n; i++) {
if (i % 2 == 1) {
a[i] = i + 1;
} else {
a[i] = i - 1;
}
}
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
vector<int> ans;
bool check(int cl, int b, int turn) {
if (turn == n) return true;
for (int i = 1; i < s.size(); i++) {
bool k = true;
if (s[i] == '1' && i > cl && i != b) {
if (check(i - cl, i, turn + 1)) {
ans.push_back(i);
k = false;
}
}
if (k == false) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
cin >> n;
s = " " + s;
if (check(0, 0, 0) == true) {
cout << "YES\n";
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
} else
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int val[maxn], n, vis[maxn];
vector<int> son[maxn];
inline int id(char c) {
if (c == 'A') return -1;
if (c == 'I') return 0;
if (c == 'X') return -3;
if (c == 'O') return -2;
if (c == 'N') return -4;
return -4;
}
void Set(int u) {
if (vis[u]) return;
vis[u] = 1;
for (int v : son[u]) Set(v);
}
int cal(int u) {
if (val[u] >= 0) return val[u];
if (val[u] == -4) return !cal(son[u][0]);
int x = cal(son[u][0]), y = cal(son[u][1]);
if (val[u] == -1) {
if (x == 0) Set(son[u][1]);
if (y == 0) Set(son[u][0]);
return x & y;
} else if (val[u] == -2) {
if (x == 1) Set(son[u][1]);
if (y == 1) Set(son[u][0]);
return x | y;
} else
return x ^ y;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
char op[10];
scanf("%s", op);
if (id(op[0])) {
val[i] = id(op[0]);
if (val[i] == -4) {
int x;
scanf("%d", &x);
son[i].push_back(x);
continue;
}
int x, y;
scanf("%d", &x);
scanf("%d", &y);
son[i].push_back(x);
son[i].push_back(y);
} else {
int x;
scanf("%d", &x);
val[i] = x;
}
}
int ans = cal(1);
for (int i = 1; i <= n; i++) {
if (val[i] < 0) continue;
if (vis[i])
printf("%d", ans);
else
printf("%d", !ans);
}
puts("");
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.