solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string findLongestPrefix(string a, string b) {
int aLen = a.length();
string pref = "";
for (int i = 0; i < aLen; i++) {
if (a[i] == b[i])
pref += a[i];
else
break;
}
return pref;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
string pref = findLongestPrefix(s[0], s[1]);
for (int i = 2; i < n; i++) {
pref = findLongestPrefix(pref, s[i]);
}
cout << pref.length() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int ans, n, v[10] = {1}, r1[10], r2[10], p[10], r3[10];
void dfs(int u) {
if (u == ans && v[u] == n) {
printf("%d\n", ans);
for (int i = 0; i < u; i++)
if (r2[i] + 1)
printf("lea e%cx, [e%cx + %d*e%cx]\n", r1[i] + 'a', r2[i] + 'a', p[i],
r3[i] + 'a');
else
printf("lea e%cx, [%d*e%cx]\n", r1[i] + 'a', p[i], r3[i] + 'a');
exit(0);
}
if (u == ans) return;
for (int i = 0; i <= u; i++)
for (int j = -1; j <= u; j++)
for (int k = 1; k < 9; k <<= 1) {
if (j + 1)
v[u + 1] = v[i] * k + v[j];
else
v[u + 1] = v[i] * k;
if (v[u + 1] <= v[u] || v[u + 1] > n) continue;
r1[u] = u + 1;
r2[u] = j;
p[u] = k;
r3[u] = i;
dfs(u + 1);
}
}
int main() {
int toriel = 2;
scanf("%d", &n);
for (ans = 0;; ans++) dfs(0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long a[n];
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
long long val;
val = sum / n;
val *= n;
while (val < sum || (val % n)) val++;
val /= n;
cout << val << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int pw(int x, int n, int mod) {
int ret = 1;
while (true) {
if (n & 1) ret = (long long)ret * x % mod;
if ((n >>= 1) == 0) return ret;
x = (long long)x * x % mod;
}
}
int inv(int x, int mod) { return pw(x, mod - 2, mod); }
vector<int> ans;
map<int, int> prv[2];
queue<pair<int, int> > q;
int invop(int x) { return x == 3 ? 3 : 3 - x; }
pair<int, vector<int> > reconstruct(int at, map<int, int> &prv, int p) {
vector<int> path;
while (true) {
int op = prv[at];
if (op == 0) {
reverse(path.begin(), path.end());
return make_pair(at, path);
}
path.push_back(op);
int iop = invop(op);
int to = iop == 1 ? (at + 1) % p : iop == 2 ? (at + p - 1) % p : inv(at, p);
at = to;
}
}
bool solve(int s, int t, int p) {
ans.clear();
prv[0].clear();
prv[1].clear();
q = queue<pair<int, int> >();
if (s == t) return true;
prv[0][s] = 0, prv[1][t] = 0;
q.push(make_pair(0, s));
q.push(make_pair(1, t));
while (!q.empty()) {
int side = q.front().first, at = q.front().second;
q.pop();
for (int op = (1); op <= (3); ++op) {
int to = op == 1 ? (at + 1) % p : op == 2 ? (at + p - 1) % p : inv(at, p);
if (prv[side].count(to)) continue;
if (prv[1 - side].count(to)) {
pair<int, vector<int> > a = reconstruct(at, prv[side], p);
pair<int, vector<int> > b = reconstruct(to, prv[1 - side], p);
bool swapped = false;
if (a.first == t) swap(a, b), swapped = true;
assert(a.first == s && b.first == t);
for (int i = (0); i < (((int)(a.second).size())); ++i)
ans.push_back(a.second[i]);
ans.push_back(!swapped ? op : invop(op));
for (int i = ((int)(b.second).size()) - 1; i >= 0; --i)
ans.push_back(invop(b.second[i]));
return true;
}
prv[side][to] = op;
q.push(make_pair(side, to));
}
}
return false;
}
void run() {
int s, t, p;
scanf("%d%d%d", &s, &t, &p);
assert(solve(s, t, p));
int x = s;
for (int i = (0); i < (((int)(ans).size())); ++i) {
int op = ans[i];
x = op == 1 ? (x + 1) % p : op == 2 ? (x + p - 1) % p : inv(x, p);
}
fprintf(stderr, "have=%d want=%d\n", x, t);
printf("%d\n", ((int)(ans).size()));
for (int i = (0); i < (((int)(ans).size())); ++i) {
if (i != 0) printf(" ");
printf("%d", ans[i]);
}
puts("");
}
int main() {
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, s;
while(cin >> x >> y >> s, x) {
int res = 0;
for(int i=1; i<=1000; ++i) {
for(int j=1; j<=1000; ++j) {
if(i*(100+x)/100 + j*(100+x)/100 == s) {
res = max(res, i*(100+y)/100 + j*(100+y)/100);
}
}
}
cout << res << endl;
}
}
| 0 |
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
vector<ll> X(n),Y(n),Z(n);
rep(i,n) cin>>X[i]>>Y[i]>>Z[i];
ll ma=0;
rep(i,8){
int a=1,b=1,c=1;
if(i&1) a=-1;
if(i&(1<<1)) b=-1;
if(i&(1<<2)) c=-1;
vector<ll> A(n);
rep(j,n) A[j]=a*X[j]+b*Y[j]+c*Z[j];
sort(ALL(A));
reverse(ALL(A));
ll sum=0;
rep(j,m) sum+=A[j];
ma=max(ma,sum);
}
cout<<ma<<endl;
return 0;
} | 0 |
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <ctime>
#define Rep(i, n) for (int i = 1; i <= n; i ++)
#define Rep0(i, n) for (int i = 0; i <= n; i ++)
#define RepG(i, x) for (int i = head[x]; i; i = edge[i].next)
#define v edge[i].to
#define mp(a, b) make_pair(a, b)
using namespace std;
typedef long long LL;
const int N = 400010;
char s0[N];
int len, nxt[N];
void get_nxt()
{
int j = 0;
for (int i = 2; i <= len; i ++) {
while (j && s0[i] != s0[j + 1]) j = nxt[j];
if (s0[i] == s0[j + 1]) j ++;
nxt[i] = j;
}
}
LL f[N][30], ans[30];
LL calc(int x, LL k, int c)
{
if (x == 1 || x == 0) {
int ret = 0;
Rep(i, k) if (s0[i] - 'a' + 1 == c) ret ++;
return ret;
}
if (f[x][0] == k) return f[x][c];
if (k >= f[x - 1][0])
return f[x - 1][c] + calc(x - 2, k - f[x - 1][0], c);
else return calc(x - 1, k, c);
}
int main()
{
scanf("%s", s0 + 1);
len = strlen(s0 + 1) / 2;
LL l, r;
scanf("%lld%lld", &l, &r);
get_nxt();
Rep(i, len - nxt[len]) f[0][s0[i] - 'a' + 1] ++;
Rep(i, len) f[1][s0[i] - 'a' + 1] ++;
f[0][0] = len - nxt[len], f[1][0] = len;
int x = 2;
while (true) {
Rep0(i, 26) f[x][i] = f[x - 1][i] + f[x - 2][i];
if (f[x][0] >= r) break;
x ++;
}
if (l > 1) Rep0(i, x) if (f[i][0] >= l - 1) {
Rep(j, 26) ans[j] -= calc(i, l - 1, j);
break;
}
Rep0(i, x) if (f[i][0] >= r) {
Rep(j, 26) ans[j] += calc(i, r, j);
break;
}
Rep(i, 26) printf("%lld ", ans[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
long long x, y, level, ht;
double ans = -1;
cin >> a >> x >> y;
double c = (double)a;
if (y % a != 0) {
level = y / a;
if (level == 0) {
if (x < c / 2 && x > -c / 2) ans = 1;
} else {
ans = ((double)level * 3) / 2;
if (level % 2) {
if (x < c / 2 && x > -c / 2)
ans = ans;
else {
ans = -1;
}
} else {
if (x > 0 && x < a)
ans = ans + 1;
else if (x < 0 && x > -a)
ans = ans;
else {
ans = -1;
}
}
}
} else
ans = -1;
cout << ceil(ans) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
template <class Iter>
void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
template <unsigned MOD_>
struct ModInt {
static const unsigned MOD = MOD_;
unsigned x;
void undef() { x = (unsigned)-1; }
bool isnan() const { return x == (unsigned)-1; }
inline int geti() const { return (int)x; }
ModInt() { x = 0; }
ModInt(const ModInt &y) { x = y.x; }
ModInt(int y) {
if (y < 0 || (int)MOD <= y) y %= (int)MOD;
if (y < 0) y += MOD;
x = y;
}
ModInt(unsigned y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt(long long y) {
if (y < 0 || MOD <= y) y %= MOD;
if (y < 0) y += MOD;
x = y;
}
ModInt(unsigned long long y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt &operator+=(const ModInt y) {
if ((x += y.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt y) {
if ((x -= y.x) & (1u << 31)) x += MOD;
return *this;
}
ModInt &operator*=(const ModInt y) {
x = (unsigned long long)x * y.x % MOD;
return *this;
}
ModInt &operator/=(const ModInt y) {
x = (unsigned long long)x * y.inv().x % MOD;
return *this;
}
ModInt operator-() const { return (x ? MOD - x : 0); }
ModInt inv() const { return pow(MOD - 2); }
ModInt pow(long long y) const {
ModInt b = *this, r = 1;
if (y < 0) {
b = b.inv();
y = -y;
}
for (; y; y >>= 1) {
if (y & 1) r *= b;
b *= b;
}
return r;
}
ModInt extgcd() const {
unsigned a = MOD, b = x;
int u = 0, v = 1;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0) u += MOD;
return ModInt(u);
}
friend ModInt operator+(ModInt x, const ModInt y) { return x += y; }
friend ModInt operator-(ModInt x, const ModInt y) { return x -= y; }
friend ModInt operator*(ModInt x, const ModInt y) { return x *= y; }
friend ModInt operator/(ModInt x, const ModInt y) { return x *= y.inv(); }
friend bool operator<(const ModInt x, const ModInt y) { return x.x < y.x; }
friend bool operator==(const ModInt x, const ModInt y) { return x.x == y.x; }
friend bool operator!=(const ModInt x, const ModInt y) { return x.x != y.x; }
};
const long long MOD = 998244353;
const int MAX = 2000011;
ModInt<MOD> inv[MAX], fact[MAX], fact_inv[MAX];
void init() {
fact[0] = 1;
for (int i = 1; i < MAX; i++) fact[i] = fact[i - 1] * i;
fact_inv[MAX - 1] = fact[MAX - 1].inv();
for (int i = MAX - 2; i >= 0; i--) fact_inv[i] = fact_inv[i + 1] * (i + 1);
inv[0] = 0;
for (int i = 1; i < MAX; i++) inv[i] = fact_inv[i] * fact[i - 1];
}
ModInt<MOD> nCk(int n, int k) {
if (k < 0 || n < k) return 0;
return fact[n] * fact_inv[k] * fact_inv[n - k];
}
int N;
char S[1000011];
void MAIN() {
init();
scanf("%s", S);
N = strlen(S);
int a = 0;
int b = count(S, S + N, ')');
int c = 0;
int d = count(S, S + N, '?');
int t = d;
int r = b + d;
ModInt<MOD> ans = 0, val = 0;
for (int i = 0, i_len = (r); i < i_len; ++i) val += nCk(t, i);
for (int i = 0, i_len = (N); i < i_len; ++i) {
if (S[i] == ')') {
b--;
r--;
val -= nCk(t, r);
}
if (S[i] == '?') {
d--;
t--;
r--;
val = (val - nCk(t, r)) / 2;
}
if (S[i] == '(' || S[i] == '?') {
ans += val;
}
if (S[i] == '(') {
a++;
r--;
val -= nCk(t, r);
}
if (S[i] == '?') {
c++;
val = val * 2 - nCk(t, r - 1);
t++;
}
}
printf("%d\n", ans.geti());
}
int main() {
int TC = 1;
for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, sum = 0, k = 0, min = 100;
cin >> n;
for (i = 0; i < n; i++) {
cin >> j;
if (j % 2 != 0) {
k++;
if (j < min) {
min = j;
}
}
sum += j;
}
if (k == 0) {
cout << 0;
} else {
if (k % 2 == 0) {
sum -= min;
}
cout << sum;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int tree[110000];
int cc[110000];
int find(int x) {
if (x == tree[x]) return x;
int fa = tree[x];
tree[x] = find(tree[x]);
cc[x] = (cc[x] + cc[fa]) % 1000000007;
return tree[x];
}
int main() {
int i, j, h;
int T, n, m;
int a, b, c;
int k, v, x;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) {
tree[i] = i;
cc[i] = 0;
}
long long ans = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &k);
for (j = 1; j <= k; j++) {
scanf("%d %d", &v, &x);
int fa = find(i);
int fb = find(v);
int sum = cc[v] + x;
if (fa != fb) {
tree[fb] = tree[fa];
cc[fb] = (cc[i] + sum) % 1000000007;
}
ans += sum;
while (ans < 0) ans += 1000000007;
ans %= 1000000007;
}
}
printf("%I64d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
const int N = (int)1e6 + 11;
int n, m, l, r, ans = INT_MIN, maxdiff = INT_MIN;
vi a, b;
void solve() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
b.resize(m);
for (int i = 0; i < m; i++) cin >> b[i];
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
for (int i = 0; i <= n; i++) {
int x, y;
if (i == n) {
int idx = m, idx1 = n;
x = idx1 * 2, y = idx * 2;
} else {
int idx = std::upper_bound((b).begin(), (b).end(), a[i] - 1) - b.begin(),
idx1;
idx1 = std::upper_bound((a).begin(), (a).end(), a[i] - 1) - a.begin();
x = idx1 * 2 + (n - idx1) * 3, y = idx * 2 + (m - idx) * 3;
}
if (maxdiff < (x - y) or (maxdiff == (x - y) and ans < x))
ans = x, l = x, r = y, maxdiff = x - y;
}
cout << l << ":" << r << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
const long long MOD1 = 1e9 + 7;
const long long MOD2 = 998244353;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const double PI = 3.1415926535897932384626;
const long long MAX_SIZE = 2e6 + 6;
const long long MAX = INT_MAX;
const long long MIN = INT_MIN;
bool prime[MAX_SIZE];
void sieve() {
memset(prime, true, sizeof(prime));
for (long long i = 2; i * i <= MAX_SIZE; i++) {
if (prime[i] == true) {
for (long long j = i * i; j <= MAX_SIZE; j += i) prime[j] = false;
}
}
}
long long powerM(long long x, long long y, long long M = MOD1) {
long long v = 1;
x = x % M;
while (y > 0) {
if (y & 1) v = (v * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return v;
}
long long power(long long x, long long y) {
long long v = 1;
while (y > 0) {
if (y & 1) v = v * x;
y = y >> 1;
x = x * x;
}
return v;
}
bool Is_Power_Of_Two(long long x) { return x && (!(x & (x - 1))); }
string Print_LCS(string x, string y) {
long long n = x.length(), m = y.length(), dp[n + 1][m + 1], i, j;
memset(dp, 0, sizeof(dp));
for (i = 1; i < n + 1; i++) {
for (j = 1; j < m + 1; j++) {
if (x[i - 1] == y[j - 1])
dp[i][j] = 1 + dp[i - 1][j - 1];
else
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
string str = "";
i = n, j = m;
while (i > 0 && j > 0) {
if (x[i - 1] == y[j - 1])
str += x[i - 1], i--, j--;
else
dp[i - 1][j] > dp[i][j - 1] ? i-- : j--;
}
reverse(str.begin(), str.end());
return str;
}
bool Compare(pair<long long, long long> A, pair<long long, long long> B) {
if (A.first == B.first) return A.second < B.second;
return A.first < B.first;
}
pair<long long, long long> a[3001];
long long n;
const long long inf = -1000000000000;
long long dp[3001][3001];
long long getAns(long long curr, long long pre) {
if (curr >= n) return 0;
if (dp[curr][pre] != inf) return dp[curr][pre];
long long x = a[curr].second + getAns(curr + 1, curr);
long long y = abs(a[curr].first - a[pre].first) + getAns(curr + 1, pre);
return dp[curr][pre] = min(x, y);
}
void Solve() {
long long i, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
for (i = 0; i < 3001; i++)
for (j = 0; j < 3001; j++) dp[i][j] = inf;
sort(a, a + n);
long long ans = getAns(1, 0) + a[0].second;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, m, x;
cin >> n >> m;
x = n + m;
string s;
for (long long i = 0; i < x; i++) {
if (i >= 2 && s[i - 1] == '1' && s[i - 2] == '1') {
s += '0';
n--;
} else if (i > 0 && s[i - 1] == '0') {
s += '1';
m--;
} else if (n > m) {
s += '0';
n--;
} else {
s += '1';
m--;
}
if (n < 0 || m < 0) {
cout << "-1\n";
return 0;
}
}
if (n != 0 || m != 0)
cout << "-1\n";
else
cout << s << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
long long wupin[350];
vector<long long> mp[350];
long long a[350];
long long b[350];
long long dp[150000];
long long degree[150000];
long long vis[150000];
long long n, q, t;
void Top() {
queue<long long> s;
memset(dp, 0, sizeof(dp));
for (long long i = 1; i <= n; i++)
if (degree[i] == 0) s.push(i);
long long cnt = 0;
int cont = 0;
while (!s.empty()) {
long long u = s.front();
s.pop();
cont++;
if (vis[u] > 0) t -= a[u] - b[u];
if (a[u] <= t) wupin[cnt++] = a[u];
for (long long i = 0; i < mp[u].size(); i++) {
long long v = mp[u][i];
a[v] += a[u];
degree[v]--;
if (degree[v] == 0) s.push(v);
}
}
dp[0] = 1;
for (long long i = 0; i < cnt; i++) {
for (long long j = wupin[i]; j <= t; j++) {
dp[j] += dp[j - wupin[i]];
dp[j] %= mod;
}
}
if (t >= 0 && cont == n)
printf(
"%lld"
"\n",
dp[t]);
else
printf("0\n");
}
int main() {
while (
~scanf("%lld"
"%lld"
"%lld",
&n, &q, &t)) {
memset(vis, 0, sizeof(vis));
memset(degree, 0, sizeof(degree));
for (long long i = 1; i <= n; i++) mp[i].clear();
for (long long i = 1; i <= n; i++) scanf("%I64d", &a[i]), b[i] = a[i];
for (long long i = 0; i < q; i++) {
long long x, y;
scanf(
"%lld"
"%lld",
&x, &y);
vis[x]++, vis[y]++;
mp[x].push_back(y);
degree[y]++;
}
Top();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
vector<long long> dp(s.size());
int prevb = -1;
int preva = -1;
int prevva = -1;
long long pos = 1;
int n = s.size();
vector<long long> apos(n + 1);
vector<long long> pr(n + 1);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'a') {
if (prevb != -1 && preva != -1 && preva < prevb) {
dp[i] = dp[preva] * 2 + 1;
pos++;
apos[pos] += apos[pos - 1];
prevva = preva;
} else if (preva != -1) {
dp[i] = dp[preva] + 1;
if (prevva != -1) dp[i] += dp[prevva];
} else
dp[i] = 1;
apos[pos]++;
preva = i;
}
if (s[i] == 'b') prevb = i;
dp[i] = dp[i] % (long long)(1e9 + 7);
}
long long res = 0;
for (int i = 0; i < n; ++i) {
if (dp[i]) res = dp[i];
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 2 * 1000000000;
long long int i, j;
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
long long int mod(long long a, long long b) { return (a % b + b) % b; }
long long int isPrime(long long int n) {
if (n <= 3) return (1);
if (n % 2 == 0 || n % 3 == 0) return (0);
for (i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return (0);
return (1);
}
long long int smallestDivisor(long long int n) {
if (n % 2 == 0) return 2;
for (i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
long long int countDivisors(long long int n) {
long long int cnt = 0;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
long long maxPrimeFactors(long long n) {
long long maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) maxPrime = n;
return maxPrime;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
long long int tt = 1;
while (tt--) {
long long int n;
cin >> n;
vector<long long int> v;
v.push_back(0);
long long int sum = 0, z = 1;
long long int a[200005] = {0};
while (n--) {
long long int k;
cin >> k;
if (k == 2) {
long long int temp;
cin >> temp;
v.push_back(temp);
sum += temp;
z++;
double avg = (double)sum / z;
cout << fixed << setprecision(10) << avg << "\n";
} else if (k == 1) {
long long int a1, x1;
cin >> a1 >> x1;
if (a1 <= z) {
a[a1 - 1] += x1;
sum += a1 * x1;
} else {
a[z - 1] += x1;
sum += z * x1;
}
double avg = (double)sum / z;
cout << fixed << setprecision(10) << avg << "\n";
} else {
sum -= v[v.size() - 1];
sum -= a[z - 1];
a[z - 2] += a[z - 1];
a[z - 1] = 0;
z--;
v.pop_back();
double avg = (double)sum / z;
cout << fixed << setprecision(10) << avg << "\n";
}
}
}
}
| 3 |
#include <iostream>
using namespace std;
typedef long long ll;
ll n, f[310][310], ans;
int main(void){
// Your code here!
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> f[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ll res = 11000000000;
if (i == j) continue;
for (int k = 0; k < n; k++) {
if (i == k || j == k) continue;
res = min(res, f[i][k] + f[j][k]);
}
if (res < f[i][j]) {
cout << -1 << endl;
return 0;
} if (res > f[i][j]) {
ans += f[i][j];
}
}
}
cout << ans / 2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int modulas(int a, int n) {
if (n == 0) return 1;
long long int ans = modulas(a, n / 2);
ans = (ans * ans) % 998244353;
if (n % 2) ans = (ans * a) % 998244353;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, i, j, k;
cin >> n;
int p[n];
for (i = 0; i < n; i++) cin >> p[i];
int a = 0;
long long int Y = 1;
int inv = modulas(100, 998244353 - 2);
for (i = 0; i < n; i++) {
long long int c = (Y * (100 - p[i])) % 998244353;
c = (inv * c) % 998244353;
c = (c * (i + 1)) % 998244353;
a = (a + c) % 998244353;
Y = (Y * p[i]) % 998244353;
Y = (Y * inv) % 998244353;
}
Y = modulas(Y, 998244353 - 2);
cout << (Y * a) % 998244353 + n << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using vint = vector<int>;
using vll = vector<ll>;
using vld = vector<ld>;
using vpii = vector<pii>;
using vpil = vector<pil>;
using vpli = vector<pli>;
using vpll = vector<pll>;
const int N = 200005;
int chk[N][3];
ll d[N][3];
const ll INF = ll(1e18);
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vint> e(n + 1);
vint h(n + 1);
vll a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 0; i < n - 1; i++) {
int first, second;
cin >> first >> second;
e[first].push_back(second);
e[second].push_back(first);
}
function<ll(int, int, int)> f = [&](int first, int c, int second) {
if (first > 1 &&
((c > 0 && h[second] > h[first]) || (c < 0 && h[second] < h[first])))
return INF;
if (chk[first][c + 1]) return d[first][c + 1];
ll &r = d[first][c + 1];
int bc = c;
ll bs = 0;
vll v;
for (int i : e[first]) {
if (i == second) continue;
ll A = f(i, 1, first);
ll B = f(i, -1, first);
if (A == INF) {
bs += B;
bc++;
} else if (B == INF) {
bs += A;
bc--;
} else {
bs += A;
bc--;
v.push_back(B - A);
}
}
sort(v.begin(), v.end());
ll mc = ll(e[first].size() + 1) / 2;
r = (mc + abs(bc) / 2) * a[first] + bs;
for (int i = 0; i < v.size(); i++) {
bs += v[i];
bc += 2;
r = min(r, (mc + abs(bc) / 2) * a[first] + bs);
}
chk[first][c + 1] = 1;
return r;
};
cout << f(1, 0, 0) << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001;
const int maxm = 100010;
bitset<maxn> mat[maxn];
int n, m, q, ans[maxm], ret;
vector<int> link[maxm];
struct Query {
int ty, i, j;
};
Query Q[maxm];
void dfs(int p) {
int r, c;
bool tp;
if (Q[p].ty == 1) {
r = Q[p].i, c = Q[p].j;
tp = mat[r][c - 1];
ret += !tp;
mat[r].set(c - 1);
} else if (Q[p].ty == 2) {
r = Q[p].i, c = Q[p].j;
tp = mat[r][c - 1];
ret -= tp;
mat[r].reset(c - 1);
} else if (Q[p].ty == 3) {
r = Q[p].i;
c = 0;
for (int i = 0; i < m; ++i) {
c += !mat[r][i];
mat[r].flip(i);
}
ret += 2 * c - m;
}
ans[p] = ret;
for (int i = 0; i < (int)link[p].size(); ++i) {
dfs(link[p][i]);
}
if (Q[p].ty == 1) {
ret -= !tp;
mat[r][c - 1] = tp;
} else if (Q[p].ty == 2) {
ret += tp;
mat[r][c - 1] = tp;
} else if (Q[p].ty == 3) {
ret -= 2 * c - m;
for (int i = 0; i < m; ++i) mat[r].flip(i);
}
}
int fa[maxm];
int find(int x) { return x != fa[x] ? find(fa[x]) : x; }
int main() {
while (~scanf("%d%d%d", &n, &m, &q)) {
ret = 0;
Q[0].ty = 0;
for (int i = 0; i <= n; ++i) mat[i].reset();
for (int i = 0; i <= q; ++i) fa[i] = i, link[i].clear();
for (int i = 1, x; i <= q; ++i) {
scanf("%d", &Q[i].ty);
if (Q[i].ty <= 2)
scanf("%d%d", &Q[i].i, &Q[i].j);
else
scanf("%d", &Q[i].i);
if (Q[i].ty == 4) {
x = find(Q[i].i);
fa[i] = x;
} else {
x = find(i - 1);
}
link[x].push_back(i);
}
dfs(0);
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
//#define che
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define MK make_pair
#define PB push_back
#define fi first
#define se second
typedef long long LL;
typedef pair<int, int> PII;
const int N=3e5 +10 ;
const LL MOD = 1e9+7;
int pre[N], n, nxt[3];
LL f[N]; char s[N];
int main(){
#ifdef che
freopen("input.txt","rt",stdin);
freopen("output.txt","wt",stdout);
#endif
scanf("%s", s); n=strlen(s);
for (int i=0; i<n; ++i) pre[i+1] =( pre[i] + (s[i]-'a'+1))%3;
bool flag= false;
for (int i=0; i+1 < n; ++i)
if ( s[i] ==s[i+1] ) flag= true;
if ( !flag){
puts("1"); return 0;
}
for (int i=0; i<3; ++i) nxt[i] = i==pre[n] ? n: n+1;
f[n] = 1;
for (int i=n; i--; ){
f[i] = i&&pre[i] == pre[n];
for (int c=0; c<2; ++c)
f[i] =(f[i] + f[ nxt[(pre[i]+c+1)%3] ])%MOD;
nxt[ pre[i]] = i;
}
cout<<f[0]<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, b, temp;
cin >> n >> b;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
temp = b;
for (long long i = 0; i < n - 1; i++) {
for (long long j = i + 1; j < n; j++) {
temp = max(temp, (b % a[i]) + ((b / a[i]) * a[j]));
}
}
cout << temp;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.141592653589793238462643383279;
const double EPS = 1e-9;
const long long MOD = 1000000007;
const int inf = 1 << 30;
const long long linf = 1LL << 60;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace LCA {
vector<vector<int>> G;
int root;
int MAX_LOG_N;
vector<vector<int>> parent;
vector<int> depth;
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (int i = 0; i < (int)G[v].size(); i++) {
if (G[v][i] != p) dfs(G[v][i], v, d + 1);
}
}
void init(int V, vector<vector<int>> _G, int root) {
{
int tmp = 1;
MAX_LOG_N = 1;
while (tmp <= V) {
tmp *= 2;
MAX_LOG_N++;
}
}
parent.resize(MAX_LOG_N, vector<int>(V));
depth.resize(V);
G = _G;
dfs(root, -1, 0);
for (int k = 0; k + 1 < MAX_LOG_N; k++) {
for (int v = 0; v < V; v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
int get_kth_parent(int v, int k) {
for (int i = MAX_LOG_N - 1; i >= 0; i--) {
if ((1 << i) > k) continue;
v = parent[i][v];
k -= (1 << i);
}
return v;
}
int lca(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
for (int k = 0; k < MAX_LOG_N; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = MAX_LOG_N - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
} // namespace LCA
int n;
vector<vector<int>> e;
vector<pair<int, int>> e2[200000];
int ord[200000];
int v[200000], s[200000], u[200000];
int rv[200000], ru[200000];
long long dist[200000];
int infe[200000];
void dfs(int v, int p, int& pos) {
ord[v] = pos++;
for (int to : e[v]) {
if (to == p) continue;
dfs(to, v, pos);
}
}
int main() {
scanf("%d", &n);
e.resize(n);
for (int i = 0; i < (int)n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
e[x].push_back(y);
e[y].push_back(x);
}
int tmp = 0;
dfs(0, -1, tmp);
LCA::init(n, e, 0);
int q;
scanf("%d", &q);
memset(rv, -1, sizeof(rv));
memset(ru, -1, sizeof(ru));
for (int i = 0; i < (int)q; i++) {
int k, m;
scanf("%d%d", &k, &m);
vector<int> vers(k + m);
for (int j = 0; j < (int)k; j++) {
scanf("%d%d", v + j, s + j);
v[j]--;
vers[j] = v[j];
rv[v[j]] = j;
}
for (int j = 0; j < (int)m; j++) {
scanf("%d", u + j);
u[j]--;
vers[j + k] = u[j];
ru[u[j]] = j;
}
sort(vers.begin(), vers.end(),
[&](const int& l, const int& r) { return ord[l] < ord[r]; });
for (int j = 1; j < k + m; j++) {
int com = LCA::lca(vers[j - 1], vers[j]);
vers.push_back(com);
}
sort(vers.begin(), vers.end());
vers.erase(unique(vers.begin(), vers.end()), vers.end());
int N = vers.size();
sort(vers.begin(), vers.end(),
[&](const int& l, const int& r) { return ord[l] < ord[r]; });
vector<int> sta;
sta.push_back(vers[0]);
for (int j = 1; j < N; j++) {
while (true) {
if (LCA::lca(sta.back(), vers[j]) == sta.back()) break;
sta.pop_back();
}
e2[sta.back()].push_back(pair<int, int>(
vers[j], LCA::depth[vers[j]] - LCA::depth[sta.back()]));
e2[vers[j]].push_back(pair<int, int>(
sta.back(), LCA::depth[vers[j]] - LCA::depth[sta.back()]));
sta.push_back(vers[j]);
}
priority_queue<pair<pair<long long, long long>, int>,
vector<pair<pair<long long, long long>, int>>,
greater<pair<pair<long long, long long>, int>>>
que;
for (int ve : vers) {
dist[ve] = linf;
infe[ve] = -1;
if (rv[ve] != -1) {
dist[ve] = 0;
infe[ve] = rv[ve];
que.push(pair<pair<long long, long long>, int>(
pair<long long, long long>(
(dist[ve] + s[infe[ve]] - 1) / s[infe[ve]], infe[ve]),
ve));
}
}
while (!que.empty()) {
pair<pair<long long, long long>, int> q = que.top();
que.pop();
for (pair<int, int> E : e2[q.second]) {
int to = E.first, cost = E.second;
if (infe[to] == -1) {
dist[to] = dist[q.second] + cost;
infe[to] = infe[q.second];
que.push(pair<pair<long long, long long>, int>(
pair<long long, long long>(
(dist[to] + s[infe[to]] - 1) / s[infe[to]], infe[to]),
to));
continue;
}
long long ti = (dist[to] + s[infe[to]] - 1) / s[infe[to]];
if (pair<long long, long long>(ti, infe[to]) >
pair<long long, long long>(
(dist[q.second] + cost + s[infe[q.second]] - 1) /
s[infe[q.second]],
infe[q.second])) {
dist[to] = dist[q.second] + cost;
infe[to] = infe[q.second];
que.push(pair<pair<long long, long long>, int>(
pair<long long, long long>(
(dist[to] + s[infe[to]] - 1) / s[infe[to]], infe[to]),
to));
}
}
}
vector<int> out(m);
for (int ve : vers) {
if (ru[ve] == -1) continue;
out[ru[ve]] = infe[ve] + 1;
}
for (int o : out) printf("%d ", o);
puts("");
for (int ve : vers) e2[ve].clear();
for (int j = 0; j < (int)k; j++) {
rv[v[j]] = -1;
}
for (int j = 0; j < (int)m; j++) {
ru[u[j]] = -1;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv, last_id;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
void clear() {
for (register int i = 1; i <= tot; i++) head[v[i] % mod] = 0;
tot = 0;
v.clear();
val.clear();
nxt.clear();
v.resize(1);
val.resize(1);
nxt.resize(1);
have_ans = 0;
}
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
last_id = i;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
if (count(x)) {
val[last_id] = y;
lastans = y;
return;
}
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
long long ans[55];
long long a, b, m;
int T;
int main() {
read(T);
while (T--) {
read(a);
read(b);
read(m);
if (a == b) {
print(1, ' '), print(a, '\n');
continue;
}
long long now = 1;
bool ok = 0;
for (register int len = 2; len <= 50; len++) {
long long qaq = b - a * now - now;
if (qaq < 0) break;
long long now2 = now;
for (register int i = 2; i < len; i++) {
now2 >>= 1;
long long tmp = min(m - 1, qaq / now2);
qaq -= now2 * tmp;
ans[i] = tmp;
}
if (qaq >= m) {
now <<= 1;
continue;
}
ans[len] = qaq;
ok = 1;
long long sum = a;
print(len, ' ');
print(a, ' ');
for (register int i = 2; i <= len; i++) {
++ans[i];
ans[i] += sum;
sum += ans[i];
print(ans[i], ' ');
}
putchar('\n');
break;
}
if (!ok) print(-1, '\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[1001][1001], b[1001] = {0}, c[1001] = {0}, d[1000001], e[1000001];
int main() {
ifstream inf("input.txt");
long long n, m, k, p;
cin >> n >> m >> k >> p;
for (int i = 1; i <= n; i++)
for (int i1 = 1; i1 <= m; i1++) cin >> a[i][i1];
for (int i = 1; i <= n; i++)
for (int i1 = 1; i1 <= m; i1++) b[i] += a[i][i1];
for (int i = 1; i <= m; i++)
for (int i1 = 1; i1 <= n; i1++) c[i] += a[i1][i];
priority_queue<long long> p1, p2;
for (int i = 1; i <= n; i++) p1.push(b[i]);
d[0] = 0;
for (int i = 1; i <= k; i++) {
long long r = p1.top();
d[i] = d[i - 1] + r;
p1.pop();
p1.push(r - m * p);
}
for (int i = 1; i <= m; i++) p2.push(c[i]);
e[0] = 0;
for (int i = 1; i <= k; i++) {
long long r = p2.top();
e[i] = e[i - 1] + r;
p2.pop();
p2.push(r - n * p);
}
long long ans = d[0] + e[k];
for (int i = 1; i <= k; i++)
if (d[i] + e[k - i] - i * (k - i) * p > ans)
ans = d[i] + e[k - i] - i * (k - i) * p;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int temp, yes_count = 0;
int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 49, 25, 9, 4, 53};
string ans;
float sq;
cout << a[0] << endl;
fflush(stdout);
cin >> ans;
for (int i = 1; i < 20; i++) {
if (ans == "yes") {
yes_count++;
}
if (yes_count > 1) {
break;
}
cout << a[i] << endl;
fflush(stdout);
cin >> ans;
}
if (ans == "yes") yes_count++;
if (yes_count > 1) {
cout << "composite" << endl;
} else {
cout << "prime" << endl;
}
fflush(stdout);
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int ans=1,n,k;
cin>>n>>k;
for(int i=1;i<=n;i++)ans+=min(ans,k);
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
long long n;
long long vals[MAXN];
long long pref[MAXN];
long long cnt1[MAXN];
long long pr[MAXN];
inline void init() {}
inline void solve() {
init();
long long ans = 0;
for (long long i = 0; i < n; i++) {
cin >> vals[i];
vals[i] = __builtin_popcountll(vals[i]);
}
for (long long i = 0; i < n; i++) {
pref[i] = (i == 0 ? 0ll : pref[i - 1]) + vals[i];
if (pref[i] % 2 == 0) {
cnt1[i] = 1;
} else {
cnt1[i] = 0;
}
}
for (long long i = n - 1; i >= 0; i--) {
pr[i] = (i == n - 1 ? 0ll : pr[i + 1]) + cnt1[i];
}
for (long long i = 0; i < n; i++) {
long long mx = 0;
long long sum = 0;
for (long long j = i; j < min(i + 500, n); j++) {
sum += vals[j];
mx = max(mx, vals[j]);
if (sum % 2 == 0 && mx * 2 > sum) {
ans--;
}
}
long long all_even = pr[i];
if (i == 0 || pref[i - 1] % 2 == 0) {
ans += all_even;
} else {
ans += n - i - all_even;
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while (cin >> n) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, x, y, i, j, m[100005], p[100005];
string s;
int main() {
cin >> n >> k >> s;
while (i < n) {
m[i] = m[i - 1];
if (s[i] == 'b') {
m[i]++;
}
i++;
}
i = 0;
while (i < n) {
while (m[j] - m[i - 1] <= k && j < n) {
a = max(a, j - i);
j++;
}
i++;
}
i = 0;
j = 0;
while (i < n) {
p[i] = p[i - 1];
if (s[i] == 'a') {
p[i]++;
}
i++;
}
i = 0;
while (i < n) {
while (p[j] - p[i - 1] <= k && j < n) {
b = max(b, j - i);
j++;
}
i++;
}
cout << max(a, b) + 1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n - 1; i++) {
if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
cout << "YES"
<< "\n";
cout << i << " " << i + 1 << " " << i + 2 << "\n";
return;
}
}
cout << "NO"
<< "\n";
return;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1234500;
namespace SAM {
int ch[maxn][26], fa[maxn], maxlen[maxn], tot, end, cnt;
long long siz[maxn], res[maxn];
char ans[100010];
void init() {
memset(ch, 0, sizeof(ch));
memset(fa, 0, sizeof(fa));
tot = 2, end = 1, cnt = 0;
}
inline int idx(char c) { return c - 'a'; }
void insert(char c) {
cnt++;
c = idx(c);
int p = end, np = tot++;
maxlen[np] = maxlen[end] + 1;
while (p && !ch[p][c]) ch[p][c] = np, p = fa[p];
if (p) {
int q = ch[p][c];
if (maxlen[p] + 1 == maxlen[q])
fa[np] = q;
else {
int nq = tot++;
maxlen[nq] = maxlen[p] + 1;
memcpy(ch[nq], ch[q], sizeof(int) * 26);
fa[nq] = fa[q];
fa[q] = fa[np] = nq;
while (ch[p][c] == q) ch[p][c] = nq, p = fa[p];
}
} else
fa[np] = 1;
end = np;
}
void dfs(int x) {
if (res[x]) return;
for (int i = 0; i < 26; i++)
if (ch[x][i]) {
dfs(ch[x][i]);
siz[x] += siz[ch[x][i]];
res[x] += res[ch[x][i]];
}
res[x] += siz[x];
}
void getans(int k, int x, char* ans, int c) {
if (k <= siz[x]) {
*ans = c + 'a';
*++ans = 0;
return;
}
k -= siz[x];
for (int i = 0; i < 26; i++)
if (ch[x][i]) {
if (k <= res[ch[x][i]]) {
*ans = c + 'a';
getans(k, ch[x][i], ans + 1, i);
return;
}
k -= res[ch[x][i]];
}
}
void slove() {
int p = end, t;
scanf("%d", &t);
if (1ll * t > 1ll * cnt * (cnt + 1) / 2)
puts("No such line.");
else {
while (p) siz[p] = 1, p = fa[p];
dfs(1);
siz[1] = 0;
getans(t, 1, ans, 0);
puts(ans + 1);
}
}
} // namespace SAM
int main() {
SAM::init();
for (char c = getchar(); c - '\n'; c = getchar()) SAM::insert(c);
SAM::slove();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, N = 1e5 + 5, INF = 1e18;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n / 2; i++) {
if ((n - i) % i == 0) ans++;
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tk, typename Tv>
ostream& operator<<(ostream& os, const pair<Tk, Tv>& p) {
os << "{" << p.first << ',' << p.second << "}";
return os;
}
const int MAX = 100005;
const int MOD = 1000000000 + 7;
const int INF = 1000000000;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
vector<bool> canBreak2(n, false), canBreak3(n, false);
canBreak2[n - 2] = true;
canBreak3[n - 3] = true;
for (int i = n - 4; i >= 0; i--) {
string subA = s.substr(i, 2);
string subB = s.substr(i + 2, 2);
if (subA != subB) {
if (canBreak2[i + 2]) canBreak2[i] = true;
}
if (canBreak3[i + 2]) canBreak2[i] = true;
subA = s.substr(i, 3);
subB = s.substr(i + 3, 3);
if (subA != subB) {
if (canBreak3[i + 3]) canBreak3[i] = true;
}
if (canBreak2[i + 3]) canBreak3[i] = true;
}
set<string> possible;
for (int i = 5; i < n; i++) {
if (canBreak2[i]) {
possible.insert(s.substr(i, 2));
}
if (canBreak3[i]) {
possible.insert(s.substr(i, 3));
}
}
cout << possible.size() << endl;
for (set<string>::iterator i = possible.begin(); i != possible.end(); i++) {
cout << *i << endl;
}
cout << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t,n;
int count = 0;
cin>>t;
string s;
string ne;
while(t--){
cin>>n;
cin>>s;
sort(s.begin(),s.end());
cout<<s<<endl;
}
} | 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000010LL;
const int mod = 1000000007;
const int MAXN = 200010;
int n, m, u, v, x, y, t, a, b, ans, cnt, mx;
int A[MAXN];
int mn[MAXN];
stack<int> st;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
A[0] = inf;
st.push(0);
for (int i = 1; i <= n; i++) {
while (A[st.top()] < A[i]) st.pop();
mn[i] = st.top();
st.push(i);
}
for (int i = 1; i <= n; i++)
if ((i - mn[i] + 1) % 2) return cout << "NO" << '\n', 0;
;
reverse(A + 1, A + n + 1);
st.push(0);
for (int i = 1; i <= n; i++) {
while (A[st.top()] < A[i]) st.pop();
mn[i] = st.top();
st.push(i);
}
for (int i = 1; i <= n; i++)
if ((i - mn[i] + 1) % 2) return cout << "NO" << '\n', 0;
;
cout << "YES" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[2];
int mark[110], cnt, res[110];
int inc, de, n;
int main() {
scanf("%s", s);
mark[cnt++] = 1;
++inc;
while (scanf("%s", s) == 1 && s[0] != '=') {
if (s[0] == '-') {
mark[cnt++] = -1;
++de;
} else {
mark[cnt++] = 1;
++inc;
}
scanf("%s", s);
}
scanf("%d", &n);
int t = n;
bool flag = true;
for (int i = 0; i < cnt; ++i)
if (mark[i] == -1) {
--de;
res[i] = min(n, n * inc - de - t);
t += res[i];
if (res[i] < 1) {
flag = false;
break;
}
}
if (t > n * inc) flag = false;
for (int i = 0; i < cnt; ++i)
if (mark[i] == 1) {
--inc;
res[i] = min(n, t - inc);
t -= res[i];
if (res[i] < 1) {
flag = false;
break;
}
}
if (t != 0) flag = false;
if (!flag)
puts("Impossible");
else {
puts("Possible");
for (int i = 0; i < cnt; ++i) {
if (i == 0)
printf("%d ", res[i]);
else
printf("%c %d ", mark[i] == 1 ? '+' : '-', res[i]);
}
printf("= %d\n", n);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
template <typename T>
T gcd(T a, T b) {
return (b ? __gcd(a, b) : a);
}
template <typename T>
T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
void go() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void solution() {
string s;
cin >> s;
long long b;
cin >> b;
vector<long long> a(b);
map<char, long long> m;
for (long long i = 0; i < s.length(); ++i) {
m[s[i]]++;
}
long long zero = 0;
for (long long i = 0; i < b; ++i) {
cin >> a[i];
if (a[i] == 0) {
zero++;
}
}
sort(s.begin(), s.end());
long long n = s.length();
vector<char> ans(b);
for (long long i = n - 1; i >= 0; --i) {
if (m[s[i]] >= zero) {
vector<long long> aa;
for (long long i1 = 0; i1 < b; ++i1) {
if (a[i1] == 0) {
aa.push_back(i1);
a[i1] = -1;
ans[i1] = s[i];
}
}
zero = 0;
for (long long i1 = 0; i1 < b; ++i1) {
if (binary_search(aa.begin(), aa.end(), i1) == 0) {
for (long long j = 0; j < aa.size(); ++j) {
if (a[i1] == -1) {
continue;
}
a[i1] -= abs(i1 - aa[j]);
}
if (a[i1] == 0) {
zero++;
}
}
}
i -= m[s[i]];
i++;
}
}
for (auto i : ans) {
cout << i;
}
cout << "\n";
}
signed main() {
go();
long long t;
cin >> t;
while (t--) {
solution();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
vector<int> v[N];
int n, cnt[N], mx = 0;
bool vis[N];
void dfs(int x, int c) {
vis[x] = true;
for (auto el : v[x]) {
cnt[c]++;
mx = max(mx, c);
if (!vis[el]) dfs(el, c + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
int a;
scanf("%d", &a);
v[a].push_back(i);
}
memset(cnt, 0, sizeof(cnt));
memset(vis, 0, sizeof(vis));
dfs(1, 1);
int ans = 1;
for (int i = 1; i <= mx; ++i) {
ans += (cnt[i] % 2);
}
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int mod = 1e9 + 7;
char second[N];
int n, ans;
int mx[21][N];
int lg[N];
int get(int l, int r) {
int z = lg[r - l + 1];
return max(mx[z][l], mx[z][r - (1 << z) + 1]);
}
void solve() {
scanf("\n%s", second);
n = strlen(second);
vector<int> z(n, 0);
for (int j = 0, i = 1; i < n; ++i) {
if (z[j] + j > i) z[i] = min(z[i - j], z[j] + j - i);
while (z[i] + i < n && second[z[i]] == second[z[i] + i]) z[i]++;
if (z[i] + i > z[j] + j) j = i;
}
z[0] = n;
for (int i = 1; i <= n; ++i)
mx[0][i] = z[i - 1], lg[i] = i > 1 ? lg[i >> 1] + 1 : 0;
for (int k = 1; k <= lg[n]; ++k)
for (int i = 1; i + (1 << k) - 1 <= n; ++i)
mx[k][i] = max(mx[k - 1][i], mx[k - 1][i + (1 << (k - 1))]);
ans = -1;
for (int i = 1, l, r; i <= n; ++i) {
l = 2, r = n - i;
if (r + i - l < i) break;
if (get(l, r) >= i && z[n - i] == i) ans = i;
}
if (ans == -1) {
printf("Just a legend\n");
return;
}
for (int i = 0; i < ans; ++i) printf("%c", second[i]);
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Size = 10000;
char buffer[Size];
const int inf = 0x7fffffff;
map<string, int> m;
const int size = 8;
int G[size][size];
int ar[size];
int aa, b, c;
pair<int, int> res;
void rec(int id) {
if (id == m.size()) {
vector<int> a[3];
for (int i = 0; i < m.size(); i++) {
if (ar[i] == 0)
a[0].push_back(i);
else if (ar[i] == 1)
a[1].push_back(i);
else
a[2].push_back(i);
}
int s = 0;
for (int k = 0; k < 3; k++) {
for (int i = 0; i < ((int)a[k].size()); i++) {
for (int j = 0; j < ((int)a[k].size()); j++) s += G[a[k][i]][a[k][j]];
}
}
for (int i = 0; i < 3; i++)
if (((int)a[i].size()) == 0) return;
vector<int> r;
r.push_back(aa / a[0].size());
r.push_back(b / a[1].size());
r.push_back(c / a[2].size());
sort(r.begin(), r.end());
int f = r[2] - r[0];
res = min(res, make_pair(f, -s));
return;
}
for (int i = 0; i < 3; i++) {
ar[id] = i;
rec(id + 1);
}
}
int solution(int nTest) {
int n;
res = make_pair(inf, 0);
m["Anka"] = 0;
m["Chapay"] = 1;
m["Cleo"] = 2;
m["Troll"] = 3;
m["Dracul"] = 4;
m["Snowy"] = 5;
m["Hexadecimal"] = 6;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", buffer);
string name = buffer;
int u = m[name];
scanf("%s", buffer);
scanf("%s", buffer);
name = buffer;
int v = m[name];
G[u][v] = 1;
}
scanf("%d%d%d", &aa, &b, &c);
rec(0);
printf("%d %d\n", res.first, -res.second);
return 0;
}
int main() {
int i = 0, n = 99999;
while (i < n && solution(i)) i++;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, mx1 = 0, mx2 = 0, sum = 0;
cin >> n;
vector<int> w;
vector<int> h;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
w.push_back(a);
sum += a;
h.push_back(b);
if (b > mx1) {
mx2 = mx1;
mx1 = b;
} else if (b > mx2) {
mx2 = b;
}
}
for (int i = 0; i < n; i++) {
if (h[i] != mx1) {
cout << (sum - w[i]) * mx1 << endl;
} else
cout << (sum - w[i]) * mx2 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return 1;
}
return 0;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define endl "\n"
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n>> m;
vector<string> a(n),b(n);
for(int i=0;i<n;i++){
cin >> a[i];
}
for(int i=0;i<n;i++){
cin >> b[i];
}
int ans = 0;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(a[i][j]!=b[i][j]){
ans++;
// cout << i << ' ' << j << endl;
}
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 2e5 + 5;
const long long MOD = 998244353;
const long long inf = 1e18;
bool maxi(long long &a, const long long b) {
return a < b ? (a = b, true) : false;
};
long long n, k, a[maxN], res = 1, dp[2][maxN];
bitset<maxN> vis[2];
vector<long long> v[2], idx;
long long power(long long n, long long k) {
if (!k) return 1;
long long tmp = power(n, k >> 1);
tmp = (((tmp) * (tmp)) % MOD);
if (k & 1) tmp = (((tmp) * (n)) % MOD);
return tmp;
}
long long DP(const bool f, const long long l) {
if (!l) return !f;
if (!vis[f][l]) {
vis[f][l] = 1;
if (l & 1) {
if (f)
dp[f][l] =
(((power(DP(true, l >> 1), 2)) +
(((((((k) - (1) + MOD) % MOD)) * (power(DP(false, l >> 1), 2))) %
MOD))) %
MOD);
else
dp[f][l] =
((((((2) * ((((DP(true, l >> 1)) * (DP(false, l >> 1))) % MOD))) %
MOD)) +
(((((((k) - (2) + MOD) % MOD)) * (power(DP(false, l >> 1), 2))) %
MOD))) %
MOD);
} else {
if (f)
dp[f][l] = ((((((k) - (1) + MOD) % MOD)) * (DP(false, l - 1))) % MOD);
else
dp[f][l] =
(((DP(true, l - 1)) +
(((((((k) - (2) + MOD) % MOD)) * (DP(false, l - 1))) % MOD))) %
MOD);
}
}
return dp[f][l];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = (1), _b = (n); i <= (_b); i++) {
cin >> a[i];
v[i & 1].push_back(a[i]);
}
for (long long i = (0), _b = (1); i <= (_b); i++) {
idx.clear();
for (long long j = (0), _b = (((long long)(v[i]).size())); j < (_b); j++)
if (v[i][j] > 0) idx.push_back(j);
if (idx.empty())
res =
(((res) *
((((k) * (power(k - 1, ((long long)(v[i]).size()) - 1))) % MOD))) %
MOD);
else {
res = (((res) * (power(k - 1, idx.front() + ((long long)(v[i]).size()) -
1 - idx.back()))) %
MOD);
for (long long j = (1), _b = (((long long)(idx).size())); j < (_b); j++)
res = (((res) * (DP(v[i][idx[j - 1]] == v[i][idx[j]],
idx[j] - idx[j - 1] - 1))) %
MOD);
}
}
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double f[1 << 21];
long long a[1 << 21];
int n;
char s[50][25];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
int m = strlen(s[0]);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
long long S = 0;
for (int k = 0; k < m; ++k)
if (s[i][k] == s[j][k]) S |= 1ll << k;
a[S] |= (long long)1 << i | (long long)1 << j;
}
for (int i = (1 << m) - 1; i >= 0; --i) {
for (int j = 0; j < m; ++j)
if (i >> j & 1) a[i ^ (1 << j)] |= a[i];
int cnt = 0;
for (int j = 0; j < m; ++j)
if (!(i >> j & 1)) ++cnt, f[i] += f[i | (1 << j)];
if (!cnt) continue;
f[i] /= cnt;
cnt = 0;
for (int j = 0; j < n; ++j)
if (a[i] >> j & 1) ++cnt;
f[i] += cnt / (double)n;
}
printf("%.9lf\n", f[0]);
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool exists(vector<int> v, int n) {
for (int i = 0; i < v.size(); i++) {
if (v[i] == n) return true;
}
return false;
}
int main() {
while (true) {
int n;
cin >> n;
if (!n) return 0;
int count[(n - 1) / 2 + 1];
vector<int> mod;
for (int i = 0; i < (n - 1) / 2 + 1; i++) {
count[i] = 0;
}
for (int i = 1; i < n; i++) {
int res = (i * i) % n;
if (!exists(mod, res)) {
mod.push_back(res);
}
}
for (int i = 0; i < mod.size(); i++) {
for (int j = 0; j < mod.size(); j++) {
if (i == j) continue;
int res = mod[i] - mod[j];
if (res < 0) res += n;
if (res > (n - 1) / 2) res = n - res;
count[res]++;
}
}
for (int i = 1; i < (n - 1) / 2 + 1; i++) {
cout << count[i] << endl;
}
}
} | 0 |
#include<iostream>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
using namespace std;
int main() {
int n,q,r;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
cin >> q; bool w;
bool y = true;
for (int i = 0; i < q; i++) {
cin >> r;
w = binary_search(v.begin(), v.end(), r);
if (!w) y = false;
}
if (y)
cout << 1 << endl;
else
cout << 0 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int dig(char c) { return c - '0'; }
bool good(string s, int m, int d) {
int rem = 0;
for (int i = 0; i < (int)s.length(); i++) {
if (i & 1) {
if (dig(s[i]) != d) {
return false;
}
} else if (dig(s[i]) == d) {
return false;
}
rem = (rem * 10 + dig(s[i])) % m;
}
return rem == 0;
}
int solve(string s, int m, int d) {
int n = (int)s.length();
s = "#" + s;
int dp[n + 1][m][2];
memset(dp, 0, sizeof dp);
dp[0][0][1] = 1;
for (int i = 1; i <= n; i++) {
for (int rem = 0; rem < m; rem++) {
if (i % 2 == 0) {
dp[i][(rem * 10 + d) % m][0] =
(dp[i][(rem * 10 + d) % m][0] + dp[i - 1][rem][0]) % MOD;
if (d < dig(s[i])) {
dp[i][(rem * 10 + d) % m][0] =
(dp[i][(rem * 10 + d) % m][0] + dp[i - 1][rem][1]) % MOD;
}
if (d == dig(s[i])) {
dp[i][(rem * 10 + d) % m][1] =
(dp[i][(rem * 10 + d) % m][1] + dp[i - 1][rem][1]) % MOD;
}
} else {
for (int dg = (i == 0 ? 1 : 0); dg <= 9; dg++) {
if (dg == d) continue;
dp[i][(rem * 10 + dg) % m][0] =
(dp[i][(rem * 10 + dg) % m][0] + dp[i - 1][rem][0]) % MOD;
if (dg == dig(s[i])) {
dp[i][(rem * 10 + dg) % m][1] =
(dp[i][(rem * 10 + dg) % m][1] + dp[i - 1][rem][1]) % MOD;
}
if (dg < dig(s[i])) {
dp[i][(rem * 10 + dg) % m][0] =
(dp[i][(rem * 10 + dg) % m][0] + dp[i - 1][rem][1]) % MOD;
}
}
}
}
}
return (dp[n][0][0] + dp[n][0][1]) % MOD;
}
int main() {
int m, d;
while (scanf("%d%d", &m, &d) == 2) {
string a, b;
cin >> a >> b;
int res =
((solve(b, m, d) - solve(a, m, d) + good(a, m, d)) % MOD + MOD) % MOD;
printf("%d\n", res);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n = 10000000;
int pr[30000007], m;
int d[100000];
bool p[100000];
void pr_simple() {
int i, j;
m = 1;
pr[0] = 2;
for (i = 3; i <= n; i += 2) {
bool mp = true;
for (j = 0; pr[j] * pr[j] <= i; ++j)
if (i % pr[j] == 0) {
mp = false;
break;
}
if (mp) pr[m++] = i;
}
}
void pr_erato() {
memset(p, true, n + 1);
int i, j;
m = 0;
for (i = 2; i <= n; ++i)
if (p[i]) {
for (j = i * 2; j <= n; j += i) p[j] = false;
pr[m++] = i;
}
}
void pr_erato_fast() {
memset(p, true, (n + 1) / 2 + 1);
int i, j;
m = 1;
pr[0] = 2;
for (i = 3; i * i <= n; i += 2)
if (p[i >> 1]) {
for (j = i * i; j <= n; j += i * 2) p[j >> 1] = false;
pr[m++] = i;
}
for (; i <= n; i += 2)
if (p[i >> 1]) pr[m++] = i;
}
void pr_erato_divs() {
memset(d, 0, 4 * (n + 1));
int i, j;
m = 1;
pr[0] = 2;
for (i = 3; i <= n; i += 2) {
if (d[i] == 0) d[i] = pr[m++] = i;
for (j = 0; j < m && pr[j] <= i && i * pr[j] <= n; ++j)
d[i * pr[j]] = pr[j];
}
}
void pr_erato_block() {
int i, j, k, N, m2, M;
for (N = 1; (N + 1) * (N + 1) <= n; ++N)
;
N += N & 1;
memset(p, true, N + 1);
memset(d, 0, 4 * (N + 1));
m = 1;
pr[0] = 2;
for (i = 3; i <= N; i += 2)
if (p[i]) {
for (j = i * i; j <= N; j += i * 2) p[j] = false;
d[m] = i * i;
pr[m++] = i;
}
m2 = m;
M = n / N;
m = 1;
for (k = 0; k <= M; ++k) {
memset(p, true, N + 1);
for (i = 1; i < m2; ++i) {
int &l = d[i];
for (; l < N; l += pr[i] * 2) p[l] = false;
l -= N;
}
if (!k) p[0] = p[1] = false;
for (i = 1; i < N && N * k + i <= n; i += 2)
if (p[i]) pr[m++] = N * k + i;
}
}
void pr_sundaram() {
int n2 = (n - 1) / 2;
memset(p, true, n2 + 1);
int i, j;
for (i = 1; i * 2 + i * i * 2 <= n2; ++i)
for (j = i * 2 + i * i * 2; j <= n2; j += 2 * i + 1) p[j] = false;
m = 1;
pr[0] = 2;
for (i = 1; i <= n2; ++i)
if (p[i]) pr[m++] = i * 2 + 1;
}
void pr_sundaram_block() {
int i, j, n2, N, M, q, k;
n2 = (n - 1) / 2;
for (N = 1; (N + 1) * (N + 1) <= n2; ++N)
;
memset(d, 0, 4 * (N + 1));
for (q = 1; q * 2 + q * q * 2 <= n2; ++q) d[q] = q * 2 + q * q * 2;
M = n2 / N;
m = 1;
pr[0] = 2;
for (k = 0; k <= M; ++k) {
memset(p, true, N + 1);
for (i = 1; i < q; ++i) {
int &l = d[i];
for (; l < N; l += i * 2 + 1) p[l] = false;
l -= N;
}
if (!k) p[0] = false;
for (i = 0; i < N && N * k + i <= n2; ++i)
if (p[i]) pr[m++] = (N * k + i) * 2 + 1;
}
}
void pr_atkin() {
memset(p, false, n + 1);
int i, j, k;
for (i = 1; i * i <= n; ++i)
for (j = 1; j * j <= n; ++j) {
if ((k = 4 * i * i + j * j) <= n) p[k] ^= 1;
if ((k = 3 * i * i + j * j) <= n && k % 12 == 7) p[k] ^= 1;
if (i > j && (k = 3 * i * i - j * j) <= n) p[k] ^= 1;
}
m = 2;
pr[0] = 2;
pr[1] = 3;
for (i = 5, k = 2; i * i <= n; i += k, k = 6 - k)
if (p[i]) {
pr[m++] = i;
for (j = i * i; j <= n; j += i * i) p[j] = false;
}
for (; i <= n; i += k, k = 6 - k)
if (p[i]) pr[m++] = i;
}
int main() {
int a, b, i;
cin >> a >> b;
n = b;
pr_sundaram_block();
while (m && pr[m - 1] > n) --m;
int res = 0;
for (i = 0; i < m; ++i)
if (pr[i] >= a && (pr[i] == 2 || (pr[i] & 3) == 1)) ++res;
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<pair<char, int>> sol;
for (int i = 97; i < 123; i++) sol.push_back(make_pair(i, 0));
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < sol.size(); j++)
if (s[i] == sol[j].first) sol[j].second++;
}
for (int i = sol.size(); i > -1; i--) {
if (sol[i].second != 0) {
for (int j = 0; j < sol[i].second; j++) cout << sol[i].first;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<char> v;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (i == 0)
v.push_back(s[i]);
else if (s[i] == v[v.size() - 1])
v.pop_back();
else
v.push_back(s[i]);
}
if (v.size() == 0)
cout << "Yes";
else
cout << "No";
}
| 4 |
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <map>
using namespace std;
#define REP(i,j,k) for(int i=j;i<(int)(k);++i)
#define rep(i,j) REP(i,0,j)
#define F first
#define S second
typedef pair<int,int> P;
const int mid = 510;
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
int field[1020][1020];
P dp[1020][1020];
bool is_prime[1000010];
int n, st;
map<int,P> mp;
void init(){
memset(field,-1,sizeof(field));
int i=0;
int x=mid,y=mid;
REP(N,1,1000010){
field[y][x] = N;
mp[N] = P(y,x);
if(field[y+dy[i]][x+dx[i]]==-1) {
y += dy[i]; x += dx[i];
i = (i+1)%4;
}else{
y += dy[(i+4-1)%4]; x += dx[(i+4-1)%4];
}
}
rep(i,1000010) is_prime[i]=true;
is_prime[0]=is_prime[1]=false;
for(int i=2;i*i<1000010;++i)if(is_prime[i]){
for(int j=i*i;j<1000010;j+=i) is_prime[j]=false;
}
}
P solve(const int& y, const int& x){
P ans(0,0);
dp[y][x] = is_prime[field[y][x]]?P(1,field[y][x]):P(0,0);
rep(i,1020)rep(j,1020){
if(dp[i][j]==P(-1,-1)) continue;
ans = max(ans,dp[i][j]);
REP(k,-1,2){
if(field[i+1][j+k]>n||field[i+1][j+k]==-1) continue;
dp[i+1][j+k] = max(dp[i+1][j+k],is_prime[field[i+1][j+k]]?
P(dp[i][j].F+1,field[i+1][j+k]):dp[i][j]);
}
}
return ans;
}
int main(){
init();
while(cin >> n >> st,n||st){
rep(i,1020)rep(j,1020) dp[i][j] = P(-1,-1);
P ans = solve(mp[st].F,mp[st].S);
cout << ans.F << " " << ans.S << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[200010];
int g[200010][30];
int main() {
int i, j, k;
int n, t, m;
cin >> t;
while (t--) {
cin >> n >> m;
cin >> s + 1;
int ans[30] = {0};
for (i = 1; i <= n; i++) {
for (j = 0; j < 26; j++) {
g[i][j] = g[i - 1][j];
}
g[i][s[i] - 'a']++;
}
for (i = 1; i <= m; i++) {
int x;
cin >> x;
for (j = 0; j < 26; j++) {
ans[j] += g[x][j];
}
}
for (i = 0; i < 26; i++) ans[i] += g[n][i];
for (i = 0; i < 26; i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 5;
int main() {
cin.tie(0), cin.sync_with_stdio(0);
long long n, k, m, d;
cin >> n >> k >> m >> d;
long long ans = -1;
for (int i = 1; i <= d; i++) {
long long times = n / k;
if (times < i - 1) break;
long long hi = n / (k * (i - 1) + 1);
long long x = min(hi, m);
ans = max(ans, x * i);
}
cout << ans;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int sum[200005];
char s[200005];
int main(){
int n;
scanf("%d",&n);
int i;
scanf("%s",s + 1);
for(i = 1;i <= n;i++)sum[i] = sum[i-1] + (s[i] == '.');
int ans = 2147483647;
for(i = 0;i <= n;i++)ans = min(ans,i - sum[i] + sum[n] - sum[i]);
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::string;
void __Check(bool condition, const char* expression, int line) {
if (!condition) {
fprintf(stderr, "Check failed at line %d: %s\n", line, expression);
exit(-1);
}
}
template <class Collection, class Key>
bool ContainsKey(const Collection& collection, const Key& key) {
return collection.find(key) != collection.end();
}
const int INF = 0x3F3F3F3F;
const long long INF64 = 0x3F3F3F3F3F3F3F3F;
const int INIT = -1;
int n, m, k;
std::vector<std::pair<int, int> > g[4];
int pos[4];
void Solve() {
if (((int)g[3].size()) + std::min(((int)g[1].size()), ((int)g[2].size())) <
k) {
cout << "-1" << endl;
return;
}
int want3 = std::min(((int)g[3].size()), k);
int cnt = want3;
int sum = 0;
for (; pos[3] < want3; pos[3]++) {
sum += g[3][pos[3]].first;
}
for (int i = want3; i < k; i++) {
sum += g[1][pos[1]++].first;
sum += g[2][pos[2]++].first;
cnt += 2;
}
(__Check(pos[1] == pos[2], "pos[1] == pos[2]", 60));
(__Check(want3 + 2 * pos[1] >= k, "want3 + 2 * pos[1] >= k", 61));
if (cnt > m) {
cout << "-1" << endl;
return;
}
for (; cnt < m; cnt++) {
std::vector<int> ar = {
pos[0] < ((int)g[0].size()) ? g[0][pos[0]].first : INF,
pos[1] < ((int)g[1].size()) ? g[1][pos[1]].first : INF,
pos[2] < ((int)g[2].size()) ? g[2][pos[2]].first : INF,
pos[3] < ((int)g[3].size()) ? g[3][pos[3]].first : INF};
if (pos[3] > 0 && pos[1] < ((int)g[1].size()) &&
pos[2] < ((int)g[2].size())) {
int last3 = g[3][pos[3] - 1].first;
int next12 = g[1][pos[1]].first + g[2][pos[2]].first;
int cost = next12 - last3;
ar.push_back(cost);
}
int mi = std::min_element((ar).begin(), (ar).end()) - ar.begin();
if (mi == 4) {
sum -= g[3][--pos[3]].first;
sum += g[1][pos[1]++].first;
sum += g[2][pos[2]++].first;
} else {
sum += g[mi][pos[mi]++].first;
}
}
cout << sum << endl;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < pos[i]; j++) {
cout << g[i][j].second + 1 << " ";
}
}
cout << endl;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t, x, y;
cin >> t >> x >> y;
int idx = (x << 1) | y;
g[idx].push_back({t, i});
}
for (int i = 0; i < 4; i++) {
std::sort((g[i]).begin(), (g[i]).end());
}
Solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110], b[110];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int cnt = 0;
for (int i = 1; i <= n; i++) {
int f = 0, k = 1;
for (int j = 1; j <= cnt; j++)
if (b[j] < b[k]) k = j;
if (cnt >= 1) {
if (b[k] <= a[i]) b[k]++, f = 1;
}
if (!f) b[++cnt] = 1;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a >= b ? a : b; }
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
map<long long, long long> make_pair;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) make_pair[a[i]]++;
vector<long long> v;
for (auto x : make_pair) v.push_back(x.second);
for (long long i = 1; i < v.size(); i++) {
if (v[i] - v[i - 1] > 0) {
cout << -1;
return;
}
}
vector<long long> b;
for (auto x : make_pair) b.push_back(x.first);
long long c = 0;
for (long long i = 1; i < b.size(); i++)
if (b[i] - b[i - 1] == 1) c++;
if (c != make_pair.size() - 1 || make_pair[1] == 0)
cout << -1;
else {
cout << make_pair[1] << '\n';
for (long long i = 0; i < n; i++) {
cout << make_pair[a[i]] << " ";
make_pair[a[i]]--;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
int n, r, A[30][30], C[30], R[30];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) scanf("%d", &A[i][j]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
C[i] += A[j][i];
R[i] += A[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (C[i] > R[j]) r++;
}
}
printf("%d\n", r);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2")
using namespace std;
time_t current_time;
const int N = 2e6 + 10, mod = 1e9 + 7, inf = 1e9;
int mat[20][20], n, p;
string s;
int charset[17][1 << 17];
int done[17][1 << 17][17];
void addall(char ch1, int mask, char ch2) {
if (done[ch1 - 'a'][mask][ch2 - 'a']) return;
done[ch1 - 'a'][mask][ch2 - 'a'] = 1;
charset[ch1 - 'a'][mask] = 1;
for (int i = 0; i < p; ++i) {
if (i != (ch1 - 'a') and i != (ch2 - 'a') and ((mask >> i) & 1) == 0) {
addall(ch1, mask + (1 << i), ch2);
}
}
}
int memo[1 << 18], counts[20];
int dp(int mask) {
if (~memo[mask]) return memo[mask];
int &ans = memo[mask];
ans = inf;
if (mask == ((1 << p) - 1)) {
ans = 0;
return ans;
}
for (int i = 0; i < p; ++i) {
if (((mask >> i) & 1) == 0 and charset[i][mask]) {
ans = inf;
return ans;
}
}
ans = n;
for (int i = 0; i < p; ++i) {
if ((mask >> i) & 1) ans -= counts[i];
}
for (int i = 0; i < p; ++i) {
if ((mask >> i) & 1) continue;
ans = min(ans, dp(mask + (1 << i)));
}
return ans;
}
void solve() {
memset(memo, -1, sizeof(memo));
memset(done, 0, sizeof(done));
memset(charset, 0, sizeof(charset));
cin >> n >> p >> s;
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) cin >> mat[i][j];
}
set<pair<int, char> > indices;
unordered_map<char, int> mapto;
for (char ch = 'a'; ch < 'r'; ch++) {
indices.insert({n, ch});
mapto[ch] = n;
}
memset(counts, 0, sizeof(counts));
for (int i = n - 1; i >= 0; --i) {
int currmask = 0;
counts[s[i] - 'a']++;
for (auto &[ind, ch] : indices) {
if (ind == n) break;
if (mat[s[i] - 'a'][ch - 'a'] == 0) {
addall(s[i], currmask, ch);
}
currmask += (1 << (ch - 'a'));
if (ch == s[i]) break;
}
indices.erase({mapto[s[i]], s[i]});
indices.insert({i, s[i]});
mapto[s[i]] = i;
}
int ans = dp(0);
if (ans == inf)
cout << 0 << "\n";
else
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
current_time = time(NULL);
int t = 1;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int r, c, k;
string s[501];
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
bool valid(int x, int y) {
if (x < 0 || y < 0 || x >= r || y >= c) return 0;
return 1;
}
void dfs(int x, int y) {
if (k == 0) return;
for (int i = 0; i < 4; i++) {
int X = x + dx[i];
int Y = y + dy[i];
if (!valid(X, Y)) continue;
if (s[X][Y] == '.') {
k--;
s[X][Y] = 'X';
dfs(X, Y);
}
if (k == 0) return;
}
}
int main() {
cin >> r >> c >> k;
int x, y;
int cnt = 0;
for (int i = 0; i < r; i++) {
cin >> s[i];
for (int j = 0; j < c; j++) {
if (s[i][j] == '.') {
x = i, y = j;
cnt++;
}
}
}
k = cnt - k;
k--;
s[x][y] = 'X';
dfs(x, y);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (s[i][j] == 'X')
s[i][j] = '.';
else if (s[i][j] == '.')
s[i][j] = 'X';
cout << s[i][j];
}
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5, inf = 1e18, mod = 1e9 + 7;
long long n, m, a[maxn], sum[maxn], ans[maxn], par[maxn];
bool mark[maxn];
vector<long long> adj[maxn];
void dfs(long long u) {
mark[u] = 1;
sum[u] += a[u];
for (long long j : adj[u]) {
if (mark[j]) continue;
par[j] = u;
dfs(j);
sum[u] += sum[j];
ans[u] += ans[j] + sum[j];
}
}
void dfs2(long long u) {
if (u != 1) ans[u] += (sum[1] - sum[u]) + (ans[par[u]] - (ans[u] + sum[u]));
for (long long j : adj[u]) {
if (j == par[u]) continue;
dfs2(j);
}
m = max(m, ans[u]);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
adj[v].push_back(u);
adj[u].push_back(v);
}
dfs(1);
dfs2(1);
cout << m << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int ans = 0;
if (n > m) {
long long int t = n;
n = m;
m = t;
}
for (int i = 1; i <= n; i++) {
ans = ans + (m + i) / 5 - i / 5;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF_of_int = 1e9;
const long long INF_of_ll = 1e18;
template <typename T>
void Read(T &x) {
bool w = 1;
x = 0;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') w = 0, c = getchar();
while (isdigit(c)) {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
if (!w) x = -x;
}
template <typename T>
void Write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) Write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 10;
const int K = 1e2 + 10;
long long n, m, p;
long long d[N], s[N], c[N];
long long dp[N][K];
struct Node {
long long x, y;
} q[N];
long long operator*(const Node a, const Node b) {
return a.x * b.y - a.y * b.x;
}
Node operator-(const Node a, const Node b) {
return (Node){a.x - b.x, a.y - b.y};
}
long long calc(Node a, long long pos) {
return a.y - s[pos] + c[pos] * (pos - a.x);
}
int main() {
Read(n), Read(m), Read(p);
for (int i = 2; i <= n; ++i) Read(d[i]), d[i] += d[i - 1];
for (int i = 1; i <= m; ++i) {
int t, h;
Read(h), Read(t);
c[i] = t - d[h];
}
sort(c + 1, c + m + 1);
for (int i = 1; i <= m; ++i) {
s[i] = s[i - 1] + c[i];
dp[i][1] = -s[i] + i * c[i];
}
int l, r;
for (int j = 2; j <= p; ++j) {
q[l = r = 1] = (Node){0ll, 0ll};
for (int i = 1; i <= m; ++i) {
while (l < r && calc(q[l], i) >= calc(q[l + 1], i)) ++l;
dp[i][j] = calc(q[l], i);
Node now = (Node){i, dp[i][j - 1] + s[i]};
while (l < r && (q[r] - now) * (q[r - 1] - now) > 0) --r;
q[++r] = now;
}
}
Write(dp[m][p]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct city {
city *before = nullptr, *after = nullptr;
ll id;
};
unordered_map<ll, city> cities;
unordered_map<ll, vector<ll>> rule_map;
int main() {
ll n;
cin >> n;
for (ll i = 0; i < n; i++) {
pair<ll, ll> rule;
cin >> rule.first >> rule.second;
rule_map[rule.first].push_back(rule.second);
rule_map[rule.second].push_back(rule.first);
if (n == 1) {
cout << rule.first << " " << rule.second << endl;
return 0;
}
}
auto ptr = rule_map.begin();
while (ptr->second.size() < 2) ptr++;
city *current = &cities[ptr->first];
current->before = &cities[ptr->second.front()];
current->before->id = ptr->second.front();
current->id = ptr->first;
for (ll i : {1, -1}) {
city *ptr = current;
while (rule_map[ptr->id].size() > 1) {
city *&next = i == 1 ? ptr->after : ptr->before;
city *&prev = i == 1 ? ptr->before : ptr->after;
ll nextID = -1;
if (prev->id == rule_map[ptr->id].front())
nextID = rule_map[ptr->id].back();
else
nextID = rule_map[ptr->id].front();
next = &cities[nextID];
next->id = nextID;
if (i == 1)
next->before = ptr;
else
next->after = ptr;
ptr = next;
}
}
city *start = &cities.begin()->second;
while (start->before) start = start->before;
while (start) {
cout << start->id << " ";
start = start->after;
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char c[2][2], t;
string s1, s2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(11);
cout.setf(ios::fixed);
srand((uint32_t)time(nullptr));
s1 = "";
s2 = "";
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
cin >> c[i][j];
}
}
if (c[0][0] != 'X') {
s1 += c[0][0];
}
if (c[0][1] != 'X') {
s1 += c[0][1];
}
if (c[1][1] != 'X') {
s1 += c[1][1];
}
if (c[1][0] != 'X') {
s1 += c[1][0];
}
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
cin >> c[i][j];
}
}
if (c[0][0] != 'X') {
s2 += c[0][0];
}
if (c[0][1] != 'X') {
s2 += c[0][1];
}
if (c[1][1] != 'X') {
s2 += c[1][1];
}
if (c[1][0] != 'X') {
s2 += c[1][0];
}
for (int i = 0; i < 3; ++i) {
bool ok = true;
for (int j = 0; j < 3; ++j) {
if (s1[(j + i) % 3] != s2[j]) {
ok = false;
break;
}
}
if (ok) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long int n;
int main() {
long long int i, j, k, e1, e2, ctr = 0, odd = 0;
scanf("%lld", &n);
cin >> s;
for (i = 0; i < n; i++) {
if (!((s[i] - '0') & 1)) {
ctr += ((i + 1));
}
}
printf("%lld\n", ctr);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long maxn = 1000 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
const double pi = acos(-1.0);
int g[maxn][maxn];
struct haha {
int x, y, w;
} p[maxn * 10], p0[maxn * 10];
struct Edge {
int from, to, dist;
};
struct HeapNode {
int d, u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
struct Dijkstra {
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn];
int d[maxn];
int p[maxn];
void init(int n) {
this->n = n;
for (int i = 0; i < n; ++i) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, int dist) {
edges.push_back((Edge){from, to, dist});
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s) {
priority_queue<HeapNode> Q;
p[s] = -1;
for (int i = 0; i < n; ++i) d[i] = INF;
d[s] = 0;
memset(done, 0, sizeof done);
Q.push((HeapNode){0, s});
while (!Q.empty()) {
HeapNode x = Q.top();
Q.pop();
int u = x.u;
if (done[u]) continue;
done[u] = true;
for (int i = 0; i < G[u].size(); ++i) {
Edge& e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist) {
d[e.to] = d[u] + e.dist;
p[e.to] = e.from;
Q.push((HeapNode){d[e.to], e.to});
}
}
}
}
} dij;
int main() {
int n, m, L, s, t;
int cnt = 0, cnt2 = 0;
scanf("%d %d %d %d %d", &n, &m, &L, &s, &t);
dij.init(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
g[u][v] = g[v][u] = w;
if (w) {
p[cnt].x = u;
p[cnt].w = w;
p[cnt++].y = v;
dij.AddEdge(u, v, w);
dij.AddEdge(v, u, w);
} else {
p0[cnt2].x = u;
p0[cnt2].w = 0;
p0[cnt2++].y = v;
}
}
dij.dijkstra(s);
if (dij.d[t] < L) return 0 * puts("NO");
if (dij.d[t] == L) {
puts("YES");
for (int i = 0; i < cnt; ++i) {
printf("%d %d %d\n", p[i].x, p[i].y, p[i].w);
}
for (int i = 0; i < cnt2; ++i) {
printf("%d %d %d\n", p0[i].x, p0[i].y, INF);
}
return 0;
}
int pos = -1;
for (int i = 0; i < cnt2; ++i) {
dij.AddEdge(p0[i].x, p0[i].y, 1);
dij.AddEdge(p0[i].y, p0[i].x, 1);
dij.dijkstra(s);
if (dij.d[t] > L) continue;
pos = i;
break;
}
if (pos == -1) return 0 * puts("NO");
puts("YES");
for (int i = 0; i < cnt; ++i) {
printf("%d %d %d\n", p[i].x, p[i].y, p[i].w);
}
for (int i = 0; i < pos; ++i) printf("%d %d %d\n", p0[i].x, p0[i].y, 1);
printf("%d %d %d\n", p0[pos].x, p0[pos].y, L - dij.d[t] + 1);
for (int i = pos + 1; i < cnt2; ++i)
printf("%d %d %d\n", p0[i].x, p0[i].y, INF);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<vector<int>> Sizes(k);
for (int i = 0; i < k; i++) {
int c;
cin >> c;
Sizes[i].resize(c);
for (int j = 0; j < c; j++) cin >> Sizes[i][j];
}
int ans = 0, single = 0;
for (int i = 0; i < k; i++) {
if (Sizes[i][0] != 1)
single += Sizes[i].size() - 1;
else {
for (int j = 0; j < Sizes[i].size(); j++) {
if (Sizes[i][j] != j + 1) {
single += Sizes[i].size() - j;
break;
}
}
}
}
ans = single + (k + single - 1);
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, buses = 0, placesTaken = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (placesTaken + a <= m)
placesTaken += a;
else {
buses++;
placesTaken = a;
}
}
if (placesTaken > 0) buses++;
cout << buses << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, big, ans = LLONG_MAX;
vector<long long> vec[101234];
long long check(long long z) {
long long res = 0, tot = vec[0].size();
vector<long long> ret;
for (long long i = 1; i <= big; i++) {
long long now = 0, siz = vec[i].size(), poi = siz;
for (long long j = 0; j < siz; j++) {
if (poi < z) {
for ("lyc"; j < siz; j++) ret.push_back(vec[i][j]);
break;
}
res += vec[i][j];
tot++, poi--;
}
}
if (tot >= z)
return res;
else {
sort(ret.begin(), ret.end());
long long siz = ret.size();
for (long long i = 0; i < siz; i++) {
res += ret[i];
tot++;
if (tot >= z) return res;
}
return res;
}
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
long long gru, rmb;
scanf("%lld%lld", &gru, &rmb);
vec[gru].push_back(rmb);
big = max(big, gru);
}
for (long long i = 1; i <= big; i++) sort(vec[i].begin(), vec[i].end());
if (check(0) == 0) {
printf("0");
return 0;
}
long long l = vec[0].size(), r = n;
while (l <= r) {
long long lmid = l + (r - l) / 3, rmid = r - (r - l) / 3;
long long tmp1 = check(lmid), tmp2 = check(rmid);
if (tmp1 > tmp2)
l = lmid + 1;
else
r = rmid - 1;
ans = min(ans, min(tmp1, tmp2));
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int floor[n][2 * m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * m; j++) {
cin >> floor[i][j];
}
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * m - 1; j += 2) {
if (floor[i][j] == 1 || floor[i][j + 1] == 1) {
count++;
}
}
}
cout << count << "\n";
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
if (n == 1)
printf("%d\n", 1);
else if (n / 2 < m)
printf("%d\n", m - 1);
else
printf("%d\n", m + 1);
return 0;
}
| 2 |
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
const int MAX_N = 12;
typedef pair<int,char> P;
// 入力
int n;
string s[MAX_N];
// f[c] := 文字 c の係数.
int f[256] = {0};
// m[c] := 文字 c に割り当てた数字 (0-9のどれか, まだ割り当てられていないときは -1 )
int m[256] = {0};
// max_digit := 最大の桁数
int max_digit;
// 登場する文字
vector<char> vc;
// is_head[c] := 文字 c が先頭で数字 0 を割り当てることができない.
bool is_head[256];
// used[i] := 数字 i を使ったかどうか.
bool used[10];
// 解
int ans;
// 上限と下限
int low, high;
int pow10(int x){
int a = 1;
for(int i=0 ; i < x ; i++ ) a *= 10;
return a;
}
void init(){
// 初期化.
vc.clear();
for(int i=0 ; i < 10 ; i++ ){
used[i] = false;
}
for(char c = 'A' ; c <= 'Z' ; c++ ){
f[c] = 0;
m[c] = -1;
}
int a = s[0].size();
for(int i=1 ; i < n-1 ; i++ ){
a = max( a , (int)s[i].size() );
}
max_digit = max( a , (int)s[n-1].size() );
// 文字列を逆にする.
for(int i=0 ; i < n ; i++ ){
reverse( s[i].begin() , s[i].end() );
}
// 各文字の係数をまとめておく.
int h[256] = {0};
for(int i=0 ; i < n ; i++ ){
for(int j=0 ; j < max_digit ; j++ ){
if( s[i].size() <= j ) continue;
h[ s[i][j] ] = 1;
if( i == n-1 ){
f[ s[i][j] ] -= pow10(j);
}else{
f[ s[i][j] ] += pow10(j);
}
}
}
// 登場する文字のチェック.
for(char c = 'A' ; c <= 'Z' ; c++ ){
if( h[c] ) vc.push_back( c );
}
// 係数の小さい順に文字の並び替え
vector<P> v;
for(int i=0 ; i < vc.size() ; i++ ){
char c = vc[i];
v.push_back( P(f[c],c) );
}
sort(v.begin(),v.end());
// 上限と下限の計算
int p=9;
high = low = 0;
for(int i=0 ; i < v.size() && v[i].first < 0 ; i++ ){
high -= v[i].first * p--;
}
p=9;
for(int i=v.size()-1 ; i >= 0 && v[i].first >= 0 ; i-- ){
low -= v[i].first * p--;
}
// 逆にした文字列を元に戻す.
for(int i=0 ; i < n ; i++ ){
reverse( s[i].begin() , s[i].end() );
}
}
void solve(int pos, int k, int sum ){
if( pos == k ){
if( sum == 0 ){
ans++;
}
return ;
}
if( sum < low || high < sum ) return;
// c := 今割り当てようとしている文字
char c = vc[pos];
for(int i=0 ; i < 10 ; i++ ){
if( used[i] ) continue;
if( i == 0 && is_head[c] ) continue;
used[i] = true;
m[c] = i;
solve( pos+1 , k , sum + m[c] * f[c] );
used[i] = false;
m[c] = -1;
}
}
int main(){
while( cin >> n , n ){
// 初期化
for(char c = 'A' ; c <= 'Z' ; c++ ) is_head[c] = false;
// 入力.
for(int i=0 ; i < n ; i++ ){
cin >> s[i];
if( s[i].size() >= 2 ){
is_head[ s[i][0] ] = true;
}
}
// 前処理.
init();
// 解く.
ans = 0;
solve( 0 , vc.size() , 0 );
// 解を出力.
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> in[50];
map<int, int> to_pop;
long long sum[50];
int get_group(int cur) {
int ret = 0;
while (cur) {
ret++;
cur = cur / 2;
}
return ret;
}
int active = 0;
void update(int cur) {
int where = get_group(cur);
sum[where] += cur;
in[where].push(-cur);
active++;
}
void my_pop(int cur) {
int where = get_group(cur);
sum[where] -= cur;
to_pop[cur]++;
while (to_pop[-in[where].top()]) {
to_pop[-in[where].top()]--;
in[where].pop();
}
active--;
}
int query() {
int ret = active;
long long cur_sum = 0;
for (int i = 0; i < 35; i++)
if (in[i].size()) {
if (2 * cur_sum < -in[i].top()) ret--;
cur_sum += sum[i];
}
return ret;
}
int main() {
int q;
scanf("%i", &q);
for (int i = 1; i <= q; i++) {
char c = getchar();
while (c != '+' && c != '-') c = getchar();
if (c == '+') {
int cur;
scanf("%i", &cur);
update(cur);
} else {
int cur;
scanf("%i", &cur);
my_pop(cur);
}
printf("%i\n", query());
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 2e5+7;
int n;
long long res;
int a[kN], b[kN];
int main()
{
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i) {
cin >> b[i];
if (b[i] < a[i]) {
cout << "-1" << endl;
return 0;
}
}
int flag = 1;
while (flag) {
flag = 0;
for (int i = 0; i < n; ++i) {
int bt = b[(i-1+n)%n]+b[(i+1)%n];
if (b[i]-bt >= a[i]) {
int k = (b[i]-a[i])/bt;
res += k;
b[i] -= k*bt;
flag = 1;
}
}
}
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
cout << "-1" << endl;
return 0;
}
}
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long jc[501], Jc[501], f[501], g[501], h[501][501][2], C[501][501], s, ans,
F;
int n, m, mod, Mod, i, j, k, l;
long long qpower(long long a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &mod), Mod = mod - 2;
jc[0] = 1;
for (i = 1; i <= n; i++) jc[i] = jc[i - 1] * i % mod;
Jc[n] = qpower(jc[n], Mod);
for (i = n - 1; i >= 0; i--) Jc[i] = Jc[i + 1] * (i + 1) % mod;
C[0][0] = 1;
for (i = 1; i <= n; i++) {
C[i][0] = C[i][i] = 1;
for (j = 1; j <= i - 1; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
f[0] = 1;
g[0] = 0;
for (i = 1; i <= m; i++) {
for (j = 1; j <= i; j++) {
s = (j * (j - 1) / 2 + (i - j + 1) * (i - j) / 2) % mod;
f[i] = ((f[i]) +
(f[j - 1] * f[i - j] % mod * (i + 1) % mod * C[i - 1][j - 1])) %
mod;
g[i] = ((g[i]) +
(((g[j - 1] * f[i - j] + f[j - 1] * g[i - j]) % mod * (i + 1) +
f[j - 1] * f[i - j] % mod * s) %
mod * C[i - 1][j - 1])) %
mod;
}
}
h[0][0][0] = 1;
for (i = 0; i <= (m < n - m + 1 ? m : n - m + 1) - 1; i++) {
for (j = 0; j <= m - 1; j++) {
for (k = 1; k <= m - j; k++) {
F = f[k] * C[j + k][j] % mod;
h[i + 1][j + k][0] = ((h[i + 1][j + k][0]) + (h[i][j][0] * F)) % mod;
h[i + 1][j + k][1] = ((h[i + 1][j + k][1]) + (h[i][j][1] * F)) % mod;
h[i + 1][j + k][1] =
((h[i + 1][j + k][1]) + (h[i][j][0] * g[k] % mod * C[j + k][j])) %
mod;
}
}
}
for (i = 1; i <= (m < n - m + 1 ? m : n - m + 1); i++)
ans = ((ans) + (h[i][m][1] * C[n - m + 1][i])) % mod;
printf("%lld\n", (ans + mod) % mod);
fclose(stdin);
fclose(stdout);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void imprimirVector(vector<long long> v) {
if (!v.empty()) {
int p = v.size();
cout << "[";
for (int i = 0; i < (int)(p - 1); i++) cout << v[i] << ",";
cout << v[p - 1] << "]" << endl;
} else
cout << "[]" << endl;
}
int toNumber(string s) {
int Number;
if (!(istringstream(s) >> Number)) Number = 0;
return Number;
}
string toString(int number) {
ostringstream ostr;
ostr << number;
return ostr.str();
}
bool sePuede(vector<long long> &s, long long k, long long c) {
long long n = s.size();
vector<long long> capacidades(k, 0);
long long j = 0;
long long menor = 0;
long long mayor = n - 1;
vector<bool> yaPuse(n, false);
while (menor < mayor) {
while (mayor > menor && s[menor] + s[mayor] > c) {
mayor--;
}
if (mayor > menor) {
capacidades[j] += (s[menor] + s[mayor]);
yaPuse[menor] = true;
yaPuse[mayor] = true;
menor++;
mayor--;
j++;
} else
break;
}
long long i = 0;
while (i < n && j < k) {
if (!yaPuse[i] && capacidades[j] + s[i] <= c) {
capacidades[j] += s[i];
yaPuse[i] = true;
j++;
}
i++;
}
bool tutti = true;
for (int p = 0; p < (int)(n); p++) tutti &= yaPuse[p];
if (tutti)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
vector<long long> s(n);
long long cinf = 0;
long long csup = 0;
for (int i = 0; i < (int)(n); i++) {
cin >> s[i];
csup += s[i];
cinf = max(cinf, s[i]);
}
cinf -= 1;
while (csup - cinf > 1) {
long long c = (cinf + csup) / 2;
if (sePuede(s, k, c))
csup = c;
else
cinf = c;
}
cout << csup << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i = (a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9+100;
const ll MOD = 1e9+7;
const bool debug = false;
void solve(string s, vector<string> &str, vector<string> &cont) {
int p = 0;
string cur = "";
while (p < s.size()) {
if (s[p] == '\"') {
p++;
if (cur != "") str.push_back(cur);
str.push_back("*");
cur = "";
while (s[p] != '\"') cur += s[p++];
cont.push_back(cur);
cur = "";
p++;
}
else cur += s[p++];
}
if (cur != "") str.push_back(cur);
}
int main() {
string s[2];
while (cin >> s[0], s[0] != ".") {
cin >> s[1];
if (debug) putchar('@');
if (s[0] == s[1]) puts("IDENTICAL");
else {
vector<string> str[2]; // encode
vector<string> cont[2]; // ""の中身
solve(s[0], str[0], cont[0]);
solve(s[1], str[1], cont[1]);
bool ng = false;
if (str[0].size() != str[1].size()) ng = true;
else {
REP(i, str[0].size()) if (str[0][i] != str[1][i]) ng = true;
}
if (!ng) {
int ngcnt = 0;
REP(i, cont[0].size()) {
if (cont[0][i] != cont[1][i]) ngcnt++;
}
if (ngcnt != 1) ng = true;
}
if (ng) puts("DIFFERENT");
else puts("CLOSE");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2505][2505];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (a[i][j] != a[j][i] || a[i][i] != 0) {
cout << "NOT MAGIC" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int l = 1; l <= 500; l++) {
int j = (rand() % n + 1);
for (int k = 1; k <= n; k++)
if (a[i][j] > max(a[i][k], a[j][k])) {
cout << "NOT MAGIC" << endl;
return 0;
}
}
}
cout << "MAGIC" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
if (b == 0) return (long long)1;
long long x = power(a, b / 2);
x = x % 1000000007;
long long ans =
((long long)(x % 1000000007) * (long long)(x % 1000000007)) % 1000000007;
if (b % 2 != 0)
ans = ((long long)(ans % 1000000007) * (long long)(a % 1000000007)) %
1000000007;
ans = ans % 1000000007;
return ans;
}
long long mod_inv(long long a) {
long long ans = power(a, 1000000007 - 2);
ans = ans % 1000000007;
return ans;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b) return a;
if (a > b)
return gcd(b, a % b);
else
return gcd(a, b % a);
}
long long func() {
long long n, m;
cin >> n >> m;
vector<long long> a(n, 0);
vector<long long> b(m, 0);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long j = 0;
long long r = INT_MIN;
for (long long i = 0; i < n; i++) {
while (j < m - 1 && abs(a[i] - b[j]) >= abs(a[i] - b[j + 1])) j++;
r = max(r, abs(a[i] - b[j]));
}
return r;
}
int main() {
long long T = 1;
while (T--) {
long long ans = func();
cout << ans << endl;
}
}
| 3 |
#include<iostream>
#include<climits>
#include<algorithm>
#include<vector>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define ALL(C) (C).begin(),(C).end()
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
int vis[50][50];
char m[50][50];
void dfs(int r,int c,int y,int x,int now){
if(((1<<now)&vis[y][x]) != 0)return;
vis[y][x]|=(1<<now);
rep(i,4){
int nex=x+dx[i],ney=y+dy[i];
if (nex==-1||nex==c||ney==r||ney==-1||m[ney][nex]!='.')continue;
dfs(r,c,ney,nex,now);
}
}
void solve(int r,int c){
rep(i,r){
rep(j,c){
vis[i][j]=0;
}
}
rep(i,r){
rep(j,c){
if (m[i][j] == 'B'){
dfs(r,c,i,j,0);
}else if (m[i][j] == 'W'){
dfs(r,c,i,j,1);
}
}
}
int w=0,b=0;
rep(i,r){
rep(j,c){
if (m[i][j] != '.')continue;
if (vis[i][j] == 1)b++;
else if (vis[i][j]==2)w++;
}
}
cout << b << " " << w << endl;
}
int main(){
int r,c;
while(cin>>c>>r && c){
rep(i,r){
rep(j,c)cin>>m[i][j];
}
solve(r,c);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline string get() {
char ch[2000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const long long maxn = 1e5 + 10;
const long long base = 29;
const long long mod = 1e9 + 7;
const long long INF = 1e10 + 100;
pair<long long, long long> a[maxn];
bool mark[maxn];
long long b[maxn];
long long res;
int32_t main() {
long long n = in(), m = in();
for (long long i = 0; i < n; i++) {
string x = get();
a[i] = {in(), x[0] != 'A'};
}
sort(a, a + n,
[](const pair<long long, long long> &A,
const pair<long long, long long> &B) {
return B.second != A.second ? A.second < B.second : A.first > B.first;
});
for (long long i = 0; i < m; i++) b[i] = in();
sort(b, b + m, greater<long long>());
long long lst = -1;
for (long long i = 0; i < n; i++) {
if (a[i].second == 0) {
lst = i;
}
}
if (lst + 1) {
for (long long i = 0; i < n && lst >= 0 && b[i] >= a[lst].first; i++) {
res += b[i] - a[lst--].first;
}
}
long long cur = n - 1;
for (long long i = m - 1; i >= 0 && cur >= 0 && a[cur].second; i--) {
if (b[i] > a[cur].first) {
mark[i] = true;
cur--;
}
}
if (cur == -1 || a[cur].second == 0) {
cur = 0;
long long res2 = 0;
for (long long i = 0; i < m && cur < n && a[cur].second == 0; i++) {
if (!mark[i] && b[i] >= a[cur].first) {
res2 += b[i] - a[cur++].first;
mark[i] = true;
}
}
if (cur == n || a[cur].second == 1) {
for (long long i = 0; i < m; i++) {
if (!mark[i]) res2 += b[i];
}
res = max(res, res2);
}
}
cout << res << "\n";
}
| 4 |
#include<bits/stdc++.h>
long long a,b,k;
int main(){
scanf("%lld%lld%lld",&k,&a,&b);
if(k<=a)return puts("1"),0;
else if(a<=b)return puts("-1"),0;
else printf("%lld\n",((k-a)/(a-b)+bool((k-a)%(a-b)))<<1|1);
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160")
using namespace std;
int p, i, j, res, d, k, dd, rr;
string s, w[101], s1, s2, w1, w2;
int main() {
p = 0;
while (getline(cin, s)) {
w[p] = s;
p++;
}
sort(w, w + p);
res = 0;
rr = 0;
d = 0;
dd = 0;
for (i = 0; i < p; i++) {
k = 0;
s2 = "";
for (j = 0; j < w[i].length(); j++)
if (w[i][j] == 92 && k == 1)
break;
else if (w[i][j] == 92) {
k++;
s2 += w[i][j];
} else
s2 += w[i][j];
if (i == 0 || s2 == s1)
d++;
else
d = 1;
if (d > res) res = d;
s1 = s2;
}
for (i = 0; i < p; i++) {
k = 0;
s2 = "";
for (j = 0; j < w[i].length(); j++)
if (w[i][j] == 92 && k == 1)
break;
else if (w[i][j] == 92) {
k++;
s2 += w[i][j];
} else
s2 += w[i][j];
if (i > 0 && s2 == s1)
d = 1;
else
d = 0;
s1 = s2;
if (d == 0) {
dd = 0;
for (j = 0; j < w[i].length(); j++)
if (w[i][j] == 92) dd++;
dd -= 2;
if (dd > rr) rr = dd;
} else {
j = 0;
while (j < w[i - 1].length() && j < w[i].length() &&
w[i - 1][j] == w[i][j])
j++;
for (int l = j; l < w[i].length(); l++)
if (w[i][l] == 92) dd++;
}
if (dd > rr) rr = dd;
}
cout << rr << " " << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, k, a[N][2];
long long f[N][2];
int main() {
scanf("%d%d", &n, &k);
for (int j = 0; j < 2; j++)
for (int i = 1; i <= n; i++) scanf("%d", &a[i][j]);
for (int j = 0; j < 2; j++)
for (int i = 1; i <= n; i++)
if ((f[i][j] = max(0LL, f[i - 1][j] + a[i][j] - 1LL * k * a[i][j ^ 1])) >
k)
return !printf("NO\n");
printf("YES\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
vector<vector<long long>> a(60 + 8, vector<long long>{});
vector<long long> b(n);
for (long long i = 0; i < n; ++i) cin >> b[i];
for (long long i = 0; i < n; ++i) {
long long x = b[i];
long long cnt = 0;
while (x % 2 == 0) x >>= 1, ++cnt;
a[cnt].push_back(b[i]);
}
long long mx = 0;
for (long long i = 0; i < 60 + 8; ++i)
if (a[mx].size() < a[i].size()) mx = i;
vector<long long> delite;
for (long long i = 0; i < 60 + 8; ++i)
if (i != mx)
for (long long j : a[i]) delite.push_back(j);
cout << delite.size() << '\n';
for (long long i : delite) cout << i << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7, INF = 0x7fffffff, rx[] = {-1, 0, 1, 0},
ry[] = {0, 1, 0, -1};
const double pi = acos(-1.0), eps = 1e-8;
void rd(int &res) {
res = 0;
char c;
while (c = getchar(), c < 48)
;
do res = (res << 3) + (res << 1) + (c ^ 48);
while (c = getchar(), c > 47);
}
inline void Max(int &a, int b) {
if (b > a) a = b;
}
inline void Min(int &a, int b) {
if (b < a) a = b;
}
inline void mod_add(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
const int N = (int)1e3 + 5, M = (int)5e3 + 5;
int n, m, dist[N];
bool mark[N], flag[N];
pair<int, int> es[M];
vector<int> rG[N];
bool Bellman_Ford() {
for (int i = 1; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!mark[es[j].first] || !flag[es[j].second]) continue;
Max(dist[es[j].second], dist[es[j].first] + 1);
Max(dist[es[j].first], dist[es[j].second] - 2);
}
}
for (int i = 0; i < m; ++i) {
if (!mark[es[i].first] || !flag[es[i].second]) continue;
if (dist[es[i].first] + 1 > dist[es[i].second]) return false;
if (dist[es[i].second] - 2 > dist[es[i].first]) return false;
}
return true;
}
int main() {
rd(n);
rd(m);
for (int i = 0; i < m; ++i) {
rd(es[i].first);
rd(es[i].second);
rG[es[i].second].push_back(es[i].first);
}
mark[1] = flag[n] = true;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
mark[es[j].second] |= mark[es[j].first];
flag[es[j].first] |= flag[es[j].second];
}
if (!Bellman_Ford()) return puts("No");
puts("Yes");
for (int i = 0; i < m; ++i) {
if (!mark[es[i].first] || !flag[es[i].second])
puts("1");
else
printf("%d\n", dist[es[i].second] - dist[es[i].first]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
map<int, bool> cur;
int ans[maxn];
int main() {
queue<int> q;
int n, k;
scanf("%d%d", &n, &k);
int a;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
if (cur[a] == 0) {
q.push(a);
if (q.size() > k) {
int t = q.front();
cur[t] = 0;
q.pop();
}
cur[a] = 1;
}
}
int l = q.size();
for (int i = 1; i <= l; i++) {
ans[l - i + 1] = q.front();
q.pop();
}
printf("%d\n", l);
for (int i = 1; i <= l; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int abs(int a){
return 0 <= a ? a : -a;
}
int main(){
int n, m;
cin >> n >> m;
int a[n], b[n], c[m], d[m];
for(int i = 0; i < n; i++) cin >> a[i] >> b[i];
for(int i = 0; i < m; i++) cin >> c[i] >> d[i];
for(int i = 0; i < n; i++){
int dist = 1e9, ans;
for(int j = 0; j < m; j++) if(abs(a[i] - c[j]) + abs(b[i] - d[j]) < dist){
dist = abs(a[i] - c[j]) + abs(b[i] - d[j]);
ans = j + 1;
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int prime[10000] = {0};
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long power(long long base, long long n) {
long long ans = 1;
while (n > 0) {
if (n % 2) {
ans = (ans * base);
}
base = (base * base);
n >>= 1;
}
return ans;
}
void sieve() {
for (int i = 2; i * i <= 10000; i++) {
if (prime[i] == 0) {
for (int j = i * 2; j <= 10000; j += i) prime[j] = 1;
}
}
}
bool palindrome(string str) {
for (int i = 0, j = str.length() - 1; i < j; i++, j--) {
if (str[i] != str[j]) return false;
}
return true;
}
int main() {
fast();
long long n, k;
cin >> n >> k;
long long r, b, g;
r = n * 2;
b = n * 8;
g = n * 5;
long long sum = 0;
sum = ceil((double)r / k) + ceil((double)g / k) + ceil((double)b / k);
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-5;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
int n, m;
char a[100][100];
bool n1s() {
bool f = true;
for (int i = (1); i <= (n); i++)
if (a[i][1] != 'A') f = false;
if (f) return f;
f = true;
for (int i = (1); i <= (n); i++)
if (a[i][m] != 'A') f = false;
if (f) return f;
f = true;
for (int i = (1); i <= (m); i++)
if (a[1][i] != 'A') f = false;
if (f) return f;
f = true;
for (int i = (1); i <= (m); i++)
if (a[n][i] != 'A') f = false;
return f;
}
bool n2s() {
for (int j = (2); j <= (m - 1); j++) {
bool f = true;
for (int i = (1); i <= (n); i++) {
if (a[i][j] != 'A') f = false;
}
if (f) return f;
}
for (int i = (2); i <= (n - 1); i++) {
bool f = true;
for (int j = (1); j <= (m); j++) {
if (a[i][j] != 'A') f = false;
}
if (f) return f;
}
if (a[1][1] == 'A' || a[1][m] == 'A' || a[n][1] == 'A' || a[n][m] == 'A')
return true;
int maxc = 0;
int cnt = 0;
for (int i = (1); i <= (n); i++) {
if (a[i][1] == 'A')
cnt++;
else
break;
}
maxc = max(maxc, cnt);
cnt = 0;
for (int i = (1); i <= (n); i++) {
if (a[i][m] == 'A')
cnt++;
else
break;
}
maxc = max(maxc, cnt);
cnt = 0;
for (int i = (n); i >= (1); i--) {
if (a[i][1] == 'A')
cnt++;
else
break;
}
if (cnt + maxc >= n) return true;
cnt = 0;
for (int i = (n); i >= (1); i--) {
if (a[i][m] == 'A')
cnt++;
else
break;
}
if (cnt + maxc >= n) return true;
maxc = 0;
cnt = 0;
for (int j = (1); j <= (m); j++) {
if (a[1][j] == 'A')
cnt++;
else
break;
}
maxc = max(maxc, cnt);
cnt = 0;
for (int j = (1); j <= (m); j++) {
if (a[n][j] == 'A')
cnt++;
else
break;
}
maxc = max(maxc, cnt);
cnt = 0;
for (int j = (m); j >= (1); j--) {
if (a[1][j] == 'A')
cnt++;
else
break;
}
if (cnt + maxc >= m) return true;
cnt = 0;
for (int j = (m); j >= (1); j--) {
if (a[n][j] == 'A')
cnt++;
else
break;
}
if (cnt + maxc >= m) return true;
for (int i = (2); i <= (n - 1); i++) {
int cnt = 0;
for (int j = (1); j <= (m); j++) {
if (a[i][j] == 'A')
cnt++;
else
break;
}
if (cnt >= m) return true;
}
for (int j = (2); j <= (m - 1); j++) {
int cnt = 0;
for (int i = (1); i <= (n); i++) {
if (a[i][j] == 'A')
cnt++;
else
break;
}
if (cnt >= n) return true;
}
return false;
}
bool n3s() {
bool f = false;
for (int i = (1); i <= (n); i++)
if (a[i][1] == 'A' || a[i][m] == 'A') f = true;
for (int j = (1); j <= (m); j++)
if (a[1][j] == 'A' || a[n][j] == 'A') f = true;
if (f) return f;
int maxc = 0;
for (int i = (2); i <= (n - 1); i++) {
int cnt = 0;
for (int j = (1); j <= (m); j++) {
if (a[i][j] == 'A')
cnt++;
else
break;
}
maxc = max(maxc, cnt);
}
int max2c = 0;
for (int i = (2); i <= (n - 1); i++) {
int cnt = 0;
for (int j = (m); j >= (1); j--) {
if (a[i][j] == 'A')
cnt++;
else
break;
}
max2c = max(max2c, cnt);
}
if (max2c + maxc >= m) return true;
maxc = 0;
max2c = 0;
for (int j = (2); j <= (m - 1); j++) {
int cnt = 0;
for (int i = (1); i <= (n); i++) {
if (a[i][j] == 'A')
cnt++;
else
break;
}
maxc = max(maxc, cnt);
}
for (int j = (2); j <= (m - 1); j++) {
int cnt = 0;
for (int i = (n); i >= (1); i--) {
if (a[i][j] == 'A')
cnt++;
else
break;
}
max2c = max(max2c, cnt);
}
if (max2c + maxc >= m) return true;
return false;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
bool mortal = true;
bool n0s = true;
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (m); j++) {
cin >> a[i][j];
if (a[i][j] == 'A') mortal = false;
if (a[i][j] == 'P') n0s = false;
}
}
if (mortal) {
cout << "MORTAL" << '\n';
continue;
}
if (n0s) {
cout << 0 << '\n';
continue;
}
if (n1s()) {
cout << 1 << '\n';
continue;
}
if (n2s()) {
cout << 2 << '\n';
continue;
}
if (n3s()) {
cout << 3 << '\n';
continue;
}
cout << 4 << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
bool isOverflow(int64_t a, int64_t b) {
if (a == 0 || b == 0)
return false;
else
return (a > LLONG_MAX / b);
}
int64_t func(int64_t c) {
int64_t cost = 0, pc = 1;
for (int ai : a) {
long long diff = ai - pc;
cost += abs(diff);
if (isOverflow(pc, c)) return LLONG_MAX;
pc *= c;
}
return cost;
}
int main(void) {
int n;
cin >> n;
int64_t ans = 0;
a.resize(n);
for (int& ai : a) {
cin >> ai;
ans += abs(ai - 1);
}
sort(a.begin(), a.end());
int64_t l = 2, r = 1e9, maxc = 0;
while (l <= r) {
int64_t mid = l + (r - l) / 2;
int64_t c = func(mid);
if (c > ans) {
maxc = mid;
r = mid - 1;
} else
l = mid + 1;
}
l = 2;
r = maxc;
while (r - l > 3) {
int64_t m1 = l + (r - l) / 3;
int64_t m2 = r - (r - l) / 3;
int64_t c1 = func(m1);
int64_t c2 = func(m2);
ans = min(ans, c1);
ans = min(ans, c2);
if (c1 > c2)
l = m1;
else
r = m2;
}
for (int64_t i = l; i <= r; i++) ans = min(ans, func(i));
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 30;
int a[MAX_N], s[MAX_N];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
s[i] = a[i];
}
sort(s, s + n);
map<int, int> spos;
for (int i = 0; i < n; i++) {
spos[s[i]] = i;
}
for (int i = 0; i < n; i++) {
cout << s[(spos[a[i]] + 1) % n] << " ";
}
cout << endl;
}
| 2 |
#include <stdio.h>
int main() {
int R;
scanf("%d",&R);
if( R<1200 ) printf("ABC");
else if (R<2800) printf("ARC");
else printf("AGC");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long N, L, W;
vector<long long> neg, pos;
long long INF32 = 0x7fffffff;
inline long long div_floor(long long a, long long b) {
if (b == 0) return (a > 0 ? +INF32 : -INF32);
if (a % b < 0) a -= (b + a % b);
return a / b;
}
int main() {
cin >> N >> L >> W;
for (int i = 0; i < N; ++i) {
long long x, d;
cin >> x >> d;
(d == 1 ? pos : neg).push_back(d == 1 ? x : x + L);
}
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end());
long long ans = 0;
for (auto x : pos) {
long long lval = max(-x - 1, x);
if (W == 1) {
if (x < 0) {
} else {
lval = INF32;
}
} else {
lval = max(lval, div_floor(((W + 1) * x), (W - 1)));
}
auto l = upper_bound(neg.begin(), neg.end(), lval);
ans += int(neg.end() - l);
lval = max(x, div_floor((W - 1) * x, (W + 1)));
long long rval = -x;
l = upper_bound(neg.begin(), neg.end(), lval);
auto r = lower_bound(neg.begin(), neg.end(), rval);
ans += max(0, int(r - l));
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int r = 1;
while (n--) {
cout << 1 << " ";
}
cout << endl;
}
}
| 1 |
//ALTF4
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<math.h>
#include<stack>
#include<vector>
#include<queue>
#include<cstdio>
#include<deque>
#include<map>
using namespace std;
using lli = long long;
using ull = unsigned long long;
const int maxN = 1e7 + 2;
const lli mod = 1e9 + 7;
const long double Pi = atan(1.0L) * 4;
void FastInput()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void InputFile()
{
freopen("a.INP","r",stdin);
//freopen("a.OUT","w",stdout);
}
int main()
{
FastInput();
//InputFile();
int test;
cin >> test;
while(test--)
{
int apr[501];
int res[501];
int cnt;
for(int i = 1;i <= 501;i++)
{
apr[i] = 0;
res[i] = 0;
}
int n,l,r,s;
cin >> n >> l >> r >> s;
int k = r - l + 1;
cnt = k - 1;
if(s < k * (k + 1)/2 || s > n*(n + 1)/2 - (n - k) * (n - k + 1)/2) {cout << -1 <<'\n';continue;}
int run = n;
for(int i = l;i <= r;i++)
{
while(apr[run] != 0 || run + cnt * (cnt + 1) / 2 > s) run--;
res[i] = run;
apr[run]++;
s -= run;
cnt--;
}
int run2 = n;
for(int i = 1;i <= n;i++)
{
if(res[i] == 0)
{
while(apr[run2] != 0) run2--;
res[i] = run2;
apr[run2]++;
}
cout << res[i] <<' ';
}
cout <<'\n';
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 20;
int n, a[N][N], sum;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (i == j || i + j == n - 1 || i == (n - 1) / 2 || j == (n - 1) / 2) {
sum += a[i][j];
}
}
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, d[200005], c, e[200005], l, r, ans;
string n;
int main() {
cin >> a;
while (a--) {
ans = 0;
cin >> b >> c;
l = 0, r = b - 1;
for (int s = 0; s < b; s++) cin >> d[s];
for (int s = 0; s < c; s++) cin >> e[s];
sort(d, d + b);
sort(e, e + c, greater<long long>());
for (int s = c - 1; s >= 0; s--) {
if (e[s] != 1) break;
ans += 2 * d[r];
r--;
}
for (int s = 0; s < c; s++) {
if (e[s] == 1) break;
ans += d[l] + d[r];
r--, l += (e[s] - 1);
}
cout << ans << endl;
}
}
| 3 |
Subsets and Splits