solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int a[N];
int mx[10 * N], dp[10 * N];
int n, s, t;
int inc(int x) { return x - t; }
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> s >> t;
if (s == t) {
cout << 0 << endl;
return 0;
}
sort(a, a + n);
n = unique(a, a + n) - a;
for (int i = 0; i < n; i++)
for (int j = s - (s % a[i]); j >= t; j -= a[i])
if (j - a[i] >= t) mx[inc(j)] = a[i];
dp[inc(s)] = 1;
for (int i = 0; i < n; i++)
if (s - (s % a[i]) >= t) dp[inc(s)] = max(dp[inc(s)], s % a[i]);
for (int i = s - 1; i > t; i--) {
dp[inc(i)] = 1;
if (i - (dp[inc(i + 1)] - 1) >= t)
dp[inc(i)] = max(dp[inc(i)], dp[inc(i + 1)] - 1);
if (mx[inc(i + 1)] != 0 && i - (mx[inc(i + 1)] - 1) >= t)
dp[inc(i)] = max(dp[inc(i)], mx[inc(i + 1)] - 1);
}
int ans = 0;
while (s != t) {
ans++;
s -= dp[inc(s)];
}
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, l = 1;
cin >> t;
while (t--) {
int x, y, z, x1, y1, z1, ans = 0;
cin >> x >> y >> z >> x1 >> y1 >> z1;
ans += min(z, y1) * 2;
z -= min(z, y1);
if (z1 > x + z) ans -= 2 * (z1 - x - z);
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using vc = vector<T>;
using pii = pair<long long, long long>;
void xmax(long long& a, long long b) { a = max(a, b); }
void xmin(long long& a, long long b) { a = min(a, b); }
void print(vc<long long>& a, string second) {
cerr << "prinitng " << second << ": ";
for (long long i = 0; i < a.size(); i++) {
cerr << a[i] << " ";
}
cerr << endl;
}
long long mod = 1e9 + 7;
long long inv2 = 5e8 + 4;
vc<vc<long long> > bin(51, vc<long long>(51, -1));
long long binom(long long n, long long k) {
if (k < 0) return 0;
if (bin[n][k] != -1) return bin[n][k];
if (k == 0) return 1;
if (n == 0) return 0;
return bin[n][k] = (binom(n - 1, k - 1) + binom(n - 1, k)) % mod;
}
vc<vc<vc<long long> > > dps(51, vc<vc<long long> >(51, vc<long long>(2)));
long long dp(long long n, long long k, long long w) {
if (n < 0 || k < 0) return 0;
return dps[n][k][w];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long nn, kk;
cin >> nn >> kk;
dps[1][0][0] = 1;
dps[0][0][0] = 0;
dps[0][0][1] = 1;
long long e = 1;
for (long long i = 2; i <= nn; i++) {
long long n = i;
for (long long k = 0; k <= kk; k++) {
for (long long j = 0; j < i; j++) {
for (long long k1 = 0; k1 <= k; k1++) {
long long add1 =
max(e, j) * max(e, i - 1 - j) *
(binom(i - 1, j) *
(dp(j, k1, 1) * dp(i - j - 1, k - k1, 1) % mod) % mod) %
mod;
long long add2 =
max(e, j) *
(max(e, i - 1 - j) *
((dp(j, k1 - 1, 0) * dp(i - j - 1, k - k1, 1)) % mod +
(dp(j, k1 - 1, 1) * dp(i - j - 1, k - k1, 0)) % mod +
(dp(j, k1 - 1, 0) * dp(i - j - 1, k - k1, 0)) % mod) %
mod) %
mod;
long long f_add1 = add1 * inv2 % mod;
long long f_add2 = inv2 * (binom(i - 1, j) * add2 % mod) % mod;
dps[i][k][0] = (dps[i][k][0] + f_add1) % mod;
dps[i][k][1] = (dps[i][k][1] + f_add2) % mod;
}
}
}
}
cout << (dps[nn][kk][1] + dps[nn][kk][0]) % mod << endl;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int neg = 1, num = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') neg = -1;
for (; isdigit(c); c = getchar()) num = (num << 1) + (num << 3) + c - '0';
return neg * num;
}
int n, T, cnt, d[2000010];
vector<int> g[2000010];
char s[2000010];
inline void Link(int u, int v) {
g[u].push_back(v);
g[v].push_back(u);
d[u]++;
d[v]++;
}
inline void Solve() {
n = cnt = read();
for (int i = 1; i <= 4 * n; i++) g[i].clear(), d[i] = 0;
for (int i = 1, u, v; i <= n - 1; i++) u = read(), v = read(), Link(u, v);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] == 'W')
Link(cnt + 1, i), Link(cnt + 1, cnt + 2), Link(cnt + 1, cnt + 3),
cnt += 3;
n = cnt;
int tot = 0;
for (int i = 1; i <= n; i++)
if (d[i] >= 4) {
cout << "White\n";
return;
}
for (int u = 1; u <= n; u++) {
if (d[u] < 3) continue;
int sum = 0;
tot++;
for (auto v : g[u]) sum += (d[v] == 1);
if (sum <= 1) {
cout << "White\n";
return;
}
}
if (tot < 2)
cout << "Draw\n";
else {
if (n & 1)
cout << "White\n";
else
cout << "Draw\n";
}
}
signed main() {
T = read();
while (T--) Solve();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int ck[3], t1, t2;
int main() {
scanf("%d%d%d%d%d", &ck[0], &ck[1], &ck[2], &t1, &t2);
ck[0] %= 12;
t1 %= 12;
t2 %= 12;
ck[0] = ck[0] * 3600 + ck[1] * 60 + ck[2];
ck[1] = (ck[1] * 60 + ck[2]) * 12;
ck[2] = ck[2] * 60 * 12;
t1 = t1 * 3600;
t2 = t2 * 3600;
sort(ck, ck + 3);
if (t1 > t2) swap(t1, t2);
if (t1 < ck[0] && t2 > ck[2]) return puts("YES"), 0;
if (t1 > ck[0] && t1 < ck[1] && t2 > ck[0] && t2 < ck[1])
return puts("YES"), 0;
if (t1 > ck[1] && t1 < ck[2] && t2 > ck[1] && t2 < ck[2])
return puts("YES"), 0;
if ((t1 < ck[0] && t2 < ck[0]) || (t1 > ck[2] && t2 > ck[2]))
return puts("YES"), 0;
puts("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int inf = std::numeric_limits<int>().max();
inline long long soma(long long x, long long y) {
return (x % 1000000007 + y % 1000000007) % 1000000007;
}
inline long long subtrai(long long x, long long y) {
return ((x % 1000000007 - y % 1000000007) + 1000000007) % 1000000007;
}
inline long long multiplica(long long x, long long y) {
return (x % 1000000007 * y % 1000000007) % 1000000007;
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v(n);
int sum = 0;
for (int i = 0; i < v.size(); i++) {
cin >> v[i];
sum += v[i];
}
int ct = 0;
for (int i = 0; i < v.size(); i++) {
if ((sum - v[i]) % 2 == 0) ct++;
}
cout << ct << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long n, m, nn, j, l;
while (~scanf("%I64d%I64d%I64d", &n, &nn, &m)) {
int lk = 0;
for (l = 1; l <= nn; l = l * m) {
if (l >= n) {
lk = 1;
break;
}
if (l * m <= 0 || l * m % m != 0) break;
}
if (lk == 0)
printf("-1\n");
else {
for (j = l; j <= nn; j = j * m) {
printf("%I64d", j);
if (j * m % m != 0) break;
if (j <= nn / m) printf(" ");
}
printf("\n");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
long long i, j, n, x, m, diff, req[300005] = {0}, ans[300005] = {0},
ara[300005] = {0};
cin >> n;
for (i = 0; i <= n; i++) {
ans[i] = -1;
}
for (i = 1; i <= n; i++) {
cin >> x;
diff = i - ara[x];
ara[x] = i;
req[x] = max(req[x], diff);
}
for (i = 0; i <= n; i++) {
diff = n + 1 - ara[i];
req[i] = max(req[i], diff);
}
for (i = n; i >= 1; i--) {
ans[req[i]] = i;
}
x = -1;
for (i = 1; i <= n; i++) {
if (ans[i] > x && x != -1) ans[i] = x;
if (ans[i] != -1) x = ans[i];
ans[i] = x;
}
for (i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using VV = vector<vector<T>>;
template <class T>
inline T SMIN(T& a, const T b) {
return a = (a > b) ? b : a;
}
template <class T>
inline T SMAX(T& a, const T b) {
return a = (a < b) ? b : a;
}
template <class Iter>
void __kumaerrc(Iter begin, Iter end) {
for (; begin != end; ++begin) {
cerr << *begin << ',';
}
cerr << endl;
}
void __kumaerr(istream_iterator<string> it) {
(void)it;
cerr << endl;
}
template <typename T, typename... Args>
void __kumaerr(istream_iterator<string> it, T a, Args... args) {
cerr << *it << "=" << a << ", ", __kumaerr(++it, args...);
}
template <typename S, typename T>
std::ostream& operator<<(std::ostream& _os, const std::pair<S, T>& _p) {
return _os << "{" << _p.first << ',' << _p.second << "}";
}
const int MAX_N = 1e6 + 1;
long long A[MAX_N], B[MAX_N];
int M, K, N, S;
int BB[MAX_N];
void nope() {
fprintf(stdout, "%d", -1), putchar('\n');
;
exit(0);
}
void yup(vector<int>& res) {
assert(M - int((res).size()) >= N * K);
fprintf(stdout, "%d", int((res).size())), putchar('\n');
;
for (int i = 0; i < (int((res).size())); ++i) printf("%d ", res[i] + 1);
fprintf(stdout, ""), putchar('\n');
;
exit(0);
}
int g(int l, int r) { return (r - l) / K; }
void f(int l, int r) {
int mrem = r - l - K, ext = r - l - S;
if (mrem > ext) return;
int s = K - (r - l), ss = max(0, s);
;
vector<int> res;
auto remM = [&]() {
vector<int> cur(M + 1, 0);
for (int i = (l); i < (r); ++i) {
int t = A[i];
if (cur[t] < BB[t])
cur[t]++;
else if (mrem > 0)
res.push_back(i), --mrem;
}
};
int x = g(0, l - ss), y = g(r, M);
if (x + y + 1 >= N) {
;
remM();
yup(res);
}
x = g(0, l), y = g(r + ss, M);
if (x + y + 1 >= N) {
;
remM();
yup(res);
}
}
void solve() {
for (int i = 0; i < (S); ++i) BB[B[i]]++;
int r = 0, cnt = 0;
map<int, int> cur;
for (int l = 0; l < (M); ++l) {
while (r < M && cnt < S) {
int t = A[r];
cur[t]++;
if (cur[t] <= BB[t]) ++cnt;
++r;
};
if (cnt == S) f(l, r);
int t = A[l];
if (cur[t] <= BB[t]) --cnt;
cur[t]--;
}
nope();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(12) << fixed;
cin >> M >> K >> N >> S;
for (int i = 0; i < (M); ++i) cin >> A[i];
for (int i = 0; i < (S); ++i) cin >> B[i];
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
namespace red {
inline long long read() {
long long x = 0;
char ch, f = 1;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return f ? x : -x;
}
const long long N = 3e5 + 10, inf = 0x3f3f3f3f3f3f3f3f;
long long n, m, sum, d, B, G, b[N], g[N];
vector<long long> a[N], f[N];
long long ans;
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline void exgcd(long long &x, long long &y, long long a, long long b) {
if (!b) {
x = 1, y = 0;
} else {
exgcd(y, x, b, a % b);
y -= a / b * x;
}
}
inline long long solve(vector<long long> a, vector<long long> b) {
vector<long long> s = a;
sum = b.size();
for (long long i = 0; i < sum; ++i) s.push_back(b[i]);
sort(s.begin(), s.end());
long long k = unique(s.begin(), s.end()) - s.begin(), x, y;
if (n == k) {
long long c[m];
memset(c, 0, sizeof(c));
sum = a.size();
for (long long i = 0; i < sum; ++i)
if (a[i] < m) ++c[a[i]];
sum = b.size();
for (long long i = 0; i < sum; ++i)
if (b[i] < m) ++c[b[i]];
for (long long i = m - 1; ~i; --i)
if (c[i] == 1) return i;
return -1;
}
vector<pair<long long, long long> > e[k << 1 | 1];
for (long long i = 0; i < k; ++i)
e[k << 1].push_back(pair<long long, long long>(i, s[i]));
exgcd(x, y, m, n), x = (x % n + n) % n;
pair<long long, long long> p[k];
for (long long i = 0; i < k; ++i)
p[i] = pair<long long, long long>(x * (s[i] - s[0]) % n, i);
sort(p, p + k);
for (long long i = 0, j = 1 % k; i < k; ++i, j = (++j == k) ? 0 : j)
e[p[i].second].push_back(pair<long long, long long>(
p[j].second + k,
m * (p[j].first - p[i].first - 1 < 0 ? p[j].first - p[i].first - 1 + n
: p[j].first - p[i].first - 1)));
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
bool vis[2 * k + 1];
long long dis[2 * k + 1], ret = 0;
memset(vis, 0, sizeof(vis));
memset(dis, 0x3f, sizeof(dis));
q.push(pair<long long, long long>(0, 2 * k)), dis[2 * k] = 0;
while (!q.empty()) {
long long now = q.top().second;
q.pop();
if (vis[now]) continue;
vis[now] = 1, ret = max(ret, dis[now]);
sum = e[now].size();
for (long long i = 0; i < sum; ++i) {
long long t = e[now][i].first;
long long len = e[now][i].second;
if (dis[t] > dis[now] + len) {
dis[t] = dis[now] + len;
q.push(pair<long long, long long>(dis[t], t));
}
}
}
return ret;
}
inline void main() {
n = read(), m = read(), B = read();
for (long long i = 1; i <= B; ++i) b[i] = read();
G = read();
for (long long i = 1; i <= G; ++i) g[i] = read();
if (n < m) swap(n, m), swap(B, G), swap(b, g);
if ((d = gcd(n, m)) > B + G) return (void)puts("-1");
n /= d, m /= d;
for (long long i = 1; i <= B; ++i) a[b[i] % d].push_back(b[i] / d);
for (long long i = 1; i <= G; ++i) f[g[i] % d].push_back(g[i] / d);
for (long long i = 0; i < d; ++i)
if (!a[i].size() && !f[i].size()) return (void)puts("-1");
for (long long i = 0; i < d; ++i) ans = max(ans, solve(a[i], f[i]) * d + i);
printf("%lld\n", ans);
}
} // namespace red
signed main() {
red::main();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
struct ajutor {
int st, dr, nr;
};
bool cmp(ajutor a, ajutor b) {
if (a.st == b.st) return a.dr > b.dr;
return a.st < b.st;
}
const int N = 200005;
int maxdr[18][N];
int maxnr[18][N];
ajutor v[N];
int id[N];
int p2[N];
int cnt;
void makermq() {
p2[1] = 0;
for (int i = 2; i <= cnt; i++) p2[i] = p2[i / 2] + 1;
for (int i = 1; i < cnt; i++) {
maxdr[0][i] = v[i].dr;
maxnr[0][i] = v[i].nr;
}
for (int log = 1; log < 18; log++) {
for (int i = 1; i < cnt; i++) {
maxdr[log][i] =
max(maxdr[log - 1][i + (1 << (log - 1))], maxdr[log - 1][i]);
maxnr[log][i] =
max(maxnr[log - 1][i + (1 << (log - 1))], maxnr[log - 1][i]);
}
}
}
int querydr(int st, int dr) {
int len = p2[dr - st + 1];
return max(maxdr[len][st], maxdr[len][dr - (1 << len) + 1]);
}
int querynr(int st, int dr) {
int len = p2[dr - st + 1];
return max(maxnr[len][st], maxnr[len][dr - (1 << len) + 1]);
}
int cautb(int val) {
int p2 = 1 << 18, pas = 0;
while (p2) {
if (pas + p2 < cnt && v[pas + p2].st <= val) pas += p2;
p2 /= 2;
}
return pas;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
cnt = 1;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
if (id[a] == 0) id[a] = cnt++;
if (v[id[a]].st == 0) v[id[a]].st = i;
v[id[a]].dr = i;
v[id[a]].nr++;
}
sort(v + 1, v + cnt, cmp);
makermq();
int rasp = 0;
int i = 1;
while (i < cnt) {
int cautadr = v[i].dr;
int upoz;
while (cautadr <= n) {
upoz = cautb(cautadr);
if (cautadr == querydr(i, upoz))
break;
else {
cautadr = querydr(i, upoz);
}
}
rasp += cautadr - v[i].st + 1 - querynr(i, upoz);
i = upoz + 1;
}
printf("%d", rasp);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long N = 3e5 + 7;
long long n;
long long arr[N];
long long dist(pair<long long, long long> p1, pair<long long, long long> p2) {
long long x = (p1.first - p2.first);
long long y = (p1.second - p2.second);
return x * x + y * y;
}
long long xx[4] = {1, -1, 1, -1};
long long yy[4] = {1, 1, -1, -1};
void solve() {
long long l, r;
cin >> l >> r;
vector<pair<long long, long long> > v1, v2;
long long h = l * l + r * r;
for (long long x = 1; x < l; x++) {
long long y = sqrt(l * l - x * x);
if (y * y + x * x == l * l) v1.push_back({x, y});
}
for (long long x = 1; x < r; x++) {
long long y = sqrt(r * r - x * x);
if (y * y + x * x == r * r) v2.push_back({x, y});
}
bool f = 0;
pair<long long, long long> a1, a2;
for (long long i = 0; i < v1.size(); i++) {
for (long long j = 0; j < v2.size(); j++) {
pair<long long, long long> p1 = v1[i];
pair<long long, long long> p2 = v2[j];
for (long long k = 0; k < 4; k++) {
pair<long long, long long> pp1 = p1;
pair<long long, long long> pp2 = p2;
pp1.first *= xx[k];
pp1.second *= yy[k];
for (long long m = 0; m < 4; m++) {
pp2.first *= xx[m];
pp2.second *= yy[m];
if (dist(pp1, pp2) == h and pp1.first != pp2.first and
pp1.second != pp2.second) {
f = 1;
a1 = pp1;
a2 = pp2;
break;
}
}
}
}
}
if (f) {
cout << "YES" << '\n';
cout << 0 << " " << 0 << '\n';
cout << a1.first << " " << a1.second << '\n';
cout << a2.first << " " << a2.second;
} else {
cout << "NO";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
| 8 |
#include<bits/stdc++.h>
#define ll long long
#define For(i,a,b) for(int i=a;i<b;i++)
#define rFor(i,a,b) for(int i=a;i>=b;i--)
#define mFor(it,m) for(auto it=m.begin(); it!=m.end(); it++)
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
ll n,x,count=0;
cin>>n>>x;
map<ll,ll> m;
ll a[n];
For(i,0,n)
{
cin>>a[i];
m[a[i]%x]++;
}
mFor(i,m)
{
if(i->second!=0)
{
ll y=x-i->first;
if(m[y])
{
if(m[y]==i->second)
count++;
else
{
count++;
count+=(abs(m[y]-m[i->first])-1);
}
m[y]=0;
m[i->first]=0;
}
else if(i->first==0)
{
count++;
}
else
{
count+=(i->second);
}
}
}
cout<<count<<"\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char str[100005];
long long int dp[11], nxt[11];
int main() {
scanf("%s", &str);
int n = strlen(str);
memset(dp, 0, sizeof(dp));
long long int ret = 0;
for (int i = 0; i < n; i++) {
int c = str[i] - '0';
memset(nxt, 0, sizeof(nxt));
for (int j = c + 1; j < 11; j++) {
int to = (j * j - j - 2) / 2 + c;
if (to < 0) to += 11;
to %= 11;
nxt[to] += dp[j];
}
if (c > 0) nxt[c]++;
for (int j = 0; j < 11; j++) {
ret += nxt[j];
dp[j] = nxt[j];
}
}
printf("%lld\n", ret);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int ara[200005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ara[i];
ara[i] = abs(ara[i]);
}
long long ans = 0;
sort(ara, ara + n);
for (long long i = 0; i < n; i++) {
long long r = upper_bound(ara, ara + n, ara[i] * 2) - ara;
r--;
ans += max(0LL, r - i);
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char arr[n];
queue<int> d, r;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 'D')
d.push(i);
else
r.push(i);
}
while (!d.empty() && !r.empty()) {
if (d.front() > r.front()) {
r.push(r.front() + n);
r.pop();
d.pop();
} else {
d.push(d.front() + n);
d.pop();
r.pop();
}
}
if (d.empty())
cout << 'R';
else
cout << 'D';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const int INF = 2000000009;
const int MX = 100005;
const double EPS = 1e-9;
const int MOD = 1000000007;
int u[MX], v[MX], w[MX];
map<int, int> fen[MX];
void add(int node, int x, int val) {
while (x < MX) {
fen[node][x] = max(fen[node][x], val);
x += x & (-x);
}
}
int getMax(int node, int x) {
int mx = 0;
while (x > 0) {
mx = max(mx, fen[node][x]);
x -= x & (-x);
}
return mx;
}
int main() {
int n = ({
int a;
read(a);
a;
}),
m = ({
int a;
read(a);
a;
});
for (int i = 0; i < m; i++)
u[i] = ({
int a;
read(a);
a;
}),
v[i] = ({
int a;
read(a);
a;
}),
w[i] = ({
int a;
read(a);
a;
}) +
2;
int ans = 0;
for (int i = 0; i < m; i++) {
int mx = getMax(u[i], w[i] - 1) + 1;
ans = max(ans, mx);
add(v[i], w[i], mx);
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void debug(...) {}
const int maxn = 1000010;
int n, m;
char a[maxn], b[maxn], c[maxn << 1];
int za[maxn], zb[maxn], zc[maxn << 1];
void build(char c[], char a[], int z[], int za[]) {
for (int i = 1, l = 0, r = 0; i <= n + m; ++i) {
z[i] = max(0, min(z[i - l], r - i + 1));
while (i + z[i] <= n + m &&
(z[i] <= m ? c[z[i]] : a[z[i] - m - 1]) ==
(z[i] + i <= m ? c[z[i] + i] : a[z[i] + i - m - 1]))
l = i, r = i + z[i]++;
}
for (int i = 0; i < n; ++i) za[i] = z[i + m + 1];
}
void init() {
build(c, a, zc, za);
reverse(c, c + m);
reverse(b, b + n);
build(c, b, zc, zb);
reverse(c, c + m);
reverse(b, b + n);
reverse(zb, zb + n);
for (int i = 0; i < n; ++i) {
if (za[i] == m) --za[i];
if (zb[i] == m) --zb[i];
}
debug(za, za + n);
debug(zb, zb + n);
}
int ca[maxn], cb[maxn];
ll sa[maxn], sb[maxn];
ll res;
struct bit {
ll v[maxn];
void add(int i, ll val) {
if (!i) return;
for (; i <= n; i += i & -i) v[i] += val;
}
void reset() { fill(v, v + n + 1, 0); }
ll query(int i) {
ll res = 0;
for (; i; i ^= i & -i) res += v[i];
return res;
}
ll query(int l, int r) { return query(r) - query(l - 1); }
} ts, tc;
void minu() {
if (m > n) return;
for (int i = 0; i < n; ++i) {
if (za[i] + n >= m)
res -= ts.query(m - za[i], n) - tc.query(m - za[i], n) * (m - za[i] - 1);
ts.add(zb[i], zb[i]);
tc.add(zb[i], 1);
}
ts.reset(), tc.reset();
for (int i = n - 1; i >= 0; --i) {
if (i + m - 1 < n) {
ts.add(zb[i + m - 1], zb[i + m - 1]);
tc.add(zb[i + m - 1], 1);
}
if (za[i] + n >= m)
res -= ts.query(m - za[i], n) - tc.query(m - za[i], n) * (m - za[i] - 1);
}
}
void solve() {
init();
for (int i = 0; i < n; ++i) ++ca[za[i]], ++cb[zb[i]];
for (int i = 1; i <= n; ++i)
sa[i] = sa[i - 1] + ca[i] * (ll)i, ca[i] += ca[i - 1];
for (int i = 1; i <= n && i < m; ++i)
if (cb[i] && m - i <= n) {
ll ad =
(sa[n] - sa[m - i - 1]) - (ll)(m - i - 1) * (ca[n] - ca[m - i - 1]);
res += ad * cb[i];
}
0;
minu();
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> a >> b >> c;
solve();
cout << res << '\n';
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long n, K;
long long X[200000], C[200000];
long long A;
set<long long> S;
long long output;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> K;
for (long long i = 0; i < n; i++) cin >> X[i];
cin >> A;
long long key = 0;
for (long long i = 0; i < n; i++) cin >> C[i];
for (long long i = 0; i < n; i++) {
S.insert(C[i]);
while (S.empty() == 0 && K < X[i]) {
K += A;
output += *S.begin();
S.erase(S.begin());
}
if (K < X[i]) {
key = 1;
break;
}
}
if (key == 1) output = -1;
cout << output;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
int T1[MAXN + 7];
int T2[MAXN + 7];
int main() {
int n;
scanf("%d", &n);
int a, b;
for (int i = 0; i < n; i++) {
scanf("%d", &T1[i]);
if (T1[i] == 1) a = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &T2[i]);
if (T2[i] == 1) b = i;
}
int x = a - 1;
for (int i = 0; i < n + 7; i++) {
if (T1[a] != T2[b]) {
printf("NO");
return 0;
}
a++;
b++;
if (a == n) a = 0;
if (b == n) b = 0;
if (T1[a] == 0) a++;
if (T2[b] == 0) b++;
if (a == n) a = 0;
if (b == n) b = 0;
}
if (T1[a] == T2[b])
printf("YES");
else
printf("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[10000000], b[10000000];
int x, y;
int main() {
cin >> a;
x = strlen(a);
for (int i = x - 1; i >= 0; i--) {
b[i] = max(b[i + 1], a[i]);
}
for (int i = 0; i <= x - 1; i++) {
if (b[i] == a[i]) {
cout << a[i];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int anum, bnum, n, sum = 0, re = 0, a, b;
scanf("%I64d", &n);
while (n--) {
scanf("%I64d %I64d", &a, &b);
while (a && b) {
sum += a / b;
anum = a % b;
a = b;
b = anum;
}
printf("%I64d\n", sum);
sum = 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dist[100001];
bool done[100001];
void dijkstra(long long source, vector<pair<long long, long long> > ed[],
long long v) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
for (long long i = 0, _n = (v); i < _n; i++) {
dist[i + 1] = 1000000000000000;
done[i + 1] = false;
}
dist[source] = {0};
pq.push(make_pair(0, source));
while (!pq.empty()) {
long long minKey = pq.top().second;
pq.pop();
for (long long j = 0, _n = (ed[minKey].size()); j < _n; j++) {
long long a = minKey;
long long b = ed[a][j].first;
long long w = ed[a][j].second;
if (!done[b] && dist[a] + w < dist[b]) {
dist[b] = dist[a] + w;
pq.push(make_pair(dist[b], b));
}
}
done[minKey] = true;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
long long c[n];
long long f[n + 1];
long long p1 = 1;
long long re[k + 1];
re[1] = 1;
for (long long i = 0, _n = (k); i < _n; i++) {
cin >> c[i];
for (long long j = 0, _n = (c[i]); j < _n; j++) {
f[p1] = i + 1;
p1++;
}
}
for (long long i = (2), _b = (k); i <= _b; i++) {
re[i] = re[i - 1] + c[i - 1];
}
vector<pair<long long, long long> > ed[n + 1];
for (long long i = 0, _n = (m); i < _n; i++) {
long long u, v, w;
cin >> u >> v >> w;
ed[u].push_back(make_pair(v, w));
ed[v].push_back(make_pair(u, w));
}
for (long long i = (1), _b = (k); i <= _b; i++) {
if (!done[re[i]]) dijkstra(re[i], ed, n);
}
long long hu = true;
p1 = 1;
for (long long i = 0, _n = (k); i < _n; i++) {
long long x = dist[p1];
for (long long j = 0, _n = (c[i]); j < _n; j++) {
if (dist[p1] != x) {
hu = false;
}
p1++;
}
}
if (!hu) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
long long mat[k + 1][k + 1];
for (long long i = 0, _n = (k + 1); i < _n; i++) {
for (long long j = 0, _n = (k + 1); j < _n; j++) {
mat[i][j] = 1000000000000000;
}
}
for (long long i = 0, _n = (k + 1); i < _n; i++) {
mat[i][i] = 0;
}
for (long long i = (1), _b = (n); i <= _b; i++) {
for (long long j = 0, _n = (ed[i].size()); j < _n; j++) {
long long x = i;
long long y = ed[i][j].first;
long long w = ed[i][j].second;
if (mat[f[x]][f[y]] > w) mat[f[x]][f[y]] = w;
}
}
long long dp[k + 1][k + 1];
for (long long i = 0, _n = (k); i < _n; i++) {
for (long long j = 0, _n = (k); j < _n; j++) {
dp[i + 1][j + 1] = mat[i + 1][j + 1];
}
}
for (long long l = 0, _n = (k); l < _n; l++) {
for (long long i = 0, _n = (k); i < _n; i++) {
for (long long j = 0, _n = (k); j < _n; j++) {
dp[i + 1][j + 1] =
min(dp[i + 1][j + 1], dp[i + 1][l + 1] + dp[l + 1][j + 1]);
}
}
}
for (long long i = 0, _n = (k); i < _n; i++) {
for (long long j = 0, _n = (k); j < _n; j++) {
if (dp[i + 1][j + 1] >= 10000000000)
cout << "-1 ";
else
cout << dp[i + 1][j + 1] << " ";
}
cout << endl;
}
}
| 12 |
#include<bits/stdc++.h>
using namespace std;
const double eps=1e-10;
const int maxn=2e5+5;
struct Point{
double x,y;
Point(double _x=0,double _y=0):x(_x),y(_y) { }
Point operator - (const Point &b) const
{
return Point(x-b.x,y-b.y);
}
double operator ^ (const Point &b) const
{
return x*b.y-y*b.x;
}
double operator *(const Point &b) const
{
return x*b.x+y*b.y;
}
}a[maxn];
double dis(Point A,Point B) { return sqrt((A-B)*(A-B)); }
int sta[maxn]; bool vis[maxn];
int main(void)
{
int n; double H; scanf("%d%lf",&n,&H);
for(int i=1;i<=n;i++) scanf("%lf%lf",&a[i].x,&a[i].y);
Point p=Point(a[n].x,a[n].y+H);
int sz=0;
for(int i=1;i<=n;i++)
{
while(sz&&((a[sta[sz]]-p)^(a[i]-p))<0) sz--;
sta[++sz]=i;
}
for(int i=1;i<=sz;i++) vis[sta[i]]=true;
double res=0;
for(int i=1;i<=n-1;i++)
{
if(vis[i]&&vis[i+1])
{
res+=dis(a[i],a[i+1]);
}
else if(vis[i]&&!vis[i+1])
{
int pos=upper_bound(sta+1,sta+1+sz,i)-sta;
pos=sta[pos];
double k1=(p.y-a[pos].y)/(p.x-a[pos].x);
double b1=p.y-k1*p.x;
double k2=(a[i].y-a[i+1].y)/(a[i].x-a[i+1].x);
double b2=a[i].y-k2*a[i].x;
double tx=(b2-b1)/(k1-k2);
double ty=k2*tx+b2;
res+=dis(a[i],Point(tx,ty));
}
}
printf("%.12lf\n",res);
return 0;
} | 17 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long c[110];
long long p[110][110];
long long dp[110][110][110];
long long solve(long long i, long long j, long long kk) {
if (kk == -1) return 9e18;
if (i == -1) {
if (kk == 0) return 0;
return 9e18;
}
if (dp[i][j][kk] != -1) return dp[i][j][kk];
long long ans = 9e18;
if (c[i] != 0)
ans = min(ans, solve(i - 1, c[i], kk - (c[i] != j)));
else {
for (long long cc = 1; cc <= m; cc++)
ans = min(ans, p[i][cc - 1] + solve(i - 1, cc, kk - (cc != j)));
}
return dp[i][j][kk] = ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int Y = 1;
while (Y--) {
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) cin >> c[i];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> p[i][j];
}
}
memset(dp, -1, sizeof(dp));
long long ans = solve(n - 1, 0, k);
if (ans == 9e18)
cout << "-1" << '\n';
else
cout << ans << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long s) {
for (long long i = 2, _b = sqrt(s); i <= _b; i++)
if (s % i == 0) return false;
return true;
}
vector<long long> snt, ans;
int bd[66], dp[102][1 << 17], gt[102][1 << 17], res = 1e9, n, a[103], now;
pair<long long, long long> lu;
void Solve() {
cin >> n;
for (long long i = 1, _b = n; i <= _b; i++) cin >> a[i];
for (long long i = 2, _b = 60; i <= _b; i++)
if (check(i)) snt.push_back(i);
for (long long i = 2, _b = 60; i <= _b; i++) {
long long b = 0;
for (long long j = 0, _b = snt.size(); j < _b; j++) {
if (i % snt[j] == 0) b |= (1 << j);
}
bd[i] = b;
}
for (long long i = 0, _b = n; i <= _b; i++)
for (long long j = 0, _b = 1 << 17; j <= _b; j++) dp[i][j] = 1e9;
dp[0][0] = 0;
for (long long i = 1, _b = n; i <= _b; i++) {
for (long long id = 1, _b = 59; id <= _b; id++) {
long long x = (~bd[id]) & ((1 << 17) - 1);
long long s = x;
while (1) {
if (dp[i][s | bd[id]] > dp[i - 1][s] + abs(a[i] - id)) {
dp[i][s | bd[id]] = dp[i - 1][s] + abs(a[i] - id);
gt[i][s | bd[id]] = id;
}
if (s == 0) break;
s = (s - 1) & x;
}
}
}
for (long long i = 0, _b = 1 << 17; i < _b; i++)
if (res > dp[n][i]) {
res = dp[n][i];
lu = {n, i};
}
for (long long i = 1, _b = n; i <= _b; i++) {
long long tmp = gt[lu.first][lu.second];
ans.push_back(tmp);
lu.second -= bd[tmp];
lu.first--;
}
reverse(ans.begin(), ans.end());
for (auto x : ans) cout << x << " ";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int Test_numbers = 1;
while (Test_numbers--) Solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 100007, __ = 300007, _n = _ << 1, lglg = 19;
vector<pair<int, int>> e[_];
inline void adde(int a, int b, int c) { e[a].emplace_back(b, c); }
inline void addde(int a, int b, int c) { adde(a, b, c), adde(b, a, c); }
int n, m, chx, qn;
long long dis[_], via[_];
int ed[_];
struct cxk {
int a, b;
long long v;
cxk(int a_ = 0, int b_ = 0, long long v_ = 0) { a = a_, b = b_, v = v_; }
friend int operator<(cxk a, cxk b) { return a.v < b.v; }
} es[__];
int ecnts = 0;
void dijks() {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
memset(dis, 63, sizeof(dis)), memset(ed, 0, sizeof(ed));
for (int i = 1; i <= chx; i++) dis[i] = 0, via[i] = i, q.emplace(dis[i], i);
while (!q.empty()) {
int a = q.top().second;
q.pop();
if (ed[a]) continue;
ed[a] = 1;
for (auto [b, c] : e[a]) {
if (dis[b] <= dis[a] + c) continue;
dis[b] = dis[a] + c, via[b] = via[a];
if (!ed[b]) q.emplace(dis[b], b);
}
}
for (int i = 1; i <= n; i++)
for (auto [b, c] : e[i])
if (b > i && via[i] != via[b])
es[++ecnts] = cxk(via[i], via[b], dis[i] + dis[b] + c);
}
int bfa[_n] = {0};
int findbfa(int x) { return bfa[x] == x ? x : bfa[x] = findbfa(bfa[x]); }
int pfa[_n][lglg + 1] = {0}, pdep[_n] = {0}, pcnt = 0;
long long pva[_n] = {0};
int lca(int a, int b) {
if (pdep[a] < pdep[b]) swap(a, b);
for (int i = lglg; i >= 0; i--)
if (pdep[pfa[a][i]] >= pdep[b]) a = pfa[a][i];
if (a == b) return a;
for (int i = lglg; i >= 0; i--)
if (pfa[a][i] != pfa[b][i]) a = pfa[a][i], b = pfa[b][i];
if (a != b) a = pfa[a][0], b = pfa[b][0];
return a;
}
void kuro() {
sort(es + 1, es + ecnts + 1);
pcnt = n;
for (int i = 1; i <= pcnt; i++) bfa[i] = i;
for (int i = 1; i <= ecnts; i++) {
auto [a, b, c] = es[i];
int aa = findbfa(a), bb = findbfa(b);
if (aa == bb) continue;
pcnt++, bfa[pcnt] = bfa[aa] = bfa[bb] = pcnt, pva[pcnt] = c,
pfa[aa][0] = pfa[bb][0] = pcnt;
}
for (int i = pcnt; i >= 1; i--) pdep[i] = pdep[pfa[i][0]] + 1;
for (int i = 1; i <= lglg; i++)
for (int j = 1; j <= pcnt; j++) pfa[j][i] = pfa[pfa[j][i - 1]][i - 1];
}
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty(), chx = ty(), qn = ty();
for (int i = 1, a, b, c; i <= m; i++)
a = ty(), b = ty(), c = ty(), addde(a, b, c);
dijks(), kuro();
for (int qq = 1; qq <= qn; qq++) {
int a = ty(), b = ty();
cout << pva[lca(a, b)] << lf;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int partition(vector<int> &v, int low, int high) {
int pivot = v[high];
int i = low - 1;
for (int j = low; j <= high; ++j) {
if (v[j] < pivot) {
++i;
swap(v[i], v[j]);
}
}
swap(v[i + 1], v[high]);
return i + 1;
}
void quicksort(vector<int> &v, int low, int high) {
if (low < high) {
int mid = partition(v, low, high);
cout << mid << " ";
quicksort(v, low, mid - 1);
quicksort(v, mid + 1, high);
}
}
long long int fun(vector<long long int> v, long long int sum1,
long long int sum2) {
for (long long int i = 0; i < v.size(); ++i) {
if (sum2 < sum1)
sum2 += v[i];
else
sum1 += v[i];
}
return sum1 > sum2 ? sum1 : sum2;
}
bool check(long long int n) {
set<long long int> s;
while (n > 0) {
s.insert(n % 10);
n /= 10;
}
if (s.size() == 4) return 1;
return 0;
}
bool prime[2083320];
vector<long long int> seive_of_eratosthenes() {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 2083320; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 2083320; i += p) prime[i] = false;
}
}
vector<long long int> v;
for (long long int i = 2; i < 2083320; ++i) {
if (prime[i]) v.push_back(i);
}
return v;
}
void fun1(string s, long long int i, long long int j, long long int n,
long long int k, long long int ans) {
for (; i < n and j < n;) {
if (s[i] == 'I' and s[j] == 'M') {
long long int count = 0;
long long int diff = j - i;
if (diff < 0) {
diff = diff * -1;
for (long long int x = j + 1; x < i; x++) {
if (s[x] == ':') count++;
}
} else {
for (long long int x = i + 1; x < j; x++) {
if (s[x] == ':') count++;
}
}
long long int p = k + 1 - diff - count;
if (p > 0)
ans++, i++, j++;
else if (i > j)
j++;
else
i++;
} else {
if (s[i] == 'X' or s[j] == 'X') {
if (s[i] == 'X') {
i = i + 1;
j = i;
} else {
j = j + 1;
i = j;
}
} else {
if (s[i] != 'I') {
i++;
}
if (s[j] != 'M') {
j++;
}
}
}
}
cout << ans << "\n";
}
void fun(string s, long long int i, long long int j, long long int n,
long long int k, long long int ans) {
fun1(s, i, j, n, k, ans);
}
string help(string s, int k) {
if (k == 1) return s;
string ans = "";
unordered_map<char, int> m;
for (int i = 0; i < s.size(); i++) m[s[i]]++;
for (auto i = m.begin(); i != m.end(); i++) {
if (i->second % k) return "-1";
int x = i->second / k;
while (x--) ans += (i->first);
}
string temp = ans;
k--;
while (k--) ans += temp;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int m = max((3 * a) / 10, a - ((a * c) / 250));
long long int v = max((3 * b) / 10, b - ((b * d) / 250));
if (m > v)
cout << "Misha";
else if (m < v)
cout << "Vasya";
else
cout << "Tie";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int x[N], y[N], cx[N], cy[N], s[2][2];
int n, m, vx, vy, dx, dy;
long long ans = 0;
int read_int() {
int a = 0;
int b = 1, c = getchar();
if (c == '-')
b = -1;
else
a = c - 48;
while ((c = getchar()) != ' ' && c != '\n') a = a * 10 + c - 48;
a *= b;
return a;
}
int main() {
n = read_int();
m = (n - 1) / 2;
for (int i = 0; i < n; ++i) {
x[i] = read_int();
y[i] = read_int();
cx[i] = x[i], cy[i] = y[i];
}
sort(x, x + n);
dx = x[m + 1] - x[m];
sort(y, y + n);
dy = y[m + 1] - y[m];
if (n % 2) {
dx = ((dx) > (x[m] - x[m - 1]) ? (x[m] - x[m - 1]) : (dx));
dy = ((dy) > (y[m] - y[m - 1]) ? (y[m] - y[m - 1]) : (dy));
}
vx = x[m], vy = y[m];
bool exist = false;
for (int i = 0; i < n; ++i) {
ans += abs(x[i] - vx) + abs(y[i] - vy);
s[cx[i] <= vx][cy[i] <= vy] = 1;
if (vx == cx[i] && vy == cy[i]) exist = true;
}
if ((n % 2 == 0 || exist) && s[0][0] & s[0][1])
ans = ((ans - dx) > (ans - dy) ? (ans - dx) : (ans - dy));
printf("%I64d\n", ans * 2);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int one = 1048576;
int n, inf = 1e9, f[40][one], g[30][30];
char s[30][30];
bool check(int x, int y) { return x >= 0 && y >= 0 && x < n && y < n; }
int Get(int x, int y, int c) {
if (c == 0) {
if ((x + y) & 1) return -1;
return 1;
}
if (c == 1) {
if ((x + y) & 1) return 1;
return -1;
}
return 0;
}
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
int Dp(int u, int sta) {
if (u == n * 2 - 2) return g[n - 1][n - 1];
if (f[u][sta] != -inf) return f[u][sta];
int tmp;
for (int j = 0; j < n; j++)
if ((sta >> j) & 1) {
tmp = g[j][u - j];
break;
}
for (int i = 0; i < 26; i++) {
int New = 0;
for (int j = 0; j < n; j++)
if ((sta >> j) & 1) {
int x = j, y = u - j;
if (check(x + 1, y) && s[x + 1][y] == 'a' + i) New |= 1 << (x + 1);
if (check(x, y + 1) && s[x][y + 1] == 'a' + i) New |= 1 << x;
}
if (New) f[u][sta] = max(f[u][sta], Dp(u + 1, New));
}
return f[u][sta] = tmp - f[u][sta];
}
int main() {
read(n);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i][j] = Get(i, j, s[i][j] - 'a');
for (int i = 0; i < n * 2; i++)
for (int j = 0; j < (1 << n); j++) f[i][j] = -inf;
int t = Dp(0, 1);
if (t > 0)
printf("FIRST\n");
else if (t < 0)
printf("SECOND\n");
else
printf("DRAW\n");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 70000 + 5, S = 70000 + 5;
int n, s;
int an[N];
bitset<S> f, ft, dt[N / 3 + 5];
bool direct[N];
int od[N], sz_od, pos[N];
inline bool cmp_int_bag_an(int a, int b) { return an[a] < an[b]; }
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; ++i) scanf("%d", &an[i]);
int big = 0;
for (int i = 1; i <= n; ++i)
if (an[i] > an[big]) big = i;
if (an[big] > s) {
puts("-1");
return 0;
}
f[0] = 1;
if (n <= 6) {
for (int i = 1; i <= n; ++i) {
if (i != big) {
ft = f;
f = ft | (ft << an[i]);
dt[i] = f ^ ft;
}
}
if (!f[s - an[big]]) {
puts("-1");
return 0;
}
int t = s - an[big];
for (int i = n; i >= 1; --i)
if (dt[i][t]) {
direct[i] = true;
t -= an[i];
}
} else {
int s1 = n / 3, s2 = s1 + n / 3, s3 = n;
for (int i = 1; i <= s2; ++i)
if (i != big) {
ft = f;
f = ft | (ft << an[i]);
}
for (int i = s2 + 1; i <= s3; ++i)
if (i != big) {
ft = f;
f = ft | (ft << an[i]);
dt[i - s2] = f ^ ft;
}
if (!f[s - an[big]]) {
puts("-1");
return 0;
}
int t = s - an[big];
for (int i = s3; i >= s2 + 1; --i)
if (dt[i - s2][t]) {
direct[i] = true;
t -= an[i];
}
f.reset();
f[0] = 1;
for (int i = 1; i <= s1; ++i)
if (i != big) {
ft = f;
f = ft | (ft << an[i]);
}
for (int i = s1 + 1; i <= s2; ++i)
if (i != big) {
ft = f;
f = ft | (ft << an[i]);
dt[i - s1] = f ^ ft;
}
for (int i = s2; i >= s1 + 1; --i)
if (dt[i - s1][t]) {
direct[i] = true;
t -= an[i];
}
f.reset();
f[0] = 1;
for (int i = 1; i <= s1; ++i)
if (i != big) {
ft = f;
f = ft | (ft << an[i]);
dt[i] = f ^ ft;
}
for (int i = s1; i >= 1; --i)
if (dt[i][t]) {
direct[i] = true;
t -= an[i];
}
}
for (int i = 1; i <= n; ++i)
if (!direct[i]) {
od[++sz_od] = i;
}
sort(od + 1, od + sz_od + 1, cmp_int_bag_an);
for (int i = 1; i <= sz_od; ++i) pos[od[i]] = i;
for (int i = 1; i <= n; ++i) {
if (direct[i] || pos[i] == 1)
printf("%d 0\n", an[i]);
else
printf("%d 1 %d\n", an[i] - an[od[pos[i] - 1]], od[pos[i] - 1]);
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, temp, ar1[2010], ar2[2010], con[2010], i = 1, c = 0, c1 = 0, j, pos;
for (i = 1; i <= 2010; i++) con[i] = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &ar1[i]);
ar2[i] = i;
con[ar1[i]] += 1;
}
for (i = 1; i <= 2010; i++) {
if (con[i] > 1) c += 1;
if (con[i] > 2) {
c1 = 1;
break;
}
}
if ((c < 2) && (c1 == 0))
printf("NO");
else if ((c >= 2) || (c1 = 1)) {
printf("YES\n");
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
if (ar1[i] > ar1[j]) {
temp = ar1[i];
ar1[i] = ar1[j];
ar1[j] = temp;
temp = ar2[i];
ar2[i] = ar2[j];
ar2[j] = temp;
}
}
}
for (i = 1; i <= n; i++) printf("%d ", ar2[i]);
printf("\n");
for (j = 1; j < n; j++) {
if (ar1[j] == ar1[j + 1]) {
pos = j + 1;
temp = ar2[j];
ar2[j] = ar2[j + 1];
ar2[j + 1] = temp;
break;
}
}
for (i = 1; i <= n; i++) printf("%d ", ar2[i]);
printf("\n");
for (j = pos; j <= n; j++) {
if (ar1[j] == ar1[j + 1]) {
temp = ar2[j];
ar2[j] = ar2[j + 1];
ar2[j + 1] = temp;
break;
}
}
for (i = 1; i <= n; i++) printf("%d ", ar2[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ara[100001];
int main() {
int n, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ara[i];
while (ara[i] % 2 == 0) ara[i] /= 2;
while (ara[i] % 3 == 0) ara[i] /= 3;
}
for (int i = 2; i <= n; i++) {
if (ara[1] != ara[i]) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int a, d;
vector<long long int> val(10000007, 0);
vector<long long int> su(10000007, 0);
int main() {
long long int q, n, x, y, i, j, k, ans = 0, lim = 2000000;
cin >> a >> d >> q;
su[0] = val[0] = 0;
for (i = 1; i <= 2000000; i++) {
val[i] = a + (i - 1) * d;
su[i] = su[i - 1] + val[i];
}
while (q--) {
long long int l, t, m;
cin >> l >> t >> m;
if (a + (l - 1) * d > t) {
cout << "-1\n";
continue;
}
int ta, tb;
ta = lower_bound(su.begin() + l, su.begin() + lim, t * m + su[l - 1]) -
su.begin();
tb = lower_bound(val.begin() + l, val.begin() + lim, t) - val.begin();
if (su[ta] != t * m + su[l - 1]) ta--;
if (val[tb] != t) tb--;
ta = min(ta, tb);
if (ta >= l)
cout << ta << "\n";
else
cout << "-1\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ct[5010], A[100010], dp[100010];
long long fact[100100];
long long moduloexp(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (1LL * res * a) % 1000000007;
b /= 2;
a = (1LL * a * a) % 1000000007;
}
return res;
}
long long comb(long long n, long long r) {
if (n < r) return 0;
return (1LL * fact[n] *
moduloexp((1LL * fact[n - r] * fact[r]) % 1000000007,
1000000007 - 2)) %
1000000007;
}
void init() {
fact[0] = 1;
for (int i = 1; i < 100010; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
}
bool islucky(int x) {
string s = to_string(x);
for (int i = 0; i < s.length(); i++) {
if (s[i] != '4' && s[i] != '7') return false;
}
return true;
}
void calcoeffs() {
for (int i = 0; i <= m; i++) dp[i] = 0;
dp[0] = 1;
dp[1] = ct[0];
for (int i = 1; i < m; i++) {
for (int j = m; j >= 1; j--) {
dp[j] = (dp[j] + dp[j - 1] * ct[i]) % 1000000007;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
init();
for (int i = 0; i < n; i++) cin >> A[i];
int ctr = 0;
map<int, int> df;
for (int i = 0; i < n; i++) {
if (islucky(A[i])) {
df[A[i]]++;
ctr++;
}
}
m = df.size();
int iter = 0;
for (auto i = df.begin(); i != df.end(); i++) {
ct[iter++] = i->second;
}
calcoeffs();
long long ans = 0;
for (int i = 0; i <= min(m, k); i++) {
ans = (ans + comb(n - ctr, k - i) * dp[i]) % 1000000007;
}
cout << ans << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long k, l, r, p;
long long fastPow(long long x, long long y, long long mod) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long pp(long long x) {
if (k % p == 0) return 0;
return fastPow(k, fastPow(2, x, p - 1), p);
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%lld%lld%lld%lld", &k, &l, &r, &p);
long long ans = 0;
if (p == 2) {
ans = k % 2 == 0 ? 1 : 0;
} else {
long long x = pp(l);
if (x == 1)
ans = fastPow(2, k & 1 ? 1 : r - l + 1, p);
else {
long long y = (pp(r + 1) - 1) * fastPow(x - 1, p - 2, p) % p;
if (k & 1) y = y * fastPow(fastPow(2, r - l, p), p - 2, p);
ans = y;
}
}
printf("%lld\n", ans % p);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
int main() {
int a, b, p, c;
scanf("%d %d", &a, &b);
while (b > 0) {
p = a % 10;
if (p == 0)
a = a / 10;
else
a = a - 1;
b = b - 1;
}
printf("%d", a);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int prime[1010];
int p[1010], run;
int a[100];
char seq[1010], ans[1010];
int ind, run1;
int main() {
char s[1010];
cin >> s;
int k = strlen(s);
int maxi = 0;
char ch;
for (int i = 2; i <= 1000; i++)
for (int j = 2; j < i; j++)
if (i % j == 0) prime[i] = 1;
prime[1] = 1;
for (int i = 2; i <= 1000; i++)
if (prime[i] == 0) p[run++] = i;
;
for (int i = 0; i < k; i++) a[(int)(s[i] - 'a')]++;
for (int i = 0; i < 26; i++)
if (maxi < a[i]) {
maxi = a[i];
ch = 'a' + i;
}
for (int i = 0; i < maxi; i++) seq[run1++] = ch;
for (int i = 0; i < k; i++)
if (s[i] != ch) {
seq[run1++] = s[i];
}
int cc = 1;
for (int i = 0; i < run && p[i] <= k; i++) {
if (p[i] * 2 > k) cc++;
}
cc = k - cc;
run1 = 0;
if (maxi >= cc) {
cout << "YES\n";
for (int i = 0; i < k; i++) {
if (i != 0 && (prime[i + 1] == 1 || 2 * i + 2 <= k)) {
ans[i] = seq[run1++];
}
}
for (int i = 0; i < k; i++) {
if (ans[i] == '\0') {
ans[i] = seq[run1++];
}
}
cout << ans << endl;
} else
cout << "NO\n";
scanf(" ");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int X[280];
bool vis[280];
int main() {
int n, k;
cin >> n >> k;
int temp;
memset(X, -1, sizeof(X));
for (int i = 0; i < n; i++) {
cin >> temp;
if (X[temp] == -1) {
int a = temp;
while (vis[a - 1] == false && a >= temp - k + 2 && a >= 1) a--;
X[a] = a;
for (int i = a + 1; i < a + k && X[i] != i; i++) {
X[i] = a;
}
}
vis[temp] = true;
cout << X[temp] << ' ';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int T12 = 531441;
int conv[T12 + 10];
int amt[1 << 12];
int w, n, m;
int count(int cur, int k, const string& s) {
if (k == w) {
return conv[cur];
}
if (s[k] == 'A') {
return count(cur * 3, k + 1, s) + count(cur * 3 + 1, k + 1, s);
} else if (s[k] == 'O') {
return count(cur * 3, k + 1, s);
} else if (s[k] == 'X') {
return count(cur * 3, k + 1, s) + count(cur * 3 + 2, k + 1, s);
} else if (s[k] == 'a') {
return count(cur * 3 + 2, k + 1, s);
} else if (s[k] == 'o') {
return count(cur * 3 + 1, k + 1, s) + count(cur * 3 + 2, k + 1, s);
} else if (s[k] == 'x') {
return count(cur * 3 + 1, k + 1, s);
}
assert(false);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> w >> n >> m;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
++amt[a];
}
for (int i = 0; i < (1 << w); ++i) {
for (int j = 0; j < (1 << w); ++j) {
int cur = 0;
for (int k = w - 1; k >= 0; k--) {
int x = ((i >> k) & 1) + ((j >> k) & 1);
cur = cur * 3 + x;
}
conv[cur] += amt[i] * amt[j];
}
}
for (int i = 0; i < m; ++i) {
string s;
cin >> s;
cout << count(0, 0, s) << "\n";
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long dp[2][20001];
int main() {
int x;
while (cin >> n) {
long long ans = 0LL;
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
cin >> x;
ans += dp[i & 1][x];
ans %= (int)(1e9 + 7);
int act = (i & 1) ^ 1;
for (int j = 0; j < 20001; j++) dp[act][j] = 0;
dp[act][0] = 1;
for (int j = 0; j < 20001 / 2; j++) {
dp[act][j + x] += dp[i & 1][j];
dp[act][j + x] %= (int)(1e9 + 7);
dp[act][abs(j - x)] += dp[i & 1][j];
dp[act][abs(j - x)] %= (int)(1e9 + 7);
}
}
cout << ans << "\n";
}
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long x[100005], c[100005];
priority_queue<long long, vector<long long>, greater<long long> > q;
int main() {
int n;
long long k, a;
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%lld", &x[i]);
cin >> a;
for (int i = 1; i <= n; i++) scanf("%lld", &c[i]);
long long ans = 0;
for (int i = 1; i <= n; i++) {
q.push(c[i]);
if (x[i] <= k) continue;
long long b = x[i] - k;
int cnt = ((b + a - 1) / a);
if (cnt > q.size()) {
cout << -1 << endl;
return 0;
}
k += cnt * a;
while (cnt--) {
ans += q.top();
q.pop();
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long int mod = 1e9 + 7;
using namespace std;
const int N = 3005;
int ans[N][N];
string second[N];
void solve1() {
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i < n + 1; i++) {
cin >> second[i];
second[i] = '0' + second[i];
}
ans[1][2] = 1;
long long int p1, p2, p3, p4;
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 1; j < m + 1; j++) {
if (second[i][j] == '#') ans[i][j] = 0;
ans[i][j] %= mod;
ans[i + 1][j] += ans[i][j];
ans[i][j + 1] += ans[i][j];
}
}
p1 = ans[n - 1][m], p3 = ans[n][m - 1];
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 1; j < m + 1; j++) ans[i][j] = 0;
}
ans[2][1] = 1;
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 1; j < m + 1; j++) {
if (second[i][j] == '#') ans[i][j] = 0;
ans[i][j] %= mod;
ans[i + 1][j] += ans[i][j];
ans[i][j + 1] += ans[i][j];
}
}
p2 = ans[n][m - 1], p4 = ans[n - 1][m];
cout << ((p1 * p2) % mod - (p3 * p4) % mod + mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int t = 1;
while (t--) {
solve1();
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll arr[101010];
ll m, n;
ll k = 1;
ll sum = 0;
ll fr[101010];
int main() {
scanf("%lld%lld", &m, &n);
for (ll i = 0; i < n; i++) {
scanf("%lld", arr + i);
if (i + arr[i] > m) {
puts("-1");
return 0;
}
sum += arr[i];
}
if (sum < m) {
puts("-1");
return 0;
}
for (ll i = 0; i < n; i++) fr[i] = i + 1;
fr[n] = m + 1;
for (ll i = n - 1; i >= 0; i--) fr[i] = max(fr[i], fr[i + 1] - arr[i]);
for (ll i = 0; i < n; i++) printf("%lld ", fr[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long first) {
if (!first) return 0;
long long res = 0, i;
for (i = 1; i <= first && i <= 1000000000000000000LL; res += i, i *= 10)
if (first == i) return res + 1;
if (first < 10) return 1;
if (first - i / 10 >= i / 10) return f(i) - 1;
return (first - i / 10) + f(i / 10);
}
int main(int argc, char **argv) {
int N;
cin >> N;
vector<pair<long long, long long> > A(N);
for (int i = (0); i < (N); ++i) cin >> A[i].first >> A[i].second;
long long V[N];
for (int i = (0); i < (N); ++i) V[i] = f(A[i].second) - f(A[i].first - 1);
double DP[N][N + 1];
memset(DP, 0, sizeof(DP));
DP[0][1] = 1. * V[0] / (A[0].second - A[0].first + 1);
DP[0][0] = 1. - DP[0][1];
for (int i = (1); i < (N); ++i)
for (int j = (0); j < (N + 1); ++j)
DP[i][j] +=
DP[i - 1][j] * (1. - 1. * V[i] / (A[i].second - A[i].first + 1)),
DP[i][j + 1] +=
DP[i - 1][j] * (1. * V[i] / (A[i].second - A[i].first + 1));
int K;
cin >> K;
int P = K * N / 100 + ((K * N) % 100 != 0);
double res = 0;
for (int i = (P); i < (N + 1); ++i) res += DP[N - 1][i];
printf("%.15f\n", res);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int nums[12][100010];
set<int> follow[100010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> nums[i][j];
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
follow[nums[i][j]].insert(nums[i][j + 1]);
}
}
long long ans = 0LL;
long long grp = 0;
for (int i = 0; i < n; i++) {
int cur = nums[0][i];
grp += 1LL;
if (follow[cur].size() == 1) {
continue;
} else {
ans += (grp) * (grp + 1) / 2LL;
grp = 0LL;
}
}
ans += (grp) * (grp + 1) / 2LL;
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int k, n;
char s[1000006];
pair<pair<bool, bool>, pair<bool, bool> > dfs() {
switch (s[k]) {
case '1':
return make_pair(make_pair(0, 0), make_pair(0, 1));
case '0':
return make_pair(make_pair(1, 0), make_pair(0, 0));
case '?':
return make_pair(make_pair(0, 1), make_pair(1, 0));
}
k++;
pair<pair<bool, bool>, pair<bool, bool> > f1 = dfs();
k++;
char ch = s[k];
k++;
pair<pair<bool, bool>, pair<bool, bool> > f2 = dfs();
k++;
switch (ch) {
case '|':
return make_pair(make_pair(f1.first.first && f2.first.first,
f1.first.first && f2.first.second ||
f1.first.second && f2.first.second ||
f1.first.second && f2.first.first),
make_pair(f1.first.first && f2.second.first ||
f1.second.first && f2.second.first ||
f1.second.first && f2.first.first,
f1.first.second && f2.second.first ||
f1.second.first && f2.first.second ||
f2.second.second || f1.second.second));
case '&':
return make_pair(make_pair(f1.first.first || f2.first.first ||
f1.first.second && f2.second.first ||
f1.second.first && f2.first.second,
f1.second.first && f2.second.first ||
f1.second.first && f2.second.second ||
f1.second.second && f2.second.first),
make_pair(f1.first.second && f2.first.second ||
f1.first.second && f2.second.second ||
f1.second.second && f2.first.second,
f1.second.second && f2.second.second));
case '^':
return make_pair(make_pair(f1.first.first && f2.first.first ||
f1.first.second && f2.first.second ||
f1.second.first && f2.second.first ||
f1.second.second && f2.second.second,
f1.first.first && f2.second.first ||
f1.first.second && f2.second.second ||
f1.second.first && f2.first.first ||
f1.second.second && f2.first.second),
make_pair(f1.first.first && f2.first.second ||
f1.first.second && f2.first.first ||
f1.second.first && f2.second.second ||
f1.second.second && f2.second.first,
f1.first.first && f2.second.second ||
f1.first.second && f2.second.first ||
f1.second.first && f2.first.second ||
f1.second.second && f2.first.first));
}
}
int main() {
scanf("%d", &n);
scanf("%s", s);
pair<pair<bool, bool>, pair<bool, bool> > ans = dfs();
if (ans.first.second || ans.second.first)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 18 |
#include <bits/stdc++.h>
#pragma gcc optimize("ofast")
using namespace std;
long long modexp(long long a, long long b, long long m) {
long long r = 1;
a = a % m;
while (b > 0) {
if (b & 1) r = (r * a) % m;
b = b / 2;
a = (a * a) % m;
}
return r % m;
}
const int MAXN = 100002;
long long a[MAXN];
vector<long long> adj[100001];
long long res = 0;
map<long long, long long> m[MAXN];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void dfs(long long u, long long pa) {
for (auto i : m[pa]) {
long long tmpgcd = gcd(a[u], i.first);
m[u][tmpgcd] += i.second;
res =
(res + ((tmpgcd % 1000000007) * (i.second % 1000000007)) % 1000000007) %
1000000007;
}
m[u][a[u]]++;
res = (res + a[u]) % 1000000007;
for (auto i : adj[u]) {
if (i != pa) dfs(i, u);
}
}
int main() {
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
cout << res << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-10;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
template <class T>
inline T sq(T a) {
return a * a;
}
const int MAX_N = 1000010;
int n, m;
int a[MAX_N], b[MAX_N], c[MAX_N];
int ans = 0;
int main() {
scanf("%d %d", &n, &m);
for (long long int i = (0); i < (long long int)(n); i++) {
scanf("%d", &a[i]);
for (long long int j = (0); j < (long long int)(31); j++)
if (a[i] & (1LL << (j))) c[j]++;
}
for (long long int i = (0); i < (long long int)(m); i++) scanf("%d", &b[i]);
sort(b, b + m);
for (long long int i = (0); i < (long long int)(m); i++) {
for (long long int j = (b[i]); j < (long long int)(31); j++)
if (c[j]) {
c[j]--;
for (long long int k = (b[i]); k < (long long int)(j); k++) c[k]++;
ans++;
break;
}
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int const N = 5000000;
int n, m;
long long v[N], vv[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld", v + i);
scanf("%d", &m);
for (int i = 0; i < m; ++i) scanf("%lld", vv + i);
int an = 0;
int i = 0, j = 0;
long long sm0 = v[0], sm1 = vv[0];
int lsti = i, lstj = j;
while (i < n || j < m) {
if (i == lsti && j == lstj && lsti && lstj) break;
if (sm0 == sm1) {
++i, ++j, ++an;
sm0 = sm1 = 0;
sm0 = (long long)v[i], sm1 = (long long)vv[j];
continue;
}
if (sm0 < sm1) {
++i;
sm0 = (long long)(sm0 + v[i]);
continue;
}
if (sm1 < sm0) {
++j;
sm1 = (long long)(sm1 + vv[j]);
continue;
}
}
if (i != n || j != m) an = -1;
printf("%d\n", an);
}
| 8 |
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
using vll = std::vector<ll>;
using pll = std::pair<ll, ll>;
template <typename T>
int sign(const T& t) {
return (t > 0) - (t < 0);
}
template <typename T, typename U>
bool remax(T& a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T, typename U>
bool remin(T& a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
T gcd(T a, T b) {
a = std::abs(a);
b = std::abs(b);
while (b) {
a %= b;
std::swap(a, b);
}
return a;
}
template <typename T>
T lcm(T a, T b) {
a = std::abs(a);
b = std::abs(b);
return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
uint32_t mrand_32t() {
static std::random_device rd;
static std::mt19937 rng(rd());
return rng();
}
uint64_t mrand_64t() {
static std::random_device rd;
static std::mt19937_64 rng(rd());
return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
std::sort(std::begin(v), std::end(v));
v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
namespace std {
template <typename A, typename B>
string to_string(const pair<A, B>& p) {
string str;
str += "(";
str += to_string(p.first);
str += ", ";
str += to_string(p.second);
str += ")";
return str;
}
string to_string(bool value) { return value ? "true" : "false"; }
template <typename T>
string to_string(const vector<T>& vec) {
string str = "{ ";
bool first = true;
for (const auto& it : vec) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename T>
string to_string(const set<T>& s) {
string str = "{ ";
bool first = true;
for (const auto& it : s) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename K, typename V>
string to_string(const map<K, V>& m) {
string str = "{ ";
bool first = true;
for (const auto& it : m) {
if (!first) {
str += ", ";
}
first = false;
str += to_string(it.first);
str += " -> ";
str += to_string(it.second);
}
str += " }";
return str;
}
string to_string(const string& s) { return "\"" + s + "\""; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(char ch) { return "\'" + string(1, ch) + "\'"; }
template <size_t N>
string to_string(const bitset<N>& b) {
string res(N, '0');
for (size_t i = 0; i < N; ++i) {
res[i] = '0' + b[i];
}
return res;
}
template <typename T>
string to_string(const T& t) {
std::stringstream ss;
ss << t;
return ss.str();
}
} // namespace std
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
std::cerr << " " << std::to_string(H);
debug_out(T...);
}
using namespace std;
struct task {
int a;
int p;
bool read() {
if (!(cin >> a >> p)) {
return 0;
}
return 1;
}
bool operator<(const task& t) const { return a < t.a; }
};
int n;
double C, T;
vector<task> ts;
bool read() {
if (!(cin >> n)) {
return 0;
}
cin >> C >> T;
ts.resize(n);
for (int i = int(0); i < int(n); ++i) {
assert(ts[i].read());
}
return 1;
}
int solve() {
sort(begin(ts), end(ts));
assert(int((ts).size()) == n);
static const int MAXN = 100 + 5;
static const int MAXP = 10;
static const int MAXSUM = MAXN * MAXP;
static const double INF = 1e20;
static double dp[MAXN][MAXN][MAXSUM];
for (int i = int(0); i < int(n + 1); ++i) {
for (int was = int(0); was < int(i + 1); ++was) {
for (int sum = int(0); sum < int(was * MAXP + 1); ++sum) {
dp[i][was][sum] = INF;
}
}
}
dp[0][0][0] = 0;
static const double EPS = 1e-9;
const auto check = [&](double t, double dp_val, int was) -> bool {
if (t < -EPS || t > T + EPS) {
return 0;
}
remax(t, 0);
remin(t, T);
double s = 1 + C * t;
double spend = t + (1 / s) * dp_val + 10 * was;
;
if (spend <= T + EPS) {
return 1;
}
return 0;
};
int ans = 0;
for (int i = int(0); i < int(n + 1); ++i) {
for (int was = int(0); was < int(i + 1); ++was) {
for (int sum = int(0); sum < int(was * MAXP + 1); ++sum) {
const auto cur_dp = dp[i][was][sum];
if (cur_dp > INF / 2) {
continue;
}
{
double a = C;
double b = 1 + 10 * was * C - C * T;
double c = cur_dp + 10 * was - T;
double t0 = -b / (2 * a);
if (check(0, cur_dp, was) || check(t0, cur_dp, was)) {
remax(ans, sum);
}
}
if (i == n) {
continue;
}
remin(dp[i + 1][was][sum], cur_dp);
remin(dp[i + 1][was + 1][sum + ts[i].p], (cur_dp + ts[i].a) / 0.9);
}
}
}
return ans;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cout.precision(12);
cout << fixed;
int tc;
cin >> tc;
for (int it = int(0); it < int(tc); ++it) {
assert(read());
auto ans = solve();
cout << ans << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 1e15;
const int inf = 2e9 + 100;
const int nmax = 5e5 + 5;
int n;
vector<long long> by, sy;
vector<long long> by2, sy2;
bool hobe(vector<pair<long long, long long> >& v, long double d) {
int j = 0;
for (int i = 0; i < n; i++) {
while (j < n - 1 and v[j + 1].first < v[i].first + d) j++;
long long boroy = -infl, sodoy = infl;
if (i - 1 >= 0) {
boroy = max(boroy, by[i - 1]);
sodoy = min(sodoy, sy[i - 1]);
}
if (j + 1 < n) {
boroy = max(boroy, by2[j + 1]);
sodoy = min(sodoy, sy2[j + 1]);
}
if (boroy - sodoy < d) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<pair<long long, long long> > pnt(n);
long long borox = -infl, sodox = infl, boroy = -infl, sodoy = infl;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
long long x1 = x - y, y1 = x + y;
pnt[i] = {x1, y1};
borox = max(x1, borox), sodox = min(sodox, x1);
boroy = max(y1, boroy), sodoy = min(sodoy, y1);
}
long double lo = 0.0, hi = 1.0 * max(borox - sodox, boroy - sodoy);
sort(pnt.begin(), pnt.end());
by.reserve(n), by2.reserve(n), sy.reserve(n), sy2.reserve(n);
by[0] = pnt[0].second;
sy[0] = by[0];
for (int i = 1; i < n; i++) {
by[i] = max(by[i - 1], pnt[i].second);
sy[i] = min(sy[i - 1], pnt[i].second);
}
by2[n - 1] = pnt[n - 1].second;
sy2[n - 1] = by2[n - 1];
for (int i = n - 2; i >= 0; i--) {
by2[i] = max(by2[i + 1], pnt[i].second);
sy2[i] = min(sy2[i + 1], pnt[i].second);
}
while (hi - lo > 1e-8) {
long double mid = (hi + lo) / 2.0;
if (hobe(pnt, mid))
hi = mid;
else
lo = mid;
}
cout << fixed << setprecision(12) << hi / 2.0 << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, m, v;
cin >> a >> b >> c >> d;
m = max((3 * a) / 10, a - (a * c) / 250);
v = max((3 * b) / 10, b - (b * d) / 250);
if (m > v)
cout << "Misha" << endl;
else if (v > m)
cout << "Vasya" << endl;
else
cout << "Tie" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6, mod = 1e9 + 7;
int read() {
int a = 0;
bool opt = 0;
char c = getchar();
while (c < '0' || c > '9') opt |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
a = (a << 3) + (a << 1) + (c ^ 48), c = getchar();
return opt ? -a : a;
}
int Mod(int x) { return x < mod ? x : x - mod; }
void Add(int& x, int y) { x = Mod(x + y); }
int n, ans, s, a[20], f[1 << 20], size[1 << 20], inv[2000005];
int solve(int A, int B) {
int ans = 1;
for (int i = 1; i <= n; ++i) {
if (A & (1 << i - 1)) {
for (int j = 1; j <= n; ++j) {
if (B & (1 << j - 1)) {
ans = 1ll * ans * a[i] % mod * inv[a[i] + a[j]] % mod;
}
}
}
}
return ans;
}
int main() {
inv[1] = 1;
for (int i = 2; i <= N; ++i)
inv[i] = mod - 1ll * (mod / i) * inv[mod % i] % mod;
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
f[0] = 1;
s = (1 << n) - 1;
for (int i = 1; i < (1 << n); ++i) {
f[i] = 1;
size[i] = size[i >> 1] + (i & 1);
for (int j = (i - 1) & i; j; j = (j - 1) & i) {
Add(f[i], mod - 1ll * f[j] * solve(j, i - j) % mod);
}
Add(ans, 1ll * f[i] * size[i] % mod * solve(i, s - i) % mod);
}
cout << ans << "\n";
return 0;
}
| 17 |
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f, mod = 1e9 + 7;
using namespace std;
int dx[]{1, -1, 0, 0, 1, 1, -1, -1};
int dy[]{0, 0, 1, -1, 1, -1, 1, -1};
void K_K() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool valid(int x, int y) { return x > 0 && y > 0 && x < 9 && y < 9; }
int main() {
K_K();
int r1, c1, r2, c2, ans[3] = {0};
cin >> r1 >> c1 >> r2 >> c2;
if (r1 != r2) ans[0]++;
if (c1 != c2) ans[0]++;
int x = r1 + c1, y = r2 + c2;
if ((!(x & 1)) && (y & 1))
ans[1] = 0;
else if ((!(y & 1)) && (x & 1))
ans[1] = 0;
else {
bool flag = 0;
for (int i = 4; i < 8; i++) {
int x = r1 + dx[i], y = c1 + dy[i];
while (valid(x, y)) {
if (x == r2 && y == c2) {
flag = 1;
i = 8;
break;
}
x += dx[i];
y += dy[i];
}
}
if (flag)
ans[1] = 1;
else
ans[1] = 2;
}
x = r1, y = c1;
while (x != r2 || y != c2) {
if (x > r2)
x--;
else if (x < r2)
x++;
if (y > c2)
y--;
else if (y < c2)
y++;
ans[2]++;
}
for (int i = 0; i < 3; i++) cout << ans[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a, s;
scanf("%d", &a);
s = sqrt(a);
while (a % s != 0) s--;
printf("%d %d\n", s, a / s);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int T, n, flag[8], dis[100010][8], op, cl, d[100010], x, c, D[8][8], bin[10],
s[100010], cnt[8][256], mx, mn, s1;
long long sum;
char S[100010];
vector<int> son[8];
int main() {
bin[0] = 1;
for (int i = 1; i <= 9; i++) bin[i] = bin[i - 1] << 1;
scanf("%d%s", &n, S + 1);
for (int i = 0; i <= 7; i++) son[i].clear();
for (int i = 1; i <= n; i++) son[S[i] - 'a'].push_back(i);
for (int i = 0; i <= 7; i++) {
op = cl = 0;
for (int j = 1; j <= n; j++) dis[j][i] = 1000000000;
memset(flag, 0, sizeof(flag));
for (int j = 0; j < son[i].size(); j++) {
x = son[i][j];
d[++cl] = x;
dis[x][i] = 0;
}
flag[i] = 1;
while (op < cl) {
op++;
x = d[op];
c = S[x] - 'a';
if (!flag[c]) {
flag[c] = 1;
for (int j = 0; j < son[c].size(); j++)
if (dis[son[c][j]][i] > dis[x][i] + 1) {
dis[son[c][j]][i] = dis[x][i] + 1;
d[++cl] = son[c][j];
}
}
if (x > 1 && dis[x - 1][i] > dis[x][i] + 1) {
dis[x - 1][i] = dis[x][i] + 1;
d[++cl] = x - 1;
}
if (x < n && dis[x + 1][i] > dis[x][i] + 1) {
dis[x + 1][i] = dis[x][i] + 1;
d[++cl] = x + 1;
}
}
}
for (int i = 0; i <= 7; i++) {
for (int j = 0; j <= 7; j++) D[j][i] = 1000000000;
for (int j = 1; j <= n; j++)
D[S[j] - 'a'][i] = min(D[S[j] - 'a'][i], dis[j][i]);
}
for (int i = 1; i <= n; i++) {
s[i] = 0;
c = S[i] - 'a';
for (int j = 0; j <= 7; j++)
if (dis[i][j] == D[c][j] + 1) s[i] += bin[j];
}
mx = sum = 0;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) {
for (int j = max(1, i - 15); j < i; j++) {
mn = i - j;
for (int k = 0; k <= 7; k++) mn = min(mn, dis[i][k] + 1 + dis[j][k]);
if (mx == mn)
sum++;
else if (mx < mn) {
mx = mn;
sum = 1;
}
}
x = i - 16;
if (x <= 0) continue;
c = S[x] - 'a';
for (int k = s[x]; k >= 0; k = (k - 1) & s[x]) {
cnt[c][k]++;
if (!k) break;
}
for (int j = 0; j <= 7; j++) {
mn = 1000000000;
s1 = 0;
for (int k = 0; k <= 7; k++) {
x = dis[i][k] + 1 + D[j][k];
if (mn > x) {
mn = x;
s1 = bin[k];
} else if (mn == x)
s1 += bin[k];
}
if (mn == 1000000000) continue;
if (cnt[j][s1]) {
mn++;
x = cnt[j][s1];
} else
x = cnt[j][0];
if (mx == mn)
sum += x;
else if (mx < mn) {
mx = mn;
sum = x;
}
}
}
printf("%d %lld\n", mx, sum);
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 1912;
int n;
int a[maxn];
int main() {
std ::ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
for (int i = (1); i <= (n); i++) {
while (a[i] % 2 == 0) a[i] /= 2;
while (a[i] % 3 == 0) a[i] /= 3;
}
int tmp = a[1];
for (int i = (1); i <= (n); i++)
if (a[i] != tmp) {
puts("NO");
return 0;
}
puts("YES");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
int flag = 1;
int x;
long long sum = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
sum += x;
if (x == 0) {
if (sum & 1) {
flag = 0;
}
sum = 0;
}
}
if (sum & 1) {
flag = 0;
}
if (flag) {
printf("YES\n");
} else {
puts("NO");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long A, B, Y, G, Bl, a, b, c, d, ans = 0;
cin >> A >> B;
cin >> Y >> G >> Bl;
a = (Y * 2) + G;
b = G + 3 * Bl;
c = a - A;
d = b - B;
if (c > 0) ans = ans + c;
if (d > 0) ans = ans + d;
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int n, p;
long long int curent, ans[N];
priority_queue<pair<int, int> > q1;
queue<int> q;
priority_queue<int> q2;
int main() {
cin >> n >> p;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
q1.push(make_pair(-x, -i));
}
for (int i = 1; i <= n; ++i) {
if (q.empty()) {
curent = -q1.top().first;
}
curent += p;
while (q1.size() && -q1.top().first <= curent) {
if (q.empty() || q.back() > -q1.top().second) {
q.push(-q1.top().second);
} else {
q2.push(q1.top().second);
}
q1.pop();
}
ans[q.front()] = curent;
q.pop();
if (q2.size() && q.empty()) {
q.push(-q2.top()), q2.pop();
}
}
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long dif = abs(a - b);
if (a == b) {
cout << "0\n";
continue;
}
int ans = dif / 5;
dif = dif % 5;
int tm = dif / 2;
ans += tm;
dif %= 2;
ans += dif;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[2][60][60], q[60][60][60][60];
int ask(int a, int b, int c, int d) {
if (q[a][b][c][d] != -1) return q[a][b][c][d];
cout << "? " << a << " " << b << " " << c << " " << d << endl;
cout.flush();
int x;
cin >> x;
if (x == -1) exit(0);
x = 1 ^ x;
q[a][b][c][d] = x;
return x;
}
void print(int v) {
cout << "!\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << dp[v][i][j];
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(q, -1, sizeof(q));
cin >> n;
for (int p = 0; p < 2; p++) {
memset(dp[p], -1, sizeof(dp[p]));
dp[p][1][1] = 1;
dp[p][n][n] = 0;
dp[p][1][2] = p;
dp[p][2][3] = dp[p][1][2] ^ ask(1, 2, 2, 3);
dp[p][3][2] = dp[p][1][2] ^ ask(1, 2, 3, 2);
dp[p][2][1] = dp[p][3][2] ^ ask(2, 1, 3, 2);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dp[p][i][j] == -1) {
if (i > 2)
dp[p][i][j] = dp[p][i - 2][j] ^ ask(i - 2, j, i, j);
else if (j > 2)
dp[p][i][j] = dp[p][i][j - 2] ^ ask(i, j - 2, i, j);
else
dp[p][i][j] = dp[p][i - 1][j - 1] ^ ask(i - 1, j - 1, i, j);
}
}
}
}
for (int p = 0; p < 2; p++) {
for (int i = 3; i <= n; i++) {
for (int j = 2; j <= n; j++) {
if (dp[p][i - 2][j - 1] == dp[p][i][j]) {
if (dp[p][i - 1][j - 1] == dp[p][i][j - 1] ||
dp[p][i - 2][j] == dp[p][i - 1][j]) {
if (ask(i - 2, j - 1, i, j))
print(1 ^ p);
else
print(p);
return 0;
}
}
}
}
for (int i = 2; i <= n; i++) {
for (int j = 3; j <= n; j++) {
if (dp[p][i - 1][j - 2] == dp[p][i][j]) {
if (dp[p][i - 1][j - 1] == dp[p][i - 1][j] ||
dp[p][i][j - 2] == dp[p][i][j - 1]) {
if (ask(i - 1, j - 2, i, j))
print(1 ^ p);
else
print(p);
return 0;
}
}
}
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int c = 1000005;
int n, m, mm, sum, t, tt, csop[c];
vector<pair<int, int> > sz;
vector<int> ans[c];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
sz.push_back({x, i});
sum += x;
}
while (sum % n) {
sz[0].first++;
sum++;
}
t = sum / n, tt = t, mm = m;
for (int i = 1; i <= t; i++) {
ans[i].resize(m + 1);
}
while (true) {
sort(sz.rbegin(), sz.rend());
while (t + 1 < m) {
if (sz.size() == 0 || sz[0].first > n) {
break;
}
csop[m] = sz[m - 1].first;
for (int i = 1; i <= t; i++) {
ans[i][m] = sz[m - i].second;
sz[m - i].first -= csop[m];
}
n -= csop[m];
sz.pop_back();
m--;
}
if (n == 0 || sz.size() == 0 || sz[0].first < n) {
break;
}
for (int i = 0; i < m; i++) {
while (sz[i].first >= n) {
sz[i].first -= n;
for (int j = 1; j <= m; j++) {
ans[t][j] = sz[i].second;
}
t--;
}
}
}
if (t == 0) {
csop[1] = n;
}
for (int i = 1; i <= m; i++) {
csop[i] = n - sz[i - 1].first;
int pos = 0;
for (int j = 1; j <= m; j++) {
if (i != j) {
pos++;
ans[pos][i] = sz[j - 1].second;
}
}
}
cout << tt << "\n";
for (int i = 1; i <= mm; i++) {
cout << csop[i] << " ";
}
cout << "\n";
for (int i = 1; i <= tt; i++) {
for (int j = 1; j <= mm; j++) {
cout << ans[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 10007;
const long long LINF = 2e16;
const int INF = 2e9;
const int magic = 348;
const double eps = 1e-10;
const double pi = 3.14159265;
inline int getint() {
char ch;
int res;
bool f;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return f ? res : -res;
}
char s[50048];
int len;
char tmp[50048];
int pt, tot;
const long long p1 = 998244353, p2 = 19260817;
const long long m1 = 1e9 + 7, m2 = 1e9 + 9;
long long pw1[50048], pw2[50048], hsh1[50048], hsh2[50048];
inline long long mod1(long long first) {
while (first >= m1) first -= m1;
while (first < 0) first += m1;
return first;
}
inline long long mod2(long long first) {
while (first >= m2) first -= m2;
while (first < 0) first += m2;
return first;
}
inline long long gethash1(int left, int right) {
return hsh1[right] - hsh1[left - 1] * pw1[right - left + 1];
}
inline long long gethash2(int left, int right) {
return mod2(hsh2[right] - (hsh2[left - 1] * pw2[right - left + 1]) % m2);
}
inline void init_pw() {
pw1[0] = pw2[0] = 1;
for (register int i = 1; i <= len; i++)
pw1[i] = pw1[i - 1] * p1, pw2[i] = pw2[i - 1] * p2;
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
int i, curlen;
init_pw();
for (curlen = 2; curlen <= len; curlen += 2) {
pt = 1;
tot = curlen / 2;
hsh1[0] = hsh2[0] = 0;
int sl = 0;
for (i = 1; i <= curlen / 2; i++) tmp[i] = s[i];
for (i = curlen / 2 + 1; i <= len; i++) {
tmp[++tot] = s[i];
if (tmp[tot] == tmp[tot - curlen / 2])
sl++;
else
sl = 0;
if (sl == curlen / 2) tot -= curlen / 2, sl = 0;
}
for (i = curlen / 2 + 1; i <= tot; i++) s[i] = tmp[i];
len = tot;
}
for (i = 1; i <= len; i++) printf("%c", s[i]);
puts("");
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 3100;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 500;
long long e[maxn][maxn];
long long ee[maxn][maxn];
char jad[maxn][maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j <= m; j++) {
jad[i][j] = s[j - 1];
}
}
e[1][2] = 1;
ee[2][1] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
e[i][j] += e[i - 1][j] + e[i][j - 1];
ee[i][j] += ee[i - 1][j] + ee[i][j - 1];
e[i][j] %= mod;
ee[i][j] %= mod;
if (jad[i][j] == '#') {
e[i][j] = 0;
ee[i][j] = 0;
}
}
}
cout << (((e[n - 1][m] * ee[n][m - 1]) % mod) -
((e[n][m - 1] * ee[n - 1][m]) % mod) + mod) %
mod;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, allsum = 0, ksum = 0;
cin >> n;
vector<int> a(n);
vector<int> ans;
cin >> a[0];
ksum += a[0];
ans.push_back(0);
for (int i = 1; i < n; i++) {
cin >> a[i];
if (a[0] >= 2 * a[i]) {
ksum += a[i];
ans.push_back(i);
} else {
allsum += a[i];
}
}
if (ksum > allsum) {
cout << ans.size() << endl;
for (auto x : ans) cout << x + 1 << " ";
} else
cout << 0;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010, mod = 1000000007;
int n, m, T, q, ans = N * N, a[N][N], s[N][N];
char st[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", st + 1);
for (int j = 1; j <= m; j++) a[i][j] = st[j] - '0';
}
q = max(n, m);
for (int i = 1; i <= q * 2; i++) {
for (int j = 1; j <= q * 2; j++)
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
}
for (int k = 2; k <= q; k++) {
int res = 0;
for (int i = 0; i < n; i += k) {
for (int j = 0; j < m; j += k) {
int z = s[i + k][j + k] - s[i][j + k] - s[i + k][j] + s[i][j];
res += min(z, k * k - z);
}
}
ans = min(ans, res);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
vector<string> c;
for (int i = 0; i < m; i++) {
string s;
cin >> s;
c.push_back(s);
}
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
if (c[i][j] == 'S') {
if (i + 1 < m && c[i + 1][j] == 'W') {
cout << "NO";
return 0;
}
if (i - 1 >= 0 && c[i - 1][j] == 'W') {
cout << "NO";
return 0;
}
if (j + 1 < n && c[i][j + 1] == 'W') {
cout << "NO";
return 0;
}
if (j - 1 >= 0 && c[i][j - 1] == 'W') {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (c[i][j] == '.')
cout << "D";
else
cout << c[i][j];
}
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = (1 << 20) + 1;
const long long INF = 1e9 + 1;
pair<int, int> gas[N];
long long dp[N];
int x[N], p[N];
struct Event {
int x;
int cost;
int num;
int typ;
};
bool cmp(const Event& a, const Event& b) {
if (a.x != b.x) return a.x < b.x;
if (a.typ != b.typ) return a.typ > b.typ;
return a.cost < b.cost;
}
void solve() {
int d, n, m;
cin >> d >> n >> m;
vector<Event> events = {{0, 0, -1, 0}, {n, 0, -1, 1}};
for (int i = 0; i < m; i++) {
cin >> x[i] >> p[i];
events.push_back({x[i], p[i], i, 0});
events.push_back({x[i] + n, p[i], i, 1});
}
sort(events.begin(), events.end(), cmp);
set<pair<int, int> > s;
vector<pair<long long, long long> > sl;
for (int i = 0; i < events.size(); i++) {
if (events[i].typ == 0) {
s.insert({events[i].cost, events[i].num});
}
if (events[i].typ == 1) {
s.erase({events[i].cost, events[i].num});
}
if (!s.size())
sl.push_back({INF, events[i].x});
else
sl.push_back({s.begin()->first, events[i].x});
if (events[i].x >= d) {
sl.back().second = d;
break;
}
}
if (sl.back().second != d) {
cout << -1;
return;
}
long long ans = 0;
for (int i = 0; i + 1 < sl.size(); i++) {
ans += (sl[i + 1].second - sl[i].second) * sl[i].first;
if (sl[i].first == INF && (sl[i + 1].second - sl[i].second)) {
cout << -1;
return;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> a >> b >> c;
string s[a];
for (long long i = 0; i < a; i++) {
cin >> s[i];
}
long long ct = 0;
for (long long i = 0; i < a; i++)
for (long long j = 0; j < b; j++)
if (s[i][j] == 'R') ct++;
long long val = ct % c;
long long v = 1;
char g[62];
for (long long i = 0; i < 26; i++) g[i] = 'a' + i;
for (long long i = 26; i < 52; i++) g[i] = 'A' + (i - 26);
for (long long i = 52; i < 62; i++) g[i] = '0' + (i - 52);
long long cpo = 0;
long long counter = 0;
char mat[a][b];
for (long long i = 0; i < a; i++) {
if (i % 2 == 0) {
for (long long j = 0; j < b; j++) {
if (s[i][j] == 'R') cpo++;
if (counter + 1 <= val && cpo == (ct / c) + 2) {
cpo = 1;
counter++;
} else if (counter + 1 > val && cpo == (ct / c) + 1) {
counter++;
cpo = 1;
}
mat[i][j] = g[counter];
}
} else {
for (long long j = b - 1; j >= 0; j--) {
if (s[i][j] == 'R') cpo++;
if (counter + 1 <= val && cpo == (ct / c) + 2) {
cpo = 1;
counter++;
} else if (counter + 1 > val && cpo == (ct / c) + 1) {
counter++;
cpo = 1;
}
mat[i][j] = g[counter];
}
}
}
for (long long i = 0; i < a; i++) {
for (long long j = 0; j < b; j++) {
cout << mat[i][j];
}
cout << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
vector<int> c(n);
for (int i = 0; i < n; i++) c[i] = b[i] - i;
vector<pair<int, int>> vs;
for (int i = 0; i < n; i++) vs.push_back({c[i], b[i]});
sort(vs.begin(), vs.end());
int idx = 0;
long long ans = 0;
while (idx < vs.size()) {
int cur = vs[idx].first;
long long curAns = 0;
while (idx < vs.size() && vs[idx].first == cur) {
curAns += vs[idx].second;
idx++;
}
ans = max(ans, curAns);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
template <class T>
int size(T &x) {
return x.size();
}
vector<pair<int, int> > vals;
long double P(int no, int lo, int hi) {
lo = max(lo, vals[no].first);
hi = min(hi, vals[no].second);
if (lo > hi) return 0.0;
return static_cast<long double>(hi - lo + 1) /
(vals[no].second - vals[no].first + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
vals.push_back(pair<int, int>(a, b));
}
long long cnt = 0;
long double res = 0;
for (int winner = 0; winner < n; winner++) {
for (int seconds = 1; seconds < (1 << n); seconds++) {
if (seconds == (1 << winner)) continue;
if (seconds & (1 << winner)) {
bool bad = false;
for (int lower = 0; lower < winner; lower++) {
if (seconds & (1 << lower)) {
bad = true;
break;
}
}
if (bad) {
continue;
}
}
for (int second = 0; second <= 11000; second++) {
long double prob = 1.0;
for (int i = 0; i < n; i++) {
if (seconds & (1 << i)) {
prob *= P(i, second, second);
} else if (i == winner) {
prob *= P(i, second + 1, 11000);
} else {
prob *= P(i, 0, second - 1);
}
}
res += prob * second;
cnt++;
}
}
}
cout << setprecision(12) << fixed << res << endl;
return 0;
}
| 12 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define all(x) (x).begin(), (x).end()
using ll = long long;
int l[200001], r[200001];
ll dp[200001][2];
vector<int> graph[200001];
void dfs(int now, int parent) {
dp[now][0] = dp[now][1] = 0;
for(int child : graph[now]) {
if(child != parent) {
dfs(child, now);
dp[now][0] += max(dp[child][0] + abs(l[now] - l[child]), dp[child][1] + abs(l[now] - r[child]));
dp[now][1] += max(dp[child][1] + abs(r[now] - r[child]), dp[child][0] + abs(r[now] - l[child]));
}
}
}
void solve() {
int n;
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
graph[i].clear();
}
for(int i = 1, a, b; i < n; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
dfs(1, 1);
cout << max(dp[1][0], dp[1][1]) << '\n';
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--)
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 60;
vector<int> dy = {2, 1, 0};
vector<int> dx = {0, 1, 2};
int tabla[maxN][maxN];
int query(int y1, int x1, int y2, int x2) {
int ans;
cout << "? " << y1 + 1 << " " << x1 + 1 << " " << y2 + 1 << " " << x2 + 1
<< endl;
cin >> ans;
return ans;
}
int main() {
int n, y, x, k, invertir = -1, i, j, l;
cin >> n;
tabla[0][0] = 1;
tabla[n - 1][n - 1] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (!(i == n - 1 && j == n - 1)) {
if ((i + j) % 2 == 0) {
for (l = 0; l < dx.size(); l++) {
y = i - dy[l];
x = j - dx[l];
if (y >= 0 && x >= 0) {
k = query(y, x, i, j);
tabla[i][j] = (tabla[y][x] + k + 1) % 2;
break;
}
}
}
}
}
}
tabla[0][1] = 0;
k = query(0, 1, 1, 2);
tabla[1][2] = (tabla[0][1] + k + 1) % 2;
k = query(0, 1, 2, 1);
tabla[2][1] = (tabla[0][1] + k + 1) % 2;
k = query(1, 0, 2, 1);
tabla[1][0] = (tabla[2][1] + k + 1) % 2;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (!(i <= 2 && j <= 2)) {
if ((i + j) % 2 == 1) {
for (l = 0; l < dx.size(); l++) {
y = i - dy[l];
x = j - dx[l];
if (y >= 0 && x >= 0) {
k = query(y, x, i, j);
tabla[i][j] = (tabla[y][x] + k + 1) % 2;
break;
}
}
}
}
}
}
for (l = 0; l < n - 3; l++) {
if (tabla[l][0] == tabla[l + 3][0] && tabla[l + 1][0] == tabla[l + 2][0]) {
k = query(l, 0, l + 3, 0);
if (k == 0)
invertir = 1;
else
invertir = 0;
break;
} else if (tabla[l][0] == ((tabla[l + 3][0] + 1) % 2) &&
((tabla[l + 1][0] + 1) % 2) == tabla[l + 2][0]) {
k = query(l, 0, l + 3, 0);
if (k == 1)
invertir = 1;
else
invertir = 0;
break;
}
}
if (invertir == -1) {
for (l = 0; l < n - 3; l++) {
if (tabla[n - 1][l] == tabla[n - 1][l + 3] &&
tabla[n - 1][l + 1] == tabla[n - 1][l + 2]) {
k = query(n - 1, l, n - 1, l + 3);
if (k == 0)
invertir = 1;
else
invertir = 0;
break;
} else if (tabla[n - 1][l] == ((tabla[n - 1][l + 3] + 1) % 2) &&
((tabla[n - 1][l + 1] + 1) % 2) == tabla[n - 1][l + 2]) {
k = query(n - 1, l, n - 1, l + 3);
if (k == 1)
invertir = 1;
else
invertir = 0;
break;
}
}
}
if (invertir == -1) {
if (tabla[n - 3][0] == tabla[n - 1][1] &&
tabla[n - 2][0] == tabla[n - 1][0]) {
k = query(n - 3, 0, n - 1, 1);
if (k == 0)
invertir = 1;
else
invertir = 0;
} else if (tabla[n - 3][0] == ((tabla[n - 1][1] + 1) % 2) &&
((tabla[n - 2][0] + 1) % 2) == tabla[n - 1][0]) {
k = query(n - 3, 0, n - 1, 1);
if (k == 1)
invertir = 1;
else
invertir = 0;
}
if (invertir == -1) {
if (tabla[n - 2][0] == tabla[n - 1][2] &&
tabla[n - 1][0] == tabla[n - 1][1]) {
k = query(n - 2, 0, n - 1, 2);
if (k == 0)
invertir = 1;
else
invertir = 0;
}
if (tabla[n - 2][0] == ((tabla[n - 1][2] + 1) % 2) &&
((tabla[n - 1][0] + 1) % 2) == tabla[n - 1][1]) {
k = query(n - 2, 0, n - 1, 2);
if (k == 1)
invertir = 1;
else
invertir = 0;
}
}
}
if (invertir == 1) {
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if ((i + j) % 2 == 1) tabla[i][j] = (tabla[i][j] + 1) % 2;
}
}
}
cout << "!" << endl;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cout << tabla[i][j];
}
cout << endl;
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string str, pal;
cin >> str;
vector<int> freq;
freq.push_back(1);
pal = str[0];
for (int i = 1; i < str.size(); i++) {
if (str[i] != str[i - 1]) {
freq.push_back(1);
pal += str[i];
} else
freq[freq.size() - 1]++;
}
str = pal;
reverse(pal.begin(), pal.end());
if (pal == str) {
bool possible = true;
for (int i = 0; i < freq.size() / 2; i++) {
if (freq[i] + freq[freq.size() - 1 - i] < 3) {
possible = false;
break;
}
}
if (possible) {
if (freq[freq.size() / 2] > 1)
cout << freq[freq.size() / 2] + 1 << '\n';
else
cout << 0 << '\n';
} else
cout << 0 << '\n';
} else
cout << 0 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int buf[500];
int main(void) {
memset(buf, -1, sizeof buf);
cin >> n >> m;
int ct = 0;
for (int i = 0; i < (m); ++i) {
int a;
cin >> a;
while (a--) {
int b;
cin >> b;
--b;
buf[b] = ct++;
}
}
vector<pair<int, int> > ans;
for (int i = 0; i < (n); ++i) {
int fr = find(buf, buf + n, -1) - buf;
int at = find(buf, buf + n, i) - buf;
if (at == i || at == n) continue;
if (buf[i] != -1) {
ans.push_back(make_pair(i, fr));
swap(buf[i], buf[fr]);
}
ans.push_back(make_pair(at, i));
swap(buf[at], buf[i]);
}
cout << ans.size() << endl;
for (auto it = (ans).begin(); it != (ans).end(); ++it)
cout << it->first + 1 << ' ' << it->second + 1 << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long int modulo = 998244353;
void add(int &a, long long int b) { a = (a + b) % modulo; }
int n;
int v[105];
int d2c1[10], d2c2[10];
int d1, d2;
int memcompute[105][10][10][3][3][8][8][2][2];
int comcompute[105][10][10][3][3][8][8][2][2];
int getnextg(int pos, int D, int g) {
if (D > v[pos] or (D == v[pos] and g == 2)) return 2;
if (D == v[pos] and g == 1) return 1;
return 0;
}
int compute(int pos, int carry1, int carry2, int g1, int g2, int c1, int c2,
int s1, int s2) {
if (pos == -1) return 0;
int &mem = memcompute[pos][carry1][carry2][g1][g2][c1][c2][s1][s2];
int &com = comcompute[pos][carry1][carry2][g1][g2][c1][c2][s1][s2];
if (com) {
return mem;
}
com = 1;
for (int D1 = 0; D1 < 10; D1++) {
for (int D2 = 0; D2 < 10; D2++) {
int v1 = carry1 + D1 * d1;
int v2 = carry2 + D2 * d2;
if (v1 % 10 != v2 % 10) continue;
int nextc1 = c1 | d2c1[D1];
int nextc2 = c2 | d2c2[D2];
if (nextc1 & nextc2) continue;
int nexts1 = s1 or D2 == d1;
int nexts2 = s2 or D1 == d2;
int nextcarry1 = v1 / 10;
int nextcarry2 = v2 / 10;
int nextg1 = getnextg(pos, D1, g1);
int nextg2 = getnextg(pos, D2, g2);
if (nexts1 and nexts2 and (nextcarry1 == nextcarry2) and
(D1 > 0 or D2 > 0) and (pos > 0 or (nextg1 <= 1 and nextg2 <= 1)))
add(mem, 1);
long long int res = compute(pos - 1, nextcarry1, nextcarry2, nextg1,
nextg2, nextc1, nextc2, nexts1, nexts2);
add(mem, res);
}
}
return mem;
}
int sol;
void compute() {
for (int i = 0; i < 10; i++) d2c1[i] = d2c2[i] = 0;
int amount = 0;
for (int D1 = d1 - 1; D1 >= 1; D1--) {
if (D1 * d2 % d1 == 0 and D1 * d2 / d1 < 10) {
d2c1[D1 * d2 / d1] = 1 << amount;
d2c2[D1] = 1 << amount;
amount++;
}
}
for (int pos = 0; pos < n; pos++)
for (int carry1 = 0; carry1 < 10; carry1++)
for (int carry2 = 0; carry2 < 10; carry2++)
for (int g1 = 0; g1 < 3; g1++)
for (int g2 = 0; g2 < 3; g2++)
for (int c1 = 0; c1 < 1 << amount; c1++)
for (int c2 = 0; c2 < 1 << amount; c2++)
for (int s1 = 0; s1 < 2; s1++)
for (int s2 = 0; s2 < 2; s2++)
memcompute[pos][carry1][carry2][g1][g2][c1][c2][s1][s2] =
comcompute[pos][carry1][carry2][g1][g2][c1][c2][s1]
[s2] = 0;
long long int res = compute(n - 1, 0, 0, 1, 1, 0, 0, 0, 0);
add(sol, 2 * res);
}
int memcomputeid[105][3][2];
int comcomputeid[105][3][2];
int computeid(int pos, int g, int s) {
if (pos < 0) return 0;
int &mem = memcomputeid[pos][g][s];
int &com = comcomputeid[pos][g][s];
if (com) return mem;
com = 1;
for (int D = 0; D < 10; D++) {
if (0 < D and D < d1) continue;
int nextg = getnextg(pos, D, g);
int nexts = s or D == d1;
if (nexts and D > 0 and (pos > 0 or nextg <= 1)) {
add(mem, 1);
}
add(mem, computeid(pos - 1, nextg, nexts));
}
return mem;
}
void computeid() {
for (int pos = 0; pos < n; pos++)
for (int g = 0; g < 3; g++)
for (int s = 0; s < 2; s++)
memcomputeid[pos][g][s] = comcomputeid[pos][g][s] = 0;
long long int res = computeid(n - 1, 1, 0);
add(sol, res);
}
int main() {
string s;
cin >> s;
n = int(s.size());
for (int i = 0; i < n; i++) v[i] = s[i] - '0';
for (d1 = 1; d1 < 10; d1++) {
for (d2 = d1; d2 < 10; d2++) {
if (d1 == d2)
computeid();
else
compute();
}
}
cout << sol << endl;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000 + 7;
const double esp = 1e-13;
int n, k, so, ans, per[10], dem, a[10];
string s[10];
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> s[i];
for (long long i = 1; i <= k; i++) per[i] = i;
ans = INF;
do {
dem = 0;
for (long long i = 1; i <= n; i++) {
so = 0;
for (long long j = 1; j <= k; j++) so = so * 10 + s[i][per[j] - 1] - '0';
a[++dem] = so;
}
sort(a + 1, a + dem + 1);
ans = min(ans, a[n] - a[1]);
} while (next_permutation(per + 1, per + k + 1));
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> isase;
struct info {
string s;
int d, h, m, c, f, id;
} help[101];
struct info_time {
int h, m, d;
} ar[100000], a[4][2];
struct info_ans {
int id, s, e;
} o;
vector<info_ans> vec;
int t, n, m;
bool fun(int i, int h, int m) {
int s, e, md;
md = h * 60 + m;
s = a[i][0].h * 60 + a[i][0].m;
e = a[i][1].h * 60 + a[i][1].m;
if (md >= s && md <= e) return 0;
return 1;
}
int dp[102][50000];
int go(int h, int m) {
if (h >= n) {
dp[h][m] = 0;
return 0;
}
if (m >= t) {
dp[h][m] = 0;
return 0;
}
if (dp[h][m] != -1) return dp[h][m];
int c1 = 0, c2 = 0, v;
v = isase[help[h].s];
if (v != 0 && m + v - 1 <= help[h].f && help[h].f != -1) {
c1 = help[h].c + go(h + 1, m + v);
}
c2 = go(h + 1, m);
return dp[h][m] = max(c1, c2);
}
void call(int h, int m) {
if (h >= n) {
return;
}
if (m >= t) {
return;
}
int c1 = 0, c2 = 0, v;
v = isase[help[h].s];
if (v != 0 && m + v - 1 <= help[h].f && help[h].f != -1) {
c1 = help[h].c + dp[h + 1][m + v];
}
c2 = dp[h + 1][m];
if (c1 > c2) {
o.id = h;
o.s = m;
o.e = m + v - 1;
vec.push_back(o);
call(h + 1, m + v);
} else {
call(h + 1, m);
}
return;
}
bool comp(info x, info y) { return x.f < y.f; }
int main() {
string s[101];
int d, i, j, l, k;
scanf("%d%d%d", &m, &n, &d);
for (i = 0; i < m; i++) cin >> s[i];
for (i = 0; i < m; i++) {
scanf("%d", &t);
isase[s[i]] = t;
}
for (i = 0; i < 4; i++)
scanf("%d:%d-%d:%d", &a[i][0].h, &a[i][0].m, &a[i][1].h, &a[i][1].m);
t = 0;
for (i = 1; i <= d; i++) {
for (j = 0; j < 24; j++)
for (k = 0; k < 60; k++) {
if (fun(0, j, k) && fun(1, j, k) && fun(2, j, k) && fun(3, j, k)) {
ar[t].h = j;
ar[t].m = k;
ar[t].d = i;
t++;
}
}
}
for (i = 0; i < n; i++) {
help[i].id = i;
cin >> help[i].s;
scanf("%d %d:%d %d", &help[i].d, &help[i].h, &help[i].m, &help[i].c);
help[i].f = -1;
for (j = 0; j < t; j++)
if (ar[j].d < help[i].d) {
help[i].f = j;
} else if (ar[j].d == help[i].d) {
int e, m;
m = ar[j].h * 60 + ar[j].m;
e = help[i].h * 60 + help[i].m;
if (m < e) help[i].f = j;
}
}
sort(help, help + n, comp);
memset(dp, -1, sizeof(dp));
printf("%d\n", go(0, 0));
call(0, 0);
j = vec.size();
printf("%d\n", j);
for (i = 0; i < j; i++) {
printf("%d %d ", help[vec[i].id].id + 1, ar[vec[i].s].d);
if (ar[vec[i].s].h < 10)
printf("0%d:", ar[vec[i].s].h);
else
printf("%d:", ar[vec[i].s].h);
if (ar[vec[i].s].m < 10)
printf("0%d", ar[vec[i].s].m);
else
printf("%d", ar[vec[i].s].m);
printf(" %d ", ar[vec[i].e].d);
if (ar[vec[i].e].h < 10)
printf("0%d:", ar[vec[i].e].h);
else
printf("%d:", ar[vec[i].e].h);
if (ar[vec[i].e].m < 10)
printf("0%d\n", ar[vec[i].e].m);
else
printf("%d\n", ar[vec[i].e].m);
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string first, last;
cin >> first >> last;
string ans = "";
int i = 1;
while (i < first.length() && first.at(i) < last.at(0)) i++;
ans = first.at(0) + first.substr(1, i - 1) + last.at(0);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
int n, m, a, b, r[20], p[20], c[20][20];
char s1[10], s2[10];
int D(int x) {
int d = 0;
while (x) x /= 10, ++d;
return d;
}
int check() {
for (int t = (0); t <= ((1 << m) - 1); ++t) {
a = 0, b = 0;
for (int i = (1); i <= (m); ++i)
if (t & (1 << (i - 1))) a += r[i];
for (int i = (1); i <= (m); ++i)
if (t & (1 << (i - 1)))
for (int j = (1); j <= (m); ++j)
if (t & (1 << (j - 1))) b += c[i][j];
if (b >= a && a) return 0;
}
return 1;
}
int ovo() {
for (int i = (1); i <= (m); ++i)
for (int j = (1); j <= (m); ++j)
if (c[i][j]) {
if (r[i] > 1) {
--c[i][j], --r[i];
if (check()) return printf("%d %d\n", r[i] + p[i], p[j]), 1;
++c[i][j], ++r[i];
}
if (r[j] > 1) {
--c[i][j], --r[j];
if (check()) return printf("%d %d\n", r[j] + p[j], p[i]), 1;
++c[i][j], ++r[j];
}
}
return 0;
}
int main() {
scanf("%d", &n);
m = D(n);
for (int i = (1); i <= (n); ++i) ++r[D(i)];
p[1] = 1;
for (int i = (2); i <= (m); ++i) p[i] = p[i - 1] * 10;
for (int i = (1); i <= (n - 1); ++i)
scanf(" %s %s", s1, s2), ++c[strlen(s1)][strlen(s2)];
if (!check()) return puts("-1"), 0;
while (ovo())
;
for (int i = (1); i <= (m); ++i)
for (int j = (1); j <= (m); ++j)
if (c[i][j]) printf("%d %d\n", r[i] + p[i] - 1, r[j] + p[j] - 1);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
namespace Solve {
template <typename T>
void read(T& x) {
x = 0;
T s = 1;
char c;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') {
s = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= s;
}
const int MAXN = 100000 + 10;
int n;
char A[MAXN], B[MAXN];
int fa[20];
int findfa(int x) { return fa[x] == x ? x : fa[x] = findfa(fa[x]); }
void solve(int kase) {
cin >> n;
cin >> A >> B;
int map[20][20];
memset(map, 0, sizeof(map));
for (int i = 0; i < n; i++) {
if (A[i] > B[i]) {
printf("-1\n");
return;
} else if (A[i] < B[i]) {
map[A[i] - 'a'][B[i] - 'a'] = 1;
}
}
for (int i = 0; i < 20; i++) {
fa[i] = i;
}
int ans = 0;
for (int a = 0; a < 20; a++) {
for (int b = 0; b < 20; b++) {
if (map[a][b] && findfa(a) != findfa(b)) {
ans++;
fa[findfa(a)] = findfa(b);
}
}
}
cout << ans << endl;
}
} // namespace Solve
int main() {
int T;
scanf("%d", &T);
for (int kase = 1; kase <= T; kase++) Solve::solve(kase);
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace solution {
class SolutionInterface {
public:
virtual int run() = 0;
protected:
virtual void pre_calc() {}
virtual bool action() = 0;
virtual void init(){};
virtual bool input() { return false; };
virtual void output(){};
SolutionInterface() {}
private:
};
} // namespace solution
namespace solution {
class SolutionBase : public SolutionInterface {
public:
virtual int run() {
pre_calc();
while (action())
;
return 0;
}
};
} // namespace solution
namespace solution {}
namespace solution {
using namespace std;
}
namespace solution {
const int SIZE = 100000 + 11;
const int NONE = -1;
const int LIMIT = 200 + 1;
const string YES = "YES";
const string NO = "NO";
int n, m;
int h;
int t;
int A[SIZE];
int B[SIZE];
std::vector<int> G[SIZE];
int u, v;
int head_vertices[LIMIT];
int head_vertices_num;
int tail_vertices[LIMIT];
int tail_vertices_num;
int head_tmp[LIMIT];
int head_tmp_num;
int tail_tmp[LIMIT];
int tail_tmp_num;
int commons_tmp[LIMIT];
int commons_tmp_num;
} // namespace solution
namespace solution {
class Solver {
public:
void solve() {
normalize();
for (int i = 0; i < n; ++i) {
if (G[i].size() < h) continue;
for (int j = 0; j < (int)G[i].size(); ++j) {
int a = i;
int b = G[i][j];
if (check(a, b)) {
u = a;
v = b;
return;
}
}
}
}
void init_head_tail() {
head_vertices_num = 0;
tail_vertices_num = 0;
head_tmp_num = 0;
tail_tmp_num = 0;
commons_tmp_num = 0;
}
bool generate_head_tmp(int u, int v) {
int connected_vertices_num = G[u].size();
for (int i = 0; i < connected_vertices_num && head_tmp_num < LIMIT; ++i) {
if (G[u][i] == v) continue;
head_tmp[head_tmp_num++] = G[u][i];
}
if (head_tmp_num < h) return false;
return true;
}
bool generate_tail_tmp(int u, int v) {
int connected_vertices_num = G[v].size();
for (int i = 0; i < connected_vertices_num && tail_tmp_num < LIMIT; ++i) {
if (G[v][i] == u) continue;
tail_tmp[tail_tmp_num++] = G[v][i];
}
if (tail_tmp_num < t) return false;
return true;
}
bool check(int u, int v) {
init_head_tail();
if (!generate_head_tmp(u, v)) return false;
if (!generate_tail_tmp(u, v)) return false;
if (head_tmp_num < h) return false;
if (tail_tmp_num < t) return false;
int commons_p = 0;
int commons_tmp_num =
std::set_intersection(head_tmp, head_tmp + head_tmp_num, tail_tmp,
tail_tmp + tail_tmp_num, commons_tmp) -
commons_tmp;
if (head_tmp_num + tail_tmp_num < h + t + commons_tmp_num) return false;
std::set<int> commons_set(commons_tmp, commons_tmp + commons_tmp_num);
for (int i = 0; i < head_tmp_num && head_vertices_num < h; ++i) {
if (commons_set.count(head_tmp[i])) continue;
head_vertices[head_vertices_num++] = head_tmp[i];
}
for (int i = 0; i < tail_tmp_num && tail_vertices_num < t; ++i) {
if (commons_set.count(tail_tmp[i])) continue;
tail_vertices[tail_vertices_num++] = tail_tmp[i];
}
while (head_vertices_num < h) {
if (commons_p >= commons_tmp_num) return false;
int vertex = commons_tmp[commons_p];
head_vertices[head_vertices_num++] = vertex;
commons_p++;
}
while (tail_vertices_num < t) {
if (commons_p >= commons_tmp_num) return false;
int vertex = commons_tmp[commons_p];
tail_vertices[tail_vertices_num++] = vertex;
commons_p++;
}
return true;
}
void normalize() {
for (int i = 0; i < m; ++i) {
A[i]--;
B[i]--;
int a = A[i];
int b = B[i];
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 0; i < n; ++i) sort(G[i].begin(), G[i].end());
}
private:
};
} // namespace solution
namespace solution {
class Solution : public SolutionBase {
public:
protected:
virtual bool action() {
init();
if (!input()) return false;
solver.solve();
output();
return true;
}
void init() {
for (int i = 0; i < n; ++i) G[i].clear();
u = NONE;
v = NONE;
}
bool input() {
if (!(scanf("%d%d", &n, &m) != EOF)) return false;
scanf("%d%d", &h, &t);
for (int i = 0; i < m; ++i) scanf("%d%d", A + i, B + i);
return true;
}
void output() {
if (u == NONE) {
puts(NO.c_str());
} else {
puts(YES.c_str());
printf("%d %d\n", u + 1, v + 1);
for (int i = 0; i < head_vertices_num; ++i)
printf("%d ", head_vertices[i] + 1);
puts("");
for (int i = 0; i < tail_vertices_num; ++i)
printf("%d ", tail_vertices[i] + 1);
puts("");
}
}
private:
Solver solver;
};
} // namespace solution
int main() { return solution::Solution().run(); }
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<string, int> mp;
set<string> ss;
string S;
void dfs(string st) {
int cd = st.size(), i = 0;
while (st[i] != '?' && i < cd) i++;
if (i == cd) {
ss.insert(st);
return;
}
for (char ch = 'a'; ch <= 'e'; ch++) {
st[i] = ch;
dfs(st);
}
dfs(st.substr(0, i) + st.substr(i + 1, cd - 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin >> m >> n;
for (int i = 0; i < m; i++) {
cin >> S;
mp[S]++;
}
for (int i = 0; i < n; i++) {
int jg = 0;
ss.clear();
cin >> S;
dfs(S);
set<string>::iterator it;
for (it = ss.begin(); it != ss.end(); it++) {
if (mp[*it] > 0) jg += mp[*it];
}
cout << jg << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, letter[30] = {0};
long long int substring = 0, cnt = 0;
string arr;
char ch;
cin >> n >> k;
cin >> arr;
for (i = 0; i < k; i++) {
cin >> ch;
letter[ch - 97] = 1;
}
for (i = 0; i < n; i++) {
if (letter[arr[i] - 97] == 1) cnt++;
if (letter[arr[i] - 97] == 0 || i == n - 1) {
substring += (cnt * (cnt + 1)) / 2;
cnt = 0;
}
}
cout << substring;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
namespace flow {
const int MAXM = 1.2e7 + 6;
int N;
int head[200036], to[MAXM], nex[MAXM], wto[MAXM], cto[MAXM], cur[200036],
ecn = -1;
inline void Ade(int u, int v, int w, int c) {
to[++ecn] = v, nex[ecn] = head[u], wto[ecn] = w, cto[ecn] = c, head[u] = ecn;
}
inline void ade(int u, int v, int w, int c) {
Ade(u, v, w, c), Ade(v, u, 0, -c);
}
void in(int t) {
N = t;
for (int i = (1), iend = (N); i <= iend; ++i) head[i] = -1;
ecn = -1;
}
queue<int> Q;
int dis[200036], vis[200036];
const int inf = 1e9;
int s, t;
bool spfa() {
memset(dis, 0x3f, sizeof dis), memset(vis, 0, sizeof vis);
for (int i = (1), iend = (N); i <= iend; ++i) cur[i] = head[i];
dis[s] = 0, vis[s] = 1;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
vis[u] = 0;
for (int i = head[u]; ~i; i = nex[i])
if (wto[i] && dis[to[i]] > dis[u] + cto[i]) {
int v = to[i];
dis[v] = dis[u] + cto[i];
if (!vis[v]) Q.push(v), vis[v] = 1;
}
}
return dis[t] < inf;
}
int co;
int dfs(int u, int lim) {
if (!lim || u == t) return lim;
vis[u] = 1;
int f, flow = 0;
for (int& i = cur[u]; ~i; i = nex[i])
if (!vis[to[i]] && wto[i] && dis[to[i]] == dis[u] + cto[i] &&
(f = dfs(to[i], min(lim, wto[i])))) {
lim -= f, flow += f, wto[i] -= f, wto[i ^ 1] += f;
co += f * cto[i];
if (!lim) break;
}
vis[u] = 0;
return flow;
}
pair<int, int> dinic() {
int re = 0;
co = 0;
while (spfa()) {
re += dfs(s, 0x3f3f3f3f);
}
return make_pair(re, co);
}
} // namespace flow
int mn[200036], mx[200036];
void solve() {
cin >> n >> q;
for (int i = (1), iend = (n); i <= iend; ++i) mn[i] = 1, mx[i] = n;
for (int i = (1), iend = (q); i <= iend; ++i) {
int t, l, r, v;
scanf("%d%d%d%d", &t, &l, &r, &v);
if (t == 1)
for (int j = (l), jend = (r); j <= jend; ++j) mn[j] = max(mn[j], v);
else
for (int j = (l), jend = (r); j <= jend; ++j) mx[j] = min(mx[j], v);
}
flow::in(n * n + n + 6);
flow::s = n * n + n + 1, flow::t = n * n + n + 2;
int s = flow::s, t = flow::t;
for (int i = (1), iend = (n); i <= iend; ++i) {
for (int j = (mn[i]), jend = (mx[i]); j <= jend; ++j) {
int cur = j + i * n;
if (j == mn[i]) flow::ade(s, cur, 1, 0);
if (j != mx[i]) flow::ade(cur, cur + 1, 1, 0);
flow::ade(cur, j, 1, 0);
}
}
for (int i = (1), iend = (n); i <= iend; ++i)
for (int j = (1), jend = (n); j <= jend; ++j) flow::ade(i, t, 1, 2 * j - 1);
pair<int, int> fl = flow::dinic();
if (fl.first != n)
puts("-1");
else
cout << fl.second << endl;
}
signed main() { solve(); }
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, x;
cin >> n >> m >> x;
n -= 2 * (x - 1);
m -= 2 * (x - 1);
if (n < 1 || m < 1)
cout << 0 << endl;
else if (n + m == 2)
cout << 1 << endl;
else
cout << n + m - 2 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 201;
const int M = 1e9 + 7;
const double eps = 1e-6;
const double PI(acos(-1.0));
bitset<155> a, b, c;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
a[1] = 1;
b[0] = 1;
int n;
cin >> n;
for (int i = 0; i < (n - 1); i++) {
c = (a << 1) ^ b;
b = a, a = c;
}
cout << n << endl;
for (int j = (0); j <= (n); j++) cout << a[j] << " ";
cout << endl;
cout << n - 1 << endl;
for (int j = (0); j <= (n - 1); j++) cout << b[j] << " ";
cout << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
int divi[1000005];
int main() {
primes.push_back(2);
for (int i = 4; i <= 1000000; i += 2) divi[i] = 2;
for (int i = 3; i < 1000000; i += 2) {
if (divi[i] > 0) continue;
primes.push_back(i);
for (int j = i + i; j <= 1000000; j += i) divi[j] = i;
}
ios::sync_with_stdio(0);
int x3;
cin >> x3;
int x0 = 1000000;
for (int pi = 0; pi < (int)primes.size() && primes[pi] < x3; pi++) {
int p = primes[pi];
if (x3 % p == 0) {
for (int i = 0; i < p; i++) {
if (divi[x3 - i] == 0) continue;
x0 = min(x0, x3 - i - divi[x3 - i] + 1);
}
}
}
cout << x0 << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long long int f = 1, t = 0, ans = 0;
cin >> s;
for (long long int i = 0; i <= s.length(); i++) {
if (s[i] < '0') {
ans += f * t;
s[i] == '+' ? f = 1 : f = -1;
t = 0;
}
t = t * 10 + s[i] - '0';
}
cout << ans << endl;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * t;
}
const int N = 3505;
const int P = 1e9 + 7;
char ch[N];
int p, a, n, m, Ans, A[N], B[N], f[N][N][2][2];
int Mod(int x) { return x >= P ? x - P : x; }
void Mod(int &x, int y) { (x += y) >= P ? x -= P : 0; }
int C(int n) { return 1ll * n * (n + 1) / 2 % P; }
int Calc(int x, int y, int v) {
if (v < 0) return 0;
if (x) return Mod(Calc(0, y, v + p) + P - Calc(0, y, p - 1));
return Mod(C(v + 1 - y) + P - 2ll * (v < p ? 0 : C(v - p + 1 - y)) % P);
}
int main() {
p = read(), a = read(), scanf("%s", ch + 1), n = strlen(ch + 1);
for (int i = 1; i <= n; i++) A[i] = ch[n + 1 - i] - '0';
while (n) {
long long t = 0;
for (int i = n; i >= 1; i--) {
t = t * 10 + A[i], A[i] = t / p, t %= p;
if ((i == n) && !A[i]) n--;
}
B[++m] = t;
}
f[m + 1][0][1][0] = 1;
for (int i = m + 1; i > 1; i--)
for (int j = 0; j <= m - i + 1; j++)
for (int k = 0; k <= 1; k++)
for (int x = 0; x <= 1; x++)
if (f[i][j][k][x]) {
for (int y = 0; y <= 1; y++) {
int res = f[i][j][k][x], v = k ? B[i - 1] : p - 1;
int a = Calc(x, y, v), b = Calc(x, y, v - 1);
Mod(f[i - 1][j + y][0][y], 1ll * res * b % P);
Mod(f[i - 1][j + y][k][y], 1ll * res * Mod(a + P - b) % P);
}
}
for (int i = a; i <= m + 1; i++)
Ans = Mod(Ans + Mod(f[1][i][1][0] + f[1][i][0][0]));
cout << Ans;
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
vector<long long> a;
for (int i = 0; i < n; i++) {
long long l;
cin >> l;
a.push_back(l);
}
long long ans = 0;
vector<long long> res(n);
res[0] = 1;
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
res[i] = 1;
} else
res[i] = res[i - 1] + 1;
}
for (int i = 0; i < n; i++) {
ans = max(ans, res[i]);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using std::sort;
const int N = 200005;
int n, m;
struct Data {
int i, v;
bool operator<(const Data &b) const { return v < b.v; }
} p[N], s[N];
int b[N], d[N], bcnt = 0, ad = 0;
void match(int adapter) {
int i = 1, j = 1;
while (i <= n && j <= m) {
if (b[p[i].i] || p[i].v < s[j].v)
++i;
else if (d[s[j].i] || p[i].v > s[j].v)
++j;
else if (p[i].v == s[j].v) {
b[p[i].i] = s[j].i, bcnt++;
d[s[j].i] = adapter + 1;
ad += adapter;
}
}
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%d", &p[i].v), p[i].i = i;
sort(p + 1, p + 1 + n);
for (i = 1; i <= m; ++i) scanf("%d", &s[i].v), s[i].i = i;
sort(s + 1, s + 1 + m);
match(0);
for (i = 1; i <= 31; ++i) {
for (j = 1; j <= m; ++j) s[j].v = (s[j].v + 1) / 2;
match(i);
}
printf("%d %d\n", bcnt, ad);
for (i = 1; i <= m; ++i) printf("%d ", (d[i] == 0) ? 0 : (d[i] - 1));
putchar('\n');
for (i = 1; i <= n; ++i) printf("%d ", b[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T sqr(T x) {
return x * x;
}
bool bad[100005], del[100005];
double cond[100005];
vector<int> g[100005];
int n, k;
double eps = 0.0000001;
bool check(double ratio) {
priority_queue<pair<double, int> > s;
memset(del, 0, n + 2);
for (int i = 1; i <= n; i++) {
if (bad[i]) continue;
int cnt = 0;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (!bad[to]) cnt++;
}
cond[i] = (double)cnt / (double)g[i].size();
s.push(make_pair(-cond[i], i));
}
int rep = n - k;
while (rep--) {
pair<double, int> cur = s.top();
s.pop();
if (abs(-cur.first - cond[cur.second]) > eps) {
rep++;
continue;
}
if (-cur.first > ratio - eps) {
return true;
}
int from = cur.second;
del[from] = 1;
for (int i = 0; i < g[from].size(); i++) {
int to = g[from][i];
if (!bad[to] && !del[to]) {
cond[to] -= 1.0 / (double)g[to].size();
s.push(make_pair(-cond[to], to));
}
}
}
return false;
}
int main() {
int m;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
bad[x] = 1;
}
for (int i = 0; i < m; i++) {
int from, to;
scanf("%d%d", &from, &to);
g[from].push_back(to);
g[to].push_back(from);
}
double l = 0, r = 1;
while ((r - l) > eps) {
double mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
check(l);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (!del[i] && !bad[i]) {
ans.push_back(i);
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
vector<long long> Sieve(long long n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long i = 2; i * i <= n; i++) {
if (prime[i]) {
for (long long j = i * i; j <= n; j += i) {
prime[j] = false;
}
}
}
vector<long long> primes;
for (long long i = 2; i <= n; i++) {
if (prime[i]) primes.push_back(i);
}
return primes;
}
set<long long> primeFactors(long long n) {
set<long long> factors;
while (n % 2 == 0) {
n /= 2;
factors.insert(2);
}
for (long long i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
factors.insert(i);
n /= i;
}
}
if (n > 2) factors.insert(n);
return factors;
}
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int32_t main() {
c_p_c();
long long n, m;
cin >> n >> m;
long long *arr = new long long[m];
map<long long, long long> occ;
long long ans = 0;
for (long long i = 0; i < m; i++) {
cin >> arr[i];
occ[arr[i]]++;
long long t = 0;
set<long long> j;
for (auto d : occ) {
if (d.second > 0) {
t++;
j.insert(d.first);
}
}
if (t == n) {
ans++;
for (auto d : j) {
occ[d]--;
}
}
}
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 3e8 + 10;
bitset<maxn> prime;
int l, r;
int main() {
scanf("%d%d", &l, &r);
prime.set();
prime[0] = prime[1] = 0;
int ans = 0;
for (int i = 3; i * i <= r; i += 2) {
if (prime[i]) {
for (int j = i * i; j <= r; j += (2 * i)) prime[j] = 0;
}
}
if (2 <= r && 2 >= l) ans++;
if (!(l & 1)) l++;
if (!(r & 1)) r--;
for (int i = l; i <= r; i += 2) {
if (prime[i] && (i % 4 == 1)) ans++;
}
printf("%d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 100 * 1000;
const int kInf = 1000 * 1000 * 1000;
map<string, int> name2id;
vector<string> id2name;
vector<string> arr;
vector<int> g[kN], gr[kN], graph[kN];
bool used[kN];
vector<int> order, component;
int N;
void DFS1(int u) {
if (used[u]) {
return;
}
used[u] = true;
for (int i = 0; i < g[u].size(); ++i) DFS1(g[u][i]);
order.push_back(u);
}
void DFS2(int u) {
if (used[u]) {
return;
}
used[u] = true;
component.push_back(u);
for (int i = 0; i < gr[u].size(); ++i) DFS2(gr[u][i]);
}
pair<long long, long long> Score(const string& s) {
int cnt = 0;
for (int i = 0; i < s.length(); ++i) cnt += s[i] == 'r' ? 1 : 0;
return make_pair(cnt, s.length());
}
int new_map[kN];
pair<long long, long long> dp[kN];
pair<long long, long long> DP(int u) {
if (!used[u]) {
used[u] = true;
for (int i = 0; i < graph[u].size(); ++i)
dp[u] = min(dp[u], DP(graph[u][i]));
}
return dp[u];
}
void Transform(string& str) {
for (int i = 0; i < str.length(); ++i) str[i] = tolower(str[i]);
}
void Add(const string& s, const string& t) {
int from = (int)id2name.size();
if (name2id.find(s) != name2id.end()) {
from = name2id[s];
} else {
id2name.push_back(s);
name2id[s] = from;
}
int to = (int)id2name.size();
if (name2id.find(t) != name2id.end()) {
to = name2id[t];
} else {
id2name.push_back(t);
name2id[t] = to;
}
g[from].push_back(to);
gr[to].push_back(from);
}
int main() {
int n, m;
cin >> n;
arr.resize(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
Transform(arr[i]);
}
cin >> m;
for (int i = 0; i < m; ++i) {
string x, y;
cin >> x >> y;
Transform(x);
Transform(y);
Add(x, y);
}
N = (int)id2name.size();
memset(used, 0, sizeof(used));
for (int i = 0; i < N; ++i)
if (!used[i]) {
DFS1(i);
}
memset(used, 0, sizeof(used));
int id = 0;
for (int i = 0; i < N; ++i) {
int u = order[N - i - 1];
if (!used[u]) {
DFS2(u);
dp[id] = {kInf, kInf};
for (int j = 0; j < component.size(); ++j) {
new_map[component[j]] = id;
dp[id] = min(dp[id], Score(id2name[component[j]]));
}
component.clear();
++id;
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < g[i].size(); ++j)
graph[new_map[i]].push_back(new_map[g[i][j]]);
}
memset(used, 0, sizeof(used));
long long score = 0, len = 0;
for (int i = 0; i < arr.size(); ++i) {
if (name2id.find(arr[i]) == name2id.end()) {
score += Score(arr[i]).first;
len += (int)arr[i].length();
} else {
int u = name2id[arr[i]];
int new_u = new_map[u];
score += DP(new_u).first;
len += DP(new_u).second;
}
}
cout << score << " " << len;
return 0;
}
| 16 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
void makedata() {
freopen("input.txt", "w", stdout);
fclose(stdout);
}
map<long long, pair<int, int> > mp;
vector<long long> v;
long long ans[250000];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
mp[a].first++, mp[b].second++, v.push_back(a), v.push_back(b);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
int h = 0;
for (int i = 0; i < v.size(); i++) {
long long p = v[i];
pair<int, int> q = mp[p];
ans[h + q.first]++;
h = h + q.first - q.second;
if (i + 1 < v.size()) ans[h] += v[i + 1] - v[i] - 1;
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n;
cin >> n;
int i;
for (i = 0; i < n; i++) cin >> a[i];
if (a[0] % 2 != 0 && a[n - 1] % 2 != 0 && n % 2 != 0)
printf("YES");
else
printf("NO");
return 0;
}
| 2 |
Subsets and Splits