solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int arr[150][150];
int n, m;
void sub_row(int row, int val) {
for (int i = 0; i < m; ++i) {
arr[row][i] -= val;
}
}
void sub_col(int col, int val) {
for (int i = 0; i < n; ++i) {
arr[i][col] -= val;
}
}
pair<int, int> max_col(int col) {
int mn = INT_MAX;
int mx = INT_MIN;
for (int i = 0; i < n; ++i) {
if (arr[i][col] < mn) {
mn = arr[i][col];
}
if (arr[i][col] > mx) {
mx = arr[i][col];
}
}
pair<int, int> tmp = {mn, mx};
return tmp;
}
pair<int, int> max_row(int row) {
int mn = INT_MAX;
int mx = INT_MIN;
for (int i = 0; i < m; ++i) {
if (arr[row][i] < mn) {
mn = arr[row][i];
}
if (arr[row][i] > mx) {
mx = arr[row][i];
}
}
pair<int, int> tmp = {mn, mx};
return tmp;
}
int main() {
cin >> n >> m;
vector<int> mn_row(n);
for (int i = 0; i < n; ++i) {
int mn = INT_MAX;
for (int j = 0; j < m; ++j) {
cin >> arr[i][j];
if (arr[i][j] < mn) {
mn = arr[i][j];
}
}
mn_row[i] = mn;
}
vector<string> res;
if (n <= m) {
for (int i = 0; i < n; ++i) {
if (mn_row[i] > 0) {
sub_row(i, mn_row[i]);
for (int j = 0; j < mn_row[i]; ++j) {
res.push_back("row " + to_string(i + 1));
}
}
}
for (int i = 0; i < m; ++i) {
pair<int, int> temp = max_col(i);
if (temp.first != temp.second) {
cout << -1 << "\n";
return 0;
}
for (int j = 0; j < temp.first; ++j) {
res.push_back("col " + to_string(i + 1));
}
}
} else {
for (int i = 0; i < m; ++i) {
pair<int, int> val = max_col(i);
if (val.first > 0) {
sub_col(i, val.first);
for (int j = 0; j < val.first; ++j) {
res.push_back("col " + to_string(i + 1));
}
}
}
for (int i = 0; i < n; ++i) {
pair<int, int> val = max_row(i);
if (val.first != val.second) {
cout << -1 << "\n";
return 0;
}
for (int j = 0; j < val.first; ++j) {
res.push_back("row " + to_string(i + 1));
}
}
}
cout << res.size() << "\n";
for (string str : res) {
cout << str << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());
if (s.length() % 2 == 0) {
cout << "CHAT WITH HER!" << endl;
} else {
cout << "IGNORE HIM!" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 3e5 + 15;
long long n, sum;
long long Arr[MAX_N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> Arr[i];
sum += Arr[i];
}
sort(Arr, Arr + n);
long long q;
cin >> q;
while (q--) {
long long tmp;
cin >> tmp;
cout << sum - Arr[n - tmp] << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, i = 1, j = 1, k = 0, t = 0;
cin >> a >> b;
while (a > 0) {
a = a - 2 * i + 1;
if (a >= 0) k++;
i++;
}
while (b > 0) {
b = b - 2 * j;
if (b >= 0) t++;
j++;
}
if (k > t)
cout << "Valera";
else
cout << "Vladik";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, l, r, w = 0, b = 1;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l >> r;
while (b + x <= l) {
b += x;
}
w += (r - b) + 1;
b = r + 1;
}
cout << w << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, x;
string s;
int main() {
cin >> n >> m;
r = 0;
l = n + 1;
for (int i = 0; i < m; ++i) {
cin >> s;
cin >> s;
cin >> s;
if (s == "left") {
cin >> s >> x;
l = min(l, x);
} else {
cin >> s >> x;
r = max(r, x);
}
}
if (l - r - 1 <= 0)
cout << -1 << endl;
else
cout << l - r - 1 << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define mp make_pair
#define REP(i,a,b) for(int i=a;i<b;i++)
typedef long long LL ;
typedef unsigned long long Uint;
typedef pair<int, int> P;
const int maxn = 1e6+10;
const LL MOD = 1e9+7;
const int INF = 1e9+7;
const double PI = acos(-1);
const double eps = 1e-7;
int ans[maxn];
int arr[maxn];
int at[maxn];
int n ;
struct node
{
// int sum;
int Max;
int Min;
int lazy;
int L;
int R;
};
node t[4*maxn];
void push_up(int rt)
{
// t[rt].sum=(t[rt<<1].sum+t[rt<<1|1].sum);
t[rt].Max = max(t[rt<<1].Max , t[rt<<1|1].Max);
t[rt].Min = min(t[rt<<1].Min, t[rt<<1|1].Min);
}
void print()
{
for(int i=1;i<=30;++i)
{
printf("rt = %d , L =%d , R = %d , Max = %d, Min = %d, Lazy =%d\n", i, t[i].L, t[i].R, t[i].Max , t[i].Min, t[i].lazy);
}
}
void build(int rt, int L, int R)
{
t[rt].lazy = 0;
t[rt].L = L;
t[rt].R =R;
t[rt].Max = t[rt].Min = 0;
if(L==R)
{
return ;
}
int mid=(L+R)>>1;
build(rt<<1, L, mid);
build(rt<<1|1, mid+1, R);
}
void push_down(int rt )
{
if(t[rt].lazy)
{
int lazy = t[rt].lazy;
t[rt].lazy = 0;
t[rt<<1].Max += lazy;
t[rt<<1].Min += lazy;
t[rt<<1].lazy += lazy;
t[rt<<1|1].Max += lazy;
t[rt<<1|1].Min += lazy;
t[rt<<1|1].lazy += lazy;
}
}
LL Query_Max(int rt, int x, int y)
{
//printf("MAx rt = %d, x= %d, y = %d\n", rt, x, y);
if(x>y) return -1;
int L = t[rt].L, R = t[rt].R;
if(x<=L && R <= y)
return t[rt].Max;
if(t[rt].lazy)
push_down(rt);
int mid=(L+R)>>1;
int Max= -INF;
if(x<=mid)
Max = max(Max*1LL , Query_Max(rt<<1,x, y) );
if(y>mid)
Max = max(Max*1LL , Query_Max(rt<<1|1 ,x, y));
// if(rt==1) Print();
return Max;
}
LL Query_Min(int rt, int x, int y)
{
//printf("Min rt = %d, x= %d, y = %d\n", rt, x, y);
if(x>y) return INF;
int L = t[rt].L, R = t[rt].R;
if(x<=L&& R <= y)
return t[rt].Min;
if(t[rt].lazy)
push_down(rt);
int mid=(L+R)>>1;
int Min= INF;
if(x<=mid)
Min = min(Min*1LL , Query_Min(rt<<1,x, y));
if(y>mid)
Min = min(Min*1LL, Query_Min(rt<<1|1,x, y));
// if(rt==1) Print();
return Min;
}
void add(int rt ,int x, int y, int val)
{
if(x>y) return;
int L = t[rt].L , R = t[rt].R;
if(x<= L&& R<=y)
{
t[rt].Max += val;
t[rt].Min += val;
t[rt].lazy = t[rt].lazy + val;
return ;
}
if(t[rt].lazy)
push_down(rt );
int mid=(L+R)>>1;
if(x<=mid)
add(rt<<1, x, y, val);
if(y>mid)
add(rt<<1|1, x, y , val);
push_up(rt);
return ;
}
bool cmp(int a, int b)
{
return arr[a] < arr[b];
}
void solve()
{
cin >>n;
if(n==1)
{
printf("0");return;
}
for(int i=1;i<=n;++i)
{
cin >>arr[i];
at[i] = i;
}
sort(at+1, at+n+1, cmp);
build(1, 1, n);
for(int i=1;i<=n;++i)
{
// printf("%d ", arr[at[i]]);
int pos = at[i];
add(1, pos, n, 1);
}
int z = 1;
for(int j=1;j<=n;++j)
{
int pos;
while(arr[at[z]] < arr[at[j]] )
{
pos = at[z];
add(1, pos, n, -2);
// printf("**************pos = %d\n" , pos);
z++;
}
pos = at[j];
int len;
if(pos==1)
{
len = Query_Max(1, 1, n);
// printf("pos = %d, len = Query_max(1, 1, %d) =%d\n", pos, n, len);
}
else
{
//print();
int A = Query_Max(1, pos, n);
int B= min(0LL, Query_Min(1, 1, pos-1));
len = A- B;
// if(pos!=30) continue;
// printf("pos = %d, len = %d \n ", pos, len);
// printf("Query_Max(1, %d, %d) = %d , Query_Min(1, 1, %d) = %d\n ",pos, n,A , pos-1, B );
}
ans[pos] = max(ans[pos], len/2);
}
build(1, 1, n);
for(int i=1;i<=n;++i)
{
int pos = at[i];
add(1, pos, n, 1);
}
// memset(t, 0, sizeof t);
// Print();
z = n;
for(int j=n;j>=1;--j)
{
while(arr[at[z]] > arr[at[j]])
{
// pos = at[z];
add(1, at[z], n , -2);
z--;
}
int pos = at[j];
int len = 0;
if(pos==1)
{
len = Query_Max(1, 1, n);
// printf("pos = %d, len = Query_max(1, 1, %d) = %d\n", pos, n, len);
}
else
{
// if(pos!=30) continue;
int A = Query_Max(1, pos, n);
int B= min(0LL, Query_Min(1, 1, pos-1));
len = A- B;
// printf("pos = %d, len = %d \n ", pos, len);
// printf("Query_Max(1,%d, %d) = %d , Query_Min(1, 1, %d) = %d\n ", pos, n,A , pos-1, B );
}
ans[pos] = max(ans[pos], (len+1)/2-1);
}
for(int i=1;i<=n;++i)
{
printf("%d " ,ans[i]);
}
}
int main()
{
ios::sync_with_stdio(0);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char in[10];
char all[800][10];
inline bool id(char* a, char* b) {
int i;
for (i = 0; i < 6; i++)
if (a[i] != b[i]) return 0;
return 1;
}
inline void rot(char* a) {
char c = a[1];
a[1] = a[2];
a[2] = a[3];
a[3] = a[4];
a[4] = c;
}
inline void rot2(char* a) {
char c = a[0];
a[0] = a[2];
a[2] = a[5];
a[5] = a[4];
a[4] = c;
}
inline void rot3(char* a) {
char c = a[0];
a[0] = a[3];
a[3] = a[5];
a[5] = a[1];
a[1] = c;
}
inline bool same(char* a, char* b) {
char c[6];
int i, j;
for (i = 0; i < 6; i++) c[i] = b[i];
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (id(a, c)) return 1;
rot(c);
}
rot2(c);
}
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (id(a, c)) return 1;
rot(c);
}
rot3(c);
}
return 0;
}
int main() {
scanf("%s", in);
sort(in, in + 6);
int ac = 0;
do {
int i;
for (i = 0; i < ac; i++)
if (same(all[i], in)) break;
if (i == ac) {
for (i = 0; i < 6; i++) all[ac][i] = in[i];
ac++;
}
} while (next_permutation(in, in + 6));
printf("%d\n", ac);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, e, o, e1, o1, x;
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> x, o += (x % 2);
e = n - o;
for (int i = 0; i < m; ++i) cin >> x, o1 += (x % 2);
e1 = m - o1;
cout << min(e, o1) + min(e1, o);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
int INF = 1000000000;
int MAXINT = 2147483647;
long long INFLL = 1000000000000000000LL;
long long MAXLL = 9223372036854775807LL;
pair<int, int> M[8] = {make_pair(0, 1), make_pair(1, 0), make_pair(-1, 0),
make_pair(0, -1), make_pair(-1, 1), make_pair(-1, -1),
make_pair(1, -1), make_pair(1, 1)};
char s[1000100];
char t[1000100];
int main() {
gets(s + 5);
s[0] = '0';
s[1] = '0';
s[2] = '0';
s[3] = '0';
s[4] = '0';
int len = strlen(s);
for (int(a) = (0); (a) <= (len - 1); (a)++) t[a] = '0';
int sav = 0;
for (int(a) = (len - 1); (a) >= (0); (a)--) {
int x = s[a] - '0';
int y = sav + 3 * x;
sav = y / 2;
t[a] = y % 2 + '0';
}
int res = 0;
for (int(a) = (0); (a) <= (len - 1); (a)++) {
if ((t[a] - '0') ^ (s[a] - '0')) res++;
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, ss = "";
cin >> s;
bool bb = 0, tt = 0, bc = 0, bd = 0, uu = 0, bkk = 0, bbc = 0;
long long n = s.size(), i;
long long ans = 0;
if (s.size() == 1) {
if (s[0] == '0' || (s[0] == 'X' || s[0] == '_')) ans = 1;
} else if (s.size() == 2) {
if (s == "25")
ans = 1;
else if (s == "75")
ans = 1;
else if (s == "50")
ans = 1;
else if (s == "__")
ans = 3;
else if (s == "_X")
ans = 3;
else if (s == "X_")
ans = 3;
else if (s[0] == '2' || (s[0] == '7' || s[0] == '5')) {
if (s[1] == '_' || s[1] == 'X') ans = 1;
} else if (s[1] == '5') {
ans = 2;
} else if (s[1] == '0') {
ans = 1;
}
} else {
ss += s[n - 2];
ss += s[n - 1];
if (ss == "25")
ans = 1;
else if (ss == "75")
ans = 1;
else if (ss == "50")
ans = 1;
else if (ss == "00")
ans = 1;
else if (ss == "__")
ans = 4;
else if (ss == "_X") {
ans = 4;
bb = 1;
} else if (ss == "X_") {
ans = 4;
bd = 1;
} else if (ss == "XX") {
ans = 1;
bc = 1;
} else if (s[n - 2] == '2' ||
(s[n - 2] == '7' || (s[n - 2] == '5' || s[n - 2] == '0'))) {
if (s[n - 1] == 'X') {
ans = 1;
bkk = 1;
if (s[0] == 'X' && (s[n - 2] == '0' || s[n - 2] == '5')) {
cout << "0";
return 0;
}
} else if (s[n - 1] == '_') {
ans = 1;
}
} else if (s[n - 2] == '_') {
if (s[n - 1] == '5')
ans = 2;
else if (s[n - 1] == '0')
ans = 2;
} else if (s[n - 2] == 'X') {
if (s[n - 1] == '5') {
ans = 2;
bbc = 1;
} else if (s[n - 1] == '0') {
if (s[0] == 'X')
ans = 1;
else
ans = 2;
}
}
if (s[0] == '0')
ans = 0;
else if (s[0] == '_')
ans *= 9;
else if (s[0] == 'X') {
uu = 1;
if (bb)
ans = 2;
else if (bc)
ans = 0;
else if (bd) {
ans = 3;
} else if (!bbc && (!bkk)) {
ans *= 9;
}
}
for (i = 1; i < n - 2; i++) {
if (s[i] == '_')
ans *= 10;
else if (s[i] == 'X')
tt = 1;
}
if (tt && (!bc && (!bd && ((!bb && !uu) && ((!bbc && !bkk)))))) ans *= 10;
}
cout << ans;
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> adds[100002];
int asz;
int Cnt5(int num) {
int ret = 0;
while (num % 5 == 0 && num != 0) {
ret++;
num /= 5;
}
return ret;
}
int main() {
int tar;
scanf("%d", &tar);
int curcnt = 0;
for (int i = 0; i <= 100000; i++) {
curcnt += Cnt5(i * 5);
if (curcnt > tar) {
printf("0\n");
return 0;
}
if (curcnt == tar) {
printf("5\n");
for (int j = 5 * i; j < 5 * (i + 1); j++) {
if (j != 5 * i) printf(" ");
printf("%d", j);
}
printf("\n");
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool remin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool remax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int nxt() {
int first;
scanf("%d", &first);
return first;
}
long long gcd(long long a, long long b) {
a = abs(a);
b = abs(b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
struct pt {
long double first, second;
pt() {}
pt(long double first, long double second) : first(first), second(second) {}
inline pt operator-(const pt &r) const {
return pt(first - r.first, second - r.second);
}
inline pt operator+(const pt &r) const {
return pt(first + r.first, second + r.second);
}
inline pt operator*(const long double &r) const {
return pt(first * r, second * r);
}
inline long double sqlen() const {
return abs(first * first + second * second);
}
pt rot(long double co, long double si) const {
return pt(first * co - si * second, si * first + co * second);
}
pt rot(long double ang) const { return rot(cosl(ang), sinl(ang)); }
long double len() const { return sqrtl(sqlen()); }
inline bool operator<(const pt &r) const {
if (first != r.first) return first < r.first;
return second < r.second;
}
inline bool operator==(const pt &r) const {
return first == r.first && second == r.second;
}
};
ostream &operator<<(ostream &os, const pt &p) {
return os << "(" << p.first << "," << p.second << ")";
}
inline long double cross(const pt &l, const pt &r) {
return l.first * r.second - l.second * r.first;
}
inline long double dot(const pt &l, const pt &r) {
return l.first * r.first + l.second * r.second;
}
long long pwmod(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
template <typename T>
inline T sqr(T first) {
return first * first;
}
bool remin(long long &first, long long second) {
if (first > second) {
first = second;
return 1;
}
return 0;
}
const long long mod = 1000000007;
const int N = 200 * 1000 + 10;
pair<int, int> a[N];
long long f[N];
long long fi[N];
long long bin(long long n, long long k) {
if (n < 0) return 0;
if (k < 0 || k > n) return 0;
return f[n] * fi[n - k] % mod * fi[k] % mod;
}
vector<int> t;
int sz;
void init(int nn) {
sz = nn;
t.assign(sz, 0);
}
int sum(int r) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, int delta) {
for (; i < sz; i = (i | (i + 1))) t[i] += delta;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
void solve(int test) {
f[0] = fi[0] = 1;
for (int i = 1; i < N; ++i) {
f[i] = f[i - 1] * i % mod;
fi[i] = pwmod(f[i], mod - 2, mod);
}
int n = nxt();
int k = nxt();
for (int i = 0; i < (int)(n); i++) {
a[i].first = nxt();
a[i].second = nxt() + 1;
}
sort(a, a + n);
vector<int> q;
for (int i = 0; i < (int)(n); i++) {
q.push_back(a[i].first);
q.push_back(a[i].second);
}
sort((q).begin(), (q).end());
q.resize(unique((q).begin(), (q).end()) - q.begin());
init(q.size());
long long ans = 0;
for (int i = 0, j = 0; i + 1 < q.size(); ++i) {
while (j < n && a[j].first <= q[i]) {
int ps = lower_bound((q).begin(), (q).end(), a[j].second) - q.begin();
inc(ps, 1);
++j;
}
long long cur = (q[i + 1] - q[i]) % mod;
ans += cur * bin(sum(i + 1, (int)q.size() - 1), k) % mod;
}
cout << ans % mod << "\n";
}
int main() {
int t = 1;
for (int i = 0; i < (int)(t); i++) {
solve(i + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dif;
map<int, int> g;
int a[120000];
int main() {
int n, flag;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 2; i <= n; i++) {
if (g[a[i] - a[i - 1]] == 0) dif.push_back(a[i] - a[i - 1]);
g[a[i] - a[i - 1]]++;
}
int sz = dif.size();
if (sz > 2 || n == 1) {
if (sz > 2)
cout << 0 << endl;
else
cout << -1 << endl;
return 0;
}
if (sz == 1) {
int D = dif[0];
if (dif[0] == 0) {
cout << 1 << endl;
cout << a[1] << endl;
return 0;
}
if (n == 2) {
if ((a[2] - a[1]) % 2 == 0) {
cout << 3 << endl;
cout << a[1] - D << " " << (a[2] + a[1]) / 2 << " " << a[2] + D << endl;
return 0;
}
}
cout << 2 << endl;
cout << a[1] - D << " " << a[n] + D << endl;
return 0;
}
int D1 = min(dif[0], dif[1]), D2 = max(dif[0], dif[1]);
if (D1 * 2 != D2 || g[D2] > 1) {
cout << 0 << endl;
return 0;
}
cout << 1 << endl;
for (int i = 2; i <= n; i++) {
if (a[i] - a[i - 1] == D2) {
cout << a[i] - D1 << endl;
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt(time(0));
const int MAXN = 5e5 + 10;
struct Item {
bool head;
int len = 0;
int8_t type[2] = {};
int in = 0;
int cnt[2] = {};
Item() = default;
Item(int h) {
head = h;
len = 1;
type[1 - h] = 1;
cnt[1 - h] = 1;
}
};
string s;
Item tree[MAXN << 2][2];
int idx[MAXN << 2], info[MAXN << 2];
Item merge(const Item& x, const Item& y) {
if (x.len == 0) return y;
if (y.len == 0) return x;
Item ret;
ret.head = x.head;
ret.len = x.len + y.len;
if ((x.head + x.len - 1) % 2 == y.head) ret.len--;
ret.in = max(x.in, y.in);
if (x.type[0] == 0 && x.type[1] == 1) {
if (y.type[0] == 0 && y.type[1] == 1) {
ret.type[1] = 1;
ret.cnt[1] = x.cnt[1] + y.cnt[1];
} else if (y.type[1] == 0) {
ret.type[0] = 2;
ret.cnt[0] = x.cnt[1] + y.cnt[0];
} else {
ret.type[0] = 2;
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[1] + y.cnt[0];
ret.cnt[1] = y.cnt[1];
}
return ret;
}
if (x.type[0] == 1 && x.type[1] == 0) {
if (y.type[0] == 0 || y.type[0] == 1) {
ret.type[0] = 1;
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[0] + y.cnt[0];
ret.cnt[1] = y.cnt[1];
} else if (y.type[1] == 0) {
ret.type[0] = 1;
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[0];
} else {
ret.type[0] = 1;
ret.type[1] = y.type[1];
ret.in = max(ret.in, y.cnt[0]);
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[1];
}
return ret;
}
if (x.type[0] == 2 && x.type[1] == 0 && y.type[0] == 2 && y.type[1] == 0) {
ret.type[0] = 2;
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[0];
return ret;
}
if (x.type[0] == 2 && x.type[1] == 0 && y.type[0] == 1) {
ret.type[0] = 2;
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[0] + y.cnt[0];
ret.cnt[1] = y.cnt[1];
return ret;
}
if (y.type[0] == 0 && x.type[1] == 1) {
ret.type[0] = x.type[0];
ret.type[1] = 1;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = x.cnt[1] + y.cnt[1];
return ret;
}
if (y.type[0] == 1 && y.type[1] == 0) {
ret.type[0] = x.type[0];
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = x.cnt[1] + y.cnt[0];
return ret;
}
if (y.type[0] == 2 && y.type[1] == 0) {
if (x.type[1] == 1) {
ret.type[0] = x.type[0];
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = x.cnt[1] + y.cnt[0];
} else {
ret.type[0] = x.type[0];
ret.type[1] = 2;
ret.in = max(ret.in, x.cnt[1]);
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[0];
}
return ret;
}
ret.type[0] = x.type[0];
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[1];
if (x.type[1] == 2 && y.type[0] == 2) {
ret.in = max(ret.in, x.cnt[1]);
ret.in = max(ret.in, y.cnt[0]);
} else
ret.in = max(ret.in, x.cnt[1] + y.cnt[0]);
return ret;
}
void build(int node, int left, int right) {
if (left == right) {
if (s[left - 1] == '>') {
tree[node][0] = Item(0);
tree[node][1] = Item(1);
} else {
tree[node][0] = Item(1);
tree[node][1] = Item(0);
}
return;
}
int mid = ((left + right) >> 1);
build((node << 1), left, mid);
build(((node << 1) | 1), mid + 1, right);
tree[node][0] = merge(tree[(node << 1)][0], tree[((node << 1) | 1)][0]);
tree[node][1] = merge(tree[(node << 1)][1], tree[((node << 1) | 1)][1]);
}
void push_down(int node, int left, int right) {
if (left == right || info[node] == 0) return;
idx[(node << 1)] ^= 1;
idx[((node << 1) | 1)] ^= 1;
info[(node << 1)] ^= 1;
info[((node << 1) | 1)] ^= 1;
info[node] = 0;
}
void update(int node, int left, int right, int i, int j) {
if (right < i || j < left) return;
if (i <= left && right <= j) {
info[node] ^= 1;
idx[node] ^= 1;
return;
}
push_down(node, left, right);
int mid = ((left + right) >> 1);
update((node << 1), left, mid, i, j);
update(((node << 1) | 1), mid + 1, right, i, j);
tree[node][idx[node]] =
merge(tree[(node << 1)][idx[(node << 1)]],
tree[((node << 1) | 1)][idx[((node << 1) | 1)]]);
tree[node][idx[node] ^ 1] =
merge(tree[(node << 1)][idx[(node << 1)] ^ 1],
tree[((node << 1) | 1)][idx[((node << 1) | 1)] ^ 1]);
}
Item query(int node, int left, int right, int i, int j) {
if (right < i || j < left) return Item();
if (i <= left && right <= j) {
return tree[node][idx[node]];
}
push_down(node, left, right);
int mid = ((left + right) >> 1);
Item a = query((node << 1), left, mid, i, j);
Item b = query(((node << 1) | 1), mid + 1, right, i, j);
return merge(a, b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int n, q;
cin >> n >> q;
cin >> s;
build(1, 1, n);
while (q--) {
int a, b;
cin >> a >> b;
update(1, 1, n, a, b);
Item tmp = query(1, 1, n, a, b);
int ret = max(tmp.cnt[0], tmp.cnt[1]);
ret = max(ret, tmp.in);
cout << ret << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n, m, k;
int x, y;
scanf("%d %d %d", &n, &m, &k);
k--;
x = k / (m * 2);
y = k % (m * 2);
if (y & 1)
printf("%d %d R\n", x + 1, (y / 2) + 1);
else
printf("%d %d L\n", x + 1, (y / 2) + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653589793;
const double tau = 6.283185307179586;
const double epsilon = 1e-6;
const int INF = 1 << 26;
const int MAXN = 100005;
int vis[MAXN * 2][2];
int graph[MAXN * 2][2];
int n, k;
int convert(char a) {
if (a == '-') return 1;
if (a == 'X') return 0;
return -1;
}
int ss(int a) { return a == 0 ? 1 : 0; }
int bfs(int x, int y) {
queue<pair<int, pair<int, int> > > q;
q.push(make_pair(0, make_pair(x, y)));
int a, b, c;
while (q.size()) {
pair<int, pair<int, int> > cur = q.front();
q.pop();
a = cur.second.first;
b = cur.second.second;
c = cur.first;
if (c > a) continue;
if (a + k >= n) {
cout << "YES" << endl;
return 1;
}
if (vis[a][b] < c) continue;
if (graph[a + k][ss(b)] == 1) {
if (a >= n) {
cout << "YES" << endl;
return 1;
}
if (vis[a + k][ss(b)] == INF) {
vis[a + k][ss(b)] = c + 1;
q.push(make_pair(c + 1, make_pair(a + k, ss(b))));
}
}
if (graph[a + 1][b] == 1) {
if (a >= n) {
cout << "YES" << endl;
return 1;
}
if (vis[a + 1][b] == INF) {
vis[a + 1][b] = c + 1;
q.push(make_pair(c + 1, make_pair(a + 1, b)));
}
}
if (graph[a - 1][b] == 1) {
if (a >= n) {
cout << "YES" << endl;
return 1;
}
if (vis[a - 1][b] == INF) {
vis[a - 1][b] = c + 1;
q.push(make_pair(c + 1, make_pair(a - 1, b)));
}
}
}
return 0;
}
int main(int argc, char** argv) {
scanf("%d %d\n", &n, &k);
for (int i = 0; i < 2 * n; i++) {
char a;
scanf("%c", &a);
if (a == '\n') {
i--;
continue;
}
graph[i % n][i / n] = convert(a);
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2 * n; j++) {
vis[j][i] = INF;
}
if (!bfs(0, 0)) cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int MAXN = 200005;
int n, x[MAXN];
long long a[MAXN], t;
long long b[MAXN];
void solve() {
for (int i = 0; i + 1 < n; i++) {
if (x[i] > x[i + 1]) {
cout << "No" << endl;
return;
}
}
for (int i = 0; i < n; i++) {
if (i > x[i]) {
cout << "No" << endl;
return;
}
}
for (int i = 0; i < n;) {
int pos = x[i];
int j = i;
while (j < n && x[j] == pos) {
j++;
}
if (j < x[i] + 1) {
cout << "No" << endl;
return;
}
long long num = a[j - 1];
for (int k = i; k + 1 < j; k++) {
b[k] = a[k + 1] + t;
}
b[j - 1] = a[j - 1] + t + (j - i > 1);
if (j < n && b[j - 1] >= a[j] + t) {
cout << "No" << endl;
return;
}
i = j;
}
cout << "Yes" << endl;
for (int i = 0; i < n; i++) {
cout << b[i] << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
while (cin >> n >> t) {
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> x[i];
x[i]--;
}
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[155];
const int INF = 1e9;
int a[155], best[155][155], f[155][155][155], flag, l, r, L, i, j, k, p, m, n;
void upd(int x) {
if (x > f[i][j][k]) f[i][j][k] = x;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == -1) a[i] = -INF;
}
scanf("%s", s + 1);
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++)
for (k = 0; k <= n; k++) f[i][j][k] = -INF;
for (L = 1; L <= n; L++)
for (i = 1; i <= n - L + 1; i++) {
j = i + L - 1;
if (L == 1) f[i][j][0] = a[1];
for (m = i; m < j; m++)
f[i][j][0] = max(f[i][j][0], f[i][m][0] + f[m + 1][j][0]);
for (flag = 1, l = i, r = j; l < r; l++, r--)
if (s[l] != s[r]) flag = 0;
if (flag) f[i][j][0] = max(f[i][j][0], a[L]);
for (m = i; m <= j; m++)
f[i][j][1] = max(f[i][j][1], f[i][m - 1][0] + f[m + 1][j][0]);
for (k = 2; k <= L; k++) {
for (p = i + 1; p <= j; p++) upd(f[i][p - 1][0] + f[p][j][k]);
for (p = i; p < j; p++) upd(f[p + 1][j][0] + f[i][p][k]);
if (s[i] == s[j]) upd(f[i + 1][j - 1][k - 2]);
}
for (k = 1; k <= L; k++) f[i][j][0] = max(f[i][j][0], f[i][j][k] + a[k]);
best[i][j] = max(0, f[i][j][0]);
for (m = i; m < j; m++)
best[i][j] = max(best[i][j], best[i][m] + best[m + 1][j]);
}
printf("%d\n", best[1][n]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[6010];
int sum[5210][5210], c[5210][5210];
int b[10];
bool check(int x) {
for (int i = 1; i <= n; i += x)
for (int j = 1; j <= n; j += x) {
int num = sum[i + x - 1][j + x - 1] - sum[i + x - 1][j - 1] -
sum[i - 1][j + x - 1] + sum[i - 1][j - 1];
if (num != x * x && num != 0) return (0);
}
return (1);
}
int main() {
scanf("%d", &n);
for (int ii = 0; ii <= n - 1; ii++) {
scanf("%s", s);
int len = n / 4;
int k = 0;
for (int i = 0; i <= len - 1; i++) {
int o;
if (s[i] >= 'A' && s[i] <= 'F')
o = s[i] - 'A' + 10;
else
o = s[i] - '0';
int num = 0;
memset(b, 0, sizeof(b));
while (o != 0) {
num++;
b[num] = o % 2;
o /= 2;
}
for (int i = 4; i >= 1; i--) c[ii + 1][++k] = b[i];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + c[i][j];
}
int o = 0;
int ans = 0;
for (int i = 1; i <= n; i++)
if (n % i == 0) {
if (check(i)) {
ans = max(ans, i);
}
}
printf("%d\n", ans);
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
const int mod = inf + 7;
inline int _sum(int a, int b) { return a + b < mod ? a + b : a + b - mod; }
inline int _mul(int a, int b) { return (1ll * a * b) % mod; }
inline int _sub(int a, int b) { return a >= b ? a - b : a - b + mod; }
inline void _inc(int& x, int y) {
if ((x += y) >= mod) {
x -= mod;
}
}
inline void _dec(int& x, int y) {
if ((x -= y) < 0) {
x += mod;
}
}
inline int _binpow(int x, int pw) {
int res = 1;
int tmp = x;
while (pw > 0) {
if (pw & 1) {
res = _mul(res, tmp);
}
tmp = _mul(tmp, tmp);
pw >>= 1;
}
return res;
}
inline int _div(int a, int b) { return _mul(a, _binpow(b, mod - 2)); }
void read(string& s) { cin >> s; }
void gen(string& s) {
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int n = 2 * (rnd() % 3 + 1);
s.resize(n, '?');
for (int i = 0; i < n; i++) {
s[i] = rnd() % 5 == 0 ? 'a' : 'b';
}
}
string join_halfs(string s) {
int n = (int)s.size();
string t;
for (int i = 0; i < n / 2; i++) {
t.push_back(s[i]);
t.push_back(s[n - 1 - i]);
}
return t;
}
int slow(string s) {
s = join_halfs(s);
int n = (int)s.size();
s = "#" + s;
vector<int> dp(n + 1);
dp[0] = 1;
cout << s << "\n";
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
if ((i - j + 1) % 2) continue;
string hlp = s.substr(j, i - j + 1);
string rhlp = hlp;
reverse(rhlp.begin(), rhlp.end());
if (hlp == rhlp) {
_inc(dp[i], dp[j - 1]);
}
}
}
return dp[n];
}
const int N = 2e6 + 5;
struct Node {
map<int, int> nxt;
int link = -1;
int dp[2] = {0, 0};
int slink = -1;
int len = 0;
int diff = 0;
Node() = default;
};
Node t[N];
int sz, max_suff;
int fast(string s) {
{
sz = 0;
t[sz++] = Node();
t[sz++] = Node();
max_suff = 1;
t[0].link = 1;
t[1].link = 0;
t[0].len = -1;
t[1].len = 0;
}
int n = (int)s.size();
s = "#" + join_halfs(s);
vector<int> dp(n + 1);
dp[0] = 1;
max_suff = 1;
for (int i = 1; i <= n; i++) {
{
while (s[i] != s[i - t[max_suff].len - 1]) {
max_suff = t[max_suff].link;
}
if (!t[max_suff].nxt.count(s[i])) {
t[sz++] = Node();
t[sz - 1].len = t[max_suff].len + 2;
int next_max_suff = t[max_suff].link;
while (s[i] != s[i - t[next_max_suff].len - 1]) {
next_max_suff = t[next_max_suff].link;
}
t[sz - 1].link =
t[next_max_suff].nxt.count(s[i]) ? t[next_max_suff].nxt[s[i]] : 1;
t[sz - 1].diff = t[sz - 1].len - t[t[sz - 1].link].len;
if (t[sz - 1].diff == t[t[sz - 1].link].diff) {
t[sz - 1].slink = t[t[sz - 1].link].slink;
} else {
t[sz - 1].slink = t[sz - 1].link;
}
t[max_suff].nxt[s[i]] = sz - 1;
}
max_suff = t[max_suff].nxt[s[i]];
}
for (int x = max_suff; t[x].len > 0; x = t[x].slink) {
t[x].dp[0] = t[x].dp[1] = 0;
{
int j = i - t[t[x].slink].len - t[x].diff;
t[x].dp[j & 1] = dp[j];
}
if (t[x].diff == t[t[x].link].diff) {
_inc(t[x].dp[0], t[t[x].link].dp[0]);
_inc(t[x].dp[1], t[t[x].link].dp[1]);
}
_inc(dp[i], t[x].dp[i & 1]);
}
}
return dp[n];
}
void WORK() {
string s;
read(s);
cout << fast(s) << "\n";
}
void TEST() {
while (1) {
string s;
gen(s);
cout << "s = " << s << endl;
int sl = slow(s);
int fs = fast(s);
if (sl == fs) {
cout << "OK (" << fs << ")" << endl;
} else {
cout << "WA" << endl;
cout << "exp = " << sl << endl;
cout << "fnd = " << fs << endl;
break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
WORK();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
vector<long long int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
bool all = false;
long long int g = arr[0] % k;
for (int i = 0; i < n; i++) {
arr[i] = arr[i] % k;
g = gcd(arr[i], g);
}
long long int total_cnt = 0;
vector<long long int> d_values(k, 0);
for (int i = 1; i <= k; i++) {
d_values[(g * i) % k] = 1;
}
for (int i = 0; i < k; i++) {
total_cnt += d_values[i];
}
cout << total_cnt << endl;
for (int i = 0; i < k; i++) {
if (d_values[i]) cout << i << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110000], L[110000], R[110000];
int main() {
int N, i;
cin >> N;
for (i = 1; i <= N; i++) {
cin >> a[i];
R[i] = i + 1;
}
a[N + 1] = INT_MAX;
int h = 1, ans = 0;
queue<int> Q;
for (i = 1; i < N; i++) Q.push(i);
for (;;) {
queue<int> P;
int x = 0;
while (!Q.empty()) {
int xx = Q.front();
Q.pop();
if (xx < x) continue;
x = xx;
if (a[x] <= a[R[x]]) continue;
P.push(x);
int t = a[x];
while (t > a[R[x]]) {
t = a[R[x]];
R[x] = R[R[x]];
}
x = R[x];
}
if (P.empty()) break;
++ans;
Q = P;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,fma,tune=native")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e5 + 100;
const long long mod = 998244353;
const long double PI = acos((long double)-1);
int n, q;
int lazy[maxn * 4][2], pw[maxn];
int ans[maxn * 4];
set<pair<int, int> > st[maxn];
void fufu(int v, int u) {
lazy[u][0] += lazy[v][0];
lazy[u][1] = (lazy[u][1] * 1LL * pw[lazy[v][0]]) % mod;
lazy[u][1] = (lazy[u][1] + lazy[v][1]) % mod;
}
void shift(int v, int l, int r) {
ans[v] = (ans[v] * 1LL * pw[lazy[v][0]]) % mod;
ans[v] = (ans[v] + (lazy[v][1] * 1LL * (r - l)) % mod) % mod;
if (r - l > 1) fufu(v, 2 * v), fufu(v, 2 * v + 1);
lazy[v][0] = lazy[v][1] = 0;
}
void update(int L, int R, int val, int v = 1, int l = 1, int r = n + 1) {
shift(v, l, r);
if (r <= L or R <= l) return;
if (L <= l and r <= R) {
lazy[v][val] = 1;
shift(v, l, r);
return;
}
int mid = (l + r) / 2;
update(L, R, val, 2 * v, l, mid);
update(L, R, val, 2 * v + 1, mid, r);
ans[v] = (ans[2 * v] + ans[2 * v + 1]) % mod;
}
long long query(int L, int R, int v = 1, int l = 1, int r = n + 1) {
shift(v, l, r);
if (r <= L or R <= l) return (0);
if (L <= l and r <= R) return (ans[v]);
int mid = (l + r) / 2;
return ((query(L, R, 2 * v, l, mid) + query(L, R, 2 * v + 1, mid, r)) % mod);
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
pw[0] = 1;
for (int i = 1; i < maxn; i++) pw[i] = 1LL * pw[i - 1] * 2 % mod;
cin >> n >> q;
while (q--) {
int t, l, r, x;
cin >> t >> l >> r;
if (t == 1) {
cin >> x;
auto L = st[x].lower_bound({l, 0}), R = st[x].upper_bound({r, n});
if (L != st[x].begin()) {
L--;
if ((*L).second < l) L++;
}
vector<pair<int, int> > q;
for (auto it = L; it != R; it = st[x].erase(it)) q.push_back(*it);
if (q.empty()) {
update(l, r + 1, 1);
st[x].insert({l, r});
continue;
}
int cur = l;
int LL = l, RR = r;
for (auto [a, b] : q) {
if (a > cur) update(cur, a, 1), cur = a;
LL = min(LL, a), RR = max(RR, b);
update(cur, min(r, b) + 1, 0);
cur = min(r, b) + 1;
st[x].erase({a, b});
}
if (q.back().second < r) update(cur, r + 1, 1);
st[x].insert({LL, RR});
} else {
cout << query(l, ++r) << '\n';
}
}
return (0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x, y, z = 0, ans, n;
cin >> x >> y >> n;
z = y - x;
switch ((n - 1) % 6) {
case 0:
ans = x;
break;
case 1:
ans = y;
break;
case 2:
ans = z;
break;
case 3:
ans = (-1) * x;
break;
case 4:
ans = (-1) * y;
break;
case 5:
ans = (-1) * z;
break;
}
if (ans < 0)
while (ans < 0) ans += 1000000007;
else
ans %= 1000000007;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
int main() {
int n, m, t;
cin >> n >> m >> t;
vector<string> v(n);
for (int __i = 0; __i < (n); ++__i) cin >> v[__i];
;
vector<int> ans(m);
for (int j = (0); j < (m); ++j) {
for (int i = (0); i < (n); ++i) {
ans[j] += v[i][j] == 'Y';
}
}
int res = 0;
for (int j = (0); j < (m); ++j) {
res += ans[j] >= t;
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 0, k = 1;
cin >> n;
vector<int> s1;
set<int> s2;
for (int i = 0; i < 2 * n; ++i) {
string s;
cin >> s;
if (s == "add") {
int j;
cin >> j;
s1.push_back(j);
s2.insert(j);
} else {
if (!s1.empty() && s1.back() != k) {
++m;
s1.clear();
} else if (!s1.empty() && s1.back() == k)
s1.pop_back();
s2.erase(k);
++k;
}
}
printf("%d\n", m);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
string s1;
long long a2;
cin >> a2 >> s1;
vector<long long> inp;
for (int i = 0; i < s1.size(); i++) {
int z = s1[i] - '0';
inp.push_back(z);
}
unordered_map<long long, long long> um;
vector<long long> psums;
psums.push_back(0);
for (int i = 0; i < inp.size(); i++) {
long long t = psums.back() + inp[i];
psums.push_back(t);
}
long long tot = 0;
for (int i = 0; i < psums.size(); i++) {
for (int j = i + 1; j < psums.size(); j++) {
tot++;
long long t = psums[j] - psums[i];
if (um.count(t) > 0)
um[t] = um[t] + 1;
else
um[t] = 1;
}
}
long long sum = 0;
for (int i = 0; i < psums.size(); i++) {
for (int j = i + 1; j < psums.size(); j++) {
long long t = psums[j] - psums[i];
if (t != 0 && a2 % t == 0) {
long long d = a2 / t;
if (um.count(d) != 0) sum += um[d];
} else if (t == 0) {
if (a2 == 0) sum += tot;
}
}
}
cout << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long su(long long int* arr, int a, int b) {
long long sum = 0;
for (int i = a - 1; i <= b - 1; i++) {
sum = sum + arr[i];
}
return sum;
}
int main() {
int n, m;
cin >> n >> m;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long t = 0;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (su(a, x, y) > 0) {
t = t + su(a, x, y);
}
}
cout << t << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)2e5 + 20;
int n;
map<int, int> mp;
char str[1000005];
int cnt[26];
void work() {
scanf("%d", &n);
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%s", str);
int m = strlen(str);
memset(cnt, 0, sizeof(cnt));
int sta = 0;
for (int j = 0; j < m; j++) {
int x = str[j] - 'a';
sta ^= 1 << x;
}
ans += mp[sta];
mp[sta]++;
for (int j = 0; j < 26; j++) {
sta ^= 1 << j;
ans += mp[sta];
sta ^= 1 << j;
}
}
cout << ans << endl;
}
int main() {
work();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e3 + 10;
int n, m, dist[maxn][maxn], sti, stj, pi, pj;
bool mark[maxn][maxn];
char num[maxn][maxn];
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, 1, 0, -1};
bool ok(int i, int j) {
if (i < 0 || j < 0) return false;
if (i >= n || j >= m) return false;
return true;
}
void BFS() {
queue<pair<int, int> > q;
q.push(make_pair(sti, stj));
dist[sti][stj] = 0;
while (!q.empty()) {
pair<int, int> t = q.front();
q.pop();
mark[t.first][t.second] = true;
for (int i = 0; i < 4; i++) {
if (!mark[t.first + di[i]][t.second + dj[i]] &&
ok(t.first + di[i], t.second + dj[i])) {
dist[t.first + di[i]][t.second + dj[i]] = dist[t.first][t.second] + 1;
mark[t.first + di[i]][t.second + dj[i]] = true;
q.push(make_pair(t.first + di[i], t.second + dj[i]));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
dist[i][j] = ((~0) ^ (1 << 31));
cin >> num[i][j];
if (num[i][j] == 'T') {
mark[i][j] = true;
}
if (num[i][j] == 'E') {
sti = i;
stj = j;
}
if (num[i][j] == 'S') {
pi = i;
pj = j;
}
}
BFS();
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (dist[i][j] <= dist[pi][pj] && (i != pi || j != pj) &&
num[i][j] != 'E') {
ans += num[i][j] - '0';
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int i, a = 0, d = 0, n;
scanf("%d", &n);
char ch;
for (i = 0; i < n; i++) {
scanf(" %c", &ch);
if (ch == 'A')
a++;
else if (ch == 'D')
d++;
}
if (a > d)
printf("Anton\n");
else if (a < d)
printf("Danik\n");
else
printf("Friendship\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100004;
long long int a[MAXN];
long long int k, n;
vector<long long int> b(MAXN, 0);
long long int f(double num) {
long long int res = 0;
for (int i = 0; i < n; i++) {
if (num > a[i] + 0.25) {
b[i] = 0;
continue;
}
double tem = sqrt(12 * (a[i] - num) - 3);
b[i] = (long long int)(tem / 6 + 0.5);
if (b[i] > a[i]) b[i] = a[i];
res += b[i];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
double mid;
double lo = -3e18, hi = 1e9;
for (int i = 0; i < 200; i++) {
mid = (lo + hi) / 2;
if (f(mid) >= k)
lo = mid;
else
hi = mid;
}
long long int tot = 0;
priority_queue<pair<long long int, int>, vector<pair<long long int, int> >,
greater<pair<long long int, int> > >
pq;
priority_queue<pair<long long int, int> > pq1;
for (int i = 0; i < n; i++) {
double tem = sqrt(12 * (a[i] - lo) - 3);
b[i] = min((long long int)(tem / 6 + 0.5), a[i]);
tot += b[i];
if (b[i]) pq.push({a[i] - 3 * b[i] * b[i] + 3 * b[i] - 1, i});
if (b[i] != a[i]) pq1.push({a[i] - 3 * b[i] * b[i] - 3 * b[i] - 1, i});
}
while (tot - k > 0) {
pair<long long int, int> tem = pq.top();
pq.pop();
int i = tem.second;
b[i]--;
tem.first = a[i] - 3 * b[i] * b[i] + 3 * b[i] - 1;
pq.push(tem);
tot--;
}
for (int i = 0; i < n; i++) {
int bu = b[i];
printf("%d ", bu);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int d[1000005];
int main() {
long long k = 0, mod = 1073741824LL;
int a, b, c;
memset(d, 0, sizeof(d));
for (int i = 1; i <= 1000000; i++) {
for (int j = 1; j * i <= 1000000; j++) d[i * j]++;
}
cin >> a >> b >> c;
for (int i = 1; i <= a; i++)
for (int j = 1; j <= b; j++)
for (int z = 1; z <= c; z++) k += d[i * j * z], k %= mod;
cout << k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = numeric_limits<long long>::max();
const long long nax = (long long)(100001);
const long long mod = 1e9 + 7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
cout << ((n - k < 0 || (n - k) & 1LL || ((n - k) >> 1) & k)
? 0
: (1LL << __builtin_popcountll(k)) - 2 * (n == k));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int start = 0, ends = n - 1;
while (start != ends) {
if (arr[ends] < arr[start]) {
reverse(arr + start, arr + ends + 1);
break;
} else if (ends == n && arr[ends] > arr[ends - 1]) {
ends--;
start++;
} else if (arr[ends] < arr[ends + 1] && arr[ends] < arr[ends - 1]) {
if (arr[ends] > arr[start]) {
start++;
ends++;
}
} else if (arr[ends] > arr[ends + 1] && arr[ends] < arr[ends - 1]) {
ends++;
start++;
}
ends--;
}
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
cout << "no";
return 0;
}
}
cout << "yes" << endl
<< min(ends + 1, start + 1) << " " << max(ends + 1, start + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.0);
const double EPS = 1e-12;
void combination(long long com[][1005]) {
com[0][0] = 1;
int sz = 1000;
for (int i = 1; i <= sz; i++) {
com[i][0] = 1;
for (int j = 1; j <= i; j++) {
com[i][j] = com[i - 1][j] + com[i - 1][j - 1];
com[i][j] = com[i][j] % 1000000007;
}
}
}
int find_par(int cn) {}
int gcd(int u, int v) {
if (v == 0) return u;
return gcd(v, u % v);
}
void insert_ind(int cs, int ci, int s, int e) {
if (s == e) {
return;
}
int mid = (s + e) / 2;
if (ci <= mid)
insert_ind(2 * cs, ci, s, mid);
else
insert_ind(2 * cs + 1, ci, mid + 1, e);
}
void update_ind(int cs, int ci, int s, int e, int val) {
if (s == e) {
return;
}
int mid = (s + e) / 2;
if (ci <= mid)
update_ind(2 * cs, ci, s, mid, val);
else
update_ind(2 * cs + 1, ci, mid + 1, e, val);
}
void update_seg(int cs, int ds, int de, int s, int e, int val) {
if (ds == s && de == e) {
return;
}
int mid = (s + e) / 2;
if (ds <= mid) update_seg(2 * cs, ds, min(mid, de), s, mid, val);
if (de > mid) update_seg(2 * cs + 1, max(mid + 1, ds), de, mid + 1, e, val);
}
void pattern_match(char pat[], const int len, int pi[]) {
pi[1] = 0;
for (int i = 2; i <= len; i++) {
int st = i - 1;
while (st >= 0 && pat[pi[st] + 1] != pat[i]) st = pi[st];
if (st == 0)
pi[i] = 0;
else
pi[i] = pi[st] + 1;
}
}
void pattern_match(char pat[], int pi[], char tar[], const int len1, int gi[]) {
if (pat[0] == tar[0]) gi[0] = 1;
for (int i = 1; i < len1; i++) {
int st = gi[i - 1];
while (pat[st] != tar[i]) {
if (st == 0) {
st = -1;
break;
}
st = pi[st - 1];
}
if (st == -1)
gi[i] = 0;
else
gi[i] = st + 1;
}
}
struct myArray {
int mat[10][10];
};
myArray matrix_mul(myArray mat1, myArray mat2, const int sz) {
int tmp[sz][sz];
memset((tmp), 0, sizeof((tmp)));
for (int r = 0; r < sz; r++)
for (int c = 0; c < sz; c++)
for (int cr = 0; cr < sz; cr++)
tmp[r][c] += mat1.mat[r][cr] * mat2.mat[c][cr];
myArray res;
for (int r = 0; r < sz; r++)
for (int c = 0; c < sz; c++) res.mat[r][c] = tmp[r][c];
return res;
}
myArray unit_matrix(const int sz) {
myArray ma;
memset((ma.mat), 0, sizeof((ma.mat)));
for (int i = 0; i < sz; i++) ma.mat[i][i] = 1;
return ma;
}
myArray matrix_expo(int p, myArray mat, const int sz) {
if (p == 0) {
return unit_matrix(sz);
}
if (p & 1) return matrix_mul(mat, matrix_expo(p - 1, mat, sz), sz);
myArray tmp = matrix_expo(p >> 1, mat, sz);
return matrix_mul(tmp, tmp, sz);
}
int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};
int n, m;
vector<pair<int, int> > first, sec;
bool couple[2005][2005];
bool can(int t) {
vector<pair<int, pair<int, int> > > f, s, ff, ss;
for (int i = 0; i < first.size(); i++) {
int x = first[i].first, y = first[i].second;
f.push_back(make_pair(x + y, make_pair(x - y - 2 * t, x - y + 2 * t)));
}
for (int i = 0; i < sec.size(); i++) {
int x = sec[i].first;
int y = sec[i].second;
s.push_back(make_pair(x - y, make_pair(x + y - 2 * t, x + y + 2 * t)));
}
sort(s.begin(), s.end());
sort(f.begin(), f.end());
for (int i = 0; i < f.size(); i++) {
int m = f[i].first;
int l = f[i].second.first;
int h = f[i].second.second;
int j = i + 1;
while (j < f.size() && f[i].first == f[j].first) {
if (h >= f[j].second.first) {
h = f[j].second.second;
} else {
ff.push_back(make_pair(m, make_pair(l, h)));
m = f[j].first;
l = f[j].second.first;
h = f[j].second.second;
}
j++;
}
ff.push_back(make_pair(m, make_pair(l, h)));
i = j - 1;
}
for (int i = 0; i < s.size(); i++) {
int j = i + 1;
int m = s[i].first;
int l = s[i].second.first;
int h = s[i].second.second;
while (j < s.size() && s[i].first == s[j].first) {
if (h >= s[j].second.first)
h = s[j].second.second;
else {
ss.push_back(make_pair(m, make_pair(l, h)));
m = s[j].first;
l = s[j].second.first;
h = s[j].second.second;
}
j++;
}
ss.push_back(make_pair(m, make_pair(l, h)));
i = j - 1;
}
memset((couple), false, sizeof((couple)));
for (int i = 0; i < ss.size(); i++) {
vector<int> v;
for (int j = 0; j < ff.size(); j++) {
if (ss[i].first >= ff[j].second.first &&
ss[i].first <= ff[j].second.second)
if (ff[j].first >= ss[i].second.first &&
ff[j].first <= ss[i].second.second) {
for (int k = 0; k < v.size(); k++) {
if (couple[j][v[k]]) return true;
couple[j][v[k]] = couple[v[k]][j] = true;
}
v.push_back(j);
}
}
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
first.push_back(make_pair(u, v));
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
sec.push_back(make_pair(u, v));
}
int l = 0, h = (1 << 20);
int ans = -1;
while (l <= h) {
int m = (l + h) / 2;
if (can(m)) {
ans = m;
h = m - 1;
} else
l = m + 1;
}
if (ans == -1)
cout << "Poor Sereja!\n";
else
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
ll n, m;
cin >> n >> m;
ll a[n][m];
for (ll i = 0; i < n; i++)
for (ll j = 0; j < m; j++) cin >> a[i][j];
ll ans;
for (int i = n - 1; i > 0; i--) {
for (int j = m - 1; j > 0; j--) {
if (a[i][j] == 0) {
vector<ll> b(4);
ans = 0;
b[0] = a[i - 1][j] + 1;
b[1] = a[i][j - 1] + 1;
b[2] = a[i][j + 1] - 1;
b[3] = a[i + 1][j] - 1;
for (ll z = 0; z < 4; z++) {
if (a[i][j + 1] == 0 && a[i + 1][j] == 0) {
if (b[z] > a[i][j - 1] && b[z] > a[i - 1][j]) {
ans = max(b[z], ans);
}
} else if (a[i][j + 1] == 0) {
if (b[z] > a[i][j - 1] && b[z] > a[i - 1][j] &&
b[z] < a[i + 1][j]) {
ans = max(b[z], ans);
}
} else if (a[i + 1][j] == 0) {
if (b[z] > a[i][j - 1] && b[z] > a[i - 1][j] &&
b[z] < a[i][j + 1]) {
ans = max(b[z], ans);
}
} else {
if (b[z] > a[i][j - 1] && b[z] > a[i - 1][j] &&
b[z] < a[i][j + 1] && b[z] < a[i + 1][j]) {
ans = max(b[z], ans);
}
}
}
if (ans == 0) {
cout << -1;
exit(0);
} else {
a[i][j] = ans;
}
}
}
}
ans = 0;
ll chk = 0;
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m - 1; j++) {
if (a[i][j] >= a[i][j + 1]) {
chk = 1;
}
ans += a[i][j];
}
ans += a[i][m - 1];
}
for (ll i = 0; i < m; i++) {
for (ll j = 0; j < n - 1; j++) {
if (a[j][i] >= a[j + 1][i]) {
chk = 1;
}
}
}
if (chk)
cout << -1;
else
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5, mod = 998244353;
int n, lim[N];
long long f[N], fac[N], inv[N], a[N];
void init() {
fac[0] = 1;
for (int i = 1; i < N; ++i) fac[i] = fac[i - 1] * i % mod;
inv[0] = inv[1] = 1;
for (int i = 2; i < N; ++i) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i < N; ++i) inv[i] = inv[i - 1] * inv[i] % mod;
}
long long A(int d, int u) {
if (u < 0 || u > d) return 0;
return fac[d] * inv[d - u] % mod;
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j) {
if (a[j] * 2 <= a[i])
lim[i] = j;
else
break;
}
f[0] = 1;
lim[0] = -1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= lim[i]; ++j)
f[i] = (f[i] + f[j] * A(n - lim[j] - 2, lim[i] - lim[j] - 1) % mod) % mod;
printf("%lld\n", lim[n] == n - 1 ? f[n] : 0);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int num[1000];
int main() {
int n;
scanf("%d", &n);
int ans = 0, cnt = 0;
while (n > 0) {
num[cnt++] = n % 8;
n /= 8;
}
for (int i = 0; i < cnt; i++) {
if (num[i] == 1) ans++;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k;
cin >> k;
int out = k;
for (int i = 0; i < n; i++) {
int ai;
cin >> ai;
if (k % ai == 0 and k / ai < out) {
out = k / ai;
}
}
cout << out << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5;
long long pr[maxn];
vector<long long> g[maxn];
long long tin[maxn];
long long tout[maxn];
long long timer = 0;
const long long mx = 20;
long long pred[maxn][mx];
bool used[maxn];
vector<long long> euler;
pair<long long, long long> t[maxn * 4 * 2];
void make_set(long long n) {
for (long long i = 0; i < n; ++i) {
pr[i] = i;
}
}
long long find_set(long long v) {
if (pr[v] == v) return v;
return pr[v] = find_set(pr[v]);
}
void unic(long long a, long long b) {
a = find_set(a);
b = find_set(b);
pr[a] = b;
}
void dfs(long long v, long long p) {
euler.push_back(v);
tin[v] = timer++;
pred[v][0] = p;
used[v] = true;
for (long long j = 1; j < mx; ++j) {
pred[v][j] = pred[pred[v][j - 1]][j - 1];
}
for (long long i = 0; i < g[v].size(); ++i) {
long long to = g[v][i];
if (to == p) continue;
dfs(to, v);
}
tout[v] = timer++;
euler.push_back(v);
}
bool ispredok(long long fath, long long son) {
return tin[fath] <= tin[son] && tout[fath] >= tout[son];
}
long long lca(long long a, long long b) {
if (ispredok(a, b)) return a;
if (ispredok(b, a)) return b;
for (long long i = mx - 1; i >= 0; --i) {
if (!ispredok(pred[a][i], b)) {
a = pred[a][i];
}
}
return pred[a][0];
}
void upd(long long v, long long tl, long long tr, long long pos,
pair<long long, long long> val) {
if (tl == tr) {
t[v].first += val.first;
t[v].second += val.second;
} else {
long long tm = (tl + tr) / 2;
if (pos <= tm) {
upd(v * 2, tl, tm, pos, val);
} else {
upd(v * 2 + 1, tm + 1, tr, pos, val);
}
t[v] = {t[v * 2].first + t[v * 2 + 1].first,
t[v * 2].second + t[v * 2 + 1].second};
}
}
pair<long long, long long> get(long long v, long long tl, long long tr,
long long l, long long r) {
if (tl > r || tr < l) {
return {0, 0};
}
if (l <= tl && tr <= r) {
return t[v];
}
long long tm = (tl + tr) / 2;
auto a1 = get(v * 2, tl, tm, l, r);
auto a2 = get(v * 2 + 1, tm + 1, tr, l, r);
return {a1.first + a2.first, a1.second + a2.second};
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
long long n, q;
cin >> n >> q;
make_set(n);
vector<pair<pair<long long, long long>, long long>> qw(q);
for (long long i = 0; i < q; ++i) {
long long u, v, x;
cin >> u >> v >> x;
u--;
v--;
qw[i] = {{u, v}, x};
if (find_set(u) == find_set(v)) {
continue;
} else {
g[u].push_back(v);
g[v].push_back(u);
unic(u, v);
}
}
for (long long k = 0; k < n; ++k) {
if (used[k]) continue;
dfs(k, k);
}
for (long long j = 0; j < q; ++j) {
long long u = qw[j].first.first;
long long v = qw[j].first.second;
long long x = qw[j].second;
long long l = lca(u, v);
if (pred[u][0] == v) {
cout << "YES\n";
long long tmp = 1;
if (x == 0) tmp = 0;
upd(1, 0, 2 * n - 1, tin[u], {tmp, 0});
upd(1, 0, 2 * n - 1, tout[u], {-tmp, 0});
continue;
}
if (pred[v][0] == u) {
cout << "YES\n";
long long tmp = 1;
if (x == 0) tmp = 0;
upd(1, 0, 2 * n - 1, tin[v], {tmp, 0});
upd(1, 0, 2 * n - 1, tout[v], {-tmp, 0});
continue;
}
auto o1 = get(1, 0, 2 * n - 1, 0, tin[u]);
auto o2 = get(1, 0, 2 * n - 1, 0, tin[v]);
auto o3 = get(1, 0, 2 * n - 1, 0, tin[l]);
long long s1 = o1.first + o2.first - o3.first * 2;
long long s2 = o1.second + o2.second - o3.second * 2;
if ((s1 + x) % 2 == 0) {
cout << "NO\n";
continue;
}
if (s2 > 0) {
cout << "NO\n";
continue;
}
cout << "YES\n";
while (v != l) {
long long tmp = 1;
upd(1, 0, 2 * n - 1, tin[v], {0, tmp});
upd(1, 0, 2 * n - 1, tout[v], {0, -tmp});
v = pred[v][0];
}
while (u != l) {
long long tmp = 1;
upd(1, 0, 2 * n - 1, tin[u], {0, tmp});
upd(1, 0, 2 * n - 1, tout[u], {0, -tmp});
u = pred[u][0];
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > letters[26];
vector<string> grid;
bool visited[200][200];
int main() {
string in;
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
cin >> in;
grid.push_back(in);
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long int ti, tj;
ti = i;
tj = j;
for (long long int k = 0; k < m; k++) {
if (grid[ti][tj] == grid[ti][k] && k != tj) {
if (visited[ti][k] == false) {
tj = k;
visited[ti][k] = true;
}
visited[ti][tj] = true;
}
}
ti = i;
tj = j;
for (long long int k = 0; k < n; k++) {
if (grid[ti][tj] == grid[k][tj] && k != ti) {
if (visited[k][tj] == false) {
ti = k;
visited[k][tj] = true;
}
visited[ti][tj] = true;
}
}
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (visited[i][j] == false) cout << grid[i][j];
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
scanf("%lld", &n);
vector<long long> arr(n);
long long e = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
if (i % 2 == 0) e += arr[i];
}
long long mx = 0;
vector<long long> diff;
long long t = 0;
for (int i = 1; i < n; i += 2) {
diff.push_back(arr[i] - arr[i - 1]);
}
for (int i = 0; i < int(diff.size()); i++) {
t += diff[i];
mx = max(mx, t);
if (t < 0) t = 0;
}
mx = max(mx, t);
t = 0;
diff.resize(0);
for (int i = 2; i < n; i += 2) {
diff.push_back(arr[i - 1] - arr[i]);
}
for (int i = 0; i < int(diff.size()); i++) {
t += diff[i];
mx = max(mx, t);
if (t < 0) t = 0;
}
mx = max(mx, t);
cout << e + mx;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool graph[110][110];
int main() {
cin >> n;
memset(graph, 0, sizeof(graph));
int current = 0;
for (int i = 0; i < 100; i++) {
for (int j = 0; j < i; j++) {
if (!graph[j][i]) {
int counter = 0;
for (int k = 0; k < i; k++) {
if (graph[j][k] && graph[k][i]) counter++;
}
if (current + counter <= n) {
current += counter;
graph[j][i] = graph[i][j] = true;
}
}
}
}
cout << 100 << endl;
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) cout << graph[i][j];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
bool rak;
vector<string> v;
vector<string> book[25];
set<string> co;
string s, x;
bool suff(string x, string y) {
while (y.size() > x.size()) y.erase(0, 1);
if (x == y) return true;
return false;
}
void kencr(string x, int t) {
if (book[t].size() == 0)
book[t].push_back(x);
else {
rak = false;
for (int i = 0; i < book[t].size(); i++) {
if (suff(book[t][i], x)) {
book[t][i] = x;
rak = true;
}
if (suff(x, book[t][i])) rak = true;
}
if (!rak) book[t].push_back(x);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
if (co.count(s) == 0) {
co.insert(s);
v.push_back(s);
}
t = 0;
while (v[t] != s) t++;
cin >> m;
for (int j = 0; j < m; j++) {
cin >> x;
kencr(x, t);
}
}
cout << co.size() << endl;
for (int i = 0; i < co.size(); i++) {
cout << v[i] << " " << book[i].size() << " ";
for (int j = 0; j < book[i].size(); j++) cout << book[i][j] << " ";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, h, k;
cin >> n >> h >> k;
vector<int> pota;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
pota.push_back(x);
}
long long cur_h = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (cur_h + pota[i] <= h) {
cur_h += pota[i];
} else {
ans++;
cur_h = pota[i];
}
ans += cur_h / k;
cur_h = cur_h % k;
}
ans += cur_h / k;
cur_h = cur_h % k;
ans += (cur_h == 0) ? 0 : 1;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> arrN(n);
for (int i = 0; i < n; i++) {
cin >> arrN[i];
}
int m;
cin >> m;
vector<int> arrM(m);
for (int i = 0; i < m; i++) {
cin >> arrM[i];
}
map<int, int> mp;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (arrM[i] % arrN[j] == 0) mp[arrM[i] / arrN[j]]++;
}
}
auto it = --mp.end();
cout << it->second << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, y, flag;
cin >> p >> y;
for (int i = y; i > p; i--) {
flag = 0;
for (int j = 2; j <= min(p, 100000); j++) {
if (i % j == 0) {
flag = 1;
}
}
if (flag != 1) {
cout << i << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, d, v, g, r, tmu;
double tm, tmod;
scanf("%d%d%d%d%d", &l, &d, &v, &g, &r);
tmu = (int)((long double)(d / v) / (g + r));
tmod = (double)d / v - tmu * (g + r);
if (tmod < g)
tm = (double)l / v;
else
tm = (double)l / v + (r - tmod + g);
printf("%.8f\n", tm);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
long long x = 1, ans = 0;
int n, k;
char S[maxn], T[maxn];
int st = 0;
int main() {
scanf("%d%d", &n, &k);
scanf("%s%s", S + 1, T + 1);
for (int i = 1; i <= n; i++) {
if (!st && S[i] != T[i]) {
st = 1;
}
if (!st)
ans++;
else {
x = x * 2;
if (S[i] == 'b') --x;
if (T[i] == 'a') --x;
if (x > k) {
ans += 1ll * (n - i + 1) * k;
break;
}
ans += x;
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int i, n, sin = 0, m, j, k = 0, cnt = 0, a[101], b[101], c[101];
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
}
for (i = 1; i <= m; i++) {
sin = 0;
for (j = 0; j < n; j++) {
if (a[j] <= i && b[j] >= i) {
sin = 1;
}
}
if (sin == 0) {
cnt++;
c[k++] = i;
}
}
printf("%d\n", cnt);
for (i = 0; i < cnt; i++) {
printf("%d ", c[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string Number, integer = "", fraction = "";
cin >> Number;
int dpos = -1;
for (int i = Number.length() - 1; i >= 0; i--) {
if (Number[i] == '.') {
dpos = i;
fraction += Number[dpos + 1];
if (Number.length() - i >= 3) {
fraction += Number[dpos + 2];
} else
fraction += '0';
break;
}
}
if (dpos == -1) {
fraction += '0';
fraction += '0';
dpos = Number.length();
}
bool minus = false;
int cnt = 0;
for (int i = dpos - 1; i >= 0; i--) {
if (Number[i] != '-') {
integer += Number[i];
cnt++;
} else
minus = true;
if (cnt == 3 && i != 0 && (i > 0 && Number[i - 1] != '-')) {
integer += ',';
cnt = 0;
}
}
reverse(integer.begin(), integer.end());
if (minus) cout << "(";
cout << "$";
cout << integer << "." << fraction;
if (minus) cout << ")";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int sp[2][1010];
int x[110], y[110];
int n, m;
inline void add(int& a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
int comb[1010][1010];
int main() {
for (int i(0); i <= 1000; i++) comb[i][0] = 1;
for (int i(1); i <= 1000; i++)
for (int j(1); j <= 1000; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007;
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i(1); i <= n; i++) {
cin >> x[i];
m += x[i];
}
for (int i(1); i <= n; i++) cin >> y[i];
int ans(1);
for (int i(1), mact(m); i <= n; mact -= x[i], i++) {
ans = 1ll * ans * comb[mact][x[i]] % 1000000007;
}
sp[0][0] = 1;
for (int i(1); i <= n; i++) {
for (int j(0); j <= m; j++) {
sp[(1 & i)][j] = 0;
for (int jos(0); jos <= y[i]; jos++) {
int from = j - x[i] + jos;
if (from < 0 || from > m) continue;
add(sp[(1 & i)][j], 1ll * sp[(1 - (1 & i))][from] *
comb[from + x[i]][jos] % 1000000007);
}
}
}
cout << 1ll * ans * (sp[(1 & n)][0] + 1000000007) % 1000000007;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, x[100009], y[100009], j = 0, t1 = 0, t2 = 0;
string second, s1, s2;
bool isnum(string a) {
if (a[0] == '0' && a.length() > 1) return 0;
if (a.length() == 0) return 0;
for (int(i) = 0; i < (a.length()); i++) {
if (!(a[i] >= 48 && a[i] < 58)) return 0;
}
return 1;
}
int main() {
cin >> second;
x[j] = 0;
s1 += '\"';
s2 += '\"';
for (int(i) = 0; i < (second.length()); i++)
if (second[i] == ';' || second[i] == ',') {
y[j] = i - 1;
j++;
x[j] = i + 1;
}
y[j] = second.length() - 1;
for (int(i) = 0; i < (j + 1); i++)
if (isnum(second.substr(x[i], y[i] - x[i] + 1))) {
if (t1 != 0) s1 += ',';
t1++;
s1 += second.substr(x[i], y[i] - x[i] + 1);
} else {
if (t2 != 0) s2 += ',';
t2++;
s2 += second.substr(x[i], y[i] - x[i] + 1);
}
s1 += '\"';
s2 += '\"';
if (t1 == 0) s1 = "-";
if (t2 == 0) s2 = "-";
cout << s1 << endl << s2;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (a != 0) {
int c = a;
a = b % a;
b = c;
}
return b;
}
vector<int> adj[3000];
vector<int> getAllDivisors(int num) {
vector<int> divs;
int square_root = (int)sqrt(num) + 1;
for (int i = 1; i < square_root; i++) {
if (num % i == 0) {
if (i * i != num) {
divs.push_back(i);
}
divs.push_back(num / i);
}
}
return divs;
}
class ChangingChange {
public:
};
long long int mod_pow(long x, int y) {
long long int r = 1;
while (y > 0) {
if (y % 2 == 1) {
r = (r * x) % (1000000007);
}
x = (x * x) % (1000000007);
y /= 2;
}
return r;
}
int main() {
ChangingChange temp;
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
vector<int> arr;
cin >> n;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
arr.push_back(temp);
}
int moves = 0;
int GCD = arr[0];
for (int i = 1; i < n; i++) {
GCD = gcd(GCD, arr[i]);
}
if (GCD > 1) {
cout << "YES" << '\n' << moves;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if ((arr[i] % 2 == 1) && (arr[i + 1] % 2 == 1)) {
arr[i] = 2, arr[i + 1] = 2;
moves++;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] % 2) {
moves += 2;
}
}
cout << "YES" << '\n' << moves;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool notPrime[1003] = {};
vector<int> l;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 2; i <= n; i++) {
int k = i;
if (!notPrime[i]) {
while (k <= n) {
l.push_back(k);
k *= i;
}
for (int j = i + i; j <= n; j += i) notPrime[j] = true;
}
}
cout << l.size() << '\n';
for (int i = 0; i < l.size(); i++) cout << l[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[600][600];
long long waysnum(long long mod, long long zero, long long one, long long m) {
bool check = true;
if (m == 0) {
if (zero == 0 && one == 0)
return 1;
else
return 0;
}
long long co = 0;
if (dp[zero][one] != -1) return dp[zero][one];
if (zero > 0 && one > 0) {
check = false;
co += ((waysnum(mod, zero - 1, one, m - 1) * zero * one)) % mod;
}
if (zero > 1) {
check = false;
co += ((waysnum(mod, zero - 2, one + 2, m - 1) *
((zero * zero - zero) / 2))) %
mod;
}
if (one > 1) {
check = false;
co +=
((waysnum(mod, zero, one - 2, m - 1) * ((one * one - one) / 2))) % mod;
}
if (check) return 0;
return dp[zero][one] = co % mod;
}
char ch[600][600];
int a[600];
int main() {
for (long long int i = 0; i < 600; i++)
for (long long int j = 0; j < 600; j++) dp[i][j] = -1;
long long int n, m, mod;
cin >> n >> m >> mod;
for (long long int j = 0; j < m; j++)
for (long long int i = 0; i < n; i++) {
cin >> ch[i][j];
if (ch[i][j] == '1') a[i]++;
}
long long int zero = 0;
long long int one = 0;
for (long long int i = 0; i < n; i++) {
if (a[i] == 1)
one++;
else if (a[i] == 0)
zero++;
}
cout << waysnum(mod, zero, one, n - m);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
bitset<201> t;
map<long long, bitset<201>> f;
long long n, m, ans = 0, c;
cin >> n >> m;
long long a[n], b[m];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) {
cin >> b[i];
for (long long j = 0; j < n; j++) {
f[b[i] + a[j]][j] = 1;
f[b[i] + a[j]][i + 100] = 1;
}
}
for (auto it : f) {
for (auto it2 : f) {
t = (it.second | it2.second);
c = t.count();
ans = max(ans, c);
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long suma = 0, sumg = 0;
string ans = "";
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
if ((suma + a - sumg) <= 500) {
suma += a;
ans += "A";
} else {
sumg += b;
ans += "G";
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define erorp(x) cout<<#x<<"={"<<(x.F)<<" , "<<x.S<<"}"<<endl;
#define print(v,r) f(i,0,r) cout<<v[i]<<" "; cout<<endl;
#define Get(x,y) scanf("%I64d%I64d",&x,&y);
#define is_bit(x,y) (x%(1<<(y+1))>=(1<<y))
#define eror(x) cout<<#x<<'='<<(x)<<endl;
#define f_(i,a,b) for(int i=a;i>=b;i--)
#define Gett(x,y) scanf("%d%d",&x,&y);
#define f(i,a,b) for(int i=a;i<b;i++)
#define get(x) scanf("%I64d",&x);
#define gett(x) scanf("%d",&x);
#define maxm(a,b) a=max(a,b);
#define minm(a,b) a=min(a,b);
#define Add(x,y) x=(x+y)%mod
#define lst(x) x[x.size()-1]
#define sz(x) int(x.size())
#define mp make_pair
#define ll long long
#define pb push_back
#define S second
#define F first
const int N=1e6+99;
int n,m,deg[N],x,mark[N],par[N],ans[N],s,t;
ll sum,a[N];
queue<int> q;
map<pair<int,int> ,int > edge;
vector<int> g[N];
void dfs1(int x){
mark[x]=1;
f(i,0,g[x].size())
if(!mark[g[x][i]]){
dfs1(g[x][i]);
par[g[x][i]]=x;
}
q.push(x);
}
int main(){
cin>>n>>m>>x;
f(i,1,n+1){ cin>>a[i]; sum+=a[i]; }
if(sum<1ll*(n-1)*x) return cout<<"NO",0;
f(i,0,m){
int u,v;
Gett(u,v);
g[u].pb(v);
g[v].pb(u);
edge[mp(u,v)]=i+1;
edge[mp(v,u)]=i+1;
}
dfs1(1);
t=n-2;
while(1){
int u=q.front();
q.pop();
if(u==1) break;
if(a[u]+a[par[u]]>=x){
ans[s++]=edge[mp(u,par[u])];
a[par[u]]+=a[u]-x;
}
else{
ans[t--]=edge[mp(u,par[u])];
}
}
cout<<"YES"<<endl;
f(i,0,n-1) cout<<ans[i]<<" ";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') x = x * 10 + (ch ^ 48), ch = getchar();
return x * f;
}
stack<long long> st;
long long a[200005], mn = 1e17, cnt, x, in[200005], tmp = 1, n, m, s[200005],
vis[200005];
signed main() {
n = read(), m = read();
a[0] = n + 1, vis[n + 1] = 1;
for (long long i = 1; i <= m; i++) {
in[i] = x = read();
vis[x]++;
a[++cnt] = x;
while (cnt && a[cnt] == tmp) cnt--, tmp++;
}
for (long long i = 1; i <= cnt; i++) {
if (a[i] < a[i - 1])
continue;
else {
printf("-1");
return 0;
}
}
for (long long i = 1; i <= m; i++) printf("%lld ", in[i]);
long long beg = 1;
while (beg <= n) {
for (; beg <= a[cnt]; beg++) {
if (!vis[beg]) st.push(beg);
}
cnt--;
while (st.size()) {
printf("%lld ", st.top());
st.pop();
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f\n", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++)) {
if (i != x.cbegin()) putchar(' ');
}
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
inline T bit(T x, int i) {
return (x >> i) & 1;
}
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
inline int two(int x) { return 1 << x; }
const int L = 70;
int l, dig[L];
int64_t dp[11][L][1 << 10];
int64_t go(int b, int pos, bool any, int msk) {
if (pos == -1) return msk == 0;
if (any) {
auto memo = dp[b][pos][msk];
if (memo != -1) return memo;
}
int64_t ans = 0;
int u = (any ? b - 1 : dig[pos]);
for (int i = (0); i <= int(u); i++)
ans += go(b, pos - 1, any || i < u, msk ^ two(i));
if (any) dp[b][pos][msk] = ans;
return ans;
}
void conv(int b, int64_t n) {
l = 0;
while (n) {
dig[l++] = n % b;
n /= b;
}
}
int64_t solve(int b, int64_t n) {
if (n == 0) return 0;
conv(b, n);
int64_t ans = 0;
for (int i = 0; i < int(l); i++) {
int u = (i == l - 1 ? dig[i] : b - 1);
for (int j = (1); j <= int(u); j++) {
int64_t now = go(b, i - 1, (i < l - 1 || j < u), two(j));
ans += now;
}
}
return ans;
}
int main() {
memset(dp, -1, sizeof(dp));
int q;
R(q);
while (q--) {
int b;
int64_t lb, rb;
R(b, lb, rb);
auto ans = solve(b, rb) - solve(b, lb - 1);
W(ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int y, b, r, m;
int main() {
scanf("%d%d%d", &y, &b, &r);
m = min(y, min(b - 1, r - 2));
if (m < 0) return puts("0"), 1;
printf("%d", m * 3 + 3);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int k;
cin >> k;
int clearLetters = 0;
bool snowflakePresent = false, candycanePresent = false;
int snowflakeCount = 0, candycaneCount = 0;
for (int i = 0; i < str.length(); ++i) {
if (str[i] >= 'a' && str[i] <= 'z') {
clearLetters++;
} else {
if (str[i] == '*') {
snowflakeCount++;
snowflakePresent = true;
} else {
candycanePresent = true;
candycaneCount++;
}
}
}
if (k > clearLetters && !snowflakePresent) {
cout << "Impossible\n";
} else if (k < clearLetters &&
(snowflakeCount + candycaneCount < (clearLetters - k))) {
cout << "Impossible\n";
} else {
bool flag = false;
if (k > clearLetters) {
for (int i = 0; i < str.length(); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
cout << str[i];
} else if (str[i] == '*' && !flag) {
for (int j = 0; j < (k - clearLetters); j++) {
cout << str[i - 1];
}
flag = true;
}
}
} else {
int toDelete = clearLetters - k;
vector<char> answer;
for (int i = 0; i < str.length(); ++i) {
if (str[i] >= 'a' && str[i] <= 'z') {
answer.push_back(str[i]);
} else {
if (toDelete) {
answer.pop_back();
toDelete--;
}
}
}
for (int i = 0; i < answer.size(); ++i) {
cout << answer[i];
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long T = 1;
while (T--) {
long long n, m;
cin >> n >> m;
string s;
cin >> s;
char a[3] = {'a', 'b', 'c'};
long long cost[6][n + 1];
memset(cost, 0, sizeof(cost));
long long k = 0;
do {
for (long long i = 0; i < n; i++) {
if (s[i] != a[i % 3]) {
cost[k][i + 1]++;
}
cost[k][i + 1] += cost[k][i];
}
k++;
} while (next_permutation(a, a + 3));
while (m--) {
long long l, r;
cin >> l >> r;
long long ans = 1e9;
for (long long i = 0; i < k; i++) {
ans = min(ans, cost[i][r] - cost[i][l - 1]);
}
cout << ans << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define REP(i, n) for(int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
#define _ << " "
#define ins(a, n, x) (a).insert((a).begin(), (n), (x));
#define popcnt __builtin_popcount
#define popcntll __builtin_popcountll
#define __ << "\n"
#define vt vector
typedef long long int ll;
typedef double lf;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <ll> vl;
const int mod = 1e9 + 7;
inline int add(int a, int b) {a += b; if(a >= mod) a-= mod; if(a < 0) a += mod; return a;}
inline int mult(int a, int b) {return (long long) a * b % mod;}
inline int pot(int a, int b) {int ret = 1; while(b){if(b & 1) ret = mult(ret, a); a = mult(a, a); b >>= 1;} return ret;}
inline int divide(int a, int b) {return mult(a, pot(b, mod - 2));}
inline ll raand() {return (ll)rand() * RAND_MAX + rand();}
inline ll raaand() {return raand() * (mod - 7) + raand();}
int gcd(int a, int b) {
if(!b) return a;
return gcd(b, a % b);
}
int main()
{
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, odg, soln = 1, solm = 1;
cin >> n >> m;
vt<vi> parn(n);
vt<vi> parm(m);
vt<bool> cann(n, 1);
vt<bool> canm(m, 1);
for(int i = n - 1; i; i--) {
if(n % i == 0) {
int siz = n;
for(int p : parn[i]) siz = gcd(siz, p);
bool yes = cann[i];
if(yes) {
int num_gr = siz / i;
int ex = 1;
while(ex <= num_gr) ex *= 2;
ex /= 2;
if(ex != num_gr) {
int howm = num_gr - ex;
cout << "? " << howm * i << " " << m << " 1 1 " << n - howm * i + 1 << " 1\n";
cout.flush();
cin >> odg;
if(!odg) yes = 0;
siz = i * ex;
}
if(yes) {
while(siz / i > 1) {
int help_siz = siz / i / 2;
cout << "? " << help_siz * i << " " << m << " 1 1 " << help_siz * i + 1 << " 1\n";
cout.flush();
cin >> odg;
if(!odg) {
yes = 0;
break;
}
siz = help_siz * i;
}
}
}
if(yes) {
soln++;
for(int j = 1; j < i; j++) {
if(i % j == 0) parn[j].pb(i);
}
}
else {
for(int j = 1; j < i; j++) {
if(i % j == 0) cann[j] = 0;
}
}
}
}
for(int i = m - 1; i; i--) {
if(m % i == 0) {
int siz = m;
for(int p : parm[i]) siz = gcd(siz, p);
bool yes = canm[i];
if(yes) {
int num_gr = siz / i;
int ex = 1;
while(ex <= num_gr) ex *= 2;
ex /= 2;
if(ex != num_gr) {
int howm = num_gr - ex;
cout << "? " << n << " " << howm * i << " 1 1 1 " << m - howm * i + 1 << "\n";
cout.flush();
cin >> odg;
if(!odg) yes = 0;
siz = i * ex;
}
if(yes) {
while(siz / i > 1) {
int help_siz = siz / i / 2;
cout << "? " << n << " " << i * help_siz << " 1 1 1 " << help_siz * i + 1 << "\n";
cout.flush();
cin >> odg;
if(!odg) {
yes = 0;
break;
}
if(siz / i % 2) {
cout << "? " << n << " " << i * help_siz << " 1 " << i + 1 << " 1 " << help_siz * i + i + 1 << "\n";
cout.flush();
cin >> odg;
if(!odg) {
yes = 0;
break;
}
}
siz = help_siz * i;
}
}
}
if(yes) {
solm++;
for(int j = 1; j < i; j++) {
if(i % j == 0) parm[j].pb(i);
}
}
else {
for(int j = 1; j < i; j++) {
if(i % j == 0) canm[j] = 0;
}
}
}
}
cout << "! " << soln * solm << endl;
cout.flush();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const long long MOD = 1000000007;
const double EBS = 1e-7;
int dX[] = {0, 0, 1, -1};
int dY[] = {1, -1, 0, 0};
const int logN = 20;
int dp[logN][N];
int depth[N], cnt[N], n, q;
vector<int> adj[N];
int dfs(int cur, int par) {
dp[0][cur] = par;
cnt[cur] = 1;
for (int i = 1; i < logN; ++i) dp[i][cur] = dp[i - 1][dp[i - 1][cur]];
for (auto x : adj[cur])
if (x != par) depth[x] = depth[cur] + 1, cnt[cur] += dfs(x, cur);
return cnt[cur];
}
int getKthAncestor(int u, int k) {
if (!k) return u;
int d = depth[u] - k;
for (int j = logN - 1; j >= 0; --j) {
int nu = dp[j][u];
if (!nu) continue;
if (depth[nu] == d)
return nu;
else if (depth[nu] > d && u)
u = nu;
}
return 0;
}
int getLCA(int a, int b) {
if (depth[a] > depth[b])
a = getKthAncestor(a, depth[a] - depth[b]);
else if (depth[b] > depth[a])
b = getKthAncestor(b, depth[b] - depth[a]);
if (a == b) return a;
for (int j = logN - 1; j >= 0; --j)
if (dp[j][b] != dp[j][a]) a = dp[j][a], b = dp[j][b];
return dp[0][a];
}
int main() {
scanf("%d", &n);
int x, y;
vector<pair<int, int> > Q;
for (int i = 1; i < n; ++i)
scanf("%d", &x), scanf("%d", &y), adj[x].push_back(y), adj[y].push_back(x);
dfs(1, 0);
scanf("%d", &q);
while (q--) {
scanf("%d", &x);
scanf("%d", &y);
if (x == y) {
printf("%d\n", n);
continue;
}
int lca = getLCA(x, y);
int len = depth[x] + depth[y] - 2 * depth[lca];
if (len & 1)
puts("0");
else {
int ans = 0;
if (x == lca)
ans = cnt[getKthAncestor(y, len / 2)] -
cnt[getKthAncestor(y, len / 2 - 1)];
else if (y == lca)
ans = cnt[getKthAncestor(x, len / 2)] -
cnt[getKthAncestor(x, len / 2 - 1)];
else {
int node = (depth[x] > depth[y] ? x : y);
int center = getKthAncestor(node, len / 2);
if (center == lca)
ans = n - cnt[getKthAncestor(x, len / 2 - 1)] -
cnt[getKthAncestor(y, len / 2 - 1)];
else
ans = (node == x ? cnt[center] - cnt[getKthAncestor(x, len / 2 - 1)]
: cnt[center] - cnt[getKthAncestor(y, len / 2 - 1)]);
}
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], x = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
x++;
}
}
if (x == n) {
cout << n - 1 << "\n";
} else {
int p = 0, m = 0;
for (int i = 0; i < n; i++) {
m = 0;
for (int j = i; j < n; j++) {
if (a[j] == 0) {
m++;
} else {
m--;
}
p = max(m, p);
}
}
cout << x + p << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
int alfa[26];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(alfa, 0, sizeof(alfa));
int nn;
cin >> nn;
string second;
cin >> second;
vector<int> ans;
int mx = 0;
for (int i = 0; i < nn; i++) {
set<int> st;
for (int j = second[i] - 'a' + 1; j <= 'z' - 'a'; j++) st.insert(alfa[j]);
for (int j = 1; j <= 26; j++)
if (st.find(j) == st.end()) {
ans.push_back(alfa[second[i] - 'a'] = j);
break;
}
}
for (int i = 0; i <= 'z'; i++) mx = max(mx, alfa[i]);
cout << mx << endl;
for (int i = 0; i < nn; i++) {
if (i) cout << " ";
cout << ans[i];
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int p;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
cin >> p;
for (; p; p--) {
long long pos;
cin >> pos;
if (k == 0) {
cout << '.';
continue;
}
if (n % 2 == 1 && pos == n) {
cout << 'X';
continue;
}
long long tn = n - (n % 2);
pos = tn - pos;
long long tk = k - (n % 2);
if (pos % 2 == 0 && pos / 2 < tk)
cout << 'X';
else if (pos % 2 == 1 && pos / 2 + (n / 2) < tk)
cout << 'X';
else
cout << '.';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[505][505];
inline long long read() {
long long q = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) q = (q << 3) + (q << 1) + (ch ^ 48), ch = getchar();
return f ? q : -q;
}
inline void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + 48);
}
signed main() {
n = read(), k = read();
if (k > n * n) {
putchar('-'), putchar('1');
return 0;
};
for (long long i = 0; i < n && k; ++i) {
a[i][i] = 1, --k;
for (long long j = i + 1; j < n && k > 1; ++j)
a[i][j] = a[j][i] = 1, -- --k;
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) print(a[i][j]), putchar(' ');
putchar('\n');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k1, k2;
cin >> n >> k1 >> k2;
int a[k1], b[k2], m1 = -1, m2 = -1;
for (int i = 0; i < k1; i++) {
cin >> a[i];
if (m1 < a[i]) m1 = a[i];
}
for (int i = 0; i < k2; i++) {
cin >> b[i];
if (m2 < b[i]) m2 = b[i];
}
if (m1 > m2) {
cout << "YES";
} else
cout << "NO";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long int arr[1002] = {0}, x1 = 1, y1, x2 = 2, y2, x3 = 3, y3, x = 0,
y = 0;
int visited[1002] = {0}, f = 0;
long double dd, m12, m13, m23, theta1 = 0, theta2 = 0;
vector<int> line2nd;
unordered_map<long double, int> mp;
unordered_map<long double, int>::iterator it;
arr[0] = 0;
visited[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
visited[i] = 0;
}
y1 = arr[1];
y2 = arr[2];
y3 = arr[3];
m12 = (y1 - y2) * 1.000 / (x1 - x2);
m13 = (y1 - y3) * 1.000 / (x1 - x3);
m23 = (y2 - y3) * 1.000 / (x2 - x3);
mp[m12]++;
mp[m13]++;
mp[m23]++;
for (int i = 4; i <= n; i++) {
dd = (y1 - arr[i]) / (1.0000 * (x1 - i));
mp[dd]++;
dd = (y2 - arr[i]) / (1.0000 * (x2 - i));
mp[dd]++;
dd = (y3 - arr[i]) / (1.0000 * (x3 - i));
mp[dd]++;
}
if (mp.size() == 1) {
f = 1;
} else {
if (mp[m12] > mp[m13] && mp[m12] > mp[m23]) {
theta1 = m12;
x = x1;
y = y1;
} else if (mp[m13] > mp[m23]) {
theta1 = m13;
x = x1;
y = y1;
} else {
theta1 = m23;
x = x2;
y = y2;
}
visited[x]++;
for (int i = 1; i <= n; i++) {
if (i != x) {
dd = (y - arr[i]) / (1.0000 * (x - i));
if (dd != theta1) {
line2nd.push_back(i);
} else {
visited[i]++;
}
}
}
if (line2nd.size() > 1) {
int tempx = line2nd[0], tempx2 = line2nd[1];
theta2 = (arr[tempx2] - arr[tempx]) * 1.0000 / (tempx2 - tempx);
for (int i = 1; i <= n; i++) {
if (i != tempx) {
dd = (arr[tempx] - arr[i]) * 1.0000 / (tempx - i);
if (visited[i] == 0) {
if (dd != theta2) {
f = 1;
break;
}
}
}
}
if (theta2 != theta1) f = 1;
}
}
if (f == 1)
cout << "NO";
else {
cout << "YES";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
inline long long MAX2(long long a, long long b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
int mod = 1e9 + 7;
int64_t extGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
if (!a) {
x = 0;
y = 1;
return b;
}
int64_t x1, y1;
int64_t d = extGcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
inline long long addmod(long long a, long long b) {
a = a % mod + b % mod;
if (a > mod) a %= mod;
return a;
}
inline long long submod(long long a, long long b) {
a = a % mod - b % mod;
if (a < 0) a += mod;
return a;
}
inline long long mulmod(long long a, long long b) {
return (a % mod * b % mod) % mod;
}
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
inline long long exp(long long a, long long b) {
if (a == 0) return 0ll;
long long r = 1LL;
while (b > 0) {
if (b & 1) {
r = r * (a % mod);
r = (r + mod) % mod;
}
b /= 2;
a = (a % mod) * (a % mod);
a = (a + mod) % mod;
}
return (r + mod) % mod;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
if (a == 0) return b;
return gcd(b, a % b);
}
unsigned long int setbits(long long n) {
unsigned long int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int main() {
if (fopen("input.txt", "r"))
freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
;
int n, a, b, c, t;
cin >> n >> a >> b >> c >> t;
int A[n];
for (long long i = (long long)(0); i < (long long)(n); i++) cin >> A[i];
long long ans = 0;
if (c - b <= 0) {
ans = n * a;
} else {
for (int i = 0; i < n; i++) {
ans += a + (t - A[i]) * (c - b);
}
}
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ts, tf, te, tv, x;
int n;
cin >> ts >> tf >> te;
cin >> n;
long long t[n + 1];
for (int i = 1; i <= n; i++) cin >> t[i];
long long tw = LLONG_MAX;
if (ts < t[1] || n == 0)
tv = ts, tw = 0;
else if (ts >= t[1]) {
vector<long long> tt;
tt.push_back(0);
if (ts + te <= tf) tt.push_back(ts);
for (int i = 2; i <= n; i++) {
x = max(tt[i - 1] + te, t[i]);
if (x + te > tf) break;
tt.push_back(x);
}
int k = tt.size() - 1;
if (tt[k] + 2 * te <= tf)
tw = 0, tv = tt[k] + te;
else {
for (int i = 1; i <= k - 1; i++) {
if (tt[i + 1] - (tt[i] + te) >= 1) {
tw = 0, tv = tt[i] + te;
break;
}
}
}
if (tw != 0) {
for (int i = 1; i <= k - 1; i++) {
if ((t[i + 1] - t[i] >= 1) && (tt[i] + te - t[i + 1] + 1 < tw)) {
tw = tt[i] + te - (t[i + 1] - 1);
tv = t[i + 1] - 1;
}
}
if (ts - (t[1] - 1) < tw) {
tw = ts - (t[1] - 1);
tv = t[1] - 1;
}
}
}
cout << tv;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 700030;
const int MOD = 1e9 + 7, H = 3137;
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return (int)(((long long)a * b) % MOD); }
int suf[2 * MAXN];
int d[2 * MAXN];
int A[2 * MAXN][2];
int bio[2 * MAXN], dp[2 * MAXN], term[2 * MAXN];
int sink, alloc;
void init() {
memset(suf, -1, sizeof suf);
memset(A, -1, sizeof A);
sink = alloc = 0;
}
void extend(char c) {
int a = c - 'a';
int newsink = ++alloc;
A[sink][a] = newsink;
d[newsink] = d[sink] + 1;
int w = suf[sink];
while (w != -1 && A[w][a] == -1) {
A[w][a] = newsink;
w = suf[w];
}
if (w == -1)
suf[newsink] = 0;
else if (d[A[w][a]] == d[w] + 1)
suf[newsink] = A[w][a];
else {
int newnode = ++alloc;
int v = A[w][a];
memcpy(A[newnode], A[v], sizeof A[v]);
A[w][a] = newnode;
d[newnode] = d[w] + 1;
suf[newsink] = newnode;
suf[newnode] = suf[v];
suf[v] = newnode;
w = suf[w];
while (w != -1 && A[w][a] == v && d[w] + 1 != d[v]) {
A[w][a] = newnode;
w = suf[w];
}
}
sink = newsink;
}
int dfs(int node) {
if (bio[node]++) return dp[node];
dp[node] = term[node];
for (int i = 0; i < 2; i++)
if (A[node][i] != -1) dp[node] += dfs(A[node][i]);
return dp[node];
}
void gen_term() {
memset(term, 0, sizeof term);
int tmp = sink;
for (; tmp; tmp = suf[tmp]) term[tmp] = 1;
}
void build(string &s) {
int n = (int)s.size();
assert(n <= MAXN);
for (int i = 0; i < n; i++) extend(s[i]);
gen_term();
memset(bio, 0, sizeof bio);
dfs(0);
}
int pojav(string &s) {
int n = (int)s.size();
int tmp = 0;
for (int i = 0; i < n; i++) {
int c = s[i] - 'a';
if (A[tmp][c] == -1) return 0;
tmp = A[tmp][c];
}
return dp[tmp];
}
string str_x, str_y, str_yx, str_xy, str_yy;
vector<string> stringovi;
vector<int> koef;
int gran;
void gen(long long treba) {
string a = "a", b = "b";
if (treba == 1) {
str_x = "";
str_y = a;
gran = 1;
} else if (treba == 2) {
str_x = a;
str_y = b;
gran = 2;
} else {
int kol = 0;
for (; kol < treba - 2 && (int)a.size() < 100000; kol++) {
string c = b + a;
a = b;
b = c;
}
gran = kol;
str_x = a;
str_y = b;
}
str_yx = str_y + str_x;
str_xy = str_x + str_y;
str_yy = str_y + str_y;
stringovi = {str_x, str_y, str_yx, str_xy, str_yy};
}
const int VM = 11;
void mult(int a[VM][VM], int b[VM][VM], int c[VM][VM]) {
for (int i = 0; i < VM; i++) {
for (int j = 0; j < VM; j++) {
c[i][j] = 0;
for (int k = 0; k < VM; k++)
c[i][j] = add(c[i][j], mul(a[i][k], b[k][j]));
}
}
}
void potenciraj(long long e) {
if (e == 0)
koef = {0, 1, 0, 0, 0};
else if (e == 1)
koef = {1, 1, 1, 0, 0};
else if (e == 2)
koef = {1, 2, 1, 1, 0};
else {
e -= 2;
int ost = (int)(e % 2);
e /= 2;
int rez[2][VM][VM];
memset(rez, 0, sizeof rez);
for (int i = 0; i < VM; i++) rez[0][i][i] = 1;
int mat[2][VM][VM];
memset(mat, 0, sizeof mat);
for (int i = 0; i < 5; i++) mat[0][i][i] = mat[0][i][5 + i] = 1;
mat[0][4][10] = 1;
for (int i = 0; i < 5; i++) {
mat[0][5 + i][i] = 1;
mat[0][5 + i][5 + i] = 2;
}
mat[0][5 + 3][10] = mat[0][5 + 4][10] = 1;
mat[0][10][10] = 1;
int indm = 0, indr = 0;
for (; e; e /= 2, indm ^= 1) {
if (e & 1) {
mult(rez[indr], mat[indm], rez[1 ^ indr]);
indr ^= 1;
}
mult(mat[indm], mat[indm], mat[1 ^ indm]);
}
int poc[VM] = {1, 1, 1, 0, 0, 1, 2, 1, 1, 0, 1};
int zav[VM];
memset(zav, 0, sizeof zav);
for (int i = 0; i < VM; i++) {
for (int j = 0; j < VM; j++)
zav[i] = add(zav[i], mul(rez[indr][i][j], poc[j]));
}
if (ost) {
for (int i = 0; i < 5; i++) koef.push_back(add(zav[i], zav[5 + i]));
koef[4] = add(koef[4], 1);
} else
for (int i = 0; i < 5; i++) koef.push_back(zav[5 + i]);
}
koef[0] = sub(koef[0], add(koef[2], koef[3]));
koef[1] = sub(koef[1], add(add(koef[2], koef[3]), mul(2, koef[4])));
}
int rje[MAXN];
char tmp_s[MAXN];
string sq[MAXN];
int main() {
long long fb;
int brq;
scanf("%lld%d", &fb, &brq);
gen(fb);
for (int i = 0; i < brq; i++) {
scanf(" %s", tmp_s);
sq[i] = tmp_s;
}
if (fb <= gran)
koef = {0, 1, 0, 0, 0};
else {
potenciraj(fb - gran - 2);
}
for (int i = 0; i < 5; i++) {
init();
build(stringovi[i]);
for (int j = 0; j < brq; j++)
rje[j] = add(rje[j], mul(koef[i], pojav(sq[j])));
}
for (int i = 0; i < brq; i++) printf("%d\n", rje[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 12050;
const int maxm = 240010;
int n, m, S, T, g, ans;
int a[10010];
vector<int> f;
int tot = 1, ver[maxm << 1], nxt[maxm << 1], head[maxn], cur[maxn],
edge[maxm << 1];
template <typename Tp>
void read(Tp &x) {
x = 0;
int f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
void add(int u, int v, int w) {
ver[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
edge[tot] = w;
ver[++tot] = u;
nxt[tot] = head[v];
head[v] = tot;
edge[tot] = 0;
}
int d[maxn];
queue<int> q;
bool bfs() {
memset(d, 0, sizeof(d));
while (!q.empty()) q.pop();
q.push(S);
d[S] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (edge[i] && !d[y]) {
q.push(y);
d[y] = d[x] + 1;
if (y == T) return 1;
}
}
}
return 0;
}
int dinic(int x, int flow) {
if (x == T) return flow;
int rest = flow, k;
for (int i = cur[x]; i && rest; i = nxt[i]) {
int y = ver[i];
cur[x] = i;
if (edge[i] && d[y] == d[x] + 1) {
k = dinic(y, min(rest, edge[i]));
if (!k) d[y] = 0;
edge[i] -= k;
edge[i ^ 1] += k;
rest -= k;
}
}
if (rest == flow) d[x] = 0;
return flow - rest;
}
int main() {
read(n), read(m), read(g);
S = n + m + 10, T = n + m + 16;
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) {
int x;
read(x);
add(S, i, (a[i] ^ 1) * x);
add(i, T, a[i] * x);
}
for (int i = 1; i <= m; i++) {
int op, wi, gi, k;
read(op);
read(wi);
read(k);
ans += wi;
for (int j = 1; j <= k; j++) {
int x;
read(x);
f.push_back(x);
}
for (unsigned j = 0; j < f.size(); j++) {
if (!op)
add(n + i, f[j], 1 << 30);
else
add(f[j], n + i, 1 << 30);
}
read(gi);
if (!op)
add(S, n + i, wi + g * gi);
else
add(n + i, T, wi + g * gi);
f.clear();
}
int flow = 0;
while (bfs()) {
memcpy(cur, head, sizeof(head));
while ((flow = dinic(S, 1 << 30))) ans -= flow;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long INF = 1e18;
const double eps = 1e-10;
int dp[20][200];
int a[20][200];
int n, m, T;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < (1 << n); ++j) {
for (int k = 0; k < (1 << n); ++k) {
if (j & k) continue;
for (int p = 0; p < n; p++) {
int sum = 0;
for (int q = 0; q < n; q++) {
if (k >> q & 1) sum += a[(p + q) % n][i];
}
dp[j | k][i] = max(dp[j | k][i], dp[j][i - 1] + sum);
}
}
}
}
cout << dp[(1 << n) - 1][m] << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000 * 1000 * 1000 + 7;
const long long int INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long int MOD2 = 998244353;
const long double PI = 3.141592653589793;
long long int gcd(long long int a, long long int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int power1(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int max(int a, int b) {
if (a > b) return a;
return b;
}
int min(int a, int b) {
if (a > b) return b;
return a;
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, x;
cin >> n >> x;
long long int arr[n + 1];
int m = INT_MAX;
int index = -1;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (m > arr[i]) {
m = arr[i];
index = i;
} else if (m == arr[i]) {
if (x >= index && x < i) continue;
m = arr[i];
index = i;
}
}
long long int a = m * n;
for (int i = 1; i <= n; i++) {
arr[i] -= m;
}
for (int i = index + 1; i != x + 1; i++) {
if (i == n + 1) i = 1;
arr[i]--;
a++;
}
arr[index] = a;
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, K;
int sum;
int main() {
scanf("%d%d", &n, &K);
K = 240 - K;
for (int i = 1; i <= n; i++) {
sum += i * 5;
if (sum > K) {
printf("%d\n", i - 1);
return 0;
}
}
printf("%d\n", n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int h, a;
long long val, d;
pt(int h = 0, int a = 1, long long val = 0) : h(h), a(a), val(val) {
d = val / a;
}
};
int n, m, k, p, h[100005], a[100005];
bool operator<(const pt x, const pt y) {
if (x.d < m || y.d < m) return x.d > y.d;
return x.val - 1ll * m * x.a - x.h > y.val - 1ll * m * y.a - y.h;
}
priority_queue<pt> pq;
bool check(long long mid) {
while (!pq.empty()) pq.pop();
for (int i = 1; i <= n; i++)
if (mid - 1ll * m * a[i] - h[i] < 0) pq.push(pt(h[i], a[i], mid));
for (int i = 1; i <= m; i++) {
if (pq.empty()) return 1;
pt u = pq.top();
if (u.d < i) return 0;
for (int j = 1; j <= k; j++) {
if (pq.empty()) return 1;
pt u = pq.top();
pq.pop();
u.val += p;
u.d = u.val / u.a;
if (u.val - 1ll * m * u.a - u.h < 0) pq.push(u);
}
}
return pq.empty();
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &p);
for (int i = 1; i <= n; i++) scanf("%d%d", &h[i], &a[i]);
long long l = 1, r = 1e18;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%I64d", l);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int qzh[505][505], a[505][505];
int main(int argc, char** argv) {
int n, m, K;
cin >> n >> m >> K;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '1') a[i][j] = 1;
}
}
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
if (a[i][j] && a[i - 1][j] && a[i][j - 1] && a[i + 1][j] && a[i][j + 1])
++qzh[i][j];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) qzh[i][j] += qzh[i - 1][j];
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 2; j <= n; j++) {
int now = 1, s = 0;
for (int k = 1; k <= m; k++) {
s -= qzh[j - 1][k] - qzh[i][k];
while (now <= m && s < K)
s += qzh[j - 1][now - 1] - qzh[i][now - 1], now++;
ans += m - now + 2 - (s < K);
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
int n;
scanf("%d", &n);
char s1[n + 1], s2[n + 1];
scanf(" %s %s", s1, s2);
int out = 0;
for (int i = 0; i < (n + 1) / 2; i++) {
if (i == n / 2) {
if (s1[i] != s2[i]) out++;
continue;
}
vector<int> v;
v.push_back((int)s1[i]);
v.push_back((int)s1[n - 1 - i]);
v.push_back((int)s2[i]);
v.push_back((int)s2[n - 1 - i]);
if (v[0] == v[2] and v[1] == v[3]) continue;
if (v[0] == v[1] and v[2] == v[3]) continue;
if (v[0] == v[3] and v[1] == v[2]) continue;
if (v[0] == v[3] and v[1] != v[2])
out++;
else if (v[0] == v[2] and v[1] != v[3])
out++;
else if (v[1] == v[3] and v[0] != v[2])
out++;
else if (v[0] != v[1] and v[1] != v[2] and v[2] != v[3])
out += 2;
else if (v[0] == v[1] and v[2] != v[3] and v[2] != v[0] and v[3] != v[0])
out += 2;
else
out++;
}
printf("%d\n", out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int a[N], ls[N], s[N], n, q;
int suf[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ls[i] = 1;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int p, x;
scanf("%d%d", &p, &x);
a[p] = x;
ls[p] = i;
} else
scanf("%d", &suf[i]);
}
for (int i = q; i >= 1; i--) suf[i] = max(suf[i], suf[i + 1]);
for (int i = 1; i <= n; i++) printf("%d ", max(a[i], suf[ls[i]]));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int Maxn = 35005;
const int Maxk = 55;
int tree[Maxk][4 * Maxn], tag[Maxk][4 * Maxn];
int dp[Maxk][Maxn];
int n, k;
void Push(int t, int p) {
tag[t][p * 2] += tag[t][p];
tag[t][p * 2 + 1] += tag[t][p];
tag[t][p] = 0;
}
void modify(int t, int p, int l, int r, int pos, int val) {
if (l == r) {
tree[t][p] = val;
return;
}
Push(t, p);
int mid = (l + r) >> 1;
if (pos <= mid) {
modify(t, p * 2, l, mid, pos, val);
} else {
modify(t, p * 2 + 1, mid + 1, r, pos, val);
}
tree[t][p] = max(tree[t][p * 2] + tag[t][p * 2],
tree[t][p * 2 + 1] + tag[t][p * 2 + 1]);
}
void Add(int t, int p, int l, int r, int lo, int hi, int val) {
if (lo > hi || !hi) return;
if (!lo) lo++;
if (lo <= l && r <= hi) {
tag[t][p] += val;
return;
}
Push(t, p);
int mid = (l + r) >> 1;
if (lo <= mid) {
Add(t, p * 2, l, mid, lo, min(hi, mid), val);
}
if (hi > mid) {
Add(t, p * 2 + 1, mid + 1, r, max(lo, mid + 1), hi, val);
}
tree[t][p] = max(tree[t][p * 2] + tag[t][p * 2],
tree[t][p * 2 + 1] + tag[t][p * 2 + 1]);
}
int query(int t, int p, int l, int r, int lo, int hi) {
if (lo > hi) return -1e9;
if (lo <= l && r <= hi) {
return tree[t][p] + tag[t][p];
}
Push(t, p);
int mid = (l + r) >> 1;
int ans = 0;
if (lo <= mid) {
ans = max(ans, query(t, p * 2, l, mid, lo, min(hi, mid)));
}
if (hi > mid) {
ans = max(ans, query(t, p * 2 + 1, mid + 1, r, max(lo, mid + 1), hi));
}
return ans;
}
int a[Maxn];
int pre[Maxn];
int hav[Maxn];
int main() {
memset(hav, -1, sizeof(hav));
scanf("%d %d", &n, &k);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (hav[a[i]] != -1)
pre[i] = hav[a[i]];
else
sum++;
hav[a[i]] = i;
dp[1][i] = sum;
modify(1, 1, 1, n, i, sum);
}
for (int i = 2; i <= k; i++) {
for (int j = 1; j <= n; j++) {
Add(i - 1, 1, 1, n, pre[j], j - 1, 1);
dp[i][j] = query(i - 1, 1, 1, n, 1, j - 1);
modify(i, 1, 1, n, j, dp[i][j]);
}
}
printf("%d\n", dp[k][n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline void open(const char *s) {}
inline int rd() {
static int x, f;
x = 0;
f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return f > 0 ? x : -x;
}
const int N = 2010, mod = 998244353;
int n, m, L, ans, f[N << 1][N], fac[N << 1];
inline int pls(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int mul(int a, int b) { return (long long)a * b % mod; }
inline int pwr(int x, int k) {
int res = 1;
for (; k; k >>= 1, x = mul(x, x))
if (k & 1) res = mul(res, x);
return res;
}
int main() {
n = rd();
m = rd();
L = rd();
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = mul(fac[i - 1], i);
f[1][1] = 1;
for (int i = 1; i <= (n << 1) - 1; i++) {
for (int j = 0; j <= min(i, n); j++) {
if (!f[i][j]) continue;
if (j + 1 <= n * 2 - i - 1)
f[i + 1][j + 1] = pls(f[i + 1][j + 1], f[i][j]);
if (j) f[i + 1][j - 1] = pls(f[i + 1][j - 1], mul(j, f[i][j]));
}
}
int ans = 0;
for (int i = 1; i <= (n << 1) - 1; i++)
for (int j = m; j <= n; j++) {
ans = pls(ans, mul(f[i][j], mul(f[n * 2 - i][j], fac[j])));
}
ans = mul(ans, pwr(f[n << 1][0], mod - 2));
ans = mul(ans, L);
ans = mul(ans, pwr(n * 2 + 1, mod - 2));
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxm = 1e5 + 5;
vector<long long> g[maxm];
long long n, q;
long long sz[maxm];
long long d[maxm];
long long f[maxm][25];
const long long maxd = 20;
void dfs(long long x, long long fa) {
sz[x] = 1;
for (long long j = 1; j <= maxd; j++) {
f[x][j] = f[f[x][j - 1]][j - 1];
}
for (long long v : g[x]) {
if (v == fa) continue;
d[v] = d[x] + 1;
f[v][0] = x;
dfs(v, x);
sz[x] += sz[v];
}
}
long long lca(long long a, long long b) {
if (d[a] < d[b]) swap(a, b);
for (long long i = maxd; i >= 0; i--) {
if (d[f[a][i]] >= d[b]) {
a = f[a][i];
}
}
if (a == b) return a;
for (long long i = maxd; i >= 0; i--) {
if (f[a][i] != f[b][i]) {
a = f[a][i];
b = f[b][i];
}
}
return f[a][0];
}
signed main() {
ios::sync_with_stdio(0);
cin >> n;
for (long long i = 1; i < n; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
d[1] = 1;
f[1][0] = 1;
dfs(1, 1);
cin >> q;
while (q--) {
long long a, b;
cin >> a >> b;
if (a == b) {
cout << n << endl;
continue;
}
long long lc = lca(a, b);
long long dab = d[a] + d[b] - 2 * d[lc];
if (dab % 2) {
cout << 0 << endl;
continue;
}
if (d[a] < d[b]) swap(a, b);
long long dist = dab / 2;
for (long long i = maxd; i >= 0; i--) {
if (dist - (1 << i) > 0) {
a = f[a][i];
b = f[b][i];
dist -= (1 << i);
}
}
if (d[a] == d[b]) {
cout << n - sz[a] - sz[b] << endl;
continue;
}
cout << sz[f[a][0]] - sz[a] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
using namespace std;
long long power(long long a, long long p, long long M) {
long long r = 1;
a = a % M;
while (p > 0) {
if (p % 2) r = (r * a) % M;
a = (a * a) % M;
p /= 2;
}
return r;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long x[3], y[3];
void solve() {
int n;
cin >> n;
long long t, a, b;
for (long long i = 0; i < n; i++) {
cin >> t;
cin >> a >> b;
x[t] += a;
y[t] += b;
}
if (x[1] >= y[1])
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (x[2] >= y[2])
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
int i;
for (i = 0; i <= 9; i++) {
if ((a * 10 + i) % b == 0) break;
}
if (i == 10)
cout << -1 << "\n";
else {
cout << a * 10 + i;
for (i = 1; i < n; i++) cout << "0";
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f;
const long long MOD = 1000000007;
const int IT_MAX = 1 << 17;
const double EPS = 1e-9;
const double PI = acos(-1);
const int MX = 100005;
pair<double, double> operator+(pair<double, double> l, pair<double, double> r) {
return pair<double, double>(l.first + r.first, l.second + r.second);
}
pair<double, double> operator-(pair<double, double> l, pair<double, double> r) {
return pair<double, double>(l.first - r.first, l.second - r.second);
}
double operator*(pair<double, double> a, pair<double, double> b) {
return a.first * b.first + a.second * b.second;
}
pair<double, double> operator*(pair<double, double> l, double r) {
return pair<double, double>(l.first * r, l.second * r);
}
double operator/(pair<double, double> l, pair<double, double> r) {
return l.first * r.second - l.second * r.first;
}
pair<double, double> r90(pair<double, double> c) {
return pair<double, double>(-c.second, c.first);
}
double size(pair<double, double> c) { return hypot(c.first, c.second); }
double sq(double x) { return x * x; }
double size2(pair<double, double> c) { return sq(c.first) + sq(c.second); }
pair<double, double> unit(double a) {
return pair<double, double>(cos(a), sin(a));
}
pair<double, double> rotate(pair<double, double> v, double a) {
return unit(a) * v.first + unit(a + PI / 2) * v.second;
}
int intersect(pair<double, double> a, pair<double, double> b,
pair<double, double> u, pair<double, double> v,
pair<double, double> &des) {
if (abs(u / v) < EPS) return 0;
des = pair<double, double>(((a - u) / v) / (v / b), ((a - u) / b) / (v / b));
return 1;
}
struct circle {
circle(pair<double, double> O, double r) : O(O), r(r) {}
circle() {}
pair<double, double> O;
double r;
};
int get_circle(pair<double, double> p0, pair<double, double> p1,
pair<double, double> p2, circle &des) {
pair<double, double> a = (p0 + p1) * 0.5, b = r90(p0 - p1);
pair<double, double> u = (p0 + p2) * 0.5, v = r90(p0 - p2), R;
if (!intersect(a, b, u, v, R)) return 0;
des = circle(a + b * R.first, size(a + b * R.first - p0));
return 1;
}
struct node {
node(int a, int b, int c, circle X) : a(a), b(b), c(c), X(X) {}
int a, b, c;
circle X;
};
node make_circle(vector<int> Q, pair<double, double> D[MX]) {
if (Q.size() == 0)
return node(-1, -1, -1, circle(pair<double, double>(0, 0), 0));
if (Q.size() == 1) return node(Q[0], -1, -1, circle(D[Q[0]], 0));
circle res;
for (int i = 0; i < Q.size(); i++) {
swap(Q.back(), Q[i]);
res = circle((D[Q[0]] + D[Q[1]]) * 0.5, size(D[Q[0]] - D[Q[1]]) / 2);
bool ch = 1;
for (int c : Q) {
if (size2(D[c] - res.O) > sq(res.r) + 1e-6) ch = 0;
}
if (ch) return node(Q[0], Q[1], -1, res);
swap(Q.back(), Q[i]);
}
get_circle(D[Q[0]], D[Q[1]], D[Q[2]], res);
return node(Q[0], Q[1], Q[2], res);
}
node smallest_circle(vector<int> &P, vector<int> &Q, int N,
pair<double, double> D[MX]) {
node c = make_circle(Q, D);
if (N == 0 || Q.size() >= 3) return c;
for (int i = 0; i < N; i++) {
if (size2(c.X.O - D[P[i]]) > sq(c.X.r)) {
Q.push_back(P[i]);
c = smallest_circle(P, Q, i, D);
Q.pop_back();
}
}
return c;
}
int counter = 0;
void get_enc(vector<int> L, vector<int> X, vector<node> &ans,
pair<double, double> D[MX], double prob = 1) {
if (prob < 1e-4) return;
counter++;
vector<int> P, Q;
random_shuffle(L.begin(), L.end());
for (int c : X) P.push_back(c);
for (int c : L) P.push_back(c);
node x = smallest_circle(P, Q, L.size(), D);
ans.push_back(x);
vector<int> t1;
auto is_in = [](vector<int> &X, int x) {
for (int c : X)
if (c == x) return true;
return false;
};
if (!is_in(X, x.a)) t1.push_back(x.a);
if (!is_in(X, x.b)) t1.push_back(x.b);
if (!is_in(X, x.c)) t1.push_back(x.c);
for (int c : t1) {
for (int j = 0; j < L.size(); j++)
if (L[j] == c) L.erase(L.begin() + j);
get_enc(L, X, ans, D, prob / 3);
prob = prob * 2 / 3;
X.push_back(c);
}
}
pair<double, double> D1[MX], D2[MX];
int N, N1, N2;
map<pair<int, int>, int> Mx;
void check(pair<double, double> O1, pair<double, double> O2, double a) {
auto move = [&](pair<double, double> c) { return rotate(c - O1, a) + O2; };
counter++;
int corr = 0;
vector<pair<int, int> > ansv;
for (int i = 1; i <= N1; i++) {
pair<double, double> ex = move(D1[i]);
int tx = (int)(ex.first * 100 + 0.5);
int ty = (int)(ex.second * 100 + 0.5);
int f = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++)
if (f == 0) {
if (Mx.find(pair<int, int>(tx + dx, ty + dy)) != Mx.end()) {
int idx = Mx[pair<int, int>(tx + dx, ty + dy)];
ansv.emplace_back(i, idx);
f = 1;
}
}
corr += f;
if (i > 100 && ((double)corr / i) * N1 < N * 0.5) break;
}
if ((int)(ansv).size() > 0.91 * N) {
int chkA[MX] = {}, chkB[MX] = {};
for (pair<int, int> e : ansv) chkA[e.first] = chkB[e.second] = 1;
int ia = 1, ib = 1;
while ((int)(ansv).size() < N) {
while (chkA[ia] == 1) ++ia;
while (chkB[ib] == 1) ++ib;
ansv.push_back(pair<int, int>(ia, ib));
++ia;
++ib;
}
for (pair<int, int> e : ansv) printf("%d %d\n", e.first, e.second);
exit(0);
}
}
int main() {
scanf("%d", &N);
scanf("%d", &N1);
for (int i = 1; i <= N1; i++) scanf("%lf%lf", &D1[i].first, &D1[i].second);
scanf("%d", &N2);
for (int i = 1; i <= N2; i++) scanf("%lf%lf", &D2[i].first, &D2[i].second);
for (int i = 1; i <= N2; i++) {
int tx = (int)(D2[i].first * 100 + 0.5);
int ty = (int)(D2[i].second * 100 + 0.5);
Mx[pair<int, int>(tx, ty)] = i;
}
vector<int> t1, t2;
vector<node> A1, A2;
for (int i = 1; i <= N1; i++) t1.push_back(i);
get_enc(t1, t2, A1, D1);
t1.clear();
for (int i = 1; i <= N2; i++) t1.push_back(i);
get_enc(t1, t2, A2, D2);
for (node a1 : A1) {
for (node a2 : A2) {
if (fabs(a1.X.r - a2.X.r) > 0.1) continue;
pair<double, double> P1[] = {D1[a1.a], D1[a1.b], D1[a1.c]};
pair<double, double> P2[] = {D2[a2.a], D2[a2.b], D2[a2.c]};
for (pair<double, double> &c : P1) c = c - a1.X.O;
for (pair<double, double> &c : P2) c = c - a2.X.O;
int O[3] = {0, 1, 2};
do {
int ch = 1;
double t = atan2(P1[0] / P2[O[0]], P1[0] * P2[O[0]]);
for (int i = 1; i < 3; i++) {
double u = atan2(P1[i] / P2[O[i]], P1[i] * P2[O[i]]);
if (fabs(t - u) < EPS) ch = 0;
}
check(a1.X.O, a2.X.O, t);
} while (next_permutation(O, O + 3));
}
}
}
| 11 |
#include <bits/stdc++.h>
inline int read() {
int x = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) f |= (c == '-'), c = getchar();
while (isdigit(c)) x = x * 10 + (c & 15), c = getchar();
return f ? -x : x;
}
namespace pb_ds {
namespace io {
const int MaxBuff = 1 << 15;
const int Output = 1 << 23;
char B[MaxBuff], *S = B, *T = B;
char Out[Output], *iter = Out;
inline void flush() {
fwrite(Out, 1, iter - Out, stdout);
iter = Out;
}
} // namespace io
template <class Type>
inline Type Read() {
using namespace io;
register char ch;
register Type ans = 0;
register bool neg = 0;
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
(ch < '0' || ch > '9') && ch != '-')
;
ch == '-' ? neg = 1 : ans = ch - '0';
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
'0' <= ch && ch <= '9')
ans = ans * 10 + ch - '0';
return neg ? -ans : ans;
}
template <class Type>
inline void Print(register Type x, register char ch = '\n') {
using namespace io;
if (!x)
*iter++ = '0';
else {
if (x < 0) *iter++ = '-', x = -x;
static int s[100];
register int t = 0;
while (x) s[++t] = x % 10, x /= 10;
while (t) *iter++ = '0' + s[t--];
}
*iter++ = ch;
}
} // namespace pb_ds
using namespace pb_ds;
using namespace std;
const int INF = 1 << 30;
const int mod = 1000000009;
inline int lowbit(int x) { return x & (-x); }
inline int ksm(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
vector<int> ans;
int x[1005], y[1005], cnt[2][2];
int main() {
int n = Read<int>();
for (register int i = 1; i <= n; ++i) x[i] = Read<int>(), y[i] = Read<int>();
while (1) {
memset(cnt, 0, sizeof(cnt));
for (register int i = 1; i <= n; ++i) cnt[x[i] & 1][y[i] & 1]++;
if (cnt[0][1] + cnt[1][0] > 0 && cnt[0][0] + cnt[1][1] > 0) {
for (register int i = 1; i <= n; ++i)
if ((x[i] & 1) ^ (y[i] & 1)) ans.push_back(i);
printf("%d\n", ans.size());
for (register int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
cout << endl;
return 0;
}
if (cnt[0][0] + cnt[0][1] > 0 && cnt[1][0] + cnt[1][1] > 0) {
for (register int i = 1; i <= n; ++i)
if (x[i] & 1) ans.push_back(i);
printf("%d\n", ans.size());
for (register int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
cout << endl;
return 0;
}
for (register int i = 1; i <= n; ++i) {
x[i] >>= 1;
y[i] >>= 1;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int get(int x) {
cout << "? " << x + 1 << endl;
cin >> x;
return x;
}
int ans(int x) {
cout << "! " << x + 1 << endl;
exit(0);
}
int main() {
int n;
cin >> n;
int a1 = 0;
int b1 = a1 + n / 2;
;
int a2 = b1 - 1;
int b2 = n;
int av = get(a1);
int bv = get(b1);
if ((av - bv) % 2 != 0) {
ans(-2);
return 0;
}
if (av == bv) {
ans(a1);
return 0;
}
if (av > bv) {
swap(av, bv);
swap(a1, b1);
swap(a2, b2);
}
int lo = a1;
int hi = a2;
while (lo <= hi) {
int mid = (lo + hi) / 2;
int m2 = (mid + n / 2) % n;
int v1 = get(mid);
int v2 = get(m2);
if (v1 == v2) {
ans(mid);
}
if (v1 < v2) {
lo = mid + 1;
} else {
hi = mid - 1;
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 60;
const int maxS = 510000;
const int inf = 1000000;
int n, a[maxN], d;
int dp[maxN][maxS];
int main() {
scanf("%d%d", &n, &d);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
dp[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < maxS; ++j) {
if (dp[i][j]) {
dp[i + 1][j] = true;
dp[i + 1][j + a[i]] = true;
}
}
}
int moves = 0, value = 0;
while (true) {
int t = -1;
for (int i = value + 1; i < maxS && i <= value + d; ++i) {
if (dp[n][i]) {
t = i;
}
}
if (t == -1) {
break;
}
++moves;
value = t;
}
printf("%d %d\n", value, moves);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
long long t, n, k, ans;
int main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld", &n, &k);
ans = 0;
while (n >= k) {
ans += n % k + 1;
n = n / k;
}
ans += n % k;
printf("%lld\n", ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long val1[1000005];
long long val2[1000005];
long long prime1[1000005];
long long prime2[1000005];
long long int cnt[2];
pair<long long, long long> getHash(int a, int b) {
long long v1 = (val1[b] - val1[a - 1] * prime1[b - a + 1]) % 1000000009;
v1 = (v1 + 1000000009) % 1000000009;
long long v2 = (val2[b] - val2[a - 1] * prime2[b - a + 1]) % 1000000007;
v2 = (v2 + 1000000007) % 1000000007;
return make_pair(v1, v2);
}
long long power(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long f = power(a, b / 2, mod);
f = (f * f) % mod;
if (b % 2) return (a * f) % mod;
return f;
}
long long zero1, zero2;
long long one1, one2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); ++i) {
++cnt[s[i] - '0'];
}
prime1[0] = prime2[0] = 1;
for (int i = 0; i < t.size(); ++i) {
val1[i + 1] = (val1[i] * 1299821 + t[i] - 'a' + 1) % 1000000009;
val2[i + 1] = (val2[i] * 1300709 + t[i] - 'a' + 1) % 1000000007;
prime1[i + 1] = (prime1[i] * 1299821) % 1000000009;
prime2[i + 1] = (prime2[i] * 1300709) % 1000000007;
}
int st = s[0] - '0';
int wo = 0;
for (int j = 0; j < s.size(); ++j) {
if (s[j] == s[0])
++wo;
else
break;
}
int vua = s.size();
for (int j = wo; j < s.size(); ++j) {
if (s[j] == s[0]) {
vua = j;
break;
}
}
long long ans = 0;
for (long long int i = 1; i < t.size(); ++i) {
long long v = cnt[st] * i;
int ot = st ^ 1;
long long rem = (long long)t.size() - v;
if (rem <= 0 || rem % cnt[ot]) continue;
long long w = rem / cnt[ot];
auto u = getHash(1, i);
long long v1 = (power(1299821, i * wo, 1000000009) - 1) *
(power(prime1[i] - 1, 1000000009 - 2, 1000000009));
v1 = (v1 % 1000000009 + 1000000009) % 1000000009;
long long v2 = (power(1300709, i * wo, 1000000007) - 1) *
(power(prime2[i] - 1, 1000000007 - 2, 1000000007));
v2 = (v2 % 1000000007 + 1000000007) % 1000000007;
auto qw = getHash(1, i * wo);
auto u1 = getHash(i * wo + 1, i * wo + w);
if (u == u1) continue;
long long ans1 = 0;
long long ans2 = 0;
long long dig = 0;
for (int j = 0; j < s.size(); ++j) {
if (s[j] == '0' + st) {
ans1 = (ans1 * prime1[i] + u.first) % 1000000009;
ans2 = (ans2 * prime2[i] + u.second) % 1000000007;
dig += i;
} else {
ans1 = (ans1 * prime1[w] + u1.first) % 1000000009;
ans2 = (ans2 * prime2[w] + u1.second) % 1000000007;
dig += w;
}
if (getHash(1, dig) != make_pair(ans1, ans2)) break;
}
if (make_pair(ans1, ans2) == getHash(1, t.size())) ++ans;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e6 + 5;
void fio() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int dsu[MAXN];
int pa(int u) { return dsu[u] < 0 ? u : dsu[u] = pa(dsu[u]); }
void join(int u, int v) {
u = pa(u), v = pa(v);
if (u == v) return;
dsu[v] += dsu[u];
dsu[u] = v;
}
int main() {
fio();
int n;
cin >> n;
for (int i = 0; i < (MAXN); i++) dsu[i] = -1;
vector<char> an(MAXN, '?');
int ma = 0;
for (int i = 0; i < (n); i++) {
string s;
cin >> s;
int k;
cin >> k;
for (int j = 0; j < (k); j++) {
int in;
cin >> in;
int len = s.size();
ma = max(in + len - 1, ma);
for (int kk = 0; kk < len;) {
an[in + kk] = s[kk];
join(in + kk, in + kk + 1);
kk = pa(in + kk) - in;
}
}
}
int slen = ma;
for (int i = 1; i <= slen; i++) {
cout << (an[i] == '?' ? 'a' : an[i]);
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long i, j, t, k = 0, result, n, p, m, c = 0, d = 0;
cin >> t;
while (t--) {
cin >> n;
c = 0;
set<long> s;
for (i = 1; i <= n; i++) {
cin >> k;
s.insert(k);
}
result = 0;
while (!s.empty()) {
m = *s.rbegin();
s.erase(m);
if (m % 2 == 0) {
result++;
s.insert(m / 2);
}
}
cout << result << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 4;
int dp[N], c[N];
int main() {
int n;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
long long a[n];
long long ans = 0;
for (int i = 0; i < n; i++) cin >> a[i], c[a[i]]++;
for (int i = 1; i < N; i++) {
if (c[i]) {
ans = max(ans, dp[i] + 1LL);
for (int j = 2 * i; j < N; j += i) {
if (c[j]) dp[j] = max(dp[j], dp[i] + 1);
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1000 * 105];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 2; i < n; i++)
if (a[i] < a[i - 1] + a[i - 2]) {
cout << "YES";
return 0;
}
cout << "NO";
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.