solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
precalc();
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
mt19937 rng(
(unsigned long long)chrono::steady_clock::now().time_since_epoch().count());
void precalc() {}
vector<vector<li> > g;
vector<li> mt;
vector<char> used;
bool try_kuhn(li v) {
if (used[v]) return false;
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i) {
li to = g[v][i];
if (mt[to] == -1 || try_kuhn(mt[to])) {
mt[to] = v;
return true;
}
}
return false;
}
li get_res(li n, li m) {
g.clear();
mt.clear();
used.clear();
li N = n * m;
g.resize(N);
mt.assign(N, -1);
for (li i = 0; i < N; ++i) {
li x = i / m, y = i % m;
if ((x + y) % 2 == 0) {
for (li dx = -3; dx <= 3; ++dx) {
for (li dy = -3; dy <= 3; ++dy) {
if (abs(dx) + abs(dy) == 3) {
li X = x + dx, Y = y + dy;
if (X >= 0 && X < n && Y >= 0 && Y < m) {
g[i].push_back(X * m + Y);
}
}
}
}
}
}
li res = 0;
for (li i = 0; i < N; ++i) {
used.assign(N, false);
if (try_kuhn(i)) {
++res;
}
}
return res;
}
li stupid_solve(li n, li m) {
if (n > m) {
swap(n, m);
}
li res = n * m / 2;
if (m < 10) {
res = get_res(n, m);
} else if (n == 1) {
if (m % 6 != 0 && m % 6 != 5 && m % 6 != 1 && res > 0) {
--res;
}
}
return res;
}
void solve(__attribute__((unused)) bool read) {
li n, m;
cin >> n >> m;
li res = stupid_solve(n, m);
cout << res * 2 << endl;
return;
for (n = 1; n <= 40; ++n) {
for (m = 1; m <= 40; ++m) {
li stup = stupid_solve(n, m);
li fact = get_res(n, m);
if (stup != fact) {
cout << "FOUND " << n << " " << m << " " << stup << " " << fact << endl;
exit(0);
}
}
}
}
| 2 |
#include <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <bitset>
#include <random>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <complex>
#include <functional>
using namespace std;
#define rep(i,a,b) for(int i = (a); i < int(b); ++i)
#define rrep(i,a,b) for(int i = (b); i --> int(a);)
#define all(v) v.begin(),v.end()
#define trav(x, v) for(auto &x : v)
#define sz(v) int((v).size())
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long double ld;
void fail(){
puts("No");
exit(0);
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<vi> a(3, vi(n));
trav(v, a) trav(x, v) cin >> x;
vi perm(n);
bool sign[2] = {};
rep(i,0,n){
int ix = (a[0][i]-1)/3;
if(a[1][i] != 3*ix+2) fail();
if(min(a[0][i], a[2][i]) != 3*ix+1
|| max(a[0][i],a[2][i]) != 3*ix+3) fail();
sign[i&1] ^= a[0][i] > a[2][i];
perm[i] = ix;
if((i+ix)&1) fail();
}
int numofcycles[2] = {};
vector<bool> vis(n);
rep(i,0,n) if(!vis[i]){
++numofcycles[i&1];
int j = i;
do {
vis[j] = 1;
j = perm[j];
} while(j != i);
}
int nn[2] = {n/2+(n&1), n/2};
if(sign[0] != (nn[1]+numofcycles[1])%2
|| sign[1] != (nn[0]+numofcycles[0])%2)
fail();
puts("Yes");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
long long INF = 1000000000;
long long MAXINT = 2147483647;
long long INFLL = 1000000000000000000LL;
long long MAXLL = 9223372036854775807LL;
pair<long long, long long> M[8] = {
make_pair(0, 1), make_pair(1, 0), make_pair(-1, 0), make_pair(0, -1),
make_pair(-1, 1), make_pair(-1, -1), make_pair(1, -1), make_pair(1, 1)};
long long d[100005];
long long t[100005];
long long sum[100005];
long long dp[102][100005];
long long n, m, p;
deque<pair<long long, long long> > v;
long long ptr;
bool cek(pair<long long, long long> v1, pair<long long, long long> v2,
pair<long long, long long> v3) {
return (v1.second - v2.second) * (v3.first - v1.first) <
(v1.second - v3.second) * (v2.first - v1.first);
}
void addpoLL(long long M, long long C) {
while ((long long)v.size() > 1 &&
cek(v[(long long)v.size() - 2], v[(long long)v.size() - 1],
make_pair(M, C)))
v.pop_back();
v.push_back(make_pair(M, C));
}
long long search(long long s) {
while ((long long)v.size() > 1 &&
v[0].first * s + v[0].second < v[1].first * s + v[1].second)
v.pop_front();
return v[0].first * s + v[0].second;
}
int main() {
scanf("%d%d%d", &n, &m, &p);
d[1] = 0LL;
for (long long(a) = (2); (a) <= (n); (a)++) {
scanf("%I64d", &d[a]);
}
for (long long(a) = (2); (a) <= (n); (a)++) {
d[a] += d[a - 1];
}
for (long long(a) = (1); (a) <= (m); (a)++) {
long long h;
long long tm;
scanf("%d %I64d", &h, &tm);
t[a] = tm - d[h];
}
sort(t + 1, t + m + 1);
long long maks = t[m];
long long sum = 0;
for (long long(a) = (1); (a) <= (m); (a)++) {
t[a] = maks - t[a];
sum += t[a];
}
p--;
for (long long(a) = (1); (a) <= (p); (a)++) {
v.clear();
ptr = 0;
for (long long(b) = (1); (b) <= (m); (b)++) {
addpoLL(1 - b, dp[a - 1][b - 1]);
dp[a][b] = (long long)b * t[b] + search(t[b]);
}
}
long long red = 0;
for (long long(b) = (1); (b) <= (m); (b)++) {
(red) = max((red), (dp[p][b]));
}
cout << sum - red << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long f() {
string s;
cin >> s;
int n = s.length();
vector<long long> a(n + 2, n);
int mi = 0;
int bal = 0;
for (int i = 0; i < n; ++i) {
bal += (s[i] == '+' ? 1 : -1);
if (bal < mi) {
mi = bal;
a[-bal] = i;
}
}
long long res = 0;
for (int i = 0; 1; ++i) {
int m = a[i + 1];
if (m == n) return res + n;
res += m + 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) cout << f() << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[22];
int main() {
long long a, b, d;
long long c, e, f, g, h;
cin >> a;
cin >> b;
for (d = 0; d < a; d++) cin >> arr[d];
for (d = a - 1, e = 0, g = 1; d > -1; d--) {
e += arr[d] * g;
g *= b;
}
cin >> a;
cin >> b;
for (d = 0; d < a; d++) cin >> arr[d];
for (d = a - 1, f = 0, g = 1; d > -1; d--) {
f += arr[d] * g;
g *= b;
}
if (f == e) {
printf("=\n");
} else if (f < e) {
printf(">\n");
} else
printf("<\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
char buf[1 << 23], *ps = buf, *pt = buf;
int read() {
register int x = 0;
register char f = 1, ch = (ps == pt && (pt = (ps = buf) +
fread(buf, 1, 1 << 23, stdin),
ps == pt)
? EOF
: *ps++);
for (; !isdigit(ch);
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
if (ch == '-') f ^= 1;
for (; isdigit(ch);
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
x = (x << 1) + (x << 3) + (ch ^ '0');
return f ? x : -x;
}
int read(char *s) {
int n = 0;
char ch =
(ps == pt && (pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++);
for (; isspace(ch) && ch != EOF;
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
;
for (; !isspace(ch) && ch != EOF;
ch = (ps == pt &&
(pt = (ps = buf) + fread(buf, 1, 1 << 23, stdin), ps == pt)
? EOF
: *ps++))
s[n++] = ch;
return s[n] = '\0', n;
}
char pbuf[1 << 23], *pp = pbuf;
struct __IO_flusher {
~__IO_flusher() { fwrite(pbuf, 1, pp - pbuf, stdout); }
} IO_flusher;
void print(int x, char ch = '\n') {
if (x == 0)
return (pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout),
pp = pbuf : 0, *pp++ = '0'),
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout),
pp = pbuf : 0, *pp++ = ch),
void(0);
int cnt = 0, num[25];
for (x < 0 ? (pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout),
pp = pbuf : 0, *pp++ = '-'),
x = -x : 0;
x; x /= 10)
num[++cnt] = x % 10;
while (cnt)
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout), pp = pbuf : 0,
*pp++ = num[cnt] ^ '0'),
--cnt;
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout), pp = pbuf : 0,
*pp++ = ch);
}
void print(const char *s, int n = -1, char ch = '\n') {
if (n == -1) n = strlen(s);
for (register int i = 0; i < n; ++i)
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout), pp = pbuf : 0,
*pp++ = s[i]);
(pp == pbuf + (1 << 23) ? fwrite(pbuf, 1, 1 << 23, stdout), pp = pbuf : 0,
*pp++ = ch);
}
const int N = 405, INF = 0x3f3f3f3f;
int n, m, f[N][N];
char s[N], t[N];
void solve() {
n = read(s + 1), m = read(t + 1);
for (register int p = 1; p <= m; ++p) {
for (register int i = 0; i <= n; ++i)
for (register int j = 0; j <= p; ++j) f[i][j] = -INF;
f[0][0] = 0;
for (register int i = 1; i <= n; ++i)
for (register int j = 0; j <= i && j <= p; ++j) {
int k = f[i - 1][j];
if (k >= 0) f[i][j] = k + (k <= m - p && s[i] == t[p + k + 1]);
if (j && s[i] == t[j]) f[i][j] = std::max(f[i][j], f[i - 1][j - 1]);
}
if (f[n][p] == m - p) return print("YES"), void(0);
}
print("NO");
}
int main() {
int T = read();
while (T--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void cpp() {}
signed main() {
cpp();
long long t;
cin >> t;
while (t--) {
long long a, b;
long long ans = 0;
cin >> a >> b;
if ((a + b) / 3 < a && (a + b) / 3 < b) {
cout << ((a + b) / 3) << endl;
continue;
} else {
cout << min(a, b) << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long k2, k3, k5, k6, ans, minim, minim1;
int main() {
cin >> k2 >> k3 >> k5 >> k6;
minim = min(k2, min(k5, k6));
ans = 256 * minim;
k2 -= minim;
k5 -= minim;
k6 -= minim;
minim1 = min(k2, k3);
ans += 32 * minim1;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second > b.second;
}
};
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
vector<long long> v;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
int ptr1 = 0;
int ptr2 = n - 1;
long long sum1 = 0, sum2 = 0;
while (ptr2 >= ptr1) {
if (sum2 >= sum1) {
sum1 += v[ptr1];
ptr1++;
}
if (sum1 > sum2) {
sum2 += v[ptr2];
ptr2--;
}
}
cout << sum2 - sum1 + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> edges[N];
vector<int> c(N);
bool good(int u, int p) {
bool res = true;
for (int v : edges[u]) {
if (v != p) {
if (c[u] != c[v]) {
return false;
}
res &= good(v, u);
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
int v0 = -1, v1 = -1;
for (int i = 0; i < n; i++) {
for (int node : edges[i]) {
if (c[i] != c[node]) {
v0 = i;
v1 = node;
break;
}
}
}
if (v0 == -1) {
cout << "YES\n1\n";
return 0;
}
bool got = true;
int ans_node = -1;
for (int v : edges[v0]) {
got &= good(v, v0);
}
if (got) {
ans_node = v0;
}
if (!got) {
got = true;
for (int v : edges[v1]) {
got &= good(v, v1);
}
if (got) {
cout << "YES\n" << v1 + 1 << '\n';
} else {
cout << "NO\n";
}
} else {
cout << "YES\n" << ans_node + 1 << '\n';
}
return 0;
}
| 1 |
// D - Dice in Line
#include <bits/stdc++.h>
using namespace std;
#define rp(i,s,e) for(int i=(s);i<(e);++i)
int main(){
int N,K; cin>>N>>K;
vector<int> P(N+K); rp(i,0,N) cin>>P[i+K];
int ans = 0, sum = 0;
rp(i,0,N) ans = max(ans, sum += P[i+K] - P[i]);
printf("%.12f\n",(ans+K)/2.0);
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 1;
const int INF = 1e9 + 7;
using namespace std;
int f[MAXN][10][10][2][2];
string A, B;
void add(int &a, int b) {
a += b;
if (a >= INF) a -= INF;
}
int n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> A >> B;
A = '=' + A;
B = '=' + B;
f[0][0][0][0][0] = 1;
for (int i = 0; i < n; i++)
for (int x = 0; x <= 9; x++)
for (int y = 0; y <= 9; y++)
for (int p = 0; p <= 1; p++)
for (int q = 0; q <= 1; q++)
if (f[i][x][y][p][q]) {
int d1 = 0, c1 = 9, d2 = 0, c2 = 9;
if (A[i + 1] != '?') d1 = A[i + 1] - '0', c1 = d1;
if (B[i + 1] != '?') d2 = B[i + 1] - '0', c2 = d2;
for (int x1 = d1; x1 <= c1; x1++)
for (int y1 = d2; y1 <= c2; y1++)
add(f[i + 1][x1][y1][p | (x1 < y1)][q | (x1 > y1)],
f[i][x][y][p][q]);
}
int ans = 0;
for (int x = 0; x <= 9; x++)
for (int y = 0; y <= 9; y++) add(ans, f[n][x][y][1][1]);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int a[300009];
vector<pair<pair<long long int, long long int>,
pair<long long int, long long int>>>
v;
long long int ans = 1;
vector<int> vec;
bool check(int idx, long long int mid) {
long long int dist, i, j, x, fuel = mid, cnt = v[idx].second.second,
kitna_chlegi;
for (i = v[idx].first.first; i < v[idx].first.second; i++) {
x = a[i + 1] - a[i];
kitna_chlegi = fuel / v[idx].second.first;
if (kitna_chlegi < x) {
if (cnt == 0 || mid / v[idx].second.first < x) {
return 0;
}
fuel = mid;
cnt--;
}
fuel -= x * v[idx].second.first;
}
return 1;
}
void update(int idx) {
if (check(idx, ans)) {
return;
}
long long int l = ans, r = 1000000000000000000, temp = r, mid;
bool f;
while (l <= r) {
mid = (l + r) / 2;
f = check(idx, mid);
if (f) {
temp = min(temp, mid);
r = mid - 1;
} else {
l = mid + 1;
}
}
ans = max(ans, temp);
}
int main() {
long long int i, j, k, x, y, t, n, m, p;
scanf("%lld%lld", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%lld%lld", &x, &y);
scanf("%lld%lld", &j, &k);
v.push_back(make_pair(make_pair(x, y), make_pair(j, k)));
vec.push_back(i);
}
random_shuffle(vec.begin(), vec.end());
for (i = 0; i < m; i++) {
update(vec[i]);
}
cout << ans << endl;
;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
struct point {
int x, y;
point() {}
point(int _x, int _y) : x(_x), y(_y) {}
inline friend point operator-(const point &a, const point &b) {
return point(a.x - b.x, a.y - b.y);
}
inline friend point operator+(const point &a, const point &b) {
return point(a.x + b.x, a.y + b.y);
}
inline friend long long operator*(const point &a, const point &b) {
return 1ll * a.x * b.y - 1ll * a.y * b.x;
}
} p[N], A, B, C;
int n, top;
long long S;
inline long long area(int i, int j, int k) {
return abs((p[j] - p[i]) * (p[k] - p[i]));
}
int main() {
scanf("%d%lld", &n, &S);
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i].x, &p[i].y);
int a = 1, b = 2, c = 3;
bool bz = 1;
S = area(a, b, c);
while (bz) {
bz = 0;
for (int i = 1; i <= n; i++) {
long long tmp;
tmp = area(a, b, i);
if (tmp > S) S = tmp, c = i, bz = 1;
tmp = area(a, i, c);
if (tmp > S) S = tmp, b = i, bz = 1;
tmp = area(i, b, c);
if (tmp > S) S = tmp, a = i, bz = 1;
}
}
A = p[a] + (p[b] - p[c]), B = p[b] + (p[c] - p[a]), C = p[c] + (p[a] - p[b]);
printf("%d %d\n%d %d\n%d %d\n", A.x, A.y, B.x, B.y, C.x, C.y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int N = 1e5 + 5;
int n;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
n = s.length();
string distinct = "A";
vector<int> st;
vector<pair<int, string>> ans(n);
for (int i = n - 1; i >= 0; i--) {
if (!st.empty() and distinct.size() > 1 and st.back() == i + 1 and
s[i + 1] == s[i] and distinct[distinct.length() - 2] < s[i]) {
st.pop_back();
if (st.empty() or s[st.back()] != s[i]) {
distinct.pop_back();
}
} else {
st.push_back(i);
if (distinct.back() != s[i]) {
distinct += s[i];
}
}
ans[i].first = st.size();
if (st.size() > 10) {
for (int j = st.size() - 1; j >= st.size() - 5; j--) {
ans[i].second += s[st[j]];
}
ans[i].second += "...";
ans[i].second += s[st[1]];
ans[i].second += s[st[0]];
} else {
for (int j = st.size() - 1; j >= 0; j--) {
ans[i].second += s[st[j]];
}
}
}
for (auto& [len, str] : ans) {
cout << len << ' ' << str << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, Q, u, v, w, x, y, edgenum, mid;
int vet[200010], Next[200010], head[100010], len[200010], d[100010], q[100010],
f[100010][22];
long long ans, Mx[100010], Mx2[100010], Mx3[100010], dis[100010],
up[100010][22], down[100010][22];
void read(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 3) + x + x + ch - '0';
ch = getchar();
}
}
void add(int u, int v, int w) {
vet[++edgenum] = v;
Next[edgenum] = head[u];
head[u] = edgenum;
len[edgenum] = w;
}
void update(int u, long long x) {
if (x > Mx[u]) {
Mx3[u] = Mx2[u];
Mx2[u] = Mx[u];
Mx[u] = x;
} else if (x > Mx2[u]) {
Mx3[u] = Mx2[u];
Mx2[u] = x;
} else if (x > Mx3[u])
Mx3[u] = x;
}
void dfs(int u, int fa, int dep, long long l) {
f[u][0] = fa;
d[u] = dep;
dis[u] = l;
for (int e = head[u]; e; e = Next[e]) {
int v = vet[e];
if (v != fa) {
dfs(v, u, dep + 1, l + len[e]);
update(u, Mx[v] + len[e]);
}
}
for (int e = head[u]; e; e = Next[e]) {
int v = vet[e];
if (v != fa) {
if (Mx[v] + len[e] == Mx[u]) {
up[v][0] = Mx2[u] + len[e];
down[v][0] = Mx2[u];
} else {
up[v][0] = Mx[u] + len[e];
down[v][0] = Mx[u];
}
}
}
}
int lca(int u, int v) {
if (d[u] < d[v]) swap(u, v);
int l = d[u] - d[v];
for (int i = 0; i <= 20; i++)
if (l >> i & 1) u = f[u][i];
for (int i = 20; i >= 0; i--)
if (f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
if (u == v) return u;
return f[u][0];
}
long long getup(int u, int v) {
int l = d[u] - d[v];
int x = u;
long long ans = 0;
for (int i = 0; i <= 20; i++)
if (l >> i & 1) {
ans = max(ans, up[x][i] + dis[u] - dis[x]);
x = f[x][i];
}
return ans;
}
long long getdown(int u, int v) {
int l = d[u] - d[v];
int x = u;
long long ans = 0;
for (int i = 0; i <= 20; i++)
if (l >> i & 1) {
ans = max(ans, down[x][i] + dis[f[x][i]] - dis[v]);
x = f[x][i];
}
return ans;
}
int jump(int u, int l) {
for (int i = 0; i <= 20; i++)
if (l >> i & 1) u = f[u][i];
return u;
}
int main() {
read(n);
for (int i = 1; i < n; i++) {
read(u);
read(v);
w = 1;
add(u, v, w);
add(v, u, w);
}
dfs(1, 0, 1, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
up[i][j] =
max(up[i][j - 1], up[f[i][j - 1]][j - 1] + dis[i] - dis[f[i][j - 1]]);
down[i][j] = max(down[i][j - 1] + dis[f[i][j - 1]] - dis[f[i][j]],
down[f[i][j - 1]][j - 1]);
}
read(Q);
while (Q--) {
read(x);
read(y);
if (dis[x] < dis[y]) swap(x, y);
int z = lca(x, y);
long long l = dis[x] + dis[y] - 2 * dis[z];
mid = x;
for (int i = 20; i >= 0; i--)
if ((dis[x] - dis[f[mid][i]]) * 2 < l) mid = f[mid][i];
ans = 0;
if (y == z) {
ans = max(Mx[x], getup(x, mid));
ans = max(ans, getdown(mid, y));
ans = max(ans, getup(y, 1));
} else {
ans = max(Mx[x], Mx[y]);
if (d[mid] < d[x]) ans = max(ans, getup(x, mid));
if (d[1] < d[z]) ans = max(ans, getup(z, 1) + dis[y] - dis[z]);
int t1 = jump(x, d[x] - d[z] - 1), t2 = jump(y, d[y] - d[z] - 1);
if (d[t1] < d[mid])
ans = max(ans, getdown(mid, t1) + dis[t1] + dis[y] - 2 * dis[z]);
if (d[t2] < d[y]) ans = max(ans, getup(y, t2));
long long w1 = Mx[t1] + dis[t1] - dis[z], w2 = Mx[t2] + dis[t2] - dis[z];
if (w1 < w2) swap(w1, w2);
if (Mx[z] == w1 && Mx2[z] == w2)
ans = max(ans, Mx3[z] + dis[y] - dis[z]);
else if (Mx[z] == w1)
ans = max(ans, Mx2[z] + dis[y] - dis[z]);
else
ans = max(ans, Mx[z] + dis[y] - dis[z]);
}
printf("%lld\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)10e9 + 7;
vector<char> readCharArray(int size);
vector<int> readArray(int size);
template <class T>
void print1D(vector<T>);
template <class T>
void print2D(vector<vector<T>>);
void solve() {
int a, b;
cin >> a >> b;
int ans = abs(a - b) / 10;
if ((abs(a - b) % 10 != 0)) ans++;
cout << ans << (char)'\n';
;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tt = 1;
cin >> tt;
for (int i = 0; i < tt; i++) {
solve();
}
return 0;
}
template <class T>
void print1D(vector<T> arr) {
for (auto x : arr) {
cout << x << " ";
}
cout << "\n";
}
template <class T>
void print2D(vector<vector<T>> arr) {
for (auto x : arr) {
for (auto el : x) {
cout << el << " ";
}
cout << " \n";
}
cout << "\n";
}
vector<int> readArray(int size) {
vector<int> arr(size, 0);
for (int i = 0; i < size; i++) {
cin >> arr[i];
}
return arr;
}
vector<char> readCharArray(int size) {
vector<char> a(size);
for (int i = 0; i < size; i++) cin >> a[i];
return a;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long N, M;
cin >> N >> M;
if (N == 1)
cout << 0;
else if (M >= N / 2) {
cout << N * (N - 1) / 2;
} else {
long long Ans = 0;
long long Cnt = 0;
while (Cnt < M) {
Ans += N - (Cnt + 1);
Cnt++;
}
long long Have = N - M;
long long Have2 = Have - M;
Ans += Have2 * M;
Ans += M * (M - 1) / 2;
cout << Ans;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 410;
struct edge {
int to, next;
} e[N * N * 2], e2[N * N * 2];
int head[N], ecnt, vis[N], stk[N], top, dfn[N], low[N], dfsn, head2[N], ecnt2;
int scc, belong[N], Belong[N];
inline void adde(int from, int to) {
from = Belong[from], to = Belong[to];
e[++ecnt] = (edge){to, head[from]}, head[from] = ecnt;
}
inline void adde2(int from, int to) {
e2[++ecnt2] = (edge){to, head2[from]}, head2[from] = ecnt2;
}
inline void Tarjan(int u, int ls) {
stk[++top] = u, vis[u] = 1;
dfn[u] = low[u] = ++dfsn;
for (int i = head[u]; i; i = e[i].next)
if (i != ls) {
if (!dfn[e[i].to])
Tarjan(e[i].to, i), low[u] = min(low[u], low[e[i].to]);
else if (vis[e[i].to])
low[u] = min(low[u], dfn[e[i].to]);
}
if (low[u] == dfn[u]) {
scc++;
int v = -1;
while (v != u) {
v = stk[top--];
belong[v] = scc, vis[v] = 0;
}
}
}
inline void Clear(int n) {
fill(head + 1, head + n + 1, 0), fill(dfn + 1, dfn + n + 1, 0),
scc = ecnt = 0;
}
inline bool Just_DOIT(int n) {
assert((n & 1) ^ 1);
for (int i = 1; i <= n; i++)
if (!dfn[Belong[i]]) Tarjan(Belong[i], 0);
for (int i = 1; i <= n / 2; i++)
if (belong[Belong[i]] == belong[Belong[i + n / 2]]) return false;
return true;
}
int n;
inline int ID(int t, int x) { return t * n + x; }
inline void mark(int t, int x) { adde(ID(t ^ 1, x), ID(t, x)); }
inline void mark(int t1, int t2, int x, int y) {
adde(ID(t1, x), ID(t2, y)), adde(ID(t2 ^ 1, y), ID(t1 ^ 1, x));
}
int nxt[30][2], vowel[30];
char s[N], t[N];
int T1[N * N], T2[N * N], from[N * N], to[N * N], m;
inline bool check(int cur) {
Clear(n * 2);
ecnt = ecnt2, memcpy(e, e2, sizeof(edge) * (ecnt2 + 1));
for (int i = 1; i <= n * 2; i++) head[i] = head2[i];
for (int i = 1; i <= cur; i++) mark(vowel[t[i] - 'a'], i);
return Just_DOIT(n * 2);
}
char str[30];
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
int cur[2] = {-1, -1};
for (int i = len; i >= 0; i--) {
nxt[i][0] = cur[0], nxt[i][1] = cur[1];
if (i) cur[str[i] == 'V'] = i - 1, vowel[i - 1] = str[i] == 'V';
}
scanf("%d%d", &n, &m);
for (int i = 1; i <= n * 2; i++) Belong[i] = i;
for (int i = 1; i <= m; i++) {
char c1, c2;
scanf("%d %c %d %c", &from[i], &c1, &to[i], &c2);
T1[i] = c1 == 'V', T2[i] = c2 == 'V';
}
for (int i = 1; i <= m; i++) mark(T1[i], T2[i], from[i], to[i]);
if (!Just_DOIT(n * 2)) return puts("-1"), 0;
for (int i = 1; i <= n * 2; i++) Belong[i] = belong[i];
for (int i = 1; i <= n * 2; i++)
for (int j = head[i]; j; j = e[j].next) {
int a = belong[i], b = belong[e[j].to];
if (a != b) adde2(a, b);
}
scanf("%s", s + 1);
int pos = -1;
for (int i = n; i >= 0; i--) {
for (int j = 1; j <= i; j++) t[j] = s[j];
if (i != n) t[i + 1] = nxt[s[i + 1] - 'a' + 1][0] + 'a';
if (t[i + 1] != 'a' - 1 && check(min(n, i + 1))) {
pos = i;
break;
}
if (i != n) t[i + 1] = nxt[s[i + 1] - 'a' + 1][1] + 'a';
if (i != n && t[i + 1] != 'a' - 1 && check(min(n, i + 1))) {
pos = i;
break;
}
}
if (!~pos) return puts("-1"), 0;
for (int i = 1; i <= pos; i++) t[i] = s[i];
for (int i = pos + 1; i <= n; i++) {
char a = i == pos + 1 ? nxt[s[i] - 'a' + 1][0] : nxt[0][0],
b = i == pos + 1 ? nxt[s[i] - 'a' + 1][1] : nxt[0][1];
a += 'a', b += 'a';
if (a == 'a' - 1) a = 'z' + 1;
if (b == 'a' - 1) b = 'z' + 1;
if (a > b) swap(a, b);
t[i] = a;
if (t[i] != 'z' + 1 && check(i)) continue;
t[i] = b;
if (t[i] < 'a' || t[i] > 'z') return puts("-1"), 0;
}
for (int i = 1; i <= n; i++) putchar(t[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const long long INF64 = 1e18;
const double EPS = 1e-9;
const double PI = acos(-1);
const long long MD = 295622452151813443;
const long long T = 26;
const int N = 300100;
const int M = 510;
int n;
double w, v, u;
pair<double, double> a[N];
bool comp(pair<double, double> a, pair<double, double> b) {
return a.second < b.second;
}
int main() {
cin >> n >> w >> v >> u;
double min_x = INF, max_x = -INF;
for (int i = 0; i < int(n); i++) {
cin >> a[i].first >> a[i].second;
min_x = min(min_x, a[i].first);
max_x = max(max_x, a[i].first);
}
double ans = INF;
sort(a, a + n, comp);
if (min_x >= 0) {
bool f = 1;
for (int i = 0; i < int(n); i++) {
double s1 = a[i].first / v, s2 = a[i].second / u;
if (s2 - s1 > EPS) f = 0;
}
if (f) {
printf("%.16lf", w / u);
return 0;
}
}
double sum = 0, yy = 0;
for (int i = 0; i < int(n); i++) {
if (a[i].first - sum * v >= 0) {
double s1 = (a[i].first - sum * v) / v;
sum += max(s1, (a[i].second - yy) / u);
yy = a[i].second;
}
}
printf("%.16lf", sum + (w - yy) / u);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n--;
long long sum = 0;
for (long long x = 0; 1ll << x <= n; x++)
sum += (((n - (1ll << x)) >> (x + 1)) + 1) << x;
cout << sum << '\n';
}
| 5 |
#include<iostream>
#include<cmath>
#include<string>
#include<map>
#include<queue>
using namespace std;
#define N 3
#define N2 9
struct Puzzle {
int f[N2];
int space;
string path;
bool operator<(const Puzzle& p) const {
for (int i = 0; i < N2; i++) {
if (f[i] == p.f[i]) continue;
return f[i] > p.f[i];
}
return false;
}
};
static const int dx[4] = { -1,0,1,0 };
static const int dy[4] = { 0,-1,0,1 };
static char dir[4] = { 'u','l','d','r' };
bool isTarget(Puzzle p) {
for (int i = 0; i < N2; i++) {
if (p.f[i] != (i + 1)) return false;
}
return true;
}
string bfs(Puzzle s) {
queue<Puzzle> Q;
map<Puzzle, bool> V;
Puzzle u, v;
s.path = "";
Q.push(s);
V[s] = true;
while (!Q.empty()) {
u = Q.front();
Q.pop();
if (isTarget(u)) return u.path;
int sx = u.space / N;
int sy = u.space % N;
for (int r = 0; r < 4; r++) {
int tx = sx + dx[r];
int ty = sy + dy[r];
if (tx < 0 || ty < 0 || tx >= N || ty >= N) continue;
v = u;
swap(v.f[u.space], v.f[tx * N + ty]);
v.space = tx * N + ty;
if (!V[v]) {
V[v] = true;
v.path += dir[r];
Q.push(v);
}
}
}
return "unsolvable";
}
int main() {
Puzzle in;
for (int i = 0; i < N2; i++) {
cin >> in.f[i];
if (in.f[i] == 0) {
in.f[i] = N2;
in.space = i;
}
}
string ans = bfs(in);
cout << ans.size() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > dp[1000004];
int main() {
int n, m, idx = -1, a[2003], b[2003], c[2003], d[2003], ans = 2000004;
vector<pair<int, int> > vec;
multiset<int> s;
multiset<int>::iterator it;
int arr[2003];
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d %d", &a[i], &b[i]);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &c[i], &d[i]);
vec.push_back(make_pair(c[i], i));
}
sort(vec.begin(), vec.end());
for (int i = m - 1; i >= 0; --i) {
if (idx == -1 || d[vec[i].second] > d[arr[idx]]) {
idx++;
arr[idx] = vec[i].second;
}
}
for (int i = 0; i < n; ++i) {
bool flag = 0;
for (int j = idx; j >= 0; --j) {
if (c[arr[j]] < a[i]) continue;
if (!flag) s.insert(max(d[arr[j]] - b[i] + 1, 0));
dp[c[arr[j]] - a[i]].push_back(
make_pair(max(d[arr[j]] - b[i] + 1, 0),
j ? max(d[arr[j - 1]] - b[i] + 1, 0) : 0));
flag = 1;
}
if (!flag) s.insert(0);
}
for (int i = 0; i < 1000002; ++i) {
it = s.end();
--it;
ans = min(ans, (*it) + i);
for (int j = 0; j < dp[i].size(); ++j) {
it = s.find(dp[i][j].first);
s.erase(it);
s.insert(dp[i][j].second);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m, rb, cb, rd, cd;
cin >> n >> m >> rb >> cb >> rd >> cd;
int dr = 1, dc = 1;
int time = 0;
if (rb == rd || cb == cd) {
cout << 0 << "\n";
continue;
}
while (true) {
if (rb + dr < 1 || rb + dr > n) {
dr = -dr;
}
if (cb + dc < 1 || cb + dc > m) {
dc = -dc;
}
rb = rb + dr;
cb = cb + dc;
time++;
if (rb == rd || cb == cd) break;
}
cout << time << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.0000000000001;
const int mod = 1000000007;
int n, m;
vector<double> cra;
vector<double> crb;
struct P {
long long x;
long long y;
P() {}
P(long long _x, long long _y) {
x = _x;
y = _y;
}
P operator-(const P &b) const { return P(x - b.x, y - b.y); }
};
P ps[100005];
int nt[1000005];
bool cmp_p(P a, P b) {
if (a.x == b.x)
return a.y < b.y;
else
return a.x < b.x;
}
double dot(P b, P a, P c) {
return (b.x - a.x) * (c.x - a.x) + (b.y - a.y) * (c.y - a.y);
}
double cross(P b, P a, P c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
double dist(P a, P b) {
return (b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y);
}
void gch(P *p, int nl, vector<double> &cr) {
sort(p, p + nl, cmp_p);
vector<P> ch(nl * 2);
int k = 0;
for (int i = 0; i < nl; i++) {
while (k > 1 && cross(ch[k - 2], ch[k - 1], p[i]) <= 0) k--;
ch[k] = p[i];
k++;
}
for (int i = nl - 2, t = k; i >= 0; i--) {
while (k > t && cross(ch[k - 2], ch[k - 1], ps[i]) <= 0) k--;
ch[k] = p[i];
k++;
}
ch.resize(k - 1);
k--;
for (int i = 1; i < k - 1; i++) {
cr.push_back(dist(ch[i - 1], ch[i]));
cr.push_back(dot(ch[i - 1], ch[i], ch[i + 1]));
}
cr.push_back(dist(ch[k - 2], ch[k - 1]));
cr.push_back(dot(ch[k - 2], ch[k - 1], ch[0]));
cr.push_back(dist(ch[k - 1], ch[0]));
cr.push_back(dot(ch[k - 1], ch[0], ch[1]));
}
void gnt(vector<double> &b) {
int bl = b.size();
int k = -1;
int i = 0;
nt[0] = -1;
while (i < bl) {
if (k == -1 || b[k] == b[i]) {
i++;
k++;
nt[i] = k;
} else {
k = nt[k];
}
}
}
bool KMP(vector<double> &a, vector<double> &b) {
int al = a.size();
int bl = b.size();
if (al != bl) return false;
int i = 0;
int j = 0;
int flag = 0;
while (j < bl) {
if (i == al) {
i = 0;
}
if (i == 0 && j == 0) {
flag++;
}
if (flag == 2) break;
if (j == -1 || a[i] == b[j]) {
i++;
j++;
} else {
j = nt[j];
}
}
if (j == bl)
return true;
else
return false;
}
int main() {
scanf("%d%d", &n, &m);
long long a, b;
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &a, &b);
ps[i].x = a;
ps[i].y = b;
}
gch(ps, n, cra);
for (int i = 0; i < m; i++) {
scanf("%I64d%I64d", &a, &b);
ps[i].x = a;
ps[i].y = b;
}
gch(ps, m, crb);
gnt(crb);
if (KMP(cra, crb)) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main(){
int n, tmp, wa=0;
cin >> n;
tmp=n;
while (tmp) {
wa+=tmp%10;
tmp/=10;
}
printf("%s\n", n%wa==0 ? "Yes": "No");
return 0;
}
| 0 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T>
int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
const double EPS = 1e-8;
typedef long long ll;
typedef pair<int, int> pint;
int main()
{
int x, y, z;
while (scanf("%d%d%d", &x, &y, &z), x|y|z)
{
float p = 1.0 / x;
int v[4], e[51], a[51];
for (int i = 0; i < x; ++i)
scanf("%d", v + i);
memset(e, 0, sizeof(e));
for (int i = 0; i < z; ++i)
{
int t;
scanf("%d", &t);
scanf("%d%d", e + t, a + t);
}
int max_money = 0;
for (int i = 0; i < y; ++i)
if (e[i] == 2)
max_money += a[i];
static float dp[51][5001];
for (int i = 0; i <= y; ++i)
for (int j = 0; j <= max_money; ++j)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 0; i < y; ++i)
{
for (int j = 0; j <= max_money; ++j)
{
if (dp[i][j] == 0)
continue;
for (int k = 0; k < x; ++k)
{
int to = min(y, i + v[k]);
int money = j;
if (e[to] == 1)
to = min(y, to + a[to]);
else if (e[to] == 2)
money += a[to];
else if (e[to] == 3)
money = max(0, money - a[to]);
dp[to][money] += dp[i][j] * p;
}
}
}
float res = 0;
for (int i = 0; i <= max_money; ++i)
res += i * dp[y][i];
printf("%d\n", (int)res);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
typedef long long ll;
const int mod = 1e9 + 7;
#define X first
#define Y second
vector<pair<int, int> > E[MAXN];
bool flag = true;
bool vis[MAXN];
int d[MAXN];
void dfs(int x)
{
for (auto e: E[x])
{
int y = e.X, z = e.Y;
if (!vis[y])
{
vis[y] = true;
d[y] = d[x] + z;
dfs(y);
}
else if (d[y] != d[x] + z) flag = false;
}
}
int main()
{
//freopen("input", "r", stdin);
int n, m, x, y, z;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i)
{
scanf("%d %d %d", &x, &y, &z);
E[x].push_back(make_pair(y, z));
E[y].push_back(make_pair(x, -z));
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) vis[i] = true, d[i] = 0, dfs(i);
puts(flag? "Yes":"No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i = 0;
int j = s.size() - 1;
while (s[i] == '0' && i < s.size()) {
i++;
}
while (s[j] == '0' && j >= 0) {
j--;
}
while (i < j) {
if (s[i] != s[j]) {
cout << "NO";
return 0;
}
i++;
j--;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9, M = 1e6 + 9, OO = 0x3f3f3f3f;
long long llOO = 0x3f3f3f3f3f3f3f3f;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
string s;
cin >> s;
int n = s.size();
long long zeros = 0, ones = 0, prev = 0, ans = 0;
for (int i = 0; i < n;) {
while (i < n && s[i] == '0') {
zeros++;
i++;
}
while (i < n && s[i] == '1') {
ones++;
i++;
}
if (ones) ans += a;
if (ones && zeros && prev) {
ans = min(ans - a + zeros * b, ans);
}
prev = ones > 0;
zeros = ones = 0;
}
cout << ans << '\n';
}
}
| 2 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int* A = new int[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int q;
cin >> q;
int k;
int answer;
for (int i = 0; i < q; i++) {
cin >> k;
answer = lower_bound(A, A + n, k) - A;
cout << answer << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int k, n;
int arr[300100];
int main() {
int i, j;
scanf("%d%d",&k,&n);
if (k%2==0) {
printf("%d ",k/2);
for (i=1;i<n;i++) printf("%d ",k);
printf("\n");
return 0;
}
if (k==1) {
for (i=0;i<(n+1)/2;i++) printf("1 ");
printf("\n");
return 0;
}
for (i=0;i<n;i++) arr[i] = (k+1)/2;
for (i=0;i<n/2;i++) {
for (j=n-1;!arr[j];j--);
arr[j]--;
if (arr[j]) for (j++;j<n;j++) arr[j]=k;
}
for (i=0;i<n;i++) {
if (arr[i]) printf("%d ",arr[i]);
}
printf("\n");
return 0;
}
| 0 |
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <list>
#include <cassert>
#include <ctime>
#include <climits>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a,ll b) { return b==0?a:gcd(b,a%b); }
const int MAXN = 300000;
int n, len;
int x[MAXN];
int t[MAXN];
char s[MAXN + 1];
ll solve() {
ll ret = 0;
REP(i, n) {
int y = t[i], z = (y - 1) / (2 * len);
ret += 2 * z + 1; y -= 2 * len*z;
bool l = y <= 2 * x[i], r = y <= 2 * (len - x[i]);
s[i] = l&&r ? '*' : l ? 'R' : r ? 'L' : '-';
}
s[n] = '\0';
//printf("%s: %lld\n", s, ret);
{ int at = 0; REP(i, n - 1) if (s[i] == 'L') { while (at < i&&s[at] != '*') ++at; if (at < i) s[at] = s[i] = '.'; } }
{ int at = 0; REP(i, n) if (s[i] == '*') { while (at < i&&s[at] != 'R') ++at; if (at<i) s[at] = s[i] = '.'; } }
{ int at = 0; REP(i, n) if (s[i] == '*') { while (at < i&&s[at] != '*') ++at; if (at < i) s[at] = s[i] = '.'; } }
REP(i, n) if (s[i] != '.') ++ret;
if (s[n - 1] != '*'&&s[n - 1] != 'L') ret += 2;
//printf("%s: %lld\n", s, ret);
return ret*len;
}
void run() {
scanf("%d%d", &n, &len); REP(i, n) scanf("%d", &x[i]); REP(i, n) scanf("%d", &t[i]);
ll ans = solve();
printf("%lld\n", ans);
}
int main() {
run();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BM(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 mdINV(T a, T M) {
return BM(a, M - 2, M);
}
template <class T>
inline T PW(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;
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <class T>
T stringtonumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
template <class T>
bool ISLEFT(T a, T b, T c) {
if (((a.first.first - b.first.first) * (b.second.second - c.second.second) -
(b.first.first - c.first.first) * (a.second.second - b.second.second)) <
0.0)
return 1;
else
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int re[2][m + 2];
memset(re, 0, sizeof re);
map<string, int> mp;
string a, b, c, first;
int ara[2][n + 2][m + 2];
for (int i = 1; i <= n; i++) {
do {
getline(cin, first);
} while (first.size() == 0);
istringstream is(first);
vector<string> v;
while (is >> a) {
v.push_back(a);
}
int l = v.size();
if (l == 3) {
if (v[2][0] == '0' || v[2][0] == '1') {
mp[v[0]] = i;
for (int j = 0; j <= m - 1; j++)
ara[0][i][j] = ara[1][i][j] = v[2][j] - '0';
} else {
mp[v[0]] = i;
for (int j = 0; j <= m - 1; j++) {
ara[0][i][j] = ara[0][mp[v[2]]][j];
ara[1][i][j] = ara[1][mp[v[2]]][j];
}
}
} else {
string second = v[2];
string z = v[4];
for (int j = 0; j <= m - 1; j++) {
int b1 = 0;
int c1 = 0;
if (second[0] != '?') b1 = ara[0][mp[second]][j];
if (z[0] != '?') c1 = ara[0][mp[z]][j];
int res = 0;
if (v[3][0] == 'A')
res = b1 & c1;
else if (v[3][0] == 'O')
res = b1 | c1;
else
res = b1 ^ c1;
re[0][j] += res;
ara[0][i][j] = res;
res = 0;
b1 = 1;
c1 = 1;
if (second[0] != '?') b1 = ara[1][mp[second]][j];
if (z[0] != '?') c1 = ara[1][mp[z]][j];
if (v[3][0] == 'A')
res = b1 & c1;
else if (v[3][0] == 'O')
res = b1 | c1;
else
res = b1 ^ c1;
re[1][j] += res;
ara[1][i][j] = res;
mp[v[0]] = i;
}
}
}
for (int i = 0; i <= m - 1; i++) {
if (re[0][i] <= re[1][i])
printf("0");
else
printf("1");
}
printf("\n");
for (int i = 0; i <= m - 1; i++) {
if (re[0][i] >= re[1][i])
printf("0");
else
printf("1");
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MAX_V = 305;
const int NIL = -1;
class Move {
public:
int x, y, flow;
Move() {}
Move(const int x, const int y, const int flow) {
this->x = x;
this->y = y;
this->flow = flow;
}
};
vector<int> G[MAX_V];
int V, Father[MAX_V], Size[MAX_V], Final[MAX_V];
vector<int> ReqIn;
vector<Move> Solution;
bool HasSolution;
void DFS(const int x, int &source) {
if (Size[x] > Final[x]) {
source = x;
return;
}
for (auto &y : G[x]) {
if (Father[y] != NIL) continue;
Father[y] = x;
DFS(y, source);
if (source != NIL) return;
}
}
inline void Transfer(const int x, const int y, const int flow) {
Solution.push_back(Move(x, y, flow));
Size[x] -= flow;
Size[y] += flow;
}
void PushFlow(const int source, const int sink, const int flow) {
int next = Father[source], add = 0;
if (next == sink) {
Transfer(source, sink, flow);
return;
}
if (Size[next] < flow) {
add = flow - Size[next];
Transfer(source, next, flow - Size[next]);
}
PushFlow(next, sink, flow);
Transfer(source, next, flow - add);
}
void Solve() {
for (auto &x : ReqIn) {
int y;
do {
memset(Father, NIL, sizeof(Father));
Father[x] = x;
y = NIL;
DFS(x, y);
if (y == NIL) break;
int required = min(Final[x] - Size[x], Size[y] - Final[y]);
PushFlow(y, x, required);
} while (Size[x] < Final[x] && y != NIL);
}
HasSolution = true;
for (int x = 1; x <= V; ++x)
if (Size[x] != Final[x]) HasSolution = false;
}
void Read() {
int e, capacity;
cin >> V >> capacity >> e;
for (int x = 1; x <= V; ++x) cin >> Size[x];
for (int x = 1; x <= V; ++x) {
cin >> Final[x];
if (Size[x] < Final[x]) ReqIn.push_back(x);
}
for (; e > 0; --e) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
}
void Print() {
if (!HasSolution) {
cout << "NO\n";
return;
}
cout << Solution.size() << "\n";
for (size_t i = 0; i < Solution.size(); ++i)
cout << Solution[i].x << " " << Solution[i].y << " " << Solution[i].flow
<< "\n";
}
int main() {
Read();
Solve();
Print();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int IINF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const double EPS = 1e-9;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
const int N = 200179;
int n;
long long m, s, d;
long long x[N];
int prv[N];
long long nextJ = 0;
int nextP = -1;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> s >> d;
x[0] = -1;
for (int i = 1; i <= n; ++i) cin >> x[i];
++n;
sort(x, x + n);
for (int i = 0; i < n; ++i) {
if (nextJ < x[i] + 1) {
cout << "IMPOSSIBLE\n";
return 0;
}
prv[i] = nextP;
if (i != n - 1)
if ((x[i + 1] - 1) - (x[i] + 1) >= s) {
nextJ = x[i + 1] - 1 + d;
nextP = i;
}
}
vector<int> ans;
int curr = n - 1;
while (curr != -1) {
ans.push_back(curr);
curr = prv[curr];
}
reverse(ans.begin(), ans.end());
for (int i = 0; i < ((int)((ans).size())) - 1; ++i) {
int co = ans[i];
int no = ans[i + 1];
cout << "RUN " << (x[co + 1] - 1) - (x[co] + 1) << "\n";
cout << "JUMP " << (x[no] + 1) - (x[co + 1] - 1) << "\n";
}
if (x[n - 1] + 1 != m) cout << "RUN " << m - (x[n - 1] + 1) << "\n";
return 0;
}
| 4 |
// D - Widespread
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define roundup(a,b) (((a)+(b)-1)/(b))
int main(){
int N,A,B; cin>>N>>A>>B;
vector<int> H(N); for(int i=0; i<N; ++i) cin>>H[i];
int ans = INT_MAX;
LL ab = (LL)A - B;//additional damage
int L = 0, R = 1e9;
while(L <= R){
int t = (L + R)/2;//mid
LL tb = (LL)t * B;
LL s = 0;
for(int hi:H){
LL h = hi - tb;
if(h > 0) s += roundup(h, ab);
}
if(t >= s){
R = t - 1;//mid-1
ans = t;
}
else L = t + 1;//mid+1
}
cout<< ans <<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using llu = unsigned long long;
ll mod = 1e9 + 7;
ll mode = 998244353;
queue<string> u;
queue<char> q;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t, n, m, i, j, k, k1;
cin >> t;
while (t--) {
cin >> s;
n = s.length();
m = 0;
for (i = 0; i < n; i++) {
rotate(s.begin(), s.begin() + 1, s.end());
string p = s;
for (j = 1; j < n; j++) {
if (abs(s[j] - s[j - 1]) == 1) {
k = j;
while (k < n) {
if (abs(s[k] - s[j - 1]) != 1) {
swap(s[k], s[j]);
break;
}
k++;
}
}
}
for (j = 1; j < n; j++) {
if (abs(s[j] - s[j - 1]) == 1) break;
}
if (j == n) {
cout << s << "\n";
m = 1;
break;
}
s = p;
}
if (m == 0)
cout << "No answer"
<< "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gli() {
long long a;
scanf("%I64d", &a);
return a;
}
int main() {
int n = gi();
int r = n % 3 ? 1 : 0;
n /= 3;
printf("%d\n", r + n * 2);
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
int ma[n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>ma[i][j];
int l[m];
for(int i=0;i<m;i++)
cin>>l[i];
for(int i=0;i<n;i++)
{
int sum=0;
for(int j=0;j<m;j++)
{
sum+=ma[i][j]*l[j];
}
cout<<sum<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = (int)1e9;
const int MAX_N = 100 * 1000 + 1000;
int n, m, total;
char arr[111][111];
bool mark[111][111];
vector<int> qi, qj;
int ai[] = {1, -1, 0, 0};
int bj[] = {0, 0, 1, -1};
int aii[] = {1, -1, 1, -1};
int bjj[] = {1, -1, -1, 1};
int ok(int x) {
memset(mark, 0, sizeof mark);
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (arr[i][j] == '#') break;
}
if (j < m) break;
}
if (j == m) return 0;
int ret = 1;
qi.clear();
qj.clear();
qi.push_back(i);
qj.push_back(j);
mark[i][j] = 1;
for (int head = 0; head < ((int)qi.size()); head++) {
int ii = qi[head];
int jj = qj[head];
for (int k = 0; k < 4; k++) {
int ni = ii + ai[k];
int nj = jj + bj[k];
if (!(ni >= 0 && nj >= 0 && ni < n && nj < m && arr[ni][nj] == '#' &&
mark[ni][nj] == 0))
continue;
qi.push_back(ni);
qj.push_back(nj);
mark[ni][nj] = 1;
ret++;
}
}
return ret < total - x;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
total += (arr[i][j] == '#');
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '.') continue;
arr[i][j] = '.';
if (ok(1)) {
cout << 1 << endl;
return 0;
}
arr[i][j] = '#';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '.') continue;
for (int k = 0; k < 4; k++) {
int ii = i + aii[k];
int jj = j + bjj[k];
if (!(ii >= 0 && jj >= 0 && ii < n && jj < m)) continue;
if (arr[ii][jj] == '.') continue;
arr[i][j] = arr[ii][jj] = '.';
if (ok(2)) {
cout << 2 << endl;
return 0;
}
arr[i][j] = arr[ii][jj] = '#';
}
}
}
cout << -1 << endl;
return 0;
}
| 3 |
#include<iostream>
#include<set>
#include<cmath>
#include<algorithm>
using namespace std;
int main(){
int i,n,t;
cin >> n;
multiset<int, std::greater<int>>a;
for(i=0;i<n;i++){
int t;
cin>>t;
a.insert(t);
}
int ans=0;
while(!a.empty()){
int x=*a.begin();
a.erase(a.begin());
int y=pow(2,(int)log2(x)+1)-x;
auto it=a.find(y);
if(it!=a.end()){
a.erase(it);
ans+=1;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(),(a).end()
int INF=1e9;
int MOD=1000000007;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
double EPS = 1e-10;
const int mod=1e9+7;
int dp[4000][4000];
int main(){
string s,t;
while(cin>>s>>t){
int ans=0;
memset(dp,0,sizeof(dp));
REP(i,s.size()){
REP(j,t.size()){
if(s[i]==t[j]){
if(i==0||j==0)dp[i][j]=1;
else dp[i][j]=dp[i-1][j-1]+1;
}
ans=max(ans,dp[i][j]);
}
}
cout<<ans<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
int res=360;
while(res%t!=0)
res+=360;
cout<<res/t;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
char cc = getchar();
long long cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const long long N = 4e5 + 5;
const long long inf = 1e16;
long long top, n, m, K, a[N], L, R;
struct node {
long long a, b;
} b[N];
long long Ceil(double x) {
long long ans = (long long)x;
return ans + (x > ans);
}
long long Floor(double x) { return (long long)x; }
long long check1(long long x) {
long long ans = 0;
for (register long long i = (1); i <= (m); ++i) ans += Ceil(1.0 * a[i] / x);
return ans <= K;
}
long long check2(long long x) {
long long ans = 0;
for (register long long i = (1); i <= (m); ++i) ans += Floor(1.0 * a[i] / x);
return ans >= K;
}
multiset<long long> S;
multiset<long long>::iterator it;
bool cmp(node x, node y) { return x.a > y.a; }
void solve() {
n = gi(), m = gi(), K = gi();
long long bef = 0, x;
for (register long long i = (1); i <= (m); ++i)
x = gi(), a[i] = x - bef, bef = x;
a[++m] = n - bef, K += m;
long long l = 1, r = n;
L = 1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check2(mid))
L = mid, l = mid + 1;
else
r = mid - 1;
}
l = 1, r = n, R = n;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check1(mid))
R = mid, r = mid - 1;
else
l = mid + 1;
}
if (R <= L) return puts("0"), void();
long long Ans = n;
S.clear(), top = 0, S.insert(R);
for (register long long i = (1); i <= (m); ++i) {
long long ll = Ceil(1.0 * a[i] / R);
long long rr = Floor(1.0 * a[i] / L);
if (ll <= rr) continue;
long long u = a[i] / ll, v = inf;
if (rr) v = Ceil(1.0 * a[i] / rr);
b[++top] = (node){u, v}, S.insert(v);
}
sort(b + 1, b + top + 1, cmp), it = S.end();
--it;
Ans = min(Ans, (*it) - L);
for (long long i = 1; i <= top; ++i) {
S.erase(S.find(b[i].b)), it = S.end(), --it;
Ans = min(Ans, (*it) - b[i].a);
}
printf("%lld\n", Ans);
}
signed main() {
long long T = gi();
while (T--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL a[3][1005];
int main(){
int n, m;
scanf("%d%d", &n, &m);
for(int i=1;i<=n;i++){
scanf("%lld%lld%lld", &a[0][i], &a[1][i], &a[2][i]);
}
LL ans = -1e18;
for(int i=0;i<8;i++){
vector<LL> res;
for(int j=1;j<=n;j++){
LL cost = 0;
for(int k=0;k<3;k++){
if((i>>k)&1) cost += a[k][j];
else cost -= a[k][j];
}
res.push_back(cost);
}
sort(res.begin(), res.end());
reverse(res.begin(), res.end());
LL tmp = 0;
for(int j=0;j<m;j++){
tmp += res[j];
}
ans = max(ans, abs(tmp));
}
printf("%lld\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N; cin >> N;
int a[100];
for(int i=0; i<N; i++){
cin >> a[i];
}
int mincost=10000000;
for(int j=-100; j<=100; j++){
int cost=0;
for(int i=0; i<N; i++){
cost+=(j-a[i])*(j-a[i]);
}
mincost=min(mincost,cost);
}
cout << mincost << endl;
}
| 0 |
#include<iostream>
using namespace std;
int money(int m){
int money=1150;
if(m<=10)return money;
if(m<=20&&m>10)return money+125*(m-10);
if(m<=30&&m>20)return money+10*125+140*(m-20);
if(m>30)return money+10*125+10*140+160*(m-30);
}
int main(){
int w;
while(true){
cin>>w;
if(w==-1)return 0;
cout<<4280-money(w)<<endl;
}
}
| 0 |
#include<iostream>
using namespace std;
int main(void){
int n,m,k;
cin>>n>>m>>k;
for(int i=0;i<=n;i++){
for(int j=0;j<=m;j++){
int l=i*m+j*n-2*i*j;
// cout<<l<<endl;
if(k==l||k==n*m-l){
cout<<"Yes"<<endl;
return 0;
}
}
}
cout<<"No"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 2000000000;
long long INFF = 8000000000000000000LL;
double PI = acos(-1);
inline string IntToString(int a) {
char x[100];
sprintf(x, "%d", a);
string s = x;
return s;
}
inline int StringToInt(string a) {
char x[100];
int res;
strcpy(x, a.c_str());
sscanf(x, "%d", &res);
return res;
}
inline string GetString(void) {
char x[1000005];
scanf("%s", x);
string s = x;
return s;
}
inline bool angka(char a) { return (a >= '0' && a <= '9'); }
inline bool kecil(char a) { return (a >= 'a' && a <= 'z'); }
inline bool besar(char a) { return (a >= 'A' && a <= 'Z'); }
inline string uppercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (kecil(s[i])) s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (besar(s[i])) s[i] = s[i] - 'A' + 'a';
return s;
}
bool pr[1000000 + 5];
int prima[1000000 + 5];
void GeneratePrime(int a) {
memset(pr, 1, sizeof(pr));
pr[0] = pr[1] = 0;
int ix = 0;
for (int(i) = (2); (i) <= (a); (i)++)
if (pr[i]) {
prima[++ix] = i;
int b = i * 2;
while (b <= a) {
pr[b] = 0;
b += i;
}
}
}
string s;
int k, n = 0;
int main() {
GeneratePrime(1000000);
cin >> k;
for (int(i) = (1); (i) <= (INF); (i)++) {
int cek = i;
s = IntToString(cek);
reverse(s.begin(), s.end());
cek = StringToInt(s);
if (cek != i && pr[cek] && pr[i]) n++;
if (n == k) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
vector<pair<int, int> > adj[MAXN];
int n;
bool mark[MAXN];
int p[MAXN];
int curv;
void dfs(int v, int ind = -1) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
pair<int, int> u = adj[v][i];
if (!mark[u.first]) {
dfs(u.first, u.second);
} else if (u.second != ind) {
curv = u.first;
}
}
}
int main() {
cin >> n;
int x;
int d = -1;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x == i) {
d = i;
}
p[i] = x;
adj[i].push_back({x, i});
adj[x].push_back({i, i});
}
int cnt = 0;
vector<int> ve;
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
dfs(i);
cnt++;
ve.push_back(curv);
}
}
if (d != -1) {
cout << cnt - 1 << '\n';
for (int i = 0; i < ve.size(); i++) {
p[ve[i]] = d;
}
for (int i = 1; i <= n; i++) {
cout << p[i] << ' ';
}
return 0;
}
cout << cnt << '\n';
for (int i = 0; i < ve.size(); i++) {
p[ve[i]] = ve[0];
}
for (int i = 1; i <= n; i++) {
cout << p[i] << ' ';
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
string s1="";
string s2="";
int sum=0;
for(int i=0;i<s.length();i++){
s1=s[i]+s1;
if(s1!=s2){
sum++;
s2=s1;
s1="";
}
}
cout<<sum;
}
| 0 |
//Bokan ga bokka--nn!!
//Daily Lunch Special Tanoshii !!
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 2000000000
vector<P>edge[3005];
ll nearest[3005];
ll d[3005];
int n,m,k;
void dijkstra(int k)
{
fill(d,d+3005,1e12);
d[k]=0LL;
priority_queue<P,vector<P>,greater<P> >que;
que.push(mp(d[k],k));
while(!que.empty())
{
P p=que.top(); que.pop();
if(d[p.second]!=p.first) continue;
for(int i=0;i<edge[p.second].size();i++)
{
if(d[edge[p.second][i].first]>d[p.second]+edge[p.second][i].second)
{
d[edge[p.second][i].first]=d[p.second]+edge[p.second][i].second;
que.push(mp(d[edge[p.second][i].first],edge[p.second][i].first));
}
}
}
for(int i=1;i<=n;i++)
{
nearest[i]=min(nearest[i],d[i]);
}
}
int main(){
scanf("%d %d %d",&n,&m,&k);
for(int i=0;i<m;i++)
{
ll a,b,c; scanf("%lld %lld %lld",&a,&b,&c);
edge[a].pb(mp(b,2*c));
edge[b].pb(mp(a,2*c));
}
fill(nearest,nearest+3005,1e12);
for(int i=0;i<k;i++)
{
int point;
scanf("%d",&point);
dijkstra(point);
}
ll ret=0;
for(int i=1;i<=n;i++)
{
for(int j=0;j<edge[i].size();j++)
{
ret=max(ret,(nearest[i]+nearest[edge[i][j].first]+edge[i][j].second)/2);
}
}
printf("%lld\n",(ret+1)/2);
}
| 0 |
#include <bits/stdc++.h>
#define endl '\n'
#define SZ(x) ((int)x.size())
#define ALL(V) V.begin(), V.end()
#define L_B lower_bound
#define U_B upper_bound
#define pb push_back
using namespace std;
template<class T, class T1> int chkmin(T &x, const T1 &y) { return x > y ? x = y, 1 : 0; }
template<class T, class T1> int chkmax(T &x, const T1 &y) { return x < y ? x = y, 1 : 0; }
const int MAXN = (1 << 20);
string t;
struct node
{
int sum, lazy;
node() {sum = 0; lazy = -1;}
node(int val)
{
sum = val;
lazy = -1;
}
};
node temp, broken;
node merge(node l, node r)
{
temp.sum = l.sum + r.sum;
temp.lazy = -1;
return temp;
}
struct segment_tree
{
node tr[4 * MAXN];
void push(int l, int r, int idx)
{
if(tr[idx].lazy != -1)
{
tr[idx].sum = (r - l + 1) * tr[idx].lazy;
if(l != r)
{
tr[2 * idx + 1].lazy = tr[idx].lazy;
tr[2 * idx + 2].lazy = tr[idx].lazy;
}
tr[idx].lazy = -1;
}
}
void init(int l, int r, int idx)
{
if(l == r)
{
tr[idx] = node(t[l] - '0');
return;
}
int mid = (l + r) >> 1;
init(l, mid, 2 * idx + 1);
init(mid + 1, r, 2 * idx + 2);
tr[idx] = merge(tr[2 * idx + 1], tr[2 * idx + 2]);
}
void update(int qL, int qR, int val, int l, int r, int idx)
{
push(l, r, idx);
if(qL > r || l > qR)
return;
if(qL <= l && r <= qR)
{
tr[idx].lazy = val;
push(l, r, idx);
return;
}
int mid = (l + r) >> 1;
update(qL, qR, val, l, mid, 2 * idx + 1);
update(qL, qR, val, mid + 1, r, 2 * idx + 2);
tr[idx] = merge(tr[2 * idx + 1], tr[2 * idx + 2]);
}
node query(int qL, int qR, int l, int r, int idx)
{
push(l, r, idx);
if(l > qR || r < qL)
return broken;
if(qL <= l && r <= qR)
return tr[idx];
int mid = (l + r) >> 1;
return merge(query(qL, qR, l, mid, 2 * idx + 1), query(qL, qR, mid + 1, r, 2 * idx + 2));
}
} tr;
int n, q;
string s;
pair<int, int> que[MAXN];
void read() {
cin >> n >> q;
cin >> s >> t;
for(int i = 0; i < q; i++) {
cin >> que[i].first >> que[i].second;
que[i].first--;
que[i].second--;
}
}
void solve() {
tr.init(0, n - 1, 0);
for(int i = q - 1; i >= 0; i--) {
int l = que[i].first, r = que[i].second, cnt = r - l + 1;
auto nd = tr.query(l, r, 0, n - 1, 0);
int cnt1 = nd.sum;
int cnt0 = cnt - cnt1;
if(cnt1 <= (cnt - 1) / 2) {
tr.update(l, r, 0, 0, n - 1, 0);
} else if(cnt0 <= (cnt - 1) / 2) {
tr.update(l, r, 1, 0, n - 1, 0);
} else {
cout << "NO" << endl;
return;
}
}
for(int i = 0; i < n; i++) {
if(s[i] - '0' != tr.query(i, i, 0, n - 1, 0).sum) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while(T--) {
read();
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 7;
int save[2][N][N];
int dp[N][N];
int n, res;
int c[2 * N], t[2 * N];
int sen[2][N];
int main() {
cin >> n;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = 100000000 + 7;
dp[0][0] = 0;
for (int i = 1; i <= 2 * n; i++) {
char cc;
cin >> cc;
if (cc == 'B')
c[i] = 1;
cin >> t[i];
}
for (int i = 1; i <= 2 * n; i++)
for (int j = i + 1; j <= 2 * n; j++)
if (c[i] == c[j] && t[i] > t[j])
res++;
for (int i = 1; i <= 2 * n; i++) {
for (int j = n; j >= 0; j--) {
save[c[i]][t[i]][j] = save[c[i]][t[i]][j + 1];
if (sen[1 - c[i]][j + 1])
save[c[i]][t[i]][j]++;
}
sen[c[i]][t[i]] = 1;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + save[0][i + 1][j]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + save[1][j + 1][i]);
}
cout << dp[n][n] + res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
vector<int> v[5002];
int w[5002];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) w[i] = INT_MAX;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
w[a] = min(w[a], (b + n - a) % n);
}
for (int i = 0; i < n; i++) {
int cap = 0;
for (int j = 0; j < n; j++) {
cap = max(cap, (int)(v[j].size()));
}
int tim = n * (cap - 1);
int maxi = 0;
for (int j = 0; j < n; j++) {
if (w[j] == INT_MAX) continue;
if (v[j].size() == cap) {
maxi = max(maxi, w[j] + (j + n - i) % n);
} else {
if (v[j].size() == cap - 1) {
maxi = max(maxi, w[j] + (j + n - i) % n - n);
}
}
}
tim += maxi;
if (i) printf(" ");
printf("%d", tim);
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int sg[105], a[105];
int f[1005][4], sum[3];
int mex(int x, int y) {
if (x && y) return 0;
if (x + y - 1) return 1;
return 2;
}
int C(int l, int r) { return (long long)(l + r) * (r - l + 1) / 2 % mod; }
int main() {
int tot = 1, l = 1, r = 1, n, p;
a[1] = 2;
scanf("%d%d", &n, &p);
for (int l = 1, r = 1; a[tot] < p;) {
int ll = (a[l] + 1) * 3 - 1;
int rr = a[r] / 2 * 3 + (a[r] & 1);
sg[++tot] = mex(sg[l], sg[r]);
tot -= sg[tot] == sg[tot - 1];
a[tot] = min(rr, ll);
l += ll == a[tot];
r += rr == a[tot];
}
a[tot] = p;
for (int i = 1; i <= tot; ++i)
sum[sg[i]] = (sum[sg[i]] + C(p - a[i], p - a[i - 1] - 1)) % mod;
f[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 4; ++j)
for (int k = 0; k < 3; ++k)
f[i][j] = ((long long)f[i - 1][j ^ k] * sum[k] + f[i][j]) % mod;
printf("%d\n", ((long long)f[n][1] + f[n][2] + f[n][3]) % mod);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
double highest = (ceil((double)n / (double)2));
int lower = -1000;
for (int i = lower; i <= 1000; i++) {
if (i == 0) continue;
int cnt = 0;
for (int j = 0; j < n; j++) {
double value = ((double)a[j] / (double)i);
if (value > 0) {
cnt++;
}
if (cnt >= highest) {
cout << i << "\n";
return 0;
}
}
}
cout << 0 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long int binomialCoeff(int n, int k) {
long long int res = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
int divisor(int num) {
int div = 0;
for (int i = 1; i <= num; i++) {
if (num % i == 0) div++;
}
return div;
}
int sub(long long int a, long long int b) {
if (a >= b)
return a - b;
else
return b - a;
}
int main() {
int n;
cin >> n;
cout << n << " ";
for (int i = 1; i < n; i++) {
cout << i << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2e5 + 42;
int n, arr[nmax];
pair<int, int> sparse[20][nmax];
int lg[nmax];
void build() {
for (int i = 1; i <= n; i++) sparse[0][i] = {arr[i], i};
for (int sz = 1; (1 << sz) <= n; sz++)
for (int j = 1; j + (1 << sz) - 1 <= n; j++) {
sparse[sz][j] =
max(sparse[sz - 1][j], sparse[sz - 1][j + (1 << (sz - 1))]);
}
for (int j = 2; j <= n; j++) lg[j] = lg[j / 2] + 1;
}
pair<int, int> query(int l, int r) {
if (l > r) swap(l, r);
if (l == r) return {arr[l], l};
int st = lg[r - l + 1];
return max(sparse[st][l], sparse[st][r - (1 << st) + 1]);
}
int where[nmax];
long long solve(int l, int r) {
if (r - l + 1 <= 2) return 0;
int av = query(l, r).second;
long long ret = solve(l, av - 1) + solve(av + 1, r);
int lq, rq;
int where_l, where_r;
if (av <= (l + r) / 2) {
lq = l;
rq = av - 1;
where_l = av + 1;
where_r = r;
} else {
lq = av + 1;
rq = r;
where_l = l;
where_r = av - 1;
}
for (int i = lq; i <= rq; i++) {
int aim = arr[av] - arr[i];
if (aim <= 0) continue;
if (where_l <= where[aim] && where[aim] <= where_r &&
query(i, where[aim]).second == av)
ret++;
}
return ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) where[arr[i]] = i;
build();
cout << solve(1, n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[400][400];
bool a[27];
int nx[27];
int main() {
int n;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
gets(s[i]);
for (int j = 0; j < n; j++) a[s[i][j] - 'a'] = true, nx[s[i][j] - 'a']++;
}
int sm = 0;
for (int i = 0; i < 26; i++) sm += a[i];
if (sm != 2) {
puts("NO");
return 0;
}
for (int i = 0; i < n; i++)
if (s[i][i] != s[0][0] || s[i][n - i - 1] != s[0][0]) {
puts("NO");
return 0;
}
if (nx[s[0][0] - 'a'] != 2 * n - 1) {
puts("NO");
return 0;
}
puts("YES");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
multiset<int> st;
int n, a, b, x, z;
double sum;
cin >> n >> a >> b >> x;
sum = x;
for (int i = 0; i < n - 1; i++) {
cin >> z;
sum += z;
st.insert(z);
}
int cnt = 0;
while ((x * a) / sum < b) {
sum -= *st.rbegin();
st.erase(st.find(*st.rbegin()));
cnt++;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3001;
int a[N], id[N], dp[N][N];
vector<int> pos[N];
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; ++i) pos[i].clear();
for (int i = 1; i <= n; ++i) {
cin >> a[i];
id[i] = pos[a[i]].size();
pos[a[i]].push_back(i);
}
for (int i = n; i > 0; --i) {
dp[i][i] = 0;
for (int j = i + 1; j <= n; ++j) {
if (a[i] == a[i + 1]) {
dp[i][j] = dp[i + 1][j];
continue;
}
dp[i][j] = dp[i + 1][j];
for (int p = id[i] + 1, k;
p < pos[a[i]].size() && (k = pos[a[i]][p]) <= j; ++p) {
dp[i][j] = min(dp[i][j], dp[i + 1][k - 1] + dp[k][j]);
}
++dp[i][j];
}
}
cout << dp[1][n] << endl;
}
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){int n;cin>>n;cout<<n*(n+1)/2<<endl;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long n, k, m;
long long a[1111][11];
long long dp[1111][111];
int main(void) {
cin >> n >> k >> m;
for (long long i = 0; i < (long long)(10); i++) {
a[0][i] = i % k;
}
for (long long i = 0; i < (long long)(n); i++) {
for (long long j = 0; j < (long long)(10); j++) {
a[i + 1][j] = (10 * a[i][j]) % k;
}
}
for (long long i = 1; i < 10; i++) {
long long idx = i % k;
dp[1][idx] = (dp[1][idx] + 1) % m;
}
for (long long i = 2; i <= n; i++) {
dp[i][0] = (9 * dp[i - 1][0]) % m;
for (long long j = 1; j < k; j++) {
for (long long l = 1; l < 10; l++) {
long long idx = (a[i - 1][l] + j) % k;
dp[i][idx] = (dp[i][idx] + dp[i - 1][j]) % m;
}
}
for (long long l = 1; l < 10; l++) {
long long idx = a[i - 1][l];
dp[i][idx] = (dp[i][idx] + 1) % m;
}
if (i != n) {
for (long long j = 0; j < (long long)(k); j++) {
dp[i][j] = (dp[i][j] + dp[i - 1][j]) % m;
}
}
}
cout << dp[n][0] << '\n';
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
int cnt=0;
for(int a=1; a<n; a++){
cnt += (n-1)/a;
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mm = 2e5 + 20;
const long long mol = 998244353;
const long long inf = 1e13;
long long m, n, inp;
bool tr[40];
void bs() {
long long l = 1, r = m + 1, i = 0;
while (r - l > 1) {
long long mid = (l + r) / 2;
cout << mid << endl;
cin >> inp;
if (inp == 0)
return;
else if (inp == -1 && tr[i])
r = mid;
else if (inp == -1 && !tr[i])
l = mid;
else if (inp == 1 && tr[i])
l = mid;
else if (inp == 1 && !tr[i])
r = mid;
i++;
if (i == n) i = 0;
}
}
int main() {
cin >> m >> n;
for (int i = 0; i < n; i++) {
cout << 1 << endl;
cin >> inp;
if (inp == 1)
tr[i] = 1;
else if (inp == -1)
tr[i] = 0;
else
return 0;
}
bs();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e2 + 10, mod = 1e9 + 9;
long long n, m, comp, mark[N], par[N], root[N], dp[N][N], com_dp[N][N],
knap[N][N], fac[N], pwfac[N];
set<long long> mat[N];
vector<long long> good, bad, adj[N], comps[N];
long long pw(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return res;
}
void pre_proc() {
fac[0] = 1;
for (long long i = 1; i < N; i++) fac[i] = (fac[i - 1] * i) % mod;
for (long long i = 0; i < N; i++) pwfac[i] = pw(fac[i], mod - 2);
}
long long C(long long a, long long b) {
return (((fac[b] * pwfac[a]) % mod) * pwfac[b - a]) % mod;
}
void dfs(long long v) {
long long p = *mat[v].begin();
mark[v] = 0;
par[v] = p;
adj[p].push_back(v);
adj[v].push_back(p);
mat[v].clear();
mat[p].erase(v);
if (mat[p].size() == 1)
dfs(p);
else if (!mat[p].size())
par[p] = p, mark[p] = 0;
}
void _dfs(long long v, long long c) {
comps[c].push_back(v);
if (par[v] == v) {
bad.push_back(c);
root[c] = v;
} else if (mat[par[v]].size()) {
par[par[v]] = par[v];
root[c] = v;
good.push_back(c);
}
mark[v] = c;
for (long long i : adj[v])
if (!mark[i]) _dfs(i, c);
}
void make_comp() {
for (long long i = 0; i < n; i++)
if (!mat[i].size()) {
mark[i] = ++comp;
par[i] = i;
bad.push_back(comp);
root[comp] = i;
comps[comp].push_back(comp);
}
for (long long i = 0; i < n; i++)
if (mat[i].size() == 1) dfs(i);
for (long long i = 0; i < n; i++)
if (!mark[i]) _dfs(i, ++comp);
}
void make_par(long long v, long long p) {
par[v] = p;
for (long long i : adj[v])
if (i != p) make_par(i, v);
}
long long solve(long long v, bool b) {
if (b) make_par(v, v);
long long sub = 1;
dp[v][0] = 1;
if (adj[v].size() == 1 && adj[v][0] == par[v]) {
dp[v][1] = 1;
return 1;
}
for (long long i : adj[v])
if (i != par[v]) sub += solve(i, 0);
long long tmp[N][N];
memset(tmp, 0, sizeof tmp);
if (adj[v][0] == par[v]) swap(adj[v][0], adj[v][1]);
tmp[0][0] = 1;
for (long long i = 1; i < N; i++) tmp[0][i] = dp[adj[v][0]][i];
for (long long i = 1; i < adj[v].size(); i++) {
if (adj[v][i] == par[v]) {
for (long long j = 0; j < N; j++) tmp[i][j] = tmp[i - 1][j];
continue;
}
tmp[i][0] = 1;
for (long long j = 1; j < N; j++)
for (long long k = 0; k <= j; k++)
tmp[i][j] = (tmp[i][j] +
((tmp[i - 1][j - k] * dp[adj[v][i]][k]) % mod) * C(k, j)) %
mod;
}
dp[v][0] = 1;
for (long long j = 1; j < N; j++) dp[v][j] = tmp[adj[v].size() - 1][j];
dp[v][sub] = dp[v][sub - 1];
return sub;
}
int32_t main() {
pre_proc();
memset(mark, -1, sizeof mark);
memset(par, -1, sizeof par);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
mat[v].insert(u);
mat[u].insert(v);
}
make_comp();
for (long long i : good) {
if (comps[i].size() == 1) {
com_dp[i][0] = com_dp[i][1] = 1;
continue;
}
solve(root[i], 0);
for (long long j = 0; j < N; j++) com_dp[i][j] = dp[root[i]][j];
}
for (long long i : bad) {
if (comps[i].size() == 1) {
com_dp[i][0] = com_dp[i][1] = 1;
continue;
}
for (long long j : comps[i]) {
memset(dp, 0, sizeof dp);
solve(j, 1);
for (long long k = 0; k < N; k++)
com_dp[i][k] = (com_dp[i][k] + dp[j][k]) % mod;
}
for (long long j = 0; j < N; j++)
com_dp[i][j] = (com_dp[i][j] *
pw(max(1LL, (long long)comps[i].size() - j), mod - 2)) %
mod;
}
if (!comp) {
cout << 1 << '\n';
for (long long i = 1; i <= n; i++) cout << 0 << '\n';
return 0;
}
knap[1][0] = 1;
for (long long j = 1; j < N; j++) knap[1][j] = com_dp[1][j];
for (long long i = 2; i <= comp; i++) {
knap[i][0] = 1;
for (long long j = 1; j < N; j++)
for (long long k = 0; k <= j; k++)
knap[i][j] = (knap[i][j] +
((knap[i - 1][j - k] * com_dp[i][k]) % mod) * C(k, j)) %
mod;
}
for (long long i = 0; i <= n; i++) cout << knap[comp][i] << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char t[10];
while (scanf("%s", t) != EOF) {
int h = (t[0] - '0') * 10 + t[1] - '0';
h = h % 12;
int m = (t[3] - '0') * 10 + t[4] - '0';
printf("%.2lf %.2lf\n", h * 360.0 / 12.0 + m * 360.0 / (12.0 * 60),
m * 360.0 / 60.0);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a, b, cnt = 0;
cin >> n >> x >> a >> b;
cnt = (a - 1) / x;
while (--n) {
cin >> a;
cnt += (a - b - 1) / x;
cin >> b;
}
cout << b - x * cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(n, 0);
for (long long i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
vector<long long> dp(n, 0);
dp[0] = k + 1;
for (long long i = 0; i < n; i++) {
dp[i] = 2 * k + 1;
if (i >= n - k) dp[i] -= 1 + i + k - n;
if (i < k) dp[i] -= k - i;
if (a[i] != -1) {
dp[i] +=
dp[a[i]] - max(min(n - a[i] - 1, k) + min(i, k) + a[i] - i + 1, 0ll);
}
}
for (auto v : dp) cout << v << ' ';
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int dx2[] = {1, -1, -1, 1, 0, 0, -1, 1};
int dy2[] = {1, -1, 1, -1, 1, -1, 0, 0};
int kmx[] = {-1, -1, 1, 1, 2, -2, 2, -2};
int kmy[] = {2, -2, 2, -2, -1, -1, 1, 1};
int bishopX[] = {-1, 1, -1, 1};
int bishopY[] = {-1, -1, 1, 1};
class Timer {
public:
clock_t T;
Timer() { T = clock(); }
~Timer() {
fprintf(stderr, "\n%.3f\n", double(clock() - T) / CLOCKS_PER_SEC);
}
};
int read() {
int x;
scanf("%d", &x);
return x;
}
long long readL() {
long long x;
scanf("%lld", &x);
return x;
}
const int N = 1005;
char s[N];
int n;
vector<int> primes;
int p[N], sz[N], cnt[26], col[N];
bitset<N> ip;
int find(int i) { return i == p[i] ? i : p[i] = find(p[i]); }
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) p[i] = i, sz[i] = 1, cnt[s[i] - 'a']++;
ip.set();
ip[0] = ip[1] = 0;
for (int i = 2; i <= n; i++) {
if (ip[i]) {
primes.push_back(i);
for (int j = i * i; j <= n; j += i) ip[j] = 0;
}
}
for (int i = 0; i < primes.size(); i++) {
int u = primes[i] - 1;
for (int j = 1; j <= n / primes[i]; j++) {
int v = primes[i] * j;
v--;
int a = find(u);
int b = find(v);
if (a != b) {
p[a] = b;
sz[b] += sz[a];
}
}
}
memset(col, -1, sizeof col);
for (int i = 0; i < n; i++) {
int a = find(i);
if (col[a] == -1) {
int l = sz[a];
int mn = 1000000000;
int c = -1;
for (int j = 0; j < 26; j++) {
int d = cnt[j] - l;
if (d >= 0) {
if (d < mn) {
mn = d;
c = j;
}
}
}
if (c == -1) {
printf("NO\n");
return 0;
}
col[a] = c;
cnt[c] -= l;
}
s[i] = char(col[a] + 'a');
}
printf("YES\n");
printf("%s\n", s);
return 0;
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
int main() {
int N;
long long INF = 1000000000000000000;
cin >> N;
vector<long long> A(N);
vector<pair<long long, int> > VP(N);
for (int i = 0; i < N; i++) cin >> A[i], VP[i] = { A[i], i };
sort(VP.begin(), VP.end(), greater<pair<long long, int> >());
vector<vector<long long> > DP(N + 1, vector<long long>(N + 1, -INF));
DP[0][N] = 0;
for (int i = 0; i < N; i++) {
for (int L = 0; L <= i; L++) {
int R = N - i + L;
DP[L + 1][R] = max(DP[L + 1][R], DP[L][R] + VP[i].first * abs(VP[i].second - L));
DP[L][R - 1] = max(DP[L][R - 1], DP[L][R] + VP[i].first * abs(VP[i].second - (R - 1)));
}
}
long long ANS = -INF;
for (int i = 0; i <= N; i++) ANS = max(ANS, DP[i][i]);
cout << ANS << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int inf = 100, N = 100005, M = 256;
int ans, tong[9][M], n, vis[9], d[N], alb[9][9], f[N][9], zt[N];
char ch[N];
long long tot;
vector<int> v[9];
void bfs(int id) {
queue<int> q;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (ch[i] == id) {
d[i] = 0;
q.push(i);
} else
d[i] = inf;
}
while (q.size()) {
int t = q.front();
q.pop();
if (!vis[ch[t]]) {
vis[ch[t]] = 1;
for (auto j : v[ch[t]])
if (d[j] == inf) {
d[j] = d[t] + 1;
q.push(j);
}
}
if (t > 1 && d[t - 1] == inf) {
d[t - 1] = d[t] + 1;
q.push(t - 1);
}
if (t < n && d[t + 1] == inf) {
d[t + 1] = d[t] + 1;
q.push(t + 1);
}
}
for (int i = 1; i <= n; i++) f[i][id] = d[i];
}
inline int get(int x, int y) {
int mn = inf;
for (int i = 0; i < 8; i++) mn = min(mn, f[x][i] + f[y][i] + 1);
return min(mn, abs(x - y));
}
int main() {
n = read();
scanf("%s", ch + 1);
for (int i = 1; i <= n; i++) {
ch[i] -= 'a';
v[ch[i]].push_back(i);
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) alb[i][j] = inf;
bfs(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 8; j++) {
alb[ch[i]][j] = min(alb[ch[i]][j], f[i][j]);
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < 8; j++)
if (f[i][j] > alb[ch[i]][j]) zt[i] |= 1 << j;
for (int i = 1; i <= n; i++) {
int t = max(i - 15, 1);
for (int j = i - 1; j >= t; j--) {
int t = get(i, j);
if (t > ans) {
ans = t;
tot = 1;
} else if (t == ans)
tot++;
}
if (i <= 16) continue;
tong[ch[i - 16]][zt[i - 16]]++;
for (int o = 0; o < 8; o++)
for (int j = 0; j < M; j++)
if (tong[o][j]) {
int mn = inf;
for (int k = 0; k < 8; k++)
mn = min(alb[o][k] + (j >> k & 1) + f[i][k] + 1, mn);
if (mn > ans) {
ans = mn;
tot = tong[o][j];
} else if (mn == ans)
tot += tong[o][j];
}
}
cout << ans << " " << tot << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename P, typename Q>
ostream& operator<<(ostream& os, pair<P, Q> p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
int main(int argc, char* argv[]) {
int n, k;
while (scanf("%d%d", &n, &k) == 2) {
vector<int> v;
for (int i = 0; i < n; ++i) {
int m;
scanf("%d", &m);
v.push_back(m);
}
long long int sum = 0;
for (int i = 0; i < n; ++i) {
long long int s = sum + i + 1;
if (k <= s) {
printf("%d\n", v[k - sum - 1]);
break;
}
sum = s;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpowmod(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long c = binpowmod(a, b >> 1, mod);
return (((c * c) % mod) * (b & 1 ? a : 1)) % mod;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
return c * c * (b & 1 ? a : 1);
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
return countbit(int(x & INT_MAX)) + countbit(int(x >> 32) & INT_MAX);
}
inline void printbit(int x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st = v;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const queue<A> &v) {
queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const deque<A> &v) {
deque<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop_front();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
do {
run();
if (0) {
0 ? printf("-------------------------------\n") : 0;
0 ? printf("-------------------------------\n") : 0;
}
} while (0);
return 0;
}
long long sqrtl(long long x) {
long long ret = sqrt(x);
if (ret * ret == x)
return ret;
else
return -1;
}
bool check(long long x1, long long y1, long long x2, long long y2, long long x3,
long long y3) {
return (x1 != x2 && x1 != x3 && x2 != x3 && y1 != y2 && y1 != y3 && y2 != y3);
}
void run() {
int a, b;
scanf("%lld%lld", &a, &b);
for (long long i = 1; i < a; i++) {
long long k = sqrtl(a * a - i * i);
if (k != -1) {
long long d = i * i + k * k - a * a;
long long D =
binpow(4ll * d * k, 2) -
4ll * (4 * i * i + 4ll * k * k) * (1ll * d * d - 4ll * i * i * b * b);
long long sqD = sqrtl(D);
if (sqD == -1 || (-4 * d * k + sqD) % (8 * i * i + 8 * k * k) != 0)
continue;
long long y = (-4 * d * k + sqD) / (8 * i * i + 8 * k * k);
if ((d - 2 * k * y) % (2 * i) != 0) continue;
long long x = (d - 2 * k * y) / (2 * i);
if (check(0, 0, i, k, x, y)) {
printf("YES\n0 0\n");
printf("%lld", i);
putchar(' ');
printf("%lld", k);
putchar('\n');
printf("%lld", x);
putchar(' ');
printf("%lld", y);
putchar('\n');
return;
}
}
}
printf("NO\n");
}
| 3 |
#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
#define maxn 300005
#define lc now<<1
#define rc lc|1
using namespace std;
int w,h,n,x[maxn],y[maxn],num[maxn],up[maxn],dn[maxn],c[maxn],z[maxn];
inline bool cmp(const int &a,const int &b){ return x[a]<x[b]; }
int Max[maxn*10],lazy[maxn*10];
inline void dt(int now)
{ if(lazy[now]){ Max[now]+=lazy[now],lazy[lc]+=lazy[now],lazy[rc]+=lazy[now],lazy[now]=0; } }
inline void upd(int now){ Max[now]=max(Max[lc],Max[rc]); }
void Add(int now,int l,int r,int ql,int qr,int val)
{
dt(now);
if(qr<l || ql>r) return;
if(ql<=l && r<=qr){ lazy[now]+=val,dt(now);return; }
int mid=(l+r)>>1;
Add(lc,l,mid,ql,qr,val),Add(rc,mid+1,r,ql,qr,val);
upd(now);
}
int Query(int now,int l,int r,int ql,int qr)
{
dt(now);
if(qr<l || ql>r) return -0x3f3f3f3f;
if(ql<=l && r<=qr) return Max[now];
int mid=(l+r)>>1;
int tmp=max(Query(lc,l,mid,ql,qr) , Query(rc,mid+1,r,ql,qr));
upd(now);
return tmp;
}
int ans=0,Q[2][maxn],tp[2];
void solve()
{
tp[0]=tp[1]=0;
memset(Max,0,sizeof Max);
memset(lazy ,0 ,sizeof lazy);
sort(c+1,c+1+n,cmp);
num[0]=0;
for(int i=1;i<=n;i++) if(i==1 || x[c[i-1]] != x[c[i]]) num[++num[0]] = x[c[i]];
for(int i=1;i<=num[0];i++) up[i] = h , dn[i] = 0;
int loc = h/2;
for(int i=1;i<=n;i++)
{
x[c[i]] = lower_bound(num+1,num+1+num[0],x[c[i]]) - num;
if(y[c[i]] >= loc) up[x[c[i]]] = min(up[x[c[i]]] , y[c[i]]);
if(y[c[i]] <= loc) dn[x[c[i]]] = max(dn[x[c[i]]] , y[c[i]]);
}
for(int i=1;i<=num[0];i++)
{
ans=max(ans,Query(1,1,num[0],1,i-1) - (w - num[i]));
if(i) Add(1,1,num[0],i-1,i-1,max(up[i-1],up[i])-min(dn[i-1],dn[i])-h);
for(;tp[0] && up[Q[0][tp[0]-1]]>up[i];tp[0]--)
Add(1,1,num[0],Q[0][tp[0]-2],i-1,max(up[i],up[Q[0][tp[0]-2]]) - up[Q[0][tp[0]-1]]);
Q[0][tp[0]++] = i;
for(;tp[1] && dn[Q[1][tp[1]-1]]<dn[i];tp[1]--)
Add(1,1,num[0],Q[1][tp[1]-2],i-1,dn[Q[1][tp[1]-1]] - min(dn[i],dn[Q[1][tp[1]-2]]));
Q[1][tp[1]++] = i;
Add(1,1,num[0],i,i,h+w-num[i]);
}
}
int main()
{
scanf("%d%d%d",&w,&h,&n);
for(int i=1;i<=n;i++) scanf("%d%d",&x[i],&y[i]),c[i]=i;
x[n+1] = 0 , y[n+1] = h/2 , c[n+1] = n+1;
x[n+2] = w , y[n+2] = h/2 , c[n+2] = n+2;
x[n+3] = w/2 , y[n+3] = 0 , c[n+3] = n+3;
x[n+4] = w/2 , y[n+4] = h , c[n+4] = n+4;
n+=4;
memcpy(z,x,sizeof x);
solve();
swap(w,h);
memcpy(x,z,sizeof z);
for(int i=1;i<=n;i++) swap(x[i],y[i]);
solve();
printf("%d\n",ans*2);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans = 1;
vector<int> v[10010];
pair<int, int> p[10010];
bool vis[10010];
int dfs(int a) {
int t = 0;
vis[a] = 1;
for (int i = 0; i < v[a].size(); i++) {
if (!vis[v[a][i]]) t += dfs(v[a][i]) + 1;
}
return t;
}
int main() {
int a, b;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
p[i].first = a, p[i].second = b;
v[a].push_back(b), v[b].push_back(a);
}
for (int i = 1; i <= m; i++) {
if (!vis[p[i].first]) ans = ans * pow(2, dfs(p[i].first));
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<string, int> M, N;
pair<string, int> A[1007];
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> A[i].first >> A[i].second;
M[A[i].first] += A[i].second;
}
for (map<string, int>::iterator it = M.begin(); it != M.end(); it++)
if ((*it).second >= mx) mx = (*it).second;
for (int i = 0; i < n; i++) {
N[A[i].first] += A[i].second;
if (N[A[i].first] >= mx and M[A[i].first] == mx) {
cout << A[i].first << endl;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp, mm;
bool comp(int a, int b) { return mm[a] < mm[b]; }
int main() {
int n;
cin >> n;
int ans = 1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
mp[x]++;
set<int> s;
for (int j = 1; j <= 10; j++) {
if (mp[j]) {
mp[j]--;
for (int k = 1; k <= 10; k++) {
if (mp[k]) s.insert(mp[k]);
}
if (s.size() <= 1) {
ans = i + 1;
mp[j]++;
break;
} else
mp[j]++;
s.clear();
}
}
s.clear();
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int main() {
vector<long long> v1, v2;
long long n, a, b, arr[N];
cin >> n >> a >> b;
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (long long i = 0; i < b; i++) v1.push_back(arr[i]);
for (long long i = b; i < n; i++) v2.push_back(arr[i]);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
cout << v2[0] - v1[v1.size() - 1];
return 0;
}
| 1 |
#include <cstdio>
bool w[6666] = { true }, s[6666] = { true };
int main(void)
{
double max = -1.0;
int a, b, c, d, e, f, i, j, ansa = 0, ansb = 0;
scanf("%d %d %d %d %d %d" ,&a, &b, &c, &d, &e, &f);
a *= 100, b *= 100;
for (i = 0; i <= f; i++)
{
if (w[i])
{
w[i + a] = true;
w[i + b] = true;
}
if (s[i])
{
s[i + c] = true;
s[i + d] = true;
}
}
for (i = 100; i <= f; i += 100)
{
if (!w[i])
continue;
for (j = 0; j <= f - i; j++)
{
if (!s[j])
continue;
if (j * 100 <= e * i)
{
double t = (double)j / (i + j);
if (max < t)
{
max = t;
ansa = i + j;
ansb = j;
}
}
else
break;
}
}
printf("%d %d" ,ansa, ansb);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
char str1[MAXN], str2[MAXN];
int n1, n2;
int main() {
int i, j, n;
bool flag = true;
scanf("%d %d", &n1, &n2);
n = max(n1, n2);
scanf("%s%s", str1, str2);
for (i = 0; i < n; i++) {
if (str1[i] == '*') {
break;
}
if (str1[i] != str2[i] || i >= n1 || i >= n2) {
flag = false;
break;
}
}
if (flag && i != n)
for (j = 1; j <= n; j++) {
if (str1[n1 - j] == '*') {
break;
}
if (str1[n1 - j] != str2[n2 - j] || n2 - j < i || j > n1 || j > n2) {
flag = false;
break;
}
}
printf("%s\n", flag ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, s, t;
cin >> n >> s >> t;
cout << n - min(s, t) + 1 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d", &n);
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].second);
}
sort(a.begin(), a.end());
a.push_back({2e9, 0});
priority_queue<int> q;
long long s = 0, ans = 0;
for (int i = 0; i <= n; i++) {
int d;
if (i == 0)
d = a[i].first;
else
d = a[i].first - a[i - 1].first;
while (!q.empty() && d) {
s -= q.top();
ans += s;
q.pop();
d--;
}
q.push(a[i].second);
s += a[i].second;
}
printf("%lld", ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAX_N = (int)2e5 + 123;
const double eps = 1e-6;
const int inf = (int)1e9 + 123;
const int P = 123457, mod = (int)1e9 + 7;
using namespace std;
int n, m;
string second, t;
int pw[MAX_N], sum[MAX_N];
struct num {
vector<int> a, h;
int len;
num() {}
void apply() {
len = int((a).size());
h.resize(len);
if (len == 0) return;
h[0] = a[0];
for (int i = 1; i < len; i++) h[i] = (1ll * h[i - 1] * P + a[i]) % mod;
}
int get(int l, int r) {
int res = h[r];
if (l > 0) {
res -= 1ll * h[l - 1] * pw[r - l + 1] % mod;
if (res < 0) res += mod;
}
return res;
}
} first[26], me[26];
void add(int &a, const int &b) {
a += b;
if (a >= mod) a -= mod;
}
int must[26];
bool check(int id) {
memset(must, -1, sizeof must);
for (int i = 0; i < 26; i++) {
int l = lower_bound(first[i].a.begin(), first[i].a.end(), id) -
first[i].a.begin();
if (l >= int((first[i].a).size())) continue;
int r = lower_bound(first[i].a.begin(), first[i].a.end(), id + m) -
first[i].a.begin();
if (r == 0 || l > r - 1) continue;
r--;
int now = first[i].get(l, r);
now -= 1ll * (id - 1) * sum[r - l] % mod;
if (now < 0) now += mod;
for (int j = 0; j < 26; j++)
if (!me[j].a.empty() && me[j].get(0, int((me[j].a).size()) - 1) == now) {
must[i] = j;
break;
}
if (must[i] == -1) return 0;
}
for (int i = 0; i < 26; i++) {
if (must[i] == -1) continue;
if (must[must[i]] != -1 && must[must[i]] != i) return 0;
}
return 1;
}
int main() {
ios_base ::sync_with_stdio(NULL), cin.tie(NULL);
cin >> n >> m >> second >> t;
pw[0] = sum[0] = 1;
for (int i = 1; i <= n; i++) {
pw[i] = 1ll * pw[i - 1] * P % mod;
sum[i] = sum[i - 1];
add(sum[i], pw[i]);
}
for (int i = 0; i < int((second).size()); i++)
first[second[i] - 'a'].a.push_back(i + 1);
for (int i = 0; i < int((t).size()); i++) me[t[i] - 'a'].a.push_back(i + 1);
for (int i = 0; i < 26; i++) first[i].apply(), me[i].apply();
vector<int> ans;
for (int it = 1; it <= int((second).size()) - int((t).size()) + 1; it++)
if (check(it)) ans.push_back(it);
cout << int((ans).size()) << '\n';
for (auto i : ans) cout << i << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-10
class point {
public:
double x, y;
point() {}
point( double x_, double y_ ) : x(x_), y(y_) {}
point operator -( point p ) { return point( x - p.x, y - p.y ); }
point operator +( point p ) { return point( x + p.x, y + p.y ); }
point operator *( double a ) { return point( x * a, y * a ); }
};
class segment {
public:
point p1, p2;
segment() {}
};
double dot( point a, point b ) { return a.x * b.x + a.y * b.y; }
double cross( point a, point b ) { return a.x * b.y - a.y * b.x; }
double norm( point a ) { return a.x * a.x + a.y * a.y; }
double distance( segment s, point p )
{
if( dot( s.p2 - s.p1, p - s.p1 ) < 0 ) return sqrt( norm( p - s.p1 ) );
if( dot( s.p1 - s.p2, p - s.p2 ) < 0 ) return sqrt( norm( p - s.p2 ) );;
return fabs( cross( s.p2 - s.p1, p - s.p1 ) / sqrt( norm( s.p2 - s.p1 ) ) );
}
int ccw( point p0, point p1, point p2 )
{
point v1 = p1 - p0;
point v2 = p2 - p0;
if( cross( v1, v2 ) > EPS ) return 1;
if( cross( v1, v2 ) < -EPS ) return -1;
if( dot( v1, v2 ) < -EPS ) return 2;
if( norm( v1 ) < norm( v2 ) ) return -2;
return 0;
}
bool intersect( segment s1, segment s2 )
{
return ccw( s1.p1, s1.p2, s2.p1 ) * ccw( s1.p1, s1.p2, s2.p2 ) <= 0 &&
ccw( s2.p1, s2.p2, s1.p1 ) * ccw( s2.p1, s2.p2, s1.p2 ) <= 0;
}
double distance( segment s1, segment s2 )
{
if( intersect( s1, s2 ) ) return 0;
return min( { distance( s1, s2.p1 ), distance( s1, s2.p2 ),
distance( s2, s1.p1 ), distance( s2, s1.p2 ) } );
}
point cpoint( segment s1, segment s2 )
{
point base = s2.p2 - s2.p1;
double d1 = fabs( cross( base, s1.p1 - s2.p1 ) );
double d2 = fabs( cross( base, s1.p2 - s2.p1 ) );
double t = d1 / (d1 + d2 );
return s1.p1 + ( s1.p2 - s1.p1 ) * t;
}
int main()
{
int q;
cin >> q;
for( int i = 0; i < q; i++ ) {
segment s1, s2;
cin >> s1.p1.x >> s1.p1.y >> s1.p2.x >> s1.p2.y >> s2.p1.x >> s2.p1.y >> s2.p2.x >> s2.p2.y;
point ans = cpoint( s1, s2 );
cout << fixed << setprecision(10) << ans.x << " " << ans.y << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long INF64 = 1e18;
const long long INF32 = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
long long n, m;
cin >> n >> m;
long long a[m];
priority_queue<long long> q;
for (long long i = (0); i < (m); i++) {
cin >> a[i];
q.push(a[i]);
}
sort(a, a + m);
long long b, maxA = 0, minA = 0, i = 0;
while (n--) {
b = q.top();
q.pop();
maxA += b;
b--;
q.push(b);
while (a[i] == 0) {
i++;
}
minA += a[i];
a[i]--;
}
cout << maxA << ' ' << minA << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
int arr[n];
set<int> st;
for (int i = 0; i < n; ++i) cin >> arr[i], st.insert(arr[i]);
int v = 1;
for (int i = 0; i < n - 1; ++i) {
auto it = st.find(arr[i]);
it++;
if (it == st.end() || arr[i + 1] != (*it)) v++;
}
if (v <= k)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
int add(int x, int y) { return (1ll * x + 1ll * y) % mod; }
int del(int x, int y) { return ((1ll * x - 1ll * y) % mod + mod) % mod; }
int mul(int x, int y) { return (1ll * x * 1ll * y) % mod; }
const int N = 1e6 + 5;
int n;
long long a[N], pre[N];
long long sum = 0;
bool p[N];
vector<long long> primes, lmao;
int main() {
cin.tie(0), ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], sum += a[i];
if (sum == 1) {
cout << "-1\n";
exit(0);
}
for (int i = 2; i < N; i++) p[i] = 1;
for (int i = 2; i < N; i++) {
if (p[i]) {
primes.push_back(i);
for (int j = 2 * i; j < N; j += i) p[j] = 0;
}
}
for (int i = 0; i < primes.size(); i++) {
if (sum % primes[i] == 0) {
lmao.push_back(primes[i]);
while (sum % primes[i] == 0) sum /= primes[i];
}
}
if (sum > 1) lmao.push_back(sum);
long long hihixd = 1e18;
for (int k = 0; k < lmao.size(); k++) {
long long ans = 0, sum = 0;
for (int i = 1; i <= n; i++) {
pre[i] = a[i] % lmao[k];
pre[i] += pre[i - 1];
}
int li = 1, ri = 1;
for (int i = 0; i <= n, li <= n; i++) {
long long l = i * lmao[k], r = (i + 1) * lmao[k], md = (l + r + 1) / 2;
while (ri <= n && pre[ri] < r) ri++;
for (int j = li; j <= min(ri, n); j++) {
if (pre[j] < md) ans += pre[j] - l;
if (pre[j - 1] >= md) ans += r - pre[j - 1];
}
li = ri;
}
hihixd = min(hihixd, ans);
}
cout << hihixd;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
scanf("%d", &n);
printf("%.7f\n", 1 / (2 * (sin(3.14159265 / (4 * n)))));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, p1, p2, p3, t1, t2, l[100 + 2], r[100 + 2], ans;
int main() {
cin >> n >> p1 >> p2 >> p3 >> t1 >> t2;
for (register int i = 1; i <= n; i++) cin >> l[i] >> r[i];
for (register int i = 1; i <= n; i++) {
ans += (r[i] - l[i]) * p1;
if (i != 1)
if (l[i] - r[i - 1] > t1 + t2) {
ans += (l[i] - r[i - 1] - t1 - t2) * p3;
ans += t2 * p2;
ans += t1 * p1;
} else if (l[i] - r[i - 1] > t1) {
ans += (l[i] - r[i - 1] - t1) * p2;
ans += t1 * p1;
} else
ans += (l[i] - r[i - 1]) * p1;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100009], b[100009];
long long k[100009], t[100009], g[100009];
long long l = 0, cur = 0;
long long qu(long long A) {
while (cur < l - 1 && A >= g[cur + 1]) cur++;
if (cur >= l) cur = l - 1;
return k[cur] * A + t[cur];
}
void add(long long m, long long n) {
long long x;
while (1) {
if (l == 0 || l == 1) break;
x = (n - t[l - 2] + k[l - 2] - m - 1) / (k[l - 2] - m);
if (x <= g[l - 1])
l--;
else
break;
}
if (l == 0)
g[l] = -1;
else
g[l] = (n - t[l - 1] + k[l - 1] - m - 1) / (k[l - 1] - m);
k[l] = m;
t[l] = n;
l++;
}
long long dp[100009];
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
dp[0] = 0;
add(b[0], dp[0]);
for (long long i = 1; i < n; i++) {
dp[i] = qu(a[i]);
add(b[i], dp[i]);
}
cout << dp[n - 1] << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma optimize "-O3"
using namespace std;
const int maxN = (int)1e5 + 100;
long long c[maxN][5];
int n;
vector<int> pos[maxN];
bool lucky[maxN];
int a[maxN];
map<int, int> mp;
long long ans = 0;
vector<int> all_lucky;
bool already[maxN];
void solve(int l, int r) {
int ind =
lower_bound(all_lucky.begin(), all_lucky.end(), r) - all_lucky.begin();
long long cur_val = 0;
set<pair<int, int> > s;
ans += c[r - 1 + 2][4] - c[l - 1 + 2][4] - c[r - l][1] * c[l - 1 + 1][3];
if (r == n + 1) return;
cur_val = 0;
s.insert(make_pair(1, r - 1));
cur_val += c[r - 1 + 1][2];
;
for (int i = ind; i + 1 < all_lucky.size(); i++) {
if (s.empty()) break;
if (!already[a[all_lucky[i]]]) {
already[a[all_lucky[i]]] = true;
for (auto v : pos[a[all_lucky[i]]]) {
if (v >= r) break;
auto it = --(s.lower_bound(make_pair(v + 1, -1)));
int x = it->first;
int y = it->second;
assert(x <= v && v <= y);
s.erase(it);
cur_val -= c[y - x + 1 + 1][2];
if (x != v) {
s.insert(make_pair(x, v - 1));
cur_val += c[v - 1 - x + 1 + 1][2];
}
if (y != v) {
s.insert(make_pair(v + 1, y));
cur_val += c[y - v - 1 + 1 + 1][2];
}
}
}
if (s.empty()) continue;
long long tot = cur_val;
int nxt = all_lucky[i + 1];
int cur_len = nxt - all_lucky[i];
if (l != r) {
auto it = --s.lower_bound(make_pair(l + 1, -1));
int x = it->first;
int y = it->second;
assert(y == r - 1 && x <= l);
int len1 = y - l + 1;
int len2 = (y - x + 1) - len1;
ans -= c[y - x + 1 + 1][2] * cur_len * (r - l + 1);
long long coef =
(c[y - x + 1 + 1][3] - c[len2 + 1][3] + c[y - x + 1 + 1][2]);
ans += coef * cur_len;
}
ans += cur_val * cur_len * (r - l + 1);
}
for (int v : all_lucky) {
already[a[v]] = false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
c[0][0] = 1;
for (int i = 1; i < maxN; i++) {
c[i][0] = 1;
for (int j = 1; j <= min(i, 4); j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]] = 1;
int x = a[i];
lucky[i] = true;
while (x) {
if (x % 10 != 4 && x % 10 != 7) {
lucky[i] = false;
break;
}
x /= 10;
}
if (lucky[i]) all_lucky.push_back(i);
}
int lll = 1;
for (auto& it : mp) {
it.second = lll;
lll++;
}
for (int i = 1; i <= n; i++) {
a[i] = mp[a[i]];
pos[a[i]].push_back(i);
}
int prv = 0;
all_lucky.push_back(n + 1);
for (int i = 1; i <= n; i++) {
if (lucky[i]) {
solve(prv + 1, i);
prv = i;
}
}
if (prv != n) {
solve(prv + 1, n + 1);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, i, j, k, sum, tot;
bool a[505][505], vis[505][505];
char ans[3000005];
bool dir(int x, int y, int dx, int dy) {
for (;;) {
x += dx;
y += dy;
if (x < 0 || x > n || y < 0 || y > n) return false;
if (vis[x][y]) return false;
if (a[x][y]) return true;
}
}
void dfs(int x, int y) {
if (!a[x][y]) ans[++tot] = '1', ++sum;
vis[x][y] = true;
if (dir(x, y, -1, 0)) {
ans[++tot] = 'U';
dfs(x - 1, y);
ans[++tot] = 'D';
}
if (dir(x, y, 1, 0)) {
ans[++tot] = 'D';
dfs(x + 1, y);
ans[++tot] = 'U';
}
if (dir(x, y, 0, -1)) {
ans[++tot] = 'L';
dfs(x, y - 1);
ans[++tot] = 'R';
}
if (dir(x, y, 0, 1)) {
ans[++tot] = 'R';
dfs(x, y + 1);
ans[++tot] = 'L';
}
ans[++tot] = '2';
--sum;
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) {
scanf("%d", &a[i][j]);
if (a[i][j]) ++sum;
}
dfs(x, y);
if (sum)
printf("NO\n");
else
printf("YES\n%s\n", ans + 1);
}
| 5 |
#include <bits/stdc++.h>
int main() {
int a, i, b, c, A[101];
memset(A, 0, sizeof(A));
scanf("%d %d", &a, &b);
;
for (i = 0; i < a; i++) {
scanf("%d", &c);
A[c]++;
}
c = 0;
while (A[b] != a) {
for (i = b - 1; i > 0; i--) {
if (A[i] != 0) {
A[i]--;
A[i + 1]++;
}
}
c++;
}
printf("%d\n", c);
}
| 2 |
#include <bits/stdc++.h>
typedef long long ll;
const int N = 3054;
int mod, n;
int pw2[N], gw2[N];
int C[N][N], S2[N][N];
inline void add(int &x, const int y) {x += y - mod, x += x >> 31 & mod;}
void init(int n) {
int i, j;
for (*pw2 = i = 1; i <= n; ++i) pw2[i] = pw2[i - 1] * 2 % mod;
for (*gw2 = 2, i = 1; i <= n; ++i) gw2[i] = (ll)gw2[i - 1] * gw2[i - 1] % mod;
for (**C = i = 1; i <= n; ++i)
for (*C[i] = j = 1; j <= i; ++j)
add(C[i][j] = C[i - 1][j], C[i - 1][j - 1]);
for (**S2 = i = 1; i <= n; ++i)
for (j = 1; j <= i; ++j)
S2[i][j] = ((ll)S2[i - 1][j] * j + S2[i - 1][j - 1]) % mod;
}
int solve(int num) {
int set, rem = n - num, S = 0;
for (set = num; set >= 0; --set) S = ((ll)S * pw2[rem] + S2[num + 1][set + 1]) % mod;
return (ll)S * gw2[rem] % mod * C[n][num] % mod;
}
int main() {
int i; ll ans = 0;
scanf("%d%d", &n, &mod), init(n + 1);
for (i = 0; i <= n; ++i) i & 1 ? ans -= solve(i) : ans += solve(i);
ans %= mod, printf("%d\n", int(ans + (ans >> 63 & mod)));
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
using namespace std;
const int N=5005;
const int MOD=1000000007;
int n,a,b;
long long f[N][2];
long long g[N];
long long dp[N][2];
long long ksm(long long a,long long b)
{
long long res=1;
while(b)
{
if(b&1) res=res*a%MOD;
a=a*a%MOD,b>>=1;
}
return res;
}
int main()
{
scanf("%d%d%d",&n,&a,&b);
if(a>b) swap(a,b);
if(b==1)
{
printf("%lld",ksm(2,n));
return 0;
}
f[0][0]=f[0][1]=1;
for(int i=1;i<=n;i++)
{
for(int j=0;j<i;j++)
f[i][1]=(f[i][1]+f[j][0])%MOD;
for(int j=0;j+a<=i;j++)
f[i][0]=(f[i][0]+f[j][1])%MOD;
}
g[0]=1;
for(int i=1;i<=n;i++)
g[i]=(f[i][0]+f[i][1])%MOD;
long long ans=0;
for(int i=1;i<n;i++)
{
if(i<a) dp[i][0]=(dp[i][0]+1)%MOD;
for(int j=max(i-a+1,1);j<i;j++)
dp[i][0]=(dp[i][0]+dp[j][1])%MOD;
if(i<b) dp[i][1]=(dp[i][1]+g[i-1])%MOD;
for(int j=max(i-b+1,1);j<i;j++)
dp[i][1]=(dp[i][1]+dp[j][0]*(i-j==1?1:g[i-j-2])%MOD)%MOD;
if(i+b-1>=n) ans=(ans+dp[i][0]*g[n-i-1]%MOD)%MOD;
if(i+a-1>=n) ans=(ans+dp[i][1])%MOD;
}
printf("%lld",(ksm(2,n)-ans+MOD)%MOD);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[200005];
map<int, int> mp;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int val = (1 << k) - 1;
int cur = 0;
long long mn = 0;
mp[0]++;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
int cur1 = cur ^ arr[i];
int cur2 = cur ^ arr[i] ^ val;
if (mp[cur1] < mp[cur2]) {
cur = cur1;
mn += mp[cur1];
} else {
cur = cur2;
mn += mp[cur2];
}
mp[cur]++;
}
long long tot = (n * 1ll * (n + 1)) / 2;
printf("%lld\n", tot - mn);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.