solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll fmax(ll a, ll b) { return a > b ? a : b; }
ll fmin(ll a, ll b) { return a < b ? a : b; }
ll gcd(ll a, ll b) {
if (a < b) return gcd(b, a);
while (a % b) {
ll t = a % b;
a = b;
b = t;
}
return b;
}
bool isPrime(ll n) {
if (n <= 2) return n == 2;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return false;
}
return true;
}
ll f(ll a, ll b) {
ll ans = (a + b) / 3;
return fmin(fmin(a, b), ans);
}
ll icase() {
ll a, b;
cin >> a >> b;
return f(a, b);
}
int main() {
int t;
cin >> t;
while (t--) {
cout << icase() << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string a[12] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
int n, b;
cin >> n;
for (int i = 0; i < 12; i++) {
if (a[i] == s) {
b = i;
}
}
cout << a[(b + n) % 12] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool p = false;
for (int i = 1; i < s.size() - 1; ++i) {
if (s[i - 1] == '.' || s[i] == '.' || s[i + 1] == '.') continue;
if (s[i - 1] != s[i] && s[i] != s[i + 1] && s[i - 1] != s[i + 1]) {
p = true;
}
}
if (p)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cc = 1;
vector<int> c, cur, z;
vector<vector<int>> adj1, adj2;
void dfs(int s, int p) {
for (auto i : adj1[s]) {
if (c[i] != -1)
cur.push_back(c[i]);
else
z.push_back(i);
}
sort(cur.begin(), cur.end());
int x = 0, pos = 0;
while (z.size() > 0) {
if (pos < cur.size() && cur[pos] == x) {
pos++;
} else {
c[z.back()] = x;
z.pop_back();
}
x++;
}
cur.clear();
for (auto i : adj2[s]) {
if (i != p) dfs(i, s);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
adj1.assign(n, vector<int>());
adj2.assign(n, vector<int>());
c.assign(m, -1);
for (int i = 0; i < n; ++i) {
int r, x;
cin >> r;
cc = max(cc, r);
for (int j = 0; j < r; ++j) {
cin >> x;
x--;
adj1[i].push_back(x);
}
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
adj2[u].push_back(v);
adj2[v].push_back(u);
}
dfs(0, 0);
cout << cc << "\n";
for (auto i : c) {
cout << max(i + 1, 1) << " ";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long int po(long long int a, long long int b, long long int mod) {
if (b == 0) {
return 1;
}
long long int x = po(a, b / 2, mod);
x = (x * x) % mod;
if (b % 2) {
x = (x * a) % mod;
}
return x;
}
long long int modin(long long int a, long long int mod) {
return po(a, mod - 2, mod);
}
double n;
double p[20][20];
double dp[2000000];
void pri(int x) {
vector<int> v;
for (int i = 0; i < 6; i++) {
if (x & (1 << i)) {
v.push_back(1);
} else
v.push_back(0);
}
reverse(v.begin(), v.end());
for (auto x : v) cout << x << " ";
cout << '\n';
}
double rec(int i, int mask, int rem) {
int t = (mask & (1 << i));
if (t != 0) return 0.00;
if (rem == 1) return 1.000;
rem = double(rem * (1.0));
if (dp[mask] != -1.0) return dp[mask];
double &res = dp[mask];
res = 0.00;
double x = 2.0 / (rem * (rem - 1));
for (int j = 0; j < n; j++) {
int l = mask & 1 << j;
if (l == 0) {
for (int k = 0; k < n; k++) {
int pq = mask & 1 << k;
if (k != j && pq == 0) {
int temp = mask | 1 << k;
res += (p[j][k] * rec(i, temp, rem - 1) * x);
}
}
}
}
return res;
}
void in() {
for (int j = 0; j < 2000000; j++) dp[j] = -1.0;
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> p[i][j];
}
}
for (int i = 0; i < n; i++) {
in();
cout << fixed;
cout << setprecision(9);
cout << double(rec(i, 0, n * 1.0)) << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
int p = 1;
while (TESTS--) {
solve();
p++;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct F {
int b;
int p;
int mx;
bool operator<(const F &o) const { return p < o.p || (p == o.p && b < o.b); }
};
int get_mxb(const F *a, int n, int r) {
int f = 0, t = n;
while (f < t) {
int m = f + (t - f) / 2;
if (a[m].p <= r)
f = m + 1;
else
t = m;
}
if (f > 0 && a[f - 1].p <= r)
return a[f - 1].mx;
else
return -1;
}
int main(int argc, char **argv) {
int n, c, d;
scanf("%d%d%d", &n, &c, &d);
F fc[n], fd[n];
int nc = 0, nd = 0;
while (n--) {
int b, p;
char t[2];
scanf("%d%d%s", &b, &p, t);
if (t[0] == 'C')
fc[nc++] = F{b, p, b};
else
fd[nd++] = F{b, p, b};
}
sort(fc, fc + nc);
sort(fd, fd + nd);
for (int i = 1; i < nc; i++) fc[i].mx = max(fc[i].mx, fc[i - 1].mx);
for (int i = 1; i < nd; i++) fd[i].mx = max(fd[i].mx, fd[i - 1].mx);
int mxc = -1, mxc2 = -1;
int mxd = -1, mxd2 = -1;
for (int i = 0; i < nc && fc[i].p <= c; i++) mxc = fc[i].mx;
for (int i = 0; i < nd && fd[i].p <= d; i++) mxd = fd[i].mx;
for (int i = nc - 1; i > 0; i--) {
int r = c - fc[i].p;
int b = get_mxb(fc, i, r);
if (b >= 0) mxc2 = max(mxc2, fc[i].b + b);
}
for (int i = nd - 1; i > 0; i--) {
int r = d - fd[i].p;
int b = get_mxb(fd, i, r);
if (b >= 0) mxd2 = max(mxd2, fd[i].b + b);
}
int mx = 0;
if (mxc >= 0 && mxd >= 0) mx = max(mx, mxc + mxd);
mx = max(mx, max(mxc2, mxd2));
printf("%d\n", mx);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:267386880")
using namespace std;
vector<int> d[1005];
int count(int wh, int to) {
int ans(lower_bound((d[wh]).begin(), (d[wh]).end(), to) - d[wh].begin());
if (binary_search((d[wh]).begin(), (d[wh]).end(), to)) ++ans;
return ans;
}
int count(int wh, int from, int to) {
int ans(count(wh, to) - count(wh, from));
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i(0); i <= ((int)(n)-1); ++i) {
int k;
scanf("%d", &k);
d[i].reserve(k);
for (int j(0); j <= ((int)(k)-1); ++j) {
int a;
scanf("%d", &a);
d[i].push_back(a);
}
sort((d[i]).begin(), (d[i]).end());
}
int ans(0);
for (int i(0); i <= ((int)(n)-1); ++i) {
int nxt((i + 1) % n);
int prv((i - 1 + n) % n);
for (int j(0); j <= ((int)(((int)d[i].size()) - 1) - 1); ++j) {
if (count(nxt, d[i][j], d[i][j + 1]) != count(prv, d[i][j], d[i][j + 1]))
++ans;
}
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#define fastIO ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
#define endl '\n'
#define lli long long int
#define ld long double
#define p_b push_back
#define m_p make_pair
#define fs first
#define sc second
#define sz(x) ((lli)x.size())
#define all(x) x.begin(),x.end()
const lli mod = 1e9 + 7;
const lli N = 2e5 + 5;
/*****************************************************/
lli t,n,m,dist[N],vis[N]={0};
vector<pair<lli,lli> > v[N];
multiset<pair<lli,lli> > s;
int main()
{
fastIO
lli i,j,k,x,y;
cin>>n>>m;
for(i=0;i<n+5;i++)
dist[i]=1e16;
for(i=1;i<=m;i++)
{
cin>>x>>y>>k;
v[x].p_b({y,k});
v[y].p_b({x,k});
}
s.insert({0,1});
dist[1]=0;
while(!s.empty())
{
pair<lli,lli> p=*(s.begin());
s.erase(s.begin());
if(vis[p.sc])
continue;
vis[p.sc]=1;
x=p.sc;
for(i=0;i<sz(v[x]);i++)
{
y=v[x][i].fs;
for(j=0;j<sz(v[y]);j++)
{
lli curr=v[x][i].sc+v[y][j].sc;
curr=(curr*curr)+dist[x];
if(dist[v[y][j].fs]>curr)
{
dist[v[y][j].fs]=curr;
s.insert({curr,v[y][j].fs});
}
}
}
}
for(i=1;i<=n;i++)
{
if(dist[i]==1e16)
cout<<"-1 ";
else
cout<<dist[i]<<" ";
}
// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long second, first;
cin >> n >> first >> second;
pair<long long, long long> segs[n];
for (int i = 0; i < n; i++) {
cin >> segs[i].first >> segs[i].second;
}
sort(segs, segs + n);
priority_queue<long long, vector<long long>, greater<long long> > ok;
multiset<long long> bad;
long long ans = 0;
long long mod = 1e9 + 7;
long long aps = first / second;
for (int i = 0; i < n; i++) {
while (ok.size() && ok.top() < segs[i].first) {
if (ok.top() + aps >= segs[i].first) {
bad.insert(ok.top() + aps);
}
ok.pop();
}
while (bad.size() && *bad.begin() < segs[i].first) {
bad.erase(bad.begin());
}
if (bad.size() == 0) {
ans += first;
ans %= mod;
ans += ((segs[i].second - segs[i].first) * second) % mod;
ans %= mod;
ok.push(segs[i].second);
} else {
long long t = *bad.rbegin();
ans += ((segs[i].first - (t - aps)) * second) % mod;
ans %= mod;
ans += ((segs[i].second - segs[i].first) * second) % mod;
ans %= mod;
ok.push(segs[i].second);
bad.erase(prev(bad.end()));
}
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
int clr[MAXN + 5], n;
vector<int> v[MAXN + 5];
int d[10][MAXN + 5];
bool tag[10];
void get_dist(int x) {
queue<int> que;
for (int i = 0; i < 8; i++) tag[i] = false;
for (int i = 1; i <= n; i++) d[x][i] = MAXN + 5;
for (int i = 0; i < v[x].size(); i++) d[x][v[x][i]] = 0, que.push(v[x][i]);
while (!que.empty()) {
int f = que.front();
que.pop();
if (!tag[clr[f]]) {
tag[clr[f]] = true;
for (int i = 0; i < v[clr[f]].size(); i++) {
int u = v[clr[f]][i];
if (d[x][u] > d[x][f] + 1) d[x][u] = d[x][f] + 1, que.push(u);
}
}
if (f != 1 && d[x][f - 1] > d[x][f] + 1)
d[x][f - 1] = d[x][f] + 1, que.push(f - 1);
if (f != n && d[x][f + 1] > d[x][f] + 1)
d[x][f + 1] = d[x][f] + 1, que.push(f + 1);
}
}
int mnd[10][10], bts[MAXN + 5], cnt[10][1 << 10];
void get_mask(int x) {
for (int i = 0; i < 8; i++) {
mnd[x][i] = MAXN + 5;
for (int j = 0; j < v[x].size(); j++)
mnd[x][i] = min(mnd[x][i], d[i][v[x][j]]);
for (int j = 0; j < v[x].size(); j++)
bts[v[x][j]] |= ((d[i][v[x][j]] - mnd[x][i]) << i);
}
for (int j = 0; j < v[x].size(); j++) cnt[x][bts[v[x][j]]]++;
}
int ans1;
long long ans2;
void update(int x, int t) {
if (x == ans1)
ans2 += t;
else if (x > ans1)
ans1 = x, ans2 = t;
}
char s[MAXN + 5];
int abs(int x) { return x >= 0 ? x : -x; }
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) v[s[i] - 'a'].push_back(i), clr[i] = s[i] - 'a';
for (int i = 0; i < 8; i++) get_dist(i);
for (int i = 0; i < 8; i++) get_mask(i);
ans1 = 0, ans2 = 0;
int t = (1 << 8);
for (int i = 1; i <= n; i++) {
for (int j = max(1, i - 16); j <= min(i + 16, n); j++) {
int mn = abs(i - j);
for (int k = 0; k < 8; k++) mn = min(mn, d[k][i] + 1 + d[k][j]);
cnt[clr[j]][bts[j]]--, update(mn, 1);
}
for (int j = 0; j < 8; j++) {
for (int s = 0; s < t; s++) {
int mn = MAXN + 5;
for (int k = 0; k < 8; k++)
mn = min(mn, mnd[j][k] + ((s >> k) & 1) + d[k][i] + 1);
if (cnt[j][s]) update(mn, cnt[j][s]);
}
}
for (int j = max(1, i - 16); j <= min(i + 16, n); j++)
cnt[clr[j]][bts[j]]++;
}
printf("%d %lld\n", ans1, ans2 / 2);
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int a[100500];
vector<int> gr[100500];
char res[100500];
int p[100500];
char x[100500];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int d = a[i];
for (int j = i; j >= 1; j -= d) {
if (a[j] > a[i]) {
gr[a[i]].push_back(a[j]);
}
}
for (int j = i; j <= n; j += d) {
if (a[j] > a[i]) {
gr[a[i]].push_back(a[j]);
}
}
}
for (int i = n; i >= 1; i--) {
res[i] = 'B';
for (auto v : gr[i]) {
if (res[v] == 'B') {
res[i] = 'A';
}
}
x[p[i]] = res[i];
}
for (int i = 1; i <= n; i++) {
cout << x[i];
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j, a[35005], dp[51][35005], pre[35005], last[35005];
int aint[132000], lazy[132000], pos[35005];
unordered_set<int> S;
void update(int k) {
aint[k] = max(aint[k << 1], aint[(k << 1) + 1]) + lazy[k];
if (k > 1) update(k >> 1);
}
void update_lazy(int k, int x, int y, int a, int b) {
if (x >= a && y <= b) {
lazy[k]++;
aint[k]++;
} else {
int m = (x + y) >> 1;
if (a <= m) update_lazy(k << 1, x, m, a, b);
if (b > m) update_lazy((k << 1) + 1, m + 1, y, a, b);
aint[k] = max(aint[k << 1], aint[(k << 1) + 1]) + lazy[k];
}
}
int query(int k, int x, int y, int a, int b) {
if (x >= a && y <= b)
return aint[k];
else {
int m = (x + y) >> 1, q = 0, w = 0;
if (a <= m) q = query(k << 1, x, m, a, b);
if (b > m) w = query((k << 1) + 1, m + 1, y, a, b);
return lazy[k] + max(q, w);
}
}
void build(int k, int x, int y) {
if (x == y)
pos[x] = k;
else {
int m = (x + y) >> 1;
build(k << 1, x, m);
build((k << 1) + 1, m + 1, y);
}
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
S.insert(a[i]);
dp[1][i] = S.size();
}
for (i = 1; i <= n; i++) {
pre[i] = last[a[i]];
last[a[i]] = i;
}
build(1, 1, n);
for (j = 2; j <= k; j++) {
memset(aint, 0, sizeof(aint));
memset(lazy, 0, sizeof(lazy));
S.clear();
S.insert(a[j]);
for (i = j - 1; i >= 1; i--) {
aint[pos[i]] = dp[j - 1][i] + S.size();
update(pos[i] >> 1);
S.insert(a[i]);
}
for (i = j; i <= n; i++) {
dp[j][i] = query(1, 1, n, 1, i - 1);
if (pre[i + 1] <= i - 1) update_lazy(1, 1, n, pre[i + 1], i - 1);
aint[pos[i]] = dp[j - 1][i] + 1;
update(pos[i] >> 1);
}
}
cout << dp[k][n];
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 100004;
int sum, n, aux;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &aux);
sum += aux;
}
printf("%d\n", n - 1 + (sum % n == 0));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> fac((long long int)(1e2 + 5), 1);
long long int exp(long long int a, long long int b) {
if (!b) return 1;
if (b & 1) return a * exp(a, b - 1) % (long long int)(1e9 + 7);
long long int t = exp(a, b / 2);
return t * t % (long long int)(1e9 + 7);
}
void fc() {
for (long long int i = 2; i < (long long int)(1e2 + 5); i++)
fac[i] = i * fac[i - 1] % (long long int)(1e9 + 7);
}
long long int com(long long int n, long long int r) {
return (fac[n] * exp(fac[r] * fac[n - r] % (long long int)(1e9 + 7),
(long long int)(1e9 + 7) - 2)) %
(long long int)(1e9 + 7);
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
vector<vector<long long int>> dp(n + 1, vector<long long int>(k + 1));
vector<vector<long long int>> c(n + 1, vector<long long int>(n + 1));
fc();
long long int cur = (m / n) + 1;
for (long long int i = 1; i <= n; i++) {
if ((m % n < i) && (cur == (m / n) + 1)) cur--;
for (long long int j = 0; j <= n; j++) c[i][j] = exp(com(n, j), cur);
}
dp[0][0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 0; j <= k; j++) {
for (long long int l = 0; l <= min(n, j); l++) {
dp[i][j] += dp[i - 1][j - l] * c[i][l] % (long long int)(1e9 + 7);
dp[i][j] %= (long long int)(1e9 + 7);
}
}
}
cout << dp[n][k] << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int u, n, k, x, ans = 0;
scanf("%d%d%d", &n, &k, &x);
for (int i = 0; i < n - k; ++i) {
scanf("%d", &u);
ans += u;
}
ans += k * x;
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long md = 1e9 + 7;
const int Inf = 1e9;
const long long Inf64 = 1e18;
const long long MaxN = 1e5 + 10;
const long long LogN = 25;
const long long MaxM = 5e5 + 10;
const long double eps = 1e-7;
const long long dx[4] = {0, 1, 0, -1};
const long long dy[4] = {1, 0, -1, 0};
const long long ddx[4] = {1, 1, -1, -1};
const long long ddy[4] = {1, -1, 1, -1};
const long double Pi = acos(-1);
using namespace std;
template <typename T>
istream &operator>>(istream &in, pair<T, T> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, pair<T, T> a) {
out << a.first << ' ' << a.second;
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &Mt) {
for (T &a : Mt) in >> a;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> Mt) {
for (int i = 0; i < Mt.size(); i++) {
out << Mt[i];
if (i != Mt.size()) out << ' ';
}
return out;
}
inline long long Mod(long long &a, long long m = md) {
while (a >= m) a -= m;
return a;
}
inline long long gcd(long long a, long long b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
inline long long gcdex(long long a, long long mod = md) {
long long g = mod, r = a, x = 0, y = 1;
while (r != 0) {
long long q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + mod : x;
}
inline long long binpow(long long a, long long n, long long m = md) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= m;
}
a *= a;
a %= m;
n >>= 1;
}
return res % md;
}
long long N, M, K, X;
vector<long long> Gr[MaxN];
long long dp[MaxN][3][11];
long long a[3][11], b[3][11];
void dfs(long long v, long long p = -1) {
bool ls = true;
for (long long to : Gr[v]) {
if (to == p) continue;
dfs(to, v);
ls = false;
}
long long temp = 0;
if (ls) {
dp[v][0][0] = K - 1;
dp[v][1][1] = 1;
dp[v][2][0] = M - K;
return;
}
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
a[0][0] = 1;
a[1][0] = 1;
a[2][0] = 1;
for (long long to : Gr[v]) {
if (to == p) continue;
for (int i = 0; i < 3; i++) {
for (int j = 0; j <= X; j++) {
for (int k = 0; k <= X; k++) {
if (j + k > X) continue;
if (i == 0) {
temp = dp[to][0][j] + dp[to][1][j] + dp[to][2][j];
temp %= md;
b[i][j + k] += (temp * a[i][k]) % md;
b[i][j + k] %= md;
} else if (i == 1) {
temp = dp[to][0][j];
temp %= md;
b[i][j + k] += (temp * a[i][k]) % md;
b[i][j + k] %= md;
} else {
temp = dp[to][0][j] + dp[to][2][j];
temp %= md;
b[i][j + k] += (temp * a[i][k]) % md;
b[i][j + k] %= md;
}
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j <= X; j++) {
a[i][j] = b[i][j];
b[i][j] = 0;
}
}
}
for (long long l = 0; l <= X; l++) {
dp[v][0][l] = (a[0][l] * (K - 1)) % md;
if (l >= 1) dp[v][1][l] = a[1][l - 1];
dp[v][2][l] = (a[2][l] * (M - K)) % md;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed, cout.precision(20);
{
cin >> N >> M;
for (int i = 0; i < N - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
Gr[a].push_back(b);
Gr[b].push_back(a);
}
long long Ans = 0;
cin >> K >> X;
dfs(0, -1);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 11; j++) {
Ans += dp[0][i][j];
Ans %= md;
}
}
cout << Ans;
}
END:
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(char a[2][2], char b[2][2]) {
if (a[0][0] == b[0][0] && a[0][1] == b[0][1] && a[1][0] == b[1][0] &&
a[1][1] == b[1][1])
return true;
else
return false;
}
int main() {
char a[2][2], b[2][2], ans[2][2];
int k, i, j, x, y;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
cin >> a[i][j];
ans[i][j] = a[i][j];
if (a[i][j] == 'X') {
x = i;
y = j;
}
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
cin >> b[i][j];
}
}
char t;
do {
if (x == 0 && y == 0) {
t = ans[0][0];
ans[0][0] = ans[0][1];
ans[0][1] = t;
x = 0;
y = 1;
if (cmp(b, ans)) {
cout << "YES";
return 0;
}
continue;
} else if (x == 0 && y == 1) {
t = ans[0][1];
ans[0][1] = ans[1][1];
ans[1][1] = t;
x = 1;
y = 1;
if (cmp(b, ans)) {
cout << "YES";
return 0;
}
continue;
} else if (x == 1 && y == 1) {
t = ans[1][1];
ans[1][1] = ans[1][0];
ans[1][0] = t;
x = 1;
y = 0;
if (cmp(b, ans)) {
cout << "YES";
return 0;
}
continue;
} else if (x == 1 && y == 0) {
t = ans[1][0];
ans[1][0] = ans[0][0];
ans[0][0] = t;
x = 0;
y = 0;
if (cmp(b, ans)) {
cout << "YES";
return 0;
}
continue;
}
} while (!cmp(a, ans));
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e4;
const int INF = 1e8;
int n, P, M;
int rt, son[N][2], size[N], val[N];
int dp_max[N][200], dp_min[N][200];
char s[N];
void process() {
rt = 0;
n = strlen(s);
stack<int> st;
for (int i = 0; i < n; i++) {
if (s[i] == ')') {
++rt;
son[rt][1] = st.top();
st.pop();
son[rt][0] = st.top();
st.pop();
st.push(rt);
size[rt] = size[son[rt][0]] + size[son[rt][1]] + 1;
} else if ('1' <= s[i] && s[i] <= '9') {
++rt;
val[rt] = s[i] - '0';
st.push(rt);
}
}
}
void dfs(int u) {
if (val[u]) {
dp_max[u][0] = dp_min[u][0] = val[u];
return;
}
int ls = son[u][0], rs = son[u][1];
dfs(ls);
dfs(rs);
int op_c = min(P, M);
int lb = max(0, op_c - (size[rt] - size[u]));
int ub = min(op_c, size[u]);
for (int i = lb; i <= ub; i++) {
dp_max[u][i] = -INF;
dp_min[u][i] = INF;
int lb2 = max(0, i - (size[u] - size[ls]));
int ub2 = min(i, size[ls]);
for (int j = lb2; j <= ub2; j++) {
if (P < M) {
if (i > j) {
dp_max[u][i] =
max(dp_max[u][i], dp_max[ls][j] + dp_max[rs][i - j - 1]);
dp_min[u][i] =
min(dp_min[u][i], dp_min[ls][j] + dp_min[rs][i - j - 1]);
}
if (size[u] - i > size[ls] - j) {
dp_max[u][i] = max(dp_max[u][i], dp_max[ls][j] - dp_min[rs][i - j]);
dp_min[u][i] = min(dp_min[u][i], dp_min[ls][j] - dp_max[rs][i - j]);
}
} else {
if (size[u] - i > size[ls] - j) {
dp_max[u][i] = max(dp_max[u][i], dp_max[ls][j] + dp_max[rs][i - j]);
dp_min[u][i] = min(dp_min[u][i], dp_min[ls][j] + dp_min[rs][i - j]);
}
if (i > j) {
dp_max[u][i] =
max(dp_max[u][i], dp_max[ls][j] - dp_min[rs][i - j - 1]);
dp_min[u][i] =
min(dp_min[u][i], dp_min[ls][j] - dp_max[rs][i - j - 1]);
}
}
}
}
}
int solve() {
dfs(rt);
return dp_max[rt][min(P, M)];
}
int main() {
scanf("%s %d %d", s, &P, &M);
process();
printf("%d\n", solve());
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
void FindAnsAB(const string& s, const string& t, vector<pair<int, int>>& ans) {
bool rv = false;
int n = s.size(), m = t.size();
for (int i = n - 1, j = m - 1;;) {
if (rv) {
while (i >= 0 && s[i] == 'b') --i;
while (j >= 0 && t[j] == 'a') --j;
if (i == -1 && j == -1) break;
ans.push_back({j + 1, i + 1});
rv = false;
} else {
while (i >= 0 && s[i] == 'a') --i;
while (j >= 0 && t[j] == 'b') --j;
if (i == -1 && j == -1) break;
ans.push_back({i + 1, j + 1});
rv = true;
}
}
}
void FindAnsBA(const string& s, const string& t, vector<pair<int, int>>& ans) {
bool rv = false;
int n = s.size(), m = t.size();
for (int i = n - 1, j = m - 1;;) {
if (rv) {
while (i >= 0 && s[i] == 'a') --i;
while (j >= 0 && t[j] == 'b') --j;
if (i == -1 && j == -1) break;
ans.push_back({j + 1, i + 1});
rv = false;
} else {
while (i >= 0 && s[i] == 'b') --i;
while (j >= 0 && t[j] == 'a') --j;
if (i == -1 && j == -1) break;
ans.push_back({i + 1, j + 1});
rv = true;
}
}
}
vector<pair<int, int>> Solve(string& s, string& t) {
int n = s.size(), m = t.size();
int ab1 = 0, ba1 = 0, ab2 = 0, ba2 = 0;
vector<int> vab1, vba1, vab2, vba2;
for (int i = 0; i + 1 < n; ++i) {
if (s[i] == 'a' && s[i + 1] == 'b') {
++ab1;
vab1.push_back(i);
}
if (s[i] == 'b' && s[i + 1] == 'a') {
++ba1;
vba1.push_back(i);
}
}
for (int i = 0; i + 1 < m; ++i) {
if (t[i] == 'a' && t[i + 1] == 'b') {
++ab2;
vab2.push_back(i);
}
if (t[i] == 'b' && t[i + 1] == 'a') {
++ba2;
vba2.push_back(i);
}
}
int ans = max(ab1, ba2) + max(ab2, ba1);
int t1 = -1, t2 = -1;
if (t[0] == 'a') {
for (int i = 1; i <= ab1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - (i - 1);
int diff = s.back() == t.back() && vab1[i - 1] != n - 1;
if (max(ab1left, ba2 + i - 1) + max(ba1left, ab2 + i - 1) + diff < ans) {
ans = max(ab1left, ba2 + i - 1) + max(ba1left, ab2 + i - 1) + diff;
t1 = vab1[i - 1] + 1;
t2 = 0;
}
}
for (int i = 1; i <= ba1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - i;
int diff = s.back() == t.back() && vba1[i - 1] != n - 1;
if (max(ab1left, ba2 + i) + max(ba1left, ab2 + i) + diff < ans) {
ans = max(ab1left, ba2 + i) + max(ba1left, ab2 + i) + diff;
t1 = vba1[i - 1] + 1;
t2 = 0;
}
}
for (int i = 1; i <= ab2; ++i) {
int ab2left = ab2 - i;
int ba2left = ba2 - (i - 1);
int diff = s.back() == t.back() && vab2[i - 1] != m - 1;
if (max(ab2left, ba1 + i - 1) + max(ba2left, ab1 + i - 1) + diff < ans) {
ans = max(ab2left, ba1 + i - 1) + max(ba2left, ab1 + i - 1) + diff;
t1 = 0;
t2 = vab2[i - 1] + 1;
}
}
for (int i = 1; i <= ba2; ++i) {
int ab2left = ab2 - i;
int ba2left = ba2 - i;
int diff = s.back() == t.back() && vba2[i - 1] != m - 1;
if (max(ab2left, ba1 + i) + max(ba2left, ab1 + i) + diff < ans) {
ans = max(ab2left, ba1 + i) + max(ba2left, ab1 + i) + diff;
t1 = 0;
t2 = vba2[i - 1] + 1;
}
}
for (int i = 1; i <= ab1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - (i - 1);
int j = (ba2 + i - 1 - ab1left) / 2;
if (1 <= j && j <= ba2) {
int ab2left = ab2 - j;
int ba2left = ba2 - j;
if (max(ab1left + j, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1) <
ans) {
ans = max(ab1left + j, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1);
t1 = vab1[i - 1] + 1;
t2 = vba2[j - 1] + 1;
}
}
j = (ab2 + i - ba1left) / 2;
if (1 <= j && j <= ba2) {
int ab2left = ab2 - j;
int ba2left = ba2 - j;
if (max(ab1left + j, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1) <
ans) {
ans = max(ab1left + j, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1);
t1 = vab1[i - 1] + 1;
t2 = vba2[j - 1] + 1;
}
}
}
for (int i = 1; i <= ba1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - i;
int j = (ba2 - 1 + i - ab1left) / 2;
if (1 <= j && j <= ab2) {
int ab2left = ab2 - j;
int ba2left = ba2 - (j - 1);
if (max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i) <
ans) {
ans = max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i);
t1 = vba1[i - 1] + 1;
t2 = vab2[j - 1] + 1;
}
}
j = (ab2 + i + 1 - ba1left) / 2;
if (1 <= j && j <= ab2) {
int ab2left = ab2 - j;
int ba2left = ba2 - (j - 1);
if (max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i) <
ans) {
ans = max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i);
t1 = vba1[i - 1] + 1;
t2 = vab2[j - 1] + 1;
}
}
}
} else {
for (int i = 1; i <= ab1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - (i - 1);
int diff = s.back() == t.back() && vab1[i - 1] != n - 1;
if (max(ab1left, ba2 + i - 1) + max(ba1left, ab2 + i) + diff < ans) {
ans = max(ab1left, ba2 + i - 1) + max(ba1left, ab2 + i) + diff;
t1 = vab1[i - 1] + 1;
t2 = 0;
}
}
for (int i = 1; i <= ba1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - i;
int diff = s.back() == t.back() && vba1[i - 1] != n - 1;
if (max(ab1left, ba2 + i - 1) + max(ba1left, ab2 + i) + diff < ans) {
ans = max(ab1left, ba2 + i - 1) + max(ba1left, ab2 + i) + diff;
t1 = vba1[i - 1] + 1;
t2 = 0;
}
}
for (int i = 1; i <= ab2; ++i) {
int ab2left = ab2 - i;
int ba2left = ba2 - i;
int diff = s.back() == t.back() && vab2[i - 1] != m - 1;
if (max(ab2left, ba1 + i) + max(ba2left, ab1 + i - 1) + diff < ans) {
ans = max(ab2left, ba1 + i) + max(ba2left, ab1 + i - 1) + diff;
t1 = 0;
t2 = vab2[i - 1] + 1;
}
}
for (int i = 1; i <= ba2; ++i) {
int ab2left = ab2 - (i - 1);
int ba2left = ba2 - i;
int diff = s.back() == t.back() && vba2[i - 1] != m - 1;
if (max(ab2left, ba1 + i) + max(ba2left, ab1 + i) + diff < ans) {
ans = max(ab2left, ba1 + i) + max(ba2left, ab1 + i) + diff;
t1 = 0;
t2 = vba2[i - 1] + 1;
}
}
for (int i = 1; i <= ab1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - (i - 1);
int j = (ba2 + i - ab1left) / 2;
if (1 <= j && j <= ba2) {
int ab2left = ab2 - (j - 1);
int ba2left = ba2 - j;
if (max(ab1left + j - 1, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1) <
ans) {
ans = max(ab1left + j, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1);
t1 = vab1[i - 1] + 1;
t2 = vba2[j - 1] + 1;
}
}
j = (ab2 + i + 1 - ba1left) / 2;
if (1 <= j && j <= ba2) {
int ab2left = ab2 - (j - 1);
int ba2left = ba2 - j;
if (max(ab1left + j - 1, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1) <
ans) {
ans = max(ab1left + j - 1, i - 1 + ba2left) +
max(ba1left + j - 1, ab2left + i - 1);
t1 = vab1[i - 1] + 1;
t2 = vba2[j - 1] + 1;
}
}
}
for (int i = 1; i <= ba1; ++i) {
int ab1left = ab1 - i;
int ba1left = ba1 - i;
int j = (ba2 + i - ab1left) / 2;
if (1 <= j && j <= ab2) {
int ab2left = ab2 - j;
int ba2left = ba2 - j;
if (max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i) <
ans) {
ans = max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i);
t1 = vba1[i - 1] + 1;
t2 = vab2[j - 1] + 1;
}
}
j = (ab2 + i + 1 - ba1left) / 2;
if (1 <= j && j <= ab2) {
int ab2left = ab2 - j;
int ba2left = ba2 - (j - 1);
if (max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i) <
ans) {
ans = max(ab1left + j - 1, ba2left + i - 1) +
max(ba1left + j - 1, ab2left + i);
t1 = vba1[i - 1] + 1;
t2 = vab2[j - 1] + 1;
}
}
}
}
vector<pair<int, int>> res;
if (t1 != -1) {
string sl = s.substr(0, t1), sr = s.substr(t1);
string tl = t.substr(0, t2), tr = t.substr(t2);
res.push_back({t1, t2});
s = tl + sr;
t = sl + tr;
n = s.size();
m = t.size();
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
if (s[0] == 'b') {
for (int i = 0; i < n; ++i) {
if (s[i] == 'a')
s[i] = 'b';
else
s[i] = 'a';
}
for (int i = 0; i < m; ++i) {
if (t[i] == 'a')
t[i] = 'b';
else
t[i] = 'a';
}
}
string os = s, ot = t;
s.push_back('a');
t.push_back('b');
vector<pair<int, int>> ab = Solve(s, t);
FindAnsAB(s, t, ab);
s = os, t = ot;
s.push_back('b');
t.push_back('a');
vector<pair<int, int>> ba = Solve(s, t);
FindAnsBA(s, t, ba);
if (ab.size() < ba.size()) {
cout << ab.size() << "\n";
for (auto [a, b] : ab) cout << a << " " << b << "\n";
} else {
cout << ba.size() << "\n";
for (auto [a, b] : ba) cout << a << " " << b << "\n";
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30 + 5;
int n, L;
long long a[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> L;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) a[i] = min(a[i], a[i - 1] * 2);
for (int i = n; i <= 30; i++) a[i] = a[i - 1] * 2;
long long ans = 0;
for (int mask = 0; mask <= 30; mask++) {
ans = min(ans, a[mask]);
if (L & (1 << mask)) {
ans += a[mask];
L ^= (1 << mask);
}
}
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
multiset<pair<pair<long long, int>, long long> > ms;
int dfs(int i, int p, vector<vector<pair<int, pair<long long, int> > > > &adj) {
int cnt = 0;
if (adj[i].size() == 1 && adj[i][0].first == p) {
return 1;
}
for (auto ch : adj[i]) {
if (ch.first != p) {
int temp = dfs(ch.first, i, adj);
ms.insert({ch.second, temp});
cnt += temp;
}
}
return cnt;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long s;
cin >> s;
vector<vector<pair<int, pair<long long, int> > > > adj(n);
int a, b, c;
long long w;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b >> w >> c;
a--, b--;
adj[a].push_back({b, {w, c}});
adj[b].push_back({a, {w, c}});
}
vector<int> sz(n);
ms.clear();
dfs(0, -1, adj);
priority_queue<pair<long long, pair<long long, int> > > pq;
priority_queue<pair<long long, pair<long long, int> > > pq1;
long long t_sum = 0;
long long t_sum1 = 0;
for (auto ele : ms) {
if (ele.first.second == 1) {
t_sum += ele.first.first * ele.second;
pq.push({((ele.first.first + 1) / 2) * ele.second,
{ele.first.first / 2, ele.second}});
} else {
t_sum1 += ele.first.first * ele.second;
pq1.push({((ele.first.first + 1) / 2) * ele.second,
{ele.first.first / 2, ele.second}});
}
}
vector<long long> v, v1;
v.push_back(t_sum);
v1.push_back(t_sum1);
while (t_sum) {
auto pr = pq.top();
pq.pop();
t_sum -= pr.first;
v.push_back(t_sum);
long long val = pr.second.first;
long long x = pr.second.second;
pq.push({((val + 1) / 2) * x, {val / 2, x}});
}
while (t_sum1) {
auto pr = pq1.top();
pq1.pop();
t_sum1 -= pr.first;
v1.push_back(t_sum1);
long long val = pr.second.first;
long long x = pr.second.second;
pq1.push({((val + 1) / 2) * x, {val / 2, x}});
}
int i = 0, j = v1.size() - 1;
int mi = 1e9;
for (int i = 0; i < v.size(); i++) {
if (v[i] <= s) {
while (j >= 0 && v[i] + v1[j] <= s) {
j--;
}
j++;
if (v1[j] + v[i] <= s) mi = min(mi, i + 2 * j);
}
}
cout << mi << endl;
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 41, M = 1 << 7;
int dp[MAXN][M][M], n, m;
bool can[MAXN][M][M];
bool ch(int l, int mid, int r) {
for (int i = 0; i < m; i++) {
if (((l >> i) & 1) || ((mid >> i) & 1) || ((r >> i) & 1)) continue;
if (i > 0 && ((mid >> (i - 1)) & 1)) continue;
if (i < m - 1 && ((mid >> (i + 1)) & 1)) continue;
return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (n < m) swap(n, m);
for (int mask = 0; mask < (1 << m); mask++) can[0][0][mask] = true;
for (int i = 1; i <= n; i++)
for (int maski = 0; maski < (1 << m); maski++)
for (int mask1 = 0; mask1 < (1 << m); mask1++) {
dp[i][maski][mask1] = INT_MAX;
for (int mask = 0; mask < (1 << m); mask++) {
if (!can[i - 1][mask][maski] || !ch(mask, maski, mask1)) continue;
can[i][maski][mask1] = true;
dp[i][maski][mask1] =
min(dp[i][maski][mask1],
__builtin_popcount(maski) + dp[i - 1][mask][maski]);
}
}
int ans = INT_MAX;
for (int mask = 0; mask < (1 << m); mask++) ans = min(ans, dp[n][mask][0]);
cout << max(0, (n * m) - ans) << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100010], str1[100010];
vector<char> vec;
vector<char> vec1;
vector<char>::iterator it;
long i, j, k;
while (gets(str)) {
gets(str1);
vec.assign(str, str + strlen(str));
vec1.assign(str1, str1 + strlen(str1));
sort(vec1.begin(), vec1.end());
reverse(vec1.begin(), vec1.end());
i = j = 0;
while (1) {
if (vec1[i] > vec[j]) {
vec[j] = vec1[i];
j++;
i++;
} else
j++;
if (vec.size() == j || vec1.size() == i) break;
}
for (i = 0; i < vec.size(); i++) printf("%c", vec[i]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char second[1009];
int n, l, i, j, k, n_pr, n_t, maxi, max_n;
int a[1009], pr[1009], d[1009];
pair<char, int> c[1009];
bool p[1009], u[1009];
bool cmp(pair<char, int> a, pair<char, int> b) { return a.second > b.second; }
int find() {
for (int i = 1; i <= n_t; i++)
if (!u[i]) return i;
return -1;
}
int main() {
gets(second);
n = strlen(second);
for (i = 0; i < n; i++) {
bool T = 0;
for (j = 0; j < l; j++) {
if (c[j].first == second[i]) {
T = 1;
c[j].second++;
}
}
if (!T) {
c[l++] = make_pair(second[i], 1);
}
}
sort(c, c + l, cmp);
memset(p, 1, sizeof(p));
p[1] = 0;
for (i = 2; i <= n; i++) {
if (p[i]) {
for (j = i + i; j <= n; j += i) p[j] = 0;
pr[n_pr++] = i;
}
}
for (i = 1; i <= n; i++) {
if (p[i] == 0 && a[i] == 0) {
a[i] = ++n_t;
d[n_t]++;
} else if (p[i] == 1 && a[i] == 0) {
int k = 0;
for (j = i; j <= n; j += i)
if (a[j] != 0) {
k = a[j];
break;
}
if (k == 0) k = ++n_t;
for (j = i; j <= n; j += i)
if (!a[j]) {
a[j] = k;
d[k]++;
}
if (maxi < d[k]) {
maxi = d[k];
max_n = k;
}
}
}
int fl = n;
if (maxi > c[0].second) {
puts("NO");
return 0;
}
puts("YES");
char s1[1009] = "";
int l = 0;
j = 0;
while (fl > 0) {
for (i = 0; i < n; i++) {
if (a[i + 1] == max_n) {
s1[i] = c[j].first;
c[j].second--;
fl--;
}
}
u[max_n] = 1;
max_n = find();
if (c[j].second == 0) j++;
}
for (i = 0; i < n; i++) printf("%c", s1[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 3e5 + 1000, N = 3e5 + 1000;
vector<pair<int, int> > so[M], sol[M];
set<int> s;
long long n, w, h, q = 1e5, r[N], o, p, t[M], x[N], y[N], xp[N], yp[N], l,
e = 0, d = 0, rd[N], pd[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
std::set<int>::iterator it, id;
cin >> n >> w >> h;
p = 0;
for (int i = 1; i <= n; i++) {
cin >> rd[i] >> pd[i] >> t[i];
t[i] -= pd[i];
t[i] += q;
if (rd[i] == 2) {
x[i] = w;
y[i] = pd[i];
so[t[i]].push_back({y[i], i});
} else {
x[i] = pd[i];
y[i] = h;
sol[t[i]].push_back({x[i], i});
}
s.insert(t[i]);
xp[i] = x[i];
yp[i] = y[i];
}
it = s.begin();
for (int j = 0; j < s.size(); j++) {
sort(so[*it].begin(), so[*it].end());
sort(sol[*it].begin(), sol[*it].end());
o = so[*it].size();
p = sol[*it].size();
if (o == 0 || p == 0) {
++it;
continue;
}
if (o > p) {
for (int g = 0; g < o; g++) {
if (g < o - p) {
l = so[*it][g].second;
e = so[*it][p + g].second;
xp[l] = x[e];
yp[l] = y[e];
} else {
l = so[*it][g].second;
e = sol[*it][o - g - 1].second;
xp[l] = x[e];
yp[l] = y[e];
l = sol[*it][g - o + p].second;
e = so[*it][o - g - 1].second;
xp[l] = x[e];
yp[l] = y[e];
}
}
} else if (o < p) {
for (int g = 0; g < p; g++) {
if (g < p - o) {
l = sol[*it][g].second;
e = sol[*it][g + o].second;
xp[l] = x[e];
yp[l] = y[e];
} else {
l = sol[*it][g].second;
e = so[*it][p - g - 1].second;
xp[l] = x[e];
yp[l] = y[e];
l = so[*it][g - p + o].second;
e = sol[*it][p - g - 1].second;
xp[l] = x[e];
yp[l] = y[e];
}
}
} else if (o == p) {
for (int g = 0; g < o; g++) {
l = so[*it][g].second;
e = sol[*it][o - g - 1].second;
xp[l] = x[e];
yp[l] = y[e];
l = sol[*it][g].second;
e = so[*it][o - g - 1].second;
xp[l] = x[e];
yp[l] = y[e];
}
}
++it;
}
for (int i = 1; i <= n; i++) {
cout << xp[i] << ' ' << yp[i] << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long ans = (n / 5) * (m / 5);
for (int i = 1; i <= 4; i++) {
long long k1 = (n + 5 - i) / 5;
long long k2 = (m + i) / 5;
ans += 1ll * k1 * k2;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
double pi = 3.1415926535897;
double dp[1 << maxn];
int n, L, R;
int lp[maxn], rp[maxn];
int ang[maxn];
int main() {
cin >> n >> L >> R;
for (int i = 0; i < n; i++) {
cin >> lp[i] >> rp[i] >> ang[i];
}
double ans = L;
int sN = (1 << n);
for (int i = 0; i < sN; i++) dp[i] = L;
for (int i = 0; i < sN; i++) {
double cur = dp[i];
if (ans < cur) ans = cur;
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
double a = lp[j], b = rp[j], angle = ang[j];
angle *= pi;
angle /= 180.0;
angle += atan((cur - a) / b);
double nxt = a + b * tan(angle);
if (nxt < cur || nxt > R) {
nxt = R;
}
int ij = i + (1 << j);
if (dp[ij] < nxt) dp[ij] = nxt;
}
}
}
ans -= L;
printf("%.9lf\n", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct bit {
int v[200000];
bit() { memset(v, 0, sizeof v); }
int query(int p) {
int resp = 0;
for (int i = p; i > 0; i -= (i & (-i))) resp = max(resp, v[i]);
return resp;
}
void set(int p, int val) {
for (int i = p; i < 200000; i += (i & (-i))) v[i] = max(val, v[i]);
}
};
int main() {
scanf("%d", &n);
bit bt;
int resp = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
bt.set(x, bt.query(x - 1) + 1);
}
printf("%d\n", bt.query(150000));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 2;
int a[maxn], b[maxn * maxn], c[maxn * maxn], dem = 0, ans = 0;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
b[dem] = a[i] + a[j];
c[b[dem]]++;
ans = max(ans, c[b[dem]]);
dem++;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x;
int y;
};
point dates[500005];
bool cmp(point a, point b) {
if (a.y < b.y) {
return true;
}
if (a.y == b.y) {
return a.x < b.x;
}
return false;
}
int main() {
cin.sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> dates[i].x >> dates[i].y;
}
sort(dates, dates + n, cmp);
int var = dates[0].y;
int ans = 1;
for (int i = 1; i < n; i++) {
if (dates[i].x > var) {
ans++;
var = dates[i].y;
}
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int INF = 0x3f3f3f3f;
const long long mod = 998244353;
const double PI = acos(-1.0);
int main() {
std::ios::sync_with_stdio(false);
int T;
while (cin >> T) {
while (T--) {
int n;
cin >> n;
n = n * 2;
int ans = INF;
for (int i = 1; i <= 360; ++i) {
if (n % i == 0) {
if (360 % (n / i) == 0) {
if (360 / (n / i) - i > 1) ans = min(ans, 360 / (n / i));
}
}
}
cout << ans << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr1[107], arr2[107];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) cin >> arr1[i];
for (int i = 0; i <= m; i++) cin >> arr2[i];
int a = arr1[0], b = arr2[0];
if (n < m)
cout << "0/1\n";
else if (n > m) {
bool f = 0;
if ((a < 0 && b > 0) || (a > 0 && b < 0)) f = 1;
if (f)
cout << "-Infinity\n";
else
cout << "Infinity\n";
} else {
int k = gcd(max(a, b), min(a, b));
int tmp = a / k, tmp1 = b / k;
if (tmp1 < 0) tmp *= -1;
cout << tmp << "/" << abs(tmp1) << "\n";
}
return 0;
}
| 6 |
// #pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define dd double
#define ld long double
#define sl(n) scanf("%lld", &n)
#define si(n) scanf("%d", &n)
#define sd(n) scanf("%lf", &n)
#define pll pair <ll, ll>
#define pii pair <int, int>
#define mp make_pair
#define pb push_back
#define all(v) v.begin(), v.end()
#define inf (1LL << 61)
#define loop(i, start, stop, inc) for(ll i = start; i <= stop; i += inc)
#define for1(i, stop) for(ll i = 1; i <= stop; ++i)
#define for0(i, stop) for(ll i = 0; i < stop; ++i)
#define rep1(i, start) for(ll i = start; i >= 1; --i)
#define rep0(i, start) for(ll i = (start-1); i >= 0; --i)
#define ms(n, i) memset(n, i, sizeof(n))
#define casep(n) printf("Case %lld:", ++n)
#define pn printf("\n")
#define pf printf
#define EL '\n'
#define fastio std::ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
// === Debug macro starts here ===
#ifndef ONLINE_JUDGE
#define DEBUG
#define SYS_COL system("COLOR")
#endif
int recur_depth = 0;
#ifdef DEBUG
#define dbg(x) {++recur_depth; auto x_=x; --recur_depth; SYS_COL; cerr<<string(recur_depth, '\t')<<"\e[91m"<<__func__<<":"<<__LINE__<<"\t"<<#x<<" = "<<x_<<"\e[39m"<<endl;}
template<typename Ostream, typename Cont>
typename enable_if<is_same<Ostream,ostream>::value, Ostream&>::type operator<<(Ostream& os, const Cont& v){
os<<"[";
for(auto& x:v){os<<x<<", ";}
return os<<"]";
}
template<typename Ostream, typename ...Ts>
Ostream& operator<<(Ostream& os, const pair<Ts...>& p){
return os<<"{"<<p.first<<", "<<p.second<<"}";
}
#else
#define dbg(x)
#endif
// === Debug macro ends here ===
#define ff first
#define ss second
int main()
{
vector <pii> lst;
ll n, ans = 0; cin >> n;
for1(i, n) {
ll a, c;
sl(a), sl(c);
ans += c;
lst.pb({a, c});
}
sort(all(lst));
ll mx = max(0, lst[0].ff + lst[0].ss);
for1(i, lst.size()-1) {
ans += max(0LL, lst[i].ff-mx);
mx = max(mx, (ll)lst[i].ff + lst[i].ss);
}
cout << ans << EL;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a[n + 1][n + 1];
long long cost[n + 1][n + 1];
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) {
cin >> a[i][j];
cost[i][j] = -a[i][j];
}
for (long long j = 1; j <= n; j++) {
long long res = 0;
for (long long i = 0; j + i <= n; i++) res += a[i + 1][j + i];
for (long long i = 0; j + i <= n; i++) cost[i + 1][j + i] += res;
}
for (long long i = 2; i <= n; i++) {
long long res = 0;
for (long long j = i; j <= n; j++) res += a[j][j - i + 1];
for (long long j = i; j <= n; j++) cost[j][j - i + 1] += res;
}
for (long long j = n; j >= 1; j--) {
long long res = 0;
for (long long i = 0; j - i >= 1; i++) res += a[i + 1][j - i];
for (long long i = 0; j - i >= 1; i++) cost[i + 1][j - i] += res;
}
for (long long i = 2; i <= n; i++) {
long long res = 0;
for (long long j = i; j <= n; j++) res += a[j][n - j + i];
for (long long j = i; j <= n; j++) cost[j][n - j + i] += res;
}
long long resodd = -1;
long long reseven = -1;
long long xodd, yodd, xeven, yeven;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
if ((i + j) & 1 && cost[i][j] > resodd) {
resodd = cost[i][j];
xodd = i;
yodd = j;
}
if ((i + j) % 2 == 0 && cost[i][j] > reseven) {
reseven = cost[i][j];
xeven = i;
yeven = j;
}
}
}
cout << reseven + resodd << '\n';
cout << xodd << " " << yodd << " " << xeven << " " << yeven << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct arr {
int a[9];
arr() { memset(a, 0, sizeof a); }
void out(int k) {
if (k > 1000) return;
printf("%d =", k);
for (int i = 0; i < 9; i++) printf(" %d", a[i]);
puts("");
}
bool chk() {
if (a[0] == 3 && a[1] == 0 && a[2] == 2 && a[3] == 3 && a[4] == 0 &&
a[5] == -1 && a[6] == 4 && a[7] == 1 && a[8] == 0)
return true;
return false;
}
} beg;
struct classcomp {
bool operator()(arr a, arr b) const {
for (int i = 0; i < 9; i++)
if (a.a[i] != b.a[i]) return a.a[i] < b.a[i];
return false;
}
};
set<arr, classcomp> a;
int pos[5], step[5], grab[5], ans, tot;
bool f;
void dfs(arr now) {
if (a.find(now) != a.end()) return;
ans = max(ans, max(max(now.a[0], now.a[3]), now.a[6]));
a.insert(now);
arr next = now;
if (now.a[5] != 1 && now.a[8] != 1) {
if (!now.a[1] && now.a[2] <= 0) {
for (int i = max(1, now.a[0] - step[1]); i <= now.a[0] + step[1]; i++)
if (now.a[3] != i && now.a[6] != i) {
next.a[1] = 1;
next.a[0] = i;
if (now.a[2] == 2) {
next.a[3] = i;
if (now.a[5] == 3) next.a[6] = i;
} else if (now.a[2] == 3) {
next.a[6] = i;
if (now.a[8] == 2) next.a[3] = i;
}
dfs(next);
next.a[1] = 0;
next.a[0] = now.a[0];
next.a[3] = now.a[3];
next.a[6] = now.a[6];
}
}
if (!now.a[2]) {
if ((now.a[3] == now.a[0] - 1 || now.a[3] == now.a[0] + 1) &&
(now.a[8] != 2)) {
next.a[2] = 2;
next.a[3] = now.a[0];
if (now.a[5] == 3) next.a[6] = now.a[0];
dfs(next);
next.a[2] = 0;
next.a[3] = now.a[3];
next.a[6] = now.a[6];
}
if ((now.a[6] == now.a[0] - 1 || now.a[6] == now.a[0] + 1) &&
(now.a[5] != 3)) {
next.a[2] = 3;
next.a[6] = now.a[0];
if (now.a[8] == 2) next.a[3] = now.a[0];
dfs(next);
next.a[2] = 0;
next.a[6] = now.a[6];
next.a[3] = now.a[3];
}
} else if (now.a[2] == 2) {
for (int i = max(1, now.a[0] - grab[1]); i <= now.a[0] + grab[1]; i++)
if (now.a[0] != i && now.a[6] != i) {
next.a[3] = i;
next.a[2] = -1;
if (now.a[5] == 3) next.a[6] = i;
dfs(next);
next.a[2] = now.a[2];
next.a[3] = now.a[3];
next.a[6] = now.a[6];
}
} else if (now.a[2] == 3) {
for (int i = max(1, now.a[0] - grab[1]); i <= now.a[0] + grab[1]; i++)
if (now.a[0] != i && now.a[3] != i) {
next.a[6] = i;
next.a[2] = -1;
if (now.a[8] == 2) next.a[3] = i;
dfs(next);
next.a[2] = 3;
next.a[3] = now.a[3];
next.a[6] = now.a[6];
}
}
}
if (now.a[2] != 2 && now.a[8] != 2) {
if (!now.a[4] && now.a[5] <= 0) {
for (int i = max(1, now.a[3] - step[2]); i <= now.a[3] + step[2]; i++)
if (now.a[0] != i && now.a[6] != i) {
next.a[4] = 1;
next.a[3] = i;
if (now.a[5] == 1) {
next.a[0] = i;
if (now.a[2] == 3) next.a[6] = i;
} else if (now.a[5] == 3) {
next.a[6] = i;
if (now.a[8] == 1) next.a[0] = i;
}
dfs(next);
next.a[4] = 0;
next.a[3] = now.a[3];
next.a[6] = now.a[6];
next.a[0] = now.a[0];
}
}
if (!now.a[5]) {
if ((now.a[0] == now.a[3] - 1 || now.a[0] == now.a[3] + 1) &&
now.a[8] != 1) {
next.a[5] = 1;
next.a[0] = now.a[3];
if (now.a[2] == 3) next.a[6] = now.a[3];
dfs(next);
next.a[5] = 0;
next.a[0] = now.a[0];
next.a[6] = now.a[6];
}
if ((now.a[6] == now.a[3] - 1 || now.a[6] == now.a[3] + 1) &&
now.a[2] != 3) {
next.a[5] = 3;
next.a[6] = now.a[3];
if (now.a[8] == 1) next.a[0] = now.a[3];
dfs(next);
next.a[5] = 0;
next.a[6] = now.a[6];
next.a[0] = now.a[0];
}
} else if (now.a[5] == 1) {
for (int i = max(1, now.a[3] - grab[2]); i <= now.a[3] + grab[2]; i++)
if (now.a[3] != i && now.a[6] != i) {
next.a[0] = i;
next.a[5] = -1;
if (now.a[2] == 3) next.a[6] = i;
dfs(next);
next.a[6] = now.a[6];
next.a[5] = now.a[5];
next.a[0] = now.a[0];
}
} else if (now.a[5] == 3) {
for (int i = max(1, now.a[3] - grab[2]); i <= now.a[3] + grab[2]; i++)
if (now.a[0] != i && now.a[3] != i) {
next.a[6] = i;
next.a[5] = -1;
if (now.a[8] == 1) next.a[0] = i;
dfs(next);
next.a[5] = now.a[5];
next.a[6] = now.a[6];
next.a[0] = now.a[0];
}
}
}
if (now.a[2] != 3 && now.a[5] != 3) {
if (!now.a[7] && now.a[8] <= 0) {
for (int i = max(1, now.a[6] - step[3]); i <= now.a[6] + step[3]; i++)
if (now.a[0] != i && now.a[3] != i) {
next.a[7] = 1;
next.a[6] = i;
if (now.a[8] == 1) {
next.a[0] = i;
if (now.a[2] == 2) next.a[3] = i;
} else if (now.a[8] == 2) {
next.a[3] = i;
if (now.a[5] == 1) next.a[0] = i;
}
dfs(next);
next.a[7] = 0;
next.a[6] = now.a[6];
next.a[0] = now.a[0];
next.a[3] = now.a[3];
}
}
if (!now.a[8]) {
if ((now.a[0] == now.a[6] - 1 || now.a[0] == now.a[6] + 1) &&
now.a[5] != 1) {
next.a[8] = 1;
next.a[0] = now.a[6];
if (now.a[2] == 2) next.a[3] = now.a[6];
dfs(next);
next.a[8] = 0;
next.a[0] = now.a[0];
next.a[3] = now.a[3];
}
if ((now.a[3] == now.a[6] - 1 || now.a[3] == now.a[6] + 1) &&
now.a[2] != 2) {
next.a[8] = 2;
next.a[3] = now.a[6];
if (now.a[5] == 1) next.a[0] = now.a[6];
dfs(next);
next.a[8] = 0;
next.a[3] = now.a[3];
next.a[0] = now.a[0];
}
} else if (now.a[8] == 1) {
for (int i = max(1, now.a[6] - grab[3]); i <= now.a[6] + grab[3]; i++)
if (now.a[3] != i && now.a[6] != i) {
next.a[0] = i;
next.a[8] = -1;
if (now.a[2] == 2) next.a[3] = i;
dfs(next);
next.a[0] = now.a[0];
next.a[3] = now.a[3];
next.a[8] = now.a[8];
}
} else if (now.a[8] == 2) {
for (int i = max(1, now.a[6] - grab[3]); i <= now.a[6] + grab[3]; i++)
if (now.a[0] != i && now.a[3] != i) {
next.a[3] = i;
next.a[8] = -1;
if (now.a[5] == 1) next.a[0] = i;
dfs(next);
next.a[8] = 2;
next.a[0] = now.a[0];
next.a[3] = now.a[3];
}
}
}
}
int main() {
for (int i = 1; i <= 3; i++) cin >> pos[i] >> step[i] >> grab[i];
beg.a[0] = pos[1];
beg.a[3] = pos[2];
beg.a[6] = pos[3];
dfs(beg);
printf("%d\n", ans);
return 0;
}
| 17 |
#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;
void test() {
int n, it;
long long int w;
cin >> n >> w;
long long int half = (w + 1) / 2;
vector<pair<int, int>> item;
item.resize(n);
for (int i = 0; i < n; ++i) {
cin >> it;
item[i] = make_pair(it, i + 1);
}
sort(item.rbegin(), item.rend());
long long int sum = 0;
vector<int> ans;
bool ok = 0;
for (int i = 0; i < n; ++i) {
it = item[i].first;
if (it >= half) {
if (it > w) {
continue;
}
ans.push_back(item[i].second);
ok = 1;
break;
} else {
sum += (long long)it;
ans.push_back(item[i].second);
if (sum >= half) {
ok = 1;
break;
}
}
}
if (ok) {
int s = ans.size();
cout << s << '\n';
for (int i = 0; i < s; ++i) {
cout << ans[i] << ' ';
}
} else {
cout << -1;
}
cout << '\n';
}
int main() {
int t;
cin >> t;
while (t--) {
test();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
string s;
cin >> n >> s;
int x = count(s.begin(), s.end(), '(');
if (x != n - x) {
cout << "-1\n";
return 0;
}
vector<int> l, r;
int ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
l.push_back(i);
} else {
if (l.empty()) {
r.push_back(i);
} else {
l.pop_back();
}
}
if (!r.empty() && l.size() >= r.size()) {
ans += l.back() - r.front() + 1;
while (!l.empty()) l.pop_back();
while (!r.empty()) r.pop_back();
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1009][109][2];
long long mod10n[1009];
long long m, n, k;
long long f(int digitCount, int modk, int suff, int digit) {
if (digitCount == n) {
if (digit == 0) return 0;
return suff;
}
if (dp[digitCount][modk][suff] != -1) return dp[digitCount][modk][suff];
long long ans = 0;
for (int i = 0; i < 10; i++) {
int newK = (modk + mod10n[digitCount] * i) % k;
int newS = suff;
if (newK == 0 && i != 0) newS = 1;
ans = (ans + f(digitCount + 1, newK, newS, i)) % m;
}
return dp[digitCount][modk][suff] = ans % m;
}
int main() {
cin >> n >> k >> m;
for (int i = 0; i < 1009; i++) {
for (int j = 0; j < 109; j++) {
dp[i][j][0] = dp[i][j][1] = -1;
}
}
mod10n[0] = 1;
for (int i = 1; i < 1009; i++) {
mod10n[i] = (mod10n[i - 1] * 10) % k;
}
cout << f(0, 0, 0, 0) % m << endl;
;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int n;
double a, d;
double t[111111], v[111111];
double get_time(double v) {
double x = v * v / (2 * a);
if (x >= d)
return sqrt(2 * d / a);
else
return v / a + (d - x) / v;
}
int main() {
scanf("%d%lf%lf", &n, &a, &d);
for (int i = 0; i < n; ++i) scanf("%lf%lf", &t[i], &v[i]);
for (int i = 0; i < n; ++i) {
t[i] += get_time(v[i]);
if (i > 0) t[i] = max(t[i], t[i - 1]);
}
for (int i = 0; i < n; ++i) printf("%.10lf\n", t[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 55;
long long sum[N << 2];
long long cnt[N << 2];
void PushUp(long long rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
cnt[rt] = cnt[rt << 1] + cnt[rt << 1 | 1];
}
void upedit(long long L, long long R, long long c, long long l, long long r,
long long rt) {
if (L <= l && r <= R) {
sum[rt] += c * l;
cnt[rt] += c;
return;
}
long long m = (l + r) >> 1;
if (L <= m) upedit(L, R, c, l, m, rt << 1);
if (m < R) upedit(L, R, c, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long ans = 0;
void gao(int l, int r, long long rt, long long ff) {
if (l == r) {
ans += ff * l;
return;
}
long long m = (l + r) >> 1;
if (cnt[rt << 1] >= ff)
gao(l, m, rt << 1, ff);
else {
ans += sum[rt << 1];
gao(m + 1, r, rt << 1 | 1, ff - cnt[rt << 1]);
}
return;
}
struct node {
long long tim;
long long v, cnt, fg;
bool friend operator<(node a, node b) { return a.tim > b.tim; }
};
priority_queue<node> q;
int main() {
long long n, m, k, l, r, c, p;
scanf("%lld%lld%lld", &n, &k, &m);
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld%lld%lld", &l, &r, &c, &p);
q.push({l, p, c, 1});
q.push({r + 1, p, c, -1});
}
for (long long i = 1; i <= n; i++) {
while (!q.empty() && q.top().tim <= i) {
node p = q.top();
upedit(p.v, p.v, p.cnt * p.fg, 1, 1e6, 1);
q.pop();
}
gao(1, 1e6, 1, min(k, cnt[1]));
}
printf("%lld\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int arr[122] = {0}, x;
while (a--) {
cin >> x;
arr[x] = 1;
}
while (b--) {
cin >> x;
}
for (int i = 1; i <= n; i++) {
if (arr[i] == 1) {
cout << "1 ";
} else {
cout << "2 ";
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct s {
int id;
long long int x;
} a[200005];
int pos[200005];
int cmp(const s &a, const s &b) { return a.x > b.x; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
long long int w;
int cnt = 0;
scanf("%d %lld", &n, &w);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i].x);
a[i].id = i;
}
sort(a + 1, a + 1 + n, cmp);
long long int sum = 0;
for (int i = 1; i <= n; i++) {
if (sum + a[i].x <= w) {
sum += a[i].x;
pos[cnt++] = a[i].id;
}
}
if (sum < (w + 1) / 2)
printf("-1");
else {
sort(pos, pos + cnt);
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) printf("%d ", pos[i]);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
void fast() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
char grid[100][100];
vector<pair<int, int>> edg;
bool vis[50][50];
int n, m;
void dfs(int x, int y) {
vis[x][y] = 1;
for (int i = 0; i < 4; i++) {
int u = dx[i] + x, v = dy[i] + y;
if (u < 0 || v < 0 || u == n || v == m || grid[u][v] == '.' || vis[u][v])
continue;
dfs(u, v);
}
}
int main() {
fast();
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
if (grid[i][j] == '#') edg.push_back({i, j});
}
}
for (auto x : edg) {
memset(vis, 0, sizeof vis);
int cnt = 0;
grid[x.first][x.second] = '.';
for (auto v : edg) {
if (v.first == x.first && v.second == x.second) continue;
if (vis[v.first][v.second]) continue;
cnt++;
dfs(v.first, v.second);
}
if (cnt > 1) return cout << 1 << "\n", 0;
;
grid[x.first][x.second] = '#';
}
if (edg.size() <= 2) return cout << -1 << "\n", 0;
;
return cout << 2 << "\n", 0;
;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void update(int64_t &A, int64_t B) {
if (A > B) A = B;
}
int64_t dp[2][500][500][2];
vector<pair<int, int>> robot[500][500];
bitset<500000> good[4];
int d[500000], e[500000];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> dx = {0, 1, 1, 0}, dy = {0, -1, 0, 1};
int cap = max(m, n);
for (int i = 0; i < k; i++) {
int x, y, t;
cin >> x >> y >> d[i] >> t >> e[i];
for (int zi = 0; zi < 4; zi++) {
int nx = x + dx[zi] * d[i], ny = y + dy[zi] * d[i];
if (zi + t <= nx + ny && (zi + t) % 4 == (nx + ny) % 4) {
robot[nx][ny].push_back({i, zi});
good[zi].set(i);
}
}
}
for (int X = 0; X < 2; ++X)
for (int Y = 0; Y < m; ++Y)
for (int W = 0; W < cap; ++W)
for (int vert = 0; vert < 2; ++vert) dp[X][Y][W][vert] = LLONG_MAX;
dp[0][0][0][0] = dp[0][0][0][1] = 0;
int64_t ans = LLONG_MAX;
for (int X = 0; X < n; ++X) {
int cur = X & 1;
int nxt = 1 - cur;
for (int Y = 0; Y < m; ++Y) {
for (int W = 0; W < cap; ++W) {
for (int vert = 0; vert < 2; vert++) {
if (W > (vert ? X : Y) || dp[cur][Y][W][vert] == LLONG_MAX) break;
if (Y < m - 1) {
int right = (vert ? 0 : W) + 1;
int64_t smash = 0;
for (auto &[id, zi] : robot[X][Y + 1]) {
if (zi == 2 && right >= d[id] && good[1][id]) continue;
if (zi == 3 && right >= d[id] && good[0][id]) continue;
smash += e[id];
}
update(dp[cur][Y + 1][right][0], dp[cur][Y][W][vert] + smash);
update(dp[cur][Y + 1][0][1], dp[cur][Y][W][vert] + smash);
}
if (X < n - 1) {
int down = (vert ? W : 0) + 1;
int64_t smash = 0;
for (auto &[id, zi] : robot[X + 1][Y]) {
if (zi == 2 && down >= d[id] && good[0][id]) continue;
smash += e[id];
}
update(dp[nxt][Y][down][1], dp[cur][Y][W][vert] + smash);
update(dp[nxt][Y][0][0], dp[cur][Y][W][vert] + smash);
}
}
}
}
if (X == n - 1) {
for (int W = 0; W < cap; ++W)
for (int vert = 0; vert < 2; ++vert)
update(ans, dp[cur][m - 1][W][vert]);
break;
}
for (int Y = 0; Y < m; ++Y)
for (int W = 0; W < cap; ++W)
for (int vert = 0; vert < 2; ++vert) dp[cur][Y][W][vert] = LLONG_MAX;
}
cout << ans;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int cnt[150];
int main() {
int v1, v2;
cin >> v1 >> v2;
int t, d;
cin >> t >> d;
int ans = v1;
int temp = v2;
for (int i = t - 1; i >= 2; i--) {
temp = temp + d;
int temp1 = v1 + d * (i - 1);
int best = min(temp, temp1);
ans += best;
}
cout << ans + v2;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long fast_pow(long long x, long long p, long long P) {
if (p == 0) return 1;
long long res = fast_pow(x, p / 2, P);
if (p & 1)
return (res * res * x) % P;
else
return (res * res) % P;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long p, ans = 0;
cin >> p;
for (long long x = 1; x < p; x++) {
bool b = true;
for (long long i = 1; i <= p - 2; i++)
if ((fast_pow(x, i, p) - 1) % p == 0) b = false;
if (b && (fast_pow(x, p - 1, p) - 1) % p == 0) ans++;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 10;
const long long INF = 1e18;
long long n;
int m;
long long a[MAXN];
long long v[100];
long long cnt[100];
bool vis[100];
map<long long, int> mpa;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
v[0] = 1;
mpa[1] = 0;
for (int i = 1; i <= 60; i++) {
v[i] = 2 * v[i - 1];
mpa[v[i]] = i;
}
while (t--) {
memset(vis, 0, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> a[i], cnt[mpa[a[i]]]++;
sort(a + 1, a + 1 + m);
for (int i = 60; i >= 0; i--) {
if (n >= v[i]) {
n -= v[i];
vis[i] = 1;
}
}
bool flag = true;
int ans = 0;
for (int i = 0; i <= 60; i++) {
if (vis[i]) {
if (cnt[i] > 0)
cnt[i]--;
else {
bool is = false;
for (int j = i + 1; j <= 60; j++) {
if (cnt[j] > 0) {
ans += j - i;
cnt[j]--;
for (int k = i; k < j; k++) cnt[k]++;
is = true;
break;
}
}
if (!is) flag = false;
}
}
cnt[i + 1] += cnt[i] / 2;
}
cout << (flag ? ans : -1) << "\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int s[6];
int main(void) {
int i, x, ans;
for (i = 1; i <= 5; i++) {
scanf("%d", &x);
s[i] = 500 * i * (250 - x) / 250;
}
ans = 0;
for (i = 1; i <= 5; i++) {
scanf("%d", &x);
s[i] -= 50 * x;
s[i] = max(150 * i, s[i]);
ans += s[i];
}
scanf("%d", &x);
ans += x * 100;
scanf("%d", &x);
ans -= x * 50;
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2750131;
int a[MX + 111], grdiv[MX + 110], isp[MX + 111], cnt[MX + 111];
int pr[MX + 111];
bool P(int n) { return !isp[n]; }
int Gr(int n) {
vector<int> v;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
v.push_back(i);
}
}
if (n > 1) v.push_back(n);
sort(v.begin(), v.end());
int ret = 1;
for (int i = 1; i < v.size(); i++) ret *= v[i];
return ret;
}
void solve() {
int N;
scanf("%d", &N);
for (int i = 0; i < N * 2; i++) scanf("%d", &a[i]), cnt[a[i]]++;
vector<int> res;
sort(a, a + N * 2, greater<int>());
for (int i = 0; i < N * 2; i++) {
if (P(a[i]))
grdiv[a[i]] = 1;
else
grdiv[a[i]] = Gr(a[i]);
if (P(a[i]) || cnt[a[i]] == 0) continue;
cnt[a[i]]--;
cnt[grdiv[a[i]]]--;
res.push_back(a[i]);
}
reverse(a, a + N * 2);
for (int i = 0; i < N * 2; i++) {
if (!P(a[i]) || cnt[a[i]] == 0) continue;
cnt[a[i]]--;
cnt[pr[a[i] - 1]]--;
res.push_back(a[i]);
}
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
}
int main() {
isp[0] = isp[1] = 1;
int sz = 0;
for (int i = 2; i <= MX + 100; i++) {
if (isp[i]) continue;
pr[sz++] = i;
for (int j = i + i; j <= MX + 100; j += i) {
isp[j] = true;
}
}
int T = 1;
while (T--) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const int MAXN = 2e5 + 5;
const long long INF = (1LL << 61);
int R, C, K, Q;
int left_fish[MAXN];
int right_fish[MAXN];
bool safe_col[MAXN];
long long dp[MAXN][2];
int pre_row[MAXN];
int left_ladder[MAXN];
int right_ladder[MAXN];
void AddFish(int r, int c) {
if (left_fish[r] == -1) {
left_fish[r] = c;
right_fish[r] = c;
} else {
mina(left_fish[r], c);
maxa(right_fish[r], c);
}
}
long long cal(int cr, int pp, int is_right, int right_l) {
long long cost = 0;
if (right_l) {
if (right_ladder[pp] == -1)
return INF;
else {
cost += right_ladder[pp] - pp;
pp = right_ladder[pp];
}
} else {
if (left_ladder[pp] == -1)
return INF;
else {
cost += pp - left_ladder[pp];
pp = left_ladder[pp];
}
}
int cp_right = right_fish[cr];
int cp_left = left_fish[cr];
if (is_right) {
if (pp >= cp_right)
return cost + pp - cp_left + cp_right - cp_left;
else if (pp >= cp_left)
return cost + pp - cp_left + cp_right - cp_left;
else
return cost + cp_right - pp;
} else {
if (pp >= cp_right)
return cost + pp - cp_left;
else if (pp >= cp_left)
return cost + cp_right - pp + cp_right - cp_left;
else
return cost + cp_right - pp + cp_right - cp_left;
}
}
long long solve(int r, int is_right) {
if (r == 0) {
if (left_fish[r] == -1) {
left_fish[0] = right_fish[0] = 0;
dp[0][0] = dp[0][1] = 0;
} else {
dp[0][0] = right_fish[0] + right_fish[0] - left_fish[0];
dp[0][1] = right_fish[0];
}
return dp[r][is_right];
}
if (dp[r][is_right] != -1) return dp[r][is_right];
int pr = pre_row[r];
int cc;
for (int i = 0; (i) < (2); ++(i)) solve(pr, i);
cc = is_right;
dp[r][is_right] = cal(r, left_fish[pr], cc, 0) + dp[pr][0];
mina(dp[r][is_right], cal(r, left_fish[pr], cc, 1) + dp[pr][0]);
mina(dp[r][is_right], cal(r, right_fish[pr], cc, 0) + dp[pr][1]);
mina(dp[r][is_right], cal(r, right_fish[pr], cc, 1) + dp[pr][1]);
dp[r][is_right] += r - pr;
return dp[r][is_right];
}
int main() {
memset(left_fish, -1, sizeof(left_fish));
memset(right_fish, -1, sizeof(right_fish));
memset(dp, -1, sizeof(dp));
memset(left_ladder, -1, sizeof(left_ladder));
memset(right_ladder, -1, sizeof(right_ladder));
int r, c;
scanf("%d %d %d %d", &R, &C, &K, &Q);
int max_r = -1;
for (int i = 0; (i) < (K); ++(i)) {
scanf("%d %d", &r, &c);
r--, c--;
AddFish(r, c);
maxa(max_r, r);
}
for (int i = 0; (i) < (Q); ++(i)) {
scanf("%d", &c);
c--;
safe_col[c] = true;
}
if (safe_col[0]) left_ladder[0] = 0;
for (int i = 1; i < C; i++) {
if (safe_col[i])
left_ladder[i] = i;
else
left_ladder[i] = left_ladder[i - 1];
}
if (safe_col[C - 1]) right_ladder[C - 1] = C - 1;
for (int i = C - 2; i >= 0; i--) {
if (safe_col[i])
right_ladder[i] = i;
else
right_ladder[i] = right_ladder[i + 1];
}
pre_row[0] = 0;
for (int i = 1; i <= max_r; i++) {
if (left_fish[i - 1] == -1) {
pre_row[i] = pre_row[i - 1];
} else {
pre_row[i] = i - 1;
}
}
cout << min(solve(max_r, 0), solve(max_r, 1)) << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxp = 7, maxpm = 2 * 3 * 5 * 7 * 11 * 13 * 17, maxx = 5e6;
int phi[maxpm + 1][maxp + 1], p[maxp + 1], sp[maxx], cachepi[maxx],
primes[maxx], sz = 0;
int sqrt2(long long x) {
long long r = (long long)sqrt(x - 0.1);
while (r * r <= x) ++r;
return int(r - 1);
}
int sqrt3(long long x) {
long long r = (long long)cbrt(x - 0.1);
while (r * r * r <= x) ++r;
return int(r - 1);
}
void init() {
for (int i = 2; i < maxx; i++) {
if (!sp[i]) sp[i] = i, primes[++sz] = i;
cachepi[i] = sz;
for (int j = 1; j <= sz && 1LL * i * primes[j] < maxx && primes[j] <= sp[i];
j++) {
sp[i * primes[j]] = primes[j];
if (i % primes[j] == 0) break;
}
}
p[0] = 1;
for (int i = 0; i <= maxpm; i++) phi[i][0] = i;
for (int j = 1; j <= maxp; j++) {
p[j] = p[j - 1] * primes[j];
for (int i = 0; i <= maxpm; i++)
phi[i][j] = phi[i][j - 1] - phi[i / primes[j]][j - 1];
}
}
long long PHI(long long x, int a) {
if (a == 0) return x;
if (a <= maxp) return phi[x % p[a]][a] + (long long)(x / p[a]) * phi[p[a]][a];
if (1LL * primes[a] * primes[a] >= x) return cachepi[x] - a + 1;
if (1LL * primes[a] * primes[a] * primes[a] >= x && x < maxx) {
int li = cachepi[sqrt2(x)];
long long ret = cachepi[x] - 1LL * (li - a + 1) * (li + a - 2) / 2;
for (int i = a + 1; i <= li; i++) ret += cachepi[x / primes[i]];
return ret;
}
return PHI(x, a - 1) - PHI(x / primes[a], a - 1);
}
long long lehmer(long long x) {
if (x < maxx) return cachepi[x];
int a = cachepi[sqrt2(sqrt2(x))], b = cachepi[sqrt2(x)],
c = cachepi[sqrt3(x)];
long long ret = PHI(x, a) + (long long)(b + a - 2) * (b - a + 1) / 2;
for (int i = a + 1; i <= b; i++) {
long long xpi = x / primes[i];
ret -= lehmer(xpi);
if (i <= c) {
long long li = cachepi[sqrt2(xpi)];
for (int j = i; j <= li; j++) ret -= cachepi[xpi / primes[j]] - (j - 1);
}
}
return ret;
}
int main() {
init();
long long n, ret = 0;
scanf("%lld", &n);
for (int i = 1; 1LL * primes[i] * primes[i] * primes[i] <= n; i++) ++ret;
for (int i = 1; 1LL * primes[i] * primes[i] < n; ++i)
ret += lehmer(n / primes[i]) - i;
printf("%lld\n", ret);
}
| 16 |
#include <bits/stdc++.h>
int main() {
long long m, b, y;
long long max = 0;
scanf("%lld%lld", &m, &b);
for (y = b; y >= 0; y--) {
long long sum = 0;
sum += m * (b - y) * (m * (b - y) + 1) * (y + 1) / 2 +
y * (y + 1) * (m * (b - y) + 1) / 2;
if (sum > max) max = sum;
}
printf("%lld", max);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long v[3005];
basic_string<int> e[3005];
vector<pair<int, long long>> dfs(int x, int p) {
vector<pair<int, long long>> dp = {{0, v[x]}};
for (int y : e[x]) {
if (y == p) continue;
auto v = dfs(y, x);
vector<pair<int, long long>> tmp(dp.size() + v.size() - 1, {-1, -1});
for (int i = 0; i < (int)dp.size(); i++) {
for (int j = 0; j < (int)v.size(); j++) {
tmp[i + j] = max(
tmp[i + j], {dp[i].first + v[j].first, dp[i].second + v[j].second});
}
}
swap(tmp, dp);
}
dp.emplace_back(-1, -1);
for (int i = 0; i < (int)dp.size() - 1; i++) {
dp[i + 1] = max(dp[i + 1], {dp[i].first + (dp[i].second > 0), 0});
}
return dp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int t;
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> v[i];
e[i].clear();
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
v[i] = x - v[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
e[u] += v;
e[v] += u;
}
auto v = dfs(1, 1);
int x = v[m - 1].first + (v[m - 1].second > 0);
cout << x << '\n';
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[300005];
int state[300005] = {};
int dp[300005][27] = {};
char a[300005];
bool check(int now) {
state[now] = 2;
for (int x : G[now]) {
if (state[x] == 2) return 0;
if (state[x] == 0 && !check(x)) return 0;
}
state[now] = 1;
return 1;
}
void dfs(int now) {
if (dp[now][26]) return;
if (G[now].size() == 0) {
dp[now][a[now] - 'a'] = 1;
dp[now][26] = 1;
return;
}
for (int i = 0; i < G[now].size(); i++) {
int to = G[now][i];
dfs(to);
for (int i = 0; i < 26; i++) {
dp[now][i] = max(dp[now][i], dp[to][i]);
}
}
dp[now][a[now] - 'a'] += 1;
dp[now][26] = 1;
return;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
bool head[300005] = {};
for (int i = 1; i <= n; i++) {
head[i] = 1;
}
scanf("%s", a);
for (int i = n; i >= 1; i--) {
a[i] = a[i - 1];
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
head[y] = 0;
}
for (int i = 1; i <= n; i++) {
if (state[i] == 0) {
if (check(i) == 0) {
printf("-1\n");
return 0;
}
}
}
int max = -1;
for (int i = 1; i <= n; i++) {
if (head[i]) {
dfs(i);
for (int j = 0; j < 26; j++) {
if (dp[i][j] > max) {
max = dp[i][j];
}
}
}
}
printf("%d\n", max);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int totCost = 0;
int P[2003], target[2003], posInTarget[2003], n;
int best[2003], ansLen, ans1[2003 * 2003 / 2], ans2[2003 * 2003 / 2];
int getBest(int i, int j) {
if (P[i] > P[j]) return i;
return j;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cout.sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> P[i];
for (int i = 1; i <= n; ++i) {
cin >> target[i];
posInTarget[target[i]] = i;
}
for (int i = 1; i <= n; ++i) P[i] = posInTarget[P[i]];
for (int i = 1; i <= n; ++i) {
int posi = i, newPosi;
while (P[posi] != i) posi++;
best[i] = i;
for (int j = i + 1; j < posi; ++j) best[j] = getBest(j, best[j - 1]);
while (posi > i) {
newPosi = best[posi - 1];
ans1[ansLen] = newPosi;
ans2[ansLen++] = posi;
totCost += abs(posi - newPosi);
swap(P[posi], P[newPosi]);
posi = newPosi;
}
}
cout << totCost << "\n" << ansLen << '\n';
for (int i = 0; i < ansLen; ++i) cout << ans1[i] << ' ' << ans2[i] << '\n';
return 0;
}
| 15 |
#include <bits/stdc++.h>
const int mo = 1000000007;
const int inf = 0x3f3f3f3f;
double pi = 3.14159265358979323846;
double e = 2.71828182845904523536;
using namespace std;
int main() {
int arr[1005];
int n, a, b, c, t;
cin >> n >> a >> b >> c >> t;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (c * (t - arr[i]) >= b * (t - arr[i]))
sum += c * (t - arr[i]) - b * (t - arr[i]) + a;
else
sum += a;
}
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int val[100010], vl[100010], vr[100010], res, far[100010], n, dl[100010],
tag[2][400010], sum[2][400010];
int tdl[2][100010];
map<int, int> mp;
int read() {
int tmp = 0, fh = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fh = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp * fh;
}
void pushdown(int c, int now, int l, int r) {
int mid = (l + r) / 2;
if (tag[c][now]) {
int x = tag[c][now];
tag[c][now] = 0;
tag[c][now * 2] = tag[c][now * 2 + 1] = x;
sum[c][now * 2] = x * ((long long)mid - l + 1) % 1000000007;
sum[c][now * 2 + 1] = x * ((long long)r - mid) % 1000000007;
}
}
void modify(int c, int now, int l, int r, int left, int right, int x) {
if (l == left && r == right) {
tag[c][now] = x;
sum[c][now] = x * ((long long)r - l + 1) % 1000000007;
return;
}
pushdown(c, now, l, r);
int mid = (l + r) / 2;
if (left <= mid) modify(c, now * 2, l, mid, left, min(right, mid), x);
if (right >= mid + 1)
modify(c, now * 2 + 1, mid + 1, r, max(left, mid + 1), right, x);
sum[c][now] = (sum[c][now * 2] + sum[c][now * 2 + 1]) % 1000000007;
}
int query(int c, int now, int l, int r, int left, int right) {
if (l == left && r == right) return sum[c][now];
pushdown(c, now, l, r);
int mid = (l + r) / 2, res = 0;
if (left <= mid) res = query(c, now * 2, l, mid, left, min(right, mid));
if (right >= mid + 1)
res = (res + query(c, now * 2 + 1, mid + 1, r, max(left, mid + 1), right)) %
1000000007;
return res;
}
int get_S(int l, int r) {
return ((long long)l + r) * (r - l + 1) / 2 % 1000000007;
}
int get_res0() {
int res = 0;
for (int i = 1; i <= n; i++)
res = (res + (long long)i * get_S(i, far[i]) % 1000000007) % 1000000007;
return res;
}
int get_res1() {
int res = 0, pos = n + 1, lef = 1, righ = 0, sum = 0;
dl[0] = n + 1;
for (int i = n; i >= 1; i--) {
while (lef <= righ && vr[i] <= vr[dl[righ]]) {
sum = (sum -
(long long)vr[dl[righ]] * (dl[righ - 1] - dl[righ]) % 1000000007 +
1000000007) %
1000000007;
righ--;
}
dl[++righ] = i;
sum = (sum +
(long long)vr[dl[righ]] * (dl[righ - 1] - dl[righ]) % 1000000007 +
1000000007) %
1000000007;
for (int j = pos - 1; j >= far[i] + 1; j--) {
sum = (sum - vr[dl[lef]] + 1000000007) % 1000000007;
if (dl[lef] == j) lef++;
}
dl[0] = pos = far[i] + 1;
res = (res + (long long)sum * i % 1000000007) % 1000000007;
}
lef = 1;
righ = 0;
sum = 0;
pos = 0;
dl[0] = 0;
for (int i = 1; i <= n; i++) {
while (lef <= righ && vl[i] >= vl[dl[righ]]) {
sum = (sum -
(long long)vl[dl[righ]] * (dl[righ] - dl[righ - 1]) % 1000000007 +
1000000007) %
1000000007;
righ--;
}
dl[++righ] = i;
sum = (sum +
(long long)vl[dl[righ]] * (dl[righ] - dl[righ - 1]) % 1000000007 +
1000000007) %
1000000007;
while (far[pos + 1] < i) {
sum = (sum - vl[dl[lef]] + 1000000007) % 1000000007;
if (dl[lef] == pos + 1) lef++;
pos++;
}
dl[0] = pos;
res = (res + (long long)sum * i % 1000000007) % 1000000007;
}
return res;
}
int get_res2() {
int lef[2], righ[2], pos = n + 1, sum = 0, t1, t2, res = 0;
lef[0] = lef[1] = 1;
righ[0] = righ[1] = 0;
tdl[0][0] = tdl[1][0] = pos;
for (int i = n; i >= 1; i--) {
while (lef[0] <= righ[0] && vl[i] >= vl[tdl[0][righ[0]]]) {
t1 = tdl[0][righ[0] - 1];
t2 = tdl[0][righ[0]];
sum = (sum -
(long long)vl[t2] * query(1, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
righ[0]--;
}
tdl[0][++righ[0]] = i;
t1 = tdl[0][righ[0] - 1];
t2 = tdl[0][righ[0]];
sum =
(sum + (long long)vl[t2] * query(1, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
modify(0, 1, 1, n, t2, t1 - 1, vl[t2]);
while (lef[1] <= righ[1] && vr[i] <= vr[tdl[1][righ[1]]]) {
t1 = tdl[1][righ[1] - 1];
t2 = tdl[1][righ[1]];
sum = (sum -
(long long)vr[t2] * query(0, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
righ[1]--;
}
tdl[1][++righ[1]] = i;
t1 = tdl[1][righ[1] - 1];
t2 = tdl[1][righ[1]];
sum =
(sum + (long long)vr[t2] * query(0, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
modify(1, 1, 1, n, t2, t1 - 1, vr[t2]);
for (int j = pos - 1; j >= far[i] + 1; j--) {
sum = (sum -
(long long)vl[tdl[0][lef[0]]] * vr[tdl[1][righ[1]]] % 1000000007 +
1000000007) %
1000000007;
if (tdl[0][lef[0]] == j) lef[0]++;
if (tdl[1][lef[1]] == j) lef[1]++;
}
tdl[0][0] = tdl[1][0] = pos = far[i] + 1;
res = (res + sum) % 1000000007;
}
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) val[i] = read();
for (int i = 1; i <= n; i++) {
if (mp.find(val[i]) == mp.end())
vl[i] = 1;
else
vl[i] = mp[val[i]] + 1;
mp[val[i]] = i;
}
mp.clear();
for (int i = n; i >= 1; i--) {
if (mp.find(val[i]) == mp.end())
vr[i] = n;
else
vr[i] = mp[val[i]] - 1;
mp[val[i]] = i;
}
mp.clear();
far[0] = 1;
mp[val[1]] = 1;
for (int i = 1; i <= n; i++) {
far[i] = far[i - 1];
if (i - 1) mp.erase(val[i - 1]);
while (far[i] < n && mp.find(val[far[i] + 1]) == mp.end()) {
far[i]++;
mp[val[far[i]]] = 1;
}
}
res = (((long long)get_res1() - get_res0() - get_res2()) % 1000000007 +
1000000007) %
1000000007;
printf("%d\n", res);
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
long long read_long() {
long long ans = 0;
char c;
bool started = false;
bool is_negative = false;
while (true) {
c = getchar();
if ((c < '0' || c > '9') && c != '-' && !started) continue;
if ((c < '0' || c > '9') && c != '-' && started) break;
if (started) {
ans = ans * 10;
}
started = true;
if (c == '-')
is_negative = true;
else
ans += c - '0';
}
if (is_negative) ans *= -1;
return ans;
}
int n;
map<string, set<string> > g;
set<string> names;
bool has(string a, string b) {
if (a.size() >= b.size()) {
return a.substr((int)a.size() - (int)b.size()) == b;
} else
return false;
}
void print(string name) {
vector<string> v;
for (__typeof(g[name].begin()) it = g[name].begin(); it != g[name].end();
it++)
v.push_back(*it);
set<string> second;
for (int i = 0; i < v.size(); i++) {
bool ok = true;
for (int j = 0; j < v.size(); j++) {
if (i == j) continue;
if (has(v[j], v[i])) ok = false;
}
if (ok) second.insert(v[i]);
}
cout << name << " " << second.size();
for (__typeof(second.begin()) it = second.begin(); it != second.end(); it++)
cout << " " << *it;
cout << endl;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string name;
int k;
string tel;
cin >> name >> k;
while (k--) {
cin >> tel;
g[name].insert(tel);
}
names.insert(name);
}
cout << names.size() << endl;
for (__typeof(names.begin()) it = names.begin(); it != names.end(); it++)
print(*it);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int b, q, l, m, a[100100], cnt;
map<long long int, long long int> is;
int main() {
cin >> b >> q >> l >> m;
for (int i = 1; i <= m; i++) {
scanf("%I64d", &a[i]);
is[a[i]] = 1;
}
if (b == 0) {
if (is[0])
cout << "0\n";
else
cout << "inf\n";
return 0;
} else if (q == 0) {
if (!is[0] && (abs(b) <= l))
cout << "inf\n";
else if ((!is[b]) && (abs(b) <= l))
cout << "1\n";
else
cout << "0\n";
return 0;
} else if (q == 1) {
if (is[b] || (abs(b) > l))
cout << "0\n";
else
cout << "inf\n";
return 0;
} else if (q == -1) {
if (is[b] && is[-b] || (abs(b) > l))
cout << "0\n";
else
cout << "inf\n";
return 0;
}
long long int temp = b;
while (abs(temp) <= l) {
if (!is[temp]) cnt++;
temp *= q;
}
cout << cnt << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9, maxn = (int)1e5 + 1;
const double eps = (double)1e-8;
int main() {
bool f;
string a;
int b[20], j, t, o;
cin >> t;
while (t > 0) {
o = 0;
t--;
cin >> a;
for (int i = 1; i <= 12; i++)
if (12 % i == 0) {
f = 0;
for (int k = 1; k <= i; k++) {
j = k - 1;
while (j < 12 && a[j] == 'X') j += i;
if (j > 11) f = 1;
}
if (f == 1) {
o++;
b[o] = i;
}
}
cout << o << " ";
for (int i = o; i > 0; i--) cout << 12 / b[i] << "x" << b[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long ar[200005], tmp[200005];
long long lowest = 0;
pair<long long, long long> br[200005];
bool can(long long cur) {
long long mn = 0;
long long ind = m - 1;
for (long long i = 0; i < m; i++) {
if (br[i].first > cur) {
ind = i - 1;
break;
}
}
vector<pair<long long, long long>> vp;
map<long long, long long> mp;
for (long long i = ind; i >= 0; i--) {
if (mp[br[i].second]) {
continue;
}
vp.push_back(br[i]);
mp[br[i].second] = 1;
}
reverse(vp.begin(), vp.end());
for (long long i = 0; i < vp.size(); i++) {
if (tmp[vp[i].second] >= 1) {
long long money = vp[i].first - mn;
if (money >= tmp[vp[i].second]) {
mn += tmp[vp[i].second];
tmp[vp[i].second] = 0;
} else {
mn += money;
tmp[vp[i].second] -= money;
}
}
}
for (long long i = 0; i < n; i++) {
mn += tmp[i] * 2;
}
if (mn <= cur) {
return true;
} else {
return false;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> ar[i];
lowest += ar[i] * 2;
}
for (long long i = 0; i < m; i++) {
cin >> br[i].first >> br[i].second;
br[i].second--;
}
sort(br, br + m);
long long l = lowest / 2, r = lowest;
while (l < r) {
for (long long i = 0; i < n; i++) {
tmp[i] = ar[i];
}
long long mid = l + (r - l) / 2;
if (can(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
cout << l << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int maxlen = 1005;
char temp[maxlen];
int a[maxlen], b[maxn][maxlen];
int n, c[maxn], f[2][maxn], lena, len[maxn], cur, sz[10], lenmax;
int rk[2][maxn], pos[2][maxn];
int main() {
int i, j, ans, num, jinwei;
scanf("%s%d", temp, &n);
for (i = 1, lenmax = lena = strlen(temp); i <= lena; i++)
a[i] = (temp[lena - i] == '?') ? -1 : (temp[lena - i] - '0');
for (i = 1; i <= n; i++) {
scanf("%s", temp);
for (j = 1, lenmax = max(lenmax, len[i] = strlen(temp)); j <= len[i]; j++)
b[i][j] = temp[len[i] - j] - '0';
for (; j <= 1000; j++) b[i][j] = 0;
}
for (i = 0; i < 10; i++) scanf("%d", &c[i]);
cur = 0;
memset(f[cur], 0x80, sizeof(f[cur]));
f[cur][0] = 0;
for (i = 1; i <= n; i++) rk[cur][i] = i, pos[cur][i] = i;
for (i = 1; i <= lenmax; i++) {
cur ^= 1;
memset(f[cur], 0x80, sizeof(f[cur]));
for (j = 0; j < 10; j++) sz[j] = 0;
for (j = 1; j <= n; j++) ++sz[b[j][i]];
++sz[9];
for (j = 8; j >= 0; j--) sz[j] += sz[j + 1];
for (j = n; j; j--) rk[cur][pos[cur ^ 1][j]] = --sz[b[pos[cur ^ 1][j]][i]];
for (j = 1; j <= n; j++) pos[cur][rk[cur][j]] = j;
if (a[i] != -1) {
num = 0;
for (j = 1; j <= n; j++)
if (b[j][i] + a[i] || i <= len[j] || i <= lena)
num += c[(b[j][i] + a[i]) % 10];
jinwei = 0;
for (j = 0; j <= n; j++) {
if (j) {
if (b[pos[cur ^ 1][j]][i] + a[i] || i <= len[pos[cur ^ 1][j]] ||
i <= lena)
num -= c[(b[pos[cur ^ 1][j]][i] + a[i]) % 10];
num += c[(b[pos[cur ^ 1][j]][i] + a[i] + 1) % 10];
}
while (jinwei < n && b[pos[cur][jinwei + 1]][i] +
(rk[cur ^ 1][pos[cur][jinwei + 1]] <= j) +
a[i] >=
10)
jinwei++;
f[cur][jinwei] = max(f[cur][jinwei], f[cur ^ 1][j] + num);
}
} else
for (a[i] = (i == lena) ? 1 : 0; a[i] <= 9; a[i]++) {
num = 0;
for (j = 1; j <= n; j++)
if (b[j][i] + a[i] || i <= len[j] || i <= lena)
num += c[(b[j][i] + a[i]) % 10];
jinwei = 0;
for (j = 0; j <= n; j++) {
if (j) {
if (b[pos[cur ^ 1][j]][i] + a[i] || i <= len[pos[cur ^ 1][j]] ||
i <= lena)
num -= c[(b[pos[cur ^ 1][j]][i] + a[i]) % 10];
num += c[(b[pos[cur ^ 1][j]][i] + a[i] + 1) % 10];
}
while (jinwei < n &&
b[pos[cur][jinwei + 1]][i] +
(rk[cur ^ 1][pos[cur][jinwei + 1]] <= j) + a[i] >=
10)
jinwei++;
f[cur][jinwei] = max(f[cur][jinwei], f[cur ^ 1][j] + num);
}
}
}
ans = -1;
for (i = 0; i <= n; i++) ans = max(ans, f[cur][i] + i * c[1]);
printf("%d\n", ans);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void takearray(vector<T> &a, long long int n) {
T y;
for (long long int i = 0; i < n; i++) {
cin >> y;
a.push_back(y);
}
}
template <typename T>
void print1d(vector<T> &a) {
for (long long int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << endl;
}
void sieveoferatosthenes(long long int n, vector<long long int> &a) {
vector<bool> prime(n + 1, true);
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) a.push_back(p);
}
vector<long long int> dectobin(long long int n) {
vector<long long int> a;
while (n != 0) {
a.push_back(n % 2);
n = n / 2;
}
return a;
}
long long int first_BS(vector<long long int> a, long long int low,
long long int high, long long int x) {
while (low <= high) {
long long int mid = low + (high - low) / 2;
if ((mid == 0 || x > a[mid - 1]) && a[mid] == x)
return mid;
else if (a[mid] < x)
low = mid + 1;
else
high = mid - 1;
}
return -1;
}
long long int last_BS(vector<long long int> a, long long int low,
long long int high, long long int x) {
while (low <= high) {
long long int mid = low + (high - low) / 2;
if ((mid == a.size() - 1 || x < a[mid + 1]) && a[mid] == x)
return mid;
else if (x < a[mid])
high = mid - 1;
else
low = mid + 1;
}
return -1;
}
bool sortbool(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return a.first < b.first;
}
vector<long long int> numberDivisior(long long int n) {
vector<long long int> b;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
b.push_back(i);
else {
b.push_back(n / i);
b.push_back(i);
}
}
}
return b;
}
long long int modiBinarySearch(long long int l, long long int r,
long long int k) {
long long int q, y, mid;
while (l <= r) {
mid = l + (r - l) / 2;
q = (mid * (mid - 1)) / 2;
y = (mid * (mid + 1)) / 2;
if (q == k)
return mid;
else if (q < k && y > k)
return mid;
else if (q > k)
r = mid - 1;
else
l = mid + 1;
}
return -1;
}
long double bs(long long int n) {
long double l, r;
l = 0;
r = n;
while (l <= r) {
long double mid = l + (r - l) / 2;
if ((n - mid) * mid == n)
return mid;
else if ((n - mid) * mid > n)
r = mid;
else
l = mid;
}
return -1;
}
unsigned long long int nchoosek(long long int n, long long int r) {
unsigned long long int q = 1;
if (r == 0 || r == n) return 1;
return nchoosek(n - 1, r - 1) + nchoosek(n - 1, r);
}
bool isPrime(unsigned long long int q) {
for (long long int i = 2; i * i <= q; i++) {
if (q % i == 0) return false;
}
return true;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long int n, m, l;
cin >> n >> m >> l;
vector<long long int> a(n, 0);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int cnt = 0, j = -1;
for (long long int i = 0; i < n; i++) {
if (a[i] > l)
j = 1;
else if (a[i] <= l && j == 1) {
j = -1;
cnt++;
}
}
if (j == 1) cnt++;
while (m--) {
long long int t;
cin >> t;
if (t == 1) {
long long int p, d;
cin >> p >> d;
if (a[p - 1] > l) {
a[p - 1] += d;
continue;
}
a[p - 1] += d;
if (a[p - 1] <= l) continue;
if (p != 1 && p != n) {
if (a[p] > l && a[p - 2] > l)
cnt--;
else if (a[p] <= l && a[p - 2] <= l)
cnt++;
} else if (p == 1 && p == n) {
cnt++;
} else if (p == 1) {
if (a[p] <= l) cnt++;
} else if (p == n) {
if (a[p - 2] <= l) cnt++;
}
} else {
cout << cnt << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
struct debug {
template <class T>
debug& operator<<(const T&) {
return *this;
}
};
using ll = long long;
template <typename T>
void min_self(T& a, T b) {
a = min(a, b);
}
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
bool ask(int x, int y) {
cout << "? " << x << ' ' << y << endl;
string ans;
cin >> ans;
if (ans == "e") {
exit(0);
}
return ans == "x";
}
void play_game() {
int i = 0, prev = 0;
while (!ask(prev, 1 << i)) {
prev = 1 << i;
i++;
}
int lo = prev + 1, hi = 1 << i;
int ans = prev;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (!ask(prev, mid)) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << "! " << ans + 1 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
while (1) {
string s;
cin >> s;
if (s == "start") {
play_game();
} else {
exit(0);
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
void factors(long long n, vector<long long> &v) {
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
if (n / i != i) v.push_back(n / i);
}
}
}
const long long mod = 1000000007;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long mx = 0, cur = 0;
for (long long i = 0; i + 1 < n; i += 2) {
cur += a[i + 1] - a[i];
cur = max(0LL, cur);
mx = max(mx, cur);
}
cur = 0;
for (long long i = 1; i + 1 < n; i += 2) {
cur += a[i] - a[i + 1];
cur = max(0LL, cur);
mx = max(mx, cur);
}
long long sum = 0;
for (long long i = 0; i < n; i += 2) {
sum += a[i];
}
cout << sum + mx << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int maxn = 100010;
int n, m, a[maxn];
void print(int x) {
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1, op, l, r, x; i <= m; i++) {
scanf("%d %d %d %d", &op, &l, &r, &x);
if (op == 1) {
int j = l;
int *b = a + l;
for (; j + 3 <= r; j += 4) {
*b -= *b > x ? x : 0, b++;
*b -= *b > x ? x : 0, b++;
*b -= *b > x ? x : 0, b++;
*b -= *b > x ? x : 0, b++;
}
while (j <= r) {
a[j] -= a[j] > x ? x : 0, j++;
}
} else {
int ans = 0, j = l;
while (j + 3 <= r) {
ans += a[j] == x, j++;
ans += a[j] == x, j++;
ans += a[j] == x, j++;
ans += a[j] == x, j++;
}
while (j <= r) {
ans += a[j] == x, j++;
}
print(ans), putchar('\n');
}
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, M = 50 + 9;
long long bit[M][N];
long long query(int rem, long long val) {
long long total = 0;
while (val) {
total += bit[rem][val];
val -= (val & (-val));
}
return total;
}
void update(int rem, int val, long long nw) {
while (val < N) {
bit[rem][val] += nw;
val += (val & (-val));
}
}
int main() {
int n, m, x;
cin >> n >> m;
++m;
for (int i = 0; i < n; ++i) {
cin >> x;
update(m, x, 1);
for (int j = 0; j < m; ++j) {
long long cur = query(j + 1, x - 1);
update(j, x, cur);
}
}
cout << query(1, N - 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 3;
const char* inf[] = {"none", "any", "at least one"};
int f[N], dfn[N], low[N];
int n, m, idx;
int res[N];
vector<pair<int, int> > p[N];
struct Tuple {
int x, y, d, idx;
bool operator<(const Tuple& t) const { return d < t.d; }
} msg[N];
void init() {
for (int i = 1; i <= n; ++i) f[i] = i;
}
int root(int x) { return x == f[x] ? x : f[x] = root(f[x]); }
void unions(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return;
if (rand() & 1)
f[x] = y;
else
f[y] = x;
}
void tarjan(int x, int pre) {
dfn[x] = low[x] = ++idx;
for (__typeof(p[x].begin()) it = p[x].begin(); it != p[x].end(); ++it) {
if (pre == (*it).second) continue;
int y = (*it).first;
if (dfn[y]) {
low[x] = min(low[x], dfn[y]);
} else {
tarjan(y, (*it).second);
low[x] = min(low[x], low[y]);
if (dfn[x] < low[y]) res[(*it).second] = 1;
}
}
}
int main() {
srand(time(NULL));
cin >> n >> m;
int x, y, d;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &x, &y, &d);
msg[i].idx = i;
msg[i].d = d;
msg[i].x = x;
msg[i].y = y;
}
sort(msg, msg + m);
init();
int i = 0, j = 0;
while (i < m) {
set<int> st;
for (; j < m && msg[j].d == msg[i].d; ++j)
if ((x = root(msg[j].x)) != (y = root(msg[j].y))) {
st.insert(x);
st.insert(y);
p[x].push_back(make_pair(y, msg[j].idx));
p[y].push_back(make_pair(x, msg[j].idx));
res[msg[j].idx] = 2;
}
for (; i < j; ++i) unions(msg[i].x, msg[i].y);
for (__typeof(st.begin()) it = st.begin(); it != st.end(); ++it)
if (!dfn[*it]) {
tarjan(*it, -1);
}
for (__typeof(st.begin()) it = st.begin(); it != st.end(); ++it) {
p[*it].clear();
dfn[*it] = low[*it] = 0;
}
}
for (int i = 0; i < m; ++i) puts(inf[res[i]]);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int n, m;
bool mark[maxn][maxn], a[maxn][maxn];
pair<int, int> par[maxn][maxn];
vector<string> v;
void dfs1(int x, int y) {
mark[x][y] = 1;
if (!a[x][y]) v.push_back("1");
a[x][y] = 1;
for (int i = x + 1; i < n; i++)
if (a[i][y] == 1 && !mark[x + 1][y]) {
v.push_back("D");
dfs1(x + 1, y);
v.push_back("U");
}
for (int i = 0; i < x; i++)
if (a[i][y] == 1 && !mark[x - 1][y]) {
v.push_back("U");
dfs1(x - 1, y);
v.push_back("D");
}
for (int j = y + 1; j < n; j++)
if (a[x][j] == 1 && !mark[x][y + 1]) {
v.push_back("R");
dfs1(x, y + 1);
v.push_back("L");
}
for (int j = 0; j < y; j++)
if (a[x][j] == 1 && !mark[x][y - 1]) {
v.push_back("L");
dfs1(x, y - 1);
v.push_back("R");
}
return;
}
void dfs2(int x, int y) {
a[x][y] = 0;
if (a[x + 1][y] == 1) {
v.push_back("D");
dfs2(x + 1, y);
v.push_back("U");
}
if (a[x - 1][y] == 1) {
v.push_back("U");
dfs2(x - 1, y);
v.push_back("D");
}
if (a[x][y + 1] == 1) {
v.push_back("R");
dfs2(x, y + 1);
v.push_back("L");
}
if (a[x][y - 1] == 1) {
v.push_back("L");
dfs2(x, y - 1);
v.push_back("R");
}
v.push_back("2");
}
int main() {
int x, y;
cin >> n >> x >> y;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
dfs1(x - 1, y - 1);
dfs2(x - 1, y - 1);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j]) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < v.size(); i++) cout << v[i];
return 0;
}
| 16 |
#include<bits/stdc++.h>
using namespace std;
int a[26];
int b[26];
int main(){
int t;
cin>>t;
while(t--){
for(int i=0;i<26;i++)a[i]=0;
for(int i=0;i<26;i++)b[i]=-1;
string s;
cin>>s;
string ans="";
for(int i=0;i<s.length();i++){
b[s[i]-'a']=i;
}
for(int i=0;i<s.length();i++){
string temp="";
int j=0;
while(j<ans.length() && ans[j]!=s[i]){
temp+=ans[j];
j++;
}
if(j>=ans.length()){ans+=s[i]; continue;}
// string temp1="";
while(j<ans.length() && (b[ans[j]-'a']>=i && ans[j]<=s[i]) ){
// temp1+=ans[j];
j++;
}
if(j<ans.length() && ans[j]>s[i]){
while(j<ans.length()){
temp+=ans[j];
j++;
}
temp+=s[i];
ans=temp;
}
//cout<<ans<<endl;
}
cout<<ans<<endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar(), w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * w;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
int n, m, p;
const int N = 510;
char s[N];
int ct[N];
long long f[2][N][N], t, c[N][N];
int main() {
n = read(), m = read(), p = read();
for (int i = 1; i <= m; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= n; ++j) ct[j] += s[j] - '0';
}
int s1 = 0, s2 = 0;
for (int i = 1; i <= n; ++i)
if (ct[i] == 0)
++s1;
else if (ct[i] == 1)
++s2;
else if (ct[i] > 2) {
puts("0");
return 0;
}
c[0][0] = 1;
for (int i = 1; i <= n; ++i) {
c[i][0] = 1;
for (int j = 1; j <= n; ++j) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % p;
}
f[0][s1][s2] = 1;
for (int i = m + 1; i <= n; ++i) {
t ^= 1;
memset(f[t], 0, sizeof f[t]);
for (int j = 0; j <= n; ++j) {
for (int k = 0; j + k <= n; ++k) {
if (k >= 2)
f[t][j][k] += (long long)f[t ^ 1][j + 2][k - 2] * c[j + 2][2];
f[t][j][k] += (long long)f[t ^ 1][j][k + 2] * c[k + 2][2];
f[t][j][k] += (long long)f[t ^ 1][j + 1][k] * (j + 1) % p * k;
if (f[t][j][k] >= p) f[t][j][k] %= p;
}
}
}
writeln(f[t][0][0]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long int i, j, k, n, m, s, sa, l, a, b, t[3], kk;
bool f(long long t1, long long t2, long long t3, long long n, long long m) {
long long int t[3] = {t1, t2, t3};
sort(t, t + 3);
m -= t[0] + t[1] + t[2];
if (t[0] < 0) m += t[0] * 3;
if (m < 0 || (m > 0 && (m % 3))) return false;
n -= (t[2] - t[0]) + (t[2] - t[1]);
if (!n || (!(n % 3) && n >= 3)) return true;
return false;
}
int main() {
scanf("%lld", &l);
for (i = 0; i < l; i++) {
scanf("%lld %lld %lld %lld", &n, &m, &a, &b);
if (f(a + b, b, 0, n - m, m)) {
cout << "yes\n";
continue;
}
if (f(0, a, a - b, n - m, m)) {
cout << "yes\n";
continue;
}
if (f(a, 0, b, n - m, m)) {
cout << "yes\n";
continue;
}
if (f(0, a, a + b, n - m, m)) {
cout << "yes\n";
continue;
}
cout << "no\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[11111], ans = 1e18;
bool vis[10001][1001];
struct inf {
long long int c, x, k;
};
int main(void) {
long long int n, m, f1, f2;
scanf("%lld%lld", &n, &m);
for (int e = 0; e < m; e++) scanf("%lld", &arr[e]);
sort(arr, arr + m);
scanf("%lld%lld", &f1, &f2);
deque<inf> q;
q.push_front({0, 0, 0});
vis[0][0] = true;
while (!q.empty()) {
long long int c = q.front().c, now = q.front().x, k = q.front().k;
q.pop_front();
if (k + (n - arr[now]) <= f1) {
ans = min(ans, c * (f1 + f2) + k + (n - arr[now]));
continue;
}
if (now) {
long long int nk = k + (arr[now] - arr[now - 1]);
if (nk <= f1) {
if (nk == f1 && vis[now - 1][0] == 0) {
vis[now - 1][0] = true;
q.push_back({c + 1, now - 1, 0});
} else if (vis[now - 1][nk] == 0) {
vis[now - 1][nk] = true;
q.push_front({c, now - 1, nk});
}
}
}
if (now < m - 1) {
long long int nk = k + (arr[now + 1] - arr[now]);
if (nk <= f1) {
if (nk == f1 && vis[now + 1][0] == 0) {
vis[now + 1][0] = true;
q.push_back({c + 1, now + 1, 0});
} else if (vis[now + 1][nk] == 0) {
vis[now + 1][nk] = 1;
q.push_front({c, now + 1, nk});
}
}
}
}
if (ans == 1e18) ans = -1;
printf("%lld", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
int dp[MAXN], type[MAXN];
int n, k;
bool flag[MAXN];
vector<int> G[MAXN];
int dp_dfs(int x) {
if (!flag[x]) return dp[x] = 1;
int temp;
if (type[x] == 1) {
temp = 1 << 30;
for (int i = 0; i < G[x].size(); ++i) {
temp = min(temp, dp_dfs(G[x][i]));
}
} else {
temp = 0;
for (int i = 0; i < G[x].size(); ++i) {
temp += dp_dfs(G[x][i]);
}
}
return dp[x] = temp;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &type[i]);
}
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
G[x].push_back(i);
flag[x] = true;
}
for (int i = 1; i <= n; ++i) {
if (!flag[i]) ++k;
}
printf("%d\n", k - dp_dfs(1) + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
int a, b, c, d, e;
scanf("%1d%1d%1d%1d%1d", &a, &b, &c, &d, &e);
long long int n = 10000 * a + 1000 * c + 100 * e + 10 * d + b, ret = 1;
for (int i = 0; i < 5; i++) ret = (ret * n) % 100000;
printf("%05lld\n", ret);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int ne[N << 1], fi[N], zz[N << 1], a[N], x, y, fa[N][20], n, tot;
long long ans;
void jb(int x, int y) {
ne[++tot] = fi[x];
fi[x] = tot;
zz[tot] = y;
}
void dfs(int x, int y) {
fa[x][0] = y;
for (int i = fi[x]; i; i = ne[i])
if (zz[i] != y) dfs(zz[i], x);
}
int main() {
scanf("%d", &n);
int id = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[id] > a[i]) id = i;
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
jb(x, y);
jb(y, x);
}
dfs(id, 0);
for (int i = 1; i <= 19; i++)
for (int j = 1; j <= n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1];
for (int i = 1; i <= n; i++)
if (id != i) {
long long num = 1e18;
for (int j = 0; j <= 19; j++)
if (fa[i][j] != 0)
num = min(num, a[i] + a[fa[i][j]] + (long long)j * a[fa[i][j]]);
else
num = min(num, a[i] + a[id] + (long long)j * a[id]);
ans += num;
}
printf("%lld\n", ans);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
bool compare(const pair<long long, long long>& lhs,
const pair<long long, long long>& rhs) {
return lhs.first < rhs.first;
}
int main() {
ios::sync_with_stdio(0);
long long n;
cin >> n;
long long a[3];
map<pair<long long, long long>, vector<pair<long long, long long> > > mp;
set<pair<long long, long long> > visited;
long long onemax = 0;
long long oneans;
for (long long i = 1; i <= n; i++) {
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
pair<long long, long long> temp, gemp;
if (a[0] > onemax) {
onemax = a[0];
oneans = i;
}
if (a[0] == a[1] && a[2] == a[1]) {
temp = make_pair(a[0], a[1]);
gemp = {a[2], i};
mp[temp].push_back(gemp);
visited.insert(temp);
} else if (a[0] == a[1]) {
temp = make_pair(a[0], a[1]);
gemp = {a[2], i};
mp[temp].push_back(gemp);
visited.insert(temp);
temp = make_pair(a[0], a[2]);
gemp = {a[1], i};
mp[temp].push_back(gemp);
visited.insert(temp);
} else if (a[1] == a[2]) {
temp = make_pair(a[0], a[1]);
gemp = {a[2], i};
mp[temp].push_back(gemp);
visited.insert(temp);
temp = make_pair(a[1], a[2]);
gemp = {a[0], i};
mp[temp].push_back(gemp);
visited.insert(temp);
} else {
temp = make_pair(a[0], a[1]);
gemp = {a[2], i};
mp[temp].push_back(gemp);
visited.insert(temp);
temp = make_pair(a[0], a[2]);
gemp = {a[1], i};
mp[temp].push_back(gemp);
visited.insert(temp);
temp = make_pair(a[1], a[2]);
gemp = {a[0], i};
mp[temp].push_back(gemp);
visited.insert(temp);
}
}
long long maxi = 0;
pair<long long, long long> ans;
for (set<pair<long long, long long> >::iterator it = visited.begin();
it != visited.end(); it++) {
long long len = mp[(*it)].size();
if (len > 1) {
sort(mp[(*it)].begin(), mp[(*it)].end(), compare);
if (min((*it).first,
mp[(*it)][len - 1].first + mp[(*it)][len - 2].first) > maxi) {
maxi = min((*it).first,
mp[(*it)][len - 1].first + mp[(*it)][len - 2].first);
ans = make_pair(
min(mp[(*it)][len - 1].second, mp[(*it)][len - 2].second),
max(mp[(*it)][len - 1].second, mp[(*it)][len - 2].second));
}
}
}
if (onemax >= maxi) {
cout << 1 << endl;
cout << oneans;
} else {
cout << 2 << endl;
cout << ans.first << " " << ans.second;
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define N 200005
#define mod 1000000007
#define mod1 998244353
//#define int long long
typedef long long LL;
typedef unsigned long long ULL;
int gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}
int a[N]={0,1};
void slove()
{
int in,k,n,t=1;LL ans=1;
cin>>n;
for(int i=2;i<n;i++)
{
if(gcd(i,n)==1)
{
ans*=i;ans%=n;t++;
a[i]=1;
}
}
if(ans!=1)
{
a[ans]=0;t--;
}
cout<<t<<endl;
for(int i=1;i<n;i++)
{
if(a[i])
{
cout<<i<<" ";
}
}
cout<<endl;
}
int main()
{
int tt=1;
//cin>>tt;
while(tt--)
slove();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 123, inf = 1e9, mod = 1e9 + 7;
const long long INF = 1e18;
int n, m, a[N][5];
bool check(int i, int j) {
int cnt = 0;
for (int q = 0; q < m; q++) cnt += (a[i][q] <= a[j][q]);
return cnt >= 3;
}
void solve() {
scanf("%d", &n);
m = 5;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
int p = 0;
for (int i = 1; i < n; i++)
if (check(i, p)) p = i;
bool ok = 1;
for (int i = 0; i < n; i++) ok &= check(p, i);
printf("%d\n", ok ? p + 1 : -1);
}
int main() {
int t = 1;
scanf("%d", &t);
while (t--) solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int BufferSize = 1 << 16;
char buffer[BufferSize], *front_head, *front_tail;
inline char GET_CHAR() {
if (front_head == front_tail) {
int l = fread(buffer, 1, BufferSize, stdin);
front_tail = (front_head = buffer) + l;
if (front_head == front_tail) return EOF;
}
return *front_head++;
}
inline int READ() {
int x = 0, f = 1;
char c = GET_CHAR();
for (; !isdigit(c); c = GET_CHAR()) {
if (c == EOF) return EOF;
if (c == '-') f = -1;
}
for (; isdigit(c); c = GET_CHAR()) x = (((x << 2) + x) << 1) + c - '0';
return x * f;
}
const int N = 500005, M = 1000005;
int pre[500005];
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
const int Headsize = N, Edgesize = M;
int head[Headsize + 5], mal = 1;
struct edge {
int nx, to;
} e[Edgesize + 5];
inline void addedge(int u, int v) {
e[mal].to = v;
e[mal].nx = head[u];
head[u] = mal++;
}
int Eu[N], Ev[N], Ew[N], w;
int faz[N], dep[N], deg[N];
bool val[N];
long long res = 0;
void dfs(int u, int f) {
dep[u] = dep[faz[u] = f] + 1;
for (int i = head[u]; i; i = e[i].nx) {
int v = e[i].to;
if (v != f) dfs(v, u);
}
if (deg[u]) val[u] = 1, --deg[f], --deg[u];
}
int main() {
int n, k, m, u, v;
n = READ();
k = READ();
m = READ();
for (int i = 1; i <= n; i++) pre[i] = i;
for (int i = 0; i < k; i++) {
addedge(u = READ(), v = READ());
addedge(v, u);
deg[u]++;
deg[v]++;
u = find(u);
v = find(v);
pre[u] = v;
}
for (int i = 0; i < m; i++) {
Eu[i] = u = READ();
Ev[i] = v = READ();
Ew[i] = READ();
u = find(u);
v = find(v);
if (u != v) {
addedge(Eu[i], Ev[i]);
addedge(Ev[i], Eu[i]);
pre[u] = v;
m--;
i--;
}
}
dep[1] = -1;
dfs(1, 0);
faz[1] = 1;
for (int i = 1; i <= n; i++) pre[i] = i;
for (int i = 0; i < m; i++) {
u = find(Eu[i]);
v = find(Ev[i]);
w = Ew[i];
while (u != v) {
if (dep[u] < dep[v]) swap(u, v);
if (val[u]) {
val[u] = 0, res += w;
if (--k == 0) {
printf("%I64d\n", res);
return 0;
}
}
u = pre[u] = find(faz[u]);
}
}
puts("-1");
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long d[111][3000];
void pre(void) {
for (long long i = 0; i < 3000; ++i) d[1][i] = 0;
for (long long i = 0; i < 26; ++i) d[1][i] = 1;
for (long long l = 2; l < 101; ++l)
for (long long s = 0; s < 3000; ++s) {
d[l][s] = 0;
for (long long j = 0; j < 26 && s - j >= 0; ++j)
d[l][s] = (d[l - 1][s - j] + d[l][s]) % 1000000007;
}
}
long long sum(string s) {
long long n = s.length(), ans = 0;
for (long long i = 0; i < n; ++i) ans += (s[i] - 'a');
return ans;
}
int main() {
long long t;
string s;
cin >> t;
pre();
for (long long i = 0; i < t; ++i) {
cin >> s;
cout << (d[s.length()][sum(s)] + 1000000007 - 1) % 1000000007 << "\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n, m, final[N], nex[N], to[N], tot, T;
void link(int x, int y) { to[++tot] = y, nex[tot] = final[x], final[x] = tot; }
int ans[N], sum[N], sp[N], dep[N];
int ins[N], vis[N], god;
void dfs(int x) {
ins[x] = vis[x] = 1;
for (int i = final[x]; i; i = nex[i]) {
int y = to[i];
if (!ins[y] && vis[y]) {
god = 0;
} else {
if (ins[y]) {
if (sp[x] == 0 || dep[sp[x]] > dep[y]) sp[x] = y;
sum[x]++;
sum[y]--;
} else {
dep[y] = dep[x] + 1;
dfs(y);
}
}
}
ins[x] = 0;
}
bool good(int x) {
god = 1;
memset(vis, 0, (n + 5) * sizeof vis[0]);
memset(sp, 0, (n + 5) * sizeof sp[0]);
memset(sum, 0, (n + 5) * sizeof sum[0]);
memset(dep, 0, sizeof(int[n + 5]));
dep[x] = 1;
dfs(x);
return god;
}
int inans[N];
void init(int x) {
vis[x] = 1;
for (int i = final[x]; i; i = nex[i]) {
int y = to[i];
if (!vis[y]) {
init(y);
sum[x] += sum[y];
if (sp[y] && (sp[x] == 0 || dep[sp[y]] < dep[sp[x]])) sp[x] = sp[y];
}
}
}
void getans(int x) {
if (sum[x] == 1 && inans[sp[x]]) inans[x] = 1, ans[++(*ans)] = x;
vis[x] = 1;
for (int i = final[x]; i; i = nex[i]) {
int y = to[i];
if (!vis[y]) {
getans(y);
}
}
}
set<pair<int, int> > ss;
int main() {
for (cin >> T; T; T--) {
tot = 0;
cin >> n >> m;
ss.clear();
memset(final, 0, (n + 5) * sizeof final[0]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
link(u, v);
assert(u != v);
if (ss.find(make_pair(u, v)) != ss.end()) assert(0);
ss.insert(make_pair(u, v));
}
int cnt = 0;
while (1) {
if (++cnt == 100) {
break;
}
int x = (rand() * RAND_MAX + rand()) % n + 1;
if (good(x)) {
ans[0] = 0;
memset(vis, 0, (n + 5) * sizeof vis[0]);
init(x);
memset(inans, 0, (n + 5) * sizeof inans[0]);
inans[x] = 1, ans[++(*ans)] = x;
memset(vis, 0, (n + 5) * sizeof vis[0]);
getans(x);
if (ans[0] * 5 < n) {
if (m == 100002) cout << 234 << endl;
cout << -1 << endl;
} else {
sort(ans + 1, ans + 1 + *ans);
for (int i = 1; i <= *ans; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
break;
}
}
if (cnt == 100) {
if (m == 100002) cout << 233 << endl;
cout << -1 << endl;
continue;
}
}
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int T = 0;
vector<vector<int>> adj;
vector<int> in, up, down, siz, par, depth;
void init(int n) {
adj.resize(n);
in.resize(n);
siz.resize(n);
up.resize(n);
par.resize(n);
down.resize(n);
depth.resize(n);
}
void pre_dfs(int v = 0, int p = -1, int d = 0) {
depth[v] = d, siz[v] = 1, par[v] = p;
up[v] = down[v] = v;
for (int& u : adj[v]) {
if (u == p) continue;
pre_dfs(u, v, d + 1);
siz[v] += siz[u];
if (adj[v][0] == p || siz[u] > siz[adj[v][0]]) swap(u, adj[v][0]);
}
}
void dfs_hld(int v = 0, int p = -1) {
in[v] = T++;
for (int u : adj[v]) {
if (u == p) continue;
if (u == adj[v][0]) up[u] = up[v];
dfs_hld(u, v);
if (u == adj[v][0]) down[v] = down[u];
}
}
const ll inf = 1e15;
using pli = pair<ll, int>;
vector<vi> girls;
struct seg_tree_lazy {
vector<ll> lazy;
vector<pli> t;
int n;
void init(int m) {
n = m;
t.assign(4 * n, make_pair(inf, -1));
lazy.assign(4 * n, 0);
}
pli get_element(int i, int v) {
if (girls[i].empty()) return make_pair(inf, -1);
pli ret = make_pair(girls[i].back(), i);
ret.first += lazy[v];
return ret;
}
void apply(int v, ll x) {
t[v].first += x;
lazy[v] += x;
}
void push(int v) {
if (!lazy[v]) return;
apply(v * 2, lazy[v]);
apply(v * 2 + 1, lazy[v]);
lazy[v] = 0;
}
void pull(int v) { t[v] = min(t[v * 2], t[v * 2 + 1]); }
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = get_element(tl, v);
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
pull(v);
}
void add(int v, int tl, int tr, int l, int r, ll addend) {
if (l > r) return;
if (l == tl && r == tr) return apply(v, addend);
push(v);
int tm = (tl + tr) / 2;
add(v * 2, tl, tm, l, min(r, tm), addend);
add(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, addend);
pull(v);
}
pli get(int v, int tl, int tr, int i) {
if (tl == tr) return t[v];
push(v);
int tm = (tl + tr) / 2;
if (i <= tm)
return get(v * 2, tl, tm, i);
else
return get(v * 2 + 1, tm + 1, tr, i);
}
void update(int v, int tl, int tr, int i) {
if (tl == tr) {
t[v] = get_element(tl, v);
return;
}
push(v);
int tm = (tl + tr) / 2;
if (i <= tm) update(v * 2, tl, tm, i);
if (i > tm) update(v * 2 + 1, tm + 1, tr, i);
pull(v);
}
pli query(int v, int tl, int tr, int l, int r) {
if (l > r) return make_pair(inf, -1);
if (l == tl && r == tr) return t[v];
push(v);
int tm = (tl + tr) / 2;
return min(query(v * 2, tl, tm, l, min(r, tm)),
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void add(int l, int r, ll x) { return add(1, 0, n - 1, l, r, x); }
pli query(int l, int r) {
pli res = query(1, 0, n - 1, l, r);
return res;
}
void update(int i) { return update(1, 0, n - 1, i); }
pli get(int i) { return get(1, 0, n - 1, i); }
void build() { return build(1, 0, n - 1); }
};
seg_tree_lazy stree;
pli path_query(int a, int b) {
pli res = make_pair(inf, -1);
for (; up[a] != up[b]; b = par[up[b]]) {
if (depth[up[a]] > depth[up[b]]) swap(a, b);
res = min(res, stree.query(in[up[b]], in[b]));
}
if (depth[a] > depth[b]) swap(a, b);
res = min(res, stree.query(in[a], in[b]));
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
init(n);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
pre_dfs(0);
dfs_hld(0);
stree.init(n);
girls.resize(n);
for (int i = 1, c; i <= m; i++) {
cin >> c, c--;
girls[in[c]].emplace_back(i);
}
for (int i = 0; i < n; i++) reverse((girls[i]).begin(), (girls[i]).end());
stree.build();
while (q--) {
int t, v, u, k;
cin >> t;
if (t == 1) {
cin >> v >> u >> k;
v--, u--;
vector<int> ans;
while (k--) {
pli res = path_query(u, v);
if (res.second == -1) break;
ans.emplace_back(girls[res.second].back());
girls[res.second].pop_back();
stree.update(res.second);
}
cout << ans.size() << ' ';
for (int i : ans) cout << i << ' ';
cout << '\n';
}
if (t == 2) {
cin >> v >> k, v--;
stree.add(in[v], in[v] + siz[v] - 1, k);
}
}
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
char str[101000];
vector<int> vt[2][30];
long long cnt[30], l;
void init(int cur) {
int i, j;
for (i = 0; i < 26; i++) {
vt[cur][i].clear();
cnt[i] = 0;
}
}
int main() {
int i, j, k, cur, flag, it, jt;
string res;
long long sum;
while (scanf("%s", str) != EOF) {
scanf("%d", &k);
res.clear();
l = strlen(str);
sum = l;
sum *= (1 + l);
sum /= 2;
if (k > sum) {
printf("No such line.\n");
continue;
}
cur = 0;
init(cur);
for (i = 0; i < l; i++) {
vt[cur][str[i] - 'a'].push_back(i);
cnt[str[i] - 'a'] += l - i;
}
sum = 0;
res = "";
while (k) {
sum = 0;
for (i = 0; i < 26; i++) {
if (sum + cnt[i] >= k) {
k -= sum;
break;
} else
sum += cnt[i];
}
if (k <= vt[cur][i].size()) {
k = 0;
res += i + 'a';
break;
} else {
res += i + 'a';
k -= vt[cur][i].size();
}
init(1 - cur);
for (it = 0; it < vt[cur][i].size(); it++) {
j = vt[cur][i][it] + 1;
if (j >= l) continue;
vt[1 - cur][str[j] - 'a'].push_back(j);
cnt[str[j] - 'a'] += l - j;
}
cur = 1 - cur;
}
cout << res << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
struct data {
int ele1, ele2, ele3;
data() {}
data(int a, int b, int c) { ele1 = a, ele2 = b, ele3 = c; }
bool friend operator<(data a, data b) { return a.ele1 > b.ele1; }
};
int n, m;
long long N, M, K;
double dp[1003][10004];
int vis[1003][10004];
double sol(int i, int baki) {
if (i == n) return 1.0;
if (baki == 0) return 0.0;
double &ret = dp[i][baki];
if (vis[i][baki]) return ret;
vis[i][baki] = 1;
ret = 0;
ret = (sol(i + 1, baki - 1) * (n - i) * 1.0) / (n * 1.0);
ret += (sol(i, baki - 1) * i * 1.0 / (n * 1.0));
return ret;
}
int main() {
int t, tc = 1;
scanf("%d %d", &n, &m);
while (m--) {
int ans = 0;
double k;
scanf("%lf", &k);
int l = 0, h = 10000;
while (l <= h) {
int mid = (l + h) / 2;
if (sol(0, mid) * 2000.00 >= k) {
ans = mid;
h = mid - 1;
} else {
l = mid + 1;
}
}
printf("%d", ans);
puts("");
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long maxx = 1e9 + 7;
bool compare(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first > b.first;
}
long long inline power(long long a, long long b, long long p) {
a %= p;
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
long long inv(long long n, long long p) { return power(n, p - 2, p); }
bool inline 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 = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
template <class T>
void printv(T &v, long long n) {
if (n == -1) n = v.size();
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << "\n";
}
void solve() {
long long n, k, idx;
cin >> n >> k;
idx = n;
string t;
cin >> t;
string ans = "";
for (long long i = 1; i <= n - 1; i++) {
if (t.substr(i) == t.substr(0, n - i)) {
idx = i;
break;
}
}
for (long long i = 0; i < k; i++) {
ans += t.substr(0, idx);
}
if (idx < n) ans += t.substr(idx);
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long test = 1;
while (test--) {
solve();
}
}
| 5 |
//Have A Good Day Traveller:)
//Author: Saksham Goel
#include<bits/stdc++.h>
#include<queue>
#include<vector>
#define MOD 1000000007
#define endl "\n"
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);
#define int long long int
#define lli long long int
#define mp(x,y) make_pair(x,y)
using namespace std;
void solve(){
int n;
cin>>n;
vector<int> v;
if(n==1){
cout<<9<<endl;
return;
}
v.push_back(9);
v.push_back(8);
int temp=9;
for(int i=3;i<=n;i++){
if(temp==10)
temp-=10;
v.push_back(temp);
temp++;
}
for(int i:v){
cout<<i;
}
cout<<endl;
}
int32_t main(){
fastio;
int t;
cin>>t;
while(t--)
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int neigh[5][2] = {{0, 0}, {1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int best, m, n;
int a[50][50];
void search(int x) {
int i, j, k, b1, x1, y1, xx, yy, x2, y2;
vector<pair<int, int> > tmp;
b1 = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++)
if (a[i][j] == 0) {
b1 = 1;
break;
}
if (b1 == 1) break;
}
if (b1 == 0) {
best = x;
return;
}
if (x + 1 >= best) return;
xx = i, yy = j;
for (k = 0; k < 5; k++) {
x2 = xx + neigh[k][0];
y2 = yy + neigh[k][1];
if ((x2 >= 0) && (x2 < m) && (y2 >= 0) && (y2 < n)) {
tmp.clear();
for (i = 0; i < 5; i++) {
x1 = x2 + neigh[i][0];
y1 = y2 + neigh[i][1];
if ((x1 >= 0) && (x1 < m) && (y1 >= 0) && (y1 < n) &&
(a[x1][y1] == 0)) {
tmp.push_back(make_pair(x1, y1));
a[x1][y1] = 1;
}
}
search(x + 1);
for (i = 0; i < tmp.size(); i++) a[tmp[i].first][tmp[i].second] = 0;
}
}
}
int main() {
cin >> m >> n;
memset(a, 0, sizeof(a));
best = m * n;
search(0);
cout << m * n - best;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
signed t;
cin >> t;
string str;
for (signed i = 0; i < t; ++i) {
cin >> str;
signed cnt = 0;
while (true) {
string nw = "";
signed t1, t2;
if (str.size() == 0) {
break;
}
for (signed i = 0; i < str.size() - 1; ++i) {
if (str[i] != str[i + 1]) {
t1 = i;
t2 = i + 1;
goto th;
}
}
break;
th : {}
for (signed i = 0; i < str.size(); ++i) {
if (i != t1 && i != t2) nw += " ", nw[nw.size() - 1] = str[i];
}
str = nw;
++cnt;
}
if (cnt % 2 == 0) {
cout << "NET" << endl;
} else {
cout << "DA" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Rec {
int x1, y1, x2, y2;
} r1, r2;
Rec u(Rec a, Rec b) {
Rec c;
c.x2 = max(min(a.x1, a.x2), min(b.x1, b.x2));
c.x1 = min(max(a.x1, a.x2), max(b.x1, b.x2));
c.y2 = max(min(a.y1, a.y2), min(b.y1, b.y2));
c.y1 = min(max(a.y1, a.y2), max(b.y1, b.y2));
return c;
}
long long A(Rec a) {
if (a.x1 < a.x2) return 0;
if (a.y1 < a.y2) return 0;
return max(((long long)(a.x1 - a.x2) + 1) * ((long long)(a.y1 - a.y2) + 1),
0LL);
}
int main() {
int t, n, m, x1, y1, x2, y2, U, D, L, R;
long long ans;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d%d%d", &n, &m, &x1, &y1, &x2, &y2);
ans = (long long)(n)*m;
n--;
m--;
x1--;
x2--;
y1--;
y2--;
U = n - max(x1, x2);
D = min(x1, x2);
R = m - max(y1, y2);
L = min(y1, y2);
r1 = (Rec){x1 + U, y1 + R, x1 - D, y1 - L};
r2 = (Rec){x2 + U, y2 + R, x2 - D, y2 - L};
ans -= A(r1) + A(r2);
ans += A(u(r1, r2));
cout << ans << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long popcount(long long l, long long r) {
long long ans = 0;
while (1) {
if (l == r) {
ans += l;
break;
} else {
long long temp1 = log2(r);
temp1 = pow(2, temp1);
long long temp3 = temp1 * 2 - 1;
if (temp3 == r) {
ans += temp3;
break;
}
long long temp2 = temp1 - 1;
if (temp2 >= l) {
ans += temp2;
break;
} else {
ans += temp1;
l = l ^ temp1;
r = r ^ temp1;
}
}
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
long long l, r;
cin >> l;
cin >> r;
long long ans = popcount(l, r);
cout << ans << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct edge {
int v, nx;
long long w;
} E[201000 * 2 + 101000 * 2];
int head[101000], EN;
void init_edge() {
EN = 0;
memset(head, -1, sizeof(head));
}
void add_edge(int u, int v, long long w) {
E[EN] = (edge){v, head[u], w};
head[u] = EN++;
E[EN] = (edge){u, head[v], w};
head[v] = EN++;
}
int n, m, u, v;
bool vis[101000];
long long w, ans, po[222], dep[101000];
struct gauss {
int cnt[61][2], num;
long long cir[61], s;
void init() {
memset(cnt, 0, sizeof(cnt));
memset(cir, 0, sizeof(cir));
s = num = 0;
}
void addline(long long w) {
for (int i = 0; i <= 60; ++i) ++cnt[i][(w >> i) & 1];
}
void addcir(long long w) {
s |= w;
for (int i = 60; i >= 0; --i) {
if (((w >> i) & 1) && cir[i] == 0) {
cir[i] = w;
num++;
break;
}
w = min(w, w ^ cir[i]);
}
}
void solve() {
for (int i = 0; i <= 60; ++i)
if ((s >> i) & 1)
ans =
(ans + 1LL * (cnt[i][0] + cnt[i][1]) * (cnt[i][0] + cnt[i][1] - 1) /
2 % MOD * po[i + num - 1] % MOD) %
MOD;
else
ans =
(ans + 1LL * cnt[i][0] * cnt[i][1] % MOD * po[i + num] % MOD) % MOD;
}
} base;
void dfs(int u, int fa, long long w) {
vis[u] = 1;
dep[u] = w;
base.addline(w);
for (int k = head[u]; ~k; k = E[k].nx) {
int v = E[k].v;
long long ww = E[k].w;
if (v == fa) continue;
if (vis[v])
base.addcir(dep[u] ^ dep[v] ^ ww);
else
dfs(v, u, w ^ ww);
}
}
int main() {
po[0] = 1;
for (int i = 1; i <= 200; ++i) po[i] = po[i - 1] * 2 % MOD;
scanf("%d%d", &n, &m);
init_edge();
for (int i = 1; i <= m; ++i) {
scanf("%d%d%I64d", &u, &v, &w);
add_edge(u, v, w);
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
base.init();
dfs(i, 0, 0);
base.solve();
}
printf("%I64d\n", ans % MOD);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int arr1[1000007];
int arr2[1000007];
int arr3[1000007];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr1[i];
arr2[i] = arr1[i];
}
sort(arr2, arr2 + n);
int mini = arr2[0];
int cnt = 0, counter = 0;
for (int i = 0; i < n; i++) {
if (arr2[i] == mini)
cnt++;
else
break;
}
if (arr1[0] == mini) {
for (int i = 0; i < n; i++) {
if (arr1[i] == mini)
counter++;
else
break;
}
}
int rabby = cnt - counter;
if (rabby == 0) {
int pro = 1;
for (int i = 0; i < n; i++) {
if (arr1[i] != arr2[i]) {
pro = 0;
break;
}
}
if (pro == 0)
cout << "-1" << endl;
else
cout << "0" << endl;
} else {
int r = 0, save;
for (int i = n - 1; i >= 0; i--) {
if (arr1[i] == mini) r++;
if (r == rabby) {
save = i;
break;
}
}
int j = 0;
for (int i = save; i < n; i++) arr3[j++] = arr1[i];
for (int i = 0; i < save; i++) arr3[j++] = arr1[i];
int pro = 1;
for (int i = 0; i < n; i++) {
if (arr3[i] != arr2[i]) {
pro = 0;
break;
}
}
if (pro == 0)
cout << "-1" << endl;
else {
int fin = n - save;
cout << fin << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = ((x % p) * (x % p)) % p;
}
return res;
}
long long raichu(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = ((res) * (x));
y = y >> 1;
x = ((x) * (x));
}
return res;
}
bool isprime(long long n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
else {
long long z = sqrt(n);
for (int i = 0; i < z - 1; i++)
if (n % (i + 2) == 0) return false;
return true;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1, T;
T = t;
while (t--) {
int n, m;
cin >> n >> m;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
vector<vector<int> > z(n, vector<int>(m, 0));
for (int i = 0; i < n - 3 + 1; i++) {
for (int j = 0; j < m - 3 + 1; j++) {
int hash = 0;
for (int k = i; k < i + 3; k++) {
for (int p = j; p < j + 3; p++) {
if (!(k == i + 1 && p == j + 1)) {
if (v[k][p] == '#') hash++;
}
}
}
if (hash == 8) {
for (int k = i; k < i + 3; k++) {
for (int p = j; p < j + 3; p++) {
if (!(k == i + 1 && p == j + 1)) z[k][p] = 1;
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j] == '#' && z[i][j] == 0) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int inf = 1e9 + 10;
const long long INF = 1e18;
const long double EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int ans[200200];
pair<int, int> ask(int l, int r) {
cout << "? " << l + 1 << ' ' << r << endl;
int x, f;
cin >> x;
if (x == -1) exit(0);
cin >> f;
return {x, f};
}
void solve(int l, int r) {
if (l >= r) return;
pair<int, int> p = ask(l, r);
int x = p.first, f = p.second;
int l1 = r - f, r1 = l + f;
if (l1 < r1) {
for (int i = (l1); i < (r1); ++i) ans[i] = x;
solve(l, l1);
solve(r1, r);
} else {
int m = (l + r) / 2;
solve(l, m);
solve(m, r);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(25);
int n;
cin >> n;
solve(0, n);
cout << "!";
for (int i = 0; i < (n); ++i) cout << ' ' << ans[i];
cout << '\n';
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b(n);
for (auto& it : a) cin >> it;
for (auto& it : b) cin >> it;
sort(begin(a), end(a));
sort(begin(b), end(b));
for (auto& it : a) cout << it << " ";
cout << "\n";
for (auto& it : b) cout << it << " ";
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
vector<int> a;
bool check(int k) {
bool f = true;
for (int i = 0; i < k; ++i) {
int sum = 0;
for (int j = i; j < a.size(); j += k) sum += a[j];
if (sum % 2 == 1) f = false;
}
return f;
}
vector<int> primes;
vector<int> pows;
vector<int> cur_pows;
int ans;
void perebor_nod(int pos) {
for (int i = 0; i <= pows[pos]; ++i) {
cur_pows[pos] = i;
if (pos + 1 == primes.size()) {
int nod = 1;
int phi = 1;
for (int j = 0; j < primes.size(); ++j) {
nod *= pow(primes[j], cur_pows[j]);
if (pows[j] - cur_pows[j] > 0) {
phi *= pow(primes[j], pows[j] - cur_pows[j] - 1);
phi *= (primes[j] - 1);
}
}
if (check(nod)) ans += phi;
} else {
perebor_nod(pos + 1);
}
}
}
int main() {
cin >> n;
cin >> s;
a.resize(n, 0);
for (int i = 0; i < n; ++i)
if (s[i] == '1') a[i] = 1;
int p = 0;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) {
primes.push_back(i);
pows.push_back(0);
++p;
while (n % i == 0) {
pows[p - 1]++;
n /= i;
}
}
if (n > 1) {
primes.push_back(n);
pows.push_back(1);
++p;
}
cur_pows.resize(p);
ans = 0;
if (a.size() == 1) {
if (a[0] == 0)
ans = 1;
else
ans = 0;
} else
perebor_nod(0);
cout << ans << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int N, i, j, k, A[500001], ans = 0;
int main() {
scanf("%d", &N);
for (int l = 0; l < N; l++) scanf("%d", &A[l]);
i = 1;
while (i < N - 1) {
j = k = i;
while (j < N - 1 && A[j] != A[j - 1] && A[j] != A[j + 1]) j++;
if ((j - i) % 2 == 0) {
while (k < i + (j - i) / 2) A[k++] = A[i - 1];
while (k < j) A[k++] = A[j];
} else {
while (k < j) A[k++] = A[j];
}
ans = max(ans, (j - i) / 2 + ((j - i) % 2 == 1 ? 1 : 0));
i = j + 1;
}
printf("%d\n", ans);
for (int i = 0; i < N; i++) printf("%d ", A[i]);
printf("\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 210000;
const long long base = 1e9 + 7;
struct Node {
int l, r;
};
void solve() {
long long result = 0;
int n, s, m, k;
cin >> n >> s >> m >> k;
vector<int> za(n);
int maxa = -1;
for (int i = 0; i < n; ++i) {
cin >> za[i];
maxa = max(za[i], maxa);
}
vector<vector<Node> > pool(n);
for (int i = 0; i < s; ++i) {
Node z;
cin >> z.l >> z.r;
z.l--;
z.r--;
if (pool[z.l].size() > 0) {
if (pool[z.l].front().r < z.r) {
pool[z.l][0] = z;
}
} else {
pool[z.l].push_back(z);
}
}
auto Work = [&](int r) {
vector<int> acc(n + 1);
acc[0] = 0;
for (int i = 0; i < n; ++i) {
acc[i + 1] = acc[i];
if (za[i] <= r) {
acc[i + 1]++;
}
}
vector<vector<int> > dp(n + 2);
for (int i = 0; i <= n; ++i) {
dp[i] = vector<int>(m + 1, 0);
}
int cr = -1;
for (int i = 0; i < n; ++i) {
if (pool[i].size() > 0) {
Node z = pool[i][0];
cr = max(cr, z.r);
}
int add = acc[cr + 1] - acc[i];
if (add > 0) {
for (int j = 0; j < m; j++) {
dp[cr + 1][j + 1] = max(dp[cr + 1][j + 1], dp[i][j] + add);
}
}
for (int j = 0; j < m + 1; j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
}
}
for (int j = 0; j < m + 1; ++j) {
if (dp[n][j] >= k) return true;
}
return false;
};
bool f = Work(maxa);
if (!f) {
cout << -1;
return;
}
int mina = 0;
while (mina + 1 < maxa) {
int mid = (mina + maxa + 1) / 2;
bool f = Work(mid);
if (f) {
maxa = mid;
} else {
mina = mid;
}
}
cout << maxa << endl;
}
int main() {
const int inId = 0;
const int outId = 0;
if (inId > 0) {
cerr << "redirect stdin to input " << inId << endl;
string s = "input";
s += to_string(inId);
s += ".txt";
auto r = freopen(s.c_str(), "r", stdin);
if (r == nullptr) {
cerr << "invalid input file " << s;
}
}
if (outId > 0) {
cerr << "redirect stdout to stdout " << outId << endl;
string s = "stdout";
s += to_string(outId);
s += ".txt";
auto r = freopen(s.c_str(), "w", stdout);
if (r == nullptr) {
cerr << "invalid output file " << s;
}
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(10);
solve();
}
| 17 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.