solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 120005;
pair<int, int> T[N << 2];
pair<int, int> operator+(const pair<int, int> &a, const pair<int, int> &b) {
return make_pair(min(a.first, b.first),
((a.first <= b.first) ? a.second : 0) +
((b.first <= a.first) ? b.second : 0));
}
struct querys {
int l, r, id;
bool operator<(const querys &q) const { return r < q.r; }
} q[N];
int n, m, a[N], que[2][N], top[2], tag[N << 2], tagcnt[N << 2];
long long ans[N], Ans[N << 2], tag2[N << 2];
void push(int cur, int x) { tag[cur] += x, T[cur].first += x; }
void pushans(int cur, int a, long long b) {
tagcnt[cur] += a, tag2[cur] += b, Ans[cur] += a + b;
}
void pushdown(int cur) {
if (tag[cur])
push(cur << 1, tag[cur]), push((cur << 1) | 1, tag[cur]), tag[cur] = 0;
if (tagcnt[cur] || tag2[cur]) {
pushans(cur << 1, (T[cur << 1].first == T[cur].first) ? tagcnt[cur] : 0,
tag2[cur] + tagcnt[cur] * (long long)((T[(cur << 1) | 1].first ==
T[cur].first)
? T[(cur << 1) | 1].second
: 0));
pushans((cur << 1) | 1,
(T[(cur << 1) | 1].first == T[cur].first) ? tagcnt[cur] : 0,
tag2[cur]);
tagcnt[cur] = tag2[cur] = 0;
}
}
void build(int cur, int l, int r) {
tag[cur] = tagcnt[cur] = tag2[cur] = 0;
if (l == r) {
T[cur] = make_pair(l, 1), Ans[cur] = 0;
return;
}
int mid = (l + r) >> 1;
build(cur << 1, l, mid), build((cur << 1) | 1, mid + 1, r);
}
void update(int cur, int l, int r, int ql, int qr, int val) {
if (ql <= l && r <= qr) {
push(cur, val);
return;
}
int mid = (l + r) >> 1;
pushdown(cur);
if (ql <= mid) update(cur << 1, l, mid, ql, qr, val);
if (mid < qr) update((cur << 1) | 1, mid + 1, r, ql, qr, val);
T[cur] = T[cur << 1] + T[(cur << 1) | 1];
}
int update(int cur, int l, int r, int ql, int qr, int val, int suf) {
if (qr < l || ql > r) return 0;
if (ql <= l && r <= qr) {
pushans(cur, (T[cur].first == val) ? 1 : 0, suf);
return (T[cur].first == val) ? T[cur].second : 0;
}
int mid = (l + r) >> 1;
pushdown(cur);
int tmp = update((cur << 1) | 1, mid + 1, r, ql, qr, val, suf);
return tmp + update(cur << 1, l, mid, ql, qr, val, suf + tmp);
}
long long query(int cur, int l, int r, int x) {
if (l == r) return Ans[cur];
int mid = (l + r) >> 1;
pushdown(cur);
if (x <= mid)
return query(cur << 1, l, mid, x);
else
return query((cur << 1) | 1, mid + 1, r, x);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
sort(q + 1, q + m + 1);
top[0] = top[1] = que[0][0] = que[1][0] = 0;
build(1, 1, n);
for (int j = 1, i = 1; i <= n; i++) {
que[0][top[0] + 1] = que[1][top[1] + 1] = i;
while (top[0] && a[que[0][top[0]]] < a[i])
update(1, 1, n, que[0][top[0] - 1] + 1, que[0][top[0]],
a[i] - a[que[0][top[0]]]),
top[0]--;
while (top[1] && a[que[1][top[1]]] > a[i])
update(1, 1, n, que[1][top[1] - 1] + 1, que[1][top[1]],
a[que[1][top[1]]] - a[i]),
top[1]--;
que[0][++top[0]] = i, que[1][++top[1]] = i;
update(1, 1, n, 1, i, i, 0);
for (; j <= m && q[j].r <= i; j++) ans[q[j].id] = query(1, 1, n, q[j].l);
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long long int MOD = 1000000007;
const long double EPS = 1e-9;
const long long int INF = 9e18;
int possible[5001][5001];
int main() {
int size;
string str;
cin >> str;
size = ((int)(str).size());
for (auto i = (int)0; i <= (int)size - 1; i++) {
int count = 0;
for (auto j = (int)i; j <= (int)size - 1; j++) {
if (str[j] == ')') {
count--;
} else {
count++;
}
if (count >= 0) {
possible[i][j]++;
} else {
break;
}
}
count = 0;
for (auto j = (int)i; j >= (int)0; j--) {
if (str[j] == '(') {
count--;
} else {
count++;
}
if (count >= 0) {
possible[j][i]++;
} else {
break;
}
}
}
int answer = 0;
for (auto i = (int)0; i <= (int)size - 1; i++) {
for (auto j = (int)i; j <= (int)size - 1; j++) {
if (possible[i][j] == 2 && (j + i - 1) % 2 == 0) {
answer++;
}
}
}
cout << answer << endl;
return 0;
}
| 5 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<bitset>
#include<time.h>
using namespace std;
#define R register int
bitset<200000>S[60];
bool c[60];
int main(){
srand(time(0));
int n,m,p,q;
cin>>n>>m>>p;
q=n-1>>1;
string s;
for(R i=0;i!=n;i++){
cin>>s;
for(R j=0;j!=m;j++){
if(s[j]=='1'){
S[j][i]=1;
}
}
}
vector<int>A,E;
for(int i=0;i!=m;i++){
c[i]=false;
if(S[i].count()>q){
A.push_back(i);
}
}
if(A.empty()==true){
for(R i=0;i!=m;i++){
cout<<0;
}
return 0;
}
p=0;
while(clock()<2950){
bitset<200000>B=S[A[p]];
vector<int>C,D;
D.push_back(A[p]);
for(R i=A.size()-1;i!=-1;i--){
if(i!=p){
C.push_back(A[i]);
}
}
random_shuffle(C.begin(),C.end());
for(vector<int>::iterator T=C.begin();T!=C.end();T++){
if((B&S[*T]).count()>q){
B&=S[*T];
D.push_back(*T);
}
}
if(D.size()>E.size()){
E=D;
}
p++;
if(p==A.size()){
p=0;
}
}
for(vector<int>::iterator T=E.begin();T!=E.end();T++){
c[*T]=true;
}
for(R i=0;i!=m;i++){
if(c[i]==true){
cout<<1;
}else{
cout<<0;
}
}
return 0;
} | 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
char c[111][111];
int n = 10;
void iterate(int x, int y) {
int it = 0;
while (1) {
cout << "new it " << it << endl;
if (c[x][y] == '.') break;
int dx = 0, dy = 0;
if (c[x][y] == '>') dy = 1;
if (c[x][y] == '<') dy = -1;
if (c[x][y] == 'v') dx = 1;
if (c[x][y] == '^') dx = -1;
int nx = x + dx;
int ny = y + dy;
if (nx < 0 || nx >= n || ny < 0 || ny >= n) break;
if (c[nx][ny] != '.') {
x = nx;
y = ny;
continue;
}
it++;
while (1) {
swap(c[x][y], c[x + dx][y + dy]);
x += dx;
y += dy;
nx = x + dx;
ny = y + dy;
if (nx < 0 || nx >= n || ny < 0 || ny >= n) goto end;
if (c[nx][ny] != '.') {
x = nx;
y = ny;
break;
}
}
}
end:
cout << "TOTAL: " << it << endl;
}
void generate(int n) {
for (int i = (0); i < (n); i++) {
if (i == 0)
cout << '>';
else
cout << '^';
if (i % 2 == 0) {
for (int j = (0); j < (n / 2 - 1); j++) cout << ">";
for (int j = (0); j < (n / 2 / 2 - 1); j++) cout << ".>";
cout << ".v";
} else {
if (i == n - 1)
cout << "..";
else
cout << "v.";
for (int j = (0); j < (n / 2 / 2 - 1); j++) cout << "<.";
for (int j = (0); j < (n / 2 - 1); j++) cout << "<";
}
puts("");
}
cout << "1 1" << endl;
}
int main() {
cin >> n;
if (n == 5) {
puts(">...v");
puts("v.<..");
puts("..^..");
puts(">....");
puts("..^.<");
puts("1 1");
return 0;
} else if (n == 3) {
puts(">vv");
puts("^<.");
puts("^.<");
puts("1 3");
return 0;
} else {
generate(100);
return 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
int pp[1000201], n, ans, fac[1000201], nn, duan[1000201], top;
inline void qieke() {
for (register int i = 1; i <= top; ++i) duan[i + top] = duan[i] + n;
top = (top << 1);
register int zhi = duan[1] + (nn - duan[top] - 1);
for (register int i = 2; i <= top; ++i)
zhi = 1LL * zhi * (duan[i] - duan[i - 1] - 1) % 998244353;
ans = (ans + zhi) % 998244353;
top = (top >> 1);
}
inline void dfs(int stp, int qk) {
if (stp >= nn && qk) {
qieke();
return;
}
if (pp[stp] != -1) {
dfs(stp + 1, qk);
return;
}
for (register int j = -2; j <= 2; ++j) {
register int da = (stp + j + nn) % nn;
if (da < 0 || da > nn || da == stp) continue;
if (pp[da] != -1) continue;
register int dyx = (stp + n) % nn;
register int dyh = (da + n) % nn;
if (pp[dyx] != -1 || pp[dyh] != -1) continue;
pp[da] = stp;
pp[stp] = da;
pp[dyx] = dyh;
pp[dyh] = dyx;
dfs(stp + 1, qk);
pp[da] = -1;
pp[stp] = -1;
pp[dyx] = -1;
pp[dyh] = -1;
}
register int da = (stp + n) % nn;
if (pp[da] == -1 && (!top || duan[top] != stp - 1)) {
pp[da] = stp;
pp[stp] = da;
duan[++top] = stp;
dfs(stp + 1, qk | 1);
--top;
pp[da] = -1;
pp[stp] = -1;
}
}
const int bia[] = {
0, 0, 0, 24, 4, 240, 204,
1316, 2988, 6720, 26200, 50248, 174280, 436904,
1140888, 3436404, 8348748, 24631232, 64575924, 174658944, 488230244,
282739095, 583167773, 599201163, 111178790, 470158977, 118436480, 744170002,
418128853, 620410921, 282515603, 777785540, 59207630, 823529776, 0};
const int bt[] = {0, 4, 8, 998244352, 16, 998244343, 4,
998244341, 998244305, 26, 998244309, 15, 998244337, 998244349,
998244349, 998244352, 0};
int f[1000201];
int main() {
for (n = 0; n <= 16; ++n) f[n] = bia[n];
for (n = 17; n <= 50000; ++n)
for (register int i = 1; i <= 17; ++i)
f[n] = (f[n] + 1LL * bt[i - 1] * f[n - i]) % 998244353;
std::cin >> n;
std::cout << f[n] << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 1000 + 10;
int n, m, a[N];
double f[N][N];
int main() {
n = read(), m = read();
for (register int i = 1; i <= n; ++i) a[i] = read();
for (register int i = 1; i <= n; ++i)
for (register int j = 1; j <= n; ++j) f[i][j] = (a[i] > a[j]);
while (m--) {
int x = read(), y = read();
for (register int i = 1; i <= n; ++i) {
f[x][i] = f[y][i] = (f[x][i] + f[y][i]) / 2;
f[i][x] = f[i][y] = 1 - f[x][i];
}
f[x][y] = f[y][x] = 0.5;
}
double ans = 0;
for (register int i = 1; i <= n; ++i)
for (register int j = i + 1; j <= n; ++j) ans += f[i][j];
printf("%.9lf\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long x, long long y) { return (x + y - 1) / y; }
int main() {
long long n, k;
cin >> n >> k;
long long x = 2 * n, y = 5 * n, z = 8 * n;
cout << f(x, k) + f(y, k) + f(z, k) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
cin >> x;
}
template <typename T, typename T0>
void read(T &x, T0 &y) {
cin >> x >> y;
}
template <typename T, typename T0, typename T1>
void read(T &x, T0 &y, T1 &z) {
cin >> x >> y >> z;
}
template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
cin >> x >> y >> z >> w;
}
template <typename T, typename T0>
void read(pair<T, T0> &p) {
cin >> p.first >> p.second;
}
template <typename T>
void read(vector<T> &oneD, long long n) {
for (long long(i) = 0; (i) < (n); ++(i)) {
long long x;
read(x);
oneD.push_back(x);
}
}
template <typename T>
void read(T oneD[], long long n) {
for (long long i = 0; i < n; i++) {
read(oneD[i]);
}
}
template <typename T>
void write(T &x) {
cout << x << " ";
}
template <typename T, typename T0>
void write(T &x, T0 &y) {
cout << x << " " << y << "\n";
}
template <typename T, typename T0, typename T1>
void write(T &x, T0 &y, T1 &z) {
cout << x << " " << y << " " << z << "\n";
}
template <typename T, typename T0, typename T1, typename T2>
void write(T &x, T0 &y, T1 &z, T2 &w) {
cout << x << " " << y << " " << z << " " << w << "\n";
}
template <typename T, typename T0>
void write(pair<T, T0> &p) {
write(p.first);
write(p.second);
}
template <typename T>
void write(vector<T> &oneD, long long n) {
for (long long i = 0; i < n; i++) {
cout << oneD[i] << " ";
}
cout << "\n";
}
template <typename T>
void write(T oneD[], int n) {
for (long long i = 0; i < n; i++) {
write(oneD[i]);
}
cout << "\n";
}
template <typename T, typename T0>
void write(map<T, T0> &mpp) {
for (auto it : mpp) {
write(it.first);
cout << ": ";
write(it.second);
cout << "\n";
}
cout << "\n";
}
void write(vector<vector<long long>> rc, long long n, long long m) {
for (long long(i) = 0; (i) < (n); ++(i)) {
for (long long(j) = 0; (j) < (m); ++(j)) {
cout << rc[i][j] << " ";
}
cout << "\n";
}
}
long long minl(long long a, long long b) { return (a < b) ? a : b; }
long long maxl(long long a, long long b) { return (a > b) ? a : b; }
int cmpPair(pair<int, int> c, pair<int, int> v) {
if (c.first > v.first)
return 1;
else if (c.first < v.first)
return 0;
else {
if (c.second > v.second)
return 1;
else if (c.second < v.second)
return 0;
else
return 2;
}
}
class seg_tree {
public:
vector<pair<long long, long long>> tree;
vector<long long> c;
long long n;
seg_tree(vector<long long> c, long long n,
vector<pair<long long, long long>> tree) {
this->tree = tree;
this->n = n;
this->c = c;
}
pair<long long, long long> buildtree(long long i, long long l, long long r) {
if (l == r) {
tree[i].first = c[l];
tree[i].second = l;
return (tree[i]);
}
pair<long long, long long> a, b;
long long mid = (l + r) / 2;
a = buildtree((2 * i) + 1, l, mid);
b = buildtree((2 * i) + 2, mid + 1, r);
pair<long long, long long> mi;
if (cmpPair(a, b))
mi = b;
else
mi = a;
tree[i] = mi;
return mi;
}
pair<long long, long long> range_query(long long i, long long l, long long r,
long long lsearch, long long rsearch) {
pair<long long, long long> mi;
pair<long long, long long> ma = {1000000007, 1000000007};
if (rsearch < l or lsearch > r) return ma;
if (lsearch <= l and rsearch >= r)
return tree[i];
else {
pair<long long, long long> a, b;
long long mid = (l + r) / 2;
a = range_query((2 * i) + 1, l, mid, lsearch, rsearch);
b = range_query((2 * i) + 2, mid + 1, r, lsearch, rsearch);
if (cmpPair(a, b))
mi = b;
else
mi = a;
}
return mi;
}
void show_tree() {
long long x = 0;
long long sz = n * 4;
while (x < sz) {
write(tree[x]);
cout << " || ";
x++;
}
cout << "\n";
}
};
vector<long long> c;
vector<pair<long long, long long>> tr;
long long n1;
seg_tree ob(c, n1, tr);
set<pair<pair<long long, long long>, long long>> s;
long long cal(long long l, long long r, long long n) {
if (l == r) return c[l];
if (l > r) return 0;
pair<long long, long long> p = ob.range_query(0, 0, n - 1, l, r);
long long mi = p.first;
long long idx = p.second;
long long left = cal(l, idx - 1, n);
long long right = cal(idx + 1, r, n);
if (right + (idx - l + 1) * mi >= left + (r - idx + 1) * mi) {
if (idx > l) s.insert({{l, idx - 1}, mi});
return right + (idx - l + 1) * mi;
} else {
if (r > idx) s.insert({{idx + 1, r}, mi});
return left + (r - idx + 1) * mi;
}
}
void solve() {
long long n;
read(n);
read(c, n);
vector<pair<long long, long long>> t(n * 4, {0, 0});
seg_tree ob1(c, n, t);
ob = ob1;
pair<long long, long long> p = ob.buildtree(0, 0, n - 1);
long long z = cal(0, n - 1, n);
for (auto it : s) {
for (long long(i) = it.first.first; (i) <= (it.first.second); (i) += (1)) {
c[i] = min(c[i], it.second);
}
}
write(c, n);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long x, y;
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(0);
cin >> x >> y;
if (gcd(x, y) != 1) {
cout << "Impossible" << endl;
exit(0);
} else {
int cur = -1;
int sz = 0;
while (x != 1 && y != 1) {
if (x > y) {
if (cur == -1) cur = 1;
if (cur == 2) {
cout << sz << 'B';
cur = 1;
sz = 0;
}
x -= y;
sz++;
} else {
if (cur == -1) cur = 2;
if (cur == 1) {
cout << sz << 'A';
cur = 2;
sz = 0;
}
y -= x;
sz++;
}
}
if (cur == 1)
cout << sz << 'A';
else if (cur == 2)
cout << sz << 'B';
if (x > 1)
cout << x - 1 << 'A';
else
cout << y - 1 << 'B';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const unsigned long long N = 200000000;
const long long INFll = 1ll * INF * INF;
const long double ldINF = 1e+018;
const long double EPS = 0.000000001;
const int sdx[4] = {-1, 0, 1, 0};
const int sdy[4] = {0, 1, 0, -1};
template <typename T>
ostream& operator<<(ostream& out, pair<T, T>& a) {
out << a.first << " " << a.second;
return out;
}
template <typename T>
istream& operator>>(istream& in, pair<T, T>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> a) {
for (int i = 0; i < a.size(); ++i)
if (i == a.size() - 1)
out << a[i];
else
out << a[i] << " ";
return out;
}
string s[5];
vector<pair<int, int> > v;
bool check(int x, int y) {
for (int i = 0; i < v.size(); i++) {
x += v[i].first, y += v[i].second;
if (x < 0 || x > 3 || y < 0 || y > 2 || s[x][y] == '-') return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
s[0] = "123";
s[1] = "456";
s[2] = "789";
s[3] = "-0-";
int n;
cin >> n;
string a;
cin >> a;
int x, y;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 3; j++)
if (s[i][j] == a[0]) x = i, y = j;
int x1 = x, y1 = y;
for (int z = 0; z < n - 1; z++) {
bool f = false;
for (int i = 0; i < 4 && !f; i++)
for (int j = 0; j < 3 && !f; j++)
if (s[i][j] == a[z + 1]) {
f = true;
v.push_back(make_pair(i - x, j - y));
x = i, y = j;
}
}
x = x1, y = y1;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 3; j++) {
if (s[i][j] == '-' || (x == i && y == j)) continue;
if (check(i, j)) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
if (0)
cerr << fixed << setprecision(0)
<< "TIME = " << clock() / (long double)CLOCKS_PER_SEC * 1000 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int zero, um, dois;
int main() {
int n;
scanf("%d", &n);
zero = um = dois = 0;
for (int i = (0); i < (n); ++i) {
int a;
scanf("%d", &a);
if (a % 3 == 0)
zero++;
else if (a % 3 == 1)
um++;
else
dois++;
}
int ans = zero / 2 + min(um, dois);
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int res = 0, c, d = 0;
while (c = getchar(), c < '0' || c > '9')
;
do {
res = (res << 3) + (res << 1) + (c ^ 48);
} while (c = getchar(), c >= '0' && c <= '9');
return res;
}
const int maxn = 300010;
vector<int> edge[maxn];
stack<int> S;
bool vis[maxn];
int low[maxn], dfn[maxn], dep;
int To[maxn], cnt, xl[maxn], xr[maxn];
long long Sum[maxn];
void dfs(int x, int from) {
low[x] = dfn[x] = dep++;
vis[x] = 1;
S.push(x);
for (auto i : edge[x])
if (i != from) {
if (!vis[i]) {
dfs(i, x);
low[x] = min(low[x], low[i]);
} else
low[x] = min(low[x], dfn[i]);
}
if (low[x] == dfn[x]) {
xl[cnt] = xr[cnt] = x;
do {
xl[cnt] = min(xl[cnt], S.top());
xr[cnt] = max(xr[cnt], S.top());
if (S.top() == x) break;
S.pop();
} while (1);
S.pop();
cnt++;
}
}
int main() {
int N = read(), M = read();
for (int i = 1; i <= M; i++) {
int l = read(), r = read();
edge[l].push_back(r);
edge[r].push_back(l);
}
for (int i = 1; i <= N; i++) To[i] = N;
for (int i = 1; i <= N; i++)
if (!vis[i]) {
dfs(i, 0);
}
for (int i = 0; i < cnt; i++)
if (xl[i] != xr[i]) {
To[xl[i]] = xr[i] - 1;
}
for (int i = N - 1; i; i--) {
To[i] = min(To[i], To[i + 1]);
}
for (int i = 1; i <= N; i++) {
Sum[i] = Sum[i - 1] + (To[i] - i + 1);
}
int Q = read();
for (int i = 1; i <= Q; i++) {
int l = read(), r = read(), L = l - 1, R = r + 1;
while (L + 1 < R) {
int mid = L + R >> 1;
if (To[mid] > r)
R = mid;
else
L = mid;
}
long long ans = Sum[L] - Sum[l - 1] + 1ll * (r - L) * (r - L + 1) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long a[N], b[N], s[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long n;
cin >> n;
long long i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long sum = 0;
memset(b, 0, sizeof(b));
if (a[0] >= 10) {
sum = a[0] % 10;
b[0] = 1;
} else {
sum = a[0];
b[0] = 0;
}
s[0] = sum;
for (i = 1; i < n; i++) {
if (sum + a[i] >= 10) {
sum = (sum + a[i]) % 10;
b[i] = b[i - 1] + 1;
} else {
sum += a[i];
b[i] = b[i - 1];
}
s[i] = sum;
}
long long q;
cin >> q;
while (q--) {
long long r, l;
cin >> l >> r;
if (l != 1) {
long long res = b[r - 1] - b[l - 2];
if (s[r - 1] < s[l - 2]) {
res--;
}
cout << res << endl;
} else {
cout << b[r - 1] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int number, number2, ans1, ans2 = 0;
while (scanf("%d%d", &number2, &number) == 2) {
ans2 = 0;
for (int i = 1; i <= number2; i++) {
if (number % i == 0) {
ans1 = number / i;
if (ans1 <= number2) {
ans2++;
}
}
}
cout << ans2 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int m = 0;
cin >> n;
string x;
cin >> x;
for (int i = 1; i <= n; i++) {
int k = atoi(x.substr(i - 1, 1).c_str());
if (k / 2 == k / 2.0) {
m += i;
}
}
cout << m;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class flow_graph {
public:
static constexpr T eps = (T)1e-9;
struct edge {
int from;
int to;
T c;
T f;
};
vector<vector<int>> g;
vector<edge> edges;
int n;
int st;
int fin;
T flow;
flow_graph(int _n, int _st, int _fin) : n(_n), st(_st), fin(_fin) {
assert(0 <= st && st < n && 0 <= fin && fin < n && st != fin);
g.resize(n);
flow = 0;
}
void clear_flow() {
for (const edge &e : edges) {
e.f = 0;
}
flow = 0;
}
int add(int from, int to, T forward_cap, T backward_cap) {
assert(0 <= from && from < n && 0 <= to && to < n);
int id = (int)edges.size();
g[from].push_back(id);
edges.push_back({from, to, forward_cap, 0});
g[to].push_back(id + 1);
edges.push_back({to, from, backward_cap, 0});
return id;
}
};
template <typename T>
class dinic {
public:
flow_graph<T> &g;
vector<int> ptr;
vector<int> d;
vector<int> q;
dinic(flow_graph<T> &_g) : g(_g) {
ptr.resize(g.n);
d.resize(g.n);
q.resize(g.n);
}
bool expath() {
fill(d.begin(), d.end(), -1);
q[0] = g.fin;
d[g.fin] = 0;
int beg = 0, end = 1;
while (beg < end) {
int i = q[beg++];
for (int id : g.g[i]) {
const auto &e = g.edges[id];
const auto &back = g.edges[id ^ 1];
if (back.c - back.f > g.eps && d[e.to] == -1) {
d[e.to] = d[i] + 1;
if (e.to == g.st) {
return true;
}
q[end++] = e.to;
}
}
}
return false;
}
T dfs(int v, T w) {
if (v == g.fin) {
return w;
}
int &j = ptr[v];
while (j >= 0) {
int id = g.g[v][j];
const auto &e = g.edges[id];
if (e.c - e.f > g.eps && d[e.to] == d[v] - 1) {
T t = dfs(e.to, min(e.c - e.f, w));
if (t > g.eps) {
g.edges[id].f += t;
g.edges[id ^ 1].f -= t;
return t;
}
}
j--;
}
return 0;
}
T max_flow() {
while (expath()) {
for (int i = 0; i < g.n; i++) {
ptr[i] = (int)g.g[i].size() - 1;
}
T big_add = 0;
while (true) {
T add = dfs(g.st, numeric_limits<T>::max());
if (add <= g.eps) {
break;
}
big_add += add;
}
if (big_add <= g.eps) {
break;
}
g.flow += big_add;
}
return g.flow;
}
vector<bool> min_cut() {
max_flow();
vector<bool> ret(g.n);
for (int i = 0; i < g.n; i++) {
ret[i] = (d[i] != -1);
}
return ret;
}
};
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << ", ";
}
}
template <typename T>
void debug_out(vector<vector<T>> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << endl;
}
}
int n, m, s, t;
struct edge {
int u, v, c, f;
int id;
edge(){};
edge(int _u, int _v, int _c, int _f, int _id)
: u(_u), v(_v), c(_c), f(_f), id(_id){};
};
int main() {
cin >> n >> m >> s >> t;
s--;
t--;
flow_graph<int> st(n, s, t);
vector<edge> res;
vector<vector<int>> edges(n);
vector<vector<int>> sp(n);
vector<int> rev(m);
const int inf = 1e9;
for (int i = 0; i < m; i++) {
int u, v, g;
cin >> u >> v >> g;
u--;
v--;
res.emplace_back(u, v, 0, 0, res.size());
if (g) {
edges[u].push_back(res.size() - 1);
sp[v].push_back(res.size() - 1);
}
rev[i] = g;
st.add(u, v, (g ? 1 : inf), (g ? inf : 0));
}
dinic<int> g(st);
vector<bool> ret = g.min_cut();
vector<int> sat(m);
int cnt = 0;
for (edge e : res) {
if (!ret[e.u] && ret[e.v]) {
sat[e.id] = 1;
cnt++;
}
}
cout << cnt << endl;
vector<vector<int>> stt(n), fin(n);
vector<int> cur;
vector<int> alive(n);
function<void(int)> dfs = [&](int v) {
alive[v] = 1;
stt[v] = cur;
for (auto i : edges[v]) {
int u = res[i].v;
if (alive[u]) continue;
cur.push_back(i);
dfs(u);
cur.pop_back();
}
};
for (int rot = 0; rot < 2; rot++) {
fill(alive.begin(), alive.end(), 0);
dfs(rot ? t : s);
swap(stt, fin);
for (auto &i : res) swap(i.u, i.v);
swap(edges, sp);
}
for (int i = 0; i < m; i++) {
int u = res[i].u, v = res[i].v;
if (!res[i].f && rev[res[i].id]) {
for (auto j : stt[u]) res[j].f++;
for (auto j : fin[v]) res[j].f++;
res[i].f++;
}
}
for (auto &i : res) {
if (sat[i.id]) {
i.c = i.f;
} else
i.c = inf;
}
for (auto i : res) {
cout << i.f << " " << i.c << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
vector<string> v;
int main() {
int n;
cin >> n;
string s, g, d, word;
int x = 0;
m["polycarp"] = 1;
getchar();
for (int i = 0; i < n; i++) {
getline(cin, s);
istringstream f(s);
while (f >> word) {
if (word != "reposted") {
if (d.size() == 0)
d = word;
else
g = word;
}
}
for (int i = 0; i < d.size(); i++) d[i] = tolower(d[i]);
for (int i = 0; i < g.size(); i++) g[i] = tolower(g[i]);
if (m[g] > 0) {
m[d] += m[g] + 1;
}
x = max(x, m[d]);
d.clear();
g.clear();
}
cout << x << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int l[112345], r[112345];
stack<pair<int, int> > st;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
string s = " ";
for (int i = 1; i <= 2 * n; i++) s += ' ';
int c = 0;
for (int i = 1; i <= 2 * n; i++) {
if (s[i] != ' ') continue;
if (st.empty()) {
st.push(make_pair(++c, i));
s[i] = '(';
if (c > n) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
continue;
}
int x = st.top().first;
int y = st.top().second;
if (i - y >= l[x] and i - y <= r[x]) {
s[i] = ')';
st.pop();
} else {
st.push(make_pair(++c, i));
s[i] = '(';
if (c > n) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
}
}
cout << s << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int get_max_prime(int n) {
int sqrt_n = (int)sqrt((double)n);
int p = 2;
for (; p <= sqrt_n; p++)
if (n % p == 0) {
while (n % p == 0) {
n /= p;
}
if (n == 1) return p;
sqrt_n = (int)sqrt((double)n);
}
return n;
}
int get_min_for(int n) { return n - get_max_prime(n) + 1; }
int main(int argc, char* argv[]) {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int N;
scanf("%d", &N);
int ans = N;
int m_;
for (int mmm = get_min_for(N); mmm <= N; mmm++)
if ((m_ = get_max_prime(mmm)) < mmm) ans = min(ans, mmm - m_ + 1);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool mark[1010][1010];
bool flag;
int n, m;
pair<int, int> a[10], b[10];
double get(pair<int, int> p[]) {
double ret = 0.0;
for (int i = 0; i < 3; i++) {
int dx = p[i].first - p[i + 1].first;
int dy = p[i].second - p[i + 1].second;
ret += sqrt(dx * dx + dy * dy + 0.0);
}
return ret;
}
void go(int pos) {
if (pos == 4) {
if (get(b) > get(a))
for (int i = 0; i < 4; i++) a[i] = b[i];
return;
}
int s = (pos % 2 == 0) ? (1) : (-1);
int X, Y;
if (s == 1)
X = 0, Y = 0;
else
X = n, Y = m;
for (int dx = 0; dx <= 4; dx++) {
for (int dy = 0; dy <= 4; dy++) {
b[pos] = make_pair(X + dx * s, Y + dy * s);
if (b[pos].first >= 0 && b[pos].first <= n && b[pos].second >= 0 &&
b[pos].second <= m && !mark[b[pos].first][b[pos].second]) {
mark[b[pos].first][b[pos].second] = true;
go(pos + 1);
mark[b[pos].first][b[pos].second] = false;
}
}
}
}
int main() {
cin >> n >> m;
if (n < m) {
swap(n, m);
flag = true;
}
for (int i = 0; i < 4; i++) a[i] = make_pair(0, 0);
go(0);
if (flag)
for (int i = 0; i < 4; i++) swap(a[i].first, a[i].second);
for (int i = 0; i < 4; i++) cout << a[i].first << ' ' << a[i].second << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,ans=0;
cin>>n;
int arr[n];
for(int i=0;i<n;i++)
{
cin>>arr[i];
if(arr[i]==1 || arr[i]==3)
{
ans++;
}
}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long MOD = 1000000007;
long long add(long long x, long long y) {
return x + y >= MOD ? x + y - MOD : x + y;
}
long long sub(long long x, long long y) {
return x - y < 0 ? x + MOD - y : x - y;
}
char a[2011][2011];
vector<int> down[2011], rig[2011];
long long up[2011][2011], lef[2011];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", a[i]);
for (int i = 0; i < n; ++i) rig[i].push_back(-1);
for (int i = 0; i < m; ++i) down[i].push_back(-1);
for (int i = n - 1; i >= 0; --i) {
for (int j = m - 1; j >= 0; --j) {
if (a[i][j] == 'R') {
down[j].push_back(i);
rig[i].push_back(j);
}
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) up[i][j] = 0;
for (int j = 0; j < m; ++j) lef[j] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i == 0 && j == 0) {
up[i][j] = 1;
lef[j] = 1;
} else {
lef[j] = 0;
up[i][j] = 0;
int rocks, start;
rocks = m - j - 1;
if (j == 0)
start = -2;
else if (rig[i].size() <= rocks + 1)
start = -1;
else {
int far = rig[i][rocks + 1];
if (far == 0)
start = -1;
else if (far == j)
start = -2;
else
start = far - 1;
}
if (start == -2)
up[i][j] = 0;
else if (start == -1)
up[i][j] = lef[j - 1];
else
up[i][j] = sub(lef[j - 1], lef[start]);
if (i > 0) up[i][j] = add(up[i][j], up[i - 1][j]);
rocks = n - i - 1;
if (i == 0)
start = -2;
else if (down[j].size() <= rocks + 1)
start = -1;
else {
int far = down[j][rocks + 1];
if (far == 0)
start = -1;
else if (far == i)
start = -2;
else
start = far - 1;
}
if (start == -2)
lef[j] = 0;
else if (start == -1)
lef[j] = up[i - 1][j];
else
lef[j] = sub(up[i - 1][j], up[start][j]);
if (j > 0) lef[j] = add(lef[j], lef[j - 1]);
}
}
}
long long ret = 0;
ret = add(ret,
n > 1 ? sub(up[n - 1][m - 1], up[n - 2][m - 1]) : up[n - 1][m - 1]);
ret = add(ret, m > 1 ? sub(lef[m - 1], lef[m - 2]) : lef[m - 1]);
if (n == 1 && m == 1) ret = a[0][0] == '.';
printf("%I64d", ret);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
int n, m, A[maxn][maxn];
int N;
struct Tcxx {
int x, y;
inline void set(int _x, int _y) { x = _x, y = _y; }
} B[maxn];
int Bx[maxn], By[maxn];
namespace Ninit {
char s[maxn];
void init() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) {
scanf("%s", s);
for (j = 0; j < m; ++j)
if (s[j] == '.')
A[i][j + 1] = 0;
else {
A[i][j + 1] = 1, B[N++].set(i, j + 1);
Bx[i] = j + 1, By[j + 1] = i;
}
}
}
} // namespace Ninit
namespace Nsolve {
double ans, tot;
namespace Nshort {
void solve() {
int i, j, l, r;
Tcxx *p, *q;
for (i = 1; i <= m; ++i)
for (j = 1; j <= m; ++j) ans += abs(i - j) * n * n;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) ans += abs(i - j) * m * m;
for (p = B; p < B + N; ++p) {
for (j = 1; j <= m; ++j) ans -= 2 * n * abs(j - p->y);
for (j = 1; j <= n; ++j) ans -= 2 * m * abs(j - p->x);
}
for (p = B; p < B + N; ++p)
for (q = B; q < B + N; ++q) ans += abs(p->x - q->x) + abs(p->y - q->y);
tot = (double)(n * m - N) * (n * m - N);
}
} // namespace Nshort
namespace Nlong {
int F[maxn][2][2], G[maxn][2][2];
void solve() {
int i, j;
for (i = 1; i <= n; ++i)
if (Bx[i]) {
F[i][0][0] = Bx[i] - 1, F[i][0][1] = m - Bx[i];
if (Bx[i - 1] && Bx[i - 1] < Bx[i]) F[i][0][0] += F[i - 1][0][0];
if (Bx[i - 1] && Bx[i - 1] > Bx[i]) F[i][0][1] += F[i - 1][0][1];
}
for (i = n; i >= 1; --i)
if (Bx[i]) {
F[i][1][0] = Bx[i] - 1, F[i][1][1] = m - Bx[i];
if (Bx[i + 1] && Bx[i + 1] < Bx[i]) F[i][1][0] += F[i + 1][1][0];
if (Bx[i + 1] && Bx[i + 1] > Bx[i]) F[i][1][1] += F[i + 1][1][1];
}
for (i = 1; i <= m; ++i)
if (By[i]) {
G[i][0][0] = By[i] - 1, G[i][0][1] = n - By[i];
if (By[i - 1] && By[i - 1] < By[i]) G[i][0][0] += G[i - 1][0][0];
if (By[i - 1] && By[i - 1] > By[i]) G[i][0][1] += G[i - 1][0][1];
}
for (i = m; i >= 1; --i)
if (By[i]) {
G[i][1][0] = By[i] - 1, G[i][1][1] = n - By[i];
if (By[i + 1] && By[i + 1] < By[i]) G[i][1][0] += G[i + 1][1][0];
if (By[i + 1] && By[i + 1] > By[i]) G[i][1][1] += G[i + 1][1][1];
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
if (!A[i][j]) {
if (Bx[i]) {
Bx[i] < j ? ans += 2 * (F[i][0][0] + F[i][1][0] - Bx[i] + 1)
: ans += 2 * (F[i][0][1] + F[i][1][1] - m + Bx[i]);
}
if (By[j]) {
By[j] < i ? ans += 2 * (G[j][0][0] + G[j][1][0] - By[j] + 1)
: ans += 2 * (G[j][0][1] + G[j][1][1] - n + By[j]);
}
}
}
} // namespace Nlong
void solve() {
Nshort::solve();
Nlong::solve();
printf("%.9lf\n", ans / tot);
}
} // namespace Nsolve
int main() {
Ninit::init();
Nsolve::solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int kmp(string T, string &P) {
if (P.empty()) return 0;
if (T.size() < P.size()) return 0;
vector<int> prefix(P.size(), 0);
for (int i = 1, k = 0; i < P.size(); ++i) {
while (k && P[k] != P[i]) k = prefix[k - 1];
if (P[k] == P[i]) ++k;
prefix[i] = k;
}
int count = 0;
for (int i = 0, k = 0; i < T.size(); ++i) {
while (k && P[k] != T[i]) k = prefix[k - 1];
if (P[k] == T[i]) ++k;
if (k == P.size()) count++;
}
return count;
}
int main() {
int n, m, q;
string s, t;
cin >> n >> m >> q;
cin >> s >> t;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
string sub = s.substr(l - 1, r - l + 1);
int ret = kmp(sub, t);
cout << ret << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int len, ans;
struct node {
int x;
int d;
} num[100005];
bool cmp(node a, node b) { return a.x < b.x; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num[i].x);
num[i].d = i;
}
sort(num, num + n, cmp);
len = ans = 0;
m = -1;
for (int i = 0; i < n; i++) {
if (num[i].d > m) {
len++;
if (len > ans) ans = len;
m = num[i].d;
} else {
m = num[i].d;
len = 1;
}
}
printf("%d\n", n - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[3005][3005];
int T[3005];
vector<int> V;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &T[i]), T[i] -= i, V.push_back(T[i]);
sort(V.begin(), V.end());
V.resize(unique(V.begin(), V.end()) - V.begin());
for (int j = 0; j < V.size(); j++) dp[0][j] = abs(T[0] - V[j]);
for (int i = 1; i < n; i++) {
long long mn = 1e18;
for (int j = 0; j < V.size(); j++) {
mn = min(mn, dp[i - 1][j]);
dp[i][j] = mn + abs(T[i] - V[j]);
}
}
long long ans = 1e18;
for (int i = 0; i < V.size(); i++) ans = min(ans, dp[n - 1][i]);
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 1e5 + 10;
int a[N];
long long LIS(int i = 0) {
vector<int> ret;
for (int i = 0; i < n; i++) {
auto it = lower_bound(ret.begin(), ret.end(), a[i]);
if (it == ret.end())
ret.push_back(a[i]);
else
*it = a[i];
}
return (int)ret.size();
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << LIS();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int c;
while (a != 0) {
c = b % a;
b = a;
a = c;
}
return b;
}
int main() {
int a, b, n, f, g, i;
cin >> a >> b >> n;
int temp = 0;
for (i = 1;; i++) {
if (i % 2 != 0) {
f = gcd(a, n);
if (f >= n) {
temp = 0;
break;
} else {
n -= f;
}
} else {
g = gcd(b, n);
if (g >= n) {
temp = 1;
break;
} else {
n -= g;
}
}
}
cout << temp << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int b[200005];
int main() {
int n;
long long sum = 0, A;
scanf("%d%I64d", &n, &A);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 1; i <= n; ++i) {
int MIN = max((long long)1, A - (sum - a[i]));
int MAX = min((long long)a[i], A - (n - 1));
b[i] = a[i] - (MAX - MIN + 1);
}
for (int i = 1; i <= n; ++i) {
if (i != 1) printf(" ");
printf("%d", b[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct fr {
unsigned long long x, k;
int m;
long p;
} fr;
fr A[120];
int n, m;
unsigned long long b;
inline bool frsort(fr a, fr b) { return a.k < b.k; }
int main() {
scanf("%d %d %I64d", &n, &m, &b);
for (int i = (1); i <= (n); i++) {
scanf("%I64d %I64d %d", &A[i].x, &A[i].k, &A[i].m);
A[i].p = 0;
int p;
for (int j = (1); j <= (A[i].m); j++) {
scanf("%d", &p);
p--;
A[i].p |= (1 << p);
}
}
sort(A + 1, A + n + 1, frsort);
unsigned long long ans = ULLONG_MAX;
int lim = (1 << m) - 1;
int c = 0;
unsigned long long dp[2][lim + 3];
for (int i = (0); i <= (lim); i++) dp[c][i] = (i == lim) ? 0 : ULLONG_MAX;
for (int i = (1); i <= (n); i++) {
for (int j = (0); j <= (lim); j++) {
unsigned long long x = dp[c][j];
unsigned long long y = dp[c][j | A[i].p];
if (y < ULLONG_MAX) y += A[i].x;
dp[1 - c][j] = (((x) < (y)) ? (x) : (y));
}
c = 1 - c;
if (dp[c][0] < ULLONG_MAX)
ans =
(((ans) < (dp[c][0] + A[i].k * b)) ? (ans) : (dp[c][0] + A[i].k * b));
}
if (ans < ULLONG_MAX) {
cout << ans << endl;
} else {
cout << (-1) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long T;
cin >> T;
while (T--) {
long long n;
long long a, ans = 0;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a;
ans += a;
}
cout << !((ans % n) == 0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
auto gucciGang = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}();
int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
if (a == b) {
cout << 0 << "\n";
} else {
long long int x;
long long int max_e = max(a, b);
long long int min_e = min(a, b);
if (max_e % min_e) {
cout << -1 << "\n";
} else {
x = max_e / min_e;
int count = 0;
while (!(x & 1)) {
count++;
x = x >> 1;
}
if (x == 1) {
int z = (count / 3);
if ((count % 3)) {
z++;
}
cout << z << "\n";
} else {
cout << -1 << "\n";
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[30];
int GG[30][30];
char str[100005];
vector<int> ans;
int vis[30];
bool dfs(int x) {
vis[x] = 1;
ans.push_back(x);
for (auto i : G[x]) {
if (vis[i] || !dfs(i)) {
return false;
}
}
return true;
}
int d[30];
int oc[30];
int main(int argc, const char* argv[]) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", str);
int l = (int)strlen(str);
for (int j = 0; j < l; j++) {
oc[str[j] - 'a'] = 1;
if (j == l - 1) {
break;
}
if (!GG[str[j] - 'a'][str[j + 1] - 'a']) {
G[str[j] - 'a'].push_back(str[j + 1] - 'a');
d[str[j + 1] - 'a']++;
GG[str[j] - 'a'][str[j + 1] - 'a'] = 1;
}
}
}
memset(vis, 0, sizeof vis);
for (int i = 0; i < 26; i++) {
if (!oc[i]) continue;
if (!vis[i] && d[i] == 0 && !dfs(i)) {
puts("NO");
return 0;
}
}
for (int i = 0; i < 26; i++) {
if (G[i].size() > 1) {
puts("NO");
return 0;
}
if (G[i].size() && vis[i] == 0) {
puts("NO");
return 0;
}
}
for (int i = 0; i < ans.size(); i++) {
putchar('a' + ans[i]);
}
putchar('\n');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int main() {
int n;
long long ans;
cin >> n;
ans = 2 * 4 * 3 * binpow(4, n - 3) + 4 * 3 * 3 * (n - 3) * binpow(4, n - 4);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m;
cin >> t;
while (t--) {
cin >> n >> m;
int ans = 0;
ans = ((n * m) + 1) / 2;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 mt(736);
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n;
cin >> n;
vector<vector<int>> arr(n, vector<int>(3));
for (auto &row : arr) {
for (auto &it : row) cin >> it;
}
vector<bool> used(n);
int cur = 0;
auto dist = [](const vector<int> &a, const vector<int> &b) {
int sum = 0;
for (int i = 0; i < a.size(); i++) sum += abs(a[i] - b[i]);
return sum;
};
while (cur < n) {
if (used[cur]) {
cur++;
continue;
}
int sn = -1;
for (int i = cur + 1; i < n; i++)
if (!used[i] &&
(sn == -1 || dist(arr[cur], arr[i]) < dist(arr[cur], arr[sn])))
sn = i;
assert(sn != -1);
cout << cur + 1 << ' ' << sn + 1 << endl;
used[cur] = true;
used[sn] = true;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
cout << (int)(n / 7) * 2 + max(0, n % 7 - 5) << ' '
<< (int)((n / 7) * 2 + min(2, n % 7)) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b = 0, c = 0, d = 0, e = 0;
cin >> a;
int arr[a];
for (int i = 0; i < a; i++) {
cin >> arr[i];
}
b = arr[0];
for (int i = 0; i < a; i++) {
if (i != 0) {
if (arr[i] >= b) {
c = arr[i];
d = i;
break;
}
}
}
for (int i = 0; i < a; i++) {
if (i != d) {
if (arr[i] >= (b + c)) {
e = i;
break;
}
}
}
if (e != 0) {
cout << 1 << " " << d + 1 << " " << e + 1 << endl;
} else {
cout << -1 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int kn = 101;
long long binpow(long long u, long long v) {
if (v == 0) return 1;
if (v == 1) return u;
long long T = binpow(u, v >> 1LL);
T = (T * T) % mod;
if (v & 1LL) return (T * u) % mod;
return T;
}
long long C[kn][kn], huhu[kn][kn][kn], dp[kn][kn * kn], n, m, k, ha, uwu;
int main() {
cin >> n >> m >> k;
ha = m % n;
uwu = m / n;
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[0][i] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[j][i] = C[j][i - 1] + C[j - 1][i - 1];
if (C[j][i] >= mod) C[j][i] %= mod;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int pos = 1; pos <= n; pos++) {
huhu[j][i][pos] = binpow(C[j][i], uwu + 1LL * (pos <= ha));
}
}
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = 1;
for (long long num = 1; num <= min(k, i * n); num++) {
for (int curnum = 0; curnum <= min(num, n); curnum++) {
dp[i][num] += dp[i - 1][num - curnum] * huhu[curnum][n][i];
if (dp[i][num] >= mod) dp[i][num] %= mod;
}
}
}
cout << dp[n][k] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int maxx(int x, int y) {
if (x > y) y = x;
return y;
}
int minx(int x, int y) {
if (x < y) y = x;
return y;
}
int main() {
int h1, h2, a1, a2, d1, d2, ph, pa, pd, i, j, k;
cin >> h1 >> a1 >> d1 >> h2 >> a2 >> d2 >> ph >> pa >> pd;
a1 -= d2;
a2 -= d1;
k = 99999999;
for (i = 0; i <= 200; i++)
for (j = 0; j <= 100; j++)
if (a1 + i > 0)
k = minx(k,
pa * i + pd * j +
ph * maxx(0, ((h2 - 1) / (a1 + i) + 1) * maxx(0, a2 - j) -
h1 + 1));
cout << k;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], prefix[100010], suffix[100010];
int Max(int x, int y) {
if (x > y)
return x;
else
return y;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int bestRes = 0;
int currentSum = 0;
prefix[0] = 0;
for (int i = 0; i <= n; i++) {
currentSum -= a[i];
prefix[i] = Max(prefix[i - 1] + a[i], currentSum);
}
bestRes = Max(-currentSum, prefix[n]);
currentSum = 0;
for (int i = n; i >= 1; i--) {
currentSum -= a[i];
suffix[i] = Max(suffix[i + 1] + a[i], currentSum);
bestRes = Max(bestRes, prefix[i - 1] + suffix[i]);
}
cout << bestRes;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int t, n, k;
cin >> t;
while (t--) {
cin >> n >> k;
int ans = 1;
int temp, last;
cin >> temp;
ans = max(temp, 1);
last = temp;
int cnt;
for (int i = 2; i <= k; i++) {
cin >> temp;
cnt = ((temp - last) / 2) + 1;
ans = max(ans, cnt);
last = temp;
}
ans = max(n - last + 1, ans);
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int ms = 200200;
int bit[ms];
int qry(int x) {
int ans = 0;
for (; x < ms; x += x & -x) {
ans = std::max(ans, bit[x]);
}
return ans;
}
void upd(int x, int v) {
for (; x > 0; x -= x & -x) {
bit[x] = std::max(v, bit[x]);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> n;
std::vector<int> a(n);
std::vector<int> last(n, 1);
for (auto &v : a) std::cin >> v;
int q;
std::cin >> q;
for (int i = 1; i <= q; i++) {
int t;
std::cin >> t;
if (t == 1) {
int p, x;
std::cin >> p >> x;
p--;
a[p] = x;
last[p] = i;
} else {
int x;
std::cin >> x;
upd(i, x);
}
}
for (int i = 0; i < n; i++) {
a[i] = std::max(a[i], qry(last[i]));
std::cout << a[i] << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)9e18 + 7;
const long long P1 = 353251;
const long long P2 = 239017;
const long long MOD = 1e9 + 7;
const long long MOD1 = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
int n;
vector<int> g[2 * 100007];
vector<long long> pref[2 * 100007];
vector<long long> suf[2 * 100007];
long long dp[2 * 100007];
long long ans[2 * 100007];
void dfs(int v, int pred = -1) {
dp[v] = 1;
vector<long long> now;
for (int to : g[v])
if (pred != to) {
dfs(to, v);
now.push_back(dp[to] + 1);
dp[v] = dp[v] * (dp[to] + 1) % MOD;
} else
now.push_back(1);
long long last = 1;
for (long long x : now)
pref[v].push_back(last * x % MOD), last = last * x % MOD;
last = 1;
reverse(now.begin(), now.end());
for (long long x : now)
suf[v].push_back(last * x % MOD), last = last * x % MOD;
reverse(suf[v].begin(), suf[v].end());
}
long long bp(long long a, long long k) {
if (k == 1) return a;
if (k & 1) {
return bp(a, k - 1) * a % MOD;
} else {
long long q = bp(a, k / 2);
return q * q % MOD;
}
}
long long getobr(long long q) { return bp(q, MOD - 2); }
void dfs2(int v, int pred, long long was) {
ans[v] = dp[v] * (was + 1) % MOD;
int f = 0;
for (int to : g[v]) {
if (pred != to) {
long long fd = (f - 1 < 0 ? 1 : pref[v][f - 1]) *
(f + 1 > (int)suf[v].size() - 1 ? 1 : suf[v][f + 1]) % MOD;
fd = fd * (was + 1) % MOD;
dfs2(to, v, fd);
}
f++;
}
}
const bool is_testing = 0;
int main() {
srand('D' + 'E' + 'N' + 'I' + 'S' + 'S' + 'O' + 'N');
if (is_testing) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
} else {
}
cin >> n;
for (int i = 0; i < n - 1; i++) {
int q;
cin >> q;
q--;
g[q].push_back(i + 1);
g[i + 1].push_back(q);
}
dfs(0);
ans[0] = dp[0];
int f = 0;
for (int to : g[0]) {
long long fd = (f - 1 < 0 ? 1 : pref[0][f - 1]) *
(f + 1 > (int)suf[0].size() - 1 ? 1 : suf[0][f + 1]) % MOD;
dfs2(to, 0, fd);
f++;
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y;
int a[100005];
set<int> b;
int found1(int k) {
for (int i = 1; i <= n; i++)
if (b.count(a[i] - k)) return 1;
return 0;
}
int found2() {
for (int i = 1; i <= n; i++) {
if (a[i] + x <= l && (b.count(a[i] + x + y) || b.count(a[i] + x - y)))
return a[i] + x;
if (a[i] - x >= 0 && (b.count(a[i] - x + y) || b.count(a[i] - x - y)))
return a[i] - x;
}
return -1;
}
int main() {
cin >> n >> l >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b.insert(a[i]);
}
int a1 = 0;
int a2 = 0;
a1 = found1(x);
a2 = found1(y);
if (a1 && a2)
cout << "0" << endl;
else if (a1 && !a2)
cout << "1" << endl << y << endl;
else if (!a1 && a2)
cout << "1" << endl << x << endl;
else {
int te = found2();
if (te == -1)
cout << "2" << endl << x << ' ' << y << endl;
else
cout << "1" << endl << te << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n;
char a[N];
int f[N][N], app[N], ans;
int main() {
scanf("%d", &n);
scanf("%s", a + 1);
ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
f[i][j] = 1;
for (int k = i; k <= j; k++)
if (!(a[k] >= 'a' && a[k] <= 'z')) {
f[i][j] = 0;
break;
}
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
if (f[i][j]) {
memset(app, 0, sizeof app);
int cnt = 0;
for (int k = i; k <= j; k++)
if (!app[a[k]]) app[a[k]] = 1, cnt++;
ans = max(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
while (cin >> a >> b) {
long long count = 0, c = 1;
while (c != 0) {
c = a % b;
count = count + a / b;
a = b;
b = c;
}
cout << count << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
string a[N];
int main() {
long double l, v1, v2, k;
long long n;
cin >> n >> l >> v1 >> v2 >> k;
n = (n + k - 1) / k;
cout << fixed << setprecision(17)
<< l * ((2 * (long double)n - 1) * v2 + v1) /
((2 * (long double)n - 1) * v1 + v2) / v2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void fft(vector<complex<long double> > &a, bool invert) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1) j -= bit;
j += bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
long double ang = 2 * PI / len * (invert ? -1 : 1);
complex<long double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<long double> w(1);
for (int j = 0; j < len / 2; ++j) {
complex<long double> u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; ++i) a[i] /= n;
}
inline void input(int &a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(long long a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[20];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
struct lnum {
vector<int> a;
int base;
lnum(int num = 0, int base = 1000000000) : base(base) {
if (!num) a.resize(1);
while (num) {
a.push_back(num % base);
num /= base;
}
}
inline int len() const { return a.size(); }
lnum &operator=(const lnum &l) {
if (this != &l) {
a = l.a;
base = l.base;
}
return *this;
}
inline friend lnum operator+(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int ln = l.len(), rn = r.len();
int n = max(ln, rn);
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = o;
if (i < ln) s += l.a[i];
if (i < rn) s += r.a[i];
o = s >= base;
if (o) s -= base;
ret.a[i] = s;
}
if (o) ret.a.push_back(1);
return ret;
}
inline friend lnum operator-(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int n = l.len();
int rn = r.len();
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = l.a[i] - o;
if (i < rn) s -= r.a[i];
o = s < 0;
if (o) s += base;
ret.a[i] = s;
}
if (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator*(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
if (l.len() * r.len() > 1000000) {
vector<complex<long double> > fa(l.a.begin(), l.a.end()),
fb(r.a.begin(), r.a.end());
int n = 1;
while (n < max(l.len(), r.len())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
fft(fa, false), fft(fb, false);
for (int i = 0; i < n; ++i) fa[i] *= fb[i];
fft(fa, true);
ret.a.resize(n);
for (int i = 0; i < n; ++i) ret.a[i] = int(fa[i].real() + 0.5);
int carry = 0;
for (int i = 0; i < n; ++i) {
ret.a[i] += carry;
carry = ret.a[i] / base;
ret.a[i] %= base;
}
} else {
ret.a.resize(l.len() + r.len());
for (int i = 0; i < l.len(); ++i)
for (int j = 0, carry = 0; j < r.len() || carry; ++j) {
long long cur = ret.a[i + j] +
(long long)l.a[i] * (j < r.len() ? r.a[j] : 0) +
carry;
ret.a[i + j] = cur % base;
carry = cur / base;
}
}
while (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator/(const lnum &l, const int &r) {
lnum ret(0, l.base);
ret.a.resize(l.len());
int carry = 0;
for (int i = l.len() - 1; i >= 0; --i) {
long long cur = l.a[i] + (long long)carry * l.base;
ret.a[i] = cur / r;
carry = cur % r;
}
while (ret.len() > 1 && ret.a.back() == 0) ret.a.pop_back();
return ret;
}
inline friend bool operator<(const lnum &l, const lnum &r) {
if (l.len() < r.len()) return true;
if (l.len() > r.len()) return false;
int n = l.len();
for (int i = n - 1; i >= 0; --i) {
if (l.a[i] < r.a[i]) return true;
if (l.a[i] > r.a[i]) return false;
}
return false;
}
inline friend bool operator>(const lnum &l, const lnum &r) { return r < l; }
inline friend bool operator==(const lnum &l, const lnum &r) {
if (l.len() != r.len()) return false;
int n = l.len();
for (int i = n - 1; i; --i) {
if (l.a[i] != r.a[i]) return false;
}
return true;
}
inline friend bool operator!=(const lnum &l, const lnum &r) {
return !(l == r);
}
inline void print() {
if (base == 1000000000) {
printf("%d", a.back());
for (int i = a.size() - 2; i >= 0; --i) printf("%09d", a[i]);
} else {
for (int i = a.size() - 1; i >= 0; --i) printf("%d", a[i]);
}
}
};
int main() {
map<int, int> cnt;
int(n);
input((n));
;
for (int i = 0; i < (int)(n); i++) cnt[nxt()]++;
int ans = 0;
for (auto it = cnt.begin(); it != cnt.end(); ++it) {
if (it->second > 1) cnt[it->first + 1] += it->second / 2;
it->second &= 1;
}
int prev = -1;
for (auto it = cnt.begin(); it != cnt.end(); ++it) {
if (it->second) {
ans += it->first - prev - 1;
prev = it->first;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
string t[m];
for (int i = 0; i < m; i++) cin >> t[i];
cin >> q;
int year;
while (q--) {
cin >> year;
cout << s[(year - 1) % n] + t[(year - 1) % m] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, tmp1, tmp2;
cin >> n >> m;
vector<int> v[n + 1];
vector<pair<int, int> > ans;
for (int i = 0; i < m; i++) {
cin >> tmp1 >> tmp2;
v[tmp1].push_back(tmp2);
v[tmp2].push_back(tmp1);
}
int loll;
for (int i = 1; i <= n; ++i) {
if (v[i].size() == 0) {
loll = i;
break;
}
}
cout << n - 1 << '\n';
for (int i = 1; i <= n; ++i) {
if (i != loll) cout << i << " " << loll << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n;
int a[1000];
int b[1000];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", a + i, b + i);
}
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
printf("rated\n");
return 0;
}
}
for (int i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
printf("unrated\n");
return 0;
}
}
printf("maybe\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int modpow(int a, int n) {
int ans = 1;
while (n > 0) {
if ((n & 1) != 0) ans = (int)(((long long)ans * a) % 1000003);
a = (int)(((long long)a * a) % 1000003);
n >>= 1;
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
if (n == 0)
printf("1\n");
else
printf("%d\n", modpow(3, n - 1));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 22, MAXM = 4e5 + 10, INF = 1e16;
int n, len[MAXN], sum[MAXN][MAXM], pre[MAXN][MAXM];
long long f[(1 << 20) + 5], ans;
char s[MAXN][MAXM];
vector<int> occ[MAXN][MAXM];
void update(int i, int s, int j) {
int L = 1, R = len[j], pos = 1e9, ret = 0;
while (L <= R) {
int mid = (L + R) >> 1;
if (pre[j][mid] < -s) {
pos = mid;
R = mid - 1;
} else {
L = mid + 1;
}
}
ret =
lower_bound(occ[j][s].begin(), occ[j][s].end(), pos) - occ[j][s].begin();
ans = max(ans, f[i] + ret);
if (pos == 1e9)
f[i | (1 << (j - 1))] = max(f[i | (1 << (j - 1))], f[i] + ret);
}
void dp() {
for (int i = (0); i <= ((1 << n) - 1); i++) {
int s = 0;
for (int j = (0); j <= (n - 1); j++)
if ((i >> j) & 1) s += sum[j + 1][len[j + 1]];
if (s < 0) continue;
for (int j = (0); j <= (n - 1); j++)
if (!((i >> j) & 1)) update(i, s, j + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
scanf("%s", s[i] + 1);
len[i] = strlen(s[i] + 1);
}
for (int i = (1); i <= (n); i++) {
pre[i][0] = 1e9;
for (int j = (1); j <= (len[i]); j++) {
sum[i][j] = sum[i][j - 1];
if (s[i][j] == '(')
sum[i][j]++;
else
sum[i][j]--;
pre[i][j] = min(pre[i][j - 1], sum[i][j]);
}
for (int j = (1); j <= (len[i]); j++) {
if (sum[i][j] <= 0) occ[i][-sum[i][j]].push_back(j);
}
}
for (int i = (1); i <= ((1 << n) - 1); i++) f[i] = -INF;
ans = 0;
dp();
for (int i = (1); i <= ((1 << n) - 1); i++) ans = max(ans, f[i]);
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 9;
const int MAXN = 1e5 + 5;
priority_queue<int> maxpq;
priority_queue<int, vector<int>, greater<int> > minpq;
int N;
vector<long long> number;
map<int, int> Y[MAXN];
pair<int, int> ps[MAXN];
bool erased[MAXN];
bool debug = false;
int who(int x, int y) {
if (Y[y].count(x) == 0) return -1;
return Y[y][x];
}
int cntsup(int i) {
int x = ps[i].first, y = ps[i].second;
int cnt = 0;
for (int j = -1; j < (int)2; j++) cnt += who(x + j, y - 1) != -1;
debug&& printf("cntsup(%d) = %d\n", i, cnt);
return cnt;
}
bool isfree(int i) {
int x = ps[i].first, y = ps[i].second;
if ((who(x - 1, y + 1) == -1 || cntsup(who(x - 1, y + 1)) > 1) &&
(who(x, y + 1) == -1 || cntsup(who(x, y + 1)) > 1) &&
(who(x + 1, y + 1) == -1 || cntsup(who(x + 1, y + 1)) > 1)) {
return true;
}
return false;
}
void iffreeadd(int x, int y) {
int i = Y[y][x];
if ((who(x - 1, y + 1) == -1 || cntsup(who(x - 1, y + 1)) > 1) &&
(who(x, y + 1) == -1 || cntsup(who(x, y + 1)) > 1) &&
(who(x + 1, y + 1) == -1 || cntsup(who(x + 1, y + 1)) > 1)) {
maxpq.push(i);
minpq.push(i);
debug&& printf("%d is free\n", i);
}
}
void erase(int i) {
int x = ps[i].first, y = ps[i].second;
Y[y].erase(x);
if (y == 0) return;
if (who(x - 1, y - 1) != -1) iffreeadd(x - 1, y - 1);
if (who(x, y - 1) != -1) iffreeadd(x, y - 1);
if (who(x + 1, y - 1) != -1) iffreeadd(x + 1, y - 1);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < (int)N; i++) {
scanf("%d", &ps[i].first), scanf("%d", &ps[i].second);
Y[ps[i].second][ps[i].first] = i;
}
for (int i = 0; i < (int)N; i++) {
int x = ps[i].first, y = ps[i].second;
iffreeadd(x, y);
}
for (int i = 0; i < (int)N; i++) {
int nxt;
if (i % 2 == 0) {
nxt = maxpq.top();
maxpq.pop();
while (erased[nxt] || !isfree(nxt)) {
nxt = maxpq.top();
maxpq.pop();
}
} else {
nxt = minpq.top();
minpq.pop();
while (erased[nxt] || !isfree(nxt)) {
nxt = minpq.top();
minpq.pop();
}
}
debug&& printf(" %d\n", nxt);
erased[nxt] = true;
erase(nxt);
number.push_back(nxt);
}
long long ans = 0;
long long pot = 1;
for (int i = number.size() - 1; i > (int)-1; i--) {
ans = (ans + number[i] * pot % MOD) % MOD;
pot = pot * N % MOD;
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
vector<long long> a(n + 1);
vector<vector<long long>> dp(2, vector<long long>(n + 1));
for (int i = 1; i <= n; ++i) cin >> a[i];
partial_sum(a.begin(), a.end(), a.begin());
for (int j = 1; j <= k; ++j)
for (int i = j * m; i <= n; ++i)
dp[j & 1][i] =
max(dp[j & 1][i - 1], (a[i] - a[i - m]) + dp[j & 1 ^ 1][i - m]);
cout << dp[k & 1][n];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int c[N], d[N], m;
vector<int> adj[N];
void dfs(int s, int p, int x) {
if (adj[s].size() == 1) c[d[s]] += x;
m = max(m, d[s]);
for (auto it : adj[s]) {
if (it != p) {
d[it] = d[s] + 1;
dfs(it, s, x);
}
}
}
int main() {
int n, i, x, y;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &x, &y);
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
long long ans = 0, t;
for (auto it : adj[0]) {
m = 0;
t = 0;
dfs(it, 0, 1);
for (i = 1; i <= m; i++)
if (c[i]) t = max(t, (long long)i - 1) + c[i];
dfs(it, 0, -1);
ans = max(ans, t + 1);
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 20;
long long n, h[2][MAXN], res[2][MAXN];
long long cal() {
res[0][1] = max(h[0][0], h[1][0] + h[0][1]);
res[1][1] = max(h[1][0], h[0][0] + h[1][1]);
for (int i = 2; i < n; i++) {
res[0][i] = max(res[0][i - 1], res[1][i - 1] + h[0][i]);
res[1][i] = max(res[1][i - 1], res[0][i - 1] + h[1][i]);
}
return max(res[0][n - 1], res[1][n - 1]);
}
int main() {
cin >> n;
for (int i = 0; i < 2; i++)
for (int j = 0; j < n; j++) cin >> h[i][j];
if (n == 1)
cout << max(h[0][0], h[1][0]) << endl;
else
cout << cal() << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
const double eps = 1e-9;
int ts, kk = 1;
int n, m, q;
int ps[105], a[105];
int main() {
int t, i, j, k;
scanf("%d%d%d", &n, &m, &q);
for (i = 0; i < q; i++) {
scanf("%d", &a[i + 1]);
ps[a[i + 1]] = i + 1;
}
int rs = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
int x;
scanf("%d", &x);
rs += ps[x];
for (k = ps[x] - 1; k > 0; k--) {
swap(a[k], a[k + 1]);
ps[a[k]] = k;
ps[a[k + 1]] = k + 1;
}
}
}
cout << rs << '\n';
return 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const long long inv2 = (998244353 + 1) / 2;
long long a[1000005], d, b[1000005], s[1000005], t[1000005], c[1000005], ans;
int n, tt;
long long pow_(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % 998244353;
x = x * x % 998244353;
y >>= 1;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) s[i] = 1, t[i] = 1;
d = n;
for (int i = n; i; i--) {
if (a[i] != -1) {
tt = a[i] - 1;
while (tt) ans += b[tt], tt -= tt & (-tt);
tt = a[i];
while (tt < 1000005) b[tt]++, tt += tt & (-tt);
s[i] = 0;
d--;
t[a[i]] = 0;
}
}
for (int i = 1; i <= n; i++) {
s[i] += s[i - 1];
t[i] += t[i - 1];
}
(ans += d * (d - 1) / 2 % 998244353 * inv2) %= 998244353;
long long inv = pow_(d, 998244353 - 2);
for (int i = 1; i <= n; i++) {
if (a[i] != -1) {
(ans += (s[i] * (d - t[a[i]]) + (d - s[i]) * t[a[i]]) % 998244353 *
inv) %= 998244353;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 3010;
long long inv[maxn * 2], sum[3];
int a[200010], b[200010];
long long f[3010][3010], g[3010][3010];
long long qpow(long long x, long long y) {
long long ans = 1;
for (; y; y >>= 1) {
if (y & 1) ans = (ans * x) % mod;
x = (x * x) % mod;
}
return ans;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
sum[2] += b[i];
sum[a[i]] += b[i];
}
for (int i = max(0ll, m - sum[0]); i <= 2 * m; i++)
inv[i] = qpow(sum[2] + i - m, mod - 2);
for (int i = m; i >= 0; i--) {
f[i][m - i] = 1, g[i][m - i] = 1;
for (int j = min(sum[0], (long long)m - i - 1); j >= 0; j--) {
f[i][j] = ((sum[1] + i + 1) * f[i + 1][j] + (sum[0] - j) * f[i][j + 1]) %
mod * inv[i - j + m] % mod;
g[i][j] = ((sum[1] + i) * g[i + 1][j] + (sum[0] - j - 1) * g[i][j + 1]) %
mod * inv[i - j + m] % mod;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] == 1)
printf("%lld\n", f[0][0] * b[i] % mod);
else
printf("%lld\n", g[0][0] * b[i] % mod);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long m, n, c;
cin >> n >> m >> c;
long a[100001];
long b[100001];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) cin >> b[i];
int k = n - m + 1;
int j = 0;
while (k--) {
for (int i = j, f = 0; i < m + j; ++i, ++f) {
a[i] = (a[i] + b[f]) % c;
}
j++;
}
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
cin >> n;
long long int a[101], h[101] = {0}, ans = 0, sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
h[a[i]]++;
}
for (i = 1; i <= 100; i++) {
sum = sum + (h[i] / 2);
}
cout << sum / 2 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 10000003;
int p[MX];
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int find(int x) { return x != p[x] ? p[x] = find(p[x]) : x; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
p[x] = x;
}
for (int x = 1; x * x < MX; ++x)
for (int y = x + 1;; y += 2)
if (gcd(x, y) == 1) {
int a = y * y - x * x;
int b = 2 * x * y;
if (a >= MX || b >= MX) break;
int c = x * x + y * y;
if (p[a]) {
if (p[b]) p[find(b)] = find(a);
if (c < MX && p[c]) p[find(c)] = find(a);
} else if (p[b] && c < MX && p[c])
p[find(c)] = find(b);
}
int res = 0;
for (int x = 1; x < MX; ++x)
if (p[x] == x) ++res;
printf("%d\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int num) {
bool flag = true;
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
flag = false;
break;
}
}
return flag;
}
int n, m;
bool f = true;
int main() {
cin >> n >> m;
for (int i = n + 1; i < m + 1; i++) {
if (isPrime(i)) {
if (i != m) {
cout << "NO";
f = false;
break;
}
}
}
if (!isPrime(m) && f) {
f = false;
cout << "NO";
}
if (f) {
cout << "YES";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
long long k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (k > i)
k = k - i;
else {
cout << a[k];
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long sum;
long long x;
int main() {
int p = 0;
cin >> x;
x = abs(x);
while (sum + p <= x) sum += p++;
p--;
if (sum == x)
cout << p << endl;
else if (p & 1) {
int tmp = x - (p + 1) * p / 2;
if (tmp & 1)
cout << p + 2 << endl;
else
cout << p + 1 << endl;
} else {
int tmp = x - (p + 1) * p / 2;
if (tmp & 1)
cout << p + 1 << endl;
else
cout << p + 3 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sim(int k) {
int n = 2;
while (n * n <= k) {
if (k % n == 0) return 0;
n++;
}
return 1;
}
int main() {
int n;
cin >> n;
int m1 = 0, me = 0, mo = 0, a;
vector<int> e;
vector<int> odd;
for (int i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 0) {
e.push_back(a);
} else {
if (a == 1) {
m1++;
} else {
odd.push_back(a);
}
}
}
me = e.size();
mo = odd.size();
if (m1 == 0) {
for (int i = 0; i < mo; i++)
for (int j = 0; j < me; j++) {
if (sim(e[j] + odd[i])) {
cout << 2 << endl;
cout << e[j] << " " << odd[i];
return 0;
}
}
cout << 1 << endl;
cout << a;
} else {
for (int i = 0; i < me; i++) {
if (sim(e[i] + 1)) {
cout << m1 + 1 << endl;
cout << e[i] << " ";
for (int j = 0; j < m1; j++) {
cout << 1 << " ";
}
return 0;
}
}
if (m1 == 1) {
for (int i = 0; i < mo; i++)
for (int j = 0; j < me; j++) {
if (sim(e[j] + odd[i])) {
cout << 2 << endl;
cout << e[j] << " " << odd[i];
return 0;
}
}
}
cout << m1 << endl;
for (int j = 0; j < m1; j++) {
cout << 1 << " ";
}
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void process() {
int a[] = {2, 7, 2, 3, 3, 4, 2, 5, 1, 2};
int n;
cin >> n;
cout << a[n % 10] * a[n / 10] << endl;
}
int main(void) {
process();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 10000 + 10, T = 1000 + 10;
int n, m, d[M], g, r;
int dis[M][T];
deque<pair<int, int> > Q;
bool vis[M][T];
void BFS() {
sort(d + 1, d + m + 1);
memset(dis, -1, sizeof(dis));
Q.push_front(make_pair(0, 0));
dis[0][0] = 0;
vis[0][0] = true;
while (!Q.empty()) {
int x = Q.front().first, t = Q.front().second;
Q.pop_front();
if (x < m) {
int tim = t + d[x + 1] - d[x];
if (tim < g && !vis[x + 1][tim]) {
vis[x + 1][tim] = true;
dis[x + 1][tim] = dis[x][t];
Q.push_front(make_pair(x + 1, tim));
}
if (tim == g && !vis[x + 1][0]) {
vis[x + 1][0] = true;
dis[x + 1][0] = dis[x][t] + 1;
Q.push_back(make_pair(x + 1, 0));
}
}
if (x > 1) {
int tim = t + d[x] - d[x - 1];
if (tim < g && !vis[x - 1][tim]) {
vis[x - 1][tim] = true;
dis[x - 1][tim] = dis[x][t];
Q.push_front(make_pair(x - 1, tim));
}
if (tim == g && !vis[x - 1][0]) {
vis[x - 1][0] = true;
dis[x - 1][0] = dis[x][t] + 1;
Q.push_back(make_pair(x - 1, 0));
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) scanf("%d", &d[i]);
scanf("%d%d", &g, &r);
BFS();
int ans = INT_MAX;
for (int i = 0; i < g; ++i) {
if (dis[m][i] == -1) continue;
if (i == 0)
ans = min(ans, dis[m][i] * g + (dis[m][i] - 1) * r);
else
ans = min(ans, dis[m][i] * g + i + dis[m][i] * r);
}
if (ans == INT_MAX)
printf("-1");
else
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) swap(arr[i], arr[j]);
}
}
for (int i = 0; i < n; i++) {
cout << arr[i];
if (i != n - 1) cout << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
const int INF = 1e9 + 7;
int n;
int a[N], l[N];
set<pair<int, int> > s;
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 << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
inline int getlen(int x) {
int len = 0;
while (x) x /= 2, len++;
return len;
}
int main() {
n = read();
for (register int i = 1, _r = n; i <= _r; ++i) l[i] = getlen(a[i] = read());
for (register int i = 1, _r = n; i <= _r; ++i) {
int sum = a[i + 1], top = 1 << l[i], j = i + 2;
while (j <= n && sum < top) {
if (sum == (a[i] ^ a[j])) s.insert({i, j});
sum += a[j++];
}
}
for (register int i = n, _l = 1; i >= _l; --i) {
int sum = a[i - 1], top = 1 << l[i], j = i - 2;
while (j > 0 && sum < top) {
if (sum == (a[i] ^ a[j])) s.insert({j, i});
sum += a[j--];
}
}
cout << s.size() << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, sx, sy, x, y;
int a[4] = {0};
cin >> n >> sx >> sy;
while (n--) {
cin >> x >> y;
if (x < sx) a[0]++;
if (x > sx) a[1]++;
if (y < sy) a[2]++;
if (y > sy) a[3]++;
}
x = *max_element(a, a + 4);
cout << x << '\n';
if (x == a[0])
cout << sx - 1 << " " << sy;
else if (x == a[1])
cout << sx + 1 << " " << sy;
else if (x == a[2])
cout << sx << " " << sy - 1;
else
cout << sx << " " << sy + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str_a, str_d[1024], str_b[8];
cin.get(str_a);
cin.ignore();
cin.getline(str_d, 1024, 'e');
cin.getline(str_b, 8, '\n');
int b = atoi(str_b);
cout << str_a;
if (strlen(str_d) == b)
cout << str_d;
else if (strlen(str_d) > b) {
if (atoi(str_d) != 0) {
int i;
for (i = 0; i < b; i++) cout << str_d[i];
cout << '.';
cout << &str_d[i];
}
} else {
cout << str_d;
for (int i = strlen(str_d); i < b; i++) cout << "0";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, INF = 0X3F3F3F3F;
int n, tot;
char s[N];
vector<int> ans;
set<int> s1, s2;
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
for (int i = (1); i <= (n); ++i) {
if (s[i] == 'L')
s1.insert(i);
else
s2.insert(i);
}
s1.insert(INF), s2.insert(INF);
if (make_pair(-((int)(s1).size()), *s1.begin()) >
make_pair(-((int)(s2).size()), *s2.begin()))
swap(s1, s2);
int go = *s1.begin();
for (int i = (1); i <= (n); ++i) {
if (i & 1) {
if (go == INF || (*s2.lower_bound(go) == INF && *s1.begin() != go &&
*s1.begin() < *s2.begin())) {
++tot;
go = *s1.begin();
}
s1.erase(go);
ans.push_back(go);
go = *s2.lower_bound(go);
} else {
if (go == INF || (*s1.lower_bound(go) == INF && *s2.begin() != go &&
*s2.begin() < *s1.begin())) {
++tot;
go = *s2.begin();
}
s2.erase(go);
ans.push_back(go);
go = *s1.lower_bound(go);
}
}
printf("%d\n", tot);
for (auto x : ans) printf("%d ", x);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, k, dp[80][80];
pair<pair<long long, long long>, long long> v[100];
long long f(int pos, long long num) {
if (dp[pos][num] != -1) return dp[pos][num];
if (pos == n) {
if (num != k)
return dp[pos][num] = -1000000000000000;
else
return dp[pos][num] = 0;
}
long long res = -1000000000000000;
res = max(res, f(pos + 1, num) + v[pos].first.first * (k - 1ll));
if (num < k) {
res = max(res, f(pos + 1, num + 1) + v[pos].first.first * num +
v[pos].first.second);
}
return dp[pos][num] = res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> v[i].first.second >> v[i].first.first;
v[i].second = i + 1;
}
sort(v, v + n);
f(0, 0);
int pos = 0, num = 0;
vector<int> us, notus;
while (pos < n) {
if (dp[pos + 1][num] != -1 &&
dp[pos + 1][num] + v[pos].first.first * (k - 1ll) == dp[pos][num]) {
notus.push_back(v[pos].second);
} else {
us.push_back(v[pos].second);
num++;
}
pos++;
}
cout << us.size() + notus.size() * 2 << "\n";
for (int i = 0; (i + 1) < us.size(); i++) {
cout << us[i] << " ";
}
for (auto i : notus) cout << i << " " << -i << " ";
cout << us[us.size() - 1] << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, i, a, m = 0, s = 0, p = 0, w = 0, q, n[10];
cin >> k;
for (i = 0; i < k; i++) {
cin >> a;
if (a == 0)
n[m++] = 0;
else if (a == 100)
n[m++] = 100;
else if (a / 10 == 0 && s == 0) {
n[m++] = a;
s = 1;
} else if (a % 10 == 0 && p == 0) {
n[m++] = a;
p = 1;
} else {
q = a;
w = 1;
}
}
if (p == 0 && s == 0 && w == 1) n[m++] = q;
cout << m << endl;
for (i = 0; i < m; i++) cout << n[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
struct Cg {
__attribute__((always_inline)) inline char operator()() { return getchar(); }
};
struct Cp {
__attribute__((always_inline)) inline void operator()(char x) { putchar(x); }
};
__attribute__((always_inline)) inline bool IS(char x) {
return x == 10 || x == 13 || x == ' ';
}
template <typename T>
struct Fr {
T P;
__attribute__((always_inline)) inline Fr &operator,(int &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator int() {
int x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(long long &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator long long() {
long long x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
__attribute__((always_inline)) inline operator char() {
char x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
__attribute__((always_inline)) inline Fr &operator,(double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator double() {
double x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(long double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator long double() {
long double x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(unsigned int &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
__attribute__((always_inline)) inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(unsigned long long &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
__attribute__((always_inline)) inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
__attribute__((always_inline)) inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(char x) {
P(x);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(char x) {
P(x);
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
const int N = 1005;
unsigned long long hp[N * 2];
struct tree {
std::vector<int> p[N];
int n, m, c, ro, tot, mi, wx, wy, avo, fa[N], sz[N], id[N];
std::pair<unsigned long long, int> bh[N];
bool vis[N];
inline void clear() {
for (int i = 0, iend = N; i < iend; i++)
p[i].clear(), fa[i] = sz[i] = id[i] = vis[i] = 0,
bh[i] = std::make_pair(0, 0);
n = m = c = ro = tot = mi = wx = wy = avo = 0;
}
inline void read(int _n) {
n = _n, m = in;
for (int i = 1, iend = m; i <= iend; i++) {
int x, y;
in, x, y;
p[x].push_back(y);
p[y].push_back(x);
}
}
inline void dfs1(int x) {
tot++;
vis[x] = 1;
sz[x] = 1;
for (__typeof((p[x]).end()) i = (p[x]).begin(); i != (p[x]).end(); ++i)
if (*i != fa[x] && *i != avo) {
fa[*i] = x;
dfs1(*i);
sz[x] += sz[*i];
}
}
inline void dfs2(int x) {
int t = tot - sz[x];
for (__typeof((p[x]).end()) i = (p[x]).begin(); i != (p[x]).end(); ++i)
if (*i != fa[x] && *i != avo) dfs2(*i), repr(t, sz[*i]);
if (t == mi)
wy = x;
else if (t < mi)
mi = t, wx = x, wy = 0;
}
inline unsigned long long getr(
std::vector<std::pair<unsigned long long, int>> &q, int l, int r) {
unsigned long long res = l;
for (__typeof((q).end()) i = (q).begin(); i != (q).end(); ++i)
res = res * hp[i->second * 2] + i->first;
return res * hp[1] + r;
}
inline unsigned long long dfs3(int x, int fa, bool dbg = 0) {
std::vector<std::pair<unsigned long long, int>> q;
sz[x] = 1;
for (__typeof((p[x]).end()) i = (p[x]).begin(); i != (p[x]).end(); ++i)
if (*i != fa && *i != avo) {
q.push_back(std::make_pair(dfs3(*i, x), sz[*i]));
sz[x] += sz[*i];
}
std::sort(q.begin(), q.end());
return getr(q, 1, 2);
}
inline void setvis(int x, int fa) {
vis[x] = 0;
for (__typeof((p[x]).end()) i = (p[x]).begin(); i != (p[x]).end(); ++i)
if (*i != fa) setvis(*i, x);
}
inline std::pair<unsigned long long, int> getbhash(int x) {
fa[x] = 0;
tot = 0;
dfs1(x);
mi = tot;
dfs2(x);
if (!wy) return std::make_pair(dfs3(wx, 0), tot);
unsigned long long a = dfs3(wx, wy), b = dfs3(wy, wx);
if (a > b) std::swap(a, b);
a = ((3 * hp[tot] + a) * hp[tot] + b) * hp[1] + 4;
return std::make_pair(a, tot);
}
inline void gethash(
int fs, std::vector<std::pair<
std::pair<unsigned long long,
std::pair<unsigned long long, unsigned long long>>,
std::pair<int, int>>> &res) {
c = 0, ro = 1;
while (p[ro].size()) ro++;
avo = 0;
for (int i = 1, iend = n; i <= iend; i++)
if (!id[i] && i != ro) {
bh[++c] = getbhash(i);
for (int j = 1, jend = n; j <= jend; j++)
if (vis[j]) id[j] = c, vis[j] = 0;
}
for (int i = 1, iend = n; i <= iend; i++)
if (i != ro) {
avo = i;
for (int _j = 0; _j <= p[i].size(); _j++) {
int j = _j < p[i].size() ? p[i][_j] : 0;
std::vector<std::pair<unsigned long long, int>> qx, qy;
std::pair<unsigned long long, int> md = std::make_pair(0, 0);
for (__typeof((p[i]).end()) k = (p[i]).begin(); k != (p[i]).end();
++k) {
if (*k == j)
md = getbhash(*k);
else
qy.push_back(getbhash(*k));
}
for (int k = 1, kend = c; k <= kend; k++)
if (k != id[i]) qx.push_back(bh[k]);
std::sort(qx.begin(), qx.end());
std::sort(qy.begin(), qy.end());
unsigned long long x = getr(qx, 5 + fs * 2, 6 + fs * 2);
unsigned long long y = getr(qy, 7 - fs * 2, 8 - fs * 2);
if (fs) std::swap(x, y);
res.push_back(
std::make_pair(std::make_pair(md.first, std::make_pair(x, y)),
std::make_pair(i, j)));
setvis(i, 0);
}
}
}
} a, b;
int n;
bool bu[N];
int main() {
hp[0] = 1;
for (int i = 1, iend = N * 2 - 1; i <= iend; i++) hp[i] = hp[i - 1] * 103;
for (int T = in; T--;) {
in, n;
(int)in;
a.read(n);
b.read(n);
std::vector<
std::pair<std::pair<unsigned long long,
std::pair<unsigned long long, unsigned long long>>,
std::pair<int, int>>>
ha, hb;
a.gethash(0, ha);
b.gethash(1, hb);
std::map<std::pair<unsigned long long,
std::pair<unsigned long long, unsigned long long>>,
std::pair<int, int>>
va;
for (__typeof((ha).end()) i = (ha).begin(); i != (ha).end(); ++i)
va.insert(*i);
bool flag = 0;
std::pair<int, int> ua, ub;
for (__typeof((hb).end()) i = (hb).begin(); i != (hb).end(); ++i)
if (va.count(i->first)) {
flag = 1;
ua = va[i->first];
ub = i->second;
break;
}
if (!flag) {
out, "NO\n";
a.clear(), b.clear();
continue;
}
out, "YES\n";
std::multiset<unsigned long long> rv;
a.avo = ua.first;
b.avo = ub.first;
for (__typeof((a.p[ua.first]).end()) i = (a.p[ua.first]).begin();
i != (a.p[ua.first]).end(); ++i) {
if (*i != ua.second) {
rv.insert(a.dfs3(*i, 0));
}
}
std::vector<std::pair<int, int>> fin;
for (int i = 1, iend = b.c; i <= iend; i++) bu[i] = 0;
for (int i = 1, iend = n; i <= iend; i++)
if (i != b.ro && !bu[b.id[i]] && b.id[i] != b.id[ub.first]) {
unsigned long long th = b.dfs3(i, 0);
if (rv.count(th)) {
bu[b.id[i]] = 1;
fin.push_back(std::make_pair(i, b.ro));
rv.erase(rv.find(th));
}
}
if (!ua.second) {
fin.push_back(std::make_pair(ub.first, b.ro));
} else {
unsigned long long th = a.dfs3(ua.second, 0);
b.fa[ub.second] = 0;
b.dfs1(ub.second);
for (int i = 1, iend = n; i <= iend; i++)
if (b.vis[i]) {
unsigned long long ph = b.dfs3(i, 0);
if (th == ph) {
fin.push_back(std::make_pair(i, b.ro));
break;
}
}
}
for (int i = 1, iend = n; i <= iend; i++)
for (__typeof((b.p[i]).end()) j = (b.p[i]).begin(); j != (b.p[i]).end();
++j)
if (*j < i) out, i, ' ', *j, '\n';
for (__typeof((fin).end()) i = (fin).begin(); i != (fin).end(); ++i)
out, i->first, ' ', i->second, '\n';
a.clear(), b.clear();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char a[101];
int main() {
int n, i = 0;
cin >> n >> a;
int f = 2 + n % 2;
for (; i < f; i++) cout << a[i];
for (; i < n; i += 2) cout << '-' << a[i] << a[i + 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma gcc target("sse4")
const long long MAXN = 1e5 + 9;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, p;
cin >> n >> p;
for (long long a = 1; a <= 50; a++) {
long long x = n - a * p;
if (x <= 0) continue;
long long t = 0;
for (long long e = 1; e <= x; e *= 2) {
if (e & x) t++;
}
if (t <= a && a <= x) {
cout << a;
return 0;
}
}
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m;
int dp[2][505][505];
char grid[505][505];
int half;
bool chk_state(int row1, int row2, int dist) {
if (row1 > row2) return 0;
int taken = (m - 1) - dist + (row1) + (n - 1 - row2);
int lft = (n + m - 2) - taken;
if (lft < 0) return 0;
if (taken & 1) return 0;
int c1 = taken / 2 - row1;
int c2 = taken / 2 - (n - 1 - row2);
c2 = (m - 1) - c2;
if (c1 > c2) return 0;
if (c1 < 0 || c2 < 0) return 0;
if ((row1 + c1) != ((n - 1 - row2) + (m - 1 - c2))) return 0;
return 1;
}
int solve() {
dp[0][n - 1][m - 1] = (grid[0][0] == grid[n - 1][m - 1]);
int ans = 0;
for (int i = 0; i < n; i++) {
if (i)
for (int j = 0; j <= 500; j++)
for (int k = 0; k <= 500; k++) dp[i & 1][j][k] = 0;
for (int j = n - 1; j >= 0; j--) {
for (int k = m - 1; k >= 0; k--) {
if (!chk_state(i, j, k)) continue;
int dist = k;
int row1 = i;
int row2 = j;
int taken = (m - 1) - dist + (row1) + (n - 1 - row2);
int lft = (n + m - 2) - taken;
int c1 = taken / 2 - row1;
int c2 = taken / 2 - (n - 1 - row2);
c2 = (m - 1) - c2;
if (grid[row1][c1] == grid[row2][c2]) {
dp[i & 1][j][k] += dp[i & 1][j][k + 2];
dp[i & 1][j][k] %= mod;
dp[i & 1][j][k] += dp[i & 1][j + 1][k + 1];
dp[i & 1][j][k] %= mod;
dp[i & 1][j][k] += dp[(i - 1) & 1][j][k + 1];
dp[i & 1][j][k] %= mod;
dp[i & 1][j][k] += dp[(i - 1) & 1][j + 1][k];
dp[i & 1][j][k] %= mod;
ans += (dp[i & 1][j][k] * ((lft == 1 || lft == 0) &&
lft == (abs(row1 - row2) + abs(c1 - c2))));
ans %= mod;
}
}
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf(" %c", &grid[i][j]);
cout << solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 150, inf = 1e9;
int n, p[maxn + 1];
char str[maxn + 1];
int dp[maxn + 1][maxn + 1][maxn + 1];
int dp2[maxn + 1];
inline void Max(int &a, int b) {
if (b > a) a = b;
}
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
if (p[i] == -1) p[i] = -inf;
}
scanf("%s", str);
for (int i = 0; i <= n; ++i) {
dp[i][i][0] = 0;
fill(dp[i][i] + 1, dp[i][i] + n + 1, -inf);
}
for (int len = 1; len <= n; ++len) {
for (int l = 0; l + len <= n; ++l) {
int r = l + len;
for (int goal = 1; goal <= len; ++goal) {
dp[l][r][goal] = -inf;
for (int i = l + 1; i < r; ++i) {
Max(dp[l][r][goal], dp[l][i][0] + dp[i][r][goal]);
Max(dp[l][r][goal], dp[l][i][goal] + dp[i][r][0]);
}
if (len == 1 && goal == 1) {
Max(dp[l][r][goal], 0);
} else if (str[l] == str[r - 1] && goal > 1) {
Max(dp[l][r][goal], dp[l + 1][r - 1][goal - 2]);
}
}
fill(dp[l][r] + len + 1, dp[l][r] + n + 1, -inf);
dp[l][r][0] = -inf;
for (int goal = 1; goal <= len; ++goal) {
Max(dp[l][r][0], dp[l][r][goal] + p[goal]);
}
}
}
dp2[0] = 0;
for (int i = 1; i <= n; ++i) {
dp2[i] = dp2[i - 1];
for (int j = 0; j < i; ++j) {
Max(dp2[i], dp2[j] + dp[j][i][0]);
}
}
printf("%d\n", dp2[n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, pair<int, int> > > E;
int par[5001], sz[5001], cc[5001];
vector<int> my[5001];
int find(int u) {
if (par[u] == u) return u;
return (par[u] = find(par[u]));
}
void merge(int u, int v) {
int pu = find(u);
int pv = find(v);
if (sz[pu] > sz[pv]) swap(pu, pv);
par[pu] = pv;
sz[pv] += sz[pu];
cc[pv] += cc[pu];
}
vector<int> W;
int myid[5001];
int h;
vector<int> nxt[5001 * 20];
int mz[5001 * 20];
int he[5001 * 20];
void compile(int uid) {
W.clear();
h++;
for (int i = 1; i <= n; i++)
if (find(i) == uid) {
W.push_back(myid[i]);
myid[i] = h;
}
if (W.size()) {
sort(W.begin(), W.end());
for (int i = 0; i < W.size(); i++) {
if (i == 0 || W[i] != W[i - 1]) {
nxt[h].push_back(W[i]);
mz[h] += mz[W[i]];
if (he[h] == 0 || mz[he[h]] < mz[W[i]]) he[h] = W[i];
}
}
}
}
long long dp[5001][2000];
long long dp2[5001];
long long solve(int u, int w) {
if (dp[u][w] == -1) {
for (int k = 0; k <= mz[u]; k++) dp[u][k] = 0;
dp[u][0] = dp[u][1] = 1;
solve(he[u], 1);
for (int k = 0; k <= mz[he[u]]; k++) dp[u][k] = dp[he[u]][k];
for (auto x : nxt[u])
if (x != he[u]) {
solve(x, 1);
for (int k1 = 0; k1 <= mz[u]; k1++) {
dp2[k1] = 0;
}
for (int k1 = 0; k1 <= mz[u]; k1++) {
for (int k2 = 1; k2 <= min(mz[u] - k1, mz[x]); k2++) {
dp2[k1 + k2] =
(dp2[k1 + k2] + dp[u][k1] * dp[x][k2] % 998244353) % 998244353;
}
}
for (int k1 = 0; k1 <= mz[u]; k1++) {
dp[u][k1] = dp2[k1];
}
}
dp[u][1] = (dp[u][1] + 1) % 998244353;
}
return dp[u][w];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
myid[i] = i;
for (int j = 1; j <= n; j++) {
int d;
scanf("%d", &d);
if (i < j) {
E.push_back(make_pair(d, make_pair(i, j)));
}
}
}
for (int i = 1; i <= n; i++) par[i] = i, sz[i] = mz[i] = 1;
sort(E.begin(), E.end());
h = n;
for (int i = 0; i < E.size(); i++) {
int u = E[i].second.first;
int v = E[i].second.second;
if (find(u) != find(v)) merge(u, v);
int pp = find(u);
cc[pp]++;
int exp = sz[pp] * (sz[pp] - 1) / 2;
if (exp == cc[pp]) {
compile(pp);
}
}
for (int i = 1; i <= h; i++)
for (int j = 0; j <= n; j++) dp[i][j] = -1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++) dp[i][j] = (j == 1 ? 1 : 0);
for (int i = 1; i <= n; i++)
printf("%lld%c", solve(h, i), (i == n ? '\n' : ' '));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
long long int minus = 0;
long long int plus = 0;
long long int zero = 0;
long long int negatives_total = 0;
long long int total = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < 0) total += (abs(a[i]) - 1), negatives_total++;
if (a[i] > 0) total += (a[i] - 1);
if (a[i] == 0) zero++;
}
if (negatives_total % 2 && zero == 0)
cout << total + 2 << endl;
else {
total += zero;
cout << total << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[30005];
set<int> s[30005];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
s[x].insert(y);
}
for (int i = 1; i <= n; i++) {
int k = i;
while (k > 1 && s[a[k - 1]].count(i)) a[k] = a[k - 1], k--;
a[k] = i;
}
for (int i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, w[110], mn = 1000;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < n; i++)
if (k % w[i] == 0) mn = min(mn, (k / w[i]));
cout << mn << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
bool is_prime(long long n) {
if (n == 1) return true;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void problem_solver() {
long long n;
cin >> n;
long long ans = n + 1;
while (!is_prime(n)) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ans += (n / i);
n /= i;
break;
}
}
}
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
problem_solver();
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int K, N;
vector<int> v;
bool m[5000];
int main() {
scanf("%d%d", &K, &N);
bool a = false, b = false;
set<int> s;
for (int i = 0; i < N; ++i) {
int t;
scanf("%d", &t);
s.insert(t - K);
if (t <= K) a = true;
if (t >= K) b = true;
}
if (!a || !b) {
printf("-1\n");
return 0;
}
for (auto it : s) v.push_back(it);
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
while (!q.empty()) {
int cur = q.front().first, d = q.front().second;
q.pop();
for (int it : v) {
int next = cur + it, dd = d + 1;
if (next < -1000 || next > 1000 || m[next + 1000]) continue;
m[next + 1000] = true;
q.push(make_pair(next, dd));
if (next == 0) {
printf("%d\n", dd);
return 0;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
int a[20005][15];
int c[200005];
memset(c, 0, sizeof(c));
int x, y, i, j;
int b[20005];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (i = 1; i <= k; i++) {
scanf("%d%d", &x, &y);
c[y]++;
b[x]--;
}
for (i = 1; i <= m; i++) {
if (c[i] != 0) {
for (j = 1; j <= n; j++) {
if (a[j][i]) {
b[j] = b[j] + c[i];
}
}
}
}
for (i = 1; i <= n; i++) {
printf("%d ", b[i]);
}
}
| 2 |
#include <bits/stdc++.h>
const int N = 200005;
const int MX = 20;
using namespace std;
int fa[N][21], dl[N], dr[N], f[N], dep[N];
int edge[N], nxt[N], lst[N], t = 0;
int tot = 0, n, m;
vector<int> q[N];
struct nn {
int u, v, w;
} a[N];
void add(int x, int y) {
edge[++t] = y;
nxt[t] = lst[x];
lst[x] = t;
}
void search(int x) {
dep[x] = dep[fa[x][0]] + 1;
tot++;
dl[x] = dr[x] = tot;
for (int r = lst[x]; r; r = nxt[r]) {
if (edge[r] == fa[x][0]) continue;
search(edge[r]);
dr[x] = max(dr[x], dr[edge[r]]);
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int de = dep[x] - dep[y];
for (int i = 20; i >= 0; i--)
if (de & (1 << i)) x = fa[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
struct tree {
struct node {
int tag, tot, lx, rx, sz;
} tr[N << 1];
void chk(int x) {
int l = tr[x].lx, r = tr[x].rx;
tr[x].tot = tr[l].tot + tr[r].tot;
tr[x].sz = tr[l].sz + tr[r].sz;
}
void pushd(int x) {
int l = tr[x].lx, r = tr[x].rx;
if (tr[x].tag) {
tr[l].tot += tr[l].sz * tr[x].tag;
tr[r].tot += tr[r].sz * tr[x].tag;
tr[l].tag += tr[x].tag;
tr[r].tag += tr[x].tag;
tr[x].tag = 0;
}
}
void insert(int x, int l, int r, int l1, int r1, int yh) {
if (l == l1 && r == r1) {
tr[x].tot += tr[x].sz * yh;
tr[x].tag += yh;
return;
}
pushd(x);
int mid = (l + r) >> 1;
if (l1 > mid)
insert(tr[x].rx, mid + 1, r, l1, r1, yh);
else if (r1 <= mid)
insert(tr[x].lx, l, mid, l1, r1, yh);
else {
insert(tr[x].lx, l, mid, l1, mid, yh);
insert(tr[x].rx, mid + 1, r, mid + 1, r1, yh);
}
chk(x);
}
int find(int x, int l, int r, int pos) {
if (l == r) return tr[x].tot;
pushd(x);
int mid = (l + r) >> 1;
if (pos > mid)
return find(tr[x].rx, mid + 1, r, pos);
else
return find(tr[x].lx, l, mid, pos);
}
void build(int x, int l, int r) {
if (l == r) {
tr[x].sz = 1;
tr[x].tot = tr[x].tag = 0;
return;
}
int mid = (l + r) >> 1;
tr[x].lx = x + 1;
tr[x].rx = x + (mid - l + 1) * 2;
build(tr[x].lx, l, mid);
build(tr[x].rx, mid + 1, r);
chk(x);
}
};
tree sub, dp;
void getans(int x) {
int sum = 0;
for (int r = lst[x]; r; r = nxt[r]) {
if (edge[r] == fa[x][0]) continue;
getans(edge[r]);
sum += f[edge[r]];
}
f[x] = sum;
sub.insert(1, 1, n, dl[x], dr[x], sum);
int ss = q[x].size();
for (int i = 0; i < ss; i++) {
int nx = a[q[x][i]].u, ny = a[q[x][i]].v, nz = a[q[x][i]].w;
int num = 0;
num += sub.find(1, 1, n, dl[nx]);
num += sub.find(1, 1, n, dl[ny]);
num -= sum;
num -= dp.find(1, 1, n, dl[nx]);
num -= dp.find(1, 1, n, dl[ny]);
if (num + nz > f[x]) {
f[x] = num + nz;
}
}
dp.insert(1, 1, n, dl[x], dr[x], f[x]);
}
int main() {
scanf("%d%d", &n, &m);
fa[1][0] = 0;
for (int i = 2; i <= n; i++) scanf("%d", &fa[i][0]), add(fa[i][0], i);
for (int j = 1; j <= MX; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
search(1);
sub.build(1, 1, n);
dp.build(1, 1, n);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
q[LCA(a[i].u, a[i].v)].push_back(i);
}
getans(1);
printf("%d\n", f[1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
string s;
cin >> s;
long long int arr[m];
for (long long int i = 0; i < m; i++) {
cin >> arr[i];
}
vector<long long int> v(n);
for (long long int i = 0; i < m; i++) {
v[arr[i] - 1]++;
}
for (long long int i = n - 1; i > 0; i--) {
v[i - 1] += v[i];
}
long long int hash[123];
memset(hash, 0, sizeof(hash));
for (long long int i = 0; i < n; i++) {
hash[s[i]] += (v[i] + 1);
}
for (long long int i = 97; i < 123; i++) {
cout << hash[i] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 110;
int n, m, a[oo];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int i = n - 1;
while (m > 0) m -= a[i], i--;
cout << n - i - 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
class MinCostMaxFlow {
int n, m;
int cap[2 * 170000];
double cost[2 * 170000], dist[802], pot[802];
int to[2 * 170000], prev[2 * 170000], last[802], path[802];
bool used[802];
priority_queue<pair<double, int> > q;
public:
MinCostMaxFlow(int n) {
this->n = n;
m = 0;
for (int i = 0, _n = (n); i < _n; ++i) last[i] = -1;
}
void addEdge(int first, int second, int w, double c) {
cap[m] = w;
cost[m] = c;
to[m] = second;
prev[m] = last[first];
last[first] = m;
m++;
cap[m] = 0;
cost[m] = -c;
to[m] = first;
prev[m] = last[second];
last[second] = m;
m++;
}
pair<int, double> getFlow(int s, int t) {
int ansf = 0;
double ansc = 0;
while (true) {
pair<int, double> p = search(s, t);
if (!used[t]) break;
ansf += p.first;
ansc += p.second;
}
return make_pair(ansf, ansc);
}
protected:
pair<int, double> search(int s, int t) {
int ansf = 0;
double ansc = 0;
for (int i = 0, _n = (n); i < _n; ++i) used[i] = false, dist[i] = 1.0E+9;
dist[s] = 0;
path[s] = -1;
q.push(make_pair(0, s));
while (!q.empty()) {
int first = q.top().second;
q.pop();
if (used[first]) continue;
used[first] = true;
for (int e = last[first]; e >= 0; e = prev[e])
if (cap[e] > 0) {
double tmp = dist[first] + cost[e] + pot[first] - pot[to[e]];
if (tmp < dist[to[e]] && !used[to[e]]) {
dist[to[e]] = tmp;
path[to[e]] = e;
q.push(make_pair(-dist[to[e]], to[e]));
}
}
}
for (int i = 0, _n = (n); i < _n; ++i) pot[i] += dist[i];
if (used[t]) {
ansf = (1 << 29);
for (int e = path[t]; e >= 0; e = path[to[e ^ 1]])
ansf = min(ansf, cap[e]);
for (int e = path[t]; e >= 0; e = path[to[e ^ 1]]) {
ansc += cost[e] * ansf;
cap[e] -= ansf;
cap[e ^ 1] += ansf;
}
}
return make_pair(ansf, ansc);
}
};
int X[400];
int Y[400];
void solution() {
int n;
scanf("%d", &n);
for (int i = 0, _n = (n); i < _n; ++i) scanf("%d %d", X + i, Y + i);
MinCostMaxFlow mf(n * 2 + 2);
for (int i = 0, _n = (n); i < _n; ++i)
for (int j = 0, _n = (n); j < _n; ++j)
if (Y[j] > Y[i]) {
double dist = sqrt(((X[i] - X[j]) * (X[i] - X[j])) +
((Y[i] - Y[j]) * (Y[i] - Y[j])) + 0.);
mf.addEdge(i, n + j, 1, dist);
}
for (int i = 0, _n = (n); i < _n; ++i) mf.addEdge(n * 2, i, 1, 0);
for (int i = 0, _n = (n); i < _n; ++i) mf.addEdge(n + i, n * 2 + 1, 2, 0);
pair<int, double> ret = mf.getFlow(n * 2, n * 2 + 1);
if (ret.first != n - 1)
puts("-1");
else
printf("%.10lf\n", ret.second);
}
int main() {
solution();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x = 0, y = 0, z = 0;
int v[100100];
int num = 0;
int main() {
int n, maxm, minm, mid;
maxm = -200000;
minm = 200000;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
if (v[i] > maxm) maxm = v[i];
if (v[i] < minm) minm = v[i];
};
mid = (maxm + minm) / 2;
if (maxm - minm < 2) {
cout << n << "\n";
for (int i = 1; i <= n - 1; i++) cout << v[i] << " ";
cout << v[n] << "\n";
} else {
for (int i = 1; i <= n; i++)
if (v[i] == mid)
y++;
else if (v[i] == minm)
x++;
else if (v[i] == maxm)
z++;
int tmp = min(x, z);
if (y / 2 > tmp) {
cout << n - y / 2 * 2 << "\n";
x += y / 2;
z += y / 2;
y %= 2;
for (int i = 1; i <= x; i++) cout << minm << " ";
for (int i = 1; i <= y; i++) cout << mid << " ";
for (int i = 1; i <= z; i++) cout << maxm << " ";
cout << "\n";
} else {
cout << n - tmp * 2 << "\n";
for (int i = 1; i <= x - tmp; i++) cout << minm << " ";
for (int i = 1; i <= y + tmp * 2; i++) cout << mid << " ";
for (int i = 1; i <= z - tmp; i++) cout << maxm << " ";
cout << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int last[N];
std::vector<int> v[N];
void init() {
for (int i = 1; i < N; ++i)
for (int j = 1; i * j < N; ++j) v[i * j].push_back(i);
}
int main(void) {
int n;
scanf("%d", &n);
init();
for (int i = 1; i <= n; ++i) {
int ans = 0;
int x, y;
scanf("%d%d", &x, &y);
for (auto it : v[x])
if (i - last[it] > y) ans = ans + 1;
printf("%d\n", ans);
for (auto it : v[x]) last[it] = i;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
bool revisa(int n, int k) {
vector<int> dv;
if (k > n) swap(k, n);
for (int i = 1; i * i <= k; i++) {
if (k % i == 0) {
int div2 = k / i;
dv.push_back(i);
if (div2 != i) dv.push_back(div2);
}
}
for (int i = 1; i < dv.size(); i++)
if (n % dv[i] == 0) return true;
return false;
}
int main() {
int n;
cin >> n;
int cuenta = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
arr.push_back(t);
arr.push_back(0);
}
if (n == 1) {
cout << 0 << endl << arr[0] << endl;
} else {
int y;
if (n % 2 != 0)
y = 2;
else
y = 3;
for (int i = 0; i < arr.size() - y; i += 2) {
if (arr[i] == arr[i + 2] && arr[i] != 1) {
arr[i + 1] = 1;
cuenta++;
} else if (revisa(arr[i], arr[i + 2]) == true) {
arr[i + 1] = 1;
cuenta++;
}
}
cout << cuenta << endl;
for (int i = 0; i < arr.size(); i++) {
if (arr[i] != 0) cout << arr[i] << " ";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 1000000007, mod = 1000000000;
double Pi = acos(-1);
const double long rad = Pi / 180.0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, a, b, ans = 0;
cin >> n;
vector<pair<int, int> > v(n);
map<int, map<int, int> > co;
map<int, int> sumA, sumB;
for (int i = (0); i < (n); i++) {
cin >> a >> b;
v[i] = make_pair(a, b);
co[a][b]++;
sumA[a]++;
sumB[b]++;
}
for (int i = (0); i < (n); i++) {
a = v[i].first;
b = v[i].second;
ans += (sumA[a] + sumB[b] - co[a][b] - 1);
co[a][b]--;
sumA[a]--;
sumB[b]--;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct wall {
double x, y;
};
struct wall a[100100];
struct unit {
int num;
double x;
};
struct unit b[110100], c[110100];
int n, m;
int ans[10010];
double v, inf = 1e9, g = 9.8;
double ang[10010];
bool cmp(struct wall aa, struct wall bb) { return aa.x < bb.x; }
bool cmp1(struct unit aa, struct unit bb) {
return aa.x < bb.x || (aa.x == bb.x && aa.num < bb.num);
}
int calc(int i, int j) {
double s;
if (j <= 0 || j > m) return 0;
s = a[j].x * tan(ang[i]) -
a[j].x * a[j].x * g / v / v / 2 * (1 + tan(ang[i]) * tan(ang[i]));
if (s >= 0) {
printf("%.10lf %.10lf\n", a[j].x, s);
return 1;
} else
return 0;
}
int main() {
int i, j;
double x1, x2, x, y, t;
double delta;
scanf("%d%lf", &n, &v);
for (i = 1; i <= n; i++) scanf("%lf", &ang[i]);
scanf("%d", &m);
for (i = 1; i <= m; i++) scanf("%lf%lf", &a[i].x, &a[i].y);
sort(a + 1, a + m + 1, cmp);
for (i = 1; i <= m; i++) {
x = a[i].x;
y = a[i].y;
delta = 4 * x * x * (v * v * v * v - g * (x * x * g + 2 * v * v * y));
if (delta >= 0) {
x1 = (2 * v * v * x - sqrt(delta)) / (2 * x * x * g);
x2 = (2 * v * v * x + sqrt(delta)) / (2 * x * x * g);
b[i].num = i;
b[i].x = x1;
c[i].num = i;
c[i].x = x2;
} else {
b[i].num = i;
b[i].x = inf;
c[i].num = i;
c[i].x = -inf;
}
}
for (i = 1; i <= n; i++) {
b[m + i].num = m + i;
b[m + i].x = tan(ang[i]);
c[m + i].num = m + i;
c[m + i].x = tan(ang[i]);
}
sort(b + 1, b + m + n + 1, cmp1);
sort(c + 1, c + m + n + 1, cmp1);
for (i = 1; i <= n; i++) ans[i] = 1000000;
j = 1000000;
for (i = m + n; i >= 1; i--)
if (b[i].num <= m)
j = min(j, b[i].num);
else
ans[b[i].num - m] = min(ans[b[i].num - m], j);
j = 1000000;
for (i = 1; i <= m + n; i++)
if (c[i].num <= m)
j = min(j, c[i].num);
else
ans[c[i].num - m] = min(ans[c[i].num - m], j);
for (i = 1; i <= n; i++)
if (!calc(i, ans[i])) {
t = v * sin(ang[i]) * 2 / g;
printf("%.10lf %.10lf\n", t * v * cos(ang[i]), 0);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[55], dp[55][2][2];
long long dfs(int pos, int limit1, int limit2) {
if (pos < n - pos + 1) return 1ll;
if (dp[pos][limit1][limit2] >= 0) return dp[pos][limit1][limit2];
long long ans = 0;
for (int i = 0; i < 2; i++)
if (i == a[pos] || a[pos] == -1)
for (int j = 0; j < 2; j++)
if (j == a[n - pos + 1] || a[n - pos + 1] == -1)
if ((!limit1 || i <= j) && (!limit2 || i <= !j) &&
(pos != n - pos + 1 || i == j))
ans += dfs(pos - 1, limit1 & (i == j), limit2 & (i != j));
dp[pos][limit1][limit2] = ans;
return ans;
}
int main() {
memset(dp, -1, sizeof(dp));
memset(a, -1, sizeof(a));
cin >> n >> k;
k++;
a[n] = 0;
if (dfs(n, 1, 1) < k) {
cout << -1 << endl;
return 0;
}
cout << 0;
for (int i = n - 1; i; i--) {
a[i] = 0;
memset(dp, -1, sizeof(dp));
long long temp = dfs(n, 1, 1);
if (temp < k) {
k -= temp;
a[i] = 1;
cout << 1;
} else
cout << 0;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
for (vector<int>::iterator it = arr.begin(); it != arr.end(); ++it) {
if (*it < 0) {
cout << "1 " << *it << endl;
arr.erase(it);
break;
}
}
bool found(false);
for (vector<int>::iterator it = arr.begin(); it != arr.end(); ++it) {
if (*it > 0) {
found = true;
cout << "1 " << *it << endl;
arr.erase(it);
break;
}
}
if (!found) {
cout << "2";
int count = 0;
for (vector<int>::iterator it = arr.begin(); count < 2;) {
if (*it < 0) {
cout << " " << *it;
it = arr.erase(it);
++count;
} else {
++it;
}
}
cout << endl;
}
cout << arr.size();
for (size_t i = 0; i < arr.size(); ++i) {
cout << " " << arr[i];
}
cout << endl;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.