solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150 + 5;
int a[N], mx[N][N][N], dp[N][N];
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
string s;
cin >> s;
memset(mx, -1, sizeof mx);
for (int i = 0; i <= n; i++) mx[i][i][0] = dp[i][i] = 0;
for (int len = 1; len <= n; len++)
for (int l = 0, r = len; r <= n; l++, r++) {
if (~mx[l][r - 1][0] && ~a[1]) mx[l][r][0] = mx[l][r - 1][0] + a[1];
if (s[l] == s[r - 1])
for (int k = 0; k <= len - 2; k++)
if (~mx[l + 1][r - 1][k] && ~a[k + 2])
mx[l][r][0] = max(mx[l][r][0], mx[l + 1][r - 1][k] + a[k + 2]);
for (int i = l + 1; i < r - 1; i++)
if (s[i] == s[r - 1] && ~mx[l][i][0] && ~mx[i][r][0])
mx[l][r][0] = max(mx[l][r][0], mx[l][i][0] + mx[i][r][0]);
for (int i = l; i < r; i++)
if (~mx[l][i][0] && ~mx[i + 1][r][0])
mx[l][r][1] = max(mx[l][r][1], mx[l][i][0] + mx[i + 1][r][0]);
for (int k = 2; k <= len; k++) {
if (s[l] == s[r - 1]) mx[l][r][k] = mx[l + 1][r - 1][k - 2];
for (int i = l; i < r; i++) {
if (i > l && ~mx[l][i][0] && ~mx[i][r][k])
mx[l][r][k] = max(mx[l][r][k], mx[l][i][0] + mx[i][r][k]);
if (i < r - 1 && ~mx[l][i + 1][k] && ~mx[i + 1][r][0])
mx[l][r][k] = max(mx[l][r][k], mx[l][i + 1][k] + mx[i + 1][r][0]);
}
}
dp[l][r] = max(mx[l][r][0], 0);
for (int i = l; i < r; i++)
dp[l][r] = max(dp[l][r], dp[l][i] + dp[i + 1][r]);
}
cout << dp[0][n] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)9e18 + 7;
const long long P1 = 353251;
const long long P2 = 239017;
const long long MOD = 1e9 + 7;
const long long MOD1 = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
struct reb {
long long w, p, del, to;
reb() {}
reb(int to1, long long w1, long long p1) {
to = to1;
w = w1;
p = p1;
del = 0;
}
};
int n;
vector<reb> g[2 * 100007];
map<pair<int, int>, long long> ma;
long long ha[2 * 100007];
long long dfs(int v) {
long long sum = 0;
for (int i = 0; i < g[v].size(); i++) {
auto t = g[v][i];
long long now = dfs(t.to);
if (now > t.p) {
cout << -1;
exit(0);
}
long long can = t.p - now;
can = min(can, t.w - 1);
g[v][i].del = can;
ma[{v, t.to}] = g[v][i].del;
sum += now + t.w - g[v][i].del;
}
ha[v] = sum;
return sum;
}
vector<pair<pair<int, int>, pair<long long, long long> > > was;
long long up(int v, long long can) {
long long now = 0;
for (reb t : g[v]) {
if (now == can) break;
now += (long long)t.del;
if (now >= can) {
long long ost = now - can;
now = can;
ma[{v, t.to}] = ost;
break;
} else {
ma[{v, t.to}] = 0;
}
long long sd = up(t.to, min(t.p - ha[t.to], can - now));
now += sd;
}
return now;
}
const bool is_testing = 0;
int main() {
srand('D' + 'E' + 'N' + 'I' + 'S' + 'S' + 'O' + 'N');
if (is_testing) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
} else {
}
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int first, second, w, p;
scanf("%d %d %d %d", &first, &second, &w, &p);
first--;
second--;
g[first].push_back(reb(second, w, p));
was.push_back({{first, second}, {w, p}});
}
dfs(0);
up(0, LINF);
printf("%d\n", n);
for (auto c : was) {
int mi = ma[{c.first.first, c.first.second}];
printf("%d %d %d %d\n", c.first.first + 1, c.first.second + 1,
(int)(c.second.first - mi), (int)(c.second.second - mi));
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
long long mod = 1000000007;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define rep(i, a, n) for (long long i = a; i < (n); i++)
long long modpow(long long m, long long n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2);
return (t * t) % mod;
} else {
return (modpow(m, n - 1) * m) % mod;
}
}
bool bitcheck(ll x, ll y) { return (x >> y) & 1; }
template <typename A, size_t N, typename T> void Fill(A (&array)[N], const T& val) {
std::fill((T*)array, (T*)(array + N), val);
}
// long long mod = 998244353;
long long power(long long m, long long n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2);
return t * t;
} else {
return modpow(m, n - 1) * m;
}
}
long long moddiv(long long a, long long b) { return (a * modpow(b, mod - 2)) % mod; }
const ll INF = 1LL << 60;
void print_binary(long long a) {
for (int i = 31; i >= 0; i--) {
cout << (a >> i & 1);
}
cout << endl;
}
ll nCkmod(ll n, ll k) {
ll denomi = 1;
for (int i = n; i > n - k; i--) {
denomi *= i;
denomi %= mod;
}
ll numera = 1;
REP(i, k) {
numera *= (i + 1);
numera %= mod;
}
return moddiv(denomi, numera);
}
map<ll, ll> cnt;
void primeFactors(long long n) {
while (n % 2 == 0) {
cnt[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cnt[i]++;
n = n / i;
}
}
if (n > 2) {
cnt[n]++;
}
}
int main() {
ll q;
cin >> q;
set<ll> s;
REP(i, q) {
ll a, b;
cin >> a >> b;
if (a == 0) {
s.insert(b);
cout << s.size() << endl;
} else if (a == 1) {
cout << s.count(b) << endl;
} else if (a == 2) {
s.erase(b);
} else {
ll r;
cin >> r;
s.lower_bound(b);
auto it1 = s.lower_bound(b);
auto it2 = s.upper_bound(r);
for (auto it = it1; it != it2; it++) {
cout << *it << endl;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 500005;
long long int tree[4 * N][2][2];
string a;
long long int n, q;
void build(long long int node, long long int s, long long int e) {
if (s == e) {
long long int x = a[s] - '0' + 1;
long long int y = 10 - x;
y *= (a[s - 1] == '1' && a[s] != '9');
tree[node][0][0] = x;
tree[node][0][1] = y;
tree[node][1][0] = 1;
tree[node][1][1] = 0;
return;
}
long long int mid = (s + e) / 2;
build(2 * node, s, mid);
build(2 * node + 1, mid + 1, e);
long long int p[2][2], q[2][2];
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) p[i][j] = tree[2 * node + 1][i][j];
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) q[i][j] = tree[2 * node][i][j];
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) tree[node][i][j] = 0;
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++)
for (long long int k = 0; k < 2; k++)
tree[node][i][j] += (p[i][k] * q[k][j]) % 998244353;
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) tree[node][i][j] %= 998244353;
}
void upd(long long int node, long long int s, long long int e,
long long int idx) {
if (s == e) {
long long int x = a[s] - '0' + 1;
long long int y = 10 - x;
y *= (a[s - 1] == '1' && a[s] != '9');
tree[node][0][0] = x;
tree[node][0][1] = y;
tree[node][1][0] = 1;
tree[node][1][1] = 0;
return;
}
long long int mid = (s + e) / 2;
if (idx <= mid)
upd(2 * node, s, mid, idx);
else
upd(2 * node + 1, mid + 1, e, idx);
long long int p[2][2], q[2][2];
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) p[i][j] = tree[2 * node + 1][i][j];
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) q[i][j] = tree[2 * node][i][j];
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) tree[node][i][j] = 0;
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++)
for (long long int k = 0; k < 2; k++)
tree[node][i][j] += (p[i][k] * q[k][j]) % 998244353;
for (long long int i = 0; i < 2; i++)
for (long long int j = 0; j < 2; j++) tree[node][i][j] %= 998244353;
}
void solve() {
cin >> n >> q;
cin >> a;
a = '*' + a;
build(1, 1, n);
while (q--) {
long long int x;
char d;
cin >> x >> d;
a[x] = d;
upd(1, 1, n, x);
upd(1, 1, n, x + 1);
cout << tree[1][0][0] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cout.precision(20);
long long int t = 1;
for (long long int i = 1; i <= t; i++) {
if (0) cout << "Case #" << i << ": ";
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
for (int i = 0; i < (1 << 3); i++) {
int ans = s[0] - '0';
string t = "";
t += s[0];
for (int j = 0; j < 3; j++) {
if (i & (1 << j)) {
ans += s[j + 1] - '0';
t += '+';
} else {
ans -= s[j + 1] - '0';
t += '-';
}
t += s[j + 1];
}
if (ans == 7) {
cout << t + "=7\n" << endl;
return 0;
}
}
} | 0 |
#include<iostream>
using namespace std;
#define lp(i,n) for(int i=1;i<=n;i++)
int main(){
int n;
while(1){
cin>>n;
if(n == 0) break;
int a=0, count=0;
string s;
lp(i,n){
cin>>s;
if(s=="lu") a++;
if(s=="ld") a--;
if(s=="ru") a++;
if(s=="rd") a--;
if(a == 2 || a == -2) count++;
if(i % 2 == 0) a=0;
}
cout<<count<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string p, c;
map<string, string> pl, cl;
int q;
string find_parent(string x) {
while (pl[x] != x) {
x = pl[x];
}
return x;
}
int main() {
cin >> q;
for (int i = 0; i < q; i++) {
cin >> c >> p;
if (pl.find(p) == pl.end()) {
pl[p] = p;
}
if (cl.find(c) == cl.end()) {
cl[c] = c;
}
pl[c] = p;
cl[p] = c;
}
int cnt = 0;
for (auto x : cl) {
if (x.first == x.second) {
cnt++;
}
}
cout << cnt << endl;
for (auto x : cl) {
if (x.first == x.second) {
cout << x.first << " " << find_parent(x.first) << endl;
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
int H,W;
string S[222];
int dp[2][1<<16];
int pc[1<<16];
signed main(){
cin.tie(0);ios_base::sync_with_stdio(0);
for(int i=0;i<1<<16;i++)pc[i]=__builtin_popcount(i);
cin>>H>>W;
S[0]="";
rep(i,H)cin>>S[i+1];
fill_n(*dp,2*(1<<16),INT_MIN);
dp[0][0]=0;
int mask=(1<<W)-1;
for(int t=0;t<H*W;t++){
const int i=t/W,j=t%W,p=t&1,q=(t+1)&1;
const int beet=(1<<(W-1));
const int ei=(1<<W);
for(int k=0;k<beet;k++){
if(dp[p][k]==INT_MIN)continue;
chmax(dp[q][(k<<1)&mask],dp[p][k]);
int l=pc[k&((1<<j)-1)];
if(l<S[i+1].size()){
int po=0;
if(j&&(k&1)&&S[i+1][l]==S[i+1][l-1])po++;
chmax(dp[q][((k<<1)&mask)+1],dp[p][k]+po*2);
}
dp[p][k]=INT_MIN;
}
for(int k=beet;k<ei;k++){
if(dp[p][k]==INT_MIN)continue;
chmax(dp[q][(k<<1)&mask],dp[p][k]);
int l=pc[k&((1<<j)-1)];
if(l<S[i+1].size()){
int po=0;
if(j&&(k&1)&&S[i+1][l]==S[i+1][l-1])po++;
if(S[i][S[i].size()-pc[k]+l]==S[i+1][l])po++;
chmax(dp[q][((k<<1)&mask)+1],dp[p][k]+po*2);
}
dp[p][k]=INT_MIN;
}
if(j==W-1)for(int k=0;k<1<<W;k++)if(pc[k]!=S[i+1].size())dp[q][k]=INT_MIN;
}
int ans=INT_MIN;
rep(i,1<<W)chmax(ans,dp[(H*W)&1][i]);
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 305;
const long long M = 1e5 + 5;
const long long MOD = 1e9 + 7;
long long n, q, t;
long long a[N], cost[N], lvl[N], cache[N][M], vis[N];
vector<long long> g[N], rg[N];
bool findLoop(long long v) {
if (vis[v] == 1) return 1;
if (vis[v] == 2) return 0;
vis[v] = 1;
for (auto &it : g[v]) {
if (findLoop(it)) return 1;
}
vis[v] = 2;
return 0;
}
bool checkLoop() {
fill(vis + 1, vis + n + 1, 0);
for (long long i = 1; i <= n; i++) {
if (!vis[i] && findLoop(i)) return 1;
}
return 0;
}
long long dfs(long long x) {
long long &ans = cost[x];
if (ans != -1) return ans;
ans = a[x];
long long level = 0;
for (auto &it : g[x]) ans += dfs(it);
return ans;
}
long long dfs2(long long x) {
long long &ans = lvl[x];
if (ans != -1) return ans;
ans = 0;
for (auto &it : rg[x]) ans = 1 + dfs2(it);
t -= ans * a[x];
return ans;
}
long long dp(long long idx, long long val) {
if (val < 0) return 0;
if (val == 0) return 1;
if (idx == n + 1) return 0;
long long &ans = cache[idx][val];
if (ans != -1) return ans;
ans = dp(idx + 1, val) + dp(idx, val - cost[idx]);
ans %= MOD;
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(cost, -1, sizeof(cost));
memset(cache, -1, sizeof(cache));
memset(lvl, -1, sizeof(lvl));
cin >> n >> q >> t;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= q; i++) {
long long b, c;
cin >> b >> c;
g[c].push_back(b);
rg[b].push_back(c);
}
if (checkLoop()) {
cout << 0;
return 0;
}
for (long long i = 1; i <= n; i++) cost[i] = dfs(i);
for (long long i = 1; i <= n; i++) dfs2(i);
long long ans = dp(1, t);
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct V {
int v[10];
} a[101000];
int n, m, T;
namespace tr {
struct P {
V le, ri;
int ans, fa[20];
int GF(int x) { return x == fa[x] ? x : fa[x] = GF(fa[x]); }
void UN(int x, int y) {
if (GF(x) != GF(y)) fa[fa[x]] = fa[y];
}
} p[404000];
int Cnt(V x) {
int t = 1;
for (int i = 1; i < m; i++) t += x.v[i] != x.v[i - 1];
return t;
}
int f[44];
int Gf(int x) { return x == f[x] ? x : f[x] = Gf(f[x]); }
void un(int x, int y) {
if (Gf(x) != Gf(y)) f[f[x]] = f[y];
}
P operator+(P p1, P p2) {
P res;
res.le = p1.le;
res.ri = p2.ri;
res.ans = p1.ans + p2.ans;
for (int i = 0; i < 20; i++) res.fa[i] = i;
for (int i = 0; i < 20; i++) {
f[i] = p1.fa[i];
f[i + 20] = p2.fa[i] + 20;
}
for (int i = 0; i < m; i++) {
if (p1.ri.v[i] == p2.le.v[i]) {
if (Gf(i + 10) != Gf(i + 20)) {
res.ans--;
un(i + 10, i + 20);
}
}
}
for (int i = 0; i < m; i++)
for (int j = i + 1; j < m; j++)
if (Gf(i) == Gf(j)) res.UN(i, j);
for (int i = 0; i < m; i++)
for (int j = i + 1; j < m; j++)
if (Gf(i + 30) == Gf(j + 30)) res.UN(i + 10, j + 10);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++)
if (Gf(i) == Gf(j + 30)) res.UN(i, j + 10);
return res;
}
void B(int x, int l, int r) {
if (l == r) {
p[x].le = p[x].ri = a[l];
p[x].ans = Cnt(a[l]);
for (int i = 0; i < 10; i++) p[x].fa[i] = i + 10;
for (int i = 10; i < 20; i++) p[x].fa[i] = i;
for (int i = 1; i < m; i++)
if (a[l].v[i] == a[l].v[i - 1]) p[x].UN(i, i - 1);
return;
}
int mid = l + r >> 1;
B(x << 1, l, mid);
B(x << 1 | 1, mid + 1, r);
p[x] = p[x << 1] + p[x << 1 | 1];
}
P Q(int x, int l, int r, int st, int en) {
if (l == st && r == en) return p[x];
int mid = l + r >> 1;
if (en <= mid) return Q(x << 1, l, mid, max(st, l), min(en, mid));
if (st > mid) return Q(x << 1 | 1, mid + 1, r, max(st, mid + 1), min(en, r));
return Q(x << 1, l, mid, max(st, l), min(en, mid)) +
Q(x << 1 | 1, mid + 1, r, max(st, mid + 1), min(en, r));
}
} // namespace tr
int main() {
scanf("%d%d%d", &m, &n, &T);
for (int i = 0; i < m; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[j].v[i]);
tr::B(1, 1, n);
for (int x, y; T--; printf("%d\n", tr::Q(1, 1, n, x, y).ans))
scanf("%d%d", &x, &y);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct turn {
int me, you, idx;
turn(){};
turn(int me, int you, int idx) {
this->me = me;
this->you = you;
this->idx = idx;
}
};
int N;
int used[1 << 21];
char a[1 << 21], b[1 << 21];
turn ab[1 << 21], ba[1 << 21];
void scan() {
scanf("%d", &N);
scanf("%s%s", a, b);
}
inline int f(const turn &t1, const turn &t2) {
return (t1.me * 2 + t1.you) > (t2.me * 2 + t2.you);
}
int winner() {
for (int i = 0; i < N; ++i)
if (a[i] > b[i])
return 0;
else if (b[i] > a[i])
return 1;
return 2;
}
void solve() {
for (int i = 0; i < 2 * N; ++i) {
ab[i] = turn(a[i] - '0', b[i] - '0', i);
ba[i] = turn(b[i] - '0', a[i] - '0', i);
}
sort(ab, ab + 2 * N, f);
sort(ba, ba + 2 * N, f);
int idx1 = 0, idx2 = 0;
for (int i = 0; i < N; ++i) {
while (used[ab[idx1].idx]) ++idx1;
a[i] = ab[idx1].me;
used[ab[idx1].idx] = 1;
while (used[ba[idx2].idx]) ++idx2;
b[i] = ba[idx2].me;
used[ba[idx2].idx] = 1;
}
int ans = winner();
if (ans == 0)
printf("First\n");
else if (ans == 1)
printf("Second\n");
else
printf("Draw\n");
}
int main() {
scan();
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
double x, y, a[100000], b[100000], v, v1, s1, w1, q1, s2;
double s = 3.141592653589793238, q, w, d, mi = 1e30, ma, s3;
int main() {
cin >> n >> x >> y;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
mi = min(mi, sqrt((a[i] - x) * (a[i] - x) + (b[i] - y) * (b[i] - y)));
ma = max(ma, sqrt((a[i] - x) * (a[i] - x) + (b[i] - y) * (b[i] - y)));
}
a[n] = a[0];
b[n] = b[0];
for (int i = 0; i < n; i++) {
q = (b[i] - b[i + 1]) / (a[i] - a[i + 1]);
w = (b[i] - (q * a[i]));
q1 = -1 / q;
if (b[i] != b[i + 1] && a[i] != a[i + 1]) {
w1 = (y - (q1 * x));
v = (w1 - w) / (q - q1);
v1 = q * v + w;
} else if (b[i] == b[i + 1]) {
v = x;
v1 = w;
} else if (a[i] == a[i + 1]) {
v1 = y;
v = a[i];
}
d = sqrt((x - v) * (x - v) + (y - v1) * (y - v1));
s2 = (a[i] - a[i + 1]) * (a[i] - a[i + 1]) +
(b[i] - b[i + 1]) * (b[i] - b[i + 1]);
s1 = (a[i] - v) * (a[i] - v) + (b[i] - v1) * (b[i] - v1);
s3 = (a[i + 1] - v) * (a[i + 1] - v) + (b[i + 1] - v1) * (b[i + 1] - v1);
if (s1 <= s2 && s3 <= s2) mi = min(mi, d);
}
ma = ma * ma * s;
mi = mi * mi * s;
ma -= mi;
cout << setprecision(18) << ma << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
void read(int &x) {
x=0;int f=1;char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
void print(int x) {
if(x<0) putchar('-'),x=-x;
if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}
#define lf double
#define ll long long
#define pii pair<int,int >
#define vec vector<int >
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define data asd09123jdf02i3h
#define FOR(i,l,r) for(int i=l,i##_r=r;i<=i##_r;i++)
const int maxn = 1e6+10;
const int inf = 1e9;
const lf eps = 1e-8;
const int mod = 1e9+7;
struct node {
int a[26],s;
node () {memset(a,0,sizeof a);}
node operator + (const node &x) const {
node c;
for(int i=0;i<26;i++) c.a[i]=a[i]+x.a[i];
c.s=s+x.s;
return c;
}
node operator - (const node &x) const {
node c;
for(int i=0;i<26;i++) c.a[i]=a[i]-x.a[i];
c.s=s-x.s;
return c;
}
}f[100];
int tot,n,p,nxt[maxn];
char s[maxn];
void gao() {
for(int i=2;i<=n;i++) {
int j=nxt[i-1];
while(j&&s[j+1]!=s[i]) j=nxt[j];
if(s[j+1]==s[i]) nxt[i]=j+1;
}
}
node solve(int r) {
node ans;
for(int i=tot;~i;i--) {
if(r<f[i].s) continue;
r-=f[i].s,ans=ans+f[i];
}
for(int i=1;i<=r;i++) ans.a[s[i]-'a']++;
return ans;
}
signed main() {
scanf("%s",s+1),n=strlen(s+1)/2;
gao();int p=n-nxt[n];
for(int i=1;i<=n;i++) f[0].a[s[i]-'a']++;f[1]=f[0];
for(int i=1;i<=p;i++) f[1].a[s[i]-'a']++;
f[0].s=n,f[1].s=n+p;tot=1;
for(int i=2;f[i-1].s+f[i-2].s<=1e18;i++) f[++tot]=f[i-1]+f[i-2];
int l,r;read(l),read(r);
node ans=solve(r)-solve(l-1);
for(int i=0;i<26;i++) printf("%lld ",ans.a[i]);puts("");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
char s[200];
vector<int> __v;
__v.assign(1000000, 127);
cin >> s;
int n;
cin >> n;
set<int> n_del['z' - 'a' + 1];
set<int>::iterator pos_n_del['z' - 'a' + 1];
for (int i = 0; i < n; i++) {
char c;
int nc;
cin >> nc >> c;
set<int>::iterator it = n_del[c - 'a'].begin();
if (n_del[c - 'a'].empty() || nc <= *it) {
n_del[c - 'a'].insert(nc - 1);
continue;
}
nc -= *it;
int pos = 0;
while (it != n_del[c - 'a'].end() && nc > 0) {
set<int>::iterator it0 = it;
it++;
if (it != n_del[c - 'a'].end()) {
nc -= *it - *it0 - 1;
}
}
if (nc > 0) {
it--;
pos = *it + nc;
} else
pos = *it + nc - 1;
n_del[c - 'a'].insert(pos);
}
for (int i = 0; i < 'z' - 'a' + 1; ++i) {
pos_n_del[i] = n_del[i].begin();
}
int tSums['z' - 'a' + 1] = {0};
for (int i = 0, len = strlen(s), j = 0; i < len * k; ++i, ++j) {
if (j == len) j = 0;
if (pos_n_del[s[j] - 'a'] != n_del[s[j] - 'a'].end() &&
*pos_n_del[s[j] - 'a'] == tSums[s[j] - 'a']) {
pos_n_del[s[j] - 'a']++;
} else
cout << s[j];
tSums[s[j] - 'a']++;
}
cout << endl;
cerr << __v[rand() % __v.size()];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
template <typename T>
T sqr(T a) {
return a * a;
}
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
int n;
int lf, rg, all;
char buf[10];
int main() {
cin >> n;
gets(buf);
for (int i = 0; i < int(n); ++i) {
string s;
gets(buf);
s = buf;
if (int((s).size()) == 4) all++;
if (s == "UL" || s == "DR") lf++;
if (s == "UR" || s == "DL") rg++;
}
pair<int, int> s1 = pair<int, int>(0, 0);
pair<int, int> s2 = pair<int, int>(-lf - all, -lf - all);
pair<int, int> s3 = pair<int, int>(rg - lf, -lf - rg - 2 * all);
pair<int, int> s4 = pair<int, int>(rg + all, -rg - all);
long long ans = (abs(s2.first) + 1) * 1ll * (s4.first + 1);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
vector<vector<long long int>> v;
long long int T = 0;
vector<long long int> dep;
bool visited[MAX];
vector<long long int> par;
vector<long long int> tin, tout, a;
long long int f = 0, k = 1;
void dfs(long long int s, long long int p = -1, long long int d = 0) {
dep[s] = d;
for (auto it : v[s]) {
if (it == p) continue;
dfs(it, s, d + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int n;
cin >> n;
v = vector<vector<long long int>>(n + 1);
par = dep = vector<long long int>(n + 1);
long long int x;
for (long long int i = 2; i <= n; i++) {
cin >> x;
v[x].push_back(i);
v[i].push_back(x);
}
dfs(1);
long long int hash[n + 1];
memset(hash, 0, sizeof(hash));
for (long long int i = 1; i <= n; i++) {
hash[dep[i]]++;
}
long long int cnt = 0;
for (long long int i = 0; i <= n; i++) {
if (hash[i] & 1) cnt++;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int a[maxn];
bool vis[maxn];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int en = n;
printf("1");
for (int i = 1; i <= n; ++i) {
vis[a[i]] = true;
while (vis[en]) en--;
printf(" %d", i - (n - en) + 1);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[222222];
int main() {
long n, k;
cin >> n >> k;
for(int i = 0; i < n; i++)
cin >> a[i + 1];
vector<int> b = {1};
int i = 1, x = 1;
for(;; i++) {
b.push_back(x = a[x]);
if(i % 2 == 0 && b[i / 2] == b[i])
break;
}
cout << b[k < i ? k : k % (i / 2) + i / 2] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
struct edge {
int to, next, id;
} e[N * 2];
int head[N], q[N], nx[N], tot, n, m;
int X[N], Y[N], f[N], del[N], to[N];
int dfn[N], low[N], fa[N], faid[N];
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
}
void tarjan(int x) {
dfn[x] = low[x] = ++*dfn;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa[x]) {
if (!dfn[e[i].to]) {
fa[e[i].to] = x;
faid[e[i].to] = e[i].id;
tarjan(e[i].to);
low[x] = min(low[x], low[e[i].to]);
} else
low[x] = min(low[e[i].to], low[x]);
}
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa[x] && fa[e[i].to] != x && dfn[e[i].to] > dfn[x]) {
*q = 0;
q[++*q] = e[i].id;
for (int j = e[i].to; j != x; j = fa[j]) q[++*q] = faid[j];
int idd = 1;
for (int j = (int)(1); j <= (int)(*q); j++) nx[j] = (j == *q ? 1 : j + 1);
for (int j = (int)(2); j <= (int)(*q); j++)
if (q[j] < q[idd]) idd = j;
int p1 = idd;
for (; nx[p1] != idd && q[nx[p1]] > q[p1]; p1 = nx[p1])
;
int p2 = p1;
for (; nx[p1] != idd && q[nx[p1]] < q[p1]; p1 = nx[p1])
;
if (nx[p1] == idd) to[q[p2]] = q[idd];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(m); i++) {
scanf("%d%d", &X[i], &Y[i]);
add(X[i], Y[i], i);
add(Y[i], X[i], i);
}
tarjan(1);
for (int i = (int)(1); i <= (int)(n); i++) f[i] = 1;
for (int i = (int)(m); i >= (int)(1); i--) {
int v = f[X[i]] + f[Y[i]] - del[i];
del[to[i]] = f[X[i]] = f[Y[i]] = v;
}
for (int i = (int)(1); i <= (int)(n); i++) printf("%d ", f[i] - 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long int>> arr(n, vector<long long int>(m));
vector<int> mat(n);
for (int i = 0; i < n; i++) {
long long int mx = 1e18;
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
mx = min(arr[i][j], mx);
}
mat.push_back(mx);
}
cout << *max_element(mat.begin(), mat.end()) << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, h;
cin >> n >> m >> h;
int a = 0;
int b = 0;
int c = n - 1;
int current;
for (int i = 0; i < m; i++) {
cin >> current;
if (i == h - 1) {
a += current - 1;
} else {
b += current;
}
}
if (c > a + b) {
cout << -1.0 << endl;
return 0;
}
double result = 1.0;
for (int i = a; i >= 1; i--) {
result *= double(i + b - c) / double(i + b);
}
result = 1.0 - result;
cout << fixed << setprecision(15) << result << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> data;
map<int, int> cache;
int CheckWinner(int powers) {
if (cache.count(powers)) {
return cache[powers];
}
int high = 0;
while (powers >= (1 << high)) {
high++;
}
set<int> res;
for (int i = 0; i < high; ++i) {
int sub_power = (powers >> (i + 1)) | (powers & ((1 << i) - 1));
res.insert(CheckWinner(sub_power));
}
int i;
for (i = 0; res.count(i); ++i) {
}
cache[powers] = i;
return i;
}
int main() {
int n;
cin >> n;
data.resize(n);
for (int i = 0; i < n; ++i) {
cin >> data[i];
}
map<int, int> divisors;
for (int i = 0; i < n; ++i) {
for (int j = 2; data[i] != 1 && j * j <= data[i]; ++j) {
int k;
for (k = 0; data[i] % j == 0; ++k, data[i] /= j) {
}
if (k > 0) {
divisors[j] |= 1 << (k - 1);
}
}
if (data[i] != 1) {
divisors[data[i]] |= 1;
}
}
cache[0] = 0;
int res = 0;
for (auto it : divisors) {
res ^= CheckWinner(it.second);
}
if (res) {
cout << "Mojtaba" << endl;
} else {
cout << "Arpa" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int lzw = 100000 + 3;
int head[lzw], tot, n;
double ans;
struct edge {
int to, next;
} e[lzw << 1];
void add(int a, int b) {
e[++tot].next = head[a];
head[a] = tot;
e[tot].to = b;
}
void dfs(int u, int fa, int dep) {
ans += 1.0 / (double)dep;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == fa) continue;
dfs(e[i].to, u, dep + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0, 1);
printf("%.10lf\n", ans);
return 0;
}
| 3 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <math.h>
#include <assert.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <iostream>
#include <functional>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pi;
#define Fi first
#define Se second
#define pb(x) push_back(x)
#define sz(x) (int)x.size()
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) x.begin(),x.end()
int n, p[510];
double d[510];
void solve(int tc){
scanf("%d", &n);
for(int i=1;i<=n;i++)scanf("%d", p+i);
for(int i=1;i<=n;i++){
d[i] = p[i];
for(int j=i-1;j;j--){
d[i] = max(d[i], d[j] + 2*sqrt(p[i] * p[j]));
}
}
double ans = 0;
for(int i=1;i<=n;i++)ans = max(ans, d[i] + p[i]);
printf("%.8f\n", ans);
}
int main(){
int Tc = 1;// scanf("%d",&Tc);
for(int i=1;i<=Tc;i++){
solve(i);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e6 + 107;
const double pi = acos(-1.0);
const double eps = 0.0000000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline void pr2(T x, int k = 64) {
long long i;
for (i = 0; i < k; i++) fprintf(stderr, "%d", (x >> i) & 1);
putchar(' ');
}
template <typename T>
inline void add_(T &A, int B, long long MOD = M) {
A += B;
(A >= MOD) && (A -= MOD);
}
template <typename T>
inline void mul_(T &A, long long B, long long MOD = M) {
A = (A * B) % MOD;
}
template <typename T>
inline void mod_(T &A, long long MOD = M) {
A %= MOD;
A += MOD;
A %= MOD;
}
template <typename T>
inline void max_(T &A, T B) {
(A < B) && (A = B);
}
template <typename T>
inline void min_(T &A, T B) {
(A > B) && (A = B);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
inline long long powMM(long long a, long long b, long long mod = M) {
long long ret = 1;
for (; b; b >>= 1ll, a = a * a % mod)
if (b & 1) ret = ret * a % mod;
return ret;
}
int startTime;
void startTimer() { startTime = clock(); }
void printTimer() {
fprintf(stderr, "/--- Time: %ld milliseconds ---/\n", clock() - startTime);
}
char str[maxn], nxt[maxn];
int dpnow[maxn], dpnxt[maxn];
int f1[maxn], f2[maxn], f3[maxn], f4[maxn];
int l[maxn], l_pre[maxn], l_suf[maxn];
int get(int A[], int l, int r) {
if (l > r) return 0;
return (A[r] - A[l - 1] + M) % M;
}
int main() {
int _, i, j;
int n;
scanf("%d", &n);
int lpre, lnow;
dpnow[1] = 1;
lpre = lnow = 0;
for (_ = 1; _ <= n; _++) {
scanf("%s", nxt + 1);
lnow = strlen(nxt + 1);
nxt[lnow + 1] = 1;
for (i = lnow + 1; i >= 1; i--) {
if (i > lpre || nxt[i] != str[i + 1])
l_suf[i] = i;
else
l_suf[i] = l_suf[i + 1];
if (i > lpre || nxt[i] != str[i - 1])
l_pre[i] = i;
else
l_pre[i] = l_pre[i + 1];
if (i > lpre || nxt[i] != str[i])
l[i] = i;
else
l[i] = l[i + 1];
}
auto cmp = [&](int i, int j) {
if (i == lnow + 1)
return l[1] < j ? str[l[1]] <= nxt[l[1]]
: str[l_suf[j] + 1] <= nxt[l_suf[j]];
if (j == lnow + 1)
return l[1] < i ? str[l[1]] <= nxt[l[1]]
: str[l_pre[i + 1] - 1] <= nxt[l_pre[i + 1]];
if (l[1] < min(i, j)) return str[l[1]] <= nxt[l[1]];
if (i <= j)
return l_pre[i + 1] - 1 < j ? str[l_pre[i + 1] - 1] <= nxt[l_pre[i + 1]]
: str[l[j + 1]] <= nxt[l[j + 1]];
if (j < i)
return l_suf[j] < i ? str[l_suf[j] + 1] <= nxt[l_suf[j]]
: str[l[i + 1]] <= nxt[l[i + 1]];
return false;
};
for (i = 1; i <= lnow + 1; i++) {
dpnxt[i] = 0;
int low = 0;
if (i != lnow + 1) low = lpre + 1;
for (j = low; j <= lpre + 1; j++) {
if (i != lnow + 1 && j != lpre + 1) continue;
if (cmp(i, j)) add_(dpnxt[i], dpnow[j]);
}
}
{
int j;
for (j = 0; j <= max(lnow + 1, lpre + 1); j++)
f1[j] = f2[j] = f3[j] = f4[j] = 0;
for (j = 1; j <= max(lnow + 1, lpre + 1); j++) {
if (j == lpre + 1) continue;
if (j <= lpre + 1) f1[j] = dpnow[j];
if (j <= lpre + 1 && str[l[j + 1]] <= nxt[l[j + 1]]) f2[j] = dpnow[j];
if (j <= lpre + 1 && str[l_suf[j] + 1] <= nxt[l_suf[j]] && j <= l[1]) {
int l = max(j + 1, l_suf[j] + 1), r = lnow + 1;
if (l <= r) {
add_(f3[l], dpnow[j]);
add_(f3[r + 1], M - dpnow[j]);
}
}
if (j <= lpre + 1 && j <= l[1]) {
int l = j + 1, r = min(lnow + 1, l_suf[j]);
if (l <= r) {
add_(f4[l], dpnow[j]);
add_(f4[r + 1], M - dpnow[j]);
}
}
}
for (j = 1; j <= max(lnow + 1, lpre + 1); j++) {
add_(f1[j], f1[j - 1]);
add_(f2[j], f2[j - 1]);
add_(f3[j], f3[j - 1]);
add_(f4[j], f4[j - 1]);
}
}
for (i = 1; i <= lnow + 1; i++) {
if (i == lnow + 1) continue;
if (l[1] < i && str[l[1]] <= nxt[l[1]])
add_(dpnxt[i], get(f1, i, lpre + 1));
if (str[l[1]] <= nxt[l[1]]) add_(dpnxt[i], get(f1, l[1] + 1, i - 1));
if (i <= l[1] && str[l_pre[i + 1] - 1] <= nxt[l_pre[i + 1]])
add_(dpnxt[i], get(f1, max(i, l_pre[i + 1]), lpre + 1));
if (i <= l[1])
add_(dpnxt[i], get(f2, i, min(lpre + 1, l_pre[i + 1] - 1)));
add_(dpnxt[i], f3[i]);
if (str[l[i + 1]] <= nxt[l[i + 1]]) add_(dpnxt[i], f4[i]);
}
for (i = 1; i <= lpre + 1; i++) dpnow[i] = str[i] = 0;
for (i = 1; i <= lnow + 1; i++) dpnow[i] = dpnxt[i], str[i] = nxt[i];
str[lnow + 1] = 0;
lpre = lnow;
}
int ans = 0;
for (i = 1; i <= lnow + 1; i++) add_(ans, dpnow[i]);
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, d, k;
int main() {
while (~scanf("%d%d%d", &n, &d, &k)) {
if (d < k || n < d + 1 || (d == 1 && n != 2) || d > 2 * k) {
printf("-1\n");
continue;
}
if (k == d) {
int single = n - d - 1;
int pos = 1;
for (int i = 1; i <= d; i++) {
printf("%d %d\n", pos, pos + 1);
pos++;
}
pos++;
for (int i = 1; i <= single; i++) {
printf("2 %d\n", pos);
pos++;
}
continue;
}
int single = n - d - 1;
int pos = 2;
int k2 = d - k;
for (int i = 1; i <= single; i++) {
printf("1 %d\n", pos);
pos++;
}
printf("1 %d\n", pos);
for (int i = 1; i <= k - 1; i++) {
printf("%d %d\n", pos, pos + 1);
pos++;
}
if (k2 != 0) {
pos++;
printf("1 %d\n", pos);
for (int i = 1; i <= k2 - 1; i++) {
printf("%d %d\n", pos, pos + 1);
pos++;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace output {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char* x) { cout << x; }
void __(const string& x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void __(const pair<S, T>& x) {
__(1 ? "(" : ""), __(x.first), __(1 ? ", " : " "), __(x.second),
__(1 ? ")" : "");
}
template <class T>
void __(const vector<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const set<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const multiset<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class S, class T>
void __(const map<S, T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
void pr() { cout << "\n"; }
template <class S, class... T>
void pr(const S& a, const T&... b) {
__(a);
if (sizeof...(b)) __(' ');
pr(b...);
}
} // namespace output
using namespace output;
const int MN = 3e5 + 5, MM = 101;
int a[MN][3], i, j, n, t, x, y, z, pat[MN][3], cnt;
long long arr[MN], base, len, nim;
void ini() {
for (int i = 1; i < MM; i++) {
for (int j = 0; j < 3; j++) {
set<int> st;
st.insert(a[max(i - x, 0)][0]);
if (j != 1) st.insert(a[max(i - y, 0)][1]);
if (j != 2) st.insert(a[max(i - z, 0)][2]);
for (int k = 0;; k++) {
if (!st.count(k)) {
a[i][j] = k;
break;
}
}
}
}
base = 65;
for (int i = base - 1; i >= 0; i--) {
int ok = 1;
for (int j = 0; j <= 30; j++) {
for (int k = 0; k < 3; k++) {
if (a[i - j][k] != a[base - j][k]) {
ok = 0;
break;
}
}
if (!ok) break;
}
if (ok) {
len = base - i;
break;
}
}
}
inline long long grundy(long long n, long long l) {
if (n <= base)
return a[n][l];
else {
n = (n - base) % len;
return a[base + n][l];
}
}
int main() {
for (scanf("%d", &t); t; t--) {
scanf("%d%d%d%d", &n, &x, &y, &z);
ini();
nim = 0;
cnt = 0;
for (i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
nim ^= grundy(arr[i], 0);
}
for (i = 1; i <= n; i++) {
nim ^= grundy(arr[i], 0);
nim ^= grundy(max(0LL, arr[i] - x), 0);
if (!nim) cnt++;
nim ^= grundy(max(0LL, arr[i] - x), 0);
nim ^= grundy(max(0LL, arr[i] - y), 1);
if (!nim) cnt++;
nim ^= grundy(max(0LL, arr[i] - y), 1);
nim ^= grundy(max(0LL, arr[i] - z), 2);
if (!nim) cnt++;
nim ^= grundy(max(0LL, arr[i] - z), 2);
nim ^= grundy(arr[i], 0);
}
printf("%d\n", cnt);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cnt[10];
inline int g(int x) {
int res = x % 9;
if (res == 0) res = 9;
return res;
}
int gg[10][10], ggg[1000005];
void solve() {
int n;
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); ++i) {
cnt[g(i)]++;
}
for (int i = (int)(1); i <= (int)(n); ++i) ggg[i] = g(i);
for (int i = (int)(1); i <= (int)(9); ++i)
for (int j = (int)(1); j <= (int)(9); ++j) gg[i][j] = g(i * j);
long long res = 0;
for (int dc = (int)(1); dc <= (int)(9); ++dc) {
for (int da = (int)(1); da <= (int)(9); ++da)
for (int db = (int)(1); db <= (int)(9); ++db) {
int k = g(da * db);
if (k != dc) continue;
res += (long long)cnt[dc] * (long long)cnt[da] * (long long)cnt[db];
}
}
int da = 0;
for (int a = 1; a <= n; ++a) {
++da;
if (da == 10) da = 1;
for (int b = 1, db = 0; b * a <= n; ++b) {
++db;
if (db == 10) db = 1;
if (gg[da][db] == ggg[a * b]) --res;
}
}
cout << res;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, T;
cin >> n >> T;
map<int, int> c1, c2;
vector<bool> ok(n);
for (int i = 0; i < n; ++i) {
int num;
cin >> num;
if (c1[T - num] <= c2[T - num]) {
c1[num]++;
ok[i] = true;
} else
c2[num]++;
}
for (int i = 0; i < n; ++i) cout << ok[i] << " \n"[i + 1 == n];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
long long i, j, k, l, co = 0;
long long n, m, t;
cin >> n >> m;
if (n == 2) {
if (m == 1)
cout << 4 << endl;
else
cout << 5 << endl;
} else if (n == 1 || n == 3 || n == 5 || n == 7 || n == 8 || n == 10 ||
n == 12) {
if (m == 6 || m == 7)
cout << 6 << endl;
else
cout << 5 << endl;
} else {
if (m == 7)
cout << 6 << endl;
else
cout << 5 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
template <typename T>
struct seg_tree {
static constexpr T unit = INT_MIN;
vector<T> tree;
int N;
inline T f(T a, T b) { return max(a, b); }
seg_tree(int _N = 0, T def = unit) : tree(2 * _N, def), N(_N) {}
void update(int pos, T value) {
for (tree[pos += N] = value; pos > 1; pos >>= 1)
tree[pos >> 1] = f(tree[pos], tree[pos ^ 1]);
}
T query(int l, int r) {
T ra = unit, rb = unit;
for (l += N, r += N; l < r; l /= 2, r /= 2) {
if (l & 1) ra = f(ra, tree[l++]);
if (r & 1) rb = f(tree[--r], rb);
}
return f(ra, rb);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> A(N);
vector<int> ans(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
int big = A[0], small = A[0];
for (int i = 0; i < N; ++i) {
uax(big, A[i]);
uin(small, A[i]);
}
if (big <= 2 * small) {
for (int i = 0; i < N; ++i) {
ans[i] = -1;
}
} else {
int X = N + N + N;
vector<int> B(X);
for (int i = 0; i < X; ++i) B[i] = A[i % N];
seg_tree<int> st(X, -1);
for (int i = 0; i < X; ++i) st.update(i, B[i]);
int len = 1;
for (int i = 0; i < N; ++i) {
len = max(len - 1, 1);
while (st.query(i, i + len) <= 2 * B[i + len]) ++len;
ans[i] = len;
}
}
for (int i = 0; i < N; ++i) {
cout << ans[i] << (i == N - 1 ? '\n' : ' ');
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char str[4][10005];
int k;
bool isV(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') return 1;
return 0;
}
int get_type() {
int len[4], i, j, st[4], x;
for (i = 0; i < 4; i++) {
len[i] = strlen(str[i]);
if (len[i] < k) return 0;
for (j = len[i] - 1, x = 0; j >= 0 && x < k; j--)
if (isV(str[i][j])) x++;
if (x < k) return 0;
st[i] = j + 1;
}
bool r[4][4];
int y;
for (i = 0; i < 4; i++)
for (j = i + 1; j < 4; j++) {
if (len[i] - st[i] == len[j] - st[j]) {
for (x = st[i], y = st[j]; x < len[i]; x++, y++)
if (str[i][x] != str[j][y]) break;
if (x == len[i])
r[i][j] = 1;
else
r[i][j] = 0;
} else
r[i][j] = 0;
}
if (r[0][1] && r[1][2] && r[2][3]) return 1;
if (r[0][1] && r[2][3]) return 2;
if (r[0][2] && r[1][3]) return 3;
if (r[0][3] && r[1][2]) return 4;
return 0;
}
int main() {
int n, i, j, t, type;
char s[5][8] = {"NO", "aaaa", "aabb", "abab", "abba"};
while (2 == scanf("%d%d", &n, &k)) {
type = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < 4; j++) scanf("%s", str[j]);
if (type) t = get_type();
if (i == 0)
type = t;
else if (type && t != 1) {
if (type == 1)
type = t;
else if (type != t)
type = 0;
}
}
puts(s[type]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int n, k, a[2 * maxn] = {0, 1}, prime[maxn], ind = 0, x = 1, y, q;
int vis[2 * maxn], check[2 * maxn];
vector<int> v[2 * maxn];
int main() {
for (int i = 2; i < maxn; ++i) {
int cnt = 1;
for (int j = 1; j <= ind; ++j) {
if (i % prime[j] == 0) {
cnt = 0;
continue;
}
}
if (cnt) prime[++ind] = i;
}
scanf("%d", &k);
n = 2 * k * k;
for (y = 1; y <= ind and x < k; ++y) {
int cnt = prime[y];
while (cnt <= n) {
for (int j = 1; j <= x and a[j] % prime[y]; ++j) {
if (1LL * a[j] * cnt > n) continue;
a[++x] = a[j] * cnt;
++vis[y];
for (int i = 0; i < v[j].size(); ++i) {
v[x].push_back(v[j][i]);
++vis[v[j][i]];
}
v[x].push_back(y);
}
cnt *= prime[y];
}
}
q = x;
for (int i = 1; i <= x and q > k; ++i) {
int flag = 1;
for (int j = 0; j < v[i].size(); ++j) {
if (vis[v[i][j]] - 1 < (k + 1) / 2) {
flag = 0;
break;
}
}
if (flag) {
for (int j = 0; j < v[i].size(); ++j) {
--vis[v[i][j]];
}
check[i] = 1;
--q;
}
}
for (int i = 1; i <= x; ++i) {
if (!check[i]) printf("%d ", a[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T rd() {
T nmb = 0;
int sgn = 0;
char chr = getchar();
while (!isdigit(chr)) {
if (chr == '-') sgn = 1;
chr = getchar();
}
while (isdigit(chr)) {
nmb = (nmb << 3) + (nmb << 1) + chr - '0';
chr = getchar();
}
return sgn ? -nmb : nmb;
}
template <typename T>
void wt(T nmb) {
if (nmb > 9) wt(nmb / 10);
putchar(nmb % 10 + '0');
}
template <typename T>
inline void cmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
inline void cmin(T &x, T y) {
x = x < y ? x : y;
}
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
const int N = 1e5 + 10, K = 40;
const int Len = 1288;
vector<int> G[N];
int w[N];
int dfn[N], Cnt;
int dep[N], fa[N][K];
void Init(int x, int f) {
dfn[x] = ++Cnt;
dep[x] = dep[f] + 1;
fa[x][0] = f;
for (int i = 1; i <= 16; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = G[x].size() - 1; ~i; --i) {
int k = G[x][i];
Init(k, x);
}
}
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 16; ~i; --i)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 16; ~i; --i)
if (fa[x][i] ^ fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int p[N], q[N];
inline int cmp(int u, int v) { return dfn[u] < dfn[v]; }
int b[N];
int to[N], fs[N], nx[N], e;
inline void add(int x, int y) {
to[++e] = y;
nx[e] = fs[x];
fs[x] = e;
}
int st[N], top;
void insert(int x) {
if (top == 1) {
st[++top] = x;
return;
}
int t = lca(x, st[top]);
while (top > 1 && dfn[st[top - 1]] >= dfn[t]) {
add(st[top - 1], st[top]);
--top;
}
if (st[top] ^ t) {
add(t, st[top]);
st[top] = t;
}
st[++top] = x;
}
int fw[N];
vector<int> vec[N];
int pos[N], cnt[N];
void init(int x, int f) {
fw[x] = f;
for (int t = fa[x][0]; t ^ f; t = fa[t][0])
if (b[t]) vec[x].push_back(w[t]);
sort(vec[x].begin(), vec[x].end());
pos[x] = -1;
for (int i = 0; i < vec[x].size(); ++i) {
if (vec[x][i] >= 0) break;
pos[x] = i;
}
for (int i = fs[x]; i; i = nx[i]) {
int k = to[i];
init(k, x);
}
}
void update(int x, int f) {
fw[x] = 0;
for (int t = fa[x][0]; t ^ f; t = fa[t][0]) w[t] -= cnt[x];
cnt[x] = 0;
for (int i = fs[x]; i; i = nx[i]) {
int k = to[i];
update(k, x);
}
fs[x] = 0;
vector<int>().swap(vec[x]);
}
int main() {
int n = rd<int>(), m = rd<int>();
for (int i = 2; i <= n; ++i) {
int f = rd<int>();
G[f].push_back(i);
}
for (int i = 1; i <= n; ++i) w[i] = rd<int>();
for (int i = 1; i <= m; ++i) q[i] = rd<int>();
Init(1, 0);
for (int i = 1; i <= n; ++i) b[i] = 1;
int ans = 0;
for (int l = 1; l <= m; l += Len) {
int r = min(l + Len - 1, m);
int len = r - l + 1;
for (int i = l; i <= r; ++i) p[i - l + 1] = q[i] > 0 ? q[i] : -q[i];
sort(p + 1, p + len + 1, cmp);
len = unique(p + 1, p + len + 1) - p - 1;
e = 0;
st[top = 1] = 1;
for (int i = 1; i <= len; ++i) {
if (p[i] == 1) continue;
insert(p[i]);
}
while (top > 1) {
add(st[top - 1], st[top]);
--top;
}
init(1, 0);
for (int i = l; i <= r; ++i) {
if (q[i] > 0) {
if (!b[q[i]]) {
wt(ans), putchar(' ');
continue;
}
if (w[q[i]] < 0) --ans;
b[q[i]] = 0;
for (int x = q[i]; x; x = fw[x]) {
++cnt[x];
int nw = lower_bound(vec[x].begin(), vec[x].end(), cnt[x]) -
vec[x].begin() - 1;
ans += nw - pos[x];
pos[x] = nw;
--w[x];
if (b[x] && w[x] == -1) ++ans;
}
} else {
if (b[-q[i]]) {
wt(ans), putchar(' ');
continue;
}
if (w[-q[i]] < 0) ++ans;
b[-q[i]] = 1;
for (int x = -q[i]; x; x = fw[x]) {
--cnt[x];
int nw = lower_bound(vec[x].begin(), vec[x].end(), cnt[x]) -
vec[x].begin() - 1;
ans -= pos[x] - nw;
pos[x] = nw;
++w[x];
if (b[x] && !w[x]) --ans;
}
}
wt(ans), putchar(' ');
}
update(1, 0);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 6;
int n, c, d, lt;
long long ans, now;
struct man {
int t, p;
} a[N];
int nx[N][2];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> c >> d;
for (int i = 1; i <= n; ++i) {
int t;
char s[5];
cin >> t >> s;
a[i] = (man){t, *s == 'W'};
}
cin >> lt;
nx[n][0] = nx[n][1] = lt;
for (int i = n - 1; i; --i) {
nx[i][0] = nx[i + 1][0];
nx[i][1] = nx[i + 1][1];
nx[i][a[i + 1].p] = a[i + 1].t;
}
ans = now = (long long)n * d;
for (int i = n; i; --i) {
now -= d;
ans = min(ans, now + (long long)c * (lt - a[i].t));
if (a[i].p == a[i - 1].p)
now += min((long long)d, (long long)c * (nx[i][!a[i].p] - a[i].t));
}
cout << ans << '\n';
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int x,y,r;
scanf("%d %d",&x,&y);
while(x % y != 0){
r = x % y;
x = y;
y = r;
}
cout << y << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
const int b1 = 17, b2 = 23, mod = 1e9 + 7, mod2 = 998244353;
int fa[300005], d[300005], anc[300005][21], pw1[300005], pw2[300005],
ipw1[300005], ipw2[300005], up1[300005], up2[300005], down1[300005],
down2[300005], son[300005], top[300005], h[300005], lg[300005], n, q;
char s[300005];
std::vector<int> ch[300005], up[300005], down[300005];
int qpow(int a, int b, int M) {
if (b == 0) return 1;
long long d = qpow(a, b >> 1, M);
d = d * d % M;
if (b & 1) d = d * a % M;
return d;
}
int dec(int x, int M) { return x >= M ? x - M : x; }
void dfs(int u, int f) {
fa[u] = f;
d[u] = d[fa[u]] + 1;
h[u] = 1;
anc[u][0] = fa[u];
down1[u] = ((long long)down1[fa[u]] * b1 % mod + s[u] - 'a') % mod;
down2[u] = ((long long)down2[fa[u]] * b2 % mod2 + s[u] - 'a') % mod2;
up1[u] = dec(up1[fa[u]] + (long long)(s[u] - 'a') * pw1[d[u]] % mod, mod);
up2[u] = dec(up2[fa[u]] + (long long)(s[u] - 'a') * pw2[d[u]] % mod2, mod2);
for (int i = 1; anc[u][i - 1] && i <= 20; ++i)
anc[u][i] = anc[anc[u][i - 1]][i - 1];
for (int v : ch[u]) {
if (v == f) continue;
dfs(v, u);
h[u] = std::max(h[v] + 1, h[u]);
if (h[v] > h[son[u]]) son[u] = v;
}
}
void dfs1(int u, int tp) {
top[u] = tp;
if (u == tp) {
for (int i = 1, x = u; i <= h[u]; ++i) {
up[u].push_back(x);
x = fa[x];
}
for (int i = 1, x = u; i <= h[u]; ++i) {
down[u].push_back(x);
x = son[x];
}
}
for (int v : ch[u])
if (v != fa[u]) dfs1(v, son[u] == v ? tp : v);
}
int lca(int u, int v) {
if (d[u] < d[v]) std::swap(u, v);
for (int i = lg[d[u]]; i >= 0; i--)
if (d[anc[u][i]] >= d[v]) u = anc[u][i];
if (u == v) return u;
for (int i = lg[d[u]]; i >= 0; i--)
if (anc[u][i] != anc[v][i]) {
u = anc[u][i];
v = anc[v][i];
}
return anc[u][0];
}
int lift(int x, int k) {
if (!k) return x;
int u = anc[x][lg[k]];
k -= (1 << lg[k]) + d[u] - d[top[u]];
return k >= 0 ? up[top[u]][k] : down[top[u]][-k];
}
std::pair<int, int> hash(int x, int l, int y, int len) {
if (len <= d[x] - d[l] + 1) {
int p = lift(x, len - 1);
return std::make_pair(
(long long)dec(up1[x] - up1[fa[p]] + mod, mod) * ipw1[d[p]] % mod,
(long long)dec(up2[x] - up2[fa[p]] + mod2, mod2) * ipw2[d[p]] % mod2);
} else {
len -= (d[x] - d[l] + 1);
int p = lift(y, d[y] - d[l] - len);
return std::make_pair(
dec((long long)dec(up1[x] - up1[fa[l]] + mod, mod) * ipw1[d[l]] % mod *
pw1[len] % mod +
dec(down1[p] - ((long long)down1[l] * pw1[len] % mod) + mod,
mod),
mod),
dec((long long)dec(up2[x] - up2[fa[l]] + mod2, mod2) * ipw2[d[l]] %
mod2 * pw2[len] % mod2 +
dec(down2[p] - ((long long)down2[l] * pw2[len] % mod2) + mod2,
mod2),
mod2));
}
}
int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
int main() {
scanf("%d%s", &n, s + 1);
lg[0] = -1;
pw1[0] = pw2[0] = ipw1[0] = ipw2[0] = 1;
int inv1 = qpow(b1, mod - 2, mod);
int inv2 = qpow(b2, mod2 - 2, mod2);
for (int i = 1; i <= n; ++i) {
pw1[i] = (long long)pw1[i - 1] * b1 % mod;
pw2[i] = (long long)pw2[i - 1] * b2 % mod2;
ipw1[i] = (long long)ipw1[i - 1] * inv1 % mod;
ipw2[i] = (long long)ipw2[i - 1] * inv2 % mod2;
lg[i] = lg[i / 2] + 1;
}
for (int i = 1; i < n; ++i) {
int u, v;
u = read();
v = read();
ch[u].push_back(v);
ch[v].push_back(u);
}
dfs(1, 0);
dfs1(1, 1);
scanf("%d", &q);
while (q--) {
int a1, b1, a2, b2;
a1 = read();
b1 = read();
a2 = read();
b2 = read();
int l1 = lca(a1, b1), l2 = lca(a2, b2);
int d1 = d[a1] + d[b1] - 2 * d[l1] + 1;
int d2 = d[a2] + d[b2] - 2 * d[l2] + 1;
int l = 1, r = std::min(d1, d2), ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (hash(a1, l1, b1, mid) == hash(a2, l2, b2, mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 250010;
vector<int> conn[MAX];
vector<int> route;
int n, m, k, lim_a, lim_b;
int chk[MAX], cnt_b;
vector<int> ans_b[MAX];
int f(int first) {
int cnt = 0;
chk[first] = route.size();
route.push_back(first);
for (auto second : conn[first]) {
if (chk[second] == -1) {
if (f(second)) return 1;
cnt++;
}
}
if (cnt == 0) {
if (route.size() >= lim_a) {
printf("PATH\n%d\n", route.size());
for (auto second : route) printf("%d ", second);
return 1;
}
int y1 = -1, y2 = -1;
for (auto second : conn[first]) {
if (chk[first] - chk[second] > 1) {
if (y1 == -1)
y1 = second;
else
y2 = second;
}
if (y2 != -1) break;
}
if ((chk[first] - chk[y1]) % 3 != 2) {
for (int i = chk[y1]; i <= chk[first]; i++)
ans_b[cnt_b].push_back(route[i]);
} else if ((chk[first] - chk[y2]) % 3 != 2) {
for (int i = chk[y2]; i <= chk[first]; i++)
ans_b[cnt_b].push_back(route[i]);
} else {
if (chk[y1] > chk[y2]) swap(y1, y2);
for (int i = chk[y1]; i <= chk[y2]; i++) ans_b[cnt_b].push_back(route[i]);
ans_b[cnt_b].push_back(route[chk[first]]);
}
cnt_b++;
if (lim_b == cnt_b) {
printf("CYCLES\n");
for (int i = 0; i < cnt_b; i++) {
printf("%d\n", ans_b[i].size());
for (int j = ans_b[i].size() - 1; j >= 0; j--)
printf("%d ", ans_b[i][j]);
printf("\n");
}
return 1;
}
}
route.pop_back();
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
conn[t1].push_back(t2);
conn[t2].push_back(t1);
}
for (int i = 1; i <= n; i++) chk[i] = -1;
lim_a = (n - 1) / k + 1;
lim_b = k;
f(1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, n0, n1, n2, prev;
int main() {
std::cin >> n;
for (int j = 0; j < n; ++j) {
std::cin >> n0 >> n1 >> n2;
prev = 1;
if ((n2 == 0) && (n0 == 0)) {
for (int i = 0; i < n1 + 1; ++i) {
std::cout << prev;
if (prev == 0) {
prev = 1;
} else {
prev = 0;
}
}
} else {
if (n2 > 0) {
for (int i = 0; i < n2 + 1; ++i) {
std::cout << "1";
}
}
if (n0 > 0) {
for (int i = 0; i < n0 + 1; ++i) {
std::cout << "0";
}
if (n2 > 0) {
for (int i = 0; i < n1 - 1; ++i) {
std::cout << prev;
if (prev == 0) {
prev = 1;
} else {
prev = 0;
}
}
} else {
for (int i = 0; i < n1; ++i) {
std::cout << prev;
if (prev == 0) {
prev = 1;
} else {
prev = 0;
}
}
}
} else {
prev = 0;
for (int i = 0; i < n1; ++i) {
std::cout << prev;
if (prev == 0) {
prev = 1;
} else {
prev = 0;
}
}
}
}
std::cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cur;
cin >> cur;
cout << n + 1 << "\n";
for (int i = 1; i < n; i++) {
int next;
cin >> next;
cout << "1 " << i << " " << next % n + n - cur % n - 1 << "\n";
cur = next;
}
cout << "1 " << n << " " << n - cur % n - 1 << "\n";
cout << "2 " << n << " " << n;
}
| 3 |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;
typedef pair<int, int> P;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define index(xs, x) (int)(lower_bound(all(xs), x) - xs.begin())
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007
struct BIT {
int n;
vector<int> xs;
BIT(int n) : n(n), xs(n+1, 0) {}
void add(int i, int v) {
for (int x=i+1; x<=n; x+=x&-x) xs[x] += v;
}
int sum(int i) {
int s = 0;
for (int x=i+1; x>0; x-=x&-x) s += xs[x];
return s;
}
};
inline int nC2(int x) { return (1LL*x*(x-1)/2) % MOD; }
inline int mul(int x, int y) { return (1LL*x*y) % MOD; }
int N;
int A[500000];
bool used[500000];
int fact[500001];
signed main() {
ios::sync_with_stdio(false); cin.tie(0);
fact[0] = 1;
for (int i=1; i<=500000; i++) fact[i] = (1LL*i*fact[i-1]) % MOD;
cin >> N;
BIT bit(N);
int X = 0, Y = 0;
rep(i, N) {
cin >> A[i], A[i]--;
if (A[i] == -1) X++;
else used[A[i]] = true;
}
vector<int> unused;
rep(i, N) if (!used[i]) unused.pb(i);
int s = fact[X], r = 0;
for (int i=N-1; i>=0; i--) {
int w = 0;
if (A[i] == -1) {
// ? -> ?
if (X >= 2) w = (w+mul(mul(Y, nC2(X)), fact[X-2])) % MOD;
// ? -> C
w = (w + mul(r, fact[X-1])) % MOD;
Y++;
}
else {
int a = bit.sum(A[i]);
// C -> C
w = (w + mul(a, fact[X])) % MOD;
// C -> ?
if (X > 0) {
int c = upper_bound(all(unused), A[i]) - unused.begin();
r = (r+X-c) % MOD;
w = (w + mul(mul(c, Y), fact[X-1])) % MOD;
}
bit.add(A[i], 1);
}
s = (s + 1LL*w*fact[N-1-i]) % MOD;
}
cout << s << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> a, b, v;
long long solve();
int main() {
cin >> n;
a.resize(n);
for (auto& p : a) cin >> p;
b.resize(n);
for (auto& p : b) cin >> p;
cout << solve() << endl;
return 0;
}
long long solve() {
long long res = 0, cnt = 0;
for (int i = 0; i < n; ++i)
if (a[i] > b[i])
v.push_back(a[i] - b[i]);
else if (a[i] < b[i]) {
cnt += b[i] - a[i];
++res;
}
sort(v.begin(), v.end(), greater<long long>());
for (auto p : v)
if (cnt) {
cnt -= min(cnt, p);
++res;
}
if (cnt > 0) return -1;
return res;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct poly {
int a[151];
poly() { memset(&a, 0, sizeof(a)); }
poly operator^(const poly& p) const {
poly res;
for (int i = 0; i < 151; i++) {
res.a[i] = a[i] ^ p.a[i];
}
return res;
}
poly operator<<(const int& x) const {
poly res;
for (int i = x; i < 151; i++) {
res.a[i] = a[i - x];
}
return res;
}
void output() {
int x = 0;
for (int i = 150; i >= 0; i--) {
if (a[i]) {
x = i;
break;
}
}
cout << x << '\n';
for (int i = 0; i <= x; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
};
poly p[151];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
p[0].a[0] = 1;
p[1].a[1] = 1;
for (int i = 2; i <= n; i++) {
p[i] = (p[i - 1] << 1) ^ p[i - 2];
}
p[n].output();
p[n - 1].output();
}
| 2 |
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;
int main(){
int n,ans=0,t[1000],u[1000];
bool visited[1000];
map<int,int> change;
cin>>n;
for(int i=0;i<n;i++){
cin>>t[i];
change[t[i]]=i;
u[i]=t[i];
visited[i]=false;
}
sort(u,u+n);
for(int i=0;i<n;i++){
int w=i,x=0,y=0,z=10000;
while(!visited[w]){
z=min(z,t[w]);
y+=t[w];
x++;
visited[w]=true;
w=change[u[w]];
}
if(x>=2)ans+=min(y+z+u[0]*(x+1),y+z*(x-2));
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <iostream>
using namespace std;
/** Problem0062 : What is Bottommost? **/
int main()
{
int array1[10], array2[10];
char c;
while (1) {
for (int i=0; i<10; i++) {
cin >> c;
array1[i] = c - '0';
}
if (cin.eof()) break;
for (int i=1; i<10; i++) {
for (int j=i; j<10; j++) {
if (i%2==1) {
array2[j] = (array1[j-1]+array1[j])%10;
} else {
array1[j] = (array2[j-1]+array2[j])%10;
}
}
}
cout << array2[9] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, siz[1000010], rt, sum = 0;
vector<int> G[1000010], ans;
void dfs(int np) {
for (int x : G[np]) {
dfs(x);
siz[np] += siz[x];
}
if (siz[np] == sum / 3 && ans.size() != 2 && np != rt) {
ans.push_back(np);
siz[np] = 0;
}
}
int main() {
scanf("%d", &n);
for (int i = 1, ti; i <= n; i++) {
scanf("%d%d", &ti, &siz[i]);
if (ti == 0)
rt = i;
else
G[ti].push_back(i);
sum += siz[i];
}
if (sum % 3) {
puts("-1");
return 0;
}
dfs(rt);
if (ans.size() != 2) {
puts("-1");
return 0;
}
for (int i = 0; i < 2; i++) printf("%d ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 700;
int arr[MAX + 10];
int g[MAX + 10][MAX + 10];
bool res[MAX + 10][MAX + 10][2];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int a = arr[i], b = arr[j];
while (b) {
a = a % b;
swap(a, b);
}
g[i][j] = g[j][i] = a;
}
}
for (int s = 1; s <= n; s++) {
for (int i = 0; i + s <= n; i++) {
int j = i + s;
for (int d = 0; d <= 1; d++) {
res[i][j][d] = 0;
int pr_flag = (d == 0 && i) || (d == 1 && j != n);
for (int c = i; c < j; c++) {
if (!pr_flag ||
(pr_flag && g[c][(d == 0) * (i - 1) + (d == 1) * j] > 1)) {
res[i][j][d] |=
(i == c || res[i][c][1]) && ((c == j - 1) || res[c + 1][j][0]);
}
}
}
}
}
if (res[0][n][0] || res[0][n][1])
cout << "Yes\n";
else
cout << "No\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100005];
long long dpp[100005];
long long dppp[100005];
const long long MOD = 1000000007;
int main() {
string s, p;
cin >> s >> p;
vector<int> f(p.length() + 1);
f[0] = f[1] = 0;
for (int i = 2; i <= p.length(); i++) {
int j = i - 1;
f[i] = 0;
while (j) {
j = f[j];
if (p[j] == p[i - 1]) {
f[i] = j + 1;
break;
}
}
}
vector<int> pos;
int ci = 0;
for (int j = 0; j < s.length();) {
if (s[j] == p[ci]) {
ci++;
j++;
if (ci == p.length()) {
pos.push_back(j - 1);
}
} else if (ci > 0)
ci = f[ci];
else
j++;
}
for (int i = 0; i < s.length(); i++) {
int cp = (int)(lower_bound(pos.begin(), pos.end(), i) - pos.begin());
int tc = 1000000;
if (cp != pos.size() && pos[cp] == i) {
tc = int(i - p.length());
} else {
cp--;
if (cp < 0) continue;
tc = int(pos[cp] - p.length());
}
dp[i] = 0;
if (tc != 1000000) dp[i] = tc + 2;
if (tc >= 0 && tc != 1000000) dp[i] += dppp[tc];
if (i == 0)
dpp[i] = dp[i];
else
dpp[i] = dpp[i - 1] + dp[i];
if (i == 0)
dppp[i] = dp[i];
else
dppp[i] = dppp[i - 1] + dpp[i];
dp[i] %= MOD;
dpp[i] %= MOD;
dppp[i] %= MOD;
}
cout << dpp[s.length() - 1] << endl;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,mmx,sse,sse2,tune=native")
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T, typename S>
inline ostream& operator<<(ostream& os, const pair<T, S> p) {
cout << "[" << p.first << ";" << p.second << "]";
return os;
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto el : v) cout << el << " ";
return os;
}
template <typename T>
inline ostream& operator<<(ostream& os, const set<T>& v) {
for (auto el : v) cout << el << " ";
return os;
}
template <typename T, typename S>
inline ostream& operator<<(ostream& os, const map<T, S>& v) {
for (auto el : v) cout << el << " ";
return os;
}
template <typename T>
inline ostream& operator<<(ostream& os, const multiset<T>& v) {
for (auto el : v) cout << el << " ";
return os;
}
namespace ___debug {
struct DebugStream {
private:
bool is_first;
public:
DebugStream(bool _is_first) : is_first(_is_first) {}
template <typename T>
DebugStream operator<<(const T& value) const {
assert(0);
if (is_first) cout << "[DBG] ";
cout << value;
return DebugStream(false);
};
template <typename T>
DebugStream printArray(T* l, T* r) {
assert(0);
if (is_first) cout << "[DBG] ";
while (l != r) {
cout << (*l);
++l;
if (l == r) {
cout << '\n';
} else {
cout << ' ';
}
}
return DebugStream(false);
}
};
DebugStream instance(true);
}; // namespace ___debug
const int INT_INF = (int)(2e9);
const ll LL_INF = (ll)(2e18);
const int NIL = -1;
static mt19937 _g(time(nullptr));
inline ll randint(ll a, ll b) {
ll w = (_g() << 31LL) ^ _g();
return a + w % (b - a + 1);
}
inline void fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
};
template <typename T>
inline T sign(T x) {
return T(x > 0) - T(x < 0);
}
template <typename T>
inline T fetch() {
T ret;
cin >> ret;
return ret;
}
template <typename T>
inline vector<T> fetch_vec(int sz) {
vector<T> ret(sz);
for (auto& elem : ret) cin >> elem;
return ret;
}
const int MAXN = (int)1e6;
int w, n, m;
int cnt[MAXN], freq[MAXN];
int pw3[MAXN], mod3[MAXN];
void init() {
pw3[0] = 1;
for (int i = 1; i < 20; ++i) pw3[i] = 3 * pw3[i - 1];
mod3[0] = 0;
for (int i = 1; i < MAXN; ++i)
mod3[i] = (mod3[i - 1] == 2 ? 0 : mod3[i - 1] + 1);
}
inline int getTrit(int msk, int pos) { return mod3[msk / pw3[pos]]; }
inline int setTrit(int msk, int pos, int val) {
int cur = getTrit(msk, pos);
msk += pw3[pos] * (val - cur);
return msk;
}
inline string fmt(int msk, int sz) {
string rez(sz, '?');
for (int i = 0; i < sz; ++i) {
int v = getTrit(msk, i);
if (v) rez[i] = '0' + (v - 1);
}
return rez;
}
inline int get(char cmd, int a, int b) {
if (cmd == 'A')
return a & b;
else if (cmd == 'O')
return a | b;
else if (cmd == 'X')
return a ^ b;
else if (cmd == 'a')
return (a & b) ^ 1;
else if (cmd == 'o')
return (a | b) ^ 1;
else if (cmd == 'x')
return (a ^ b) ^ 1;
else
assert(false);
}
int dp[256][2];
void solve() {
init();
cin >> w >> n >> m;
for (int i = 0; i < n; ++i) {
int a = fetch<int>();
int msk = 0;
for (int i = 0; i < w; ++i) msk = setTrit(msk, i, ((a >> i) & 1) + 1);
++cnt[msk];
++freq[a];
}
int pw = 1;
for (int j = 0; j < w; ++j) {
for (int msk = 0; msk < pw3[w]; ++msk) {
int v = mod3[msk / pw];
if (v) {
int msk2 = msk - pw * v;
cnt[msk2] += cnt[msk];
}
}
pw = pw + (pw << 1);
}
for (auto& cmd : string("AOXaox")) {
int code = (int)cmd;
for (int bt = 0; bt < 2; ++bt) {
int zero = 0, one = 0;
if (get(cmd, bt, 0) == 0) zero = 1;
if (get(cmd, bt, 1) == 0) one = 1;
if (zero && one)
dp[code][bt] = 0;
else if (zero)
dp[code][bt] = 1;
else if (one)
dp[code][bt] = 2;
else
dp[code][bt] = NIL;
}
}
for (int que = 0; que < m; ++que) {
auto func = fetch<string>();
reverse(func.begin(), func.end());
ll answ = 0;
for (int a = 0; a < (1 << w); ++a) {
if (!freq[a]) continue;
int msk = 0, good = 1;
int pw = 1;
for (int j = 0; j < w; ++j) {
int cur = dp[(int)func[j]][(a >> j) & 1];
if (cur == NIL) {
good = 0;
break;
}
msk += cur * pw;
pw = pw + (pw << 1);
}
if (good) answ += cnt[msk] * 1LL * freq[a];
}
cout << answ << '\n';
}
}
int main() {
fast_io();
solve();
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N;
cin>>N;
vector<int> A(N),B(N+1);
for(int i=0;i<N;i++){
cin>>A[i];
B[i+1]=B[i]+A[i];
}
vector<vector<int>> C(N,vector<int>(N,100000000000000000));
for(int i=0;i<N;i++)
C[i][i]=0;
for(int i=1;i<N;i++){
for(int j=0;j<N-i;j++){
for(int k=0;k<i;k++)C[j][j+i]=min(C[j][j+i],C[j][j+k]+C[j+k+1][j+i]);
C[j][j+i]+=B[j+i+1]-B[j];
}
}
cout<<C[0][N-1]<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, A[100005], cnt = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> A[i];
}
for (i = 2; i <= n - 1; i++) {
if (A[i] == 0 && A[i - 1] == 1 && A[i + 1] == 1) {
A[i + 1] = 0;
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 1;
int n, s, e, val, a[N], seg[N * 4];
vector<pair<int, int> > sol;
queue<pair<pair<int, int>, int> > q;
vector<vector<int> > pos;
void build(int at, int l, int r) {
if (l == r) {
seg[at] = a[l];
return;
}
int mid = (l + r) >> 1;
build(at << 1, l, mid);
build(at << 1 | 1, mid + 1, r);
seg[at] = min(seg[at << 1], seg[at << 1 | 1]);
}
int get(int at, int l, int r) {
if (l > e || r < s) return 1e9;
if (l >= s && r <= e) return seg[at];
int mid = (l + r) >> 1;
return min(get(at << 1, l, mid), get(at << 1 | 1, mid + 1, r));
}
int main() {
pos.resize(N);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
pos[a[i]].push_back(i);
}
build(1, 1, n);
q.push({{1, n}, 0});
while (!q.empty()) {
int l = q.front().first.first, r = q.front().first.second;
int cur = q.front().second;
q.pop();
if (!(l <= r)) continue;
s = l, e = r;
int mn = get(1, 1, n);
for (int i = 0; i < mn - cur; ++i) sol.push_back({l, r});
int idx = lower_bound(pos[mn].begin(), pos[mn].end(), l) - pos[mn].begin();
q.push({{l, pos[mn][idx] - 1}, (mn - cur) + cur});
++idx;
while (idx < pos[mn].size() && pos[mn][idx] <= r) {
q.push({{pos[mn][idx - 1] + 1, pos[mn][idx] - 1}, (mn - cur) + cur});
++idx;
}
--idx;
q.push({{pos[mn][idx] + 1, r}, (mn - cur) + cur});
}
printf("%d\n", int(sol.size()));
for (int i = 0; i < sol.size(); ++i)
printf("%d %d\n", sol[i].first, sol[i].second);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
inline double sqr(double x) { return x * x; }
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) : x(_x), y(_y) {}
void input() { scanf("%lf%lf", &x, &y); }
void output() { printf("%.6f %.6f\n", x, y); }
bool operator==(Point b) const {
return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
}
bool operator<(const Point &b) const {
return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : x < b.x;
}
Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
double operator*(const Point &b) const { return x * b.x + y * b.y; }
double operator^(const Point &b) const { return x * b.y - y * b.x; }
Point operator*(const double &k) const { return Point(x * k, y * k); }
Point operator/(const double &k) const { return Point(x / k, y / k); }
double len() { return sqrt(x * x + y * y); }
double len2() { return x * x + y * y; }
double dis(const Point &p) { return (*this - p).len(); }
double dis2(const Point &p) { return (*this - p).len2(); }
Point rotleft() { return Point(-y, x); }
Point rotright() { return Point(y, -x); }
Point trunc(double r) {
double l = len();
if (!sgn(l)) return *this;
r /= l;
return (*this) * r;
}
Point rotate(double angle) {
double c = cos(angle), s = sin(angle);
return Point(x * c - y * s, x * s + y * c);
}
Point rotate(Point p, double angle) {
return p + ((*this) - p).rotate(angle);
}
};
double trans(double ang) { return ang / pi * 180; }
double rad(Point a, Point b) { return fabs(atan2(a ^ b, a * b)); }
Point calcO(Point *p, int n) {
Point O(0, 0);
double s = 0, sumS = 0;
for (int i = 2; i <= n - 1; i++) {
s = ((p[i] - p[1]) ^ (p[i + 1] - p[1])) * 0.5;
sumS += s;
O = O + ((p[1] + p[i] + p[i + 1]) * s);
}
O = O / (sumS * 3);
return O;
}
const int N = 10000 + 5;
Point p[N], O;
double ang[N], len[N], angO;
int n, q, pin[2] = {1, 2};
int replace(int f, int t) {
if (pin[0] == f) {
pin[0] = t;
return pin[1];
} else {
pin[1] = t;
return pin[0];
}
}
void pre() {
O = calcO(p, n);
for (int i = 1; i <= n; i++) {
Point tmp = p[i] - O;
ang[i] = atan2(tmp.y, tmp.x);
len[i] = tmp.len();
}
}
Point query(int x) {
double ag = ang[x] + angO;
return O + Point(len[x] * cos(ag), len[x] * sin(ag));
}
void Rotate(int x) {
O = O.rotate(query(x), pi / 2 - ang[x] - angO);
angO += pi / 2 - ang[x] - angO;
}
void debug() {
for (int i = 1; i <= n; i++) query(i).output();
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) p[i].input();
pre();
while (q--) {
int op, f, t, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &f, &t);
int tp = replace(f, t);
Rotate(tp);
} else {
scanf("%d", &v);
query(v).output();
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct event {
int car, v, end_t;
bool operator<(const event& e) const {
return end_t != e.end_t ? end_t < e.end_t : car < e.car;
}
bool operator==(const event& e) const {
return car == e.car and v == e.v and end_t == e.end_t;
}
};
int n;
int x[100] = {};
queue<int> v[100];
template <typename T>
long long count_inversions(vector<T>& a, vector<T>& b, int s, int e) {
if (e - s == 1) {
return 0;
} else {
int m = (s + e) / 2;
long long ans = count_inversions(a, b, s, m) + count_inversions(a, b, m, e);
int l_head = s, r_head = m;
for (int i = s; i < e; i++) {
if (r_head >= e or (l_head < m and a[l_head] <= a[r_head])) {
b[i] = a[l_head++];
} else {
b[i] = a[r_head++];
ans += m - l_head;
}
}
for (int i = s; i < e; i++) {
a[i] = b[i];
}
return ans;
}
}
template <typename T>
long long count_inversions(vector<T>& a) {
vector<T> b(a.size());
return count_inversions(a, b, 0, a.size());
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int s;
cin >> n >> s;
set<event> events;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
int time = 0;
while (k--) {
int vj, tj;
cin >> vj >> tj;
v[i].push(vj);
time += tj;
events.insert({i, vj, time});
}
v[i].push(1);
}
vector<int> previous_order;
int time = 0;
ll ans = 0;
for (const event& e : events) {
int dt = e.end_t - time;
for (int i = 0; i < n; i++) {
x[i] += v[i].front() * dt;
}
vector<int> index_of(n);
if (not previous_order.empty()) {
for (int i = 0; i < n; i++) {
index_of[previous_order[i]] = i;
}
}
vector<int> curr_order(n);
iota(curr_order.begin(), curr_order.end(), 0);
sort(curr_order.begin(), curr_order.end(), [&](int i, int j) {
if (x[i] != x[j]) {
return x[i] < x[j];
} else if (previous_order.empty()) {
return v[i].front() < v[j].front();
} else {
return index_of[i] < index_of[j];
}
});
if (not previous_order.empty()) {
vector<int> relative_order(n);
for (int i = 0; i < n; i++) {
relative_order[i] = index_of[curr_order[i]];
}
ans += count_inversions(relative_order);
}
previous_order = curr_order;
v[e.car].pop();
time = e.end_t;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef pair<int,int>P;
vector<int>E[100000];
int s[100000],t[100000];
int ord[100000],low[100000],k;
bool used[100000];
vector<P>V;
void dfs(int v,int p){
used[v]=true;
low[v]=ord[v]=k++;
for(auto u:E[v]){
if(!used[u]){
dfs(u,v);
low[v]=min(low[v],low[u]);
if(ord[v]<low[u])V.push_back(P(min(u,v),max(u,v)));
}
else if(p!=u){
low[v]=min(low[v],ord[u]);
}
}
}
int main(){
int v,e;scanf("%d%d",&v,&e);
rep(i,e){
scanf("%d%d",&s[i],&t[i]);
E[s[i]].push_back(t[i]);
E[t[i]].push_back(s[i]);
}
dfs(0,-1);
sort(V.begin(),V.end());
for(auto p:V){
cout<<p.first<<' '<<p.second<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int cnt;
bool ltrd[2000001];
bool rtld[2000001];
bool traversed[1000000];
void mark(int xx) {
if (traversed[xx]) {
return;
}
++cnt;
for (int dd = 0; dd < 2; ++dd) {
int xdir = (dd == 0) ? 1 : -1;
int ydir = 1;
int x = xx;
int y = 0;
while (true) {
if (y == 0) {
traversed[x] = true;
}
bool& bref = (xdir == ydir) ? ltrd[x - y + m - 1] : rtld[x + y];
if (bref) break;
bref = true;
int xdist = (xdir == 1) ? (n - x - 1) : x;
int ydist = (ydir == 1) ? (m - y - 1) : y;
int run = min(xdist, ydist);
x += xdir * run;
y += ydir * run;
if (xdist == ydist) {
xdir = -xdir;
ydir = -ydir;
} else if (xdist < ydist) {
xdir = -xdir;
} else {
ydir = -ydir;
}
}
}
}
int main() {
int a, b;
cin >> a >> b;
n = max(a, b);
m = min(a, b);
cnt = 0;
for (int i = 0; i < n; ++i) {
traversed[i] = false;
}
for (int i = 0; i < n; ++i) {
mark(i);
}
cout << cnt << endl;
return 0;
}
| 3 |
#include<stdio.h>
#include<algorithm>
using namespace std;
int b[65536];
int c[65536];
int main(){
int a;
while(scanf("%d",&a),a){
for(int i=0;i<a;i++)scanf("%d",b+i);
for(int i=0;i<a-1;i++)scanf("%d",c+i);
std::sort(b,b+a);
std::sort(c,c+a-1);
long long s=0;
for(int i=0;i<a;i++)s+=b[i];
for(int i=0;i<a-1;i++)s+=c[i];
long long ret=s;
for(int i=0;i<a-1;i++){
s-=c[i];
ret=max(ret,s*(i+2));
}
printf("%lld\n",ret);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
struct Dir {
double a, b;
Dir() {}
Dir(double aa, double bb) {
double len = sqrt(aa * aa + bb * bb);
a = aa / len;
b = bb / len;
if (fabs(a) < eps) {
if (b < 0) {
b = -b;
a = -a;
}
} else if (a < 0) {
a = -a;
b = -b;
}
}
};
bool cmp(Dir a, Dir b) { return a.a < b.a || (a.a == b.a && a.b < b.b); }
bool eq(Dir a, Dir b) { return fabs(a.a - b.a) < eps && fabs(a.b - b.b) < eps; }
struct Point {
double x, y;
Point(double xx = 0, double yy = 0) {
x = xx;
y = yy;
}
} p[2010];
bool operator==(const Point& a, const Point& b) {
return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}
Point Mid(Point a, Point b) { return Point((a.x + b.x) / 2, (a.y + b.y) / 2); }
bool vis[2010];
Dir res[2010];
int num;
double getdis(Point a, Point b) {
if (abs(a.x) < eps) return b.x;
double k = a.y / a.x;
return (b.y - k * b.x) / sqrt(1 + k * k);
}
double dis[2010];
int n;
void check(Point x) {
int N = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) dis[++N] = getdis(x, p[i]);
sort(dis + 1, dis + N + 1);
for (int i = 1; i <= N / 2; i++)
if (fabs(dis[i] + dis[N - i + 1]) > eps) return;
if (N % 2 == 1 && fabs(dis[N / 2 + 1]) > eps) return;
res[++num] = Dir(x.x, x.y);
return;
}
int main() {
scanf("%d", &n);
Point S;
for (int i = 1; i <= n; i++) {
scanf("%lf %lf", &p[i].x, &p[i].y);
S.x += p[i].x;
S.y += p[i].y;
}
S.x /= n;
S.y /= n;
for (int i = 1; i <= n; i++) {
p[i].x -= S.x;
p[i].y -= S.y;
}
S.x = 0;
S.y = 0;
int id = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (p[i] == S) {
vis[i] = true;
continue;
}
for (int j = i + 1; j <= n; j++)
if (!vis[j] && Mid(p[i], p[j]) == S) {
vis[i] = vis[j] = true;
break;
}
if (!vis[i]) id = i;
}
if (!id) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) check(Mid(p[id], p[i]));
sort(res + 1, res + num + 1, cmp);
int ans = min(1, num);
for (int i = 2; i <= num; i++)
if (!eq(res[i - 1], res[i])) ans++;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct d {
int l = 10005, r = -1;
} mat;
int main() {
int n, m;
cin >> n >> m;
int arr[n][m];
mat row[n], col[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
if (arr[i][j] == 1) {
row[i].l = min(row[i].l, j);
row[i].r = max(row[i].r, j);
col[j].l = min(col[j].l, i);
col[j].r = max(col[j].r, i);
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 0) {
if (row[i].l < j) ans++;
if (row[i].r > j) ans++;
if (col[j].l < i) ans++;
if (col[j].r > i) ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 1 + 1e5;
int n, l, r;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> l >> r;
int ans = 0;
for (int i = 0; i < l; i++) ans += (1 << i);
for (int i = l; i < n; i++) ans++;
cout << ans << endl;
ans = 0;
for (int i = 0; i < r; i++) ans += (1 << i);
for (int i = r; i < n; i++) ans += (1 << (r - 1));
cout << ans << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N;
string S;
cin>>N>>S;
int ok=0,ng=N/2+1;
while(ng-ok>1){
int n=(ok+ng)/2;
set<string> s;
for(int i=n;i+n<=N;i++){
s.insert(S.substr(i-n,n));
if(s.count(S.substr(i,n))){
ok=n;
goto home;
}
}
ng=n;
continue;
home:;
}
cout<<ok<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string in1, in2;
cin >> in1 >> in2;
int dist[30][30];
for (int i = 0; i < 30; i++) {
for (int j = 0; j < 30; j++) dist[i][j] = 1 << 28;
dist[i][i] = 0;
}
int n, w;
char a, b;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a >> b >> w;
dist[a - 'a'][b - 'a'] = min(w, dist[a - 'a'][b - 'a']);
}
for (int k = 0; k < 26; k++)
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
if (in1.size() != in2.size()) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < in1.size(); i++) {
bool mila = false;
for (int j = 0; j < 26; j++) {
if (dist[in1[i] - 'a'][j] != 1 << 28 && dist[in2[i] - 'a'][j] != 1 << 28)
mila = true;
}
if (!mila) {
cout << "-1\n";
return 0;
}
}
char ans[100009];
int tt = 0;
for (int i = 0; i < in1.size(); i++) {
int mx = 1 << 28;
for (int j = 0; j < 26; j++)
if (dist[in1[i] - 'a'][j] + dist[in2[i] - 'a'][j] < mx) {
ans[i] = 'a' + j;
mx = dist[in1[i] - 'a'][j] + dist[in2[i] - 'a'][j];
}
tt += mx;
}
cout << tt << endl;
for (int i = 0; i < in1.size(); i++) cout << ans[i];
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, where[2000000], num[2000000], place[200000], rep[2000000], co,
rev[2000000], dir[2000000], res;
vector<int> a[2000000];
vector<int> t[2000000];
void dfs(int u, int p) {
rep[u] = ++co;
rev[co] = u;
num[u] = 1;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (v == p) continue;
dfs(v, u);
num[u] += num[v];
}
int nmax = num[u] / 2;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (v == p) continue;
if (num[v] > nmax) {
dir[u] = v;
return;
}
}
where[u] = u;
}
void build(int p, int l, int r) {
if (l == r) {
t[p].push_back(l);
return;
}
build(p * 2, l, (l + r) / 2);
build(p * 2 + 1, (l + r) / 2 + 1, r);
int p1 = p * 2, p2 = p * 2 + 1, u = 0, v = 0;
for (int i = l; i <= r; i++)
if (u < t[p1].size() and
(v == t[p2].size() or num[rev[t[p1][u]]] < num[rev[t[p2][v]]]))
t[p].push_back(t[p1][u++]);
else
t[p].push_back(t[p2][v++]);
}
void find_(int p, int l1, int r1, int a, int b, int v) {
if (r1 < a or l1 > b) return;
if (l1 >= a and r1 <= b) {
int l = 0, r = t[p].size() - 1, tmp = t[p].size();
while (l <= r) {
int m = (l + r) / 2;
if (num[rev[t[p][m]]] >= v)
tmp = m, r = m - 1;
else
l = m + 1;
}
if (tmp != t[p].size() and (num[rev[t[p][tmp]]] < num[res]))
res = rev[t[p][tmp]];
return;
}
find_(p * 2, l1, (l1 + r1) / 2, a, b, v);
find_(p * 2 + 1, (l1 + r1) / 2 + 1, r1, a, b, v);
}
int main() {
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int u = i, v;
cin >> v;
a[u].push_back(v);
a[v].push_back(u);
}
dfs(1, 0);
build(1, 1, n);
num[n + 1] = 1e9;
while (q--) {
int u;
cin >> u;
if (where[u]) {
cout << where[u] << "\n";
continue;
}
res = n + 1;
int v = dir[u];
int tmp = num[u] - num[v];
int nmax = num[u] / 2;
tmp = nmax - tmp;
tmp = num[v] - tmp;
find_(1, 1, n, rep[v], rep[v] + num[v] - 1, tmp);
where[u] = res;
cout << where[u] << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++) L[i] = arr[l + i];
for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int main() {
int n, i = 0, k = 0, j = 0, count = 0, t = 0, m, c[200002], flag = 0,
a[52][52], b[100000];
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] == 1) count++;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if ((i == 0 || i == n - 1 || j == 0 || j == m - 1) && (a[i][j] == 1)) {
flag = 1;
}
}
}
if (flag == 1)
printf("2");
else if (flag == 0 && count > 1)
printf("4");
else if (flag == 0 && count == 1)
printf("4");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 5;
const int MOD = 1e9 + 7;
int n, q, w, a[N], du[N], sum[N];
vector<int> p[N];
bool v[N];
int dp[1 << 17];
bool dfs(int x, int cnt) {
if (sum[x]) return sum[x];
sum[x] = cnt + a[x];
w = max(-1, w - cnt);
for (int i = 0; i < p[x].size(); ++i)
if (v[p[x][i]])
return true;
else {
v[p[x][i]] = true;
if (dfs(p[x][i], cnt + a[x])) return true;
v[p[x][i]] = false;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> q >> w;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < q; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
p[x].push_back(y);
++du[y];
}
bool flag = false;
for (int i = 0; !flag && i < n; ++i)
if (!du[i]) flag = dfs(i, 0);
for (int i = 0; !flag && i < n; ++i)
if (sum[i] == 0) flag = true;
if (flag || w < 0) {
cout << 0 << endl;
return 0;
}
dp[0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = sum[i]; j <= w; ++j) dp[j] = (dp[j] + dp[j - sum[i]]) % MOD;
}
cout << dp[w] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int MAXN = 1e5 + 5;
long long a[MAXN];
int main() {
long long m, n, i, j, k, d, ans = 0;
scanf("%I64d %I64d %I64d", &m, &n, &d);
long long now = 0;
for (i = 1; i <= m; i++) {
scanf("%I64d", &a[i]);
if (a[i] <= n) {
now += a[i];
if (now > d) {
now = 0;
ans++;
}
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, m, j = 1, l, r;
long long i, k, p = 0, h = 0, x = 0, y, z, q;
string s;
t = 1;
for (r = 0; r < t; r++) {
int a, b, c;
std::cin >> a >> b >> c;
std::set<int> ans;
std::set<int>::iterator it;
for (i = 1; i <= 81; i++) {
x = b * pow(i, a) + c;
p = x;
h = 0;
while (p > 0) h += p % 10, p = p / 10;
if (x > 0 && x < 1000000000 && h == i) ans.insert(x);
}
std::cout << ans.size() << std::endl;
for (it = ans.begin(); it != ans.end(); it++) cout << *it << " ";
}
return 0;
}
| 2 |
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
string list[24] = {"012345","024135","031425","043215","103254","120534","135024","152304","201453","215043","240513","254103","304152","310542","345012","351402","402351","425031","430521","453201","513240","521430","534120","542310"};
bool used[8];
vector<string> data(8);
vector<string> puzzle(8);
// TOP FRONT RIGHT LEFT BACK BOTTOM
int connect[8][8] = {
{-1},
{0,3,-1},
{1,1,-1},
{0,1,2,2,-1},
{0,5,-1},
{1,5,4,3,-1},
{2,5,5,1,-1},
{3,5,4,1,6,2,-1}
};
bool ok(char a,char b){
return a != b && (a&~32) == (b&~32);
}
bool backTrack(int s){
if(s == 8){
//for(int i = 0 ; i < 8 ; i++)
// cout << "[" << puzzle[i].dice << "]" << endl;
return true;
}
for(int d = 0 ; d < 8 ; d++){
if(used[d] != 0) continue;
used[d] = true;
puzzle[s] = data[d];
for(int i = 0 ; i < 24 ; i++){
for(int j = 0 ; j < 6 ; j++){
puzzle[s][j] = data[d][list[i][j]] ;
}
bool f = true;
for(int j = 0 ; ~connect[s][j] ; j += 2){
int pos = connect[s][j];
int face = connect[s][j+1];
if(!ok(puzzle[pos][5-face], puzzle[s][face])){
f = false;
}
}
if(f)if(backTrack(s+1))return true;
}
used[d] = false;
}
return false;
}
int main(){
for(int i = 0 ; i < 24 ; i++)
for(int j = 0 ; j < 6 ; j++)
list[i][j] -= '0';
while(1){
string str;
for(int i = 0 ; i < 8 ; i++){
if(cin >> str , str == "0") return 0;
data[i] = str;
used[i] = 0;
}
cout << (backTrack(0)?"YES":"NO") << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const long long INF = 1e9 + 7;
long long n, dp[N][1 << 4 | 1];
string s1, s2;
bool check(const long long &pos, const long long &num) {
if (num == 1) {
if (s1[pos - 1] == 'X' || s1[pos] == 'X' || s2[pos - 1] == 'X')
return false;
}
if (num == 2) {
if (s1[pos - 1] == 'X' || s1[pos] == 'X' || s2[pos] == 'X') return false;
}
if (num == 3) {
if (s1[pos] == 'X' || s2[pos - 1] == 'X' || s2[pos] == 'X') return false;
}
if (num == 4) {
if (s1[pos - 1] == 'X' || s2[pos] == 'X' || s2[pos - 1] == 'X')
return false;
}
return true;
}
long long merge(const long long &pos, const long long &num) {
long long mask;
if (num == 1) mask = 7;
if (num == 2) mask = 11;
if (num == 3) mask = 14;
if (num == 4) mask = 13;
if (s1[pos - 1] == 'X') mask |= 1;
if (s1[pos] == 'X') mask |= 1 << 1;
if (s2[pos - 1] == 'X') mask |= 1 << 2;
if (s2[pos] == 'X') mask |= 1 << 3;
return mask;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s1 >> s2;
n = s1.size();
s1 = '~' + s1;
s2 = '~' + s2;
for (long long num = 1; num <= 4; num++)
if (check(2, num)) dp[2][merge(2, num)] = 1;
for (long long i = 3; i <= n; i++) {
for (long long mask = 0; mask < 1 << 4; mask++)
dp[i][mask] = dp[i - 1][mask];
for (long long num = 1; num <= 4; num++)
if (check(i, num)) {
for (long long preMask = 0; preMask < 1 << 4; preMask++)
dp[i][merge(i, num)] =
max(dp[i][merge(i, num)], dp[i - 2][preMask] + 1);
if (num == 3 && check(i - 1, 1))
dp[i][15] = max(dp[i][15], dp[i - 1][7] + 1);
if (num == 2 && check(i - 1, 4))
dp[i][15] = max(dp[i][15], dp[i - 1][13] + 1);
}
}
long long ans = 0;
for (long long mask = 0; mask < 1 << 4; mask++) ans = max(ans, dp[n][mask]);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
struct edge {
int x, y, w;
} e[200005];
int a[100005], b[100005], fa[200005];
inline int read() {
register int x = 0, f = 1;
register char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline bool cmp(const edge &x, const edge &y) { return x.w > y.w; }
int main() {
int m = read(), n = read(), tot = 0;
long long ans = 0;
for (register int i = 1; i <= m; ++i) a[i] = read();
for (register int i = 1; i <= n; ++i) b[i] = read();
for (register int i = 1; i <= m; ++i) {
int s = read();
for (register int j = 1; j <= s; ++j) {
++tot;
e[tot].x = read();
e[tot].y = i + n;
ans += (e[tot].w = a[i] + b[e[tot].x]);
}
}
std::sort(e + 1, e + 1 + tot, cmp);
for (register int i = 1; i <= n + m; ++i) fa[i] = i;
for (register int i = 1; i <= tot; ++i) {
int fx = find(e[i].x), fy = find(e[i].y);
if (fx != fy) {
ans -= e[i].w;
fa[fx] = fy;
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
vector<pair<long long int, long long int> > g[N];
int a[N][2];
vector<int> s;
bool used[N], ex[N];
int n;
int cv, ce;
bool tr(int v) {
if (used[v]) return 0;
used[v] = 1;
for (pair<long long int, long long int> it : g[v]) {
int u = it.first, w = it.second;
if (ex[w]) continue;
if (used[u]) return 0;
ex[w] = 1;
if (!tr(u)) return 0;
}
return 1;
}
void dfs(int v) {
++cv;
used[v] = 1;
for (pair<long long int, long long int> it : g[v]) {
int u = it.first, w = it.second;
if (ex[w]) continue;
ex[w] = 1;
++ce;
if (!used[u]) dfs(u);
}
}
bool chk(int k) {
for (int i = 0; i < ((int)(s).size()); ++i) {
used[i] = 0;
ex[i] = 0;
}
for (int i = 0; i < ((int)(s).size()); ++i)
if (i > k)
if (!tr(i)) return 0;
for (int i = 0; i < ((int)(s).size()); ++i) {
if (!used[i]) {
cv = 0;
ce = 0;
dfs(i);
if (cv < ce) return 0;
}
}
return 1;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
s.reserve(2 * n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
cin >> a[i][j];
s.push_back(a[i][j]);
}
}
sort(s.begin(), s.end());
s.resize(unique(s.begin(), s.end()) - s.begin());
if (n > ((int)(s).size())) {
cout << -1;
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j)
a[i][j] = lower_bound(s.begin(), s.end(), a[i][j]) - s.begin();
g[a[i][0]].push_back({a[i][1], i});
g[a[i][1]].push_back({a[i][0], i});
}
int l = 0, r = ((int)(s).size()) - 1;
while (r - l > 1) {
int m = (r + l) / 2;
if (chk(m))
r = m;
else
l = m;
}
if (chk(l))
cout << s[l];
else if (chk(r))
cout << s[r];
else
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int Fl, Pn, SI = 100;
char mch = ' ', ch, Bf[21];
template <typename t>
void in(t& a) {
a = 0;
ch = getchar();
Fl = 1;
while ((ch < '0') || (ch > '9')) Fl = (ch == '-') ? -Fl : Fl, ch = getchar();
while ((ch >= '0') && (ch <= '9')) a = a * 10 + ch - '0', ch = getchar();
a *= Fl;
}
template <typename t>
void out(t a) {
if (a < 0) putchar('-'), a = -a;
if (a == 0) putchar('0');
while (a) Bf[++Pn] = a % 10 + '0', a /= 10;
while (Pn) putchar(Bf[Pn]), --Pn;
putchar(mch);
}
template <typename t, typename... ARGS>
void in(t& a, ARGS&... args) {
in(a);
in(args...);
}
template <typename t, typename... ARGS>
void out(t a, ARGS... args) {
out(a);
out(args...);
}
using namespace std;
struct node {
int u, d, l, r;
} a[101][101];
int n, m, b[101][101], t, t1, t2, t3, t4, tt[10001], ttop;
int dfs(int x, int y, int color) {
int sum = 1;
b[x][y] = color;
if (x > 1 && a[x][y].u && !b[x - 1][y]) sum += dfs(x - 1, y, color);
if (x < n && a[x][y].d && !b[x + 1][y]) sum += dfs(x + 1, y, color);
if (y > 1 && a[x][y].l && !b[x][y - 1]) sum += dfs(x, y - 1, color);
if (y < m && a[x][y].r && !b[x][y + 1]) sum += dfs(x, y + 1, color);
return sum;
}
void cut(int sx, int sy, int ex, int ey) {
if (sx > ex) swap(sx, ex);
if (sy > ey) swap(sy, ey);
if (sx == ex)
for (register int i = 1 + sy; i <= ey; i++) {
a[sx][i].d = 0;
a[sx + 1][i].u = 0;
}
else
for (register int i = 1 + sx; i <= ex; i++) {
a[i][sy].r = 0;
a[i][sy + 1].l = 0;
}
}
int main() {
in(n, m, t);
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= m; j++) {
if (i > 1) a[i][j].u = i - 1;
if (i < n) a[i][j].d = i + 1;
if (j > 1) a[i][j].l = j - 1;
if (j < m) a[i][j].r = j + 1;
}
for (register int i = 1; i <= t; i++) {
in(t1, t2, t3, t4);
cut(t3, t4, t1, t2);
}
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= m; j++) {
if (!b[i][j]) tt[++ttop] = dfs(i, j, ttop);
}
sort(tt + 1, tt + 1 + ttop);
for (register int i = 1; i <= ttop; i++) out(tt[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
pair<char, char> v[15];
int main() {
int ans = 0, l;
string s;
cin >> s;
l = (int)(s.size());
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
cin >> v[i].first;
cin >> v[i].second;
}
for (int i = 0; i < k; i++) {
char a = v[i].first;
char b = v[i].second;
char tmp;
int j = 0;
while (j < l) {
if (s[j] == a || s[j] == b) {
int k = j;
char c = s[j];
int cnt = 0;
while (j < l && (s[j] == a || s[j] == b)) {
if (s[j] == c) cnt++;
j++;
}
if (j - k != cnt) ans += min(cnt, j - k - cnt);
} else
j++;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, sum, tag;
int premx, prefr, premn, pmnfr;
int sufmx, suffr, sufmn, smnfr;
int mx, mxfrl, mxfrr, mn, mnfrl, mnfrr;
node *lch, *rch;
node operator+(node b) {
node Ans;
Ans.sum = sum + b.sum, Ans.l = l, Ans.r = b.r;
Ans.tag = false, Ans.lch = Ans.rch = nullptr;
Ans.premx = max(premx, sum + b.premx);
if (Ans.premx == premx)
Ans.prefr = prefr;
else
Ans.prefr = b.prefr;
Ans.sufmx = max(b.sufmx, sufmx + b.sum);
if (Ans.sufmx == b.sufmx)
Ans.suffr = b.suffr;
else
Ans.suffr = suffr;
Ans.mx = max(max(Ans.sufmx, Ans.premx), sufmx + b.premx);
Ans.mx = max(Ans.mx, max(mx, b.mx));
if (Ans.mx == mx)
Ans.mxfrl = mxfrl, Ans.mxfrr = mxfrr;
else if (Ans.mx == b.mx)
Ans.mxfrl = b.mxfrl, Ans.mxfrr = b.mxfrr;
else if (Ans.mx == Ans.sufmx)
Ans.mxfrl = Ans.suffr, Ans.mxfrr = Ans.r;
else if (Ans.mx == Ans.premx)
Ans.mxfrl = l, Ans.mxfrr = Ans.prefr;
else
Ans.mxfrl = suffr, Ans.mxfrr = b.prefr;
Ans.premn = min(premn, sum + b.premn);
if (Ans.premn == premn)
Ans.pmnfr = pmnfr;
else
Ans.pmnfr = b.pmnfr;
Ans.sufmn = min(b.sufmn, sufmn + b.sum);
if (Ans.sufmn == b.sufmn)
Ans.smnfr = b.smnfr;
else
Ans.smnfr = smnfr;
Ans.mn = min(min(Ans.sufmn, Ans.premn), sufmn + b.premn);
Ans.mn = min(Ans.mn, min(mn, b.mn));
if (Ans.mn == mn)
Ans.mnfrl = mnfrl, Ans.mnfrr = mnfrr;
else if (Ans.mn == b.mn)
Ans.mnfrl = b.mnfrl, Ans.mnfrr = b.mnfrr;
else if (Ans.mn == Ans.sufmn)
Ans.mnfrl = Ans.smnfr, Ans.mnfrr = Ans.r;
else if (Ans.mn == Ans.premn)
Ans.mnfrl = l, Ans.mnfrr = Ans.pmnfr;
else
Ans.mnfrl = smnfr, Ans.mnfrr = b.pmnfr;
return Ans;
}
} * root, POOL[(100000 + 54) * 2];
int cnt, a[(100000 + 54)];
void dooppo(node *x) {
x->tag ^= 1, x->sum *= -1;
swap(x->prefr, x->pmnfr), swap(x->premx, x->premn);
x->premx *= -1, x->premn *= -1;
swap(x->suffr, x->smnfr), swap(x->sufmx, x->sufmn);
x->sufmx *= -1, x->sufmn *= -1;
swap(x->mxfrl, x->mnfrl), swap(x->mxfrr, x->mnfrr), swap(x->mx, x->mn);
x->mx *= -1, x->mn *= -1;
}
void pushdown(node *x) {
if (x->lch == nullptr || !x->tag) return;
dooppo(x->lch), dooppo(x->rch);
x->tag = false;
}
void pushup(node *x) {
if (x->l == x->r) {
x->premx = x->sufmx = x->mx = x->mn = x->sum;
x->premn = x->sufmn = x->sum;
x->pmnfr = x->smnfr = x->mnfrl = x->mnfrr = x->l;
x->prefr = x->suffr = x->mxfrl = x->mxfrr = x->l;
} else {
node *l = x->lch, *r = x->rch;
int tag = x->tag;
*x = *x->lch + *x->rch;
x->lch = l, x->rch = r;
x->tag = tag;
}
}
node *build(int l, int r) {
node *x = &POOL[cnt++];
x->l = l, x->r = r, x->tag = 0;
if (l == r)
x->sum = a[l], x->lch = x->rch = nullptr;
else {
int mid = (l + r) >> 1;
x->lch = build(l, mid);
x->rch = build(mid + 1, r);
}
pushup(x);
return x;
}
void change(node *x, int p, int v) {
if (x->lch == nullptr) return x->sum = v, pushup(x);
int mid = (x->l + x->r) >> 1;
pushdown(x);
if (p <= mid)
change(x->lch, p, v);
else
change(x->rch, p, v);
return pushup(x);
}
node getmx(node *x, int l, int r) {
if (l <= x->l && x->r <= r) return *x;
int mid = (x->l + x->r) >> 1;
pushdown(x);
if (l <= mid && mid < r) return getmx(x->lch, l, r) + getmx(x->rch, l, r);
if (l <= mid) return getmx(x->lch, l, r);
return getmx(x->rch, l, r);
}
void oppo(node *x, int l, int r) {
if (l <= x->l && x->r <= r) return dooppo(x);
int mid = (x->l + x->r) >> 1;
pushdown(x);
if (l <= mid) oppo(x->lch, l, r);
if (r > mid) oppo(x->rch, l, r);
return pushup(x);
}
void out(node *x) {
pushdown(x);
if (x->lch == nullptr) {
cout << x->sum << " ";
return;
}
out(x->lch), out(x->rch);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
root = build(1, n);
int m;
cin >> m;
for (int i = 1, op, l, r, v; i <= m; ++i) {
cin >> op;
if (op == 0) {
cin >> l >> v;
change(root, l, v);
} else {
cin >> l >> r >> v;
int Ans = 0;
int L[22] = {0}, R[22] = {0};
for (int j = 1; j <= v + 1; ++j) {
node tmp = getmx(root, l, r);
if (j == v + 1 || tmp.mx <= 0) {
cout << Ans << endl;
while (--j) {
oppo(root, L[j], R[j]);
}
break;
}
Ans += tmp.mx;
L[j] = tmp.mxfrl, R[j] = tmp.mxfrr;
oppo(root, L[j], R[j]);
}
}
}
return 0;
}
| 4 |
#include<cstdio>
#include<cstring>
#define inf 0x7f7f7f7f
int l,Test_num,mxc,mxx;
char ch[53];
int f[53][91][919][2];
inline int min(int a,int b)
{
return a<b? a:b;
}
inline int dp(int pos,int c,int x,int delta)
{
if(pos==l)return c? inf:0;if(c>mxc || c<-mxc || x>mxx || x<-mxx)return inf;
if(!(~f[pos][c+mxc][x+mxx][(delta==1)]))f[pos][c+mxc][x+mxx][(delta==1)]=min(dp(pos,c,x+delta,delta)+l-pos,min(dp(pos+1,c*10+ch[pos+1]-x,x,1),dp(pos+1,c*10+ch[pos+1]-x,x,-1)));
return f[pos][c+mxc][x+mxx][(delta==1)];
}
int main()
{
scanf("%s",ch+2),l=strlen(ch+2)+1,ch[1]=0,mxx=9*l,mxc=mxx/10;
for(int i=2;i<=l;++i)ch[i]^=48;
memset(f,-1,sizeof(f)),printf("%d",dp(0,0,0,1));
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int cases = 1;
cin >> cases;
while (cases--) {
int a = 0, b = 0;
string s;
cin >> s;
char f = s[0];
for (int i = 1; i < s.length(); i++) {
if (s[i] != f) {
if (f == 'a') {
a++;
} else {
b++;
}
}
f = s[i];
}
if (a > b) {
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'b') {
s[i] = 'a';
break;
}
}
} else if (b > a) {
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'a') {
s[i] = 'b';
break;
}
}
}
cout << s << endl;
}
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
int gcd(int a, int b){
if(b==0) return a;
return gcd(b,a%b);
}
int lcm(int a, int b){
return a/gcd(a,b)*b;
}
signed main(void) {
int n;
cin >> n;
loop(i,1,2000){
int cnt = 0;
for(int j = 1; j*j <= i; j++)if(i%j == 0){
cnt++;
if(j*j < i)cnt++;
}
if(cnt == n){
cout << i << endl;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NUM = 2e5 + 5;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
long long int bpow(long long int x, long long int n, long long int MOD) {
if (n == 0) return 1;
long long int ans = (bpow(x, n / 2, MOD) * bpow(x, n / 2, MOD)) % MOD;
if (n % 2) ans = (x * ans) % MOD;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int num_tests = 1;
while (num_tests-- > 0) {
long long int b, k;
cin >> b >> k;
vector<long long int> a(k);
for (long long int i = 0; i < k; i++) cin >> a[i];
long long int ans = 0;
for (long long int i = 1; i < k + 1; i++) {
ans += (a[i - 1] * bpow(b, k - i, 2)) % 2;
}
if (ans % 2)
cout << "odd";
else
cout << "even";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, mod = 1e9 + 7, Max1 = 13 * 5 + 10, Max2 = 14;
int n, k, m, ans = 0, ifac[20], cc[Max1][Max2];
vector<int> vec;
int Pow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
int C(int n, int k) {
if (n < 0 || k < 0 || n < k) return 0;
int ans = 1;
for (int i = 0; i < k; i++) ans = 1ll * ans * (n - i) % mod;
return 1ll * ans * ifac[k] % mod;
}
void go(int zr = 1, int sm = n - k, int cnt = 2, int pos = 1) {
if (sm < 0) return;
if (pos == k) {
ans = (1ll * ans + 1ll * zr * cc[n - sm][cnt]) % mod;
return;
}
int pt = int((vec).size()) - 1, tot = 1;
while (pt >= 0 && tot + vec[pt] <= m) {
tot += vec[pt];
pt--;
}
++pt;
for (int i = 0; i < m; i++) {
vec.push_back(i + 1);
go(1ll * zr * (int((vec).size()) - pt + 1) % mod, sm - i, cnt, pos + 1);
vec.pop_back();
tot++;
while (pt < int((vec).size()) && tot > m) {
tot -= vec[pt];
pt++;
}
}
vec.push_back(m + 1);
go(zr, sm - m, cnt + 1, pos + 1);
vec.pop_back();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
cin >> n >> k >> m;
int fc = 1;
for (int i = 0; i < 20; i++) {
ifac[i] = Pow(fc, mod - 2);
fc = 1ll * fc * (i + 1) % mod;
}
for (int i = 0; i < Max1; i++) {
for (int j = 0; j < Max2; j++) cc[i][j] = C(n - i + j - 1, j - 1);
}
go();
return cout << ans << endl, 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << "} ";
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long dx[4] = {-1, 1, 0, 0};
long long dy[4] = {0, 0, -1, 1};
long long XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
long long YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long N = (long long)(5 * 1e5 + 10);
long long tt, n, query, q, k, value, m, x, val, a, b, c, d, e, sum = 0;
int main() {
clock_t tStart = clock();
long long a, b, c, d;
cin >> a >> b >> c >> d;
string str;
cin >> str;
long long c1 = count(str.begin(), str.end(), '1');
long long c2 = count(str.begin(), str.end(), '2');
long long c3 = count(str.begin(), str.end(), '3');
long long c4 = count(str.begin(), str.end(), '4');
cout << c1 * a + c2 * b + c3 * c + c4 * d << "\n";
return 0;
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 10000001;
char p[MAX];
vector<char> P;
void f(){
for(int i=2 ; i < MAX ; i++ ) p[i] = 1;
for(int i=2 ; i+i < MAX ; i++ ){
if( p[i] ){
for(int j=i+i ; j < MAX ; j += i ){
p[j] = 0;
}
}
}
for(int i=2 ; i < MAX ; i++ ){
if( p[i] ) P.push_back( i );
}
}
int main(){
int n;
f();
while( cin >> n , n ){
int ans=0;
for(int a=2 ; a < n ; a++ ){
if( p[a] ){
int b = n - a;
if( a > b ) break;
if( p[b] ) ans++;
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[105][150005], tk[105], po2[25];
int arrbt[105][150005], vl[105][150005], p[105], pr[105];
vector<int> pri;
vector<int> kn[150005], cals, pv[150000];
map<int, int> mp;
void re(int cur, int val, int bm) {
if (val > 60) {
return;
}
if (mp[val] == 0) {
kn[bm].push_back(val);
}
mp[val] = 1;
re(cur, val * pri[cur], bm | po2[cur]);
if (cur + 1 < pri.size()) re(cur + 1, val, bm);
}
void ss(int bm, int lv) {
if (lv == pri.size()) {
return;
}
}
int main() {
po2[0] = 1;
for (int i = 1; i < 22; i++) {
po2[i] = po2[i - 1] * 2;
}
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d", &p[i]);
}
for (int i = 2; i <= 60; i++) {
if (pr[i] == 0) {
for (int j = 2 * i; j <= 100; j += i) {
pr[j] = 1;
}
pri.push_back(i);
}
}
re(0, 1, 0);
for (int i = 0; i < 150005; i++) {
if (!kn[i].empty()) {
cals.push_back(i);
}
}
for (int i = 0; i < 105; i++) {
for (int j = 0; j < 150005; j++) dp[i][j] = 1e9;
}
dp[0][0] = 0;
for (int i = 0; i < t; i++) {
for (int j = 0; j < 150005; j++) {
if (dp[i][j] != 1e9) {
for (int k = 0; k < cals.size(); k++) {
if ((cals[k] & j) == 0) {
int pos = cals[k];
for (int l = 0; l < kn[pos].size(); l++) {
if (dp[i + 1][j | pos] > dp[i][j] + abs(kn[pos][l] - p[i])) {
dp[i + 1][j | pos] = dp[i][j] + abs(kn[pos][l] - p[i]);
arrbt[i + 1][j | pos] = j;
vl[i + 1][j | pos] = kn[pos][l];
}
}
}
}
}
}
}
int mn = 1e9, pos = -1;
int cc = t, cc2 = cc;
for (int i = 0; i < 150005; i++) {
if (mn > dp[cc2][i]) {
mn = dp[cc2][i];
pos = i;
}
}
while (cc > 0) {
tk[cc] = vl[cc][pos];
pos = arrbt[cc][pos];
cc--;
}
for (int i = 1; i <= cc2; i++) {
printf("%d ", tk[i]);
}
}
| 2 |
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int H, max_;
while (true)
{
max_ = 0;
cin >> H;
if (H == 0) { break; }
vector<vector<char> > c(H, vector<char>(H));
vector<vector<int> > dp(H, vector<int>(H, 0));
for (int i = 0; i < H; i++)
{
dp[0][i] = 1; dp[i][0] = 1;
}
for (int i = 0; i < H; i++)
{
for (int j = 0; j < H; j++)
{
cin >> c[i][j];
if (c[i][j] == '*')
{
dp[i][j] = 0;
}
else
{
max_ = 1;
}
}
}
for (int i = 1; i < H; i++)
{
for (int j = 1; j < H; j++)
{
if (c[i][j] == '.')
{
dp[i][j] = min({ dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1] }) + 1;
max_ = max(dp[i][j], max_);
}
}
}
cout << max_ << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const int N = 1e3 + 5;
using namespace std;
int n, m, t;
int nx[6] = {0, 1, 0, -1, 0};
int a[N][N], c[N][N];
queue<pair<int, int> > q;
void create() {
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int p = 0; p <= 3; p++) {
int u = i + nx[p];
int v = j + nx[p + 1];
if (c[u][v] == c[i][j]) a[i][j] = 1, p = 4;
}
a[i][j]--;
if (a[i][j] == 0)
q.push(make_pair(i, j));
else
a[i][j] = 1e9;
}
}
}
void BFS() {
while (q.size()) {
pair<int, int> T = q.front();
q.pop();
for (int p = 0; p <= 3; p++) {
int u = T.first + nx[p];
int v = T.second + nx[p + 1];
if (a[u][v] > a[T.first][T.second] + 1) {
a[u][v] = a[T.first][T.second] + 1;
q.push(make_pair(u, v));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m >> n >> t;
memset(c, -1, sizeof(c));
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
char cc;
cin >> cc;
c[i][j] = cc - '0';
}
create();
BFS();
int d = 0;
while (t--) {
d++;
int u, v;
long long p;
cin >> u >> v >> p;
if (a[u][v] == 1e9)
cout << c[u][v] << '\n';
else {
if (p <= a[u][v])
cout << c[u][v] << '\n';
else {
if ((p - (long long)a[u][v]) & 1)
cout << 1 - c[u][v] << '\n';
else
cout << c[u][v] << '\n';
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i, x, n) for (int i = x; i < (int)(n); ++i)
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll go(int w, int h, int k){
ll an = 0;
f(x, 1, w)f(y2, 0, min(h, (2 * k - 2 + w) / (w - x) + 1)){
int y1 = min(h - 1ll, (2 * k + (ll)x * y2 + gcd(w, y2)) / w), t = 0;
if (y1 >= y2){
t += y1 - y2;
++y1;
if (y1 != h && (ll)w * y1 - gcd(x, y1) - gcd(w - x, y1 - y2) <= 2 * k + (ll)x * y2 - 2 + gcd(w, y2))++t;
}
an += t;
if (y2)an += t;
}
return an;
}
int main(){
int w, h, k;
scanf("%d%d%d", &w, &h, &k);
printf("%lld\n", go(w, h, k) + go(h, w, k) << 1);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int now[2][2];
int gcd(int a, int b) {
if (!b) return a;
swap(now[0][0], now[1][0]);
swap(now[0][1], now[1][1]);
int k = a / b;
now[1][0] -= k * now[0][0];
now[1][1] -= k * now[0][1];
return gcd(b, a % b);
}
int main() {
int n, s;
while (scanf("%d%d", &n, &s) >= 1) {
int c[3] = {0, 0, 0};
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x >= 3 && x <= 5) c[x - 3]++;
}
n = c[0] + c[1] + c[2];
int kans[3] = {-1, -1, -1};
int funcans = ((int)1E9);
int k[3];
for (k[1] = 0; k[1] * c[1] <= s; k[1]++) {
int z = s - k[1] * c[1];
int d = gcd(c[0], c[2]);
if (z % d) continue;
z /= d;
int a = c[0] / d, b = c[2] / d;
now[0][0] = 1, now[0][1] = 0;
now[1][0] = 0, now[1][1] = 1;
gcd(a, b);
k[0] = now[0][0], k[2] = now[0][1];
k[0] *= z, k[2] *= z;
assert(k[0] * c[0] + k[2] * c[2] == s - k[1] * c[1]);
int x0 = k[0] * c[0], delx0 = c[2] / d, delx2 = -c[0] / d;
int segmx[2] = {0, min(s - c[1] * k[1] - k[1] * c[2], k[1] * c[0])};
if (x0 % delx0 > segmx[1]) continue;
int func[3][2] = {{0, abs(s - 3 * k[1] * c[1])},
{2, k[1] * c[1] - s},
{-2, s - k[1] * c[1]}};
for (int i1 = 0; i1 < 3; i1++) {
for (int i2 = i1 + 1; i2 < 3; i2++) {
int bestx = (func[i1][1] - func[i2][1]) / (func[i2][0] - func[i1][0]);
bestx = min(bestx, segmx[1]);
bestx = max(bestx, segmx[0]);
int kn = (bestx - x0) / (delx0 * c[0]);
while (x0 + delx0 * kn * c[0] > bestx) kn--;
for (int iter = 0; iter < 2; iter++, kn++) {
int know[3] = {k[0], k[1], k[2]};
know[0] += delx0 * kn, know[2] += delx2 * kn;
assert(know[0] * c[0] + know[1] * c[1] + know[2] * c[2] == s);
if (know[0] * c[0] < segmx[0] || know[0] * c[0] > segmx[1])
continue;
int funcn = 0;
for (int i = 0; i < 3; i++)
funcn = max(funcn, know[0] * c[0] * func[i][0] + func[i][1]);
if (funcn < funcans) {
funcans = funcn;
for (int i = 0; i < 3; i++) kans[i] = know[i];
}
}
}
}
}
if (kans[0] == -1)
printf("-1\n");
else
printf("%d %d %d\n", kans[0], kans[1], kans[2]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n, x, y, a, b;
cin >> x >> y >> n;
b = (n - y) / x;
cout << b * x + y << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
struct ins {
int ans;
ins() { ans = 1; }
void read() {}
void read1(char &s) {
char c = getchar();
for (; !isprint(c) || c == ' ' || c == '\n' || c == '\t'; c = getchar())
;
s = c;
if (c == EOF) ans = 0;
}
void read1(string &s) {
s = "";
char c = getchar();
for (; !isprint(c) || c == ' ' || c == '\n' || c == '\t'; c = getchar())
;
for (; isprint(c) && c != ' ' && c != '\n' && c != '\t'; c = getchar())
s += c;
if (c == EOF) ans = 0;
}
template <typename T>
void read1(T &n) {
T x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') f = -1;
if (c == EOF) {
ans = 0;
return;
}
}
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
n = x * f;
if (c == EOF) ans = 0;
if (c != '.') return;
T l = 0.1;
while ((c = getchar()) <= '9' && c >= '0') x = x + (c & 15) * l, l *= 0.1;
n = x * f;
if (c == EOF) ans = 0;
}
void write() {}
void write1(string s) {
int n = s.size();
for (int i = 0; i < n; i++) putchar(s[i]);
}
void write1(const char *s) {
int n = strlen(s);
for (int i = 0; i < n; i++) putchar(s[i]);
}
void write1(char s) { putchar(s); }
void write1(float s, int x = 6) {
char y[10001];
sprintf(y, "%%.%df", x);
printf(y, s);
}
void write1(double s, int x = 6) {
char y[10001];
sprintf(y, "%%.%dlf", x);
printf(y, s);
}
void write1(long double s, int x = 6) {
char y[10001];
sprintf(y, "%%.%dLf", x);
printf(y, s);
}
template <typename T>
void write1(T n) {
if (n < 0) n = -n, putchar('-');
if (n > 9) write1(n / 10);
putchar('0' + n % 10);
}
template <typename T>
friend ins operator>>(ins x, T &n);
template <typename T>
friend ins operator<<(ins x, T n);
operator bool() { return ans; }
};
template <typename T>
ins operator>>(ins x, T &n) {
if (!x.ans) return x;
x.read1(n);
return x;
}
template <typename T>
ins operator<<(ins x, T n) {
x.write1(n);
return x;
}
ins yin;
ins yout;
int TTT;
int n, k, z;
const int maxn = 1e5 + 10;
int ans;
int a[maxn];
int dp[maxn][10];
int main() {
yin >> TTT;
while (TTT--) {
yin >> n >> k >> z;
++k;
ans = 0;
for (int i = 1; i <= n; i++) {
yin >> a[i];
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j <= z; j++) {
dp[i][j] = dp[i - 1][j] + a[i];
if (!j) ans = max(ans, dp[i][j]);
if (j * 2 + i <= k && j) {
dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[i] + a[i - 1]);
ans = max(ans, dp[i][j]);
}
if (j * 2 + i - 1 == k && j) {
ans = max(ans, dp[i][j - 1] + a[i - 1]);
}
}
}
cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int T, i;
long long int a, b, ans;
scanf("%d", &T);
for (i = 1; i <= T; i++) {
scanf("%lld %lld", &a, &b);
if (a > b) {
if (b * 2 <= a) {
printf("%lld\n", b);
} else {
ans = (a + b) / 3;
printf("%lld\n", ans);
}
} else {
if (a * 2 <= b) {
printf("%lld\n", a);
} else {
ans = (a + b) / 3;
printf("%lld\n", ans);
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
struct node {
int p, r, c;
};
node pre[maxn][26][26];
int cost[maxn][26][26];
int dp[maxn][26][26];
char s[maxn][maxn];
int n, m;
void print(int deep, int r, int c) {
if (deep == 0) return;
node tmp = pre[deep][r][c];
print(tmp.p, tmp.r, tmp.c);
for (int i = 1; i <= m; i++)
if (i & 1)
printf("%c", r + 'a');
else
printf("%c", c + 'a');
printf("\n");
}
int main() {
scanf("%d%d", &n, &m);
memset(dp, 0x3f, sizeof(dp));
memset(dp[0], 0, sizeof(dp[0]));
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < 26; j++) {
for (int k = 0; k < 26; k++) {
if (j == k) {
cost[i][j][k] = 0x3f3f3f3f;
continue;
}
for (int t = 1; t <= m; t++) {
if (t % 2 == 1) {
if (s[i][t] - 'a' != j) cost[i][j][k]++;
} else {
if (s[i][t] - 'a' != k) {
cost[i][j][k]++;
}
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
for (int k = 0; k < 26; k++) {
for (int p = 0; p < 26; p++) {
for (int q = 0; q < 26; q++) {
if (p == j || q == k) continue;
if (dp[i - 1][p][q] + cost[i][j][k] < dp[i][j][k]) {
dp[i][j][k] = dp[i - 1][p][q] + cost[i][j][k];
pre[i][j][k] = (node){i - 1, p, q};
}
}
}
}
}
}
int ans = 0x3f3f3f3f;
int nowr, nowc;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
if (ans > dp[n][i][j]) {
ans = dp[n][i][j];
nowr = i, nowc = j;
}
}
}
printf("%d\n", ans);
print(n, nowr, nowc);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
struct edge {
int to, w;
edge(int a = 0, int b = 0) { to = a, w = b; }
};
int deep[maxn], fa[maxn], store[maxn], tail, n, k;
vector<edge> graph[maxn];
void dfs(int node) {
for (int i = 0; i < graph[node].size(); ++i) {
edge e = graph[node][i];
int to = e.to, w = e.w;
if (fa[to] == 0) {
if (deep[to] == -1) deep[to] = deep[node] + w;
fa[to] = node;
dfs(to);
}
}
}
int main() {
scanf("%d%d", &n, &k);
int from, to, w;
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%d", &from, &to, &w);
graph[from].push_back(edge(to, w));
graph[to].push_back(edge(from, w));
}
memset(deep, -1, sizeof(deep));
memset(fa, 0, sizeof(fa));
fa[1] = -1;
deep[1] = 0;
dfs(1);
int ed1 = 1, ed2;
for (int i = 1; i <= n; ++i) {
if (deep[i] > deep[ed1]) ed1 = i;
}
memset(deep, -1, sizeof(deep));
memset(fa, 0, sizeof(fa));
fa[ed1] = -1;
deep[ed1] = 0;
dfs(ed1);
ed2 = ed1;
for (int i = 1; i <= n; ++i) {
if (deep[i] > deep[ed2]) ed2 = i;
}
int deepest = deep[ed2];
for (int i = ed2; i != -1; i = fa[i]) {
store[tail++] = i;
}
int l, r;
if (tail <= k)
l = 0, r = tail - 1;
else {
int L = 0;
for (int i = 0; i < tail - k + 1; ++i) {
if (max(deepest - deep[store[i]], deep[store[i + k - 1]]) <
max(deepest - deep[store[L]], deep[store[L + k - 1]]))
L = i;
}
l = L, r = l + k - 1;
}
memset(deep, -1, sizeof(deep));
memset(fa, 0, sizeof(fa));
fa[store[l]] = -1;
for (int i = l; i <= r; ++i) {
deep[store[i]] = 0;
}
dfs(store[l]);
int ans = 0;
for (int i = 1; i <= n; ++i) ans = max(ans, deep[i]);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const double eps = 1e-9, INF = 0x3f3f3f3f;
double sy, a, b, sum[maxn], l[maxn], r[maxn];
int n, q;
inline void init() {
scanf("%lf%lf%lf", &sy, &a, &b);
scanf("%d", &n);
n++;
l[1] = r[1] = 0;
for (int i = 2; i <= n; i++) {
scanf("%lf%lf", &l[i], &r[i]);
sum[i] = sum[i - 1] + (r[i] - l[i]);
}
++n;
l[n] = r[n] = INF;
sum[n] = sum[n - 1];
}
inline void solve() {
scanf("%d", &q);
while (q--) {
double x, y;
scanf("%lf%lf", &x, &y);
double sfb = y / (y - sy);
double pax = a - x, pbx = b - x;
pax *= sfb;
pbx *= sfb;
pax += x;
pbx += x;
if (pbx <= l[1] || pax >= r[n]) {
printf("0.00000000\n");
continue;
}
double ans = 0;
int L = 1, R = n;
while (L < R) {
int mid = (L + R + 1) >> 1;
if (l[mid] <= pax)
L = mid;
else
R = mid - 1;
}
ans -= sum[L] - max(0.0, r[L] - pax);
L = 1, R = n;
while (L < R) {
int mid = (L + R) >> 1;
if (r[mid] >= pbx)
R = mid;
else
L = mid + 1;
}
ans += sum[R];
ans -= min(r[L] - pbx, r[L] - l[L]);
ans = ans / sfb;
printf("%.7f\n", ans);
}
}
int main() {
init();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 201000;
int n, a[N], val[N], pos[N];
long long ret, s;
map<int, int> hs;
void add(int l, int r) {
if (l > r) return;
auto p = hs.upper_bound(l);
--p;
if (p->second >= r) return;
int prx = l, pry = p->second;
hs[l] = r;
while (1) {
auto p = hs.upper_bound(l);
s -= (long long)pry * (p->first - prx);
prx = p->first;
pry = p->second;
if (pry > r) {
s += (long long)(prx - l) * r;
break;
}
hs.erase(p);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%d", a + i), pos[a[i]] = i;
hs[0] = 0;
for (int i = 1; i < n + 1; i++) hs[i] = i - 1;
hs[n + 1] = n + 1;
for (int i = 1; i < n + 1; i++) val[i] = i - 1;
s = n * (n - 1) / 2;
for (int i = 200001 - 1; i >= 1; i--) {
vector<int> v;
for (int j = i; j <= 200000; j += i)
if (pos[j]) v.push_back(pos[j]);
sort((v).begin(), (v).end());
if (((int)(v).size()) > 1) {
int m = ((int)(v).size());
add(1, v[m - 2] - 1);
add(v[0] + 1, v[m - 1] - 1);
add(v[1] + 1, n);
}
ret += s - n * (n - 1) / 2;
}
printf("%lld\n", ret);
}
| 3 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
const int M=300;
int N,x,y;
int dp[101][301][601];
int main(){
cin>>N>>x>>y;
rep(i,N+1) rep(j,301) rep(k,601) dp[i][j][k]=-1;
dp[0][0][M]=0;
rep(i,N){
int a,b,c,d;
cin>>a>>b>>c>>d;
rep(j,301) rep(k,601) if(dp[i][j][k]>=0){
chmax(dp[i+1][j][k],dp[i][j][k]);
if(j+a<=x) chmax(dp[i+1][j+a][k-b],dp[i][j][k]);
chmax(dp[i+1][j][k+c],dp[i][j][k]+d);
}
}
int ans=0;
rep(j,x+1) rep(k,601) if(k-M<=y) chmax(ans,dp[N][j][k]);
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct Data {
using type = int;
type val, lazy;
static type id() { return INT_MAX; }
static type op(const type& l, const type & r) { return min(l, r); }
Data(type v) : val(v), lazy(-1) {}
void update(type a) { lazy = a; }
type get() { return lazy == -1 ? val : lazy; }
void push(Data& l, Data& r) {
if (lazy == -1) return;
val = lazy;
l.lazy = lazy;
r.lazy = lazy;
}
};
template <typename M>
class LazySegmentTree {
using T = typename M::type;
const int n;
vector<M> data;
int size(int n) {
int res = 1;
while (res < n) res <<= 1;
return res;
}
void suc(int l, int r, int node, int lb, int ub, T val) {
if (ub <= l || r <= lb) return;
if (l <= lb && ub <= r) {
data[node].update(val);
return;
}
data[node].push(data[node * 2], data[node * 2 + 1]);
int c = (lb + ub) / 2;
suc(l, r, node * 2, lb, c, val);
suc(l, r, node * 2 + 1, c, ub, val);
data[node] = M::op(data[node * 2].get(), data[node * 2 + 1].get());
}
T sub(int l, int r, int node, int lb, int ub) {
if (ub <= l || r <= lb) return M::id();
if (l <= lb && ub <= r) return data[node].get();
data[node].push(data[node * 2], data[node * 2 + 1]);
int c = (lb + ub) / 2;
return M::op(sub(l, r, node * 2, lb, c), sub(l, r, node * 2 + 1, c, ub));
}
public:
LazySegmentTree(int n_) : n(size(n_)), data(n * 2, M::id()) {}
void init(const vector<T>& data_) {
for (int i = 0; i < (int)data_.size(); i++)
data[i + n] = data_[i];
for (int i = n - 1; i >= 0; i--)
data[i] = M::op(data[i * 2], data[i * 2 + 1]);
}
void update(int l, int r, T val) {
suc(l, r + 1, 1, 0, n, val);
}
T find(int l, int r) {
return sub(l, r + 1, 1, 0, n);
}
};
int main()
{
ios::sync_with_stdio(false), cin.tie(0);
int n, q, com, x, y, val;
cin >> n >> q;
LazySegmentTree<Data> st(n);
while (q--) {
cin >> com >> x >> y;
if (com) {
printf("%d\n", st.find(x, y));
}
else {
cin >> val;
st.update(x, y, val);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int skillexp[100];
map<string, int> sk;
int main() {
int n, m;
double k;
cin >> n >> m >> k;
int t = 0;
for (int i = 0; i < n; ++i) {
int b;
string a;
cin >> a >> b;
if ((sk[a] + b) * k + 1e-8 > 100) {
sk[a] = (int)((sk[a] + b) * k + 1e-8);
} else {
sk.erase(sk.find(a));
}
}
for (int i = 0; i < m; ++i) {
int b = 0;
string a;
cin >> a;
sk[a] = sk[a] + b;
}
cout << sk.size() << endl;
for (map<string, int>::iterator it = sk.begin(); it != sk.end(); ++it) {
cout << it->first << " " << it->second << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void debug(int n, ...) {
va_list v1;
va_start(v1, n);
for (int i = 0; i < n; i++) {
int val = va_arg(v1, int);
printf("%d ", val);
}
va_end(v1);
printf("\n");
}
double n, k;
double sum;
int ans;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
double m;
cin >> m;
sum += m;
}
while (sum / (double)n < (k - 0.5)) {
sum += k;
ans++;
n++;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename G1, typename G2 = G1, typename G3 = G1>
struct triple {
G1 first;
G2 second;
G3 T;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v) cin >> i, --i;
int m = min(n, 100);
vector<vector<int>> o(m);
for (int i = 0; i < n; i++) o[v[i]].push_back(i);
int mx = 0;
for (int i = 0; i < m; i++)
if (o[i].size() > o[mx].size()) mx = i;
vector<int> mp(2 * n + 1, n);
int ans = 0;
for (int i = 0; i < m; i++)
if (i != mx && !o[i].empty()) {
if (o[i].size() == o[mx].size()) {
ans = n;
break;
}
int p1 = 0, p2 = 0, s = 0;
mp[n] = -1;
vector<int> upd;
while (p1 < o[mx].size() || p2 < o[i].size()) {
if (p1 == o[mx].size()) {
ans = max(ans, o[i][p2] - mp[s + n] - 1);
--s;
mp[s + n] = min(mp[s + n], o[i][p2]);
upd.push_back(s);
++p2;
} else if (p2 == o[i].size()) {
ans = max(ans, o[mx][p1] - mp[s + n] - 1);
++s;
mp[s + n] = min(mp[s + n], o[mx][p1]);
upd.push_back(s);
++p1;
} else {
if (o[mx][p1] > o[i][p2]) {
ans = max(ans, o[i][p2] - mp[s + n] - 1);
--s;
mp[s + n] = min(mp[s + n], o[i][p2]);
upd.push_back(s);
++p2;
} else {
ans = max(ans, o[mx][p1] - mp[s + n] - 1);
++s;
mp[s + n] = min(mp[s + n], o[mx][p1]);
upd.push_back(s);
++p1;
}
}
}
ans = max(ans, n - mp[s + n] - 1);
for (auto j : upd) mp[j + n] = n;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b;
scanf("%c %c", &a, &b);
int k, arr[4] = {118, 60, 94, 62}, fir, sec;
scanf("%d", &k);
k %= 4;
for (int i = 0; i < 4; i++) {
if (a == arr[i]) fir = i;
if (b == arr[i]) sec = i;
}
if ((fir + k) % 4 == sec && (sec + k) % 4 == fir)
printf("undefined");
else if ((fir + k) % 4 == sec)
printf("cw");
else if ((sec + k) % 4 == fir)
printf("ccw");
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.