solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long INF = 1e7;
double EPS = 1e-12;
double tick() {
static clock_t oldt;
clock_t newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
long long int powP(long long int a, long long int b) {
if (b == 0) return 1 % mod;
long long int k;
k = powP(a, b / 2);
k = k * k % mod;
if (b % 2 == 0)
return k;
else
return a * k % mod;
}
bool bitSet(long long int n, long long int i) {
if ((n & (1LL << i)) != 0)
return true;
else
return false;
}
long long int findGcd(long long int a, long long int b) {
if (a == 0)
return b;
else
return findGcd(b % a, a);
}
string S[300010];
long long int A[300010], B[300010], C[300010];
map<string, vector<long long int> > M;
bool dp[503][503];
long long int Next[503][503], Reduce[503][503], Total[503][503];
int main() {
long long int T, i, p, j, l, n, e, r, b, c, k, m, q, a, d, w, x, y, u, v, z,
t, curr, prev, sum, ans, pos, val, countA, indicator;
scanf("%lld", &n);
for (long long int i = (1); i <= (n); ++i) {
cin >> S[i];
A[i] = S[i].size();
A[i] += A[i - 1];
M[S[i]].push_back(i);
}
for (const auto& i : M) {
for (const auto& a : i.second) {
for (const auto& b : i.second) {
dp[a][b] = dp[b][a] = true;
}
}
}
for (long long int i = (1); i <= (n); ++i)
for (long long int j = (i + 1); j <= (n); ++j) {
curr = 0;
while (i + curr < j and j + curr <= n and dp[i + curr][j + curr]) {
curr++;
if (Next[i][curr] == 0) {
Next[i][curr] = j;
Reduce[i][curr] = (A[i + curr - 1] - A[i - 1] + curr - 1) - curr;
}
}
}
ans = 0;
for (long long int i = (n); i >= (1); --i)
for (long long int curr = (1); curr <= (n); ++curr) {
if (Next[i][curr] == 0) continue;
Total[i][curr] += 1 + Total[Next[i][curr]][curr];
ans = max(ans, (1 + Total[i][curr]) * Reduce[i][curr]);
}
printf("%lld\n", A[n] + n - 1 - ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[10000011], T[10000011], S[5][10000011], t[10000011];
int P[10000011], Len, L[10000011], len, nxt[10000011], cnt, K;
void Lyndon() {
for (int i = 1; i <= len;) {
int j = i, k = i + 1;
while (k <= len && s[k] >= s[j]) {
if (s[k] > s[j])
j = i;
else
j++;
k++;
}
P[++cnt] = i;
L[cnt] = k - j;
while (i <= j) {
i += (k - j);
}
}
}
void solve1(int n) {
for (int i = 1; i <= n; i++) S[1][i] = s[n - i + 1];
}
void solve2(int n) {
int p = 1;
for (int i = 1; i <= n; i++) t[i] = t[n + i] = s[i];
for (int i = 1, j = 2, k = 0; i <= n && j <= n;) {
j = max(j, i + 1);
while (t[i + k] == t[j + k] && k < n) k++;
if (k == n) {
p = i;
break;
}
if (t[i + k] > t[j + k])
i = i + k + 1;
else
j = j + k + 1;
p = i;
k = 0;
}
for (int i = 1; i <= n; i++) S[2][i] = t[p + i - 1];
}
void solve3(int n) {
nxt[1] = n;
int p = 0, maxx = 0;
for (int i = 1; i <= n; i++) t[i + n] = s[n - i + 1];
for (int i = 2; i <= n * 2; i++) {
if (i < maxx) nxt[i] = min(maxx - i, nxt[i - p + 1]);
while (i + nxt[i] <= n * 2 && t[i + nxt[i]] == t[1 + nxt[i]]) nxt[i]++;
if (i + nxt[i] > maxx) maxx = i + nxt[i], p = i;
}
p = 1;
for (int i = 2; i < n; i++) {
int t1 = nxt[n + n + 1 - i];
if (t1 != i - p) {
if (t[n + n - i + 1 + t1] > t[t1 + 1]) p = i;
} else {
t1 = nxt[i - p + 1];
if (t[t1 + 1] > t[i - p + t1 + 1]) p = i;
}
}
for (int i = 1; i <= n - p; i++) S[3][i] = s[n - i + 1];
for (int i = 1; i <= p; i++) S[3][n - p + i] = s[i];
}
void solve4(int n) {
int p = cnt;
while ((P[p + 1] - P[p]) * 2 <= (P[p] - P[p - 1])) {
int flag = 0;
for (int i = P[p] - 1; i >= P[p - 1]; i--) {
if (s[i] < s[n - i + P[p - 1]]) {
flag = 1;
break;
}
if (s[i] > s[n - i + P[p - 1]]) break;
}
if (flag) break;
p--;
}
for (int i = 1; i <= n - P[p] + 1; i++) S[4][i] = s[P[p] + i - 1];
for (int i = 1; i < P[p]; i++) S[4][i + n - P[p] + 1] = s[P[p] - i];
}
void solve(int n) {
solve1(n);
solve2(n);
solve3(n);
solve4(n);
int p = 1;
for (int i = 2; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
if (S[i][j] == S[p][j])
continue;
else {
if (S[i][j] < S[p][j]) p = i;
break;
}
}
}
printf("%s", T + 1);
printf("%s", S[p] + 1);
}
void Extend(int l, int r) {
for (int i = l; i <= r; i++) T[++Len] = s[i];
}
void solve0(int n) {
for (int i = 1; i <= n; i++) {
S[1][i] = s[i];
S[2][i] = s[n - i + 1];
}
int p = 1;
for (int i = 1; i <= n; i++) {
if (S[2][i] < S[1][i])
p = 2;
else if (S[2][i] > S[1][i])
break;
}
for (int i = 1; i <= n; i++) printf("%c", S[p][i]);
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
scanf("%d", &K);
if (K == 1) {
solve0(len);
return 0;
}
for (int i = 1; i < len - i + 1; i++) {
swap(s[i], s[len - i + 1]);
}
Lyndon();
P[cnt + 1] = len + 1;
while (cnt && K >= 3) {
Extend(P[cnt], P[cnt + 1] - 1);
if (L[cnt] != 1 || L[cnt - 1] != 1) K--;
cnt--;
}
if (cnt) {
solve(P[cnt + 1] - 1);
} else {
for (int i = 1; i <= Len; i++) printf("%c", T[i]);
}
return 0;
}
| 5 |
#include<iostream>
#include<cstdio>
#define MAX_N 10000
using namespace std;
const int INF = 1 << 30;
int dp[2][MAX_N / 2 + 1][2];
int main() {
int n, ans = INF, t[MAX_N + 1] = {};
scanf("%d", &n);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n / 2 + 1; j++) {
fill(dp[i][j], dp[i][j] + 2, INF);
}
}
for (int i = 0; i < n - 1; i++) {
scanf("%d", &t[i]);
}
dp[1][1][1] = t[0];
for (int i = 1; i < n ; i++) {
for (int j = 0; j < n / 2 + 1; j++) {
for (int k = 0; k < 2; k++) {
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = INF;
}
}
for (int j = 0; j < n / 2; j++) {
if (j > i) break;
dp[1][j + 1][0] = min(dp[0][j + 1][1], dp[0][j + 1][0]);
dp[1][j + 1][1] = min(dp[1][j + 1][1], min(dp[0][j][1] + t[i] - t[i - 1], dp[0][j][0] + t[i] + t[i - 1]));
}
ans = min(ans, min(dp[1][n / 2][0], dp[1][n/2][1]));
}
printf("%d\n", ans);
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int n; ll c[60][60];
ll f[60][120];
int main()
{
c[0][0] = 1;
for(int i = 0; i < 60; ++i)
{
c[i][0] = 1;
for(int j = 1; j <= i; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
scanf("%d", &n);
f[1][n] = f[1][n - 1] = 1;
for(int i = 1; i <= n; ++i)
for(int j = -i; j <= i; ++j)
{
if(f[i][j + n] == 0) continue;
for(int a = 0; a <= n; ++a)
for(int b = 0; b <= n; ++b)
if(a + b > 0 && i + a + b <= n && (j + a - b) % 2 == 0 && abs(j) <= a + b)
(f[i + a + b][(j + a - b) / 2 + n] += f[i][j + n] * c[i + a + b][a + b] % MOD * c[a + b][a] % MOD) %= MOD;
}
printf("%lld\n", f[n][n]);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
long long t,a[1000020],k,l;
int main(){
cin>>t;
for(long long i=1;i<10;i++){
a[k++]=i;
}
while(1){
long long x=a[l],o=x%10;
l++;
if(o!=0)a[k++]=x*10+o-1;
a[k++]=x*10+o;
if(o!=9)a[k++]=x*10+o+1;
if(k>=t){
cout<<a[t-1]<<endl;break;
}
}
return 0;
}
/* SO EASY UH */ | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int Int;
Int ans[10];
int main(void)
{
map<pair<int,int>,int> m;
Int h,w,n;
cin>>h>>w>>n;
for(int i = 0;i < n;i++)
{
int a,b;
cin>>a>>b;
a--;
b--;
int dx[9] = {-2,-1,0,-2,-1,0,-2,-1,0};
int dy[9] = {-2,-2,-2,-1,-1,-1,0,0,0};
for(int s = 0;s < 9;s++)
{
if(a+dx[s] < 0 || b+dy[s] < 0 || a+dx[s] > h-3 || b+dy[s] > w - 3)
continue;
pair<int,int> p;
p.first = a+dx[s];
p.second = b+dy[s];
m[p]++;
}
}
for(map<pair<int,int>,int>::iterator it = m.begin();it != m.end();it++)
{
ans[it->second]++;
}
ans[0] = (h-2)*(w-2) - m.size();
for(int i = 0;i < 10;i++)
cout<<ans[i]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long ara[300000], m, n, x, y, z;
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> ara[i];
long long prvoff = -1;
for (long long i = 1; i <= n; i++) {
if (prvoff == -1) {
long long tmp = ara[i];
tmp = tmp % 2;
if (tmp == 0) continue;
prvoff = 1;
} else {
if (ara[i] == 0) {
cout << "NO" << endl;
return 0;
}
long long tmp = ara[i] - 1;
tmp = tmp % 2;
if (tmp == 1) continue;
prvoff = -1;
}
}
if (prvoff == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const int mod = 998244353;
const int inf = 1 << 30;
const int maxn = 200000 + 5;
int n, k, a[maxn];
ll pre[maxn], suf[maxn];
int main() {
scanf("%d%d", &n, &k);
map<int, int> cnt;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
cnt[a[i]]++;
}
for (auto& x : cnt) {
if (x.second >= k) {
puts("0");
return 0;
}
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
pre[i] = a[i] + pre[i - 1];
}
for (int i = n; i >= 1; i--) {
suf[i] = suf[i + 1] + a[i];
}
auto qL = [&](int x) {
int k = upper_bound(a + 1, a + 1 + n, x) - a - 1;
return make_pair(k, 1ll * k * x - pre[k]);
};
auto qR = [&](int x) {
int k = lower_bound(a + 1, a + 1 + n, x) - a;
return make_pair(n - k + 1, suf[k] - 1ll * x * (n - k + 1));
};
ll ans = 1e18;
for (auto& x : cnt) {
auto a = qL(x.first - 1);
auto b = qR(x.first + 1);
if (a.first + x.second >= k) {
ans = min(ans, a.second + k - x.second);
}
if (b.first + x.second >= k) {
ans = min(ans, b.second + k - x.second);
}
ans = min(ans, a.second + b.second + k - x.second);
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int fin(string s, int i1) {
int mi = 999999999;
for (int d = 1; d <= 9; d++) {
for (int i = i1; i < i1 + 10; i++) {
if (i + 2 * d < s.length()) {
if (s[i] == s[i + d] && s[i] == s[i + 2 * d]) {
mi = min(mi, i + 2 * d);
}
}
}
}
return mi;
}
int main() {
string s;
cin >> s;
long long n = s.length();
long long ans = 0;
for (int i = 0; i < n; i++) {
int p = fin(s, i);
if (n > p) {
ans = ans + n - p;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool dbg = 0;
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
void amax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void amin(T& x, T y) {
x = min(x, y);
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 2e9 + 20;
const long double eps = 1e-12;
const int maxn = 1e5 + 12, base = 1e9 + 7;
const long long llinf = 4e18 + 5;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % base;
} else {
return (1LL * binpow(n, second - 1) * n) % base;
}
}
int a[maxn];
int tree[4 * maxn];
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr)
tree[v] = val;
else {
int m = (tl + tr) >> 1;
if (pos <= m)
update(v << 1, tl, m, pos, val);
else
update(v << 1 | 1, m + 1, tr, pos, val);
tree[v] = min(tree[v << 1], tree[v << 1 | 1]);
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l > r) return inf;
if (tl == l && tr == r) return tree[v];
int m = (tl + tr) >> 1;
return min(get(v << 1, tl, m, l, min(r, m)),
get(v << 1 | 1, m + 1, tr, max(l, m + 1), r));
}
multiset<int> st;
int cur() {
if (st.empty()) return -1;
return *st.rbegin() - *st.begin();
}
int main() {
int n, second, l;
read(n, second, l);
for (int i = 0; i < n; i++) {
read(a[i]);
}
if (l > n) bad(-1);
for (int i = 0; i + 1 < l; i++) {
st.insert(a[i]);
update(1, 0, n - 1, i, inf);
}
if (cur() > second) bad(-1);
int L = 0;
for (int i = l - 1; i < n; i++) {
st.insert(a[i]);
while (cur() > second) {
st.erase(st.find(a[L]));
L++;
}
if (i - l < L - 1) {
update(1, 0, n - 1, i, inf);
continue;
}
if (L == 0) {
update(1, 0, n - 1, i, 1);
continue;
}
int cur = get(1, 0, n - 1, L - 1, i - l) + 1;
update(1, 0, n - 1, i, cur);
}
int ans = get(1, 0, n - 1, n - 1, n - 1);
if (ans == inf) ans = -1;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long MAX = 10000000000;
using namespace std;
long long pw(long a, int n) {
long long res = 1;
for (int i = 0; i < n; i++) {
res *= a;
if (res > MAX) return res;
}
return res;
}
int main() {
long p, n, d, t, k, count, q;
long long res = 0;
cin >> n >> k;
vector<pair<long, long> > a;
vector<pair<long, long> > b;
map<vector<pair<long, long> >, long>::iterator it;
map<vector<pair<long, long> >, long> myMap;
for (int i = 0; i < n; i++) {
a.clear();
b.clear();
cin >> t;
p = 2;
while (t != 1) {
while (t % p != 0 && p <= sqrt(t)) p++;
if (p > sqrt(t)) {
a.insert(a.cend(), make_pair(t, 1));
t = 1;
break;
}
count = 0;
while (t % p == 0) {
count++;
t /= p;
}
count %= k;
if (count != 0) a.insert(a.cend(), make_pair(p, count));
p++;
}
for (auto f : a) b.insert(b.cend(), make_pair(f.first, k - f.second));
it = myMap.find(b);
if (it != myMap.cend()) res += it->second;
myMap[a]++;
}
cout << res << endl;
return 0;
}
| 4 |
#include <iostream>
int main(){
int a,p;
std::cin>>a>>p;
std::cout << (a*3+p)/2 << '\n';
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string a;
cin>>a;
if(int(a.find('C'))!=-1 and int(a.rfind('F'))!=-1&&a.find('C')<a.rfind('F'))//个人码风问题，习惯用and而不是&&
cout<<"Yes";
else
cout<<"No";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') f = ch == '-' ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
const int MAXN = 100010, MAXM = 200010;
const long long mod = 1e9 + 7;
long long a[MAXN];
int h[MAXN], tot = 0;
long long res = 0;
map<long long, int> num[MAXN];
struct edge {
int v, nxt;
} e[MAXM];
void add_edge(int x, int y) {
tot++;
e[tot].v = y;
e[tot].nxt = h[x];
h[x] = tot;
}
long long gcd(long long a, long long b) {
return (b == 0LL) ? a : gcd(b, a % b);
}
void dfs(int u, int pre) {
for (int x = h[u]; x; x = e[x].nxt) {
int v = e[x].v;
if (v == pre) continue;
for (auto kv : num[u]) num[v][gcd(kv.first, a[v])] += kv.second;
dfs(v, u);
}
for (auto kv : num[u]) res = (res + kv.first * kv.second % mod) % mod;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n = read();
for (int i = (1); i <= (n); i += (1)) num[i][a[i] = read()]++;
for (int _ = (1); _ <= (n - 1); _ += (1)) {
int u = read(), v = read();
add_edge(u, v), add_edge(v, u);
}
dfs(1, -1);
printf("%lld\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 17;
int f(int m, int n, int d) { return m + ceil(double(d) / double(m + 1)); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int l = 0, r = 0;
for (auto cur : s) (cur == 'L') ? l++ : r++;
l *= -1;
cout << (r - l + 1);
}
| 1 |
#include <bits/stdc++.h>
int main() {
int a, b, c = 0, d = 0, e, f;
scanf("%d", &a);
char s[a + 1];
scanf("%s", &s);
for (b = 0; b < a - 1; b++) {
if (s[b] == 'F' && s[b + 1] == 'S') {
c++;
}
if (s[b] == 'S' && s[b + 1] == 'F') {
d++;
}
}
if (d > c) {
printf("YES\n");
} else {
printf("NO\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void NO () {
cout << "No";
exit (0);
}
void YES (string ans) {
cout << "Yes\n" << ans;
exit (0);
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int n, sum = 0, askiiA = 'A';
cin >> n;
vector <string> a(n);
int c[3+askiiA];
for (int i=askiiA; i<3+askiiA; i++) {
cin >> c[i];
sum += c[i];
}
if (!sum) NO();
for (int i=0; i<n; i++) {
cin >> a[i];
}
string ans = "";
for (int i=0; i<n; i++) {
string cur = a[i];
if (!c[cur[0]] && !c[cur[1]]) NO();
if (i == n-1) {
if (c[cur[0]]) {
ans += cur[1];
} else {
ans += cur[0];
}
break;
}
if (!c[cur[0]] && c[cur[1]]) {
ans += cur[0];
c[cur[0]] ++;
c[cur[1]] --;
} else if (c[cur[0]] && !c[cur[1]]) {
ans += cur[1];
c[cur[1]] ++;
c[cur[0]] --;
} else {
string next = a[i+1];
if (next[0] == cur[0] || next[1] == cur[0]) {
ans += cur[0];
c[cur[0]] ++;
c[cur[1]] --;
} else {
ans += cur[1];
c[cur[1]] ++;
c[cur[0]] --;
}
}
ans += "\n";
}
YES(ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
sort(S.begin(), S.end());
if (S.at(0)==S.at(1) && S.at(2)==S.at(3) && S.at(0)!=S.at(2)) cout << "Yes\n";
else cout << "No\n";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const long long L = 1e9;
map<long long, pair<long long, long long> > mp;
int a[MAXN], b[MAXN], c[MAXN];
int n, nn;
long long ans, ans1, ans2;
void dfs1(int cur, long long t, long long x, long long y, long long z) {
if (cur == nn + 1) {
long long tmp = (y - x) * L + (z - y);
if (mp.count(tmp))
mp[tmp] = max(make_pair(x, t), mp[tmp]);
else
mp[tmp] = make_pair(x, t);
return;
}
dfs1(cur + 1, t * 3 + 0, x + a[cur], y + b[cur], z);
dfs1(cur + 1, t * 3 + 1, x + a[cur], y, z + c[cur]);
dfs1(cur + 1, t * 3 + 2, x, y + b[cur], z + c[cur]);
}
void dfs2(int cur, long long t, long long x, long long y, long long z) {
if (cur == n + 1) {
long long tmp = (x - y) * L + (y - z);
if (mp.count(tmp)) {
pair<long long, long long> A = mp[tmp];
if (A.first + x > ans) {
ans = A.first + x;
ans1 = A.second;
ans2 = t;
}
}
return;
}
dfs2(cur + 1, t * 3 + 0, x + a[cur], y + b[cur], z);
dfs2(cur + 1, t * 3 + 1, x + a[cur], y, z + c[cur]);
dfs2(cur + 1, t * 3 + 2, x, y + b[cur], z + c[cur]);
}
void print(long long x, int n) {
if (n > 1) print(x / 3, n - 1);
long long tmp = x % 3;
if (tmp == 0) printf("LM\n");
if (tmp == 1) printf("LW\n");
if (tmp == 2) printf("MW\n");
}
void solve() {
ans = -L;
mp.clear();
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
if (n == 1) {
if (!a[1] && !b[1])
printf("LM\n");
else if (!a[1] && !c[1])
printf("LW\n");
else if (!b[1] && !c[1])
printf("MW\n");
else
printf("Impossible\n");
return;
}
nn = n / 2;
dfs1(1, 0, 0, 0, 0);
dfs2(nn + 1, 0, 0, 0, 0);
if (ans == -L) {
printf("Impossible\n");
return;
}
print(ans1, nn);
print(ans2, n - nn);
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
template <typename T, typename Add = std::plus<T>,
typename Mul = std::multiplies<T>>
struct Matrix {
std::vector<std::vector<T>> D;
Matrix(size_t m, size_t n) {
D.resize(m);
for (size_t i = 0; i < m; ++i) {
D[i].resize(n);
}
}
size_t m() const { return D.size(); }
size_t n() const { return m() == 0 ? 0 : D[0].size(); }
std::vector<T>& operator[](int i) { return D[i]; }
Matrix<T, Add, Mul> operator*(const Matrix<T, Add, Mul>& that) const {
assert(n() == that.m());
Matrix<T, Add, Mul> r(m(), that.n());
for (size_t i = 0; i < m(); ++i) {
for (size_t j = 0; j < that.n(); ++j) {
for (size_t k = 0; k < n(); ++k) {
T tmp = Mul()(D[i][k], that.D[k][j]);
r[i][j] = k == 0 ? tmp : Add()(r[i][j], tmp);
}
}
}
return std::move(r);
}
Matrix<T, Add, Mul> operator^(int k) const {
assert(k >= 0);
assert(m() == n());
Matrix<T, Add, Mul> r(m(), m());
bool initial = true;
auto t = *this;
while (k) {
if (k & 1) {
r = initial ? t : r * t;
initial = false;
}
t = t * t;
k >>= 1;
}
return std::move(r);
}
void print() const {
for (size_t i = 0; i < m(); ++i) {
for (size_t j = 0; j < n(); ++j) {
std::cout << D[i][j] << ' ';
}
std::cout << std::endl;
}
}
};
const LL INF = 1LL << 61;
LL calcJumpCost(const bitset<10>& from, const bitset<10>& to, int Cost[]) {
assert(from.count() == to.count());
auto shift = to << 1;
auto tmp = from ^ shift;
if (tmp.count() == 0)
return 0;
else if (tmp.count() != 2)
return INF;
else {
int p = 0;
while (!from.test(p)) p++;
if (!tmp.test(p)) return INF;
tmp.reset(p);
int q = 0;
while (!tmp.test(q)) q++;
if (q < p) return INF;
return Cost[q - p];
}
}
template <typename T>
struct Min {
T operator()(T a, T b) { return min({a, b, INF}); }
};
Matrix<LL, Min<LL>, plus<LL>> buildMatrix(const vector<bitset<10>>& V,
int C[]) {
Matrix<LL, Min<LL>, plus<LL>> R(V.size(), V.size());
for (size_t i = 0; i < V.size(); i++) {
for (size_t j = 0; j < V.size(); j++) {
auto from = V[i];
auto to = V[j];
R[i][j] = calcJumpCost(from, to, C);
}
}
return R;
}
int x, k, n, q;
int C[10];
map<int, int> Special;
int main() {
scanf("%d%d%d%d", &x, &k, &n, &q);
vector<bitset<10>> V;
for (int state = 1; state < (1 << k); state++) {
auto bs = bitset<10>(state);
if (int(bs.count()) != x) continue;
V.push_back(bs);
}
for (int i = (1); i <= (k); ++i) scanf("%d", &C[i]);
LL ans = 0;
set<int> S;
for (int i = (1); i <= (q); ++i) {
int p, w;
scanf("%d%d", &p, &w);
if (p >= n - x + 1) {
ans += w;
continue;
}
for (int j = p - k; j <= p; j++) {
if (j <= 1) continue;
S.insert(j);
}
Special[p] = w;
}
S.insert(n - x + 1);
auto Mul = buildMatrix(V, C);
auto A = Mul;
A.D.resize(1);
for (size_t i = 0; i < A.n(); ++i) A[0][i] = INF;
A[0][0] = 0;
int pre = 1;
for (auto cur : S) {
if (cur == pre + 1) {
auto B = A;
for (int j = 0; j < int(V.size()); j++) {
B[0][j] = INF;
for (int i = 0; i < int(V.size()); i++) {
LL update = A[0][i];
auto from = V[i];
auto to = V[j];
update += calcJumpCost(from, to, C);
auto tmp = (from ^ (to << 1)) & (~from);
for (int k = 0; k < 10; k++) {
if (tmp.test(k) && Special.find(k + pre) != Special.end()) {
update += Special[k + pre];
break;
}
}
B[0][j] = min(B[0][j], update);
}
}
A = B;
} else {
A = A * (Mul ^ (cur - pre));
}
pre = cur;
}
cout << A[0][0] + ans << endl;
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
string s,t;
cin>>s>>t;
int a,b;
cin>>a>>b;
string u;
cin>>u;
if( s == u){
a--;
}else {
b--;
}
cout<<a<<" "<<b;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
vector<tuple<int, int, int>> adjList[MAXN + 1];
tuple<int, int, int> edges[MAXN];
int ans[MAXN];
bool dfs(int v, int p, int target, int bt, int &minW) {
if (v == target) return true;
for (int i = 0; i < (int)adjList[v].size(); i++) {
tuple<int, int, int> e = adjList[v][i];
int u = get<0>(e);
int ind = get<2>(e);
int w = ans[ind];
if (u != p) {
if (dfs(u, v, target, bt, minW)) {
minW = min(minW, w);
adjList[v][i] = make_tuple(u, max(bt, w), ind);
ans[ind] = max(bt, w);
return true;
}
}
}
return false;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adjList[a].push_back(make_tuple(b, 0, i));
adjList[b].push_back(make_tuple(a, 0, i));
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int a, b, g;
cin >> a >> b >> g;
edges[i] = make_tuple(g, a, b);
}
sort(edges, edges + m);
bool valid = true;
for (int i = m - 1; i >= 0; i--) {
int a, b, g;
g = get<0>(edges[i]);
a = get<1>(edges[i]);
b = get<2>(edges[i]);
int minn = 2E6;
dfs(a, a, b, g, minn);
if (minn > g) valid = false;
}
if (valid) {
for (int i = 0; i < n - 1; i++) {
if (i > 0) cout << " ";
cout << (ans[i] == 0 ? 1 : ans[i]);
}
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
long long x = min(a.first * 2, a.second) - a.first;
long long y = min(b.first * 2, b.second) - b.first;
return x > y;
}
int main() {
int n, f;
cin >> n >> f;
long long out = 0;
for (int i = (0); i < (n); i++) {
long long k, l;
cin >> k >> l;
if (k >= l) {
out += l;
} else {
v.push_back({k, l});
out += k;
}
}
sort(v.begin(), v.end(), comp);
for (int i = (0); i < ((min(f, (int)v.size()))); i++) {
long long x = v[i].first * 2;
long long y = v[i].second;
out += min(x, y);
out -= v[i].first;
}
cout << out << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 5e5 + 5;
int s[N], num[N];
int find(int x) {
if (x != s[x]) s[x] = find(s[x]);
return s[x];
}
void built(int x, int y) {
x = find(s[x]), y = find(s[y]);
if (x != y) {
if (num[x] >= num[y]) {
s[y] = x;
num[x] += num[y];
} else {
s[x] = y;
num[y] += num[x];
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
s[i] = i;
num[i] = 1;
}
while (m--) {
int t, x, y;
scanf("%d", &t);
if (t > 0) scanf("%d", &x);
--t;
for (int i = 0; i < t; ++i) {
scanf("%d", &y);
built(x, y);
}
}
for (int i = 1; i <= n; ++i) {
int x = find(i);
printf("%d ", num[x]);
}
return 0;
}
| 3 |
#include <stdio.h>
#include <stdlib.h>
const int map[7][2]={
{0,0}, /* 0:砂漠 */
{2,3}, /* 1:A XorY*/
{0,4}, /* 2:X 砂漠orZ*/
{2,0}, /* 3:Y Aor砂漠*/
{5,6}, /* 4:Z WorB*/
{6,3}, /* 5:W BorY*/
{3,2}, /* 6:B YorX*/
};
int main(void) {
char route[200];
int i,P;
while(0==0) {
scanf("%s",route);
if(route[0]=='#')break;
P=1;//初期位置はA
for(i=0;route[i];i++)
P=map[P][route[i]-'0'];
if(P==6)printf("Yes\n");
else printf("No\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long n, sum, sum2, w, k, a[maxn], ti[maxn], ans;
set<pair<long long, long long>> s;
set<pair<long long, long long>, greater<pair<long long, long long>>> s1;
bool mrk[maxn];
void f16_62() {
while (s1.size()) {
long long sz = s.size();
if (sz < w) {
pair<long long, long long> p = (*s1.begin());
s1.erase(p);
sum2 = sum2 - ti[p.second];
s.insert(p);
mrk[p.second] = 1;
sum2 += (ti[p.second] + 1ll) / 2ll;
continue;
}
pair<long long, long long> p = (*s1.begin());
pair<long long, long long> p2 = (*s.begin());
if (p2.first < p.first) {
s1.erase(p);
s.erase(p2);
sum2 = sum2 - (((ti[p2.second] + 1ll) / 2ll) + ti[p.second]);
sum2 = sum2 + (ti[p2.second] + ((ti[p.second] + 1ll) / 2ll));
s1.insert(p2);
s.insert(p);
mrk[p.second] = 1;
mrk[p2.second] = 0;
} else
break;
}
}
void aDd(long long i) {
sum += a[i];
sum2 += ti[i];
long long x = ti[i] / 2ll;
pair<long long, long long> p = {x, i};
s1.insert(p);
if (i > n)
cout << "i"
<< " : " << i << "\n";
if (i < 0)
cout << "i"
<< " : " << i << "\n";
f16_62();
if (sum2 <= k) ans = max(ans, sum);
}
void dLt(long long i) {
long long x = ti[i] / 2ll;
pair<long long, long long> p = {x, i};
sum -= a[i];
if (mrk[i]) {
s.erase(p);
sum2 -= ((ti[i] + 1ll) / 2ll);
mrk[i] = 0;
} else {
s1.erase(p);
sum2 -= ti[i];
}
f16_62();
if (sum2 <= k) ans = max(ans, sum);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> w >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> ti[i];
aDd(0);
long long p1 = 0, p2 = 1;
while (p1 < n) {
if (sum2 > k) {
dLt(p1);
p1++;
continue;
}
ans = max(ans, sum);
if (p1 == p2) {
aDd(p1);
p2++;
continue;
}
while ((p2 < n) && (sum2 <= k)) {
ans = max(ans, sum);
aDd(p2);
p2++;
}
dLt(p1);
p1++;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long N = 1e2 + 5;
unsigned long long a, z[101], vis[101], ok = 0;
vector<unsigned long long> ans;
void dfs(unsigned long long u, unsigned long long le) {
if (u % 3 == 0) {
for (unsigned long long i = 1; i <= a; i++) {
if (z[i] == u / 3 && vis[i] == 0) {
vis[i] = 1;
dfs(z[i], le + 1);
}
}
}
for (unsigned long long i = 1; i <= a; i++) {
if (u * 2 == z[i] && vis[i] == 0) {
vis[i] = 1;
dfs(z[i], le + 1);
}
}
if (le == a and ok == 0) {
ans.push_back(u);
ok = 1;
ok = a - 1;
}
if (le == ok) {
ok--;
ans.push_back(u);
}
}
int32_t main() {
cin >> a;
for (unsigned long long i = 1; i <= a; i++) {
cin >> z[i];
}
for (unsigned long long i = 1; i <= a; i++) {
memset(vis, 0LL, sizeof(vis));
vis[i] = 1;
dfs(z[i], 1);
}
reverse(ans.begin(), ans.end());
for (unsigned long long it : ans) {
cout << it << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> string_to_id;
map<int, string> id_to_string;
vector<vector<int>> adj;
vector<int> in_degree;
vector<int> out_degree;
int get_id(const string& code) {
if (string_to_id.count(code) == 0) {
int size = string_to_id.size();
string_to_id[code] = size;
id_to_string[size] = code;
}
return string_to_id[code];
}
int get_char(int i) {
if (i < 26) return 'a' + i;
i -= 26;
if (i < 26) return 'A' + i;
i -= 26;
return '0' + i;
}
template <class T>
void remove_item(std::vector<T>& coll, int item) {
coll[item] = coll.back();
coll.resize(coll.size() - 1);
}
int main() {
string line;
getline(cin, line);
int n;
sscanf(line.c_str(), "%d", &n);
for (int i = 0; i < n; ++i) {
getline(cin, line);
int a = get_id(line.substr(0, 2));
int b = get_id(line.substr(1, 2));
if (adj.size() <= a) adj.resize(a + 1);
if (adj.size() <= b) adj.resize(b + 1);
if (in_degree.size() <= a) in_degree.resize(a + 1);
if (out_degree.size() <= a) out_degree.resize(a + 1);
if (in_degree.size() <= b) in_degree.resize(b + 1);
if (out_degree.size() <= b) out_degree.resize(b + 1);
adj[a].push_back(b);
in_degree[b]++;
out_degree[a]++;
}
int start_index = -1;
int end_index = -1;
int N = adj.size();
for (int i = 0; i < N; ++i) {
if (abs(in_degree[i] - out_degree[i]) > 1) {
printf("NO\n");
return 0;
}
if (in_degree[i] + 1 == out_degree[i]) {
if (start_index != -1) {
printf("NO\n");
return 0;
}
start_index = i;
}
if (in_degree[i] == out_degree[i] + 1) {
if (end_index != -1) {
printf("NO\n");
return 0;
}
end_index = i;
}
}
if (start_index == -1) {
start_index = 0;
end_index = 0;
}
vector<vector<int>> adj_copy = adj;
string result = id_to_string[start_index];
vector<int> steps;
vector<vector<int>> cycles;
for (int i = 0; i < N; ++i) {
while (true) {
bool cycle_found = false;
vector<int> visited(N);
vector<int> processed(N);
stack<pair<int, int>> s;
s.push(make_pair(i, -1));
visited[i] = true;
while (s.size()) {
int v = s.top().first;
bool need_pop = true;
while (processed[v] < adj[v].size()) {
int u = adj[v][processed[v]];
if (u == -1) {
processed[v]++;
continue;
}
if (visited[u]) {
vector<int> cycle;
cycle.push_back(u);
int from = processed[v];
while (s.top().first != u) {
visited[s.top().first] = false;
cycle.push_back(s.top().first);
remove_item(adj[s.top().first], from);
from = s.top().second;
s.pop();
}
remove_item(adj[u], from);
reverse(cycle.begin(), cycle.end());
cycles.push_back(cycle);
cycle_found = true;
break;
} else {
visited[u] = true;
s.push(make_pair(u, processed[v]));
processed[v]++;
need_pop = false;
break;
}
}
if (cycle_found) break;
if (need_pop) {
visited[s.top().first] = false;
s.pop();
}
}
if (!cycle_found) break;
}
}
int C = cycles.size();
stack<int> s_cycle;
stack<int> s_current;
s_current.push(start_index);
steps.push_back(start_index);
vector<int> processed_current(N, 0);
vector<int> processed_cycle(C, 0);
vector<int> visited_cycle(C);
vector<vector<int>> vertex_to_cycle(N);
vector<vector<int>> vertex_to_cycle_position(N);
vector<int> processed_vertex_to_cycle(N);
for (int i = 0; i < C; ++i) {
for (int j = 0; j < cycles[i].size(); ++j) {
vertex_to_cycle[cycles[i][j]].push_back(i);
vertex_to_cycle_position[cycles[i][j]].push_back(j);
}
}
while (s_current.size() || s_cycle.size()) {
if (s_cycle.size()) {
int c = s_cycle.top();
bool need_pop = true;
while (processed_cycle[c] < cycles[c].size()) {
int v = cycles[c][processed_cycle[c]++];
steps.push_back(v);
while (processed_vertex_to_cycle[v] < vertex_to_cycle[v].size()) {
int index = processed_vertex_to_cycle[v]++;
int c = vertex_to_cycle[v][index];
int p = vertex_to_cycle_position[v][index];
if (visited_cycle[c]) continue;
rotate(cycles[c].begin(), cycles[c].begin() + p + 1, cycles[c].end());
s_cycle.push(c);
visited_cycle[c] = true;
need_pop = false;
break;
}
if (!need_pop) break;
}
if (need_pop) s_cycle.pop();
} else if (s_current.size()) {
int v = s_current.top();
bool go_to_cycle = false;
while (processed_vertex_to_cycle[v] < vertex_to_cycle[v].size()) {
int index = processed_vertex_to_cycle[v]++;
int c = vertex_to_cycle[v][index];
int p = vertex_to_cycle_position[v][index];
if (visited_cycle[c]) continue;
rotate(cycles[c].begin(), cycles[c].begin() + p + 1, cycles[c].end());
s_cycle.push(c);
visited_cycle[c] = true;
go_to_cycle = true;
break;
}
if (go_to_cycle) continue;
bool need_pop = true;
while (processed_current[v] < adj[v].size()) {
int u = adj[v][processed_current[v]++];
if (u == -1) continue;
steps.push_back(u);
s_current.push(u);
need_pop = false;
break;
}
if (need_pop) s_current.pop();
}
}
if (steps.size() != n + 1) {
printf("NO\n");
return 0;
}
for (int i = 1; i < steps.size(); ++i) {
result += id_to_string[steps[i]][1];
}
printf("YES\n");
printf("%s\n", result.c_str());
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
struct Cg {
inline char operator()() { return getchar(); }
};
struct Cp {
inline void operator()(char x) { putchar(x); }
};
inline bool IS(char x) { return x == 10 || x == 13 || x == ' '; }
template <typename T>
struct Fr {
T P;
inline Fr &operator,(int &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator int() {
int x;
*this, x;
return x;
}
inline Fr &operator,(long long &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator long long() {
long long x;
*this, x;
return x;
}
inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
inline operator char() {
char x;
*this, x;
return x;
}
inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
inline Fr &operator,(double &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator double() {
double x;
*this, x;
return x;
}
inline Fr &operator,(long double &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator long double() {
long double x;
*this, x;
return x;
}
inline Fr &operator,(unsigned int &x) {
x = 0;
char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
inline Fr &operator,(unsigned long long &x) {
x = 0;
char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned int x) {
if (x) {
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned int x) {
if (x) {
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned long long x) {
if (x) {
char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned long long x) {
if (x) {
char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(char x) {
P(x);
return *this;
}
inline Fw &operator()(char x) {
P(x);
return *this;
}
inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
const int N = 2000007;
char r[N], s[N];
int fa[N];
int main() {
for (int i = 0, iend = N; i < iend; i++) fa[i] = i;
for (int n = in; n--;) {
in, s;
int k, v;
in, k;
v = strlen(s);
for (int i = 0, iend = k; i < iend; i++) {
int p = in;
for (int j = p;;) {
for (; fa[j] ^ j; j = fa[j] = fa[fa[j]])
;
if (j >= p + v) break;
r[j] = s[j - p];
j = fa[j] = j + 1;
}
}
}
int l = 0;
for (int i = 0, iend = N; i < iend; i++)
if (r[i]) l = i;
for (int i = 1, iend = l; i <= iend; i++)
if (r[i])
out, r[i];
else
out, 'a';
out, '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <size_t N>
string to_string(bitset<N> v) {
string s = "";
for (size_t i = 0; i < N; i++) {
s += static_cast<char>('0' + v[i]);
}
return s;
}
template <typename A>
string to_string(A v) {
bool first = true;
string s = "{";
for (const auto& x : v) {
if (!first) {
s += ", ";
}
first = false;
s += to_string(x);
}
s += "}";
return s;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
vector<vector<int>> g;
map<int, int> leaves;
void dfs(int v, int p, int h) {
if ((int)g[v].size() == 1) {
leaves[h]++;
return;
}
for (int u : g[v]) {
if (u == p) continue;
dfs(u, v, h + 1);
}
}
int main() {
int n;
cin >> n;
g.resize(n);
for (int i = 0; i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
int cost = 0;
for (int v : g[0]) {
dfs(v, 0, 1);
while (!leaves.empty()) {
auto e = *leaves.begin();
int h = e.first;
int c = e.second;
leaves.erase(h);
cost = max(cost, h);
if (c == 1) continue;
c--;
leaves[h + 1] += c;
}
}
cout << cost << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
map<string, int> dp;
void add(int &a, int b){
a += b;
if(a >= mod)
a -= mod;
}
void merge(string &a, string b){
int n = b.length();
for(int i = 0;i < n;i++){
if(b[i] == '0')
a[i] = '0';
}
}
int Dp(string s){
if(s == "")
return 1;
if(dp.find(s) != dp.end())
return dp[s];
int n = s.length();
int ans = 0;
int val = Dp(s.substr(1, n - 1));
add(ans, val);
if(s[0] == '1')
add(ans, val);
for(int len = 1;len <= n;len++){
string str = s.substr(0, len);
for(int j = 2;j * len <= n;j++){
string x = s.substr((j - 1) * len, len);
merge(str, x);
string s1 = s.substr(j * len, n - j * len);
val = 1LL * Dp(s1) * Dp(str) % mod;
add(ans, val);
}
}
dp[s] = ans;
return ans;
}
string S;
int main(){
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> S;
cout << Dp(S) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int a[maxn];
int main() {
int n;
scanf("%i", &n);
for (int i = 0; i < n; i++) scanf("%i", &a[i]);
int cnt = 0;
int l = 0, r = 0;
for (int i = 1; i < n; i++)
if (a[i - 1] > a[i]) {
if (cnt == 2) {
printf("NO\n");
return 0;
}
if (cnt == 0) {
l = i - 1;
cnt++;
} else {
r = i;
cnt++;
}
}
if (cnt == 0) {
printf("YES\n");
return 0;
}
if (cnt == 1) {
r = l + 1;
for (; l > 0; l--)
if (a[l - 1] != a[l]) break;
for (; r < n - 1; r++)
if (a[r + 1] != a[r]) break;
}
swap(a[l], a[r]);
for (int i = 1; i < n; i++) {
if (a[i - 1] > a[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
vector<string> a;
vector<int> pA, pB;
vector<vector<int> > dp;
int n, m, x, y;
int getPA(int l, int r) { return pA[r] - (l ? pA[l - 1] : 0); }
int getPB(int l, int r) { return pB[r] - (l ? pB[l - 1] : 0); }
int main() {
cin >> n >> m >> x >> y;
a.resize(n);
getline(cin, a[0]);
for (int i = 0; i < n; i++) getline(cin, a[i]);
pA.resize(m, 0);
pB.resize(m, 0);
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) (a[i][j] == '.' ? pA[j]++ : pB[j]++);
for (int j = 1; j < m; j++) {
pA[j] += pA[j - 1];
pB[j] += pB[j - 1];
}
y = min(y, m);
dp.resize(m + 1, vector<int>(m, inf));
for (int i = x; i <= y; i++) dp[0][i - 1] = pB[i - 1];
for (int i = x; i <= y; i++) dp[i][i - 1] = pA[i - 1];
for (int j = 0; j < m; j++) {
for (int i = x; i <= y; i++) {
if (j + i >= m) break;
dp[i][j + i] = min(dp[i][j + i], dp[0][j] + getPA(j + 1, j + i));
}
int cur = inf;
for (int i = x; i <= y; i++) cur = min(cur, dp[i][j]);
for (int i = x; i <= y; i++) {
if (j + i >= m) break;
dp[0][j + i] = min(dp[0][j + i], cur + getPB(j + 1, j + i));
}
}
int ans = dp[0][m - 1];
for (int i = x; i <= y; i++) ans = min(ans, dp[i][m - 1]);
cout << ans << endl;
return 0;
}
| 3 |
#include<stdio.h>
int main(){float n,m,d;scanf("%f%f%f",&n,&m,&d);printf("%lf",(d?2:1)*(n-d)*(m-1)/n/n);} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, x1, x2, p, d, t1, t2, ans = 0;
cin >> s >> x1 >> x2 >> t1 >> t2 >> p >> d;
if (t1 >= t2) {
ans = (abs(x2 - x1)) * t2;
} else if (x2 < x1) {
if (p >= x1 and d == -1)
ans = min(t1 * (p - x2), t2 * (x1 - x2));
else if (d == -1 and p < x1)
ans = min(t2 * (x1 - x2), t1 * (2 * s + (p - x2)));
else if (d == 1)
ans = min(t2 * (x1 - x2), t1 * (2 * s - x2 - p));
} else if (x2 > x1) {
if (d == 1 and p <= x1)
ans = min(t1 * (x2 - p), t2 * (x2 - x1));
else if (d == 1 and p > x1)
ans = min(t2 * (x2 - x1), t1 * (2 * s + (x2 - p)));
else if (d == -1)
ans = min(t2 * (x2 - x1), t1 * (x2 + p));
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n + 1], x;
for (int i = 1; i <= n; i++) {
cin >> x;
a[x] = i;
}
for (int i = 1; i <= n; i++) {
cin >> x;
b[i] = a[x];
}
for (int i = 1; i <= n; i++) {
cout << b[i] << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using PQ = priority_queue<T>;
template <typename T>
using GPQ = priority_queue<T, vector<T>, greater<T>>;
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> p);
template <class T>
ostream& operator<<(ostream& os, vector<T> v) {
os << "[";
for (auto vv : v) os << vv << ",";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> v) {
os << "[";
for (auto vv : v) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
inline T sq(T a) {
return a * a;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) return gcd(b, a);
return b == 0 ? a : gcd(b, a % b);
}
template <typename T, typename U>
T mypow(T b, U n) {
if (n == 0) return 1;
if (n == 1) return b;
if (n % 2 == 0) {
return mypow(b * b, n / 2);
} else {
return mypow(b, n - 1) * b;
}
}
ll pcnt(ll b) { return __builtin_popcountll(b); }
template <typename T>
T iceil(T n, T d) {
return (n + d - 1) / d;
}
int query(int t, int v) {
cout << "AB"[t] << " " << v + 1 << endl;
int res;
cin >> res;
return res - 1;
}
void answer(int v) { cout << 'C' << " " << (v < 0 ? -1 : v + 1) << endl; }
int main() {
int Q;
cin >> Q;
for (int q = 0; q < Q; ++q) {
int n;
cin >> n;
vector<int> path[n];
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
path[u].push_back(v);
path[v].push_back(u);
}
int k[2];
set<int> x[2];
for (int i = 0; i < 2; ++i) {
cin >> k[i];
for (int j = 0; j < k[i]; ++j) {
int v;
cin >> v;
--v;
x[i].insert(v);
}
}
int r = query(1, *x[1].begin());
if (x[0].count(r) == 1) {
answer(r);
continue;
}
bool visited[n];
fill(visited, visited + n, false);
visited[r] = true;
queue<int> que;
que.push(r);
while (!que.empty()) {
int v = que.front();
que.pop();
if (x[0].count(v)) {
r = v;
break;
}
for (int sv : path[v]) {
if (visited[sv]) continue;
visited[sv] = true;
que.push(sv);
}
}
int s = query(0, r);
if (x[1].count(s) == 1) {
answer(r);
} else {
answer(-1);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1000000ll * 1000000 + 200;
long long int mod = 998244353;
const int maxn = 2e5 + 2000;
long long int fen[maxn], h[maxn];
void inc(int i) {
for (; i < maxn; i += i & -i) {
fen[i]++;
}
}
void dec(int i) {
for (; i < maxn; i += i & -i) {
fen[i]--;
}
}
int fgt(int i) {
long long int res = 0;
for (; i > 0; i -= i & -i) {
res += fen[i];
}
return res;
}
vector<pair<int, int> > vec;
int ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
vec.push_back({h[i], i});
}
sort(vec.begin(), vec.end());
int last = 0;
for (int i = 1; i <= n; i++) {
pair<int, int> P = {h[i - 1], i - 1};
int pos = lower_bound(vec.begin(), vec.end(), P) - vec.begin() + 1;
inc(pos);
if (fgt(i) - fgt(last) == i - last) {
ans++;
last = i;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int times(int a, int b) {
int s = 0;
while (a) {
a /= b;
s++;
}
return s;
}
int main() {
int t, a[100001] = {}, b, s = 0, c = 0, n, i, j, x;
int d;
char s1[101], s2[101];
cin >> n;
s = n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n - 1; i++)
if (a[i] == a[i + 1]) s--;
cout << s << endl;
}
| 1 |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
long n, k;
cin >> n >> k;
cout << (n - 1 + (k - 1) - 1) / (k - 1) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
double low = 0, high = INFINITY;
void restrict(int init, int dir, int min, int max) {
if (dir > 0) {
low = std::max(low, double(min - init) / dir);
high = std::min(high, double(max - init) / dir);
} else if (dir < 0) {
low = std::max(low, double(max - init) / dir);
high = std::min(high, double(min - init) / dir);
} else if ((init <= min) || (init >= max)) {
low = INFINITY;
high = 0;
}
}
int main() {
int N;
int X1, Y1, X2, Y2;
scanf("%d", &N);
scanf("%d %d %d %d", &X1, &Y1, &X2, &Y2);
for (int i = 0; i < N; i++) {
int x, y, xdir, ydir;
scanf("%d %d %d %d", &x, &y, &xdir, &ydir);
restrict(x, xdir, X1, X2);
restrict(y, ydir, Y1, Y2);
}
if (low < high) {
printf("%.10lf\n", low);
} else {
printf("-1\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], a1, a2, a3, a4, sum = 0, k;
cin >> a1 >> a2 >> a3 >> a4;
a[1] = a1;
a[2] = a2;
a[3] = a3;
a[4] = a4;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
k = s[i] - 48;
sum = sum + a[k];
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
int t;
cin >> t;
string y = "YES\n", z = "NO\n";
while (t--) {
long long int a, b, i, j;
cin >> a >> b;
if (a - b == 1 && isprime(a + b))
cout << y;
else
cout << z;
}
}
| 2 |
#include<iostream>
#include<algorithm>
using namespace std;
int a[12];
int main(){
for(int i=0;i<12;i++)cin>>a[i];
sort(a,a+12);
bool ok=true;
for(int i=0;i<12;i++){
if(i%4!=3)if(a[i]!=a[i+1])ok=false;
}
if(ok)cout<<"yes"<<endl;
else cout<<"no"<<endl;
return 0;
} | 0 |
/*
* じょえチャンネル
* 高評価・チャンネル登録よろしくお願いします！
* https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
*/
#include<bits/stdc++.h>
int main(){
using namespace std;
unsigned long k, q;
cin >> k >> q;
vector<unsigned long> d(k);
for(auto& i : d)cin >> i;
const auto& query = [&](unsigned long n, unsigned long x, unsigned long m) -> unsigned long {
x %= m;
unsigned long S{0}, c{0};
for(unsigned long i{0}; i < k; ++i){
auto coef = (n + k - i - 2) / k;
S += d[i] % m * coef;
c += !!(d[i] % m) * coef;
}
return c - (S + x) / m + x / m;
};
for(unsigned long i{0}, n, x, m; i < q; ++i){
cin >> n >> x >> m;
cout << query(n, x, m) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX_N = 1e5+2;
int n;
int a[MAX_N];
void solve()
{
sort(a,a+n);
int x=a[n-1], y=-x/2;
for(int i=0;i<n-1;++i){
if(abs(1.0*x/2-a[i]) < abs(1.0*x/2-y)) y=a[i];
}
cout << x << ' ' << y << '\n';
}
int main()
{
cin >> n;
for(int i=0;i<n;++i) cin >> a[i];
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
printf("%d\n", n / 2 + 1);
return 0;
}
| 1 |
#include <map>
#include <set>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cctype>
#include <string>
#include <numeric>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std ;
#define rep(i, a, b) for (register ll i = (a); i <= (b); ++i)
#define per(i, a, b) for (register ll i = (a); i >= (b); --i)
#define loop(it, v) for (auto it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (register int i = head[x]; i; i = edge[i].nex)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, cnt) memset(a, cnt, sizeof(a))
#define cop(a, b) memcpy(a, b, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define SC(t, x) static_cast <t> (x)
#define ub upper_bound
#define lb lower_bound
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define pof pop_front
#define pob pop_back
#define fi first
#define se second
#define y1 y1_
#define Pi acos(-1.0)
#define iv inline void
#define enter putchar('\n')
#define siz(x) ((int)x.size())
#define file(x) freopen(x".in", "r", stdin),freopen(x".out", "w", stdout)
typedef double db ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <int, int> pii ;
typedef vector <int> vi ;
typedef vector <pii> vii ;
typedef queue <int> qi ;
typedef queue <pii> qii ;
typedef set <int> si ;
typedef map <int, int> mii ;
typedef map <string, int> msi ;
const int maxn = 3e5 + 100 ;
const int inf = 0x3f3f3f3f ;
const int iinf = 1 << 30 ;
const ll linf = 2e18 ;
const ll mod = 1e9 + 7 ;
const double eps = 1e-7 ;
template <class T = int> T read()
{
T f = 1, a = 0;
char ch = getchar() ;
while (!isdigit(ch)) { if (ch == '-') f = -1 ; ch = getchar() ; }
while (isdigit(ch)) { a = (a << 3) + (a << 1) + ch - '0' ; ch = getchar() ; }
return a * f ;
}
ll n;
ll a[maxn], sum[2], ans;
bool check(ll lim)
{
ll sum = 0, pre = 0, val;
rep(i, 1, n)
{
pre += val = a[i] * ((i & 1) ? -1 : 1);
if(pre - val - sum <= lim) sum = max(sum, pre);
}
if(pre - sum <= lim) return 1;
return 0;
}
signed main()
{
scanf("%lld", &n);
rep(i, 1, n) scanf("%lld", &a[i]), sum[i & 1] += a[i];
if(!(n & 1))
{
printf("%lld %lld\n", max(sum[0], sum[1]), min(sum[0], sum[1]));
return 0;
}
ll l = -1e9, r = 1e9;
while(l <= r)
{
ll mid = (l + r) >> 1;
if(check(mid)) ans = mid, r = mid - 1;
else l = mid + 1;
}
ans = sum[0] - ans;
printf("%lld %lld\n", ans, sum[0] + sum[1] - ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q, n;
long long x, s = 0;
cin >> q;
while (q--) {
cin >> n;
s = 0;
for (int i = 0; i < n; i++) {
cin >> x;
if (x <= 2048) {
if (s < 2048) s = s + x;
}
}
if (s >= 2048)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long X;
cin >> X;
for(long long i=-200;i<201;i++){
for(long long j=-200;j<201;j++){
if(i*i*i*i*i-j*j*j*j*j==X){
cout << i << " " << j << endl;
return 0;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 9223372034707292160;
const int maxn = 2e5 + 5;
long long geshu(long long a) {
int sum = 0;
for (int i = 1; i <= sqrt(a); i++) {
if (a % i == 0) {
sum++;
if (a / i != i) sum++;
}
}
return sum - 2;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
long long a[500];
memset(a, 0, sizeof(a));
scanf("%d", &n);
long long ans;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
ans = a[1] * a[n];
int flag = 1;
for (int i = 1; i <= n; i++) {
if (ans % a[i] != 0) {
flag = 0;
break;
}
}
if (geshu(ans) != n) {
printf("-1\n");
} else if (flag)
printf("%lld\n", ans);
else
printf("-1\n");
}
return 0;
}
| 4 |
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int dp[201][201];
int t[201],u[201],v[201],w[201];
int N,D,ans=0;
int main(){
cin>>N>>D;
for(int i=1;i<=N;i++)cin>>t[i];
for(int i=1;i<=D;i++){
cin>>u[i]>>v[i]>>w[i];
if(t[1]<u[i]||v[i]<t[1])dp[1][i]=-1;
else dp[1][i]=0;
}
for(int i=2;i<=N;i++){
for(int j=1;j<=D;j++){
dp[i][j]=-1;
if(t[i]<u[j]||v[j]<t[i])continue;
for(int k=1;k<=D;k++){
if(dp[i-1][k]==-1)continue;
dp[i][j]=max(dp[i][j],dp[i-1][k]+abs(w[k]-w[j]));
}
ans=max(ans,dp[i][j]);
}
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int main() {
constexpr Int INF = 1e18;
int N;
cin >> N;
vector<Int> a(N);
for (int i = 0; i < N; ++i) { cin >> a[i]; }
int skip = 1 + N % 2;
vector<vector<Int>> dp(N + 2, vector<Int>(skip + 1, -INF));
dp[0][0] = 0;
for (int i = 0; i <= N; ++i) {
for (int j = 0; j <= skip; ++j) {
if (j < skip) {
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j]);
}
if (i < N) {
dp[i + 2][j] = max(dp[i + 2][j], dp[i][j] + a[i]);
}
}
}
cout << dp[N + 1][skip] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q, x;
cin >> q >> x;
vector<int> rem(x);
vector<bool> a(q);
int mes = 0;
for (int i = 0; i < q; i++) {
int y;
cin >> y;
int r = y % x;
rem[r]++;
long long ind = (long long)(rem[r] - 1) * x + r;
if (ind < q) a[ind] = true;
while (mes < q && a[mes]) mes++;
cout << mes << '\n';
}
}
| 4 |
#include<cstdio>
#include<algorithm>
int h[100000];
int main(){
int n,k;
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++)scanf("%d",&h[i]);
std::sort(h,h+n);
for(int i=0;i+k-1<n;i++)h[i]=h[i+k-1]-h[i];
std::sort(h,h+(n+1-k));
printf("%d",h[0]);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define ll long long
#define ii pair<int, int>
#define fi first
#define se second
#define multitest \
int t; \
cin >> t; \
while (t--)
using namespace std;
const int N = 32;
int main()
{
ios::sync_with_stdio(false);
multitest
{
int n, w;
cin >> n >> w;
multiset<int> ws;
for (int i = 0; i < n; i++)
{
int x;
cin >> x;
ws.insert(x);
}
int ans = 0;
while (ws.size())
{
int d = 0;
while (d < w && ws.size())
{
auto it = ws.upper_bound(w - d);
if (it == ws.begin())
{
break;
}
it--;
d += *it;
ws.erase(it);
}
ans++;
}
cout << ans << endl;
}
return 0;
} | 2 |
#include <iostream>
#include <cstdio>
using namespace std;
char c;
int n,m;
int f[110][110][110][110];
int linex[110][110],liney[110][110];
int X,Y;
struct LIMIT{
int u,d,l,r;
}L;
int main(){
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++){
scanf("%c",&c);
while (c!='.'&&c!='o'&&c!='E') scanf("%c",&c);
if (c=='E') X=i,Y=j;
linex[i][j]=linex[i][j-1];
liney[i][j]=liney[i-1][j];
if (c=='o'){
linex[i][j]++;
liney[i][j]++;
}
}
L.u=X-1;L.d=n-X;L.l=Y-1;L.r=m-Y;
for(int u=0;u<=L.u;u++)
for(int d=0;d<=L.d;d++)
for(int l=0;l<=L.l;l++)
for(int r=0;r<=L.r;r++){
int L=max(Y-l,r+1),R=min(Y+r,m-l);
if(L<=R){
f[u+1][d][l][r]=max(f[u+1][d][l][r],f[u][d][l][r]+(X-u-1>=d+1?linex[X-u-1][R]-linex[X-u-1][L-1]:0));
f[u][d+1][l][r]=max(f[u][d+1][l][r],f[u][d][l][r]+(X+d+1<=n-u?linex[X+d+1][R]-linex[X+d+1][L-1]:0));
}
L=max(X-u,d+1);
R=min(X+d,n-u);
if(L<=R){
f[u][d][l+1][r]=max(f[u][d][l+1][r],f[u][d][l][r]+(Y-l-1>=r+1?liney[R][Y-l-1]-liney[L-1][Y-l-1]:0));
f[u][d][l][r+1]=max(f[u][d][l][r+1],f[u][d][l][r]+(Y+r+1<=m-l?liney[R][Y+r+1]-liney[L-1][Y+r+1]:0));
}
}
printf("%d\n",f[L.u][L.d][L.l][L.r]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long maxx, maxy;
void judge(long long x, long long y) {
if (x * y > maxx * maxy) {
maxx = x;
maxy = y;
return;
}
if ((x * y == maxx * maxy) && (x > maxx)) {
maxx = x;
maxy = y;
return;
}
}
int main() {
long long s;
long long i;
long long x, y;
long long left, right;
long long m, n;
double f;
maxx = maxy = 1;
scanf("%I64d %I64d", &m, &n);
s = 1;
while (s <= m) {
f = 0.8 * s;
left = f;
if (f != left) left++;
right = 1.25 * s;
if (left > n) break;
if (right <= n) {
x = s;
y = right;
judge(x, y);
} else {
x = s;
y = n;
judge(x, y);
}
s *= 2;
}
s = 1;
while (s <= n) {
f = 0.8 * s;
left = f;
if (f != left) left++;
right = 1.25 * s;
if (left > m) break;
if (right <= m) {
x = right;
y = s;
judge(x, y);
} else {
x = m;
y = s;
judge(x, y);
}
s *= 2;
}
printf("%I64d %I64d\n", maxx, maxy);
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
string s;
int n=0;
cin >> s;
for (auto &c:s) {
if (c=='+') n++;
else n--;
}
cout << n << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long ans, all1, all1full, bonus, All1[1000006];
vector<pair<long long, long long> > v;
stack<pair<int, long long> > zeroes;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
long long sz = s.size(), l = 0;
while (l < sz && s[l] == '0') l++;
if (l == sz) {
cout << sz << '\n';
return 0;
}
while (s[sz - 1] == '0') sz--;
bonus = (long long)(l + 1) * (long long)(s.size() + 1 - sz) % 1000000007;
int X = sz - 1;
while (X >= 0 && s[X] == '1') X--;
ans = sz - X - 1;
all1 = ans;
all1full = 1;
for (int i = X; i >= l;) {
int j = i;
while (s[j] == '0') j--;
int jj = j;
while (s[jj] == '1') jj--;
v.push_back({j - jj, i - j});
i = jj;
}
int n = v.size();
for (int i = 0; i < n; i++) {
All1[i] = all1;
if (i > 0) All1[i] += All1[i - 1];
All1[i] %= 1000000007;
long long ALL1 = all1;
all1 = all1 * v[i].second % 1000000007 * v[i].first + all1full * v[i].first;
all1 %= 1000000007;
ans += all1;
ans %= 1000000007;
all1full = ALL1 * v[i].second + all1full;
all1full %= 1000000007;
long long sum = 0;
while (!zeroes.empty() && zeroes.top().second < v[i].second) {
auto p = zeroes.top();
zeroes.pop();
long long curr;
if (zeroes.empty())
curr = All1[p.first];
else
curr = All1[p.first] - All1[zeroes.top().first];
if (curr < 0) curr += 1000000007;
curr *= v[i].second - p.second;
sum = (sum + curr) % 1000000007;
}
if (!zeroes.empty() && zeroes.top().second == v[i].second) zeroes.pop();
zeroes.push({i, v[i].second});
all1full += sum;
all1full %= 1000000007;
all1 += sum * v[i].first;
all1 %= 1000000007;
ans += sum * v[i].first;
ans %= 1000000007;
}
ans *= bonus;
cout << ans % 1000000007 << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, min_, j, k, n, z, cnt, arr[30][30], ans[100005];
for (i = 0; i < 30; i++) {
for (j = 0; j < 30; j++) {
arr[i][j] = 1123456789LL;
}
}
string str1, str2, sx, sy, str, ch;
cin >> str1 >> str2 >> n;
for (i = 1; i <= n; i++) {
cin >> sx >> sy >> z;
arr[sx[0] - 96][sy[0] - 96] = min(z, arr[sx[0] - 96][sy[0] - 96]);
}
if (str1.length() != str2.length()) {
cout << "-1";
return 0;
}
for (k = 1; k <= 26; k++) {
for (i = 1; i <= 26; i++) {
for (j = 1; j <= 26; j++) {
arr[i][j] = min(arr[i][j], arr[i][k] + arr[k][j]);
}
}
}
cnt = 0;
str = "";
for (i = 0; i < str1.length(); i++) {
if (str1[i] == str2[i]) {
str = str + str1[i];
continue;
}
min_ =
min(arr[str1[i] - 96][str2[i] - 96], arr[str2[i] - 96][str1[i] - 96]);
if (arr[str1[i] - 96][str2[i] - 96] < arr[str2[i] - 96][str1[i] - 96])
ch = str2[i];
else
ch = str1[i];
for (k = 1; k <= 26; k++) {
if (min_ > arr[str1[i] - 96][k] + arr[str2[i] - 96][k]) {
ch = k + 96;
min_ = arr[str1[i] - 96][k] + arr[str2[i] - 96][k];
}
}
if (min_ == 1123456789LL) {
printf("-1");
return 0;
}
cnt += min_;
str = str + ch;
}
cout << cnt << endl;
cout << str;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int x, n;
cin >> x >> n;
if (n == 0)
cout << x << endl;
else if (n > 0) {
long long int nums = (n / 4) * 4;
n = n % 4;
long long int cnt = 0;
nums++;
while (cnt < n) {
if (x % 2 == 0)
x -= nums;
else
x += nums;
cnt++;
nums++;
}
cout << x << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void array_print(vector<char> a, long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i];
}
cout << "\n";
}
void pair_print(vector<pair<long long int, long long int> > p,
long long int n) {
for (long long int i = 0; i < n; i++) {
cout << p[i].first << " " << p[i].second << "\n";
}
}
long long int largest_val = 9999999999999;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int Q;
cin >> Q;
vector<long long int> P, num(200020, 0);
char c;
long long int x;
long long int lm = -1, rm = 1, ix = 0;
cin >> c >> x;
P.push_back(0);
num[x] = ix;
ix++;
for (long long int i = 1; i < Q; i++) {
cin >> c >> x;
if (c == 'R') {
P.push_back(rm);
num[x] = ix;
rm++;
ix++;
} else if (c == 'L') {
P.push_back(lm);
num[x] = ix;
lm--;
ix++;
} else {
long long int t = min((rm - 1 - P[num[x]]), (P[num[x]] - lm - 1));
cout << t << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a;
cin >> n >> m >> a;
long long x = n / a;
if (n % a != 0) x++;
long long y = m / a;
if (m % a != 0) y++;
cout << x * y << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000000;
int pi[maxn + 10], pa[maxn + 10];
bool zhi[maxn + 10];
bool hui[maxn + 10];
void mk_zhi() {
memset(zhi, 1, sizeof(zhi));
for (int i = 4; i <= maxn; i += 2) zhi[i] = false;
for (int i = 3; i <= maxn; i += 2) {
if (zhi[i]) {
for (int k = i * 2; k <= maxn; k += i) zhi[k] = false;
}
}
pi[1] = 0;
for (int i = 2; i <= maxn; ++i) {
pi[i] = pi[i - 1];
if (zhi[i]) ++pi[i];
}
return;
}
void mk_hui() {
memset(hui, 1, sizeof(hui));
int temp[15];
int now, len, k;
for (int i = 1; i <= maxn; ++i) {
now = i;
len = 0;
k = 1;
while (now > 0) {
temp[++len] = now % 10;
now /= 10;
}
while (k <= len) {
if (temp[k] != temp[len]) {
hui[i] = false;
break;
}
++k;
--len;
}
}
pa[1] = 1;
for (int i = 2; i <= maxn; ++i) {
pa[i] = pa[i - 1];
if (hui[i]) ++pa[i];
}
return;
}
void run() {
int p, q;
cin >> p >> q;
mk_zhi();
mk_hui();
for (int i = maxn; i >= 1; --i) {
if ((long long)q * pi[i] <= (long long)p * pa[i]) {
printf("%d", i);
return;
}
}
return;
}
int main() {
run();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main (){
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3] ) {
cout << "Bad"; }
else {
cout << "Good"; } } | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
bool g[MAXN][MAXN];
void a(int x, int y) { g[x][y] = g[y][x] = true; }
int n;
void out() {
vector<int> p(n);
for (int i = 0; i < (int)(n); i++) p[i] = i;
p[1] = n - 1;
p[n - 1] = 1;
cout << n << endl;
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(n); j++) printf("%c", g[p[i]][p[j]] ? 'Y' : 'N');
cout << endl;
}
}
int main() {
int k;
cin >> k;
if (k == 1) {
a(0, 1);
a(1, 0);
n = 2;
out();
return 0;
}
int p = 0;
while ((1 << p) <= k) p++;
p--;
a(0, 1);
a(0, 2);
vector<int> cur;
cur.push_back(1);
cur.push_back(2);
n = 3;
for (int i = 0; i < p; i++) {
vector<int> ncur;
a(cur[0], n);
a(cur[1], n);
ncur.push_back(n++);
a(cur[0], n);
a(cur[1], n);
ncur.push_back(n++);
for (int j = 2; j <= cur.size(); j++) {
a(cur[j - 1], n);
ncur.push_back(n++);
}
cur = ncur;
}
for (int i = 0; i < (int)(p + 1); i++) {
if (k & (1 << i)) {
a(cur[cur.size() - i - 1], n);
}
}
n++;
out();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
bool debug = 1;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int amn[n];
fill(amn, amn + n, 0);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
amn[x]++, amn[y]++;
}
bool ok = 1;
int k = 0;
int one = 0;
int two = 0;
for (int i = 0; i < n; i++) {
if (amn[i] == 1)
one++;
else if (amn[i] == 2)
two++;
else if (amn[i] == 0) {
ok = 0;
break;
} else
k++;
}
if (!ok)
printf("unknown topology\n");
else if (one == 2 && k == 0)
printf("bus topology\n");
else if (one > 2 && two == 0 && k == 1)
printf("star topology\n");
else if (one == 0 && k == 0)
printf("ring topology\n");
else
printf("unknown topology\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
void z_fn(const string& s, vector<int>& z) {
int n = s.size();
z.resize(n);
for (int i = 0; i < n; i++) z[i] = 0;
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
const int maxn = 1e6 + 7;
struct Fenwick {
long long tree[maxn];
void add(int x, int val) {
x++;
while (x < maxn) {
tree[x] += val;
x += x & -x;
}
}
long long query(int x) {
x++;
long long ret = 0;
while (x) {
ret += tree[x];
x -= x & -x;
}
return ret;
}
} cnt, sum;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string a, b, s;
int n, m;
cin >> n >> m;
cin >> a >> b >> s;
vector<int> za, zb;
z_fn(s + '$' + a, za);
reverse(s.begin(), s.end());
reverse(b.begin(), b.end());
z_fn(s + '$' + b, zb);
auto fa = [&](int x) {
x += m + 1;
int ret = za[x];
if (ret == m) ret--;
return ret;
};
auto fb = [&](int x) {
x = n - 1 - x;
x += m + 1;
int ret = zb[x];
if (ret == m) ret--;
return ret;
};
long long ans = 0;
int cur = 0;
for (int i = 0; i < n; i++) {
while (cur - i < m - 1 && cur < n) {
if (fb(cur) > 0) {
cnt.add(max(0, m - 1 - fb(cur)), 1);
sum.add(max(0, m - 1 - fb(cur)), fb(cur));
}
cur++;
}
if (fa(i) > 0) {
int cc = cnt.query(fa(i) - 1);
ans += sum.query(fa(i) - 1) + (long long)cc * (fa(i) - m + 1);
}
if (fb(i) > 0) {
cnt.add(max(0, m - 1 - fb(i)), -1);
sum.add(max(0, m - 1 - fb(i)), -fb(i));
}
}
print(ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[100010];
int main() {
long long int num, i, flag, div;
cin >> num;
for (i = 0; i < num; i++) cin >> arr[i];
sort(arr, arr + num);
div = arr[0];
flag = 1;
for (i = 0; i < num; i++) {
while (arr[i] % 2 == 0 || arr[i] % 3 == 0) {
if (arr[i] % 2 == 0)
arr[i] = arr[i] / 2;
else
arr[i] = arr[i] / 3;
}
}
flag = 1;
for (i = 0; i < num - 1; i++) {
if (arr[i] != arr[i + 1]) {
flag = 0;
break;
}
}
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct treap;
typedef treap *ptreap;
const unsigned long long mod = 1000000007ll;
unsigned long long k, dp[100000][11], n, m, a, ans;
ptreap tree = NULL;
struct treap {
ptreap l, r;
unsigned long long x, sum[11], key, index;
treap(unsigned long long x, unsigned long long index)
: x(x), l(NULL), r(NULL), key(rand() % mod), index(index) {
for (int i = 0; i < k + 1; i++) sum[i] = 0;
};
};
void fix_sum(ptreap &t) {
if (!t) return;
for (int i = 0; i < k + 1; i++) t->sum[i] = dp[t->index][i];
if (t->l)
for (int i = 0; i < k + 1; i++) t->sum[i] += t->l->sum[i];
if (t->r)
for (int i = 0; i < k + 1; i++) t->sum[i] += t->r->sum[i];
}
void Merge(ptreap &t, ptreap l, ptreap r) {
if (!l || !r)
t = l ? l : r;
else if (l->key > r->key)
Merge(l->r, l->r, r), t = l;
else
Merge(r->l, l, r->l), t = r;
fix_sum(t);
}
void Split(ptreap t, ptreap &l, ptreap &r, unsigned long long x) {
if (!t)
l = r = NULL;
else if (x < t->x)
Split(t->l, l, t->l, x), r = t;
else
Split(t->r, t->r, r, x), l = t;
fix_sum(t);
}
void Insert(ptreap &t, ptreap v) {
if (!t)
t = v;
else {
if (v->key > t->key)
Split(t, v->l, v->r, v->x), t = v;
else
Insert(v->x < t->x ? t->l : t->r, v);
}
fix_sum(t);
}
void dp_sum(ptreap t, unsigned long long x, unsigned long long index) {
if (!t)
return;
else {
if (x < t->x)
dp_sum(t->l, x, index);
else {
for (int i = 1; i < k + 1; i++)
dp[index][i] += t->sum[i - 1] - (t->r ? t->r->sum[i - 1] : 0);
dp_sum(t->r, x, index);
}
}
}
void output(ptreap &t, int level) {
if (!t) return;
output(t->l, level + 1);
output(t->r, level + 1);
}
int main() {
scanf("%I64d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a);
dp[i][0] = 1;
dp_sum(tree, a, i);
Insert(tree, new treap(a, i));
}
for (int i = 0; i < n; i++) ans += dp[i][k];
printf("%I64d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
const int mod = 1e9 + 7;
const int inf = 1e9;
int n;
char s[N], ans[N];
map<string, int> mp;
string pre[N];
int main() {
scanf("%d", &n);
if (n == 1) {
printf("? %d %d\n", 1, n);
fflush(stdout);
scanf("%s", s);
printf("! %s\n", s);
fflush(stdout);
}
printf("? %d %d\n", 1, n);
fflush(stdout);
int l = n * (n - 1) / 2 + n;
for (int i = 0; i < l; ++i) {
scanf("%s", s);
int len = strlen(s);
sort(s, s + len);
mp[s]++;
}
printf("? %d %d\n", 2, n);
fflush(stdout);
l = (n - 1) * (n - 2) / 2 + n - 1;
for (int i = 0; i < l; ++i) {
scanf("%s", s);
int len = strlen(s);
sort(s, s + len);
mp[s]--;
}
for (auto& p : mp) {
if (p.second == 0) continue;
pre[p.first.length()] = p.first;
}
for (int i = 1; i <= n; ++i) {
ans[i] = pre[i][i - 1];
for (int j = 0; j < i - 1; ++j) {
if (pre[i][j] != pre[i - 1][j]) {
ans[i] = pre[i][j];
break;
}
}
}
ans[n + 1] = 0;
printf("! %s\n", ans + 1);
fflush(stdout);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
while ((a = a % b) != 0) {
swap(a, b);
}
return b;
}
long long mpow(long long x, long long y, long long m) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x % m;
y = y >> 1;
x = x * x % m;
}
return res;
}
long long ncr(long long n, long long r) {
if (r > n) return 0;
long long res = 1;
for (long long i = (1); i < (r + 1); i++) res = res * (n - r + i) / i;
return res;
}
long long *sieve(long long n) {
long long *lpf = new long long[n + 1];
for (long long i = 1; i <= n; i++) lpf[i] = i;
long long rt = (long long)floor(sqrt(n)) + 1;
for (long long i = (2); i < (rt); i++) {
if (lpf[i] != i) continue;
for (long long j = i * i; j <= n; j += i) {
if (lpf[j] == j) lpf[j] = i;
}
}
return lpf;
}
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = (0); i < (n); i++) cin >> a[i];
long long mx = *max_element(a, a + n), mn = *min_element(a, a + n);
if (mx == mn) {
if (mx != 0)
cout << "NO";
else {
cout << "YES\n";
for (long long i = (0); i < (n); i++) cout << "1 ";
}
return;
}
long long k;
for (long long i = (0); i < (n); i++) {
long long prev = i - 1;
if (prev == -1) prev = n - 1;
if (a[i] == mx && a[prev] != mx) {
k = i;
break;
}
}
long long pt = k;
long long b[n];
b[pt] = mx;
pt--;
if (pt == -1) pt = n - 1;
if (a[pt] == 0)
b[pt] = mx * 2;
else
b[pt] = mx + a[pt];
pt--;
if (pt == -1) pt = n - 1;
while (pt != k) {
b[pt] = b[(pt + 1) % n] + a[pt];
pt--;
if (pt == -1) pt = n - 1;
}
cout << "YES\n";
for (long long i = (0); i < (n); i++) cout << b[i] << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
for (long long i = (1); i < (t + 1); i++) {
solve();
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
const int inf = 0x7f7f7f7f;
const int mod = (int)(1e9 + 7);
const long long INF = 1LL << 50;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int mask = 65535;
vector<int> W[maxn];
bool ok(int x, int y) {
if (x >= maxn || y >= maxn) return 0;
return binary_search(W[x].begin(), W[x].end(), y);
}
int main() {
ios::sync_with_stdio(false);
int n, i, j, k, u, x, y;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> x >> y;
W[x].push_back(y);
}
for (i = 0; i < maxn; ++i) {
sort(W[i].begin(), W[i].end());
}
int block = (int)sqrt(n + 0.0);
vector<int>::iterator it, jt;
int ans = 0, d;
for (i = 0; i < maxn; ++i) {
int sz = W[i].size();
if (sz <= block) {
for (j = 0; j < sz; ++j) {
for (k = j + 1; k < sz; ++k) {
d = W[i][k] - W[i][j];
y = W[i][j];
x = i;
ans += ok(x + d, y) && ok(x + d, y + d);
}
}
} else {
for (j = i + 1; j < maxn; ++j) {
int sz = W[j].size();
d = j - i;
for (k = 0; k < sz; ++k) {
x = j;
y = W[j][k];
ans += ok(j, y + d) && ok(i, y) && ok(i, y + d);
}
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class dsu {
vector<int> p;
public:
dsu(int n) {
p.resize(n);
iota(p.begin(), p.end(), 0);
}
int get(int v) { return (v == p[v] ? v : p[v] = get(p[v])); }
void unite(int u, int v) { p[get(u)] = get(v); }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> l(2 * n, -1), r(2 * n, -1), L(n);
set<pair<int, int>> s;
dsu g(n);
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
L[i] = a;
l[a] = i;
r[b] = i;
}
int edg = 0;
for (int i = 0; i < 2 * n; ++i) {
if (l[i] != -1) {
s.emplace(L[l[i]], l[i]);
} else {
s.erase({L[r[i]], r[i]});
for (auto it = s.rbegin(); it != s.rend(); ++it) {
if (it->first < L[r[i]]) {
break;
}
int x = it->second;
if (g.get(r[i]) == g.get(x)) {
cout << "NO";
return 0;
} else {
g.unite(r[i], x);
++edg;
}
}
}
}
cout << (edg == n - 1 ? "YES" : "NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
std::istream& operator>>(std::istream& input, std::vector<T>& v) {
for (T& a : v) input >> a;
return input;
}
void no_answer() { std::cout << -1 << '\n'; }
void answer(const std::vector<unsigned>& v) {
const char* separator = "";
for (const unsigned x : v) {
std::cout << separator << x;
separator = " ";
}
std::cout << '\n';
}
void solve(const std::vector<unsigned>& b) {
const size_t n = b.size();
std::set<unsigned> s;
for (unsigned x = 1; x <= 2 * n; ++x) s.insert(x);
for (const unsigned x : b) s.erase(x);
std::vector<unsigned> a(2 * n);
for (size_t i = 0; i < n; ++i) {
const auto it = s.upper_bound(b[i]);
if (it == s.cend()) return no_answer();
a[2 * i + 0] = b[i];
a[2 * i + 1] = *it;
s.erase(it);
}
answer(a);
}
void test_case() {
size_t n;
std::cin >> n;
std::vector<unsigned> b(n);
std::cin >> b;
solve(b);
}
int main() {
size_t t;
std::cin >> t;
while (t-- > 0) test_case();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const bool TEST = false;
using ll = long long;
const ll MAXX = ll(1e18);
int n;
ll l;
ll D;
int nq = 0;
map<pair<int, ll>, ll> cache;
ll f(int i, ll x) {
if (cache.count({i, x})) return cache[{i, x}];
nq += 1;
assert(nq <= 199999);
if (TEST) return min(x / (i + 1), 5ll);
assert(0 <= i && i < n);
assert(0 <= x && x <= MAXX);
cout << "?"
<< " " << i + 1 << " " << x << '\n';
cout << flush;
ll val;
cin >> val;
cache[{i, x}] = val;
return val;
}
vector<pair<ll, ll> > ans;
mt19937 mt(48);
void solve(ll s, ll e, vector<int> ids) {
int n = ids.size();
if (n == 1) {
ans[ids.front()] = {s, e};
return;
}
int z = n / 2;
vector<int> lids;
vector<int> rids;
while (!ids.empty()) {
shuffle(ids.begin(), ids.end(), mt);
int x = ids.front();
ll l = s - 1;
ll r = e + 1;
ll loc = -1;
assert(f(x, e) - f(x, s) >= n * D);
while (l + 1 < r) {
ll m = (l + r) / 2;
bool lok = f(x, m) - f(x, s) >= z * D;
bool rok = f(x, e) - f(x, m) >= (n - z) * D;
if (lok && rok) {
loc = m;
break;
} else if (rok) {
l = m;
} else if (lok) {
r = m;
} else
assert(false);
}
assert(loc != -1);
vector<int> lt, eq, rt;
for (int x : ids) {
assert(f(x, e) - f(x, s) >= n * D);
bool lok = f(x, loc) - f(x, s) >= z * D;
bool rok = f(x, e) - f(x, loc) >= (n - z) * D;
if (lok && rok) {
eq.push_back(x);
} else if (lok) {
lt.push_back(x);
} else if (rok) {
rt.push_back(x);
} else
assert(false);
}
ids.clear();
if (lids.size() + lt.size() <= z) {
for (int x : lt) lids.push_back(x);
lt.clear();
while (!eq.empty() && (int)lids.size() < z) {
lids.push_back(eq.back());
eq.pop_back();
}
}
if (rids.size() + rt.size() <= n - z) {
for (int x : rt) rids.push_back(x);
rt.clear();
while (!eq.empty() && (int)rids.size() < n - z) {
rids.push_back(eq.back());
eq.pop_back();
}
}
for (int x : lt) ids.push_back(x);
for (int x : eq) ids.push_back(x);
for (int x : rt) ids.push_back(x);
if (ids.empty()) {
solve(s, loc, lids);
solve(loc, e, rids);
return;
}
}
assert(false);
return;
}
void answer() {
cout << "!" << '\n';
for (pair<ll, ll> x : ans) {
assert(x.first != -1 && x.second != -1);
cout << x.first << ' ' << x.second << '\n';
}
cout << flush;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> l;
D = l / n;
ans.assign(n, {-1, -1});
vector<int> ids;
for (int i = 0; i < n; i++) ids.push_back(i);
solve(0, MAXX, ids);
answer();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 21, MAXx = (1 << 20), anti = MAXx - 1;
long double sum[MAXx], dp[MAXx], prob[MAXn];
int n, k, kk;
vector<int> vec[MAXn + 2];
bool flag[MAXx];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> prob[i];
if (prob[i] > 0) kk++;
}
k = min(kk, k);
for (int i = 0; i < MAXx; i++) vec[__builtin_popcount(i)].push_back(i);
for (int i = 0; i < MAXx; i++)
for (int j = 0; j < MAXn; j++)
if ((i >> j) & 1) sum[i] += prob[j];
dp[0] = 1;
for (int i = 1; i < MAXx; i++) dp[i] = 0;
for (int i = 1; i <= k; i++)
for (int j = 0; j < vec[i].size(); j++)
for (int x = 0; x < n; x++) {
int hp = vec[i][j];
if (prob[x] == (long double)0 && ((hp >> x) & 1)) {
dp[hp] = 0;
break;
}
if ((hp >> x) & 1)
dp[hp] += (long double)(prob[x] / sum[anti ^ (hp - (1 << x))]) *
dp[(hp - (1 << x))];
}
for (int i = 0; i < n; i++) {
long double ans = 0;
for (int j = 0; j < vec[k].size(); j++)
if ((vec[k][j] >> i) & 1) ans += dp[vec[k][j]];
cout << fixed << setprecision(7) << ans << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned int get_mask(int m) {
unsigned int res = (1 << m) - 1;
res <<= (32 - m);
return res;
}
int count(vector<unsigned int> &ips, unsigned int mask) {
unsigned int pr = 1;
unsigned int temp;
int count = 0;
for (vector<unsigned int>::iterator it = ips.begin(); it != ips.end(); it++) {
temp = (*it) & mask;
if (temp != pr) {
count++;
pr = temp;
}
}
return count;
}
int main() {
int n, k;
cin >> n >> k;
vector<unsigned int> ips(n);
for (int i = 0; i < n; i++) {
unsigned int oc;
char ch;
unsigned int res = 0;
for (int j = 3; j > 0; j--) {
cin >> oc >> ch;
res += oc << (j * 8);
}
cin >> oc;
ips[i] = res + oc;
}
sort(ips.begin(), ips.end());
for (int m = 1; m < 31; m++) {
unsigned int mask = get_mask(m);
if (count(ips, mask) == k) {
for (int i = 3; i > 0; i--) {
cout << ((mask >> (i * 8)) & 255) << '.';
}
cout << (mask & 255);
return 0;
}
}
cout << -1;
}
| 3 |
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int dp[100100];
int n,l;
int a[100100];
int rec(int p){
if(0<=dp[p])return dp[p];
if(a[p-1] < a[p] && a[p] < a[p])return dp[p] = l-a[p];
int tmp = 0;
if(a[p]<a[p-1])tmp = max(tmp,rec(p-1));
if(a[p]<a[p+1])tmp = max(tmp,rec(p+1));
return dp[p]= l-a[p] + tmp;
}
int main(){
cin.tie(0);
std::ios::sync_with_stdio(false);
int ans = 0;
cin >> n >> l;
for(int i=1;i<=n;i++)cin >> a[i];
memset(dp,-1,sizeof(dp));
a[0] = a[n+1] = dp[0] = dp[n+1] = 0;
for(int i=1;i<=n;i++)ans = max(ans,rec(i));
cout << ans << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(i,n) for(ll i=0;i<n;i++)
#define ALL(a) (a).begin(),(a).end()
ll n,m;
ll p[100000],y[100000];
vector<ll> yd[100001];
int main(){
cin>>n>>m;
rep(i,m){
cin>>p[i]>>y[i];
yd[p[i]].push_back(y[i]);
}
rep(i,n){
sort(ALL(yd[i+1]));
}
rep(i,m){
printf("%012lld\n",ll(p[i])*1000000+(ll)(lower_bound(ALL(yd[p[i]]),y[i])-yd[p[i]].begin())+1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = (int)1e9 + 7;
struct edge {
int u, v, c, f;
edge() {}
edge(int u, int v, int c) : u(u), v(v), c(c), f(0) {}
int nxt(int x) { return x ^ u ^ v; }
};
struct FLOW {
int N, s, t, d[maxn], cur[maxn];
vector<edge> E;
vector<int> G[maxn];
void add_edge(int u, int v, int c) {
G[u].push_back(E.size());
E.push_back(edge(u, v, c));
G[v].push_back(E.size());
E.push_back(edge(v, u, 0));
}
bool bfs() {
for (int i = 0; i < N; i++) d[i] = -1;
queue<int> Q;
d[s] = 0;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < G[u].size(); i++) {
int id = G[u][i], v = E[id].v;
if (d[v] == -1 && E[id].f < E[id].c) {
d[v] = d[u] + 1;
Q.push(v);
}
}
}
return (d[t] != -1);
}
int dfs(int u, int flow) {
if (u == t) return flow;
for (int &i = cur[u]; i < G[u].size(); i++) {
int id = G[u][i], v = E[id].v;
if (d[v] == d[u] + 1 && E[id].c > E[id].f) {
int val = dfs(v, min(flow, E[id].c - E[id].f));
if (val) {
E[id].f += val;
E[id ^ 1].f -= val;
return val;
}
}
}
return 0;
}
int get_ans() {
int ans = 0, x;
while (bfs()) {
for (int i = 0; i < N; i++) cur[i] = 0;
while (x = dfs(s, mod)) {
ans += x;
}
}
return ans;
}
};
FLOW FF;
vector<edge> E;
vector<int> G[maxn];
int n, m, p[maxn], f[maxn], vis[maxn], sz[maxn], have[maxn], cur;
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int id = G[u][i];
if (f[id]) continue;
f[id] = 1;
int v = E[id].nxt(u);
if (vis[v]) {
cur++;
int t = u, sz = 0;
while (t != v) {
f[p[t]] = 2;
FF.add_edge(cur, E[p[t]].c + n, mod);
t = E[p[t]].nxt(t);
sz++;
}
FF.add_edge(cur, E[id].c + n, mod);
f[id] = 2;
FF.add_edge(FF.s, cur, sz);
} else {
p[v] = id;
dfs(v);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
E.push_back(edge(u, v, c));
G[u].push_back(i);
G[v].push_back(i);
}
FF.N = n + m + 2, FF.s = 0, FF.t = n + m + 1;
dfs(1);
for (int i = 0; i < m; i++)
if (f[i] == 1) FF.add_edge(FF.s, E[i].c + n, mod);
for (int i = 1; i <= m; i++) {
FF.add_edge(n + i, FF.t, 1);
}
cout << FF.get_ans() << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100007;
const int ooi = 1e9 + 7;
const long long mod = 1e9 + 7;
const long long ool = 1e18 + 7;
long long cost[maxn];
long long used[maxn];
long long has[maxn];
long long yu1;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
set<pair<long long, long long> > nowmi;
for (int i = (1); i <= (n); ++i) cin >> has[i], yu1 += has[i];
for (int i = (1); i <= (n); ++i) {
cin >> cost[i];
nowmi.insert({cost[i], i});
}
while (q--) {
long long nd;
long long kd;
cin >> kd >> nd;
if (yu1 <= 0) {
cout << 0 << endl;
continue;
}
long long c = 0;
yu1 -= nd;
if (nd <= has[kd] - used[kd]) {
used[kd] += nd;
if (used[kd] == has[kd]) nowmi.erase({cost[kd], kd});
c = cost[kd] * nd;
cout << c << endl;
continue;
}
nd -= (has[kd] - used[kd]);
c += (has[kd] - used[kd]) * cost[kd];
used[kd] = has[kd];
int ok = 0;
for (; nowmi.size() != 0;) {
auto tp = *nowmi.begin();
int pos = tp.second;
long long dt = has[pos] - used[pos];
if (dt >= nd) {
c += nd * cost[pos];
used[pos] += nd;
if (used[pos] == has[pos]) nowmi.erase(tp);
ok = 1;
break;
}
used[pos] = has[pos];
nowmi.erase(tp);
c += dt * cost[pos];
nd -= dt;
}
if (ok)
cout << c << endl;
else
cout << 0 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
char s[500005];
int x[300005], y[300005];
inline bool check(int n, int val) {
int xL = 0, xR = INT_MAX, yL = 0, yR = INT_MAX, zL = INT_MIN, zR = INT_MAX;
for (register int i = 1; i <= n; ++i) {
xL = ((xL) > (x[i] - val) ? (xL) : (x[i] - val));
xR = ((xR) < (x[i] + val) ? (xR) : (x[i] + val));
yL = ((yL) > (y[i] - val) ? (yL) : (y[i] - val));
yR = ((yR) < (y[i] + val) ? (yR) : (y[i] + val));
zL = ((zL) > (x[i] - y[i] - val) ? (zL) : (x[i] - y[i] - val));
zR = ((zR) < (x[i] - y[i] + val) ? (zR) : (x[i] - y[i] + val));
}
if (xL > xR || yL > yR || zL > zR) return 0;
if (xR - yL < zL || xL - yR > zR) return 0;
return 1;
}
int main() {
int n;
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
int len = strlen(s + 1);
for (register int j = 1; j <= len; ++j)
x[i] += (s[j] == 'B'), y[i] += (s[j] == 'N');
}
int l = 0, r = 500000, res = -1;
while (l <= r) {
int mid = l + r >> 1;
if (check(n, mid))
r = mid - 1, res = mid;
else
l = mid + 1;
}
printf("%d\n", res);
int resX, resY;
int xL = 0, xR = INT_MAX, yL = 0, yR = INT_MAX, zL = INT_MIN, zR = INT_MAX;
for (register int i = 1; i <= n; ++i) {
xL = ((xL) > (x[i] - res) ? (xL) : (x[i] - res));
xR = ((xR) < (x[i] + res) ? (xR) : (x[i] + res));
yL = ((yL) > (y[i] - res) ? (yL) : (y[i] - res));
yR = ((yR) < (y[i] + res) ? (yR) : (y[i] + res));
zL = ((zL) > (x[i] - y[i] - res) ? (zL) : (x[i] - y[i] - res));
zR = ((zR) < (x[i] - y[i] + res) ? (zR) : (x[i] - y[i] + res));
}
resX = ((xR) < (yR + zR) ? (xR) : (yR + zR)),
resY = ((yR) < (xR - zL) ? (yR) : (xR - zL));
for (register int i = 1; i <= resX; ++i) putchar('B');
for (register int i = 1; i <= resY; ++i) putchar('N');
putchar('\n');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 6e5 + 10;
pair<long long, long long> a[N], b[N];
long long limit[N][50];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
long long maxi = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
maxi = max(maxi, a[i].second);
}
for (long long i = 1; i <= m; i++) {
cin >> b[i].first >> b[i].second;
}
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; i++) {
limit[a[i].first][0] = max(limit[a[i].first][0], a[i].second);
}
for (long long i = 1; i <= maxi; i++)
limit[i][0] = max(limit[i - 1][0], limit[i][0]);
for (long long i = 1; i <= 20; i++) {
for (long long j = 0; j <= maxi; j++) {
limit[j][i] = limit[limit[j][i - 1]][i - 1];
}
}
long long res = 0;
for (long long i = 1; i <= m; i++) {
res = 0;
for (long long j = 20; j >= 0; j--) {
if (limit[b[i].first][j] < b[i].second) {
res += 1 << j;
b[i].first = limit[b[i].first][j];
}
}
if (limit[b[i].first][0] >= b[i].second)
cout << res + 1 << endl;
else
cout << -1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s, p;
cin >> s >> p;
int n = s.size();
vector<int> pos(n);
for (int c1 = 0; c1 < n; c1++) {
cin >> pos[c1];
pos[c1]--;
}
reverse(pos.begin(), pos.end());
int l = 1, r = n;
while (l <= r) {
int x = (l + r) / 2;
set<int> st;
for (int c1 = 0; c1 < x; c1++) {
st.insert(pos[c1]);
}
bool f = 0;
int p1 = 0;
for (auto it : st) {
if (s[it] == p[p1]) {
p1++;
}
if (p1 == p.size()) {
f = 1;
break;
}
}
if (f) {
r = x - 1;
} else {
l = x + 1;
}
}
cout << n - l << endl;
return 0;
}
| 1 |
// tsukasa_diary's programing contest code template
#include <bits/stdc++.h>
using namespace std;
// define
#define for_(i,a,b) for(int i=a;i<b;++i)
#define for_rev(i,a,b) for(int i=a;i>=b;--i)
#define allof(a) a.begin(),a.end()
#define minit(a,b) memset(a,b,sizeof(a))
#define size_of(a) (int)a.size()
// typedef
typedef long long lint;
typedef double Double;
typedef pair<int, int> pii;
//
typedef vector< int > Array;
typedef vector< Array > Matrix;
typedef vector< Double > DArray;
typedef vector< DArray > DMatrix;
typedef vector< string > SArray;
typedef vector< pii > PArray;
// popcount
inline int POPCNT(int _x) { return __builtin_popcount(_x); }
inline int POPCNT(lint _x) { return __builtin_popcountll(_x); }
// inf
const int iINF = 1L << 30;
const lint lINF = 1LL << 60;
// eps
Double EPS = 1e-9;
// in range
inline bool in_range(int _v, int _mx, int _mi) { return _mi <= _v && _v < _mx; }
inline bool in_range(Double _v, Double _mi, Double _mx) { return -EPS < _v - _mi && _v - _mx < EPS; }
inline bool in_range(int _x, int _y, int _W, int _H) { return 0 <= _x && _x < _W && 0 <= _y && _y < _H; }
// neighbor clockwise
const int DX[4] = {0,1,0,-1}, DY[4] = {-1,0,1,0};
const int DX_[8] = {0,1,1,1,0,-1,-1,-1}, DY_[8] = {-1,-1,0,1,1,1,0,-1};
int s_to_i(string s) {
stringstream ss(s);
int res; ss >> res;
return res;
}
int N;
string a[1010];
void solve() {
int lb = -iINF, ub = iINF;
for_(i,1,N) {
if (a[i] == "x") {
if (a[i - 1] == "x") {
cout << "none" << endl;
return;
} else {
int val = s_to_i(a[i - 1]);
if (i % 2) {
lb = max(lb, val + 1);
} else {
ub = min(ub, val - 1);
}
}
} else {
int val = s_to_i(a[i]);
if (a[i - 1] == "x") {
if (i % 2) {
ub = min(ub, val - 1);
} else {
lb = max(lb, val + 1);
}
} else {
int val2 = s_to_i(a[i - 1]);
if (i % 2) {
if (val2 >= val) {
cout << "none" << endl;
return;
}
} else {
if (val2 <= val) {
cout << "none" << endl;
return;
}
}
}
}
if (lb > ub) {
cout << "none" << endl;
return;
}
}
if (lb == ub) cout << lb << endl;
else cout << "ambiguous" << endl;
}
int main() {
while (cin >> N, N) {
for_(i,0,N) cin >> a[i];
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, mod = 20090717, inf = 2e9 + 10;
int dp[110][55][310][2], m, n;
char a[N];
int main() {
scanf("%s%d", a + 1, &m);
n = strlen(a + 1);
dp[0][0][100][1] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= m; ++j) {
for (int k = 0; k < 210; ++k) {
for (int cnt = 0; cnt <= m - j; ++cnt) {
if (a[i + 1] == 'T') {
if (cnt % 2) {
dp[i + 1][j + cnt][k + 1][1] |= dp[i][j][k][1];
if (k - 1 >= 0) dp[i + 1][j + cnt][k - 1][0] |= dp[i][j][k][0];
} else {
dp[i + 1][j + cnt][k][1] |= dp[i][j][k][0];
dp[i + 1][j + cnt][k][0] |= dp[i][j][k][1];
}
} else {
if (cnt % 2) {
dp[i + 1][j + cnt][k][1] |= dp[i][j][k][0];
dp[i + 1][j + cnt][k][0] |= dp[i][j][k][1];
} else {
dp[i + 1][j + cnt][k + 1][1] |= dp[i][j][k][1];
if (k - 1 >= 0) dp[i + 1][j + cnt][k - 1][0] |= dp[i][j][k][0];
}
}
}
}
}
}
int ans = 0;
for (int j = 0; j < 210; ++j) {
if (dp[n][m][j][0]) ans = max(ans, abs(j - 100));
if (dp[n][m][j][1]) ans = max(ans, abs(j - 100));
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, arr[1000001], k[1000001];
int main() {
scanf("%d %d", &n, &m);
if (n / m < 3)
printf("-1\n");
else {
memset(k, 0, sizeof(k));
int coun = 1;
for (int i = 1; i <= n; i++) {
if (i <= m) {
arr[i] = i;
k[i]++;
} else {
arr[i] = coun;
k[coun]++;
if (coun != m) {
if (k[coun] == (n / m)) coun++;
}
}
}
for (int i = 1; i <= n; i++) {
printf("%d", arr[i]);
if (i == n)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 4, inF = N * N * N;
int n, ans = inF;
string s[M][N];
vector<int> vec = {0, 1, 2, 3};
int check(int dex, int b) {
int res = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
res += (s[dex][i][j] - '0' != ((i + j + b) & 1));
return res;
}
int get(vector<int> vec) {
int res = 0;
for (int i = 0; i < M; i++) res += check(vec[i], i & 1);
return res;
}
int main() {
cin >> n;
for (int i = 0; i < M; i++)
for (int j = 0; j < n; j++) cin >> s[i][j];
do {
ans = min(ans, get(vec));
} while (next_permutation(vec.begin(), vec.end()));
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, cnt = 0;
long long p = 1000000007;
long long pre[100] = {0, 1};
long long a[100] = {1, 2};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long l, r, ans = 0;
cin >> l >> r;
for (int i = 2; i <= 60; i++) {
a[i] = (a[i - 2] + (1ll << i - 1)) % p;
}
for (int i = 2; i <= 60; i++) {
pre[i] = (a[i - 1] + (1ll << i - 1) - 1) % p * ((1ll << i - 1) % p) % p;
}
for (i = 1; i < 61; i++) pre[i] = (pre[i] + pre[i - 1]) % p;
long long lb, rb, nl, nr;
for (lb = 61; lb >= 0; lb--)
if (l >> lb & 1) break;
for (rb = 61; rb >= 0; rb--)
if (r >> rb & 1) break;
nl = l - (1ll << lb), nr = r - (1ll << rb) + 1;
long long x = ((a[lb] + nl - 1 + p) % p * (nl % p) % p + pre[lb]) % p;
long long y = ((a[rb] + nr - 1 + p) % p * (nr % p) % p + pre[rb]) % p;
ans = (y - x + p) % p;
cout << ans << '\n';
return ~~(0 ^ 0 ^ 0);
}
| 3 |
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int n,a[100010],b[100010];
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
if(a[i]<=n) b[a[i]]++;
}
int all=0;
for(int i=1;i<=n;i++)
if(b[i]!=0)
{
if(b[i]<i) continue;
else all+=i;
}
printf("%d",n-all);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
string Name, in;
vector<vector<int> > v(n, vector<int>(3, 0));
vector<string> names(n);
for (int i = 0; i < n; ++i) {
cin >> m;
cin >> names[i];
for (int j = 0; j < m; ++j) {
cin >> in;
char x = in[0];
bool ck = true;
for (int h = 1; h < in.length(); ++h) {
if (in[h] == '-') continue;
if (in[h] >= x) {
ck = false;
break;
}
x = in[h];
}
if (ck == true)
v[i][1]++;
else {
x = in[0];
ck = true;
for (int h = 1; h < in.length(); ++h) {
if (in[h] == '-') continue;
if (x != in[h]) {
ck = false;
break;
}
}
if (ck == true)
v[i][0]++;
else
v[i][2]++;
}
}
}
int taxiM = 0, pizzaM = 0, girlsM = 0;
for (int j = 0; j < v.size(); ++j)
if (v[j][0] > taxiM) taxiM = v[j][0];
for (int j = 0; j < v.size(); ++j)
if (v[j][1] > pizzaM) pizzaM = v[j][1];
for (int j = 0; j < v.size(); ++j)
if (v[j][2] > girlsM) girlsM = v[j][2];
string res1 = "If you want to call a taxi, you should call:";
for (int j = 0; j < v.size(); ++j)
if (v[j][0] == taxiM) res1 += " " + names[j] + ",";
string res2 = "If you want to order a pizza, you should call:";
for (int j = 0; j < v.size(); ++j)
if (v[j][1] == pizzaM) res2 += " " + names[j] + ",";
string res3 =
"If you want to go to a cafe with a wonderful girl, you should call:";
for (int j = 0; j < v.size(); ++j)
if (v[j][2] == girlsM) res3 += " " + names[j] + ",";
res1[res1.length() - 1] = '.';
res2[res2.length() - 1] = '.';
res3[res3.length() - 1] = '.';
cout << res1 << endl << res2 << endl << res3 << endl;
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n;
int x[5000], y[5000], maxn;
bool p[7000][7000];
int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
int main() {
while (true) {
memset(p, false, sizeof(p));
cin >> n;
maxn = 0;
if (n == 0) { break; }
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
p[x[i]][y[i]] = true;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
Ax = x[i];
Bx = x[j];
Ay = y[i];
By = y[j];
Cx = Ax - (By - Ay);
Cy = Ay + (Bx - Ax);
Dx = Bx - (By - Ay);
Dy = By + (Bx - Ax);
if (Cx >= 0 && Cy >= 0 && Dx >= 0 && Dy >= 0 && Cx <= 5000 && Cy <= 5000 && Dx <= 5000 && Dy <= 5000) {
if (p[Cx][Cy] == true && p[Dx][Dy] == true) {
maxn = max(maxn, (Ax - Bx)*(Ax - Bx) + (Ay - By)*(Ay - By));
}
}
}
}
cout << maxn << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100][100];
int main() {
long long i, j, n, m, t, ans = 0;
a[0][0] = 1;
for (i = 1; i < 40; i++)
for (j = 0; j <= i; j++) {
a[i][j] = a[i - 1][j];
if (j) a[i][j] += a[i - 1][j - 1];
}
cin >> n >> m >> t;
t -= 5;
for (i = 0; i <= t; i++) {
ans += a[n][i + 4] * a[m][t - i + 1];
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << " " << H;
dbg_out(T...);
}
void solve() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; i++) {
cin >> S[i];
}
int ans = 0;
for (char c = 'a'; c <= 'e'; c++) {
vector<pair<int, int>> cnt;
for (int i = 0; i < N; i++) {
int other = 0;
for (char s : S[i]) {
if (s != c) {
other++;
}
}
cnt.emplace_back(other - (S[i].size() - other), i);
}
sort(cnt.begin(), cnt.end());
int cur = 0, ccnt = 0, other = 0;
for (int i = 0; i < N; i++) {
int idx = cnt[i].second;
if (c == 'c') {
;
}
int cur_other = (cnt[i].first + S[idx].size()) / 2;
other += cur_other;
ccnt += S[idx].size() - cur_other;
if (ccnt <= other) {
break;
}
cur++;
}
ans = max(ans, cur);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test = 1;
cin >> test;
while (test--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s, t, ans;
int alphabets[128];
int i = 0;
void find_matching() {
for (i = 0; i < s.length(); ++i) ++alphabets[s[i]];
for (i = 0; i < t.length(); ++i) {
if (alphabets[t[i]] > 0) {
ans[i] = t[i];
--alphabets[t[i]];
continue;
}
break;
}
return;
}
int main() {
cin >> s >> t;
ans.resize(s.length());
find_matching();
char c = 0;
for (; i >= 0; --i) {
for (c = t[i] + 1; c <= 'z'; c++) {
if (alphabets[c] > 0) break;
}
if (c <= 'z') break;
if (i > 0) ++alphabets[t[i - 1]];
}
if (i < 0) {
cout << "-1" << endl;
return 0;
}
ans[i++] = c;
--alphabets[c];
for (char k = 'a'; k <= 'z'; k++)
while (alphabets[k]--) {
ans[i++] = k;
};
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
if (a == b)
cout << "0\n";
else {
if (a > b)
(a - b) % 2 ? cout << "2\n" : cout << "1\n";
else
(b - a) % 2 ? cout << "1\n" : cout << "2\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[102];
int main() {
int n, d, m, c = 0;
cin >> n >> d;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cin >> m;
for (int i = 0; i < m; i++) {
c += a[i];
}
if (n < m) {
c += (n - m) * d;
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200200];
int main() {
int n, l, r, m, p;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
l = 0;
r = a[n - 1];
while (l < r) {
m = (l + r) / 2;
p = 0;
for (int i = 0; i < 3; ++i) {
p = upper_bound(a + p, a + n, a[p] + m) - a;
}
if (p < n) {
l = m + 1;
} else {
r = m;
}
}
printf("%d.%c00000\n", r / 2, r % 2 == 0 ? '0' : '5');
p = 0;
for (int i = 0; i < 3; ++i) {
printf("%d.%c00000%c", (p < n ? a[p] : 0) + r / 2, r % 2 == 0 ? '0' : '5',
i == 2 ? '\n' : ' ');
p = upper_bound(a + p, a + n, a[p] + r) - a;
}
return 0;
}
| 3 |
Subsets and Splits