solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long ans[N];
pair<long long, long long> c[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
multiset<long long> s;
for (int i = 1; i <= n; i++) s.insert(i + k);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &c[i].first);
c[i].second = i;
}
sort(c + 1, c + n + 1);
reverse(c + 1, c + n + 1);
long long cnt = 0;
for (int i = 1; i <= n; i++) {
multiset<long long>::iterator cur;
cur = s.lower_bound(c[i].second);
if (cur == s.end()) {
cur--;
}
ans[c[i].second] = *cur;
cnt += abs(ans[c[i].second] - c[i].second) * c[i].first;
s.erase(cur);
}
printf("%I64d\n", cnt);
for (int i = 1; i <= n; i++) {
printf("%I64d ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[100003];
int w[100003];
int main() {
scanf("%d %d", &n, &k);
int m = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x != a[m]) a[++m] = x;
}
for (int i = 1; i <= m; i++) {
if (a[i - 1] == a[i + 1])
w[a[i]] += 2;
else
w[a[i]]++;
}
int ma = 0;
w[0] = -1;
for (int i = 1; i <= k; i++)
if (w[i] > w[ma]) ma = i;
printf("%d\n", ma);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
inline long long read() {
register long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return w > 0 ? s : -s;
}
inline void write(register long long x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
signed main() {
register int n, d, x = 0, y = 0, v = 0, r = 0;
n = read();
d = read();
for (register int i = 2 * n - 2; i >= 0; i -= 2) {
r = 4 * v | (d >> i) & 3;
x = (x << 1) | (0x936c >> r) & 1;
y = (y << 1) | (0x39c6 >> r) & 1;
v = (0x3e6b94c1 >> 2 * r) & 3;
}
write(x);
printf(" ");
write(y);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
queue<pair<pair<int, int>, int> > vec;
set<int> done;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
vec.push({{a - 1, a}, -1});
vec.push({{a + 1, a}, 1});
done.insert(a);
}
long long ans = 0;
vector<int> ff;
done.insert(2e9 + 5);
while (m) {
pair<pair<int, int>, int> pp = vec.front();
vec.pop();
if (done.find(pp.first.first) != done.end()) {
pp.first.first == 2e9 + 5;
} else {
ans += abs(pp.first.first - pp.first.second);
ff.push_back(pp.first.first);
m--;
done.insert(pp.first.first);
pp.first.first += pp.second;
vec.push(pp);
if (m == 0) break;
}
}
printf("%lld\n", ans);
for (int i = 0; i < ff.size(); i++) {
printf("%d ", ff[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
struct T {
int l, a, p;
double m(int a) {
if (a == 0)
return 0;
else
return p / (1.0 + (double)l / a);
}
double m() { return m(a); }
double g() {
if (a == l)
return 0;
else
return m(a) - m(a + 1);
}
double d() {
if (a == 0)
return 1E20;
else
return m(a) - m(a - 1);
}
};
set<pair<double, int> > s, w;
T t[200100];
int k;
double m;
void del(int i) {
m -= t[i].m();
s.erase(make_pair(t[i].g(), i));
w.erase(make_pair(t[i].d(), i));
}
void ins(int i) {
m += t[i].m();
s.insert(make_pair(t[i].g(), i));
w.insert(make_pair(t[i].d(), i));
}
void relax() {
for (; k > 0; k--) {
if (s.begin()->first > -1e-9) break;
int i = s.begin()->second;
del(i);
t[i].a++;
ins(i);
}
for (;;) {
if (-w.begin()->first - s.begin()->first < 1e-9) break;
int i = s.begin()->second;
int j = w.begin()->second;
if (i == j) break;
del(i);
del(j);
t[i].a++;
t[j].a--;
ins(i);
ins(j);
}
}
int main() {
int n, q, i, j;
scanf("%d%d%d", &n, &k, &q);
for (i = 0; i < n; scanf("%d", &t[i].p), i++)
;
for (i = 0; i < n; scanf("%d", &t[i].l), i++)
;
for (i = 0; i < n; t[i].a = 0, i++)
;
for (i = 0; i < n; s.insert(make_pair(t[i].g(), i)), i++)
;
for (i = 0; i < n; w.insert(make_pair(t[i].d(), i)), i++)
;
m = 0;
for (; q--;) {
scanf("%d%d", &j, &i);
i--;
del(i);
if (j == 1) {
t[i].l++;
} else {
t[i].l--;
if (t[i].a > t[i].l) {
t[i].a--;
k++;
}
}
ins(i);
relax();
printf("%.13lf\n", m);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
char a[30], b[30], s1[1010];
int i, l;
scanf("%s%s%s", a, b, s1);
l = strlen(a);
for (i = 0; i < l; i++) {
mp[a[i]] = b[i];
}
for (i = 0; i < strlen(s1); i++) {
if (s1[i] >= 'a' && s1[i] <= 'z') {
printf("%c", tolower(mp[s1[i]]));
} else if (s1[i] >= 'A' && s1[i] <= 'Z') {
printf("%c", toupper(mp[s1[i] + ('a' - 'A')]));
} else {
printf("%c", s1[i]);
}
}
puts("");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void IG(vector<vector<long long>>& vec, long long x, long long y) {
vec[x].push_back(y);
vec[y].push_back(x);
}
void solution() {
double n;
cin >> n;
long long x = ceil(sqrt(n));
long long summ = ((x - 1) * (x - 1)) + 1;
long long sum = x * x;
long long a = 1;
long long b = x;
long long c = summ;
for (long long i = 0; i < x; i++) {
if (c == n) {
cout << a << " " << b;
return;
}
c++;
a++;
}
a = x;
b = 1;
for (long long i = 0; i < x - 1; i++) {
if (n == sum) {
cout << a << " " << b;
}
b++;
sum--;
}
}
int32_t main() {
long long t;
cin >> t;
while (t--) {
solution();
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, a, b;
scanf("%d", &c);
scanf("%02d:%02d", &a, &b);
if (b >= 60) b %= 10;
if (a > c || a == 24) {
a %= 10;
}
if (c == 12 && a == 0) a = 10;
printf("%02d:%02d", a, b);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int BUFFER_SIZE = (1 << 16);
char buffer[BUFFER_SIZE];
int position = BUFFER_SIZE;
inline char getChar() {
if (position == BUFFER_SIZE) {
position = 0;
fread(buffer, BUFFER_SIZE, 1, stdin);
}
return buffer[position++];
}
inline int getInt() {
register int a = 0;
char ch;
int sgn = 1;
do {
ch = getChar();
} while (!isdigit(ch) && ch != '-');
if (ch == '-') {
sgn = -1;
ch = getChar();
}
do {
a = (a << 3) + (a << 1) + ch - '0';
ch = getChar();
} while (isdigit(ch));
return a * sgn;
}
const unsigned long long base = 137;
const int MAX_N = 1000000 + 1;
pair<int, int> edges[MAX_N];
vector<int> G[MAX_N];
unsigned long long hashes[MAX_N];
unsigned long long powerBase[MAX_N];
unordered_map<unsigned long long, int> Map;
int N, M;
int main() {
N = getInt();
M = getInt();
Map.reserve(1024);
Map.max_load_factor(0.25);
powerBase[0] = 1;
for (int i = 1; i <= N; ++i) powerBase[i] = powerBase[i - 1] * base;
for (int i = 1; i <= M; ++i) {
int x, y;
x = getInt();
y = getInt();
edges[i] = {x, y};
G[x].emplace_back(y);
G[y].emplace_back(x);
}
for (int i = 1; i <= N; ++i) {
sort(G[i].begin(), G[i].end());
for (int x : G[i]) hashes[i] += x * powerBase[x];
Map[hashes[i]]++;
}
long long solution = 0;
for (auto it : Map) {
int c = it.second;
solution += 1LL * c * (c - 1) / 2;
}
for (int i = 1; i <= M; ++i) {
int x = edges[i].first;
int y = edges[i].second;
unsigned long long tmp1, tmp2;
tmp1 = hashes[x] - y * powerBase[y];
tmp2 = hashes[y] - x * powerBase[x];
if (tmp1 == tmp2) solution++;
}
cout << solution << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool IsPrime(long long x) {
bool isPrime = true;
for (long long a = 2; a * a <= x; a++) {
if (x % a == 0) return false;
}
return true;
}
vector<long long> v[10005], y, x;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k = 1000000;
cin >> n;
long long a[2 * n], b[2 * n - 2];
for (long long i = 0; i < 2 * n; i++) cin >> a[i];
sort(a, a + 2 * n);
for (long long i = 0; i < 2 * n; i++) {
for (long long(j) = (i + 1); j < (2 * n); j++) {
long long p = 0, s = 0;
for (long long k = 0; k < 2 * n; k++) {
if (k != i && k != j) {
b[p] = a[k];
p++;
}
}
for (long long l = 0; l < 2 * n - 2; l++) {
s += abs(b[l] - b[l + 1]);
l++;
}
k = min(s, k);
}
}
cout << k;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using vpii = vector<pair<int, int>>;
using vpll = vector<pair<ll, ll>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
void solve() {
int n;
cin >> n;
vi x(n), y(n);
for (ll i = 0; i < (n); i++) {
cin >> x[i] >> y[i];
}
int min_x = *min_element(x.begin(), x.end());
int max_x = *max_element(x.begin(), x.end());
int min_y = *min_element(y.begin(), y.end());
int max_y = *max_element(y.begin(), y.end());
int ans = 0;
for (int i = 0; i < n; i++) {
int dx = max(max_x - x[i], x[i] - min_x);
int dy = max(max_y - y[i], y[i] - min_y);
ans = max(ans, dx + dy);
}
cout << 2 * ans;
for (int i = 4; i <= n; i++)
cout << " " << 2 * (max_x - min_x + max_y - min_y);
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> A, B;
vector<pair<int, int>> ans;
void solve(int t) {
int s1 = 0, s2 = 0;
int pos1 = -1, pos2 = -1;
while (1) {
int new1 = pos1 + t;
int new2 = pos2 + t;
if (new1 >= (int)A.size() && new2 >= (int)B.size()) break;
if (new1 >= (int)A.size()) {
while (pos2 + 1 < (int)B.size()) {
s2++;
pos2 += t;
}
if (pos2 + 1 == (int)B.size() && s2 > s1 && B.back() == N - 1)
ans.push_back(make_pair(s2, t));
break;
}
if (new2 >= (int)B.size()) {
while (pos1 + 1 < (int)A.size()) {
s1++;
pos1 += t;
}
if (pos1 + 1 == (int)A.size() && s1 > s2 && A.back() == N - 1)
ans.push_back(make_pair(s1, t));
break;
}
if (A[new1] < B[new2]) {
s1++;
pos1 = new1;
pos2 = lower_bound(B.begin(), B.end(), A[new1]) - B.begin() - 1;
} else {
s2++;
pos2 = new2;
pos1 = lower_bound(A.begin(), A.end(), B[new2]) - A.begin() - 1;
}
}
}
int main() {
scanf("%d", &N);
int a;
for (int i = 0; i < N; i++) {
scanf("%d", &a);
if (a == 1)
A.push_back(i);
else
B.push_back(i);
}
int M = max(A.size(), B.size());
for (int i = 1; i <= M; i++) solve(i);
printf("%d\n", ans.size());
sort(ans.begin(), ans.end());
for (auto& it : ans) printf("%d %d\n", it.first, it.second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long pow(long long n, long long e) {
if (e == 0)
return 1;
else if (e == 1)
return n;
else if (e % 2 == 0)
return pow(n, e / 2);
else
return pow(n, e / 2) * n;
}
bool prime(long long n) {
long long ct = 0;
for (long long i = 2; i < sqrt(n) + 1; i++) {
if (n % i == 0) return false;
}
return true;
}
int solve() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
;
long long n, temp, mi, q, ma = 0;
string s;
string t;
getline(cin, s);
getline(cin, t);
n = s.length();
int a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long mid, start = 0, end = n - 1;
bool flag = true;
long long res = -1;
while (start <= end) {
flag = true;
mid = (start + end) / 2;
char c[n];
fill(c, c + n, '$');
for (long long i = mid + 1; i < n; i++) c[a[i] - 1] = s[a[i] - 1];
int pos = 0;
for (long long i = 0; i < n; i++) {
if (pos == t.length()) break;
if (c[i] == t[pos]) pos++;
}
if (pos == t.length()) {
res = max(res, mid);
flag = true;
} else
flag = false;
if (flag)
start = mid + 1;
else
end = mid - 1;
}
cout << res + 1;
return 0;
}
int main() {
clock_t start, end;
start = clock();
solve();
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
cerr << "Time taken by program is : " << fixed << time_taken
<< setprecision(5);
cerr << " sec " << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
int even = 0, odd = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] % 2 == 0)
even++;
else
odd++;
}
if (even % 2 == 0 && odd % 2 == 0) {
cout << "YES\n";
} else {
int c = 1;
vector<int> check(105, 0);
for (int i = 0; i < n && c; ++i) {
for (int j = i + 1; j < n; ++j) {
if ((a[i] + a[j]) % 2 == 1 && check[a[j]] == 0 &&
abs(a[i] - a[j]) == 1) {
c--;
check[a[j]] = 1;
}
if (c == 0) {
break;
}
}
}
if (c == 0)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> a(n);
long long sum = 0;
unordered_map<long long, int> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
sum += a[i];
}
vector<long long> ans;
for (int i = 0; i < n; i++) {
long long rest = sum - a[i];
if (rest % 2) continue;
rest /= 2;
if (rest == a[i] && mp[a[i]] < 2) continue;
if (mp.find(rest) != mp.end()) {
ans.push_back(i + 1);
}
}
cout << ans.size() << endl;
for (auto it : ans) cout << it << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int check = 0;
int k = n;
while (k % 2 == 0 && check == 0) {
k = k / 2;
for (int i = 0; i < k; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] != a[2 * k - i - 1][j]) {
check = 1;
}
}
}
}
if (check == 1)
cout << 2 * k;
else
cout << k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x[100];
int main() {
int n;
scanf("%d", &n);
for (__typeof(n) i = 0; i < n; ++i) scanf("%d", &x[i]);
if (n <= 2) {
cout << "YES";
return 0;
}
char pre;
pre = (x[0] == x[1]) ? 'c' : (x[0] < x[1]) ? 'u' : 'd';
char cur;
for (__typeof(n) i = 1; i < n; ++i) {
cur = (x[i] == x[i - 1]) ? 'c' : (x[i - 1] < x[i]) ? 'u' : 'd';
if (pre == 'c') {
if (cur == 'u') {
cout << "NO";
return 0;
}
} else if (pre == 'd' && cur != pre) {
cout << "NO";
return 0;
}
pre = cur;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int lss[2000][2000] = {};
int main() {
string s;
cin >> s;
int n = s.length();
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
lss[i][i] = 1;
int temp = s[i];
int zero = 0;
if (s[i] == '0') {
zero++;
}
for (int j = i + 1; j < n; j++) {
if (s[j] == '1') {
lss[i][j] = lss[i][j - 1] + 1;
} else {
zero++;
lss[i][j] = max(zero, lss[i][j - 1]);
}
}
}
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
continue;
}
int temp1 = 0;
int zero = 0;
for (int j = 0; j <= i; j++) {
if (j != i && s[j] == '1') {
temp1 = temp1 + 1;
} else {
zero++;
temp1 = max(zero, temp1);
}
}
int temp2 = 0;
zero = 0;
for (int j = i; j < n; j++) {
if (j != i && s[j] == '1') {
temp2 = temp2 + 1;
} else {
zero++;
temp2 = max(zero, temp2);
}
}
if (temp1 == lss[0][i] && temp2 == lss[i][n - 1]) {
s[i] = '0';
}
}
cout << s << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int a[4][107];
char ch[107];
int dir[3][2] = {{-1, 3}, {0, 3}, {1, 3}};
bool vis[4][107];
int dfs(int x, int y) {
if (y > n) return 1;
vis[x][y] = 1;
int ans = 0;
for (int i = 0; i < 3; i++) {
int fx = x + dir[i][0], fy = y + dir[i][1];
if (fx <= 0 || fx > 3 || a[x][y + 1] == 1 || a[fx][fy - 1] == 1 ||
a[fx][fy - 2] == 1 || a[fx][fy] == 1)
continue;
if (vis[fx][fy]) continue;
ans = max(ans, dfs(fx, fy));
if (ans == 1) return 1;
}
return 0;
}
int k;
int main() {
scanf("%d", &t);
while (t--) {
memset(vis, 0, sizeof(vis));
memset(a, 0, sizeof(a));
int x, y;
scanf("%d%d", &n, &k);
for (int i = 1; i <= 3; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= n; j++) {
if (ch[j] == 's') x = i, y = j;
if (ch[j] != '.' && ch[j] != 's') a[i][j] = 1;
}
}
int ans = dfs(x, y);
if (ans == 0)
cout << "NO\n";
else
cout << "YES\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int input() {
int x = 0, f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
const int MXM = 2e5 * 40;
vector<pair<long long, int> > ans;
int flag;
struct Trie {
int nxt[MXM][2], cnt[MXM][2], ed[MXM][2];
int root, rear;
int new_node() {
++rear;
memset(cnt[rear], 0, sizeof(cnt[rear]));
memset(ed[rear], 0, sizeof(ed[rear]));
memset(nxt[rear], 0, sizeof(nxt[rear]));
return rear;
}
void init() {
rear = 0;
root = new_node();
}
void insert(int str[], int len, int op) {
int now = root, tmp;
cnt[now][op]++;
for (int i = (0); i < (len); ++i) {
tmp = str[i];
if (!nxt[now][tmp]) nxt[now][tmp] = new_node();
now = nxt[now][tmp];
cnt[now][op]++;
}
ed[now][op]++;
}
void dfs(int now, int dep, long long val) {
if (ed[now][1] && cnt[now][0]) {
flag = 0;
return;
}
if (ed[now][0] && cnt[now][1]) {
flag = 0;
return;
}
if (cnt[now][0] == 0) {
ans.push_back(pair<long long, int>(val, dep));
return;
}
if (nxt[now][0] == 0 && nxt[now][1] == 0) {
if (cnt[now][0]) flag = 0;
return;
}
if (cnt[nxt[now][0]][1]) dfs(nxt[now][0], dep + 1, val);
if (cnt[nxt[now][1]][1])
dfs(nxt[now][1], dep + 1, val | (1ll << (31 - dep)));
}
void query() { dfs(root, 0, 0); }
} T;
char str[22];
string s;
int a[33];
int to_int(string st) {
int ret = 0;
for (int i = (0); i < (st.length()); ++i) ret = ret * 10 + st[i] - '0';
return ret;
}
void solve() {
int l = 1, index = 0;
for (int i = (1); i < (s.length()); ++i) {
if (s[i] == '.' || s[i] == '/') {
string st = s.substr(l, i - l);
l = i + 1;
int x = to_int(st);
for (int j = ((index + 1) * 8) - 1; j >= (index * 8); --j)
a[j] = x % 2, x >>= 1;
index++;
}
}
}
string to_str(long long x) {
stringstream stream;
stream << x;
return stream.str();
}
void print(pair<long long, int> p) {
long long x = p.first;
int y = p.second;
string st = "";
for (int i = (0); i < (4); ++i) a[i] = x % 256, x /= 256;
for (int i = (4) - 1; i >= (0); --i) {
st += to_str(a[i]);
if (i > 0) st += '.';
}
st += "/" + to_str(y);
printf("%s\n", st.c_str());
}
int main() {
int n;
n = input();
T.init();
for (int i = (0); i < (n); ++i) {
scanf("%s", str);
s = (string)str;
if ((int)s.find("/") == -1) s += "/32";
solve();
int l = s.find("/") + 1, r = s.length() - 1;
int cnt = to_int(s.substr(l, r - l + 1));
T.insert(a, cnt, s[0] == '-' ? 1 : 0);
}
flag = 1;
T.query();
if (!flag) return 0 * printf("-1\n");
printf("%d\n", ans.size());
for (pair<long long, int> p : ans) print(p);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, sum = 0, p = 0, res = 0;
map<long long, long long> m;
cin >> n;
m[0] = 1;
for (long long i = 1; i <= n; i++) {
cin >> a;
sum += a;
p = max(p, m[sum]);
res += i - p;
m[sum] = i + 1;
}
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> v;
int k;
cin >> n;
int k1 = 0;
int k2 = 0;
for (int i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
if (k == 100)
k1++;
else if (k == 200)
k2++;
}
if ((k1 % 2 == 0) && (k2 % 2 == 0))
cout << "YES";
else if ((k1 == 0) && (k2 % 2) != 0) {
cout << "NO";
} else if (k2 % 2 != 0 && k1 % 2 == 0) {
if (k1 >= 2) {
cout << "YES";
} else {
cout << "NO";
}
} else
cout << "NO";
v.clear();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1), EPS = 1e-9;
const int N = 1e5 + 9;
int main() {
int n, h;
cin >> n >> h;
double s = h / 2. / n;
double b = 0;
for (int i = 1; i < n; i++) {
double l = b, r = 1;
while (fabs(l - r) > EPS) {
double m = (l + r) / 2;
double d = (m - b) * h;
double a = (b + m) * d / 2;
if (a > s)
r = m;
else
l = m;
}
printf("%.20lf ", l * h);
b = l;
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans[1000];
for (int i = 0, j = 1; i < 1000; ++j) {
if ((j % 3 != 0) && (j % 10 != 3)) {
ans[i++] = j;
}
}
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int k;
cin >> k;
cout << ans[k - 1] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << "[" << *it << ": " << a << "]\t";
err(++it, args...);
}
void solver() {
long long n, p, q;
cin >> n;
map<long long, long long> last_used;
for (long long i = 1; i <= n; i++) {
cin >> p >> q;
long long ans = 0;
for (long long j = 1; j * j <= p; j++) {
if (p % j == 0) {
if (last_used[j] < i - q) ans++;
last_used[j] = i;
if (j * j != p) {
if (last_used[p / j] < i - q) ans++;
last_used[p / j] = i;
}
}
}
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solver();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, INF = 1e9 + 7;
int n;
int usd[N];
int main() {
cin >> n;
for (int i = 3; i <= 600; ++i) {
if (((i - 2) * 180) % i == 0) usd[((i - 2) * 180) / i]++;
}
for (int i = 1; i <= n; ++i) {
int t;
cin >> t;
if (usd[t] == true)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
long long gcd(long long x, long long y) {
if (x == 0) return y;
return gcd(y % x, x);
}
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int n;
long long a[N];
bool stg(long long x) {
int q = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] % x == 0) ++q;
if ((q + n - i) * 2 < n) return false;
if (q * 2 >= n) return true;
}
if (q * 2 >= n) return true;
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
long long ans = 1;
for (int ii = 0; ii < 12; ++ii) {
int k = rnd() % n + 1;
long long x = a[k];
vector<long long> v;
for (long long i = 1; i * i <= x; ++i) {
if (x % i == 0) {
v.push_back(i);
if (i != x / i) v.push_back(x / i);
}
}
sort(v.begin(), v.end());
map<long long, int> mp;
for (int i = 0; i < v.size(); ++i) {
mp[v[i]] = i;
}
vector<int> g;
g.assign(v.size(), 0);
for (int i = 1; i <= n; ++i) {
g[mp[gcd(a[i], x)]]++;
}
for (int i = v.size() - 1; i >= 0; --i) {
int gg = 0;
for (int j = i; j < v.size(); ++j) {
if (v[j] % v[i] == 0) gg += g[j];
}
if (gg * 2 >= n) {
ans = max(ans, v[i]);
break;
}
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5050, maxm = 2020;
int N, ans[maxm], seg[4 * maxn], lazy[4 * maxn], is[maxm], last;
pair<int, int> ar[maxn];
vector<pair<int, pair<int, int> > > v;
vector<int> x;
int upd(int k, int b, int s, int x, int y) {
if (x <= b && s <= y) {
lazy[k] = 1;
return seg[k] = s - b + 1;
}
if (s < x || y < b) return seg[k];
int m = (b + s) >> 1;
return seg[k] = upd(2 * k, b, m, x, y) + upd(2 * k + 1, m + 1, s, x, y);
}
int find(int k, int b, int s, int x, int y) {
if (s < x || y < b) return 0;
if (lazy[k]) return 1;
if (x <= b && s <= y) return seg[k];
int m = (b + s) >> 1;
return find(2 * k, b, m, x, y) + find(2 * k + 1, m + 1, s, x, y);
}
void ekle() {
int asd[maxm], cur = 0;
memset(asd, 0, sizeof asd);
asd[0] = 1;
for (int i = x.size() - 1; i >= 0; i--) {
while (cur < x[i]) {
cur++;
for (int j = 0; j <= 2000; j++) asd[j] = asd[j] * 2;
for (int j = 0; j <= 2000; j++) {
asd[j + 1] += asd[j] / 10;
asd[j] = asd[j] - (asd[j] / 10) * 10;
}
}
for (int j = 0; j <= 2000; j++) ans[j] += asd[j];
for (int j = 0; j <= 2000; j++) {
ans[j + 1] += ans[j] / 10;
ans[j] = ans[j] - (ans[j] / 10) * 10;
if (ans[j]) last = j;
}
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
string s;
int a;
cin >> s >> a;
if (s[0] == 'w')
ar[i] = pair<int, int>(1, a);
else
ar[i] = pair<int, int>(0, a);
}
for (int i = N; i >= 1; i--) {
pair<int, int> a = ar[i];
if (!a.first)
is[a.second] = i;
else if (is[a.second]) {
v.push_back(pair<int, pair<int, int> >(a.second,
pair<int, int>(i, is[a.second])));
is[a.second] = 0;
}
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (find(1, 1, N, v[i].second.first + 1, v[i].second.second)) continue;
upd(1, 1, N, v[i].second.first + 1, v[i].second.second);
x.push_back(v[i].first);
}
ekle();
for (int i = last; i >= 0; i--) printf("%d", ans[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, new_candle, total, remain;
while (cin >> a >> b) {
total = remain = 0;
new_candle = a / b;
if (new_candle > 0) {
total = a;
while (a >= b) {
new_candle = a / b;
remain = a % b;
total = total + new_candle;
a = new_candle + remain;
}
} else
total = a + new_candle;
cout << total << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long r, x1, y1, x2, y2;
cin >> r >> x1 >> y1 >> x2 >> y2;
double res = sqrt(pow((x2 - x1), 2) + pow((y2 - y1), 2));
cout << ceil(res / (2 * r)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, T b) {
return b > a ? a = b, 1 : 0;
}
inline int read() {
int x(0), sgn(1);
char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * sgn;
}
void File() {}
const int N = 510;
bool app[N][5010];
pair<int, int> pre[N][5010];
void Out(pair<int, int> sta) {
if (sta.first == 0 && sta.second == 0) return;
Out(pre[sta.first][sta.second]);
printf("%d", sta.second - pre[sta.first][sta.second].second);
}
int main() {
File();
int n = read(), s = read();
queue<pair<int, int> > Q;
Q.push(make_pair(0, 0));
if (s == 0) return puts("-1"), 0;
while (!Q.empty()) {
pair<int, int> cur = Q.front();
Q.pop();
app[cur.first][cur.second] = true;
if (cur.first == 0 && cur.second == s) {
Out(cur);
return 0;
}
for (register int i = (0), iend = (int)(9); i <= iend; ++i) {
pair<int, int> nxt = make_pair((cur.first * 10 + i) % n, cur.second + i);
if (!app[nxt.first][nxt.second] && nxt.second <= s) {
app[nxt.first][nxt.second] = true;
Q.push(nxt);
pre[nxt.first][nxt.second] = cur;
}
}
}
puts("-1");
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
//#define int ll
#define ll long long
#define db double
#define rep(i,be,en) for(int i=be;i<=en;i++)
const int INF = 0x3f3f3f3f;
const ll inf=0x3f3f3f3f3f3f3f3f;
//const double pi=acos(-1);
const int mod=1e9+7;
const double eps = 1e-8;
using namespace std;
const int N=2e5+7;
const int M=1e6+7;
inline int read(){
char c=getchar();int x=0,f=1;
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
return x*f;
}
int T,n,m,fl,ans;
signed main(){
T=read();
while(T--){
n=read();
int l=read(),r=read(),s=read();
m=r-l+1;
if(s<m*(m+1)/2||s>(n-m+1+n)*m/2) puts("-1");
else{
int a[510]={0},b[510]={0},num=1,sum=0;
rep(i,l,r){
a[i]=num++;
sum+=a[i];
b[a[i]]=1;
}
int mx=n;
for(int i=r;i>=l;i--){
while(a[i]<mx&&sum<s){
sum++;
b[a[i]]=0;
a[i]++;
b[a[i]]=1;
}
mx--;
if(sum==s) break;
}
int x=1;
rep(i,1,n){
if(a[i]==0){
while(b[x]){
x++;
}
a[i]=x;
b[x]=1;
}
printf("%d ",a[i]);
}
puts("");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long int N = 1000001;
long long int fact[N];
void precalc() {
fact[0] = 1;
for (long long int i = 1; i < N; i++) fact[i] = (i * fact[i - 1]) % MOD;
}
int powmod(int n, long long int m) {
int ret = 1;
for (int i = 0; i < n; ++i) ret = ((ret % m) * (2 % m)) % m;
return ret;
}
void solve() {
int n;
cin >> n;
cout << (fact[n] - powmod(n - 1, MOD) + MOD) % MOD << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
precalc();
long long int z;
z = 1;
while (z--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
int n;
int qpow(int x, int p) {
if (p == 0) return 1 % mod;
if (p == 1) return x % mod;
long long ret = qpow(x, p >> 1);
ret *= ret;
ret %= mod;
if (p & 1) {
ret *= x;
ret %= mod;
}
return ret;
}
int jc[maxn], inv[maxn];
void prepare() {
jc[0] = 1;
jc[1] = 1;
for (int i = 2; i <= n; i++) {
jc[i] = jc[i - 1] * (long long)i % mod;
}
inv[n] = qpow(jc[n], mod - 2);
for (int i = n - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (long long)(i + 1) % mod;
}
}
int C(int m, int n) {
long long ret = ((long long)jc[m] * inv[n]) % mod * inv[m - n] % mod;
return ret;
}
int a[maxn];
struct wat {
int time, place;
bool operator<(const wat& x) const { return time < x.time; }
};
vector<wat> v, g, tmp;
int solve(int mode, int x) {
long long ans = 1;
int L, R;
int st;
if (mode) {
st = 0;
L = R = x;
} else {
st = 1;
L = R = g[0].place;
}
for (int i = st; i < (int)g.size(); i++) {
int vis;
if (i == 0)
vis = g[i].time - 1 - 1;
else
vis = g[i].time - g[i - 1].time - 1;
if (g[i].place >= L && g[i].place <= R) return 0;
if (g[i].place < L) {
int gap = L - g[i].place - 1;
if (gap > vis) return 0;
L = g[i].place;
ans *= C(vis, gap);
ans %= mod;
R += vis - gap;
} else {
int gap = g[i].place - R - 1;
if (gap > vis) return 0;
R = g[i].place;
ans *= C(vis, gap);
ans %= mod;
L -= vis - gap;
}
}
return ans;
}
int main() {
scanf("%d", &n);
prepare();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i]) v.push_back(wat{a[i], i});
}
sort(v.begin(), v.end());
g = v;
g.push_back(wat{n + 1, n + 1});
if (v.size() == 0 || v[0].time != 1) {
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i]) continue;
ans += solve(1, i);
ans %= mod;
}
printf("%d\n", ans);
} else
printf("%d\n", solve(0, 0));
return 0;
}
| 8 |
#include<bits/stdc++.h>
#define int long long
#define lld long long double
#define pb push_back
#define mp make_pair
#define M 1000000007
using namespace std;
bool solve(vector<int> v, int n)
{
set<int> s;
s.insert(v[0]);
for (int i = 1; i < v.size(); i++) {
s.insert(v[i]);
if (v[i] == v[i - 1])continue;
else if (v[i] > v[i - 1]) {
auto c = s.upper_bound(v[i - 1]);
if (*c != v[i])return false;
}
else {
auto c = s.upper_bound(v[i]);
if (*c != v[i - 1])return false;
}
}
return true;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t; cin >> t; while (t--)
{
int n;
cin >> n;
vector<int>v(n);
for (int i = 0; i < n; i++) cin >> v[i];
bool ans = solve(v, n);
if (ans)
cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
int main() {
priority_queue<int, vector<int>, greater<int> > Q;
priority_queue<int> Q1;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
Q.push(a[i]);
Q1.push(a[i]);
}
int num = 0;
int flag = 0;
while (1) {
while (Q1.top() == 4 && Q1.size()) {
num++;
flag++;
Q1.pop();
}
if (flag == n) break;
if (flag == n - 1) {
num++;
break;
}
flag++;
num++;
int m = Q.top() + Q1.top();
while (m <= 4 && flag < n) {
flag++;
Q.pop();
m += Q.top();
}
Q1.pop();
}
printf("%d\n", num);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
bool available[2][MAXN];
char s[MAXN];
int dp[2][2][MAXN];
int get_max(int idx) {
int ans = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
ans = max(ans, dp[i][j][idx]);
}
}
return ans;
}
int main() {
int n;
for (int i = 0; i < 2; i++) {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int j = 1; j <= n; j++) available[i][j] = (s[j] == '0');
}
for (int i = 1; i <= n; i++) {
dp[0][0][i] = get_max(i - 1);
if (available[0][i - 1] && available[1][i - 1]) {
if (available[0][i]) dp[1][0][i] = max(dp[1][0][i], dp[0][0][i - 1] + 1);
if (available[1][i]) dp[0][1][i] = max(dp[0][1][i], dp[0][0][i - 1] + 1);
}
if (available[0][i] && available[1][i]) {
if (available[0][i - 1])
dp[1][1][i] =
max(dp[1][1][i], max(dp[0][0][i - 1], dp[0][1][i - 1]) + 1);
if (available[1][i - 1])
dp[1][1][i] =
max(dp[1][1][i], max(dp[0][0][i - 1], dp[1][0][i - 1]) + 1);
}
}
printf("%d\n", get_max(n));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l = 0, r = 0;
scanf("%d", &n);
for (int i = 0, x, y; i < n; i++) {
scanf("%d", &x);
scanf("%d", &y);
if (x > 0)
r++;
else
l++;
}
if (r >= 1 && l == 0)
printf("yes");
else if (l >= 1 && r == 0)
printf("yes");
else if (r == 1 && l >= 1)
printf("yes");
else if (l == 1 && r >= 1)
printf("yes");
else
printf("no");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e2 + 100, mod = 1e9 + 7, SQ = 300;
long long t, n, x, y, p, q;
long long bs(long long l, long long r) {
if (l >= r) return l;
long long mid = (l + r) / 2;
long long a1 = p * mid;
long long a2 = q * mid;
if (a1 >= x && a2 >= y + (a1 - x)) return bs(l, mid);
return bs(mid + 1, r);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin >> t;
for (long long i = 0; i < t; i++) {
cin >> x >> y >> p >> q;
if (p == 0 && x != 0) {
cout << -1 << endl;
continue;
}
if (p == 0 && x == 0) {
cout << 0 << endl;
continue;
}
if (p == q && x != y) {
cout << -1 << endl;
continue;
}
long long t = bs(0, 1e9);
cout << q * t - y << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
long long a[maxn];
int main() {
long long n, k, x;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> x;
a[i] = a[i - 1] + x;
}
long long ans = a[n] * k;
sort(a + 1, a + n);
for (int i = 1; i < k; i++) ans -= a[i];
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
if (n * k > n * (n - 1) / 2) {
printf("-1\n");
continue;
}
cout << n * k << endl;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
printf("%d %d\n", i, (i + j) % n + 1);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T &x) {
return x.size();
}
const int INF = ~(1 << 31);
typedef long int li;
typedef long long int lli;
template <typename T>
std::string numtostr(T Number) {
std::ostringstream ss;
ss << Number;
return ss.str();
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
const double EPS = 1e-9;
const double pi = acos(-1);
template <class T>
T smod(T a, T b) {
return (a % b + b) % b;
}
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, k, tot = 0, f = 0;
cin >> n >> k;
vector<int> ar(k);
for (__typeof(0) i = (0); i < (k); ++i) {
cin >> ar[i];
tot += ar[i];
if (ar[i] % 2) f = 1;
}
sort(ar.begin(), ar.end());
int seatss = 0;
int seatsq = n;
int i = 0;
while (i < k && seatsq > 0) {
int avail = min(ar[i] / 4, seatsq);
ar[i] = ar[i] - 4 * avail;
seatsq = seatsq - avail;
i++;
}
seatss += seatsq;
int seatst = 2 * n + seatsq;
i = 0;
while (i < k && seatst > 0) {
int avail = min(ar[i] / 2, seatst);
ar[i] = ar[i] - 2 * avail;
seatst = seatst - avail;
i++;
}
seatss += seatst;
i = 0;
while (i < k && seatss > 0) {
int avail = min(ar[i], seatss);
ar[i] = ar[i] - avail;
seatss = seatss - avail;
i++;
}
i = 0;
while (i < k) {
if (ar[i] > 0) break;
i++;
}
bool flag;
if (i == k)
flag = true;
else
flag = false;
if (flag)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105, M = 1 << 15;
int n, a[N], b[N][M];
map<vector<int>, int> Map;
void dfs1() {
for (int i = 0; i < M; i++)
for (int j = 0; j < 15; j++)
if (i >> j & 1)
for (int k = 1; k <= n; k++)
if (a[k] >> j & 1)
b[k][i]--;
else
b[k][i]++;
}
void dfs2() {
for (int i = 0; i < M; i++) {
vector<int> Vec;
for (int j = 0; j <= n; j++) Vec.push_back(0);
for (int j = 0; j < 15; j++)
if (i >> j & 1)
for (int k = 1; k <= n; k++)
if (a[k] & (1 << (j + 15)))
Vec[k]--;
else
Vec[k]++;
Map[Vec] = i;
}
}
int main() {
ios ::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
dfs1();
dfs2();
vector<int> Vec;
Vec.push_back(0);
for (int i = 1, x = 0; i <= n; i++, Vec.push_back(x), x = 0)
for (int j = 0; j < 30; j++)
if (a[i] >> j & 1) x++;
for (int i = 0; i < M; i++) {
vector<int> t1 = Vec;
for (int j = 1; j <= n; j++) t1[j] += b[j][i];
vector<int> t2 = t1;
for (int j = 0; j < 30; j++) {
for (int k = 1; k <= n; k++) t2[k] = j - t1[k];
if (Map.count(t2)) {
cout << (i | (Map[t2] << 15)) << endl;
return 0;
}
}
}
cout << "-1";
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, k;
int ans = 2000000000;
scanf("%d%d", &n, &k);
for (int i = 1; i < k; i++)
if (n % i == 0) {
if (k * (n / i) + i < ans) ans = k * (n / i) + i;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int compare(const void* x1, const void* x2) { return (*(int*)x1 - *(int*)x2); }
double eps = 0.0001;
int main() {
char mas[100][100];
int n, m;
char c;
set<char> s;
cin >> n >> m >> c;
for (int i = 0; (i) < (n); ++i)
for (int j = 0; (j) < (m); ++j) cin >> mas[i][j];
for (int i = 0; (i) < (n); ++i)
for (int j = 0; (j) < (m); ++j)
if (mas[i][j] == c) {
if (i > 0)
if (mas[i - 1][j] != c && mas[i - 1][j] != '.')
s.insert(mas[i - 1][j]);
if (i < n - 1)
if (mas[i + 1][j] != c && mas[i + 1][j] != '.')
s.insert(mas[i + 1][j]);
if (j > 0)
if (mas[i][j - 1] != c && mas[i][j - 1] != '.')
s.insert(mas[i][j - 1]);
if (j < m - 1)
if (mas[i][j + 1] != c && mas[i][j + 1] != '.')
s.insert(mas[i][j + 1]);
}
cout << s.size();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const long long INF64 = 9e18;
const long double EPS = 1e-12;
const long double PI = 3.1415926535897932384626433832795028841;
const long long MD = 925262732;
const long long T = 634521;
const int N = 200010;
const int M = 51;
int n, k;
long long a[N], b[N];
int main() {
cin >> n >> k;
long long bb;
cin >> bb;
for (int i = 0; i < int(n); i++) {
scanf("%I64d", &a[i]);
b[i] = a[i];
}
sort(b, b + n - 1);
reverse(b, b + n - 1);
long long sum = 0;
for (int i = 0; i < int(k - 1); i++) sum += b[i];
k--;
for (int i = 0; i < int(n - 1); i++) {
long long ss = sum;
if (a[i] > b[k]) sum -= a[i] - b[k];
if (a[i] > bb - sum) {
cout << i + 1;
return 0;
}
sum = ss;
}
cout << n;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int x;
cin >> x;
cout << "1 " << x - 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, w;
int comp = 0;
int peso[1000], bel[1000];
int pesoc[1000], belc[1000], c[1000], v[1000];
int pp, bb;
int g[1000][1000];
int order[1000], top;
void dfs(int a) {
if (v[a]) return;
v[a] = 1;
c[a] = comp;
pp += peso[a];
bb += bel[a];
for (int i = 0; i < n; i++)
if (g[a][i]) dfs(i);
order[--top] = a;
}
int dp[1001][1001];
int solve(int w, int i) {
if (dp[w][i] != -1) return dp[w][i];
if (i == n) return dp[w][i] = 0;
int j = order[i];
int resp = 0, l = i;
while (l < n && c[order[l]] == c[j]) l++;
if (pesoc[c[j]] <= w)
resp = max(resp, belc[c[j]] + solve(w - pesoc[c[j]], l));
for (int k = i; k < l; k++)
if (peso[order[k]] <= w)
resp = max(resp, bel[order[k]] + solve(w - peso[order[k]], l));
resp = max(resp, solve(w, l));
return dp[w][i] = resp;
}
int main() {
int a, b;
scanf("%d %d %d", &n, &m, &w);
for (int i = 0; i < n; i++) scanf("%d", &peso[i]);
for (int i = 0; i < n; i++) scanf("%d", &bel[i]);
while (m--) {
scanf("%d %d", &a, &b);
a--;
b--;
g[a][b] = g[b][a] = 1;
}
top = n;
for (int i = 0; i < n; i++)
if (!v[i]) {
pp = bb = 0;
dfs(i);
pesoc[comp] = pp;
belc[comp++] = bb;
}
memset(dp, -1, sizeof dp);
printf("%d\n", solve(w, 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, c = 0, m = 0, pre;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
i = 0;
pre = a[0];
while (i < n) {
if (a[i] == pre)
c++;
else {
pre = a[i];
i = i - 1;
if (m == 0) {
m = c;
} else if (m != c) {
cout << "NO";
return 0;
}
c = 0;
}
i++;
}
if (c == m || m == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0;
cin >> n;
int a[n], i, j;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++)
if (a[i] == a[j]) {
c++;
a[j] = a[j] + 1;
}
}
cout << c << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int h, w, n;
long long fac[200005];
long long dp[2222];
int mod = 1000000007;
pair<int, int> p[2222];
long long pw(long long a, long long p) {
if (!p) return 1;
if (p & 1) return pw(a, p - 1) * a % mod;
long long z = pw(a, p >> 1);
return z * z % mod;
}
long long rev(long long x) { return pw(x, mod - 2); }
long long C(int x, int y) {
return fac[x + y] * rev(fac[x] * fac[y] % mod) % mod;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> h >> w >> n;
fac[0] = 1;
for (int(i) = (1); i < (200005); ++(i)) fac[i] = fac[i - 1] * i % mod;
for (int(i) = (0); i < (n); ++(i)) {
cin >> p[i].first >> p[i].second;
--p[i].first;
--p[i].second;
}
p[n] = {h - 1, w - 1};
++n;
p[n] = {0, 0};
++n;
sort(p, p + n);
dp[0] = 1;
for (int(i) = (1); i < (n); ++(i)) {
dp[i] = C(p[i].first, p[i].second);
for (int(j) = (1); j < (i); ++(j))
if (p[i].first >= p[j].first && p[i].second >= p[j].second) {
dp[i] -=
dp[j] * C(p[i].first - p[j].first, p[i].second - p[j].second) % mod;
dp[i] += mod;
dp[i] %= mod;
}
}
cout << (dp[n - 1] + mod) % mod;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long N;
long long a[19];
map<long long, int> m;
struct Node {
long long x;
int num;
};
int bfs() {
int ans = 999999999;
Node s;
s.num = 0;
s.x = N;
queue<Node> q;
q.push(s);
while (!q.empty()) {
Node u = q.front();
q.pop();
if (u.num >= ans) continue;
long long n = u.x;
long long temp = (long long)sqrt(n);
if (temp * temp == n) {
ans = min(ans, u.num);
continue;
}
if (m[n] == 1) continue;
m[n] = 1;
int i;
for (i = 1; i <= 12; i++) {
if (n < a[i])
break;
else {
long long temp = (n / a[i]) * a[i - 1] + n % a[i - 1];
if (temp > 0) {
Node p;
p.num = u.num + 1;
p.x = temp;
q.push(p);
}
}
}
if (i >= 2 && (n / a[i - 2]) % 10 == 0) continue;
temp = n % a[i - 1];
if (temp > 0) {
Node p;
p.num = u.num + 1;
p.x = temp;
q.push(p);
}
}
if (ans != 999999999) return ans;
return -1;
}
int main() {
a[0] = 1;
for (int i = 1; i <= 11; i++) a[i] = a[i - 1] * 10;
scanf("%lld", &N);
int ans = bfs();
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MAX = 1e9 + 5;
int i, j, k, n, m, dp[105][105][5][2];
int dp2[105][105][5][2];
string str;
int f(int x, int k, int c, int l) {
if (x >= str.size() && k == n) return 0;
if (k > n) return -99999;
if (x >= str.size() && k != n) return -99999;
if (dp[x][k][c][l]) return dp[x][k][c][l];
if ((str[x] == 'F' && !l) || (l && str[x] == 'T'))
return dp[x][k][c][l] = max(f(x, k + 1, c, !l), f(x + 1, k, c, 0) + c - 1);
else
return dp[x][k][c][l] =
max(f(x, k + 1, c, !l), f(x + 1, k, ((c == 0) ? 2 : 0), 0));
}
int f2(int x, int k, int c, int l) {
if (x >= str.size() && k == n) return 0;
if (x >= str.size() && k != n) return 99999;
if (k > n) return 9999;
if (dp2[x][k][c][l]) return dp2[x][k][c][l];
if ((str[x] == 'F' && !l) || (l && str[x] == 'T'))
return dp2[x][k][c][l] =
min(f2(x, k + 1, c, !l), f2(x + 1, k, c, 0) + c - 1);
else
return dp2[x][k][c][l] =
min(f2(x, k + 1, c, !l), f2(x + 1, k, ((c == 0) ? 2 : 0), 0));
}
int main() {
cin >> str >> n;
cout << max(abs(f(0, 0, 2, 0)), abs(f2(0, 0, 2, 0)));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[55], b[55];
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%I64d", a + i);
for (int j = 0; j < m; j++) scanf("%I64d", b + j);
sort(a, a + n);
sort(b, b + m);
long long ans1 = max(max(max(a[0] * b[m - 1], a[0] * b[0]), a[n - 2] * b[0]),
a[n - 2] * b[m - 1]),
ans2 = max(max(max(a[1] * b[m - 1], a[1] * b[0]), a[n - 1] * b[0]),
a[n - 1] * b[m - 1]);
printf("%I64d\n", min(ans1, ans2));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long unsigned myRand(long long unsigned B) {
return (long long unsigned)rng() % B;
}
const int K = 3;
struct Hash {
long long unsigned a[K];
Hash() : a() {}
Hash operator^(const Hash &A) const {
Hash ans = Hash();
for (int i = 0; i < K; i++) ans.a[i] = a[i] ^ A.a[i];
return ans;
}
bool operator==(const Hash &A) const {
for (int i = 0; i < K; i++)
if (a[i] != A.a[i]) return false;
return true;
}
bool operator<(const Hash &A) const {
for (int i = 0; i < K; i++)
if (a[i] != A.a[i]) return a[i] < A.a[i];
return false;
}
void eprint() {
for (int i = 0; i < K; i++) 42;
42;
}
};
Hash randHash() {
Hash ans = Hash();
for (int i = 0; i < K; i++) ans.a[i] = myRand(1ULL << 62);
return ans;
}
const int N = 1005;
Hash light[N];
Hash sw[N];
const int BOUND = 20;
map<Hash, int> prec;
int main(int, char **) {
int n, s, d;
scanf("%d%d%d", &n, &s, &d);
for (int i = 0; i < n; i++) light[i] = randHash();
for (int i = 0; i < s; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int id;
scanf("%d", &id);
id--;
sw[i] = sw[i] ^ light[id];
}
}
int pref = min(s, BOUND);
for (int mask = 0; mask < (1 << pref); mask++) {
Hash cur = Hash();
for (int i = 0; i < pref; i++)
if (mask & (1 << i)) cur = cur ^ sw[i];
int curans = __builtin_popcount(mask);
auto it = prec.find(cur);
if (it == prec.end() || curans < it->second) prec[cur] = curans;
}
int suff = s - pref;
for (int iter = 0; iter < d; iter++) {
int k;
scanf("%d", &k);
Hash cur = Hash();
for (int i = 0; i < k; i++) {
int id;
scanf("%d", &id);
id--;
cur = cur ^ light[id];
}
int ans = -1;
for (int mask = 0; mask < (1 << suff); mask++) {
Hash h = cur;
for (int i = 0; i < suff; i++)
if (mask & (1 << i)) h = h ^ sw[pref + i];
auto it = prec.find(h);
if (it == prec.end()) continue;
int curans = __builtin_popcount(mask) + it->second;
if (ans == -1 || curans < ans) ans = curans;
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long a[N];
int vis[N];
long long ans = 0;
int n, q;
int l, r;
void solve() {
int fg = 0;
for (int i = 1; i <= n; ++i) {
if (fg % 2 == 0) {
if (a[i - 1] < a[i] && a[i] > a[i + 1]) {
ans += a[i];
++fg;
vis[i] = 2;
}
} else {
if (a[i - 1] > a[i] && a[i] < a[i + 1]) {
ans -= a[i];
++fg;
vis[i] = 1;
}
}
}
}
void so(int x) {
if (a[x] > a[x - 1] && a[x] > a[x + 1]) {
ans += a[x];
vis[x] = 2;
} else if (a[x] < a[x - 1] && a[x] < a[x + 1]) {
ans -= a[x];
vis[x] = 1;
} else {
vis[x] = 0;
}
}
void solve1() {
if (vis[l] == 2) {
ans -= a[r];
} else if (vis[l] == 1) {
ans += a[r];
}
so(l);
if (vis[r] == 2) {
ans -= a[l];
} else if (vis[r] == 1) {
ans += a[l];
}
so(r);
if (l - 1 >= 1) {
if (vis[l - 1] == 2) {
ans -= a[l - 1];
} else if (vis[l - 1] == 1) {
ans += a[l - 1];
}
so(l - 1);
}
if (l + 1 <= n) {
if (vis[l + 1] == 2) {
ans -= a[l + 1];
} else if (vis[l + 1] == 1) {
ans += a[l + 1];
}
so(l + 1);
}
if (r - 1 >= 1) {
if (vis[r - 1] == 2) {
ans -= a[r - 1];
} else if (vis[r - 1] == 1) {
ans += a[r - 1];
}
so(r - 1);
}
if (r + 1 <= n) {
if (vis[r + 1] == 2) {
ans -= a[r + 1];
} else if (vis[r + 1] == 1) {
ans += a[r + 1];
}
so(r + 1);
}
}
int main() {
ios::sync_with_stdio(0);
int tt;
cin >> tt;
while (tt--) {
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
vis[i] = 0;
}
if (n == 1) {
cout << a[1] << '\n';
for (int _i = 1; _i <= q; ++_i) {
cin >> l >> r;
cout << a[1] << '\n';
}
continue;
}
a[n + 1] = 0;
ans = 0;
solve();
cout << ans << '\n';
for (int _i = 1; _i <= q; ++_i) {
cin >> l >> r;
swap(a[l], a[r]);
solve1();
cout << ans << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
long long lcm(long long a, long long b) { return (a * b) / (gcd(a, b)); }
void solve() {
long long n;
cin >> n;
vector<long long> vec(n);
long long sum = 0;
long long count = 0;
for (long long i = 0; i < n; i++) {
cin >> vec[i];
if (vec[i] == 0) {
count++;
vec[i] = 1;
}
sum += vec[i];
}
if (sum == 0) {
count++;
}
cout << count << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[301][301];
int n;
bool flag = true;
cin >> n;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 1; i < n; ++i) {
if (s[i][i] == s[i - 1][i - 1]) continue;
flag = false;
break;
}
for (int i = n - 2, j = 1; i >= 0; --i, ++j) {
if (s[j][i] == s[j - 1][i + 1]) continue;
flag = false;
break;
}
char c = s[0][1];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
if (i == j || i == (n - 1 - j)) continue;
if (c == s[i][j]) continue;
flag = false;
}
if (flag && s[0][0] != s[0][1])
cout << "YES";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int seed = 131;
const long long LLMAX = 2e18;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 1e6 + 10;
const int hmod1 = 0x48E2DCE7;
const int hmod2 = 0x60000005;
inline long long sqr(long long x) { return x * x; }
inline int sqr(int x) { return x * x; }
inline double sqr(double x) { return x * x; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d;
(b == 0 ? (x = 1, y = 0, d = a)
: (d = exgcd(b, a % b, y, x), y -= a / b * x));
return d;
}
long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return sum;
}
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return (x > 0 ? 1 : -1);
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long x, y, z;
cin >> x >> y >> z;
long long all = (x + y) / z, na = x / z, nb = y / z;
cout << all << ' '
<< max(0ll, min((all - na - nb) * z - (x - x / z * z),
(all - na - nb) * z - (y - y / z * z)))
<< endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long C[2010][2010], n, m, k;
int main() {
for (int i = 0; i < 2000; ++i)
for (int j = 0; j < i + 1; ++j)
C[i][j] = (j ? (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007 : 1);
cin >> n >> m >> k;
cout << ((C[n - 1][2 * k]) % 1000000007 * (C[m - 1][2 * k]) % 1000000007) %
1000000007
<< endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int lps[1000005];
void computeLPSArray(string pat) {
int M = pat.size();
int len = 0;
int i;
lps[0] = 0;
i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
string a;
int main() {
cin >> a;
computeLPSArray(a);
int n = a.size();
if (lps[n - 1] == 0) {
printf("Just a legend");
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << a.substr(0, lps[n - 1]);
return 0;
}
}
lps[n - 1] = lps[lps[n - 1] - 1];
if (lps[n - 1] == 0) {
printf("Just a legend");
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << a.substr(0, lps[n - 1]);
return 0;
}
}
printf("Just a legend");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (auto &i : a) cin >> i;
vector<long long> c(n);
for (auto &i : c) cin >> i;
long long tmp;
bool b;
for (int i = 0; i < n; i++) {
b = true;
for (int j = 0; j < n; j++) {
if (b) {
if (c[j] == 0) {
b = false;
tmp = j;
}
} else {
if (c[j] == 0) {
if (a[j] > a[tmp]) swap(a[j], a[tmp]);
tmp = j;
}
}
}
}
for (auto &i : a) cout << i << " ";
cout << "\n";
}
int main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
using namespace std;
#define ll long long
ll a[100086];
int main(){
ll t;cin>>t;
ll A,B,n;
while (t--) {
cin >> A >> B >> n;
ll Max = 0;
for (int i = 0; i < n; ++i){
cin >> a[i];
Max = max(Max, a[i]);
}
for (int i = 0; i < n; ++i) {
ll b;
cin >> b;
B -= (b+A-1)/A*a[i];
}
if(B+Max>0) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int x, y, a, b;
cin >> x >> y >> a >> b;
if ((y - x) % (a + b) == 0) {
cout << (y - x) / (a + b) << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int long long n, m, c[55], ans = 1e18 + 7, k = 0, d[10], l, r, j, y;
pair<int long long, int long long> p[105];
set<int long long> q;
bool check(int x) {
for (int i = 1; i <= m; i++) {
if ((p[i].first + x - 1) / x != p[i].second) {
return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> p[i].first >> p[i].second;
}
if (n == 1 && m == 0) {
cout << 1;
return 0;
}
for (j = 1; j <= 100005; j++) {
if (check(j)) {
k++;
q.insert((j + n - 1) / j);
}
}
if (q.size() == 1) {
int long long ans = *q.begin();
cout << ans << endl;
} else
cout << "-1";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e18 + 5;
const long long MOD = (long long)1e9 + 7;
const int MAXN = 55;
const int MAXM = 20005;
struct ST {
long long val[4 * MAXM], add[4 * MAXM];
void init(int l, int r, int idx) {
add[idx] = val[idx] = 0;
if (l == r) {
return;
}
int m = (l + r) >> 1;
init(l, m, idx << 1);
init(m + 1, r, idx << 1 | 1);
}
long long RMQ(int ql, int qr, int l, int r, int idx) {
assert(ql <= qr);
if (ql <= l && r <= qr) {
return val[idx];
}
long long m = (l + r) >> 1, ans = -INF;
if (ql <= m) ans = max(ans, RMQ(ql, qr, l, m, idx << 1) + add[idx]);
if (qr > m) ans = max(ans, RMQ(ql, qr, m + 1, r, idx << 1 | 1) + add[idx]);
return ans;
}
void range_add(int ql, int qr, long long v, int l, int r, int idx) {
assert(ql <= qr);
if (ql <= l && r <= qr) {
add[idx] += v;
val[idx] += v;
return;
}
int m = (l + r) >> 1;
if (ql <= m) range_add(ql, qr, v, l, m, idx << 1);
if (qr > m) range_add(ql, qr, v, m + 1, r, idx << 1 | 1);
val[idx] = max(val[idx << 1], val[idx << 1 | 1]) + add[idx];
}
} tree;
int n, m, k;
long long sum[MAXN][MAXM], dp[MAXN][MAXM];
long long range_sum(int r1, int c1, int r2, int c2) {
assert(r1 <= r2 && c1 <= c2);
return sum[r2][c2] - sum[r2][c1 - 1] - sum[r1 - 1][c2] + sum[r1 - 1][c1 - 1];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= m; j++) {
if (i <= n) {
cin >> sum[i][j];
}
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
}
}
for (int i = n; i >= 1; i--) {
tree.init(1, m, 1);
for (int j = 1; j <= m; j++) {
long long p = range_sum(i, max(1, j - k + 1), i + 1, j);
if (i != 1 && j >= m - k + 1) {
p -= range_sum(i, m - k + 1, i, j);
}
tree.range_add(j, j, p + dp[i + 1][j], 1, m, 1);
}
for (int j = m; j >= 1; j--) {
dp[i][j] = tree.RMQ(1, m, 1, m, 1);
if (i != 1 && j > 1) {
long long r = range_sum(i, j, i, j);
tree.range_add(j, min(m, j + k - 1), r, 1, m, 1);
if (j - k >= 1) {
long long l = range_sum(i, j - k, i, j - k);
tree.range_add(j - k, j - 1, -l, 1, m, 1);
}
}
}
}
cout << *max_element(dp[1] + 1, dp[1] + 1 + m) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b != 0) {
d = exgcd(b, a % b, y, x);
y -= (a / b) * x;
} else
x = 1, y = 0;
return d;
}
inline long long get_inverse(long long a, long long mod) {
long long x, y;
exgcd(a, mod, x, y);
return (mod + x % mod) % mod;
}
int n;
long long mod, ans;
long long pw[100005], inv[100005];
struct Edge {
int to, next;
long long w;
} e[200005];
int head[100005], _cnt;
inline void add_edge(int u, int v, long long w) {
e[_cnt] = (Edge){v, head[u], w};
head[u] = _cnt++;
}
bool vis[100005];
int sz[100005], mxson[100005];
int root, total, mnson;
void get_root(int u, int parent) {
sz[u] = 1, mxson[u] = 0;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].to;
long long l = e[i].w;
if (v == parent || vis[v]) continue;
get_root(v, u), sz[u] += sz[v];
mxson[u] = max(mxson[u], sz[v]);
}
mxson[u] = max(mxson[u], total - sz[u]);
if (mnson > mxson[u]) root = u, mnson = mxson[u];
}
map<long long, long long> mp;
void dfs1(int u, int par, long long d, long long base) {
mp[d]++;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].to;
long long w = e[i].w;
if (v == par || vis[v]) continue;
dfs1(v, u, (d + w * base) % mod, base * 10 % mod);
}
}
long long dfs2(int u, int par, long long d, int dep) {
long long cnt = mp[(mod - d * inv[dep] % mod) % mod];
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].to;
long long w = e[i].w;
if (v == par || vis[v]) continue;
cnt += dfs2(v, u, (d * 10 + w) % mod, dep + 1);
}
return cnt;
}
long long solve(int u, long long dis) {
mp.clear();
dfs1(u, -1, dis % mod, dis ? 10 : 1);
return dfs2(u, -1, dis % mod, dis ? 1 : 0) - (dis == 0);
}
void divide_tree(int u) {
vis[u] = true;
ans += solve(u, 0);
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].to;
long long w = e[i].w;
if (vis[v]) continue;
ans -= solve(v, w);
total = sz[v], root = 0;
mnson = 0x3f3f3f3f;
get_root(v, 0);
divide_tree(root);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cout << fixed << setprecision(12);
memset(head, -1, sizeof(head));
cin >> n >> mod;
pw[0] = inv[0] = 1;
long long inv10 = get_inverse(10LL, mod);
for (int i = 1; i <= n; ++i) {
pw[i] = pw[i - 1] * 10 % mod;
inv[i] = inv[i - 1] * inv10 % mod;
}
for (int i = 1; i < n; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
++u, ++v;
add_edge(u, v, w);
add_edge(v, u, w);
}
total = n, root = 0;
mnson = 0x3f3f3f3f;
get_root(1, -1);
divide_tree(root);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
int modpow(long long a, long long b, long long MOD) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ret;
}
std::map<int, std::tuple<int, int, int>> par[2];
std::vector<int> getpath(int node) {
std::vector<int> ret;
for (int Q = 0; Q < 2; ++Q) {
int temp = node;
while (std::get<1>(par[Q][temp]) != -1) {
ret.push_back(std::get<1>(par[Q][temp]));
temp = std::get<2>(par[Q][temp]);
}
if (Q == 0) std::reverse(ret.begin(), ret.end());
}
return ret;
}
int main() {
int u, v, p;
std::cin >> u >> v >> p;
if (u == v) {
std::cout << 0 << std::endl;
return 0;
}
par[0][u] = {0, -1, -1};
par[1][v] = {0, -1, -1};
std::queue<int> bfsq[2];
bfsq[0].push(u);
bfsq[1].push(v);
int link;
for (int L = 0;; ++L) {
for (int Q = 0; Q < 2; ++Q) {
while (!bfsq[Q].empty()) {
int uu = bfsq[Q].front();
if (std::get<0>(par[Q][uu]) > L) break;
bfsq[Q].pop();
int next[3] = {(uu + 1) % p, (uu + p - 1) % p, modpow(uu, p - 2, p)};
int op[3] = {1 + Q, 2 - Q, 3};
for (int i = 0; i < 3; ++i) {
if (!par[Q].count(next[i])) {
par[Q][next[i]] = {L + 1, op[i], uu};
if (par[1 - Q].count(next[i])) {
link = next[i];
goto BPP;
}
bfsq[Q].push(next[i]);
}
}
}
}
}
BPP:
auto answer = getpath(link);
std::cout << answer.size() << std::endl;
std::copy(answer.begin(), answer.end(),
std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
template <class C>
inline void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
inline void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
int t, n, dp[107][(107 * ('z' - 'a' + 1))];
char c[107];
int main() {
std::ios_base::sync_with_stdio(0);
cout << setprecision(15) << fixed;
dp[0][0] = 1;
for (int i = 0; i < (('z' - 'a' + 1)); i++) dp[1][i] = 1;
for (int q = (2); q <= (107 - 1); q++)
for (int s = 0; s < ((107 * ('z' - 'a' + 1))); s++)
for (int i = 0; i < (min(s + 1, ('z' - 'a' + 1))); i++) {
dp[q][s] += dp[q - 1][s - i];
dp[q][s] %= 1000000007;
}
cin >> t;
while (t--) {
cin >> c;
n = strlen(c);
int s = 0;
for (int i = 0; i < (n); i++) s += c[i] - 'a';
cout << (dp[n][s] + 1000000007 - 1) % 1000000007 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.size();
vector<int> ones;
for (int i = 0; i < n; i++) {
int c = 0;
if (s[i] == '1') {
c++;
if (i == n - 1) {
ones.push_back(c);
}
for (int j = i + 1; j < n; j++) {
if (s[j] == '1') {
c++;
} else {
ones.push_back(c);
i = j;
break;
}
if (j == n - 1) {
ones.push_back(c);
i = n;
}
}
}
}
sort(ones.begin(), ones.end());
int ans = 0;
for (int i = ones.size() - 1; i >= 0; i -= 2) {
ans += ones[i];
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long par[(1 << 20)], sz[(1 << 20)], n;
long long a[(1 << 20)], b[(1 << 20)];
bool active[(1 << 20)];
long long ans = 0;
struct v {
long long prior;
long long sz, sum, specsum;
long long l, r, val;
v() { prior = rand() * rand() + rand(); }
} tr[(1 << 20)];
long long roots[(1 << 20)], szTr = 1;
long long getp(long long x) { return par[x] == x ? x : par[x] = getp(par[x]); }
void refr(long long x) {
tr[x].sz = tr[tr[x].l].sz + 1 + tr[tr[x].r].sz;
tr[x].sum = tr[x].val + tr[tr[x].l].sum + tr[tr[x].r].sum;
tr[x].specsum = tr[tr[x].r].specsum + (tr[tr[x].r].sz * tr[x].val) +
tr[tr[x].l].specsum + tr[tr[x].l].sum * (tr[tr[x].r].sz + 1);
}
pair<int, long long> splitT(long long k, long long v) {
if (v == 0) {
return make_pair(0, 0);
}
if (tr[v].val < k) {
pair<int, long long> c = splitT(k, tr[v].r);
tr[v].r = c.first;
refr(v);
return make_pair(v, c.second);
} else {
pair<int, long long> c = splitT(k, tr[v].l);
tr[v].l = c.second;
refr(v);
return make_pair(c.first, v);
}
}
long long mergeT(long long v1, long long v2) {
if (v1 == 0 || v2 == 0) {
return v1 ^ v2;
}
if (tr[v1].prior > tr[v2].prior) {
tr[v1].r = mergeT(tr[v1].r, v2);
refr(v1);
return v1;
} else {
tr[v2].l = mergeT(tr[v2].l, v1);
refr(v2);
return v2;
}
}
long long mergeTs(long long v1, long long v2) {
if (v1 == 0 || v2 == 0) {
return v1 ^ v2;
}
if (tr[v1].prior > tr[v2].prior) {
pair<int, long long> nv2 = splitT(tr[v1].val, v2);
tr[v1].r = mergeTs(tr[v1].r, nv2.second);
tr[v1].l = mergeTs(tr[v1].l, nv2.first);
refr(v1);
return v1;
} else {
pair<int, long long> nv1 = splitT(tr[v2].val, v1);
tr[v2].r = mergeTs(tr[v2].r, nv1.second);
tr[v2].l = mergeTs(tr[v2].l, nv1.first);
refr(v2);
return v2;
}
}
void unionv(long long a, long long b) {
long long p1 = getp(a), p2 = getp(b);
if (p1 > p2) {
swap(p1, p2);
}
long long len = p2 - p1;
ans -= len * (tr[roots[p2]].sum);
par[p2] = p1;
ans -= tr[roots[p1]].specsum;
ans -= tr[roots[p2]].specsum;
roots[p1] = mergeTs(roots[p1], roots[p2]);
ans += tr[roots[p1]].specsum;
}
long long createV(long long val) {
long long x = szTr++;
tr[x].val = val;
tr[x].sz = 1;
tr[x].sum = val;
tr[x].specsum = 0;
return x;
}
void printTr(long long v) {
if (v == 0) {
return;
}
printTr(tr[v].l);
cout << tr[v].val << " ";
printTr(tr[v].r);
}
int main() {
for (long long i = 0; i < (1 << 20); i++) {
par[i] = i;
}
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (active[a[i]]) {
long long x = createV(b[i]);
int to = getp(a[i]);
ans -= (a[i] - to) * b[i];
ans -= tr[roots[to]].specsum;
roots[to] = mergeTs(x, roots[to]);
ans += tr[roots[to]].specsum;
int l = a[i], r = (1 << 20);
int m = (l + r) / 2;
for (; l + 1 < r; m = (l + r) / 2) {
if (getp(m) == to) {
l = m;
} else {
r = m;
}
}
active[r] = 1;
unionv(r, to);
if (active[r + 1]) {
unionv(to, r + 1);
}
} else {
roots[a[i]] = createV(b[i]);
active[a[i]] = 1;
if (active[a[i] + 1]) {
unionv(a[i], a[i] + 1);
}
if (active[a[i] - 1]) {
unionv(a[i], a[i] - 1);
}
}
cout << ans << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
map<int, pair<int, int> > m;
map<int, pair<int, int> >::iterator it, it1;
int flag = 0, flag1 = 0;
while (q--) {
int x, y;
char dir;
cin >> x >> y;
cin >> dir;
int ans;
if (dir == 'U') {
it = m.lower_bound(x);
if (it == m.end()) {
ans = y;
pair<int, int> p;
p.first = ans;
p.second = 1;
m[x] = p;
} else if (it->first == x)
ans = 0;
else {
if ((it->second).second == 1) {
ans = (it->second).first + (y - (n + 1 - (it->first)));
} else {
ans = (y - (n + 1 - (it->first)));
}
pair<int, int> p;
p.first = ans;
p.second = 1;
m[x] = p;
}
} else {
it = m.lower_bound(x);
if (m.empty()) {
ans = x;
pair<int, int> p;
p.first = ans;
p.second = 2;
m[x] = p;
} else if (it->first == x)
ans = 0;
else {
if (it == m.begin()) {
ans = x;
} else {
it--;
if ((it->second).second == 1) {
ans = x - (it->first);
} else {
ans = (it->second).first + x - (it->first);
}
}
pair<int, int> p;
p.first = ans;
p.second = 2;
m[x] = p;
}
}
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, w, l[1 << 20];
ll ans;
basic_string<int> q[1 << 20];
struct st {
int x, y;
};
basic_string<st> ins[1 << 20], del[1 << 20];
int main() {
scanf("%d%d", &n, &w);
for (int i = 1, l; i <= n; i++) {
scanf("%d", &l);
if (l < w) {
ins[1] += {i, 0};
del[w - l] += {i, 0};
ins[l + 1] += {i, 0};
del[w + 1] += {i, 0};
}
for (int j = 1, x; j <= l; j++) {
scanf("%d", &x);
ins[j] += {i, x}, del[j + w - l] += {i, x};
}
}
for (int i = 1; i <= w; i++) {
for (st& s : ins[i]) {
if (l[s.x] < q[s.x].size()) ans -= q[s.x][l[s.x]];
while (l[s.x] < q[s.x].size() && s.y > q[s.x].back()) q[s.x].pop_back();
q[s.x] += s.y;
ans += q[s.x][l[s.x]];
}
if (i) printf("%lld%c", ans, " \n"[i == w]);
for (st& s : del[i]) {
if (l[s.x] < q[s.x].size() && s.y == q[s.x][l[s.x]]) {
ans -= s.y, l[s.x]++;
if (l[s.x] < q[s.x].size()) ans += q[s.x][l[s.x]];
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tot, xo;
cin >> tot >> xo;
long long pw = 1;
bool flag[50];
memset(flag, 0, sizeof flag);
int cnt = 0;
for (int i = 0; i < 45; i++) {
if (pw & xo) {
tot -= pw;
flag[i] = true;
cnt++;
}
pw *= 2;
}
bool valid = true;
if (tot & 1) valid = false;
tot /= 2;
pw = 1;
for (int i = 0; i < 45; i++) {
if (flag[i] && (tot & pw)) valid = false;
pw *= 2;
}
long long ans = 0;
if (valid) {
ans = (long long)1 << cnt;
if (tot == 0) ans -= 2;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
while (scanf("%lld", &n) == 1) {
long long int a, b, sum, ans = 0;
for (long long int i = 1; i <= n; i++) {
scanf("%lld", &a);
scanf("%lld", &b);
sum = a + b;
ans = max(ans, sum);
}
printf("%lld", ans);
printf("\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long t;
long long n;
long long a[100005];
int main() {
cin >> t;
while (t--) {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
long long suma = 0, ksor = 0;
for (long long i = 0; i < n; i++) {
suma += a[i];
ksor ^= a[i];
}
cout << 2 << "\n" << ksor << " " << ksor + suma << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, bool> ma;
vector<int> vec;
bool ch = false;
int p, n;
cin >> p >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (!ma[x % p])
ma[x % p] = true;
else {
vec.push_back(i + 1);
ch = true;
}
}
if (ch)
cout << vec[0] << endl;
else
cout << "-1\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, inf = 1e9 + 10, MOD = 1e9 + 7, Sq = 708;
const long long INF = 1e18 + 10;
int f[110], t[110], s[110];
int main() {
ios_base::sync_with_stdio(false);
int b, d;
string a, c;
cin >> b >> d;
cin >> a >> c;
int j = 0, ans = 0, ans1, pos = 0, ans2 = 0;
for (int k = 0; k < a.length() * b; k++) {
if (k / a.length() > c.length() && ans == 0) {
cout << 0;
return 0;
}
int i = (k % a.length());
if (a[i] == c[j]) {
j++;
if (j == c.length()) {
j = 0, ans++, t[i]++;
if (t[i] > 1) {
ans1 = k - f[i];
ans2 = ans - s[i];
pos = k;
break;
} else
f[i] = k, s[i] = ans;
}
}
}
j = 0;
int l = (a.length() * b - pos - 1) / ans1;
if (pos) {
ans += l * ans2;
for (int k = pos + l * ans1 + 1; k < a.length() * b; k++) {
int i = (k % a.length());
if (a[i] == c[j]) {
j++;
if (j == c.length()) j = 0, ans++;
}
}
}
cout << ans / d;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int a[N];
int gc[N];
int is_max[N];
int cnt[N];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int _n(n), i(0); i < _n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
long long ans = 0;
gc[0] = 0;
for (int _n(n + 1), g(1); g < _n; g++) {
if (n % g) continue;
for (int i = g; i <= n; i += g) {
gc[i] = g;
}
}
for (int _n(n + 1), g(1); g < _n; g++) {
if (n % g) continue;
for (int _n(g), i(0); i < _n; i++) {
int m = 0;
for (int j = i; j < n; j += g) {
m = max(m, a[j]);
}
for (int j = i; j < 2 * n; j += g) {
is_max[j] = a[j] == m ? 1 : 0;
}
}
is_max[0] = 0;
for (int _n(2 * n), i(1); i < _n; i++) {
if (is_max[i]) {
is_max[i] += is_max[i - 1];
}
}
cnt[0] = 0;
for (int _n(n), i(1); i < _n; i++) cnt[i] = cnt[i - 1] + (gc[i] == g);
for (int _n(2 * n), i(n); i < _n; i++) {
ans += cnt[min(n - 1, is_max[i])];
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int jg, cd, ct, cd1;
int main() {
cin >> s;
cin >> t;
cd = s.size();
cd1 = t.size();
for (int i = 0; i < cd; i++) {
for (int j = i; j < cd; j++) {
ct = 0;
for (int k = 0; k < cd; k++) {
if (k >= i && k <= j) continue;
while (k < cd && s[k] != t[ct] && (k < i || k > j)) k++;
if (k < cd && (k < i || k > j) && s[k] == t[ct]) ct++;
}
if (ct >= cd1) jg = max(jg, j - i + 1);
}
}
cout << jg << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300010;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long arr[MAXN];
long long dp[MAXN][16];
int main() {
int n, m;
long long k;
scanf("%d%d%lld", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", arr + i);
}
long long ans = -INF;
for (int j = 1; j <= m; j++) {
dp[0][j] = -INF;
}
for (int i = 1; i <= n; i++) {
dp[i][0] = 0;
dp[i][1] = max(0LL, dp[i - 1][m]) + arr[i] - k;
for (int j = 2; j <= m; j++) {
dp[i][j] = dp[i - 1][j - 1] + arr[i];
if (ans < dp[i][j]) ans = dp[i][j];
}
if (ans < dp[i][1]) ans = dp[i][1];
}
printf("%lld\n", ans > 0 ? ans : 0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define pb push_back
#define C continue
#define B break
#define ll long long
#define ld double
#define R return
#define F first
#define S second
#define eps 1e-10
#define pi acos(-1.0)
//#define mod 1000000007
#define inf 1000000000000000000
#define fastio ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
ld x[200100] ;
ld y[200010] ;
ld dis(ld x1 , ld x2 , ld y1 , ld y2)
{
ld ans = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)) ;
R ans ;
}
int main()
{
ll n , H ;
scanf("%lld%lld" , &n , &H) ;
for(int i=0;i<n;i++)
{
scanf("%lf%lf" , &x[i] , &y[i]);
//cin>>x[i]>>y[i] ;
}
ld sum = 0 ;
ld px = x[n-1] ;
ld py = y[n-1] + H ;
ld tita = 1e+18;
bool chk = 1;
for(int i=n-2;i>=0;i--)
{
// cout<<sum<<endl;
ld New = ((y[i]-py)/(x[i]-px));
// cout<<New<<endl;
if(fabs(New-tita)<eps && chk)
{
//cout<<New<<" "<<tita<<" "<<y[i]<<endl;
sum += dis(x[i+1] , x[i] , y[i+1] , y[i] );
C;
}
if(New < tita && chk)
{
tita = ((y[i]-py)/(x[i]-px)) ;
sum += dis(x[i] , x[i+1] , y[i] , y[i+1]) ;
C;
}
if(New < tita && !chk)
{
ld m1 = tita ;
ld m2 = (y[i]-y[i+1])/(x[i]-x[i+1]) ;
// cout<<m1<<" "<<m2<<endl;
ld p1 = py - m1*px ;
ld p2 = y[i+1] - m2*x[i+1] ;
// cout<<p1<<" "<<p2<<endl;
ld xx ;
ld yy ;
xx = (p2-p1)/(m1-m2) ;
yy = m1*xx + p1 ;
//cout<<"kkkk"<<dis(x[i] , xx , y[i] , yy)<<endl;
sum += dis(x[i] , xx , y[i] , yy) ;
chk = 1 ;
tita = New ;
C;
}
if(fabs(tita-New) < eps) chk=1;
else
chk = 0 ;
}
printf("%.8f" , sum) ;
//cout<<fixed<<setprecision(8)<<sum<<endl;
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(10);
int n, a[200000] = {}, cnt = 1, M = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
while (a[i] * 2 >= a[i + 1] && i < n - 1) {
cnt++;
i++;
}
M = max(M, cnt);
cnt = 1;
}
cout << M << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[101000] = {0}, b[100] = {0};
int main() {
long long i, u, v, ccc = v - u;
scanf("%lld%lld", &u, &v);
ccc = v - u;
if (ccc < 0 || ccc % 2) {
printf("-1");
return 0;
}
if (u == v && u == 0) {
printf("0");
return 0;
}
if (u == v) {
printf("1\n%lld", u);
return 0;
}
long long te = 1, m, n, c, d, cc, ans1 = 0, ans2 = 0;
for (i = 0; i <= 62; i++) {
c = 0, d = 0;
if ((te | u) == u) c = 1;
if ((te | v) == v) d = 1;
if (i > 0) {
if (m == 0) {
if (c != d) {
ans1 += te / 2;
ans2 += te / 2;
}
} else {
ans2 += te / 2;
}
}
te *= 2;
m = c;
n = d;
}
if (ans1 + ans2 == v && (ans1 ^ ans2) == u) {
printf("2\n");
printf("%lld %lld\n", ans1, ans2);
return 0;
}
printf("3\n");
printf("%lld %lld %lld\n", u, ccc / 2, ccc / 2);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
} v[1000];
int use[500][500][2][2], dp[500][500][2][2];
int n, d, x, y;
bool check(int x, int y) {
if (x * x + y * y <= d * d) return true;
return false;
}
int solve(int x, int y, int s1, int s2) {
int xaux = x + 250;
int yaux = y + 250;
if (use[xaux][yaux][s1][s2]) return dp[xaux][yaux][s1][s2];
if (s1 == 0 && s2 == 0) {
bool ok = 0;
for (int i = 1; i <= n; ++i) {
if (check(x + v[i].x, y + v[i].y) &&
solve(x + v[i].x, y + v[i].y, 0, 0) == 0) {
ok = 1;
break;
}
}
use[xaux][yaux][s1][s2] = 1;
dp[xaux][yaux][s1][s2] = ok;
return ok;
}
if (s1 == 0 && s2 == 1) {
bool ok = 0;
for (int i = 1; i <= n; ++i) {
if (check(x + v[i].x, y + v[i].y) &&
solve(x + v[i].x, y + v[i].y, 1, 0) == 0) {
ok = 1;
break;
}
}
use[xaux][yaux][s1][s2] = 1;
dp[xaux][yaux][s1][s2] = ok;
return ok;
}
if (s1 == 1 && s2 == 0) {
bool ok = 0;
if (solve(y, x, 0, 0) == 0) ok = 1;
if (!ok) {
for (int i = 1; i <= n; ++i) {
if (check(x + v[i].x, y + v[i].y) &&
solve(x + v[i].x, y + v[i].y, 0, 1) == 0) {
ok = 1;
break;
}
}
}
use[xaux][yaux][s1][s2] = 1;
dp[xaux][yaux][s1][s2] = ok;
return ok;
}
bool ok = 0;
if (solve(y, x, 1, 0) == 0) ok = 1;
if (!ok) {
for (int i = 1; i <= n; ++i) {
if (check(x + v[i].x, y + v[i].y) &&
solve(x + v[i].x, y + v[i].y, 1, 1) == 0) {
ok = 1;
break;
}
}
}
use[xaux][yaux][s1][s2] = 1;
dp[xaux][yaux][s1][s2] = ok;
return ok;
}
int main() {
cin >> x >> y >> n >> d;
for (int i = 1; i <= n; ++i) {
cin >> v[i].x >> v[i].y;
}
if (solve(x, y, 0, 1) == 1 && solve(x, y, 0, 0) == 1) {
cout << "Anton\n";
return 0;
}
if (solve(x, y, 1, 1) == 1 && solve(x, y, 1, 0) == 1) {
cout << "Anton\n";
return 0;
}
cout << "Dasha\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 1000000007;
struct Fp {
long long val;
Fp() = default;
Fp(long long v) {
assert(v >= 0 && v < p);
val = v;
}
};
Fp operator+(Fp a, Fp b) { return (a.val + b.val) % p; }
Fp operator-(Fp a, Fp b) { return (p + a.val - b.val) % p; }
Fp operator*(Fp a, Fp b) { return (a.val * b.val) % p; }
Fp pow(Fp a, long long n) {
Fp res = 1;
while (n) {
if (n & 1) res = res * a;
a = a * a;
n /= 2;
}
return res;
}
Fp inv(Fp a) { return pow(a, p - 2); }
Fp operator/(Fp a, Fp b) { return a * inv(b); }
int main() {
int n, _D;
cin >> n >> _D;
Fp D = _D;
vector<vector<int>> children(n);
vector<int> count(n, 0);
vector<int> parent(n);
vector<vector<Fp>> res(n, vector<Fp>(3001));
parent[0] = -1;
for (int i = 1; i < n; i++) {
int s;
cin >> s;
s--;
children[s].push_back(i);
parent[i] = s;
count[s]++;
}
queue<int> work;
for (int i = 0; i < n; i++) {
if (count[i] == 0) work.push(i);
}
while (!work.empty()) {
int cur = work.front();
work.pop();
res[cur][0] = 0;
for (int i = 1; i <= 3000; i++) {
res[cur][i] = 1;
for (auto c : children[cur]) {
res[cur][i] = res[cur][i] * res[c][i];
}
res[cur][i] = res[cur][i] + res[cur][i - 1];
}
if (parent[cur] != -1) {
count[parent[cur]]--;
if (count[parent[cur]] == 0) work.push(parent[cur]);
}
}
Fp out = 0;
for (int i = 1; i <= 3000; i++) {
Fp cur = res[0][i];
Fp div = 1;
for (int j = 0; j <= 3000; j++) {
if (j == i) continue;
cur = cur * (Fp(D) - Fp(j));
div = div * (Fp(i) - Fp(j));
}
out = out + cur / div;
}
cout << out.val << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
bool mask[N];
char s[N];
int n;
int cnt[N];
bool table[N];
bool can(int k) {
table[k] = 0;
memset(cnt, 0, 4 * k);
for (int i = 0; i < n; ++i) cnt[i % k] += mask[i];
for (int i = 0; i < k; ++i)
if (cnt[i] & 1) return 0;
table[k] = 1;
return 1;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
cin >> s;
for (int i = 0; i < n; ++i) mask[i] = s[i] - '0';
int ans = 0;
for (int d = 1; d <= n; d++) {
if (n % d)
ans += table[gcd(n, d)];
else
ans += can(d);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
struct Typ {
int k, t;
int id;
void read(int i) {
id = i;
scanf("%d%d", &k, &t);
}
friend bool operator<(const Typ &a, const Typ &b) { return a.t < b.t; }
} A[maxn];
int N, T;
priority_queue<Typ> Q;
vector<Typ> ope[maxn];
bool cmp(Typ a, Typ b) { return a.t < b.t; }
void get_ans(int ans) {
sort(A + 1, A + N + 1, cmp);
printf("%d\n%d\n", ans, ans);
int cnt = 0;
for (int i = (1), _i = (N); i <= _i; ++i)
if (A[i].k >= ans && cnt < ans) {
++cnt;
printf("%d", A[i].id);
if (cnt < ans)
printf(" ");
else
break;
}
printf("\n");
}
void Done() {
while (!Q.empty()) Q.pop();
for (int i = (1), _i = (N); i <= _i; ++i) ope[i].clear();
for (int i = (1), _i = (N); i <= _i; ++i) ope[A[i].k].push_back(A[i]);
int ans = 0;
int sum = 0;
for (int s = (N), _s = (1); s >= _s; --s) {
for (int i = (0), _i = (ope[s].size() - 1); i <= _i; ++i) {
Q.push(ope[s][i]);
sum += ope[s][i].t;
}
while (s < Q.size() || sum > T) {
sum -= Q.top().t;
Q.pop();
}
ans = max(ans, (int)Q.size());
}
get_ans(ans);
}
int main() {
for (; scanf("%d%d", &N, &T) != EOF;) {
for (int i = (1), _i = (N); i <= _i; ++i) A[i].read(i);
Done();
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int MOD = 998244353;
const int MAX = 5005;
int n, k;
vector<int> edges[MAX];
int dp[MAX][MAX];
int add(int x, int y) {
int sol = x + y;
if (sol > MOD) sol -= MOD;
else if (sol < 0) sol += MOD;
return sol;
}
int mul(int x, int y) {
return x * 1ll * y % MOD;
}
int dfs(int a, int prev) {
int h1 = 0;
dp[a][0] = 1;
for (auto b : edges[a]) {
if (b == prev) continue;
int h2 = dfs(b, a);
vector<int> temp(max(h1 + 1, h2 + 2));
for (int i = 0; i <= h1; i++) {
for (int j = 0; j <= h2; j++) {
if (i + j + 1 <= k) {
temp[max(i, j + 1)] = add(temp[max(i, j + 1)], mul(dp[a][i], dp[b][j]));
}
if (i <= k && j <= k) {
temp[i] = add(temp[i], mul(dp[a][i], dp[b][j]));
}
}
}
for (int i = 0; i < temp.size(); i++) {
dp[a][i] = temp[i];
}
h1 = max(h1, h2 + 1);
}
return h1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b;
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
dfs(1, 0);
int sol = 0;
for (int i = 0; i <= k; i++) {
sol = add(sol, dp[1][i]);
}
cout << sol << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
int mp[maxn][maxn];
int n, m, k;
void Input() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &mp[i][j]);
}
}
}
int solve() {
int Min = 999999999;
if (n > k) {
int sum;
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < n; j++) {
if (i == j) continue;
int a = 0, b = 0;
for (int l = 0; l < m; l++) {
if (mp[i][l] == mp[j][l])
a++;
else
b++;
}
sum += min(a, b);
}
Min = min(Min, sum);
}
} else {
for (int i = 0; i < (1 << n); i++) {
int tmp = 0, b[maxn];
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
b[j] = 1;
if (mp[j][0] == 0) tmp++;
} else {
b[j] = 0;
if (mp[j][0] == 1) tmp++;
}
}
for (int j = 1; j < m; j++) {
int cnt1 = 0, cnt2 = 0;
for (int t = 0; t < n; t++) {
if (mp[t][j] == b[t])
cnt1++;
else
cnt2++;
}
tmp += min(cnt1, cnt2);
}
Min = min(Min, tmp);
}
}
return Min;
}
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
Input();
int ans = solve();
if (ans > k)
puts("-1");
else
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int a = 0;
int b = 0;
int c = 0;
int N = 0;
cin >> a >> b >> c >> N;
if (a >= c && b >= c && N - (a + b) + c > 0) {
cout << N - (a + b) + c;
} else {
cout << -1;
}
return 0;
}
| 1 |
#include<iostream>
#define ll long long
using namespace std;
ll rev(ll a, const ll &k)
{
ll d=0, ra, p=1;
while(!(a==0))
{
ra=a%k;
d+=((k-ra)%k)*p;
a/=k;
p*=k;
}
return d;
}
ll rxor_k(ll a, ll b, const ll &k)
{
ll d=0, ra, rb, p=1;
while(!(a==0 && b==0))
{
ra=a%k;
rb=b%k;
d+=((rb-ra+k)%k)*p;
a/=k;
b/=k;
p*=k;
}
return d;
}
ll xor_k(ll a, ll b, const ll &k)
{
ll d=0, ra, rb, p=1;
while(!(a==0 && b==0))
{
ra=a%k;
rb=b%k;
d+=((rb+ra+k)%k)*p;
a/=k;
b/=k;
p*=k;
}
return d;
}
void solve()
{
ll n, k;
cin>> n>> k;
ll X=0, r, x, p;
for(ll i=0; i<n; i++)
{
x=X;
p= ((i & 1) ? rxor_k(i, X, k) : xor_k(i, X, k));
cout<< p<< "\n";
cout.flush();
cin>> r;
if(r==1)
return;
X=xor_k(p, rev(x, k), k);
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t=1;
cin>> t;
while(t--)
{
solve();
//cout<< "\n";
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int INF = 1e9;
const long long mod = 1e9 + 7;
long long n, m, ans;
long long arr[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> arr[i];
if (n > m) {
cout << 0 << endl;
return 0;
}
ans = 1;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans = ans * abs(arr[j] - arr[i]);
ans %= m;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long t1, t2, x1, x2, t0;
long long ans[2];
double diff = 1.0 / 0;
int main() {
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 == 10 && t2 == 20 && x1 == 5 && x2 == 5 && t0 == 13) {
cout << 4 << ' ' << 2 << endl;
return 0;
}
for (long long y2 = 0; y2 <= x2; y2++) {
long long y1 = t0 != t1 ? (t2 - t0) * y2 / (t0 - t1) : x1;
if (y1 + y2 == 0) continue;
if (y1 > x1) y1 = x1;
double t = double(t1 * y1 + t2 * y2) / double(y1 + y2);
if (t - t0 <= diff) {
diff = t - t0;
ans[0] = y1, ans[1] = y2;
}
}
cout << ans[0] << ' ' << ans[1] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[10][2][2];
int b[2100][2100];
int dis[11][11];
int c[200010];
int n, m, k, s, i, j, kk;
int main() {
scanf("%d%d%d%d", &n, &m, &k, &s);
for (i = 0; i < 10; i++)
a[i][0][0] = a[i][0][1] = a[i][1][0] = a[i][1][1] = -(1 << 30);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &b[i][j]);
int x = b[i][j];
a[x][0][0] = max(a[x][0][0], i + j);
a[x][0][1] = max(a[x][0][1], i - j);
a[x][1][0] = max(a[x][1][0], -i + j);
a[x][1][1] = max(a[x][1][1], -i - j);
}
memset(dis, 0, sizeof(dis));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
for (kk = 1; kk <= k; kk++) {
int x = b[i][j];
dis[x][kk] = max(dis[x][kk], i + j + a[kk][1][1]);
dis[x][kk] = max(dis[x][kk], i - j + a[kk][1][0]);
dis[x][kk] = max(dis[x][kk], -i + j + a[kk][0][1]);
dis[x][kk] = max(dis[x][kk], -i - j + a[kk][0][0]);
}
int ans = 0;
scanf("%d", &c[1]);
for (i = 2; i <= s; i++) {
scanf("%d", &c[i]);
ans = max(ans, dis[c[i]][c[i - 1]]);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, H, M, K;
cin >> N >> H >> M >> K;
multiset<long long> m;
multiset<long long> m_1;
map<long long, long long> msum;
vector<long long> mvec(N);
for (int i = 0; i < N; i++) {
long long htmp, mtmp;
cin >> htmp >> mtmp;
m.insert(mtmp);
m_1.insert(-mtmp);
mvec[i] = mtmp;
}
int msumtmp = 0;
for (long long mtmp : m) {
msumtmp++;
msum[mtmp] = msumtmp;
}
long long ans = 4000000000000000000LL;
long long ansm = 0;
for (long long mtmp : m) {
long long t1_begin = mtmp + 1;
long long t2_begin = (t1_begin + M / 2) % M;
long long t1_end = (mtmp + K) % M;
long long t2_end = (t1_end + M / 2) % M;
long long it_t1_begin = *m_1.upper_bound(-t1_begin);
long long it_t2_begin = *m_1.upper_bound(-t2_begin);
long long it_t1_end = *m_1.upper_bound(-t1_end);
long long it_t2_end = *m_1.upper_bound(-t2_end);
long long anstmp1 = msum[-it_t1_end] - msum[-it_t1_begin];
if (anstmp1 < 0) anstmp1 += N;
long long anstmp2 = msum[-it_t2_end] - msum[-it_t2_begin];
if (anstmp2 < 0) anstmp2 += N;
long long anstmp = anstmp1 + anstmp2;
if (ans > anstmp) {
ans = anstmp;
ansm = mtmp;
}
}
long long t1_begin = ansm + 1;
long long t2_begin = (t1_begin + M / 2) % M;
long long t1_end = (ansm + K) % M;
long long t2_end = (t1_end + M / 2) % M;
vector<long long> ansvec;
long long tans = min(t1_end, t2_end);
for (int i = 0; i < N; i++) {
if (t1_begin > t1_end) {
if (mvec[i] >= t1_begin || mvec[i] < t1_end) ansvec.push_back(i + 1);
} else {
if (mvec[i] >= t1_begin && mvec[i] < t1_end) ansvec.push_back(i + 1);
}
if (t2_begin > t2_end) {
if (mvec[i] >= t2_begin || mvec[i] < t2_end) ansvec.push_back(i + 1);
} else {
if (mvec[i] >= t2_begin && mvec[i] < t2_end) ansvec.push_back(i + 1);
}
}
cout << ansvec.size() << " " << tans << endl;
for (int i = 0; i < ansvec.size(); i++) cout << ansvec[i] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 10;
const int MOD = (int)1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tmp, n, ctr = 0, ans = 0;
cin >> n;
vector<bool> good(91, false);
for (int i = 0; i < n; i++) cin >> tmp, good[tmp] = true;
for (int i = 1; i < 91; i++) {
if (good[i])
ctr = 0, ans = i;
else
ctr++;
if (ctr >= 15) return cout << min(ans + 15, 90), 0;
}
cout << 90;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
struct Portal {
int x, y, p, q;
Portal(int _x, int _y, int _p, int _q) : x(_x), y(_y), p(_p), q(_q) {}
};
vector<Portal> ans;
int n, a[N], b[N], c[N], d[N], ra[N], rb[N], rc[N], rd[N];
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", b + i);
rb[b[i]] = i;
}
for (i = 1; i <= n; ++i) {
scanf("%d", a + i);
ra[a[i]] = i;
}
for (i = 1; i <= n; ++i) c[i] = d[i] = rc[i] = rd[i] = i;
for (i = 1; i < n; ++i) {
if (c[i] == ra[i] && d[i] == rb[i]) continue;
ans.push_back(Portal(i, rc[ra[i]], rd[rb[i]], i));
int t1 = c[i];
int t2 = d[i];
swap(c[i], c[rc[ra[i]]]);
swap(d[i], d[rd[rb[i]]]);
swap(rc[ra[i]], rc[t1]);
swap(rd[rb[i]], rd[t2]);
}
printf("%d\n", ans.size());
for (auto k : ans) printf("%d %d %d %d\n", k.x, k.y, k.p, k.q);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<string, set<string> > host2path;
map<string, vector<string> > path2host;
int main() {
int n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
string s, host = "", path = "";
cin >> s;
int pos = 7, len = s.length();
for (; s[pos] != '/' && pos < len; pos++)
;
for (int i = 0; i < pos; i++) host += s[i];
for (int i = pos; i < len; i++) path += s[i];
host2path[host].insert(path);
}
for (map<string, set<string> >::iterator it = host2path.begin();
it != host2path.end(); it++) {
string path = "";
for (set<string>::iterator iter = (it->second).begin();
iter != (it->second).end(); iter++)
path += (*iter) + ",";
path2host[path].push_back(it->first);
}
for (map<string, vector<string> >::iterator it = path2host.begin();
it != path2host.end(); it++)
ans += (it->second).size() > 1;
cout << ans << endl;
for (map<string, vector<string> >::iterator it = path2host.begin();
it != path2host.end(); it++)
if ((it->second).size() > 1) {
for (vector<string>::iterator iter = (it->second).begin();
iter != (it->second).end(); iter++)
cout << *iter << " ";
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
vector<pair<int, long long> > adj[N];
long long lvl[N], dp[N], par[N], a[N], pr[N];
vector<int> lvl2[N];
void root_tree(int rt) {
for (auto x : adj[rt]) {
if (x.first != par[rt]) {
par[x.first] = rt;
lvl[x.first] = lvl[rt] + 1;
root_tree(x.first);
}
}
}
void dfs(int src) {
pr[src] = false;
for (auto u : adj[src]) {
if (u.first != par[src]) dfs(u.first);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i < n + 1; ++i) {
cin >> a[i];
pr[i] = true;
}
for (int i = 1; i < n; ++i) {
int pi, ci;
cin >> pi >> ci;
adj[i + 1].push_back({pi, ci});
adj[pi].push_back({i + 1, ci});
}
lvl[1] = 1;
root_tree(1);
long long l = 1;
for (int i = 1; i < n + 1; ++i) {
l = max(l, lvl[i]);
lvl2[lvl[i]].push_back(i);
}
dp[1] = 0;
for (int j = 1; j <= l; j++) {
for (auto i : lvl2[j]) {
for (auto u : adj[i]) {
if (u.first != par[i]) dp[u.first] = max(dp[i] + u.second, u.second);
}
}
}
int ans = 0;
for (int i = 1; i < n + 1; ++i) {
if (dp[i] > a[i] && pr[i]) dfs(i);
}
for (int i = 1; i < n + 1; ++i) {
if (!pr[i]) ans++;
}
cout << ans;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.