solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int M = 525000;
const int mo = 1000000000;
int tg[M], s1[M], s2[M];
int f[N], sum[N], n, q;
void chg(int k, int l, int r, int v) {
tg[k] = (tg[k] + v) % mo;
s1[k] = (s1[k] + 1ll * v * sum[r - l]) % mo;
s2[k] = (s2[k] + 1ll * v * (sum[r - l + 1] + mo - 1)) % mo;
}
void pushdown(int k, int l, int r) {
if (!tg[k]) return;
int mid = (l + r) / 2;
chg(k * 2, l, mid, tg[k]);
chg(k * 2 + 1, mid + 1, r, tg[k]);
tg[k] = 0;
}
int move(int s1, int s2, int k) {
if (k == -1) return s1;
return (1ll * s1 * (k == 0 ? 0 : f[k - 1]) + 1ll * s2 * f[k]) % mo;
}
void pushup(int k, int l, int r) {
int mid = (l + r) / 2, kk = mid - l;
s1[k] = (move(s1[k * 2 + 1], s2[k * 2 + 1], kk) + s1[k * 2]) % mo;
s2[k] = (move(s1[k * 2 + 1], s2[k * 2 + 1], kk + 1) + s2[k * 2]) % mo;
}
void change(int k, int l, int r, int p, int v) {
if (l == r) {
s1[k] = s2[k] = v;
return;
}
int mid = (l + r) / 2;
pushdown(k, l, r);
if (p <= mid)
change(k * 2, l, mid, p, v);
else
change(k * 2 + 1, mid + 1, r, p, v);
pushup(k, l, r);
}
void add(int k, int l, int r, int x, int y, int v) {
if (x <= l && r <= y) {
chg(k, l, r, v);
return;
}
int mid = (l + r) / 2;
pushdown(k, l, r);
if (x <= mid) add(k * 2, l, mid, x, y, v);
if (y > mid) add(k * 2 + 1, mid + 1, r, x, y, v);
pushup(k, l, r);
}
int ask(int k, int l, int r, int x, int y) {
if (x <= l && r <= y) return move(s1[k], s2[k], l - x - 1);
int mid = (l + r) / 2, ans = 0;
pushdown(k, l, r);
if (x <= mid) ans += ask(k * 2, l, mid, x, y);
if (y > mid) ans += ask(k * 2 + 1, mid + 1, r, x, y);
return ans % mo;
}
int main() {
f[0] = f[1] = sum[0] = 1;
sum[1] = 2;
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
f[i] = (f[i - 1] + f[i - 2]) % mo;
sum[i] = (sum[i - 1] + f[i]) % mo;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
change(1, 1, n, i, x);
}
while (q--) {
int tp, x, y, k;
scanf("%d%d%d", &tp, &x, &y);
if (tp == 1)
change(1, 1, n, x, y);
else if (tp == 2)
printf("%d\n", ask(1, 1, n, x, y));
else
scanf("%d", &k), add(1, 1, n, x, y, k);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int LG = 18, N = 1 << LG, Mod = 998244353, Rn = 3;
int rev[N + 5];
inline int Power(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = 1ll * a * a % Mod)
if (b & 1) ret = 1ll * ret * a % Mod;
return (ret);
}
inline void NTT(int* F, int n, bool inv) {
int d = LG - __builtin_ctz(n);
for (int i = 0; i < n; i++)
if (i < (rev[i] >> d)) swap(F[i], F[(rev[i] >> d)]);
for (int len = 1; len < n; len <<= 1) {
int wn = Power(Rn, (Mod - 1) / (len << 1));
if (inv) wn = Power(wn, Mod - 2);
for (int i = 0; i < n; i += (len << 1))
for (int j = i, w = 1; j < i + len; j++) {
int a = 1ll * F[j + len] * w % Mod;
F[j + len] = F[j] - a;
F[j] += a;
if (F[j + len] < 0) F[j + len] += Mod;
if (F[j] >= Mod) F[j] -= Mod;
w = 1ll * w * wn % Mod;
}
}
if (inv)
for (int i = 0, rn = Power(n, Mod - 2); i < n; i++)
F[i] = 1ll * F[i] * rn % Mod;
}
inline void Inverse(int* A, int* B, int* C, int n) {
for (int i = 0; i < n + n; i++) B[i] = C[i] = 0;
B[0] = Power(A[0], Mod - 2);
for (int j = 2; j <= n; j <<= 1) {
for (int i = 0; i < j; i++) C[i] = A[i];
NTT(C, j << 1, 0);
NTT(B, j << 1, 0);
for (int i = 0; i < j + j; i++)
B[i] = (2 - 1ll * C[i] * B[i] % Mod + Mod) * B[i] % Mod;
NTT(B, j << 1, 1);
for (int i = j; i < j + j; i++) B[i] = 0;
}
}
void Sqrt(int* A, int* B, int* C, int* D, int n) {
B[0] = 1;
for (int j = 2; j <= n; j <<= 1) {
Inverse(B, D, C, j);
for (int i = 0; i < j; i++) C[i] = A[i], C[i + j] = 0;
NTT(C, j << 1, 0);
NTT(D, j << 1, 0);
for (int i = 0; i < j + j; i++) C[i] = 1ll * C[i] * D[i] % Mod, D[i] = 0;
NTT(C, j << 1, 1);
for (int i = 0; i < j; i++)
B[i] = 1ll * (B[i] + C[i]) * (Mod + 1) / 2 % Mod;
}
}
int n, m, A[N + 4], B[N + 4], C[N + 4], D[N + 4];
int main() {
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (LG - 1));
scanf("%d%d", &n, &m);
for (int i = 1, a; i <= n; i++) {
scanf("%d", &a);
if (a <= m) A[a] = Mod - 4;
}
n = 1;
while (n <= m) n <<= 1;
A[0]++;
Sqrt(A, B, C, D, n);
B[0]++;
Inverse(B, A, C, n);
for (int i = 1; i <= m; i++) printf("%d\n", A[i] * 2 % Mod);
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long sum[400500];
int a[100500];
int b[100500];
int c[100500];
void build(int v, int l, int r) {
int m;
if (l == r) {
sum[v] = a[l];
return;
}
m = (r + l) / 2;
build(2 * v, l, m);
build(2 * v + 1, m + 1, r);
sum[v] = sum[2 * v] + sum[2 * v + 1];
}
int find(int v, int l, int r, int x, int y) {
int m;
if (l == r) return sum[l];
m = (r + l) / 2;
if (y <= m) return find(v * 2, l, m, x, y);
if (x > m) return find((2 * v + 1), m + 1, r, x, y);
return (find(v * 2, l, m, x, y) + find((2 * v + 1), m + 1, r, x, y));
}
int main() {
#pragma warning(disable : 4996)
int n, i, x, y, z, m, t;
string s1, s2;
getline(cin, s1);
getline(cin, s2);
if (s2 != s1)
cout << max(s1.length(), s2.length());
else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long at[100005], a[100005];
int bmap[64];
vector<int> adj[100005];
int d[100005];
int bestans;
queue<int> bq;
int bfs(int f, int dst) {
while (!bq.empty()) bq.pop();
bq.push(f);
d[f] = 1;
while (!bq.empty()) {
int bf = bq.front();
bq.pop();
for (auto it : adj[bf]) {
if (bf == f && it == dst)
continue;
else if (bf == dst && it == f)
continue;
if (!d[it]) {
bq.push(it);
d[it] = d[bf] + 1;
}
}
}
return d[dst];
}
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int allz = 0;
for (int i = 0; i < n; i++) {
cin >> at[i];
allz += (at[i] == 0ll);
for (int j = 0; j < 64; j++) bmap[j] += ((at[i] >> j) & 1);
}
if (allz == n) {
cout << "0\n";
return 0;
}
int p = 0;
for (int i = 0; i < n; i++) {
if (at[i]) a[p++] = at[i];
}
n = p;
bool found = false;
for (int i = 0; i < 64; i++) {
if (bmap[i] >= 3) {
found = true;
cout << 3 << endl;
return 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (a[i] & a[j]) adj[i].push_back(j);
}
}
bestans = n + n;
for (int i = 0; i < n; i++) {
for (auto k : adj[i]) {
for (int j = 0; j < n; j++) d[j] = 0;
int ret = bfs(i, k);
if (ret) bestans = min(bestans, ret);
}
}
if (bestans > n)
cout << "-1" << endl;
else
cout << bestans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000003;
const int oo = 1000000000;
const int N = 0;
string GetCode(char ch) {
switch (ch) {
case '>':
return "1000";
case '<':
return "1001";
case '+':
return "1010";
case '-':
return "1011";
case '.':
return "1100";
case ',':
return "1101";
case '[':
return "1110";
case ']':
return "1111";
}
}
int main() {
string s;
cin >> s;
int result = 0;
for (int i = 0; i < int(s.size()); ++i) {
string temp = GetCode(s[i]);
for (int j = 0; j < int(temp.size()); ++j) {
result = result * 2 + (temp[j] - '0');
result %= mod;
}
}
printf("%d\n", result);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int inf = 1e9 + 7;
const int maxn = 2005;
using namespace std;
char ma[maxn], mb[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
string s, p;
cin >> s;
p = s;
int q = s.size() / 2;
for (int i = 1; i < s.size(); i++) {
string t = s.substr(i);
string k = s.substr(0, s.size() - i);
if (k == t) {
p = s.substr(s.size() - i);
break;
}
}
cout << s;
for (int i = 1; i < k; i++) {
cout << p;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
pair<long long int, long long int> p1, p2;
long long int n;
long long int A[300][3];
long long int solve(long long int i, pair<long long int, long long int> p) {
long long int ret = A[i][0] * p.first + A[i][1] * p.second + A[i][2];
return ret;
}
int main() {
cin >> p1.first >> p1.second;
cin >> p2.first >> p2.second;
cin >> n;
int ans = 0;
for (long long int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) cin >> A[i][j];
long long int val = solve(i, p1);
long long int val1 = solve(i, p2);
if ((val > 0 && val1 > 0) || (val < 0 && val1 < 0))
;
else
ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
int main() {
int N, M, X;
cin >> N >> M >> X;
vector<int> C(N);
vector<vector<int>> A(N, vector<int>(M));
rep(i, N) {
cin >> C[i];
rep(j, M) cin >> A[i][j];
}
int ans = 1e9;
rep(bit, 1 << N) {
int amount = 0;
vector<int> cnt(M, 0);
rep(i, N) {
if(!(bit & (1 << i))) continue;
amount += C[i];
rep(j, M) cnt[j] += A[i][j];
}
bool res = true;
rep(j, M) {
if(cnt[j] < X) res = false;
}
if(res) ans = min(ans, amount);
}
if(ans == 1e9)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000000 + 7;
int addm(int& a, int b) {
return (a += b) < mod ? (a < 0 ? a += mod : a) : a -= mod;
}
template <class T, class U>
bool smin(T& a, U b) {
return a > b ? (a = b, 1) : 0;
}
template <class T, class U>
bool smax(T& a, U b) {
return a < b ? (a = b, 1) : 0;
}
int n, d, dp[1001][11][1001], cs[1001][11][1002];
int a, b, g;
void gcd(int m, int n) {
if (n == 0) {
a = 1;
b = 0;
g = m;
return;
}
gcd(n, m % n);
int t = a - b * (m / n);
a = b;
b = t;
}
int inv(int a, int mod) {
gcd(mod, a);
return g > 0 ? b : -b;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> mod;
dp[0][0][0] = 1;
for (int i = 1; i < 1002; i++)
for (int j = 0; j <= d; j++)
cs[0][j][i] = (cs[0][j][i - 1] + dp[0][j][i - 1]) % mod;
for (int i = 1; i < n; i++)
for (int j = 1; j <= d; j++)
for (int k = 1; k < n; k++) {
long long f = 1;
for (int l = 1; l * k <= i && l <= j; l++) {
f = f * ((k == 1 ? 1 : cs[k - 1][d - 1][k]) + l - 1) % mod *
inv(l, mod) % mod;
addm(dp[i][j][k], (long long)cs[i - l * k][j - l][k] * f % mod);
}
cs[i][j][k + 1] = (cs[i][j][k] + dp[i][j][k]) % mod;
}
int ans = cs[n - 1][d][(n + 1) / 2];
addm(ans, cs[n - 1][0][(n + 1) / 2]);
if (n % 2 == 0) {
long long v = cs[n / 2 - 1][d - 1][n / 2] + cs[n / 2 - 1][0][n / 2];
addm(ans, v * (v + 1) / 2 % mod);
}
if (ans < 0) ans += mod;
cout << ans << endl;
}
| 6 |
#include <iostream>
#include <string>
using namespace std;
int main () {
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
int dx = tx - sx;
int dy = ty - sy;
cout << string(dx, 'R') << string(dy, 'U')
<< string(dx, 'L') << string(dy, 'D')
<< 'L' << string(dy + 1, 'U') << string(dx + 1, 'R') << 'D'
<< 'R' << string(dy + 1, 'D') << string(dx + 1, 'L') << 'U'
<< "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
int l = s.size();
string s1 = "",s2 = "";
int cnt = 0;
for(int i = 0;i < l;i++){
s1 += s[i];
if(s1 != s2){
cnt++;
s2 = s1;
s1 = "";
}
}
cout << cnt << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[6] % 2 == 0)
cout << 0;
else
cout << 1;
return 0;
}
| 4 |
#include <iostream>
int main() {
std::string p, s;
std::cin >> p >> s;
p = p + p;
if(p.find(s) != std::string::npos){
std::cout << "Yes" << std::endl;
}
else{
std::cout << "No" << std::endl;
}
} | 0 |
#include<iostream>
using namespace std;
int main()
{
int ans=0;
int n,k;
cin>>n>>k;
while(n)
{
ans++;
n=n/k;
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 mt_rand(
chrono::high_resolution_clock::now().time_since_epoch().count());
const long long hashSize = 3;
long long mod[hashSize];
const long long N = 2e5 + 50;
long long ans = 0;
struct hash_number {
long long a[hashSize];
hash_number() { fill(a, a + hashSize, 0ll); }
hash_number(long long x) {
for (long long i = (0); i <= (hashSize - 1); ++i) {
a[i] = x % mod[i];
}
}
hash_number operator+(hash_number x) {
hash_number res = hash_number();
for (long long i = (0); i <= (hashSize - 1); ++i) {
res.a[i] = (a[i] + x.a[i]) % mod[i];
}
return res;
}
bool operator==(const hash_number &x) {
for (long long i = (0); i <= (hashSize - 1); ++i) {
if (a[i] != x.a[i]) return false;
}
return true;
}
} val[N], c[10][10], s;
vector<pair<long long, long long> > g[N];
long long n, m, k;
void solve(long long lvl, hash_number hashNumber) {
if (lvl == k) {
if (hashNumber == s) ++ans;
return;
}
for (long long i = 1; i <= lvl + 1; i++) {
solve(lvl + 1, hashNumber + c[lvl + 1][i]);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
mod[0] = 1e9 + 7;
mod[1] = 998244353;
mod[2] = uniform_int_distribution<long long>(1e8, 1e9)(mt_rand);
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].emplace_back(w, v);
}
uniform_int_distribution<long long> rg(1ll, 1e18);
for (long long i = 1; i <= n; i++) {
val[i] = hash_number(rg(mt_rand));
s = s + val[i];
}
for (long long u = 1; u <= n; u++) {
long long d = g[u].size();
sort(g[u].begin(), g[u].end());
for (long long q = 1; q <= d; q++) {
c[d][q] = c[d][q] + val[g[u][q - 1].second];
}
}
solve(0, hash_number());
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int power(int a, int b) {
int f = 1;
for (; b; b >>= 1, a = 1ll * a * a % P)
if (b & 1) f = 1ll * f * a % P;
return f;
}
const int N = 550000 * 2;
int w1[N], w2[N], rev[N];
void initfft(int n) {
int k = 0, nn = n >> 1;
while (nn) {
nn >>= 1;
k++;
}
int g = power(3, (P - 1) / n);
w1[0] = 1;
for (int i = (1); i <= (n - 1); ++i) w1[i] = 1ll * w1[i - 1] * g % P;
for (int i = (0); i <= (n - 1); ++i) {
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (k - 1));
w2[(n - i) % n] = w1[i];
}
}
void fft(int n, int a[], int w[]) {
for (int i = (0); i <= (n - 1); ++i)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int k = 1; k < n; k <<= 1)
for (int i = 0; i < n; i += k << 1)
for (int j = 0; j < k; j++) {
int t1 = a[i + j], t2 = 1ll * a[i + j + k] * w[n / (k << 1) * j] % P;
a[i + j] = (t1 + t2) % P;
a[i + j + k] = (t1 + P - t2) % P;
}
}
int fac[N], inv[N], p2[N];
void init() {
fac[0] = 1;
for (int i = (1); i <= (N - 1); ++i) fac[i] = 1ll * fac[i - 1] * i % P;
inv[1] = 1;
for (int i = (2); i <= (N - 1); ++i)
inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
inv[0] = 1;
for (int i = (1); i <= (N - 1); ++i) inv[i] = 1ll * inv[i - 1] * inv[i] % P;
p2[0] = 1;
for (int i = (1); i <= (N - 1); ++i) p2[i] = p2[i - 1] * 2 % P;
}
int C(int n, int m) { return 1ll * fac[n] * inv[m] % P * inv[n - m] % P; }
int getans(int t1, int t2, int a[]) {
static int b[N];
int n = 1;
while (n <= t1 + t2) n <<= 1;
for (int i = (0); i <= (n); ++i) a[i] = b[i] = 0;
for (int i = (0); i <= (t1); ++i) a[i] = C(t1, i);
for (int i = (0); i <= (t2); ++i) b[i] = 1ll * C(t2, i) * p2[i] % P;
initfft(n);
fft(n, a, w1);
fft(n, b, w1);
for (int i = (0); i <= (n); ++i) a[i] = 1ll * a[i] * b[i] % P;
fft(n, a, w2);
int invn = power(n, P - 2);
for (int i = (0); i <= (n); ++i) a[i] = 1ll * a[i] * invn % P;
return n;
}
int s[N], b[8], Q[N];
int s1[N], s2[N];
int a[N], ans[N];
int main() {
init();
int n, k;
scanf("%d%d", &n, &k);
for (int i = (1); i <= (n); ++i) {
int a;
scanf("%d", &a);
s[a]++;
}
for (int i = (1); i <= (N - 1); ++i) {
s1[i] = s1[i - 1];
s2[i] = s2[i - 1];
if (s[i] == 1) s1[i]++;
if (s[i] >= 2) s2[i]++;
}
for (int i = (1); i <= (k); ++i) scanf("%d", &b[i]);
int q;
scanf("%d", &q);
for (int i = (1); i <= (q); ++i) scanf("%d", &Q[i]);
for (int i = (1); i <= (k); ++i) {
int t1 = s1[b[i] - 1];
int t2 = s2[b[i] - 1];
int mx = getans(t2 * 2, t1, a);
for (int j = (1); j <= (q); ++j) {
int need = Q[j] / 2 - b[i] - 1;
if (need >= 0 && need <= mx) (ans[j] += a[need]) %= P;
}
}
for (int i = (1); i <= (q); ++i) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int hmt() {
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
if (n) x = -x;
return x;
}
const int N = 300010;
int n, m, dd[N], pre[N];
set<int> ke[N];
unsigned long long a[N], pw[N];
void BFS(int u) {
dd[u] = 1;
queue<int> q;
q.push(u);
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &v : ke[u])
if (!dd[v]) {
pre[v] = u;
dd[v] = dd[u] + 1;
q.push(v);
}
}
}
int main() {
n = hmt(), m = hmt();
for (int i = 1, _b = m; i <= _b; ++i) {
int u = hmt(), v = hmt();
ke[u].insert(v);
ke[v].insert(u);
}
pw[0] = 1;
for (int i = 1, _b = n; i <= _b; ++i) {
pw[i] = pw[i - 1] * 1000000007;
ke[i].insert(i);
}
for (int u = 1, _b = n; u <= _b; ++u)
for (auto &v : ke[u]) a[u] += pw[v];
BFS(1);
if (dd[n] && dd[n] <= 5) {
cout << dd[n] - 1 << "\n";
vector<int> ans;
while (n != 1) ans.push_back(n), n = pre[n];
ans.push_back(1);
reverse(ans.begin(), ans.end());
for (auto &x : ans) cout << x << " ";
return 0;
}
for (int i = 1, _b = n; i <= _b; ++i)
if (dd[i] == 3) {
cout << 4 << "\n";
return cout << 1 << " " << pre[i] << " " << i << " " << 1 << " " << n, 0;
}
for (auto &u : ke[1])
for (auto &v : ke[u])
if (u != 1 && v != 1 && a[u] != a[v]) {
cout << 5 << "\n";
for (auto &x : ke[u])
if (!ke[v].count(x))
return cout << 1 << " " << v << " " << u << " " << x << " " << v
<< " " << n,
0;
for (auto &x : ke[v])
if (!ke[u].count(x))
return cout << 1 << " " << u << " " << v << " " << x << " " << u
<< " " << n,
0;
}
cout << -1 << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int money, b1 = 0, b2 = 0;
cin >> money;
b1 = b2 = money / 3;
b1 += (money % 3 == 1) ? 1 : 0;
b2 += (money % 3 == 2) ? 1 : 0;
cout << b1 << ' ' << b2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2002, mod = 1e9 + 7;
long long dp1[N][N], dp2[N][N], ans[N], n, k, anss;
string s;
long long up(char s) { return 'z' - s; }
long long down(char s) { return s - 'a'; }
int main() {
cin >> n >> k;
cin >> s;
s = ' ' + s;
n++, k++;
dp1[0][0] = 1;
ans[0] = 1;
for (long long i = 1; i < n; i++) {
anss = ans[k - 1];
for (long long j = 0; j < k; j++) {
dp2[i][j] = (down(s[i]) * ans[j]) % mod,
ans[j] = (ans[j] + dp2[i][j]) % mod;
}
for (long long j = i - 1; j >= max(1ll * 0, i - 1 - (k / (n - i)) - 1);
j--) {
for (long long l = (n - i) * (i - j); l < k; l++) {
ans[l] =
(ans[l] +
((dp1[j][l - (n - i) * (i - j)] + dp2[j][l - (n - i) * (i - j)]) %
mod * up(s[i])) %
mod) %
mod;
dp1[i][l] =
(dp1[i][l] +
((dp1[j][l - (n - i) * (i - j)] + dp2[j][l - (n - i) * (i - j)]) %
mod * up(s[i])) %
mod) %
mod;
}
}
}
cout << (dp1[n - 1][k - 1] + dp2[n - 1][k - 1] + anss) % mod;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt2, cnt4, cnt1, n, k, x, l, r, m;
scanf("%d %d", &n, &k);
cnt1 = cnt2 = cnt4 = 0;
l = 2 * n;
r = n;
m = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &x);
cnt4 += x / 4;
x %= 4;
cnt2 += x / 2;
x %= 2;
cnt1 += x;
}
if (r >= cnt4) {
r -= cnt4;
cnt4 = 0;
l += r;
m += r;
} else {
cnt4 -= r;
r = 0;
cnt2 += cnt4 * 2;
}
if (cnt2 >= l) {
cnt2 -= l;
cnt1 += cnt2 * 2;
cnt2 = 0;
} else {
l -= cnt2;
m += l;
}
if (m >= cnt1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <iostream>
#define reep(i,n,m) for(int i=(n);i<(m);i++)
#define rep(i,n) reep(i,0,n)
using namespace std;
int main(){
int n;
while(cin>>n,n){
int a[101]={0};
rep(i,n){
cin >> a[i];
}
int ans=0;
rep(i,n){
rep(i,n-1){
if(a[i]>a[i+1]){
swap(a[i],a[i+1]);
ans++;
}
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
long long n, m;
vector<long long> e[100005];
vector<long long> res;
long long sz[100005], mxp[100005], rt;
void getrt(long long u, long long pa) {
sz[u] = 1;
for (auto v : e[u]) {
if (v == pa) continue;
getrt(v, u), sz[u] += sz[v], mxp[u] = max(mxp[u], sz[v]);
}
mxp[u] = max(mxp[u], n - sz[u]);
if (mxp[rt] > mxp[u]) rt = u;
}
long long deg[100005], dep[100005], fa[100005], top[100005];
set<pair<long long, long long> > s, S[100005];
void dfs(long long u, long long pa, long long tp) {
top[u] = tp;
fa[u] = pa;
if (tp && (long long)e[u].size() >= 2) S[tp].insert(make_pair(dep[u], u));
for (auto v : e[u]) {
if (v == pa) continue;
dep[v] = dep[u] + 1, deg[u]++, fa[v] = u;
dfs(v, u, tp);
}
}
bool vis[100005];
inline void del(long long x) {
vis[x] = 1;
deg[fa[x]]--;
if (!deg[fa[x]]) S[top[x]].erase(make_pair(dep[fa[x]], fa[x]));
}
void getrest(long long u) {
if (!vis[u]) res.push_back(u);
for (auto v : e[u])
if (v != fa[u]) getrest(v);
}
signed main() {
n = read(), m = read();
for (register long long i = (2); i <= (n); ++i) {
long long u = read(), v = read();
e[u].push_back(v), e[v].push_back(u);
}
mxp[rt = 0] = n + 1, getrt(1, 0), getrt(rt, 0);
long long mx = 0, mn = 0;
for (register long long i = (1); i <= (n); ++i)
if (i != rt) mx += sz[i], mn += (sz[i] & 1);
if (m > mx || m < mn || (mx - m) % 2 != 0) return puts("NO") & 0;
puts("YES");
long long k = mx - m;
for (auto v : e[rt])
if (sz[v] > 1) s.insert(make_pair(sz[v], v));
for (auto v : e[rt]) dep[v] = 1, dfs(v, rt, v);
while (k) {
long long u = (--s.end())->second;
s.erase(--s.end());
long long x = (--S[u].end())->second;
vector<long long> o;
if (2 * dep[x] > k) {
x = (S[u].lower_bound(make_pair(k / 2, 0)))->second;
for (auto v : e[x])
if (v != fa[x] && !vis[v]) o.push_back(v);
if (o.size() < 2) o.push_back(x);
cout << o[0] << ' ' << o[1] << endl;
vis[o[0]] = vis[o[1]] = 1;
break;
}
for (auto v : e[x])
if (v != fa[x] && !vis[v]) o.push_back(v);
if (o.size() < 2) o.push_back(x);
cout << o[0] << ' ' << o[1] << endl;
del(o[0]), del(o[1]);
sz[u] -= 2;
k -= dep[x] * 2;
if (sz[u] > 1) s.insert(make_pair(sz[u], u));
}
getrest(rt);
for (long long i = 0; i < res.size() / 2; ++i)
cout << res[i] << ' ' << res[i + (res.size() / 2)] << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int n;
int main(){
cin >> n;
cout << n/2+n%2 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 200005;
struct Tree {
int tot, lnk[N], son[M], nxt[M];
int n, len, q[N], sz[N], fa[N];
long long sum, mxs, s[N], f[N], g[N];
Tree() {
len = tot = sum = mxs = 0;
memset(lnk, 0, sizeof(lnk));
}
int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
void add(int x, int y) {
tot++;
son[tot] = y;
nxt[tot] = lnk[x];
lnk[x] = tot;
tot++;
son[tot] = x;
nxt[tot] = lnk[y];
lnk[y] = tot;
}
void dfs(int x, int ff) {
s[x] = 0;
sz[x] = 1;
fa[x] = ff;
q[++len] = x;
for (int j = lnk[x]; j; j = nxt[j])
if (son[j] != ff)
dfs(son[j], x), s[x] += s[son[j]] + sz[son[j]], sz[x] += sz[son[j]];
}
void init() {
for (int i = (2); i <= (n); i++) add(read(), read());
dfs(1, 0);
for (int i = (2); i <= (n); i++) {
int x = q[i];
s[x] = s[fa[x]] + n - 2 * sz[x];
}
for (int i = (1); i <= (n); i++) {
sum += s[i];
if (s[i] > mxs) mxs = s[i];
}
sum /= 2;
}
void dp(int x, int dep, int n1, int n2, long long &res) {
f[x] = s[x] * n1 + (long long)dep * n1 * n2;
g[x] = s[x] * n2 + (long long)dep * n1 * n2;
if (f[x] + g[x] - 2ll * dep * n1 * n2 > res)
res = f[x] + g[x] - 2ll * dep * n1 * n2;
for (int j = lnk[x]; j; j = nxt[j])
if (son[j] != fa[x]) {
int y = son[j];
dp(y, dep + 1, n1, n2, res);
if (f[x] + g[son[j]] - 2ll * dep * n1 * n2 > res)
res = f[x] + g[son[j]] - 2ll * dep * n1 * n2;
if (f[son[j]] + g[x] - 2ll * dep * n1 * n2 > res)
res = f[son[j]] + g[x] - 2ll * dep * n1 * n2;
if (f[son[j]] > f[x]) f[x] = f[son[j]];
if (g[son[j]] > g[x]) g[x] = g[son[j]];
}
}
};
Tree t[3];
long long ans;
long long get(Tree &t1, Tree &t2, Tree &t3) {
long long res = 0;
t2.dp(1, 1, t1.n, t3.n, res);
return res + (t1.mxs + t1.n) * (t2.n + t3.n) +
(t3.mxs + t3.n) * (t2.n + t1.n);
}
int main() {
scanf("%d%d%d", &t[0].n, &t[1].n, &t[2].n);
for (int i = (0); i <= (2); i++) t[i].init();
for (int i = (0); i <= (2); i++)
if (get(t[(i + 2) % 3], t[i], t[(i + 1) % 3]) > ans)
ans = get(t[(i + 2) % 3], t[i], t[(i + 1) % 3]);
for (int i = (0); i <= (2); i++) ans += t[i].sum;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 1;
int main() {
int n;
cin >> n;
vector<int> a(n);
map<int, int> mp;
long long Ans = 0;
for (int &x : a) {
scanf("%d", &x);
if (mp.find(-x) != mp.end()) {
Ans += mp[-x];
}
mp[x]++;
}
cout << Ans;
}
| 2 |
#include <bits/stdc++.h>
#define MOD 1000000007
#define ll long long
#define cy cout << "YES" << endl
#define cn cout << "NO" << endl
#define all(v) v.begin(), v.end()
#define fo(i, n) for (int i = 0; i < n; i++)
#define fok(i, k, n) for (int i = k; i < n; i++)
#define pb push_back
#define FLASH ios_base::sync_with_stdio(false), cin.tie(NULL);
#define float long double
using namespace std;
void solve()
{
ll i = 0, j = 0, k = 0;
int n;
cin >> n;
ll a[n];
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
sort(a, a + n);
ll ans = 0;
ll pre = a[0];
// cout << ans << "\n";
fok(i, 1, n)
{
ans += pre - (i)*a[i];
pre = pre + a[i];
}
cout << ans + a[n - 1] << "\n";
}
signed main()
{
FLASH
#ifndef ONLINE_JUDGE
freopen("output.txt", "w", stdout);
freopen("input.txt", "r", stdin);
#endif
int t;
cin >> t;
while (t-- > 0)
{
solve();
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
char a[MAXN];
int sum[MAXN][3];
int main() {
int n;
cin >> a;
n = strlen(a);
for (int i = 1; i <= n; i++) {
sum[i][0] = sum[i - 1][0];
sum[i][1] = sum[i - 1][1];
sum[i][2] = sum[i - 1][2];
sum[i][a[i - 1] - 'x']++;
}
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
if (r - l < 2) {
cout << "YES" << endl;
continue;
}
int b[3];
b[0] = sum[r][0] - sum[l - 1][0];
b[1] = sum[r][1] - sum[l - 1][1];
b[2] = sum[r][2] - sum[l - 1][2];
sort(b, b + 3);
if (b[2] - b[0] > 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define r(i,n) for(long long i = 0; i<n; i++)
typedef long long ll;
using namespace std;
int main() {
int n,ans;
cin >> n;
ans=n;
r(i,n+1){
int t=i,count=0;
while(t){
count+=t%6;
t/=6;
}
t=n-i;
while(t){
count+=t%9;
t/=9;
}
ans=min(ans,count);
}
cout<< ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, k, l, m, n;
cin >> n;
vector<int> arr(n + 1);
int t = (1 << 22);
vector<int> dp(t, -1);
for (i = 0; i < t; i++) dp[i] = -1;
for (i = 1; i <= n; i++) {
cin >> arr[i];
dp[arr[i]] = arr[i];
}
for (j = 1; j <= 22; j++) {
vector<int> temp(t, -1);
for (i = 0; i < t; i++) {
if (i & (1 << (j - 1))) {
temp[i] = dp[i];
int x1 = (1 << (j - 1));
int newt = i ^ x1;
if (dp[newt] > 0) {
if (temp[i] == -1) temp[i] = dp[newt];
}
} else
temp[i] = dp[i];
}
for (i = 0; i < t; i++) dp[i] = temp[i];
}
for (i = 1; i <= n; i++) {
int N = t - 1;
int n2 = arr[i];
int x = N ^ n2;
int a1 = dp[x];
cout << a1 << " ";
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int l, d, v, g, r, cnt;
int main() {
scanf("%d%d%d%d%d", &l, &d, &v, &g, &r);
double pre = 1. * d / v;
for (; pre > g + r; cnt++) pre -= g + r;
printf("%.12lf\n",
pre < g ? 1. * l / v : 1. * (l - d) / v + (cnt + 1.) * (g + r));
}
| 2 |
#include <iostream>
using namespace std;
int n, a, mx, md, fl=1, c[105];
int main() {
int i;
cin>>n;
for(i=0; i<n; i++) {
cin>>a;
c[a]++;
mx = max(mx, a);
}
md = (mx+1)/2;
if(c[md] != mx%2+1) fl = 0;
for(i=md+1; i<=mx; i++) if(c[i]<2) fl = 0;
cout<<(fl ? "P":"Imp")<<"ossible";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=200010;
ll a[N],k;
int n;
map<ll,ll> mp;
int main()
{
cin >> n >> k;
for(int i=1;i<=n;i++)
{
cin >> a[i];
a[i]+=a[i-1];
}
ll ans=0;
for(int i=0;i<=n;i++)
{
if(i>=k) mp[(a[i-k]-i+k)%k]--;
ans+=mp[(a[i]-i)%k]++;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const int MAX = 1e6 + 5;
const long long MOD = 1e9 + 7;
const long double eps = 1e-9;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline void read(T& num) {
bool start = false, neg = false;
char c;
num = 0;
while ((c = getchar()) != EOF) {
if (c == '-')
start = neg = true;
else if (c >= '0' && c <= '9') {
start = true;
num = num * 10 + c - '0';
} else if (start)
break;
}
if (neg) num = -num;
}
inline long long powMM(long long a, long long b, long long M) {
long long ret = 1;
a %= M;
while (b) {
if (b & 1) ret = ret * a % M;
b >>= 1;
a = a * a % M;
}
return ret;
}
void open() { freopen("out.txt", "w", stdout); }
int n, k, m, a, yu;
struct node {
int piao = 0;
int last = 1000;
int id;
} ren[105];
bool win[105], lose[105];
bool cmp(node x, node y) {
if (x.piao != y.piao)
return x.piao > y.piao;
else
return x.last < y.last;
}
node tem;
bool checkwin(int x) {
for (int i = 1; i <= n; i++) {
if (ren[i].id == x) {
x = i;
break;
}
}
if (yu) {
tem.id = ren[x].id;
tem.last = m;
tem.piao = ren[x].piao;
tem.piao += yu;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (i == x) continue;
if (cmp(ren[i], tem)) ++cnt;
}
return (cnt < k);
} else {
if (ren[x].piao == 0)
return false;
else
return (x - 1) < k;
}
}
bool checklose(int x) {
for (int i = 1; i <= n; i++) {
if (ren[i].id == x) {
x = i;
break;
}
}
if (ren[x].piao == 0) return true;
int cnt = 0, num = yu;
for (int i = 1; i <= n; i++) {
if (i == x) continue;
if (cmp(ren[i], ren[x]))
++cnt;
else {
if (num >= (ren[x].piao - ren[i].piao + 1)) {
num -= ren[x].piao - ren[i].piao + 1;
++cnt;
} else
return false;
if (cnt >= k) return true;
}
if (cnt >= k) return true;
}
if (cnt >= k)
return true;
else
return false;
}
int main() {
scanf("%d%d%d%d", &n, &k, &m, &a);
for (int i = 1; i <= n; i++) {
ren[i].id = i;
ren[i].last = 1000;
ren[i].piao = 0;
}
for (int i = 1; i <= a; i++) {
int x;
scanf("%d", &x);
ren[x].piao++;
ren[x].last = i;
}
sort(ren + 1, ren + 1 + n, cmp);
yu = m - a;
for (int i = 1; i <= n; i++) {
win[i] = checkwin(i);
lose[i] = checklose(i);
}
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
if (win[i] && !lose[i])
printf("1");
else if (win[i] && lose[i])
printf("2");
else
printf("3");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int MAXIOSIZE = 1 << 24 | 1;
unsigned char buf[MAXIOSIZE], *p1, *p2;
template <typename T>
void read(T& x) {
x = 0;
char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 24, stdin), p1 == p2)
? EOF
: *p1++);
bool flg = false;
for (; ch < '0' || '9' < ch;
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 24, stdin), p1 == p2)
? EOF
: *p1++))
if (ch == '-') flg |= true;
for (; '0' <= ch && ch <= '9';
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 24, stdin), p1 == p2)
? EOF
: *p1++))
x = x * 10 + ch - '0';
flg ? x = -x : 0;
}
template <typename T>
void out(const T& x) {
if (x > 9) out(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void write(const T& x, const char& ed = ' ') {
if (x < 0)
putchar('-'), out(-x);
else
out(x);
putchar(ed);
}
} // namespace IO
string str;
vector<string> tokens;
int main() {
getline(cin, str);
auto itr = str.begin();
while (itr != str.end()) {
if (*itr == ',') tokens.push_back(",");
if (*itr == '.') tokens.push_back("..."), ++itr, ++itr;
if (isdigit(*itr)) {
string cur = "";
while (itr != str.end() && isdigit(*itr)) cur += *itr, itr++;
--itr;
tokens.push_back(cur);
}
++itr;
}
for (int i = (0), iend = (tokens.size() - 1); i <= iend; ++i) {
string cur = tokens[i];
if (tokens[i] == "," && i != tokens.size() - 1 ||
i != tokens.size() - 1 && tokens[i + 1] == "..." ||
i != tokens.size() - 1 && isdigit(tokens[i][0]) &&
isdigit(tokens[i + 1][0]))
cur += ' ';
cout << cur;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int e[N][N], mn, n;
bool vis[N];
long long dis[N];
int main() {
scanf("%d", &n);
mn = 1e9;
for (int i = (0); i <= (n); ++i) dis[i] = 1e18;
for (int i = (1); i <= (n); ++i)
for (int j = (i + 1); j <= (n); ++j)
scanf("%d", &e[i][j]), e[j][i] = e[i][j], mn = min(mn, e[i][j]);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j)
if (i ^ j) e[i][j] -= mn, dis[i] = min(dis[i], 2ll * e[i][j]);
for (int i = (1); i <= (n); ++i) {
int u = 0;
for (int j = (1); j <= (n); ++j)
if (dis[j] < dis[u] && !vis[j]) u = j;
vis[u] = 1;
for (int v = (1); v <= (n); ++v)
if (!vis[v]) dis[v] = min(dis[v], dis[u] + e[u][v]);
}
for (int i = (1); i <= (n); ++i)
printf("%lld\n", dis[i] + 1ll * mn * (n - 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
int n, k, a[MAXN];
int main() {
cin >> n >> k;
if (k * 3 <= n && k != 1) {
for (int i = 1; i <= n; i++) {
a[i] = ceil(i / 2);
if (i % 2 == 0) {
a[i] = i / 2;
}
}
for (int i = k * 2 + 1; i <= n + 1; i++) {
a[i + 1] = (i % k + 1) % k + 1;
}
swap(a[3], a[6]);
for (int i = 2; i <= n + 1; i++) {
cout << a[i] << " ";
}
} else {
cout << -1;
return 0;
}
return 0;
}
| 3 |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
typedef long long i64;
const int N = 500000 + 10;
int n, m, d[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]);
static int a[N], b[N];
a[0] = m;
for (int i = 1; i <= n; ++i) a[i] = std::min(a[i - 1], abs(a[i - 1] - d[i]));
b[n + 1] = 0;
for (int i = n; i > 0; --i) b[i] = b[i + 1] + (b[i + 1] >= d[i] / 2 ? d[i] : 0);
int q;
for (scanf("%d", &q); q--;) {
int x;
scanf("%d", &x);
puts(a[x - 1] <= b[x + 1] ? "NO" : "YES");
}
return 0;
}
| 0 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
struct edge {
int u, v;
int64_t cost;
edge(int u=0, int v=0, int64_t cost=0):u(u), v(v), cost(cost) {}
};
struct Edge {
int to;
int64_t cost;
Edge(int x=0, int64_t y=0):to(x), cost(y) {}
};
vector<vector<Edge> > G; // resizeの必要あり
map<P, bool> checked;
int dfs(int i, int j, Edge& X) {
//cout << i << endl;
if(i == X.to) {
return 0;
}
bool flag = false;
int cou = 0;
for(auto next:G[i]) {
if(next.to == j) continue;
int v = dfs(next.to, i, X);
if(v == -1) continue;
flag = true;
cou += v;
if(next.cost == X.cost && !(checked[P(i, next.to)])) {
checked[P(next.to, i)] = checked[P(i, next.to)] = true;
cou++;
}
}
if(flag) return cou;
else return -1;
}
struct UnionFind {
vector<int> par; // 親を指すvector,-par[親]は木のサイズ
UnionFind(int n):par(n, -1) {} // uniteで親を埋め込んでいく必要あり
int root(int x) { // 親をたどる&データの整理
if(par[x] < 0) {
return x;
}
return par[x] = root(par[x]);
}
bool unite(int x, int y) { // データの結合
x = root(x);
y = root(y);
if(x == y) return false;
if(par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
bool same(int x, int y) {
x = root(x);
y = root(y);
return (x == y);
} // 所属判定
int size(int x) {return -par[root(x)];} // 木のサイズ
};
bool comp(const edge& e1, const edge& e2) {
return e1.cost < e2.cost;
}
int ans=0;
vector<edge> es; // 辺の数でresize
//最小全域木
int64_t kruskal(int V) { // Vは頂点数
int E = es.size();
sort(es.begin(), es.end(), comp);
UnionFind uft(V);
int64_t res = 0;
for(int i = 0; i < E; ++i) {
edge e = es[i];
//cout << e.u << ' ' << e.v << endl;
G[e.u].push_back(Edge(e.v, e.cost));
G[e.v].push_back(Edge(e.u, e.cost));
if(!uft.same(e.u, e.v)) {
uft.unite(e.u, e.v);
res += e.cost;
++ans;
} else {
Edge X = Edge(e.u, e.cost);
int gg = dfs(e.v, e.u, X);
G[e.u].pop_back();
G[e.v].pop_back();
ans -= gg;
res -= gg*e.cost;
}
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
es.resize(m);
G.resize(n);
rep(i, m) {
int a, b;
ll c;
cin >> a >> b >> c;
--a;
--b;
es[i] = edge(a, b, c);
}
int kk = kruskal(n);
cout << ans << ' ';
cout << kk << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int zero, one;
char s[maxn];
vector<string> ans;
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == '0') zero++;
if (s[i] == '1') one++;
}
if (n & 1) {
if (one <= n / 2) ans.push_back("00");
if (zero <= n / 2 - 1) ans.push_back("11");
if (one <= n / 2 + 1 && zero <= n / 2) {
if (s[n] == '?') {
if (one != n / 2 + 1) ans.push_back("01");
if (zero != n / 2) ans.push_back("10");
} else if (s[n] == '1')
ans.push_back("01");
else if (s[n] == '0')
ans.push_back("10");
}
} else {
if (one <= n / 2 - 1) ans.push_back("00");
if (zero <= n / 2 - 1) ans.push_back("11");
if (one <= n / 2 && zero <= n / 2) {
if (s[n] == '?') {
if (one != n / 2) ans.push_back("01");
if (zero != n / 2) ans.push_back("10");
} else if (s[n] == '1')
ans.push_back("01");
else if (s[n] == '0')
ans.push_back("10");
}
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
const int dir[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
int dp[N * 2][N][N], adj[N][N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &adj[i][j]);
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) dp[i][j][k] = -(1 << 30);
dp[0][0][0] = adj[0][0];
for (int i = 1; i < 2 * n - 1; i++) {
for (int x1 = 0; x1 <= i && x1 < n; x1++) {
for (int x2 = 0; x1 <= i && x2 < n; x2++) {
int y1 = i - x1, y2 = i - x2;
if (y1 >= n || y2 >= n || y1 < 0 || y2 < 0) continue;
for (int r = 0; r < 4; r++) {
int tmp1 = x1 - dir[r][0], tmp2 = x2 - dir[r][1];
if (tmp1 >= 0 && tmp2 >= 0)
dp[i][x1][x2] = max(dp[i][x1][x2], dp[i - 1][tmp1][tmp2]);
}
dp[i][x1][x2] += adj[x1][y1];
if (x1 != x2 || y1 != y2) dp[i][x1][x2] += adj[x2][y2];
}
}
}
printf("%d\n", dp[2 * n - 2][n - 1][n - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int p, n, t, i, a[101], maxd = 1;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cin >> t;
for (i = 0; i < n; i++) {
if (a[i] + t >= a[n - 1]) {
if (n - i > maxd) maxd = n - i;
break;
} else {
p = upper_bound(a, a + n, a[i] + t) - a;
if (p - i > maxd) maxd = p - i;
}
}
cout << maxd;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c[21][100010];
int cn[21], d;
int p[100010];
bool a[21][1 << 20];
vector<int> e[1 << 20];
int dp[1 << 21];
bool find(int ci, int x) {
int l = -1, r = cn[ci] - 1, z;
if (r < 0 || c[ci][r] <= x) return false;
while (l + 1 < r) {
z = (l + r) >> 1;
if (c[ci][z] <= x)
l = z;
else
r = z;
}
return c[ci][r] - x <= d;
}
int m;
int dfs(int x) {
if (dp[x] >= 0) return dp[x];
int i, t = -1;
dp[x] = 1000;
for (i = 0; i <= m; i++) {
if ((x & (1 << i)) && a[i][(1 << m) ^ x]) {
t = i;
break;
}
}
if (t == -1) return dp[x] = 0;
for (i = 0; i < m; i++) {
if (x & (1 << i)) continue;
dp[x] = min(dp[x], dfs(x | (1 << i)) + 1);
}
return dp[x];
}
int main() {
int n, i, j, k, x;
scanf("%d%d%d", &n, &m, &d);
cn[m] = 2;
c[m][0] = 0;
c[m][1] = n + 1;
p[0] = p[n + 1] = m;
for (i = 0; i < m; i++) {
scanf("%d", &cn[i]);
for (j = 0; j < cn[i]; j++) {
scanf("%d", &x);
c[i][j] = x;
p[x] = i;
}
sort(c[i], c[i] + cn[i]);
}
int mm = (1 << m) - 1;
for (i = 0; i <= n; i++) {
if (n + 1 - i <= d) break;
x = p[i];
if (find(x, i)) continue;
x = 0;
for (j = 0; j < m; j++) {
if (find(j, i)) x |= (1 << j);
}
a[p[i]][mm ^ x] = true;
}
for (i = 0; i <= mm; i++) {
for (j = 0; j < m; j++) {
if (i & (1 << j)) {
e[i].push_back(i ^ (1 << j));
}
}
}
for (i = 0; i <= m; i++) {
for (j = mm; j >= 0; j--) {
if (a[i][j]) {
for (k = 0; k < (int)e[j].size(); k++) {
a[i][e[j][k]] = true;
}
}
}
}
for (i = 0; i < (1 << (m + 1)); i++) dp[i] = -1;
printf("%d\n", dfs(1 << m));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100001;
int n,m,s,t,d[MAX_N],a[MAX_N],b[MAX_N],dist[MAX_N];
vector<int> e[MAX_N];
typedef pair<int,int> P;
int cal(){
priority_queue<P,vector<P>,greater<P> > Q;
for(int i=0;i<n;i++)dist[i]=1e9;
Q.push(P(0,s));
dist[s]=0;
int head=0;
while(!Q.empty()){
P tmp=Q.top();
int pos=tmp.second,ct=tmp.first;
// cout<<pos<<" "<<ct<<endl;
Q.pop();
if(pos==t)return ct;
for(int i=head;i<pos;i++){
int nct=ct;
if(nct<dist[i]){
dist[i]=nct;
Q.push(P(nct,i));
}
}
head=max(head,pos);
for(int i=0;i<e[pos].size();i++){
int npos=e[pos][i];
int nct=ct+d[npos];
if(nct<dist[npos]){
dist[npos]=nct;
Q.push(P(nct,npos));
}
}
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin>>n>>m>>s>>t;
s--,t--;
for(int i=0;i<n;i++)cin>>d[i];
for(int i=0;i<m;i++){
cin>>a[i]>>b[i],a[i]--,b[i]--;
e[a[i]].push_back(b[i]);
}
cout<<cal()<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int h, w, q;
char buf[505][505];
int ans[1000005];
struct query_ {
int y1, x1, y2, x2;
int id;
};
bitset<505> able[2][505][505];
void rec(int l, int r, vector<query_>& query) {
vector<query_> left, right;
int md = (l + r) >> 1;
for (int i = 0; i < h; ++i)
for (int j = l; j < r; ++j) able[0][i][j].reset(), able[1][i][j].reset();
for (int i = 0; i < h; ++i)
if (buf[i][md] == '.') able[0][i][md].set(i), able[1][i][md].set(i);
for (int i = h - 1; i >= 0; --i)
for (int j = md; j >= l; --j)
if (buf[i][j] == '.') {
able[0][i][j] |= able[0][i + 1][j];
if (j < md) able[0][i][j] |= able[0][i][j + 1];
}
for (int i = 0; i < h; ++i)
for (int j = md; j < r; ++j)
if (buf[i][j] == '.') {
if (buf[i][j + 1] == '.') able[1][i][j + 1] |= able[1][i][j];
if (buf[i + 1][j] == '.') able[1][i + 1][j] |= able[1][i][j];
}
for (int i = 0; i < query.size(); ++i) {
if (query[i].x1 <= md && md <= query[i].x2) {
if ((able[0][query[i].y1][query[i].x1] &
able[1][query[i].y2][query[i].x2])
.any()) {
ans[query[i].id] = 1;
}
} else if (query[i].x2 < md)
left.push_back(query[i]);
else
right.push_back(query[i]);
}
if (!left.empty()) rec(l, md, left);
if (!right.empty()) rec(md, r, right);
query.clear();
}
int main() {
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) buf[i][j] = '#';
scanf("%d%d", &h, &w);
for (int i = 0; i < h; ++i) scanf("%s", buf[i]);
scanf("%d", &q);
vector<query_> query;
for (int i = 0; i < q; ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
--a;
--b;
--c;
--d;
if (a > c || b > d) continue;
query.push_back((query_){a, b, c, d, i});
}
rec(0, w, query);
for (int i = 0; i < q; ++i) {
if (ans[i])
puts("Yes");
else
puts("No");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int a[n];
long long int flag = 0;
long long int s = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) s++;
}
for (long long int i = 0; i < n - 1; i++) {
if (gcd(a[i], a[i + 1]) == 1) {
flag = 1;
break;
}
}
if (s == n)
cout << 0 << endl;
else if (flag == 1)
cout << n - s << endl;
else {
long long int mini = INT_MAX;
for (long long int i = 0; i < n - 1; i++) {
for (long long int j = i + 1; j < n - 1; j++) {
long long int x = a[i];
long long int y = a[j];
long long int val = gcd(x, y);
long long int c = 0;
while (val != 1 && j < n - 1) {
j++;
val = gcd(val, a[j]);
c++;
}
if (val == 1) mini = min(mini, c + 1);
break;
}
}
if (mini == INT_MAX)
cout << -1 << endl;
else
cout << n - 1 + mini - s << endl;
}
}
| 1 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<iomanip>
#include<cstdio>
#define DIF 5000
#define all(n) n.begin(),n.end()
using namespace std;
void draw(vector<vector<bool> >& graph,int sx,int sy,int ex,int ey)
{
for(int i=sy;i<ey;i++)
for(int j=sx;j<ex;j++)
graph[i][j] = true;
}
int main()
{
int n,NARI = 1;
while(cin >> n,n)
{
vector<double> X,Y,X1,X2,Y1,Y2;
vector<vector<bool> > graph;
graph.resize(310);
for(int i=0;i<310;i++)
{
graph[i].resize(310);
for(int j=0;j<310;j++)
graph[i][j] = false;
}
for(int i=0;i<n;i++)
{
double x,y,r;
cin >> x >> y >> r;
X.push_back(x+r),X.push_back(x-r);
Y.push_back(y+r),Y.push_back(y-r);
X1.push_back(x-r),Y1.push_back(y-r);
X2.push_back(x+r),Y2.push_back(y+r);
}
sort(all(X));
sort(all(Y));
X.erase(unique(all(X)),X.end());
Y.erase(unique(all(Y)),Y.end());
for(int i=0;i<n;i++)
{
X1[i] = find(all(X),X1[i]) - X.begin();
Y1[i] = find(all(Y),Y1[i]) - Y.begin();
X2[i] = find(all(X),X2[i]) - X.begin();
Y2[i] = find(all(Y),Y2[i]) - Y.begin();
}
for(int i=0;i<n;i++)
draw(graph,X1[i],Y1[i],X2[i],Y2[i]);
double ans = 0;
for(int i=0;i<Y.size()-1;i++)
for(int j=0;j<X.size()-1;j++)
if(graph[i][j])
ans += (X[j+1]-X[j])*(Y[i+1]-Y[i]);
cout << NARI++ << setiosflags(ios::fixed) << setprecision(2)<< " " << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// sando: 0+N
// katsu: 100000+N
// karee: 200000+N
// katsusan: 300000+N
// katsukare: 400000+N
int x, y, z, n, m, s, t;
vector<int> G[500005];
int dist[500005];
void addedge(int u, int v) {
G[u].push_back(v), G[v].push_back(u);
// cout << u << "<->" << v << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> x >> y >> z >> n >> m >> s >> t;
s = 300000 + s - 1;
t = 400000 + t - 1;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
addedge(0 + a, 300000 + i);
addedge(100000 + b, 300000 + i);
}
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
addedge(100000 + b, 400000 + i);
addedge(200000 + c, 400000 + i);
}
for (int i = 0; i < 500000; i++)
dist[i] = 0x3f3f3f3f;
dist[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int t = q.front();
// cout << "Vis " << t << endl;
q.pop();
for (int h : G[t])
if (dist[h] > dist[t] + 1) {
dist[h] = dist[t] + 1;
q.push(h);
}
}
if (dist[t] == 0x3f3f3f3f)
cout << -1 << endl;
else
cout << dist[t] / 2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int node = 0;
int t[100005][30];
bool win[100005], lose[100005];
void Insert(string a) {
int len = a.size();
int k = 0;
for (int i = 0; i < len; i++) {
int c = a[i] - 'a';
if (t[k][c] == 0) {
t[k][c] = ++node;
}
k = t[k][c];
}
}
void dfs(int v) {
win[v] = lose[v] = false;
int Leaf = true;
for (int i = 0; i < 26; i++) {
if (t[v][i]) {
Leaf = false;
dfs(t[v][i]);
win[v] |= !win[t[v][i]];
lose[v] |= !lose[t[v][i]];
}
}
if (Leaf) lose[v] = true;
}
void ans(int id) {
if (id == 0)
cout << "Second";
else
cout << "First";
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
while (n--) {
string a;
cin >> a;
Insert(a);
}
dfs(0);
if (k == 1)
ans(win[0]);
else if (win[0] == 0)
ans(win[0]);
else if (lose[0])
ans(lose[0]);
else if (k % 2)
ans(1);
else
ans(0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define FORR(i,a,b) for(int i=(int)(b)-1;i>=(int)(a);i--)
#define MOD 1000000007
int n;
char s[2521];
ll dp[2521][2521];
set<int> cs[26];
int main(){
scanf("%s",s);
n = strlen(s);
REP(i,n)cs[s[i]-'a'].insert(i);
dp[0][n] = 1;
ll ans = 0;
FORR(len,0,n+1)REP(l,n){
int r = l+len;
if(r>n)break;
ll cnt = dp[l][r];
if(cnt==0)continue;
// step
REP(i,26){
auto it1 = cs[i].lower_bound(l);
auto it2 = cs[i].lower_bound(r);
if(it1==cs[i].end())continue;
if(it2==cs[i].begin())continue;
it2--;
int x = *it1;
int y = *it2;
if(x>=y)continue;
if(x>=r)continue;
if(y<l)continue;
ans += cnt;
ans %= MOD;
(dp[x+1][y] += cnt) %= MOD;
// printf("%c(%d-%d)%c: %lld\n",'a'+i,x+1,y-1,'a'+i,cnt);
}
// finish
REP(i,26){
auto it = cs[i].lower_bound(l);
if(it==cs[i].end())continue;
int x = *it;
if(x<r){
// printf("%c single\n",'a'+i);
ans += cnt;
ans %= MOD;
}
}
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int b;
while (cin >> b, b) {
for (int c = 0; c<b; c++)scanf("%d", &a[c]);
int sum = 0;
for (int d = 0; d < b - 1; d++) {
for (int e = d + 1; e < b; e++) {
if (a[d] > a[e])sum++;
}
}
cout << sum << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> zero;
int main() {
int n, k;
int rl[100005][2];
char s[100005];
scanf("%d %d", &n, &k);
scanf("%s", &s);
for (int i = 0; i < n; i++) {
if (s[i] == '0') zero.push_back(i);
}
int l = 0, m = l, r = l;
int res = 199999;
r = 0 + k;
while (r < zero.size()) {
while (max(zero[m] - zero[l], zero[r] - zero[m]) >
max(zero[m + 1] - zero[l], zero[r] - zero[m + 1])) {
m = m + 1;
}
res = min(max(zero[m] - zero[l], zero[r] - zero[m]), res);
l = l + 1, r = r + 1;
}
printf("%d\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int legs[100005];
vector<int> E[100005];
vector<int> leafs;
bool vis[100005];
bool deleted[100005];
int deg(int u) { return E[u].size(); }
void findL(int u) {
vis[u] = true;
if (E[u].size() == 1) leafs.push_back(u);
for (int i = 0, v; i < E[u].size(); i++) {
v = E[u][i];
if (vis[v]) continue;
findL(v);
}
}
void del(int u) {
if (deg(u) > 2) {
legs[u]++;
return;
}
deleted[u] = true;
for (int i = 0, v; i < deg(u); i++) {
v = E[u][i];
if (deleted[v]) continue;
del(v);
}
}
int main() {
scanf("%d", &n);
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
E[a].push_back(b);
E[b].push_back(a);
}
findL(0);
for (int i = 0; i < leafs.size(); i++) {
del(leafs[i]);
}
bool pos = true;
for (int u = 0; u < n && pos; u++) {
int cnt = 0;
if (deleted[u]) continue;
for (int i = 0, v; i < deg(u); i++) {
v = E[u][i];
if (deleted[v]) continue;
if (deg(v) - legs[v] == 1) {
if (legs[v] != 2) cnt++;
} else {
cnt++;
}
}
if (cnt > 2) pos = false;
}
if (pos)
puts("Yes");
else
puts("No");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[555][555];
long long b[555][555];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> b[i][j];
}
}
for (long long i = 1; i < n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] != b[i][j]) {
for (long long k = j + 1; k <= m; k++) {
if (a[i][k] != b[i][k]) {
a[i][j] ^= 1, a[i][k] ^= 1;
a[i + 1][j] ^= 1, a[i + 1][k] ^= 1;
j = k;
break;
}
}
}
}
}
bool bad = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] != b[i][j]) {
bad = 1;
}
}
}
cout << (bad ? "No" : "Yes") << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long n, len, a[N], K, pre[N];
long long ans;
multiset<long long> s1, s2;
void solve() {
long long sum = 0;
multiset<long long>::iterator it;
for (int i = 1; i <= n; i++) {
if (a[i] >= 0)
sum += a[i];
else {
if (s1.size() == K) {
if (a[i] <= *s1.rbegin()) {
s1.insert(a[i]), sum += -a[i];
int k = *s1.rbegin();
s2.insert(k), s1.erase(s1.find(k));
sum -= -k, sum += k;
} else {
sum += a[i];
s2.insert(a[i]);
}
} else {
sum += -a[i];
s1.insert(a[i]);
}
}
if (i > len) {
if (a[i - len] >= 0)
sum -= a[i - len];
else {
if (s1.size() == K) {
if (a[i - len] <= *s1.rbegin()) {
sum -= -a[i - len];
s1.erase(s1.find(a[i - len]));
if (s2.size()) {
int k = *s2.begin();
s1.insert(k);
s2.erase(s2.begin());
sum -= k;
sum += -k;
}
} else {
sum -= a[i - len];
s2.erase(s2.find(a[i - len]));
}
} else {
sum -= -a[i - len];
s1.erase(s1.find(a[i - len]));
}
}
}
if (i >= len) ans = max(ans, sum);
}
}
int main() {
cin >> n >> len;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), pre[i] = pre[i - 1] + a[i];
cin >> K;
if (!K) {
for (int i = len; i <= n; i++) ans = max(ans, abs(pre[i] - pre[i - len]));
cout << ans << endl;
return 0;
}
solve();
s1.clear(), s2.clear();
for (int i = 1; i <= n; i++) a[i] = -a[i];
solve();
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main(){
int n;
cin >> n;
int xo[n];
int allxor = 0;
for(int i = 0; i < n; i++){
cin >> xo[i];
allxor ^= xo[i];
}
for(int i = 0; i < n; i++){
xo[i] ^= allxor; cout << xo[i] << " ";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[10];
int main() {
map<int, int> A;
map<int, char> B;
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int x, y, z = 0;
scanf("%d%d%s", &x, &y, s);
if (A.find(x) != A.end()) {
puts("0");
continue;
}
if (s[0] == 'L') {
auto it = A.lower_bound(x);
if (it == A.begin()) {
z = x;
} else {
--it;
if (B[it->first] == 'L') {
z = x - it->first + it->second;
} else {
z = x - it->first;
}
}
} else {
auto it = A.lower_bound(x);
if (it == A.end()) {
z = n + 1 - x;
} else {
if (B[it->first] == 'U') {
z = it->first - x + it->second;
} else {
z = it->first - x;
}
}
}
printf("%d\n", z);
A[x] = z;
B[x] = s[0];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int l[100005], r[100005], t[100005];
int main() {
int n, m, s, f;
scanf("%d%d%d%d", &n, &m, &s, &f);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", t + i, l + i, r + i);
}
int ind = 0, pos = s, j, dir, c;
if (f > s) {
dir = 1;
c = 1;
} else {
dir = -1;
c = 0;
}
for (j = 1; pos != f; ++j) {
if (t[ind] != j || l[ind] > pos + c || r[ind] < pos + c - 1) {
if (dir == 1)
printf("R");
else
printf("L");
pos += dir;
} else {
printf("X");
}
if (t[ind] == j) ++ind;
}
return 0;
}
| 2 |
#include <iostream>
#include <vector>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> v(n);
for (auto& x : v) cin >> x;
vector<vector<int>> dp(n, vector<int>(n, n));
for (int i{0}; i < n; ++i) dp[0][i] = 0;
for (int i{1}; i < n; ++i) {
int cnt{0};
for (int j{i - 1}; j >= 0; --j)
if (j + v[j] >= i)
dp[i][j + v[j]] = min(dp[i][j + v[j]], dp[j][i - 1] + cnt), ++cnt;
for (int j{i + 1}; j < n; ++j)
dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
cout << dp[n - 1][n - 1] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t{1};
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int N = 100005, E = 262144;
int n, m, i, u, v, p, t, vis[55][55], j, k;
vector<int> g[55][55];
int q[N], l, r;
vector<int> ansr, ansl;
long long dp[105][55][2];
bool flag1 = true;
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d %d", &u, &v);
vis[u][v] = 1;
scanf("%d", &t);
if (t == 0) flag1 = false;
while (t--) {
scanf("%d", &p);
g[u][v].push_back(p);
}
}
bool flag = true;
for (i = 1; i <= n && flag; ++i)
for (j = 1; j <= n && flag; ++j) {
for (k = 0; k + 1 < g[i][j].size(); ++k)
if (g[i][j][k] == i && g[i][j][k + 1] == j) break;
if (k + 1 < g[i][j].size()) {
l = 1, r = 0;
for (p = k + 2; p < g[i][j].size(); ++p) q[++r] = g[i][j][p];
p = j;
ansl.clear(), ansr.clear();
ansr.push_back(j);
while (l <= r && r <= 2 * n) {
if (!vis[p][q[l]]) break;
for (auto it : g[p][q[l]]) q[++r] = it;
p = q[l];
ansr.push_back(q[l]);
++l;
}
if (l <= r) continue;
l = 1, r = 0;
for (p = k - 1; p >= 0; --p) q[++r] = g[i][j][p];
p = i;
ansl.push_back(i);
while (l <= r && r <= 2 * n) {
if (!vis[q[l]][p]) break;
for (int i = g[q[l]][p].size() - 1; i >= 0; --i)
q[++r] = g[q[l]][p][i];
p = q[l];
ansl.push_back(q[l]);
++l;
}
if (l <= r) continue;
if (flag && ansl.size() + ansr.size() <= 2 * n) {
printf("%d\n", ansl.size() + ansr.size());
for (j = ansl.size() - 1; j >= 0; --j) printf("%d ", ansl[j]);
for (j = 0; j < ansr.size(); ++j) printf("%d ", ansr[j]);
flag = false;
}
}
}
if (flag) puts("0");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
int arr[n + 10];
for (int i = 0; i < n; i++) cin >> arr[i];
int ons = 0;
for (int i = 0; i < n; i++) ons += arr[i];
if (ons == n) {
cout << n - 1 << endl;
continue;
}
int zeros[1001][1001], ones[1001][1001];
for (int i = 0; i < n; i++) {
zeros[i][i] = !arr[i];
ones[i][i] = arr[i];
for (int j = i + 1; j < n; j++) {
zeros[i][j] = zeros[i][j - 1] + !arr[j];
ones[i][j] = ones[i][j - 1] + arr[j];
}
}
int mx = ons;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
mx = max(mx, ons + zeros[i][j] - ones[i][j]);
}
}
cout << mx << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXSZ = 50;
const int MAXN = MAXSZ;
const int MAXMOVE = 10800;
struct Move {
int sx, sy, ex, ey;
Move() {}
Move(int sx, int sy, int ex, int ey) : sx(sx), sy(sy), ex(ex), ey(ey) {}
};
int sz, n;
int sx[MAXN], sy[MAXN];
int ex[MAXN], ey[MAXN];
Move ret[MAXMOVE];
int nret;
int cx[MAXN], cy[MAXN];
int erowsum[MAXSZ];
void solve() {
nret = 0;
if (sz == 1) return;
for (int i = (0); i < (n); ++i) cx[i] = sx[i], cy[i] = sy[i];
for (int i = (0); i < (sz); ++i) erowsum[i] = 0;
for (int i = (0); i < (n); ++i) ++erowsum[ex[i]];
int ax = -1;
for (int i = (0); i < (sz - 1); ++i)
if (erowsum[i] + erowsum[i + 1] <= 2) {
ax = i;
break;
}
bool special = false;
if (ax == -1) {
assert(sz == 3 && n == 3 && erowsum[1] == 3);
special = true;
ax = 0;
}
int acnt = 0;
while (true) {
int cur = -1;
for (int i = (0); i < (n); ++i)
if (cx[i] == ax && cy[i] >= acnt && (cur == -1 || cy[i] < cy[cur]))
cur = i;
if (cur == -1) break;
while (cy[cur] > acnt) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
++acnt;
}
while (true) {
int cur = -1;
for (int i = (0); i < (n); ++i)
if (cx[i] < ax &&
(cur == -1 || cx[i] > cx[cur] || cx[i] == cx[cur] && cy[i] > cy[cur]))
cur = i;
if (cur == -1) break;
while (cy[cur] < acnt) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] + 1);
++cy[cur];
}
while (cx[cur] < ax) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
while (cy[cur] > acnt) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
++acnt;
}
while (true) {
int cur = -1;
for (int i = (0); i < (n); ++i)
if (cx[i] > ax &&
(cur == -1 || cx[i] < cx[cur] || cx[i] == cx[cur] && cy[i] > cy[cur]))
cur = i;
if (cur == -1) break;
while (cy[cur] < acnt) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] + 1);
++cy[cur];
}
while (cx[cur] > ax) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
}
while (cy[cur] > acnt) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
++acnt;
}
assert(acnt == n);
if (special) {
for (int i = (0); i < (n); ++i) {
int cur = i;
while (cx[cur] < i) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
}
for (int i = (0); i < (n); ++i) {
int cur = i;
while (cy[cur] < ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] + 1);
++cy[cur];
}
while (cy[cur] > ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
}
for (int i = (0); i < (n); ++i) {
int cur = i;
while (cx[cur] < ex[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
while (cx[cur] > ex[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
}
}
return;
}
while (true) {
int cur = -1;
for (int i = (0); i < (n); ++i)
if (cx[i] == ax && ex[i] > ax + 1 && (cur == -1 || ex[i] > ex[cur]))
cur = i;
if (cur == -1) break;
{
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
while (cy[cur] < ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] + 1);
++cy[cur];
}
while (cy[cur] > ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
while (cx[cur] < ex[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
}
for (int i = (0); i < (n); ++i)
if (cx[i] == ax) {
int cur = i;
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
while (true) {
int cur = -1;
for (int i = (0); i < (n); ++i)
if (cx[i] == ax + 1 && ex[i] < ax && (cur == -1 || ex[i] < ex[cur]))
cur = i;
if (cur == -1) break;
{
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
}
while (cy[cur] < ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] + 1);
++cy[cur];
}
while (cy[cur] > ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
while (cx[cur] > ex[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
}
}
vector<int> rem;
for (int i = (0); i < (n); ++i)
if (cx[i] == ax + 1) rem.push_back(i);
assert(((int)(rem).size()) <= 2);
if (((int)(rem).size()) == 0) return;
if (ex[rem[0]] == ax) {
int cur = rem[0];
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
} else if (((int)(rem).size()) == 2) {
int cur = rem[1];
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
}
for (int i = (0); i < (((int)(rem).size())); ++i) {
int cur = rem[i];
while (cy[cur] < ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] + 1);
++cy[cur];
}
while (cy[cur] > ey[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur], cy[cur] - 1);
--cy[cur];
}
while (cx[cur] < ex[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] + 1, cy[cur]);
++cx[cur];
}
while (cx[cur] > ex[cur]) {
ret[nret++] = Move(cx[cur], cy[cur], cx[cur] - 1, cy[cur]);
--cx[cur];
}
}
for (int i = (0); i < (n); ++i) assert(cx[i] == ex[i] && cy[i] == ey[i]);
}
void verify() {
vector<vector<int>> who(sz, vector<int>(sz, -1));
for (int i = (0); i < (n); ++i) who[sx[i]][sy[i]] = i;
for (int i = (0); i < (nret); ++i) {
assert(who[ret[i].sx][ret[i].sy] != -1);
assert(who[ret[i].ex][ret[i].ey] == -1);
assert(abs(ret[i].sx - ret[i].ex) + abs(ret[i].sy - ret[i].ey) == 1);
swap(who[ret[i].sx][ret[i].sy], who[ret[i].ex][ret[i].ey]);
}
for (int i = (0); i < (n); ++i) assert(who[ex[i]][ey[i]] == i);
}
void run() {
scanf("%d%d", &sz, &n);
for (int i = (0); i < (n); ++i)
scanf("%d%d", &sx[i], &sy[i]), --sx[i], --sy[i];
for (int i = (0); i < (n); ++i)
scanf("%d%d", &ex[i], &ey[i]), --ex[i], --ey[i];
solve();
printf("%d\n", nret);
for (int i = (0); i < (nret); ++i)
printf("%d %d %d %d\n", ret[i].sx + 1, ret[i].sy + 1, ret[i].ex + 1,
ret[i].ey + 1);
verify();
}
void stress() {
for (int rep = (0); rep < (100000); ++rep) {
sz = n = rand() % 6 + 1;
{
set<pair<int, int>> seen;
for (int i = (0); i < (n); ++i)
while (true) {
int x = rand() % sz, y = rand() % sz;
if (seen.count(make_pair(x, y))) continue;
sx[i] = x, sy[i] = y;
seen.insert(make_pair(x, y));
break;
}
}
{
set<pair<int, int>> seen;
for (int i = (0); i < (n); ++i)
while (true) {
int x = rand() % sz, y = rand() % sz;
if (seen.count(make_pair(x, y))) continue;
ex[i] = x, ey[i] = y;
seen.insert(make_pair(x, y));
break;
}
}
solve();
verify();
printf(".");
}
}
int main() {
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
const int MAX_N = 2e5 + 5;
vector< int > g[MAX_N];
int main() {
int n, m;
scanf(" %d %d", &n, &m);
for(int i = 0; i < m; i++) {
int u, v;
scanf(" %d %d", &u, &v);
g[u].pb(v);
g[v].pb(u);
}
for(int nb1 : g[1]) {
for(int nb2 : g[nb1]) {
if(nb2 == n) {
printf("POSSIBLE\n");
return 0;
}
}
}
printf("IMPOSSIBLE\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, dienos = 0;
cin >> n >> m;
while (n > 0) {
dienos++;
n--;
if (dienos % m == 0) n++;
}
cout << dienos << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int n;
long long dp[100010];
int main() {
cin.tie(nullptr);
cin.sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
a[b]++;
}
dp[0] = a[0];
dp[1] = max(a[0], a[1]);
for (long long i = 2; i < 100010; i++) {
dp[i] = max(i * a[i] + dp[i - 2], dp[i - 1]);
}
cout << dp[100010 - 1] << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
pair<int, int> valp[150010];
struct node {
int p, t, pp;
} a[150010];
long long T, tl[150010], tr[150010];
double l, r, mid, t[150010];
const double inf = (1e18);
void add(int x, double v) {
for (; x; x -= (x & -x)) t[x] = min(t[x], v);
}
double query(int x) {
double ans = inf;
for (; x <= cnt; x += (x & -x)) ans = min(ans, t[x]);
return ans;
}
bool cmp(node a, node b) {
return 1ll * a.p * b.t > 1ll * a.t * b.p ||
1ll * a.p * b.t == 1ll * a.t * b.p && a.p < b.p;
}
bool check(double c) {
for (int i = 1; i <= cnt; i++) t[i] = inf;
for (int i = n; i; i--) {
if (query(a[i].pp + 1) <= a[i].p * (1 - (c * tl[i]) / T)) return 1;
add(a[i].pp, a[i].p * (1 - (c * tr[i]) / T));
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].t);
sort(a + 1, a + 1 + n, cmp), T = 0;
for (int i = 1; i <= n; i++) valp[i] = make_pair(a[i].p, i);
sort(valp + 1, valp + 1 + n);
for (int i = 1; i <= n; i++) {
if (i == 1 || valp[i].first != valp[i - 1].first) cnt++;
a[valp[i].second].pp = cnt;
}
for (int l = 1, r; l <= n; l++) {
for (r = l; r < n && 1ll * a[l].p * a[r + 1].t == 1ll * a[l].t * a[r + 1].p;
r++)
;
for (int i = l; i <= r; i++) tl[i] = T + a[i].t;
for (int i = l; i <= r; i++) T += a[i].t;
for (int i = l; i <= r; i++) tr[i] = T;
l = r;
}
l = 0, r = 1;
for (int i = 1; i <= 50; i++) {
mid = (l + r) / 2.0;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.10lf\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> fo[5010];
bool used[5010];
int dfs(int vr) {
used[vr] = true;
int SZ = 1;
for (int i = 0; i < ((int)(fo[vr]).size()); ++i)
if (!used[fo[vr][i]]) SZ += dfs(fo[vr][i]);
return SZ;
}
int ANS[5010], cur[5010];
int main() {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
fo[a].push_back(b);
fo[b].push_back(a);
}
for (int i = 0; i < N; ++i) {
vector<int> act;
memset(used, 0, sizeof used);
used[i] = true;
for (int j = 0; j < ((int)(fo[i]).size()); ++j)
if (!used[fo[i][j]]) act.push_back(dfs(fo[i][j]));
if (((int)(act).size()) < 2) continue;
memset(cur, 0, sizeof cur);
cur[0] = 1;
for (int j = 0; j < ((int)(act).size()); ++j)
for (int k = N - 1; k >= act[j]; --k)
if (cur[k - act[j]]) cur[k] = 1;
cur[N - 1] = cur[0] = 0;
for (int j = 0; j < N; ++j)
if (cur[j]) ANS[j] = 1;
}
vector<pair<int, int> > out;
for (int i = 0; i < N; ++i)
if (ANS[i]) out.push_back(make_pair(i, N - 1 - i));
printf("%d\n", ((int)(out).size()));
for (int i = 0; i < ((int)(out).size()); ++i)
printf("%d %d\n", out[i].first, out[i].second);
return 0;
}
| 5 |
#include<iostream>
#include<vector>
using namespace std;
#define repeat(i,n) for(int i=0;i<(n);i++)
int main(){
int theta;
cin>>theta;
cout<<theta/30<<' '<<theta%30*2<<endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef pair<P,P> P1;
int G[4][4],sum,ans=6;
int X[6][4][4];
int dy[4]={-1,0,1,0};
int dx[4]={0,1,0,-1};
int tim[4][4];
void dfs(int dep,int s){
if(dep==6)return;
for(int i=0;i<4;i++)
for(int j=0;j<4;j++){
int cnt=0;
if(!G[i][j])continue;
G[i][j]--;
X[dep][i][j]++;
cnt++;
queue<P1> q;
for(int k=0;k<4;k++){
int ny=i+dy[k],nx=j+dx[k];
if(ny<0||nx<0||4<=ny||4<=nx)continue;
if(G[i][j])continue;
tim[i][j]=0;
q.push(P1(P(1,k),P(ny,nx)));
}
while(!q.empty()){
P1 t=q.front(); q.pop();
int y=t.second.first,x=t.second.second;
int cost=t.first.first,d=t.first.second;
if(!G[y][x]){
if(tim[y][x]==cost)continue;
int ny=y+dy[d],nx=x+dx[d];
if(ny<0||nx<0||4<=ny||4<=nx)continue;
q.push(P1(P(cost+1,d),P(ny,nx)));
}else{
G[y][x]--;
X[dep][y][x]++;
cnt++;
for(int k=0;k<4;k++){
int ny=y+dy[k],nx=x+dx[k];
if(ny<0||nx<0||4<=ny||4<=nx)continue;
if(G[y][x])continue;
tim[y][x]=cost;
q.push(P1(P(cost+1,k),P(ny,nx)));
}
}
}
if(s+cnt==sum)ans=min(ans,dep);
dfs(dep+1,s+cnt);
for(int y=0;y<4;y++)
for(int x=0;x<4;x++){
G[y][x]+=X[dep][y][x];
if(G[y][x])tim[y][x]=0;
X[dep][y][x]=0;
}
}
}
int main(){
for(int i=0;i<4;i++)
for(int j=0;j<4;j++){
cin>>G[i][j];
G[i][j]=5-G[i][j];
if(G[i][j]==5)G[i][j]=0;
sum+=G[i][j];
}
dfs(1,0);
if(sum==0)cout<<0<<endl;
else if(ans==6)cout<<-1<<endl;
else cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int SortedData[100];
int main() {
int n, k, cnt, left, right, mid;
while (cin >> n, n) {
for (int i = 0; i < n; i++) {
cin >> SortedData[i];
}
cin >> k;
left = 0;
right = n - 1;
cnt = 0;
while (1) {
++cnt;
mid = (left + right) / 2;
if (SortedData[mid] == k) {
break;
}
if (SortedData[mid] < k) {
left = mid + 1;
}
else if (SortedData[mid] > k) {
right = mid - 1;
}
if (left > right) {
break;
}
}
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ara[1000006], val[1000006], b[1000006];
bool chck(int n, int mid) {
vector<int> v1, v2;
for (int i = 0; i < n; i++) b[i] = ara[i];
for (int i = mid - 1; i >= 0; i--) {
int x = val[i], cnt = 0;
while (i >= 0 && val[i] == x) cnt++, i--;
i++;
v1.emplace_back(x);
v2.emplace_back(cnt);
}
for (int i = 0; i < v1.size(); i++) {
int cnt = v2[i];
for (int j = 0; j < n && cnt; j++)
while (b[j] >= v1[i] && cnt) b[j] -= v1[i], cnt--;
if (cnt) return 0;
}
return 1;
}
int main() {
int n, m, x;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &ara[i]);
for (int i = 0; i < m; i++) scanf("%d", &x), val[i] = (1 << (x));
sort(ara, ara + n, greater<int>()), sort(val, val + m);
int lo = 1, hi = m, res = 0;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (chck(n, mid))
res = mid, lo = mid + 1;
else
hi = mid - 1;
}
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7 + 7;
const int MXN = 1e6 + 1;
const int N = 1e3 + 1;
int a, b, second;
int main() {
cin >> a >> b >> second;
int ans = abs(a) + abs(b);
if (ans <= second) {
if (second % 2 == ans % 2)
cout << "Yes";
else
cout << "No";
} else
cout << "No";
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
bool vis[N];
vector<int> adj[N], p1, p2;
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++) {
int A, B;
scanf("%d%d",&A,&B);
adj[A].push_back(B);
adj[B].push_back(A);
}
p1.push_back(1);
vis[1] = true;
for(int i=1;;) {
bool F = false;
for(auto &T : adj[i]) {
if(!vis[T]) {
p1.push_back(T);
vis[T] = true;
F = true;
i = T;
break;
}
}
if(!F) break;
}
for(int i=1;;) {
bool F = false;
for(auto &T : adj[i]) {
if(!vis[T]) {
p2.push_back(T);
vis[T] = true;
F = true;
i = T;
break;
}
}
if(!F) break;
}
printf("%d\n",(int)(p1.size()+p2.size()));
for(int i=p1.size();i--;) {
printf("%d ",p1[i]);
}
for(int i=0;i<p2.size();i++) {
printf("%d ",p2[i]);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int X = 1e7 + 5;
int F[X];
vector<int> adj[N];
int A[N];
int leaf;
int dep[N];
void dfs(int v, int p, int d) {
dep[v] = (d & 1);
int c = 0;
for (auto u : adj[v]) {
if (u == p) continue;
dfs(u, v, d + 1);
c++;
}
if (c == 0) leaf = (d & 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
adj[p].push_back(i), adj[i].push_back(p);
}
dfs(1, 0, 0);
int ans = 0;
int leafCount = 0;
for (int i = 1; i <= n; i++) {
if (dep[i] == leaf) {
leafCount++;
ans ^= A[i];
} else {
F[A[i]]++;
}
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
if (dep[i] == leaf) {
if ((ans ^ A[i]) < X) cnt += F[ans ^ A[i]];
}
}
if (ans == 0) {
cnt += (leafCount * 1LL * (leafCount - 1)) >> 1;
cnt += ((n - leafCount) * 1LL * (n - leafCount - 1)) >> 1;
}
cout << cnt << "\n";
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
typedef pair<string, int> P;
void solve()
{
int n;
bool flag = false;
while(cin >> n, n)
{
if(flag)
{
cout << endl;
}
flag = true;
vector<P> data(n);
int temp[3];
for(int i = 0; i < n; ++i)
{
cin >> data[i].first >> temp[0] >> temp[1] >> temp[2];
data[i].second = temp[0] * 3 + temp[2];
}
for(int i = 0; i < n; ++i)
{
for(int j = n - 1; j > i; --j)
{
if(data[j].second > data[j - 1].second)
{
P a = data[j];
data[j] = data[j - 1];
data[j - 1] = a;
}
}
}
for(int i = 0; i < n; ++i)
{
cout << data[i].first << "," << data[i].second << endl;
}
}
}
int main()
{
solve();
return(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, Q;
int mn[N * 4], mx[N * 4], fl[N * 4];
set<int> SL[N], SR[N];
map<pair<int, int>, int> mp;
void pushup(int k) {
mn[k] = max(mn[k * 2], mn[k * 2 + 1]);
mx[k] = min(mx[k * 2], mx[k * 2 + 1]);
fl[k] = fl[k * 2] | fl[k * 2 + 1] | (mn[k * 2 + 1] >= mx[k * 2]);
}
void build(int k, int l, int r) {
if (l == r) {
mn[k] = 0;
mx[k] = m + 1;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void change(int k, int l, int r, int p) {
if (l == r) {
mn[k] = (SL[l].size() ? *SL[l].rbegin() : 0);
mx[k] = (SR[l].size() ? *SR[l].begin() : m + 1);
fl[k] = (mn[k] >= mx[k]);
return;
}
int mid = (l + r) / 2;
if (p <= mid)
change(k * 2, l, mid, p);
else
change(k * 2 + 1, mid + 1, r, p);
pushup(k);
}
int main() {
scanf("%d%d%d", &n, &m, &Q);
build(1, 1, n);
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
x++;
y++;
if (mp[pair<int, int>(x, y)]) {
if (y & 1)
SL[x >> 1].erase(y >> 1);
else
SR[x >> 1].erase(y >> 1);
} else {
if (y & 1)
SL[x >> 1].insert(y >> 1);
else
SR[x >> 1].insert(y >> 1);
}
mp[pair<int, int>(x, y)] ^= 1;
change(1, 1, n, x >> 1);
puts(fl[1] ? "NO" : "YES");
}
}
| 6 |
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1e4;
const int mod=998244353;
int n,m,len,ans;
char S1[maxn+8],S2[maxn+8];
int fac[maxn+8],fact[maxn+8],f[maxn+8][maxn+8];
int read()
{
int x=0,f=1;char ch=getchar();
for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
for (;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*f;
}
int C(int n,int m){return 1ll*fac[n]*fact[m]%mod*fact[n-m]%mod;}
int power(int a,int k)
{
int sum=1;
for (;k;k>>=1,a=1ll*a*a%mod)
if (k&1)
sum=1ll*sum*a%mod;
return sum;
}
int main()
{
scanf("%s",S1+1);
scanf("%s",S2+1);
len=strlen(S1+1);
fac[0]=fact[0]=1;
for (int i=1;i<=len;i++) fac[i]=1ll*fac[i-1]*i%mod;
fact[len]=power(fac[len],mod-2);
for (int i=len-1;i;i--) fact[i]=1ll*fact[i+1]*(i+1)%mod;
for (int i=1;i<=len;i++) {if (S1[i]==S2[i]&&S1[i]=='1') n++;if (S1[i]=='1'&&S2[i]=='0') m++;}
f[0][0]=1;//for (int i=1;i<=m;i++) f[0][i]=1ll*f[0][i-1]*(m-i+1)%mod*(m-i+1)%mod;
for (int i=0;i<=n;i++)
for (int j=0;j<=m;j++)
{
if (i) f[i][j]=(f[i][j]+1ll*f[i-1][j]*(n-i+1)%mod*(m-j)%mod)%mod;
if (j) f[i][j]=(f[i][j]+1ll*f[i][j-1]*(m-j+1)%mod*(m-j+1)%mod)%mod;
}
for (int i=0;i<=n;i++)
{
//printf("%d\n",f[i][m]);
ans=(ans+1ll*f[i][m]*fac[n-i]%mod*fac[n-i]%mod*C(n+m,n-i)%mod)%mod;
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int n,l,r,t;
long long s,dis[1000005],ans;
struct node
{
long long len,num;
}q[1000005];
bool cmp(node t1,node t2)
{
return t1.len<t2.len;
}
int main()
{
scanf("%d%lld",&n,&s);
for (int i=1;i<=n; i++)
scanf("%lld%lld",&q[i].len,&q[i].num);
sort(q+1,q+1+n,cmp);
l=1,r=n,t=2;
while (q[l].len<s && q[r].len>s)
{
if (q[l].num<q[r].num) q[r].num+=q[l].num,dis[r]+=dis[l]+((t!=0)?(q[r].len-q[l].len):0),t=0,l++;
else q[l].num+=q[r].num,dis[l]+=dis[r]+((t!=1)?(q[r].len-q[l].len):0),t=1,r--;
}
if (q[l].len>s) ans=dis[r]+q[r].len-s;else ans=dis[l]+s-q[l].len;
printf("%lld\n",ans);
return 0;
} | 0 |
#include<bits//stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
cout<<min(a+b,min(b+c,a+c));
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * f;
}
const int maxn = 5e5 + 5;
stack<int> s;
long long a[maxn];
long long n, ans, x, y, tot;
void init() {
n = read();
for (int i(1); i <= n; ++i) {
a[i] = read();
while (s.size() >= 2) {
x = s.top(), s.pop(), y = s.top();
if (y >= x && x <= a[i])
ans += min(a[i], y);
else {
s.push(x);
break;
}
}
s.push(a[i]);
}
}
signed main() {
init();
while (!s.empty()) a[++tot] = s.top(), s.pop();
sort(a + 1, a + 1 + tot);
for (int i(1); i < tot - 1; ++i) ans += a[i];
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if ((m >= n) && (k >= n)) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int32 N, M;
cin >> N >> M;
vector<double> a(N);
vector<double> sum(N+1, 0);
REP(i, N)
cin >> a[i];
REP(i, N){
sum[i+1] = sum[i]+a[i];
}
vector<vector<vector<long double>>> dp(2, vector<vector<long double>>(510, vector<long double>(510, -INF_LL)));
dp[0][0][0] = 0;
REP(i, N){
dp[1] = vector<vector<long double>>(510, vector<long double>(510, -INF_LL));
REP(j, M+1){
REP(k, i+1){
chmax(dp[1][j][k], dp[0][j][k]);
chmax(dp[1][j+1][i+1], dp[0][j][k]+(sum[i+1]-sum[k])/(i-k+1));
}
}
swap(dp[0], dp[1]);
}
cout << fixed << setprecision(10) << dp[0][M][N] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct edge {
int u, v, next;
} edge[maxn * 2];
int head[maxn], cnt;
int n, m, q;
vector<int> person[maxn][20];
vector<int> city[maxn];
void addedge(int u, int v) {
edge[cnt].u = u;
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
int deep[maxn], ances[maxn][20];
void update(vector<int>& a, vector<int>& b) {
for (int i = 0; i < b.size(); i++) a.push_back(b[i]);
sort(a.begin(), a.end());
while (a.size() > 10) a.pop_back();
}
void dfs(int u) {
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (!deep[v]) {
deep[v] = deep[u] + 1;
ances[v][0] = u;
update(person[v][0], city[v]);
dfs(v);
}
}
}
void init() {
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i <= n; i++) {
if (ances[i][j - 1] != -1) {
update(person[i][j], person[i][j - 1]);
update(person[i][j], person[ances[i][j - 1]][j - 1]);
ances[i][j] = ances[ances[i][j - 1]][j - 1];
}
}
}
}
vector<int> S;
int lca(int a, int b) {
if (deep[a] < deep[b]) swap(a, b);
int i, j;
for (i = 0; (1 << i) <= deep[a]; i++)
;
i--;
for (j = i; j >= 0; j--) {
if (deep[a] - (1 << j) >= deep[b]) {
update(S, person[a][j]);
a = ances[a][j];
}
}
if (a == b) return a;
for (j = i; j >= 0; j--) {
if (ances[a][j] != -1 && ances[a][j] != ances[b][j]) {
update(S, person[a][j]);
update(S, person[b][j]);
a = ances[a][j];
b = ances[b][j];
}
}
update(S, person[a][0]);
update(S, person[b][0]);
return ances[a][0];
}
int main() {
memset(head, -1, sizeof(head));
memset(ances, -1, sizeof(ances));
cnt = 0;
scanf("%d%d%d", &n, &m, &q);
int u, v, a;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
for (int i = 1; i <= m; i++) {
int c;
scanf("%d", &c);
city[c].push_back(i);
}
vector<int> emp;
for (int i = 1; i <= m; i++) {
update(city[i], emp);
}
deep[1] = 1;
dfs(1);
init();
while (q--) {
scanf("%d%d%d", &u, &v, &a);
S.clear();
int lc = lca(u, v);
update(S, city[lc]);
int k = S.size() > a ? a : S.size();
printf("%d ", k);
for (int i = 0; i < k; i++) {
printf("%d ", S[i]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <algorithm>
#include <bitset>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main()
{
const auto primes = [] {
bitset<1000000 + 1> b;
auto t = b;
t.set();
t[0] = false;
t[1] = false;
int i = 0;
while (true) {
bool done = false;
while (!t[i]) {
++i;
if (i == t.size()) {
done = true;
break;
}
}
if (done) {
break;
}
b[i] = true;
for (int j = i; j < t.size(); j += i) {
t[j] = false;
}
}
return b;
}();
while (true) {
int a, b;
cin >> a >> b;
if (a == 0 && b == 0) {
return 0;
}
auto f = [&primes](int x) {
vector<int> r;
int j = 2;
while (true) {
while (!primes[j]) {
++j;
}
if (x == 1) {
break;
}
if (x % j == 0) {
r.push_back(j);
x /= j;
}
else {
j += 1;
}
}
r.erase(unique(begin(r), end(r)), end(r));
return r;
};
auto pa = f(a);
auto pb = f(b);
auto g = [](const vector<int>& v) {
auto s = accumulate(begin(v), --end(v), 0);
return v.back() - s;
};
if (g(pa) > g(pb)) {
cout << "a" << endl;
}
else {
cout << "b" << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const long long INF = (long long)(inf)*inf;
const long long mod = 1000000000 + 7;
const int maxn = 100000 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t, n;
string s;
cin >> t;
while (t--) {
cin >> n;
cin >> s;
int maxcount = 0, cnt = 0;
int i = 0;
while (i < n && s[i] == 'P') i++;
for (; i < n; i++) {
if (s[i] == 'A') {
cnt = 0;
} else
cnt++;
maxcount = max(cnt, maxcount);
}
cout << maxcount << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool sortbysecinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
bool sortbysize(string &s1, string &s2) { return s1.size() < s2.size(); }
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortcol(const vector<int> &v1, const vector<int> &v2) {
return v1[0] < v2[0];
}
long long proceed() {
long long n;
cin >> n;
long long a[n], i;
for (i = 0; i < n; ++i) cin >> a[i];
;
long long dp[n][2];
dp[0][0] = abs(a[0] - 1);
dp[0][1] = abs(a[0] + 1);
for (i = 1; i < n; ++i) {
dp[i][0] = min(dp[i - 1][0] + abs(a[i] - 1), dp[i - 1][1] + abs(a[i] + 1));
dp[i][1] = min(dp[i - 1][0] + abs(a[i] + 1), dp[i - 1][1] + abs(a[i] - 1));
}
cout << dp[n - 1][0] << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1, i = 0;
while (t--) {
proceed();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
const long long mod = 1e9 + 7;
long long cnt[N];
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % mod;
}
a = a * a % mod;
b >>= 1;
}
return res;
}
long long calc(long long x, long long p, long long y) {
if (p == 1) {
return x;
}
long long res = 1;
for (long long i = 1; i <= y; i++) {
if (res * p >= N) {
return -1;
}
res *= p;
}
if (res * x >= N) {
return -1;
}
return res * x;
}
void solve() {
long long n, p;
cin >> n >> p;
vector<long long> vc(n), a;
for (auto &i : vc) {
cin >> i;
cnt[i]++;
}
map<long long, long long> used;
for (auto i : vc) {
if (used[i]) {
continue;
}
used[i] = 1;
a.push_back(i);
}
n = a.size();
sort(a.rbegin(), a.rend());
long long pos = 0, dif = 0;
while (pos < n) {
if (cnt[a[pos]] % 2 == 0) {
pos++;
continue;
}
long long x = a[pos], need = 1, ok = 0;
for (long long i = pos + 1; i < n; i++) {
long long new_need = calc(need, p, x - a[i]);
if (new_need == -1) {
break;
}
if (new_need <= cnt[a[i]]) {
cnt[a[i]] -= new_need;
pos = i;
ok = 1;
break;
} else {
need = new_need - cnt[a[i]];
x = a[i];
}
}
if (!ok) {
dif = binpow(p, a[pos]);
for (long long i = pos + 1; i < n; i++) {
dif -= cnt[a[i]] * binpow(p, a[i]) % mod;
if (dif < 0) {
dif += mod;
}
}
break;
}
}
cout << dif << '\n';
for (auto i : vc) {
cnt[i] = 0;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T = 1;
cin >> T;
while (T--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244853;
const int N = 2001;
int n, m, f[N][N][2], res;
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n >> m;
f[0][0][0] = f[0][0][1] = 1;
for (int k = 1; k <= n + m; k++)
for (int i = max(0, k - m); i <= min(n, k); i++) {
int j = k - i;
if (i - j < 0) {
if (i > 0) f[i][j][0] = (f[i][j][0] + f[i - 1][j][0]) % mod;
if (j > 0) f[i][j][0] = (f[i][j][0] + f[i][j - 1][0]) % mod;
} else {
if (i > 0) f[i][j][1] = (f[i][j][1] + f[i - 1][j][1]) % mod;
if (j > 0) f[i][j][1] = (f[i][j][1] + f[i][j - 1][1]) % mod;
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= min(i - 1, m); j++)
res =
(((long long)f[i][j][1] * f[n - i][m - j][0] % mod) * (i - j) + res) %
mod;
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long m = 1000 * 1000 * 1000 + 7;
int main() {
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int S = 13;
const int Full = (1 << S) - 1;
int prime[50] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97},
tot = 25;
char block[800][1 << S][25];
int mm[10010][26], to[100000];
unsigned long long all[15][15][16][200];
unsigned long long tmp[200];
int tmp2[25];
int ans[25];
int key(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
for (int j = 0; j < tot; j++) {
mm[i][j] = x % prime[j];
}
}
for (int i = 0; i < S; i++) {
to[1 << i] = i;
}
for (int i = 0; i < n; i += S) {
int s = min(S, n - i);
for (int j = 0; j < 25; j++) {
block[i / S][0][j] = 1;
}
for (int mask = 1; mask < (1 << s); mask++) {
int lowbit = mask & -mask;
for (int j = 0; j < 25; j++) {
block[i / S][mask][j] =
block[i / S][mask - lowbit][j] * mm[i + to[lowbit]][j] % prime[j];
}
}
}
for (int d = 2; d <= 16; d++) {
int pw = 1;
for (int j = 0; pw < n; j++, pw *= d) {
for (int i = 0; i < n; i++) {
int val = 0, len = 0, x = i, cnt = 0;
while (x) {
if (j == cnt) val = x % d;
x /= d, len++, cnt++;
}
all[d - 2][j][val][i / (4 * S)] |= 1ull << (i % (4 * S));
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int d;
char s[50];
long long a;
scanf("%d", &d);
scanf("%s", s), scanf("%lld", &a);
int m = strlen(s);
for (int j = 0; j < tot; j++) {
ans[j] = a % prime[j];
}
for (int j = 0; j <= ((n - 1) / (4 * S)); j++) {
tmp[j] = (1ull << 4 * S) - 1;
}
long long pw = 1;
for (int i = m - 1; i >= 0; i--) {
if (pw >= n) {
if (s[i] != '?' && s[i] != '0') {
for (int j = 0; j <= ((n - 1) / (4 * S)); j++) {
tmp[j] = 0;
}
}
continue;
}
pw *= d;
if (s[i] == '?') continue;
int val = key(s[i]);
for (int j = 0; j <= ((n - 1) / (4 * S)); j++) {
tmp[j] &= all[d - 2][m - i - 1][val][j];
}
}
int nn = m;
while (pw < n) {
for (int j = 0; j <= ((n - 1) / (4 * S)); j++) {
tmp[j] &= all[d - 2][nn][0][j];
}
pw *= d, nn++;
}
for (int k = 0; k < 25; k++) {
tmp2[k] = 1;
}
for (int j = 0; j <= ((n - 1) / (4 * S)); j++) {
int be = j * 4 * S, pp = be / S;
for (int k = 0; k < 25; k++) {
if (n - be > 0)
tmp2[k] =
tmp2[k] * block[pp][tmp[j] & ((1 << min(S, n - be)) - 1)][k];
if (n - be - S > 0)
tmp2[k] =
tmp2[k] *
block[pp + 1][tmp[j] >> S & ((1 << min(S, n - be - S)) - 1)][k];
tmp2[k] -= tmp2[k] / prime[k] * prime[k];
if (n - be - 2 * S > 0)
tmp2[k] =
tmp2[k] * block[pp + 2][tmp[j] >> 2 * S &
((1 << min(S, n - be - 2 * S)) - 1)][k];
if (n - be - 3 * S > 0)
tmp2[k] =
tmp2[k] * block[pp + 3][tmp[j] >> 3 * S &
((1 << min(S, n - be - 3 * S)) - 1)][k];
tmp2[k] -= tmp2[k] / prime[k] * prime[k];
}
}
int pos = 0;
while (pos < tot && (ans[pos] + tmp2[pos]) % prime[pos] != 0) pos++;
if (pos == tot)
printf("-1\n");
else
printf("%d\n", prime[pos]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int T, n;
int main() {
ios::sync_with_stdio(false);
cin >> T;
while (T--) {
cin >> n;
if (n == 1)
cout << "FastestFinger\n";
else if (n == 2)
cout << "Ashishgup\n";
else if (n % 2)
cout << "Ashishgup\n";
else {
long long int c = 0, s = 1, m = n;
for (long long int i = 2; i * i <= m; i++) {
while (m % i == 0) {
if (i % 2) c++, s *= i;
m /= i;
}
}
if (m != 1) {
if (m % 2) c++, s *= m;
}
if (c == 0)
cout << "FastestFinger\n";
else if (n / s == 2) {
if (c == 1)
cout << "FastestFinger\n";
else
cout << "Ashishgup\n";
} else
cout << "Ashishgup\n";
;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> E[555555], W[555555];
vector<long long> G[555555];
int T, N, K, A[555555];
long long F[555555][2];
void dfs(int x, int f) {
F[x][1] = 0;
F[x][0] = 0;
int cnt = E[x].size();
for (int i = 0; i < cnt; i++) {
int nx = E[x][i];
if (nx != f) {
dfs(nx, x);
int w = W[x][i];
G[x].push_back(w + F[nx][1] - F[nx][0]);
F[x][0] += F[nx][0];
F[x][1] += F[nx][0];
}
}
if (f) {
cnt--;
}
sort(G[x].begin(), G[x].end());
for (int i = cnt - 1; i >= 0 && cnt - i < K; i--) {
if (G[x][i] > 0) {
F[x][1] += G[x][i];
}
}
for (int i = cnt - 1; i >= 0 && cnt - i <= K; i--) {
if (G[x][i] > 0) {
F[x][0] += G[x][i];
}
}
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &N, &K);
for (int i = 1; i < N; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
E[u].push_back(v);
E[v].push_back(u);
W[u].push_back(w);
W[v].push_back(w);
}
dfs(1, 0);
printf("%lld\n", F[1][0]);
for (int i = 1; i <= N; i++) {
E[i].resize(0);
W[i].resize(0);
G[i].resize(0);
}
}
return 0;
}
| 3 |
#include<iostream>
#include<sstream>
using namespace std;
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
int main()
{
int m;
cin>>m;
for(;m--;)
{
long long int money;
cin>>money;
int year;
cin>>year;
int n;
cin>>n;
long long int ans=0;
for(;n--;)
{
int a,c;
double b;
long long int tmp=money;
cin>>a>>b>>c;
if(a==0)
{
int risi=0;
for(int i=0;i<year;i++)
{
risi+=tmp*b;
tmp-=c;
}
ans=max(ans,risi+tmp);
}
else
{
for(int i=0;i<year;i++)
{
tmp+=tmp*b;
tmp-=c;
}
ans=max(ans,tmp);
}
}
cout<<ans<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int *compute_lps(vector<int> &pat);
int search_kmp(vector<int> &txt, vector<int> &pat, int *lps);
int main() {
int n, m;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
vector<int> txt, pat;
if (m == 1) {
cout << n << endl;
return 0;
}
for (int i = 0; i < n - 1; i++) txt.push_back(a[i] - a[i + 1]);
for (int i = 0; i < m - 1; i++) pat.push_back(b[i] - b[i + 1]);
int *lps = compute_lps(pat);
int cnt = search_kmp(txt, pat, lps);
cout << cnt << endl;
return 0;
}
int *compute_lps(vector<int> &pat) {
int m = (int)pat.size();
int *lps = (int *)malloc(sizeof(int) * m);
;
lps[0] = 0;
int j = 0;
for (int i = 1; i < m; i++) {
while (j > 0 && pat[i] != pat[j]) j = lps[j - 1];
if (pat[i] == pat[j]) j++;
lps[i] = j;
}
return lps;
}
int search_kmp(vector<int> &txt, vector<int> &pat, int *lps) {
int n = (int)txt.size();
int m = (int)pat.size();
int cnt = 0, i = 0, j = 0;
while (i < n) {
if (txt[i] == pat[j]) {
i++;
j++;
}
if (j == m) {
cnt++;
j = lps[j - 1];
}
if (txt[i] != pat[j]) {
if (j != 0)
j = lps[j - 1];
else
i++;
}
}
return cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[100000];
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n - 1; i++) cout << arr[i] + arr[i + 1] << " ";
cout << arr[n - 1] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string ans, sr;
multiset<string> s;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
getchar();
string str, rstr;
for (int j = 0; j < m; j++) {
char c = getchar();
str.push_back(c);
rstr.push_back(c);
}
reverse(rstr.begin(), rstr.end());
if (!s.count(rstr))
s.insert(str);
else {
for (int i = 0; i < str.size(); i++) ans.push_back(str[i]);
s.erase(rstr);
}
}
for (auto i : s) {
string j = i;
reverse(j.begin(), j.end());
if (i == j) {
for (int k = 0; k < i.size(); k++) sr.push_back(i[k]);
break;
}
}
printf("%ld\n", ans.size() * 2 + sr.size());
for (int i = 0; i < ans.size(); i++) printf("%c", ans[i]);
for (int i = 0; i < sr.size(); i++) printf("%c", sr[i]);
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) printf("%c", ans[i]);
printf("\n");
}
| 2 |
#include <iostream>
#include <vector>
using namespace std;
int N, K, tmp;
void solve() {
vector<int> bloods(K), family(K);
for (int i = 0; i < K; i += 1) cin>>bloods[i];
for (int i = 0; i < N; i += 1) {
for (int j = 0; j < K; j += 1) {
cin>>tmp;
family[j]+=tmp;
}
}
// calc
for (int i = 0; i < K; i += 1) {
if (family[i] > bloods[i]) {
cout<<"No"<<endl;
return;
}
}
cout<<"Yes"<<endl;
}
int main(int argc, char const* argv[]) {
while (true) {
cin>>N>>K;
if (N==0 && K==0) break;
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int main() {
string s;
cin >> s;
int k;
int n = s.size();
cin >> k;
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; i + 2 * j - 1 < n + k; j++) {
bool flag = 1;
for (int u = 0; u < j && i + j + u < n; u++) {
if (s[u + i] != s[i + j + u]) {
flag = 0;
break;
}
}
if (flag == 1) {
res = max(j, res);
}
}
}
cout << 2 * res << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> v(m);
for (int i = 0; i < m; i++) {
cin >> v[i];
}
int aq = 1;
long long ans = 0;
for (int i = 0; i < m; i++) {
if (v[i] == aq) continue;
if (v[i] < aq) {
ans += n - aq + v[i];
aq = v[i];
} else {
ans += v[i] - aq;
aq = v[i];
}
}
cout << ans * 1LL << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
enum { MAXN = 550, INF = 2000000000 };
int sum[MAXN][MAXN];
int sumSpiral[MAXN][MAXN];
int field[MAXN][MAXN];
int ans = -INF;
int getSum(int x1, int y1, int x2, int y2) {
int val =
sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
return val;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> field[i][j];
sumSpiral[i][j] = -INF;
sum[i][j] =
sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + field[i][j];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i + 2 > n or j + 2 > m) continue;
int initSum =
getSum(i, j, i + 2, j + 2) - field[i + 1][j] - field[i + 1][j + 1];
sumSpiral[i][j] = max(sumSpiral[i][j], initSum);
int x1, y1, x2, y2, sum;
sum = initSum;
x1 = i, x2 = i + 2, y1 = j, y2 = j + 2;
for (;;) {
sum = getSum(x1, y1, x2, y2) - sum;
x1--;
y1--;
x2++;
y2++;
if (x1 < 1 or y1 < 1 or x2 > n or y2 > m) break;
sum += getSum(x1, y1, x2, y1) + getSum(x1, y2, x2, y2) +
getSum(x1, y1, x1, y2) + getSum(x2, y1, x2, y2);
sum -= field[x1 + 1][y1] + field[x1][y1] + field[x1][y2] +
field[x2][y1] + field[x2][y2];
sumSpiral[x1][y1] = max(sumSpiral[x1][y1], sum);
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) ans = max(ans, sumSpiral[i][j]);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n = 3000;
bool arr[3002];
int ar[3002];
void prime() {
for (int i = 2; i < n; i += 2) {
arr[i] = 1;
}
arr[2] = 0;
for (int j = 3; j * j < n; j++) {
if (!arr[j])
for (int i = j * j; i < n; i += j) arr[i] = 1;
}
}
void getall(int x) {
ar[6] = 1;
for (int i = 7; i <= x; i++) {
int cntr = 0;
for (int j = 2; j <= i / 2; j++) {
if (!arr[j] && !(i % j)) cntr++;
}
if (cntr == 2) {
ar[i] = ar[i - 1] + 1;
} else
ar[i] = ar[i - 1];
}
}
set<long long> st;
void get(long long s, long long c, int c4, int c7) {
if (s > 4444477777) return;
if ((c4 + c7) % 2 == 0 && c4 == c7) st.insert(s);
if (c4 < 5) get(s + 4 * c, c * 10, c4 + 1, c7);
if (c7 < 5) get(s + 7 * c, c * 10, c4, c7 + 1);
}
int main() {
get(0, 1, 0, 0);
set<long long>::iterator it = st.begin();
long long x;
scanf("%lld", &x);
while (it != st.end() && (*it) < x) {
it++;
}
cout << (*it);
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.