solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& x) {
return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-8;
char TEMPORARY_CHAR;
const long long INF = 1e17;
const int N = 1 << 17;
inline void input(int& a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
vector<vector<pair<int, int> > > g;
int dp1[3000], dp2[3000];
int cnt = 0;
int dfs(int v, int p) {
int mi1 = dp2[v] - dp1[v], mi2 = 1e9;
for (int i = 0; i < (int)(g[v].size()); i++) {
int to = g[v][i].first;
if (to != p) {
dp1[to] = dp1[v] + g[v][i].second;
dp2[to] = dp2[v] + 1 - g[v][i].second;
cnt += g[v][i].second;
int rr = dfs(to, v);
if (rr < mi1) {
mi2 = mi1;
mi1 = rr;
} else if (rr < mi2)
mi2 = rr;
}
}
int ret = mi1;
if (p == -1) ret += mi2;
return ret;
}
int main() {
int(n);
input((n));
;
if (n == 1) {
puts("0");
return 0;
}
g.resize(n);
memset((dp1), 0, sizeof(dp1));
memset((dp2), 0, sizeof(dp2));
for (int i = 0; i < (int)(n - 1); i++) {
int(a);
input((a));
;
int(b);
input((b));
;
g[a - 1].push_back(make_pair(b - 1, 0));
g[b - 1].push_back(make_pair(a - 1, 1));
}
dfs(0, -1);
int val[n];
int ans = 1e9;
for (int i = 0; i < (int)(n); i++) {
val[i] = cnt - dp1[i] + dp2[i];
ans = min(ans, val[i]);
}
for (int i = 0; i < (int)(n); i++) {
memset((dp1), 0, sizeof(dp1));
memset((dp2), 0, sizeof(dp2));
ans = min(val[i] + dfs(i, -1), ans);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > nei[100005];
int from[100005], to[100005], cost[100005];
long long cnt[100005], yp[100005];
void dfs(int root, int parent) {
cnt[root] = 1;
for (int i = 0; i < nei[root].size(); i++) {
if (nei[root][i].first != parent) {
dfs(nei[root][i].first, root);
cnt[root] += cnt[nei[root][i].first];
yp[nei[root][i].second] =
1ll * cnt[nei[root][i].first] * (n - cnt[nei[root][i].first]);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> from[i] >> to[i] >> cost[i];
from[i]--;
to[i]--;
nei[from[i]].push_back(make_pair(to[i], i));
nei[to[i]].push_back(make_pair(from[i], i));
}
dfs(0, -1);
long long ans = 0;
for (int i = 0; i < n - 1; i++) {
ans += yp[i] * cost[i];
}
double d = 6.0 / n / (n - 1);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--;
ans -= yp[a] * (cost[a] - b);
cost[a] = b;
cout << setprecision(10) << d * ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
using ld = long double;
using ll = long long;
const ld EPS = 1e-10;
int n, m, x, y, t, c[N * 2], v[N];
ld p, q, a[N], b[N];
pair<ld, int> s[N * 2];
inline int lowbit(int x) { return x & -x; }
void add(int x) {
while (x <= t) ++c[x], x += lowbit(x);
}
int query(int x) {
int ret = 0;
while (x) ret += c[x], x -= lowbit(x);
return ret;
}
void solve(ld r) {
t = 0;
for (int i = 1; i <= n; i++) {
ld aa = a[i], bb = b[i],
d = 4 * aa * aa * bb * bb - 4 * (aa * aa + 1) * (bb * bb - r * r);
if (d < EPS) continue;
d = sqrt(d);
ld x1 = (-2 * aa * bb - d) / (2 * (aa * aa + 1));
ld x2 = (-2 * aa * bb + d) / (2 * (aa * aa + 1));
ld y1 = aa * x1 + bb, y2 = aa * x2 + bb;
s[++t] = {atan2(y1, x1), i};
s[++t] = {atan2(y2, x2), i};
v[i] = 0;
}
sort(s + 1, s + t + 1);
for (int i = t; i > 0; --i)
if (!v[s[i].second]) v[s[i].second] = i;
}
bool check(ld r) {
solve(r);
for (int i = 1; i <= t; i++) c[i] = 0;
ll ret = 0;
for (int i = 1; i <= t; i++)
if (v[s[i].second] != i) {
ret += query(v[s[i].second]) - query(i - 1);
add(v[s[i].second]);
}
return ret >= m;
}
ld calc(int i, int j) {
ld x = (b[j] - b[i]) / (a[i] - a[j]), y = a[i] * x + b[i];
return sqrt(x * x + y * y);
}
ld calc(ld r) {
solve(r);
set<pair<int, int>> st;
ld ret = 0;
int cnt = 0;
for (int i = 1; i <= t; i++)
if (v[s[i].second] != i) {
auto it = st.upper_bound({i + 1, 0});
while (it != st.end() && it->first < v[s[i].second])
ret += calc(s[i].second, it->second), ++it, ++cnt;
st.insert({v[s[i].second], s[i].second});
}
return ret + (m - cnt) * r;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> x >> y >> m;
p = x / 1000.0;
q = y / 1000.0;
for (int i = 1; i <= n; i++)
cin >> x >> y, a[i] = x / 1000.0, b[i] = y / 1000.0 + a[i] * p - q;
ld l = 0, r = 1e10;
for (int _ = 1; _ <= 100; _++) {
ld mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.10lf\n", double(max(0.0l, calc(r))));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k, m, c1 = 0, count2 = 0, m3 = 0;
cin >> n;
long long int a[n];
map<long long int, long long int> m1;
for (i = 0; i < n; i++) {
cin >> a[i];
m1[i] = -1;
}
cin >> m;
vector<long long int> v;
for (i = 0; i < m; i++) {
long long int p, q, r;
cin >> p;
if (p == 1) {
cin >> q >> r;
a[q - 1] = r;
m1[q - 1] = i;
v.push_back(0);
} else {
cin >> q;
m3 = max(m3, q);
v.push_back(q);
}
}
long long int max1[v.size() - 1];
memset(max1, 0, sizeof(max1));
long long int m_1 = 0;
for (i = (m - 1); i >= 0; i--) {
if (v[i] > m_1) {
max1[i] = max(m_1, v[i]);
m_1 = max(m_1, v[i]);
} else {
max1[i] = m_1;
m_1 = max(m_1, v[i]);
}
}
for (i = 0; i < n; i++) {
if (m1[i] >= m) {
cout << a[i] << " ";
} else if (m1[i] != -1) {
cout << max(a[i], max1[m1[i]]) << " ";
} else {
cout << max(a[i], m3) << " ";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, x, y, ans, t[10], sz[200010], f[200010][5];
vector<int> g[200010];
void dfs1(int u, int p) {
sz[u] = 1;
for (int v : g[u]) {
if (v != p) {
dfs1(v, u);
sz[u] += sz[v];
f[u][0] += f[v][k - 1] + sz[v];
for (int i = 1; i < k; i++) {
f[u][i] += f[v][i - 1];
}
}
}
}
void dfs2(int u, int p) {
memset(t, 0, sizeof(t));
if (p) {
t[0] = f[p][0] - f[u][k - 1] - sz[u];
for (int i = 1; i < k; i++) {
t[i] = f[p][i] - f[u][i - 1];
}
}
f[u][0] += t[k - 1] + n - sz[u];
for (int i = 1; i < k; i++) {
f[u][i] += t[i - 1];
}
for (int v : g[u]) {
if (v != p) {
dfs2(v, u);
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
ans += f[i][0];
}
cout << ans / 2;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool J27 = 1;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
if (!J27) return;
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
if (!J27) return;
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline void INP();
const long long N = 3e4 + 7;
const long long INF = LLONG_MAX;
const long long inf = INT_MAX;
long long n, Q, k;
long long arr[N + 2];
pair<long long, long long> query(vector<long long>& vec) {
cout << "? ";
for (auto i : vec) cout << i << " ";
cout << '\n';
cout.flush();
pair<long long, long long> p;
cin >> p.first >> p.second;
return p;
}
void solve() {
cin >> n >> k;
memset(arr, -1, sizeof(arr));
vector<long long> vec;
for (long long i = 1; i < (long long)k + 1; i++) vec.push_back(i);
pair<long long, long long> p = query(vec);
pair<long long, long long> mafia = p;
vec.clear();
for (long long i = 1; i < (long long)k + 2; i++)
if (i != p.first) vec.push_back(i);
p = query(vec);
pair<long long, long long> val = p;
long long small = 0;
long long id = 0;
for (long long i = 0; i < (long long)k; i++)
if (vec[i] == val.first) id = i;
swap(vec[id], vec[0]);
id = k - 1;
while (id > 0) {
long long r = vec[id];
vec[id] = mafia.first;
p = query(vec);
if (p.second > val.second)
small++;
else if (p.second == val.second and mafia.second < val.second)
small++;
vec[id] = r;
id--;
}
cout << "! " << small + 1 << '\n';
cout.flush();
}
int32_t main() {
J27 = 1;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
INP();
long long t = 1;
while (t--) solve();
}
inline void INP() {}
| 5 |
#include <bits/stdc++.h>
int f[100001], m, n, g[100001], i, j, k, s, p;
int main() {
scanf("%d%d", &n, &m);
memset(g, 0, sizeof(g));
s = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &f[i]);
if (f[i] > 0) {
g[f[i]]++;
} else {
s++;
g[-f[i]]--;
}
}
p = 0;
for (i = 1; i <= n; i++) {
if (g[i] + s == m) {
g[i] = 1;
p++;
} else
g[i] = 0;
}
if (p == 1) {
for (i = 1; i <= n; i++) {
if (f[i] > 0) {
if (g[f[i]])
printf("Truth\n");
else
printf("Lie\n");
} else {
if (g[-f[i]])
printf("Lie\n");
else
printf("Truth\n");
}
}
} else if (p == 0) {
for (i = 1; i <= n; i++) printf("Lie\n");
} else {
for (i = 1; i <= n; i++) {
if (f[i] > 0) {
if (g[f[i]])
printf("Not defined\n");
else
printf("Lie\n");
} else {
if (g[-f[i]])
printf("Not defined\n");
else
printf("Truth\n");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
unsigned long long dp[M][12];
int A[M], n, K;
struct BIT {
unsigned long long bit[M];
inline void add(int x, unsigned long long a) {
for (; x <= n; bit[x] += a, x += x & -x)
;
}
inline unsigned long long sum(int x) {
unsigned long long ans = 0;
for (; x; ans += bit[x], x -= x & -x)
;
return ans;
}
inline void Init() { memset(bit, 0, sizeof(bit)); }
} T;
int main() {
cin >> n >> K;
++K;
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]), dp[i][1] = 1;
for (int i = 1; i <= n; ++i) T.add(A[i], 1);
for (int i = 2; i <= K; ++i) {
T.Init();
for (int j = 1; j <= n; ++j) {
T.add(A[j], dp[j][i - 1]);
dp[j][i] += T.sum(A[j] - 1);
}
}
unsigned long long ans = 0;
for (int i = 1; i <= n; ++i) ans += dp[i][K];
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
int n;
vector<int> a;
map<pair<int, int>, int> dp;
int func(int p, int q) {
if (p == a.size()) return 0;
if (dp.find(make_pair(p, q)) != dp.end()) return dp[make_pair(p, q)];
if (q == 0) {
return dp[make_pair(p, q)] = func(p + 1, a[p]) + 1;
} else {
if (q + 1 + a[p] <= n) {
return dp[make_pair(p, q)] =
min(func(p + 1, q + 1 + a[p]), func(p + 1, a[p]) + 1);
} else {
return dp[make_pair(p, q)] = func(p + 1, a[p]) + 1;
}
}
}
int main() {
cin >> n;
string s;
a.push_back(0);
while (cin >> s) {
if (a.back() != 0) ++a.back();
a.back() += s.length();
char c = s[s.length() - 1];
if (c == '.' || c == '?' || c == '!') {
a.push_back(0);
}
}
a.pop_back();
for (int i = 0; i < a.size(); ++i) {
if (a[i] > n) {
cout << "Impossible" << endl;
return 0;
}
}
cout << func(0, 0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long i, sum, t, k = 0;
vector<long long> v;
long long start = 0;
if (n > 100) start = n - 100;
for (i = start; i < n; i++) {
t = i;
sum = 0;
while (t) {
sum += t % 10;
t /= 10;
}
if (i + sum == n) {
k++;
v.push_back(i);
}
}
cout << k << endl;
for (i = 0; i < k; i++) {
cout << v[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long ans = 0;
if (n > a * .5 + b + c * 2) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
long long x = n - i - j * 2;
if (x >= 0 && x * 2 <= a) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
bool chck1(string s){
vector<int>v(26,0);
int n=s.length();
for(int i=0;i<n;i++){
int j=s[i]-'a';
if(v[j]==1) return false;
v[j]++;
}
for(int i=0;i<n;i++){
if(v[i]==0) return false;
}
return true;
}
bool chck2(string s,int l,int r,int i){
int n=s.length();
if(r-l+1<n ){
char c='a'+i;
// cout<<c<<endl;
if(l>0&&s[l-1]==c) return chck2(s,l-1,r,i+1);
else if(r<n-1&&s[r+1]==c) return chck2(s,l,r+1,i+1);
else return false;
}
return true;
}
void solve(){
string s;
cin>>s;
if(chck1(s)){
int i=0;
while(s[i]!='a') i++;
if(chck2(s,i,i,1)) cout<<"YES\n";
else cout<<"NO\n";
}
else cout<<"NO\n";
}
int main(){
int t;
cin>>t;
while(t--){
solve();
}
} | 0 |
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 400010;
int n, q;
vector<pair<long long, long long> > G[maxN];
map<int, pair<long long, long long> > ei;
long long e1[maxN], ind1[maxN];
long long dist[maxN];
long long st[maxN], disc[maxN], fin[maxN], t;
void dfs(int cur) {
st[cur] = ++t;
disc[t] = cur;
for (int i = 0; i < (int)G[cur].size(); i++) {
int nxt = G[cur][i].first;
dist[nxt] = dist[cur] + G[cur][i].second;
dfs(nxt);
}
fin[cur] = t;
}
long long segt[1 << 20], lazy[1 << 20];
void build(int node, int l, int r) {
if (l == r) {
segt[node] = dist[disc[l]] + e1[disc[l]];
return;
}
int mid = (l + r) >> 1, nxt = node << 1;
build(nxt, l, mid);
build(nxt + 1, mid + 1, r);
segt[node] = min(segt[nxt], segt[nxt + 1]);
}
void lazyprop(int node, int l, int r) {
if (!lazy[node]) return;
segt[node] += lazy[node];
if (l != r) {
int nxt = node << 1;
lazy[nxt] += lazy[node];
lazy[nxt + 1] += lazy[node];
}
lazy[node] = 0;
}
void update(int node, int l, int r, int i, int j, long long val) {
lazyprop(node, l, r);
if (l > r || i > r || j < l) return;
if (i <= l && j >= r) {
lazy[node] = val;
lazyprop(node, l, r);
return;
}
int mid = (l + r) >> 1, nxt = node << 1;
update(nxt, l, mid, i, j, val);
update(nxt + 1, mid + 1, r, i, j, val);
segt[node] = min(segt[nxt], segt[nxt + 1]);
}
long long query(int node, int l, int r, int i, int j) {
if (l > r || i > r || j < l) return LLONG_MAX;
lazyprop(node, l, r);
if (i <= l && j >= r) return segt[node];
int mid = (l + r) >> 1, nxt = node << 1;
return min(query(nxt, l, mid, i, j), query(nxt + 1, mid + 1, r, i, j));
}
int main(int argc, char** argv) {
scanf("%d %d", &n, &q);
int a, b, c;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
G[a].push_back(pair<long long, long long>(b, c));
ei[i] = pair<long long, long long>(a, b);
}
dfs(0);
for (int i = n - 1; i < 2 * n - 2; i++) {
scanf("%d %d %d", &a, &b, &c);
a--;
e1[a] = c;
ind1[i] = a;
}
build(1, 1, n);
int qi;
for (int i = 0; i < q; i++) {
scanf("%d %d %d", &qi, &a, &b);
if (qi == 1) {
a--;
if (a >= n - 1) {
update(1, 1, n, st[ind1[a]], st[ind1[a]], b - e1[ind1[a]]);
e1[ind1[a]] = b;
} else {
int u = ei[a].first, v = ei[a].second;
long long d1 = query(1, 1, n, st[u], st[u]) - e1[u],
d2 = query(1, 1, n, st[v], st[v]) - e1[v];
update(1, 1, n, st[v], fin[v], b - d2 + d1);
}
} else {
a--;
b--;
long long d1 = query(1, 1, n, st[a], st[a]) - e1[a],
d2 = query(1, 1, n, st[b], st[b]) - e1[b];
if (st[a] <= st[b] && fin[a] >= fin[b])
printf("%lld\n", d2 - d1);
else {
int minup = query(1, 1, n, st[a], fin[a]);
printf("%lld\n", minup - d1 + d2);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double d, h, v, e;
int main() {
cin >> d >> h >> v >> e;
d /= 2;
if (v / (3.14159265359 * d * d) <= e)
printf("NO\n");
else
printf("YES\n%.10f", h / (v / (3.14159265359 * d * d) - e));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c = 0, temp = 0;
cin >> a >> b;
if (a % b == 0) {
cout << a / b << endl;
} else {
while (1) {
if (a % b == 0) {
c += a / b;
break;
}
c += a / b;
temp = a;
a = b;
b = temp % b;
}
cout << c << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100 + 10];
int main() {
ios_base::sync_with_stdio(false);
int n, f = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n % 2 == 0 || n == 1) {
cout << -1;
return 0;
}
for (int i = n; i >= 1; i -= 2) {
int m = max(a[i], a[i - 1]);
f += m;
a[(i - 1) / 2] -= m;
a[i] = 0;
a[i - 1] = 0;
if (a[(i - 1) / 2] < 0) a[(i - 1) / 2] = 0;
}
cout << f;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200009];
int c[200009];
set<int> col[200009];
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
int fans = 1e6;
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
fans = min(fans, c[i]);
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
int id = c[i];
for (int j = 0; j < g[i].size(); j++) {
if (c[g[i][j]] != id) {
col[id].insert(c[g[i][j]]);
}
}
}
int maxx = -1, maxid = -1;
for (int i = 1; i <= 100000; i++) {
int sz = col[i].size();
if (maxx < sz) {
maxx = sz;
maxid = i;
}
}
if (maxx == 0) {
maxid = fans;
}
printf("%d\n", maxid);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std ;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0) ;
#define int long long int
#define pb push_back
#define pob pop_back
#define mod 1000000007
int32_t main()
{
IOS ;
int n, k, x ;
cin >> n >> k >> x ;
int a[n] ;
for (int i=0; i<n; i++)
cin >> a[i] ;
sort(a, a+n);
// store & sort gaps
vector<int> gaps ;
for (int i=1; i<n; i++)
{
if (a[i]-a[i-1]>x)
gaps.pb(a[i]-a[i-1]) ;
}
sort(gaps.begin(), gaps.end()) ;
// remove gaps
int gaps_removed = 0 ;
for (int i=0; i<gaps.size(); i++)
{
int temp = (gaps[i]%x==0)? gaps[i]/x -1 : gaps[i]/x ;
if (temp<=k)
{
k -= temp ;
gaps_removed++ ;
}
else
break ;
}
cout << gaps.size()- gaps_removed +1 << endl ;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, multiset<int>> incr, decr;
int n;
int ans[100111];
int pos[100111];
int b[100111];
int main() {
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) {
int v;
scanf("%d", &v);
pos[v - 1] = i;
}
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
b[i]--;
if (pos[b[i]] <= i) {
decr[i - pos[b[i]]].insert(b[i]);
} else {
incr[pos[b[i]] - i].insert(b[i]);
}
}
for (i = 0; i < n; i++) {
ans[i] = n;
if (!incr.empty()) {
ans[i] = min(ans[i], incr.begin()->first + i);
}
if (!decr.empty()) {
ans[i] = min(ans[i], decr.begin()->first - i);
}
if (!decr.empty() && decr.begin()->first == i) {
for (auto nv : decr.begin()->second) {
incr[-i].insert(nv);
}
decr.erase(i);
}
incr[pos[b[i]] - i].erase(b[i]);
if (incr[pos[b[i]] - i].empty()) {
incr.erase(pos[b[i]] - i);
}
decr[n - pos[b[i]] + i].insert(b[i]);
}
for (i = 0; i < n; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
cin >> n;
long int var;
vector<long int> even, odd, even1, odd1;
while (n--) {
cin >> var;
if (var % 2 == 0)
even.push_back(var);
else
odd.push_back(var);
}
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
even1 = even;
odd1 = odd;
while (1) {
if (even.empty())
break;
else
even.pop_back();
if (odd.empty())
break;
else
odd.pop_back();
}
while (1) {
if (odd1.empty())
break;
else
odd1.pop_back();
if (even1.empty())
break;
else
even1.pop_back();
}
long int ans1, ans2;
ans1 = ans2 = 0;
for (long int i = 0; i < even.size(); i++) ans1 += even[i];
for (long int i = 0; i < odd.size(); i++) ans1 += odd[i];
for (long int i = 0; i < even1.size(); i++) ans2 += even1[i];
for (long int i = 0; i < odd1.size(); i++) ans2 += odd1[i];
cout << min(ans1, ans2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
using namespace std;
long long dp[(1 << 24)];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
int a = 1 << (arr[i][0] - 'a'), b = 1 << (arr[i][1] - 'a'),
c = 1 << (arr[i][2] - 'a');
dp[a]++, dp[b]++, dp[c]++;
dp[a | b]--, dp[a | c]--, dp[b | c]--;
dp[a | b | c]++;
}
for (int i = 0; i < 24; i++) {
for (int j = 0; j < (1 << 24); j++) {
if (j & (1 << i)) dp[j] += dp[j ^ (1 << i)];
}
}
long long ans = 0;
for (int i = 0; i < (1 << 24); i++) {
ans ^= (dp[i] * dp[i]);
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long n = s.size();
long long cnt = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == 'b')
cnt++;
else {
ans += cnt;
ans %= 1000000007;
cnt *= 2;
}
cnt %= 1000000007;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<pair<string, long long>> a(n);
for (long long i = 0; i < (n); i++) {
long long x;
cin >> x;
a[i].second = i;
if (x > 0) {
long long k = 0;
while ((x & 1LL) == 0) x >>= 1, k++;
x >>= 1, k++;
a[i].first.push_back((char)k);
while (x > 0) {
k = 0;
long long b = x & 1LL;
while ((x & 1LL) == b) x >>= 1, k++;
a[i].first.push_back((char)k);
}
}
}
sort((a).begin(), (a).end());
long long bestx, besty, bestm = -1;
vector<pair<long long, long long>> m(32, make_pair(-1, -1));
m[a[0].first.size()] = make_pair(a[0].first.size(), a[0].second);
for (long long i = 1; i <= (n - 1); i++) {
long long cp = 0;
for (; cp < max(a[i].first.size(), a[i - 1].first.size()); cp++) {
if (a[i].first[cp] != a[i - 1].first[cp]) break;
}
for (long long j = 0; j < (a[i - 1].first.size() + 1); j++) {
long long tm = -1;
if (m[j].first >= 0) {
tm = a[i].first.size() + m[j].first - 2 * min(j, cp);
if (tm > bestm) bestm = tm, bestx = m[j].second, besty = a[i].second;
}
}
pair<long long, long long> mcp = make_pair(-1, -1);
for (long long j = cp; j <= a[i - 1].first.size(); j++) {
if (m[j].first > mcp.first) mcp = m[j];
}
m[cp] = mcp;
m[a[i].first.size()] = make_pair(a[i].first.size(), a[i].second);
}
cout << bestx + 1 << " " << besty + 1 << " " << bestm << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
ifstream ifs;
if (""[0]) cin.rdbuf((ifs = ifstream("")).rdbuf());
;
ofstream ofs;
if (""[0]) cout.rdbuf((ofs = ofstream("")).rdbuf());
;
ofstream lfs;
if (""[0]) clog.rdbuf((lfs = ofstream("")).rdbuf());
;
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int i, j;
if (a.size() != b.size()) {
cout << "NO" << endl;
return 0;
}
for (i = 0, j = (int)b.size() - 1; i < (int)a.size(); i++, j--) {
if (a[i] != b[j]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int n, a[MAX], f[MAX], d[MAX];
long long result;
void update(int x, int val) {
int u = x;
while (u <= n) {
f[u] = max(f[u], val);
u += (u & -u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
result = 0;
int u;
memset(d, 0, sizeof(d));
memset(f, 0, sizeof(f));
d[1] = 1;
update(a[1], 1);
int result;
for (int i = 2; i <= n; i++) {
u = a[i] - 1;
result = 0;
while (u > 0) {
result = max(result, f[u]);
u -= (u & -u);
}
d[i] = result + 1;
update(a[i], d[i]);
}
result = 0;
for (int i = 1; i <= n; i++) result = max(result, d[i]);
cout << result << endl;
}
| 3 |
#include <bits/stdc++.h>
int n;
int t;
int color[10000];
bool isprime[50000000];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) color[i] = 0;
t = n * (n + 1) / 2;
for (int i = 0; i <= t; i++) isprime[i] = true;
for (int i = 2; i * i <= t; i++) {
if (!isprime[i]) continue;
for (int j = i * i; j <= t; j += i) {
isprime[j] = false;
}
}
if (isprime[t]) {
for (int i = 1; i <= n; i++) color[i] = 1;
} else {
int u = -1;
for (int i = 2; i < t - 1; i++)
if (isprime[i] && isprime[t - i]) u = i;
if (u == -1) {
color[3] = 3;
t -= 3;
u = -1;
for (int i = 2; i < t - 1; i++)
if (isprime[i] && isprime[t - i]) u = i;
}
if (true) {
for (int i = n; i >= 1; i--) {
if (color[i] == 0 && i <= u) {
color[i] = 1;
u -= i;
}
}
for (int i = 1; i <= n; i++)
if (color[i] == 0) color[i] = 2;
}
}
for (int i = 1; i <= n; i++) printf("%d ", color[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = std::vector<int>;
using vll = std::vector<long long>;
using vull = std::vector<unsigned long long>;
void setIO(std::ifstream &readFile, std::ofstream &writeFile,
const std::string &name = "", bool stdIO = false) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
if (!name.empty() && !stdIO) {
readFile.open(name + ".in");
if (readFile.fail()) return;
writeFile.open(name + ".out");
std::cin.rdbuf(readFile.rdbuf());
std::cout.rdbuf(writeFile.rdbuf());
}
}
class Timer {
std::chrono::time_point<std::chrono::high_resolution_clock> m_beg;
public:
Timer() : m_beg(std::chrono::high_resolution_clock::now()) {}
void reset() { m_beg = std::chrono::high_resolution_clock::now(); }
[[nodiscard]] long double elapsed() const {
return std::chrono::duration_cast<
std::chrono::duration<long double, std::ratio<1>>>(
std::chrono::high_resolution_clock::now() - m_beg)
.count();
}
};
using dt = int;
constexpr dt MAXN = 1e9 + 1;
constexpr dt MOD = 1e9 + 7;
constexpr long double EPS = 1e-9;
vector<vector<int>> neighbors;
vector<pair<int, int>> order;
int value = -1;
void dfs(int i, int parent) {
order[i].first = ++value;
for (auto &neighbor : neighbors[i])
if (neighbor != parent) dfs(neighbor, i);
order[i].second = value;
}
struct Node {
int value = 0;
bool delta = false;
};
vector<Node> tree;
vector<int> ts;
void propogate(int i, int l, int r) {
if (tree[i].delta) {
tree[i].value = (r - l + 1) - tree[i].value;
if (l != r) tree[2 * i].delta ^= 1, tree[2 * i + 1].delta ^= 1;
tree[i].delta = false;
}
}
void update(int i) {
tree[i].value = tree[2 * i].value + tree[2 * i + 1].value;
}
void change(int i, int l, int r, int tl, int tr) {
propogate(i, tl, tr);
if (l > tr || tl > r) return;
if (l <= tl && tr <= r) {
tree[i].delta ^= 1;
propogate(i, tl, tr);
return;
}
int mid = tl + (tr - tl) / 2;
change(2 * i, l, r, tl, mid);
change(2 * i + 1, l, r, mid + 1, tr);
update(i);
}
int rsq(int i, int l, int r, int tl, int tr) {
propogate(i, tl, tr);
if (l > tr || tl > r) return 0;
if (l <= tl && tr <= r) return tree[i].value;
int mid = tl + (tr - tl) / 2;
return rsq(2 * i, l, r, tl, mid) + rsq(2 * i + 1, l, r, mid + 1, tr);
}
int main(int argc, char *argv[]) {
static std::ifstream readFile;
static std::ofstream writeFile;
setIO(readFile, writeFile, "");
int n;
cin >> n;
neighbors.resize(n);
for (int i = 1; i < n; ++i) {
int p;
cin >> p;
--p;
neighbors[i].push_back(p);
neighbors[p].push_back(i);
}
order.resize(n);
dfs(0, 0);
tree.resize(4 * n);
for (int i = 0; i < n; ++i) {
int t;
cin >> t;
if (t) change(1, order[i].first, order[i].first, 0, n - 1);
}
int q;
cin >> q;
while (q--) {
string s;
int v;
cin >> s >> v;
--v;
if (s == "pow")
change(1, order[v].first, order[v].second, 0, n - 1);
else
cout << rsq(1, order[v].first, order[v].second, 0, n - 1) << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
int left_wall[100010];
int right_wall[100010];
int left_wall_steps[100010];
int right_wall_steps[100010];
int left_que[100010];
int right_que[100010];
int head_left;
int head_right;
int tail_left;
int tail_right;
int ninja_jump;
int wall_height;
bool ExitExist;
int last_step;
void push_left(int x) {
left_que[head_left] = x;
head_left++;
}
void push_right(int x) {
right_que[head_right] = x;
head_right++;
}
int pop_left() {
if (head_left == tail_left) return -1;
int res = left_que[tail_left];
tail_left++;
return res;
}
int pop_right() {
if (head_right == tail_right) return -1;
int res = right_que[tail_right];
tail_right++;
return res;
}
int main() {
char temp_char;
std::cin >> wall_height >> ninja_jump;
for (int i = 1; i <= wall_height; i++) {
std::cin >> temp_char;
if (temp_char == 'X')
left_wall[i] = 1;
else if (temp_char == '-')
left_wall[i] = 0;
}
for (int i = 1; i <= wall_height; i++) {
std::cin >> temp_char;
if (temp_char == 'X')
right_wall[i] = 1;
else if (temp_char == '-')
right_wall[i] = 0;
}
push_left(1);
left_wall_steps[1] = 1;
last_step = 1;
int curr_left = 0;
int curr_right = 0;
while (last_step < wall_height && head_left != tail_left ||
head_right != tail_right) {
curr_left = pop_left();
curr_right = pop_right();
if (last_step + ninja_jump > wall_height) {
last_step = wall_height;
continue;
}
if (curr_left != -1) {
if (left_wall[curr_left + 1] == 0 &&
left_wall_steps[curr_left + 1] == 0) {
push_left(curr_left + 1);
left_wall_steps[curr_left + 1] = left_wall_steps[curr_left] + 1;
if (last_step < curr_left + 1) last_step = curr_left + 1;
}
if (right_wall[curr_left + ninja_jump] == 0 &&
right_wall_steps[curr_left + ninja_jump] == 0) {
push_right(curr_left + ninja_jump);
right_wall_steps[curr_left + ninja_jump] =
left_wall_steps[curr_left] + 1;
if (last_step < curr_left + ninja_jump)
last_step = curr_left + ninja_jump;
}
if (left_wall[curr_left - 1] == 0 &&
left_wall_steps[curr_left - 1] == 0 &&
(curr_left - 1) >= left_wall_steps[curr_left] + 1) {
push_left(curr_left - 1);
left_wall_steps[curr_left - 1] = left_wall_steps[curr_left] + 1;
}
}
if (curr_right != -1) {
if (right_wall[curr_right + 1] == 0 &&
right_wall_steps[curr_right + 1] == 0) {
push_right(curr_right + 1);
right_wall_steps[curr_right + 1] = right_wall_steps[curr_right] + 1;
if (last_step < curr_right + 1) last_step = curr_right + 1;
}
if (left_wall[curr_right + ninja_jump] == 0 &&
left_wall_steps[curr_right + ninja_jump] == 0) {
push_left(curr_right + ninja_jump);
left_wall_steps[curr_right + ninja_jump] =
right_wall_steps[curr_right] + 1;
if (last_step < curr_right + ninja_jump)
last_step = curr_right + ninja_jump;
}
if (right_wall[curr_right - 1] == 0 &&
right_wall_steps[curr_right - 1] == 0 &&
(curr_right - 1) >= right_wall_steps[curr_right] + 1) {
push_right(curr_right - 1);
right_wall_steps[curr_right - 1] = right_wall_steps[curr_right] + 1;
}
}
}
if (last_step >= wall_height) {
std::cout << "YES\n";
} else {
std::cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int INF = 2147483647;
const long long LINF = 9223372036854775807;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int n, p[1000005], ans = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
p[0] = 0;
for (int i = 1; i <= n; i++) p[i] = p[i - 1] ^ i;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
ans ^= x;
if (n / i % 2) ans ^= p[i - 1];
ans ^= p[n % i];
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, seq = 0, x, y, j = 0, z = 0;
vector<pair<int, int> > res;
cin >> n >> m;
int a[n + 1];
memset(a, 0, sizeof a);
for (int i = 0; i < m; i++) {
cin >> x;
for (j = x; j > 0; j--) {
cin >> y;
a[y] = ++seq;
}
}
for (z = 1; z <= n; z++) {
if (a[z] == 0) break;
}
for (int i = 1; i <= seq; i++) {
if (a[i] != i) {
for (j = i + 1; j <= n; j++) {
if (a[j] == i) break;
}
if (i != z) res.push_back(make_pair(i, z));
res.push_back(make_pair(j, i));
a[z] = a[i];
a[i] = i;
z = j;
}
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
const int NANA = -427394241, maxN = 1e5 + 5, maxK = 305;
int N, K;
struct Event {
int x, y, tp;
Event() {}
Event(int x, int y, int tp) : x(x), y(y), tp(tp) {}
void print() { fprintf(stderr, "x = %d y = %d tp = %d", x, y, tp); }
} ev[maxN << 1];
int Hash[maxN * maxK], totHash = 0;
void init() {
cin >> N >> K;
for (int i = (1), _end = (N); i <= _end; ++i) {
int x, y;
cin >> x >> y;
ev[i * 2 - 1] = Event(x, y, +1);
ev[i * 2] = Event(x + K, y, -1);
for (int k = (0), _end = (K - 1); k <= _end; ++k) Hash[++totHash] = y + k;
}
sort(Hash + 1, Hash + totHash + 1);
totHash = unique(Hash + 1, Hash + totHash + 1) - Hash - 1;
N <<= 1;
for (int i = (1), _end = (N); i <= _end; ++i) {
ev[i].y = lower_bound(Hash + 1, Hash + totHash + 1, ev[i].y) - Hash;
}
}
int *last, cnt[maxN * maxK];
long long ans[maxN];
bool cmp(const Event &x, const Event &y) {
return x.x < y.x || (x.x == y.x && x.y < y.y);
}
void solve() {
sort(ev + 1, ev + N + 1, cmp);
last = Hash;
for (int i = (0), _end = (totHash); i <= _end; ++i) last[i] = NANA;
for (int i = (1), _end = (N); i <= _end; ++i) {
int x = ev[i].x, y = ev[i].y, tp = ev[i].tp;
for (int k = (0), _end = (K - 1); k <= _end; ++k) {
if (last[y + k] != NANA) {
ans[cnt[y + k]] += x - last[y + k];
}
cnt[y + k] += tp;
last[y + k] = x;
}
}
for (int i = (1), _end = (N >> 1); i <= _end; ++i) cout << ans[i] << ' ';
}
int main() {
ios::sync_with_stdio(false);
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 300000 + 5;
const int Root = 1;
int Ans[Maxn];
int qry[Maxn];
struct Edge {
int v, nxt;
Edge() {}
Edge(int v0, int n0) {
v = v0;
nxt = n0;
}
};
Edge e[Maxn];
int head[Maxn];
int nume;
int fa[Maxn], dep[Maxn], siz[Maxn], son[Maxn];
int n, m;
void treeDP(int x) {
dep[x] = dep[fa[x]] + 1;
siz[x] = 1;
for (int i = head[x]; i; i = e[i].nxt) {
treeDP(e[i].v);
siz[x] += siz[e[i].v];
if (siz[e[i].v] > siz[son[x]]) son[x] = e[i].v;
}
if (siz[son[x]] <= siz[x] / 2) {
Ans[x] = x;
return;
}
for (int i = head[x]; i; i = e[i].nxt) {
int v = Ans[e[i].v];
int len = 0;
while (v != x) {
len = max(siz[x] - siz[v], siz[son[v]]);
if (len <= siz[x] / 2) {
Ans[x] = v;
return;
}
v = fa[v];
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++) {
int tmp;
scanf("%d", &tmp);
e[++nume] = Edge(i, head[tmp]);
head[tmp] = nume;
fa[i] = tmp;
}
for (int i = 1; i <= m; i++) scanf("%d", &qry[i]);
treeDP(Root);
for (int i = 1; i <= m; i++) {
printf("%d\n", Ans[qry[i]]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
void __print(long long first) { cerr << first; }
void __print(long first) { cerr << first; }
void __print(unsigned first) { cerr << first; }
void __print(unsigned long first) { cerr << first; }
void __print(unsigned long long first) { cerr << first; }
void __print(float first) { cerr << first; }
void __print(double first) { cerr << first; }
void __print(long double first) { cerr << first; }
void __print(char first) { cerr << '\'' << first << '\''; }
void __print(const char *first) { cerr << '\"' << first << '\"'; }
void __print(const string &first) { cerr << '\"' << first << '\"'; }
void __print(bool first) { cerr << (first ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &first) {
cerr << '{';
__print(first.first);
cerr << ',';
__print(first.second);
cerr << '}';
}
template <typename T>
void __print(const T &first) {
long long f = 0;
cerr << '{';
for (auto &i : first) 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...);
}
std::mt19937 rng(
(long long)std::chrono::steady_clock::now().time_since_epoch().count());
const long long N = 1 << 20;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
long long n, m, k, p;
cin >> n >> m >> k >> p;
priority_queue<long long> r, c;
vector<long long> rs(n), cs(m);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long first;
cin >> first;
rs[i] += first;
cs[j] += first;
}
}
for (long long i = 0; i < n; i++) r.push(rs[i]);
for (long long j = 0; j < m; j++) c.push(cs[j]);
vector<long long> dpr(k + 1), dpc(k + 1);
for (long long i = 1; i <= k; i++) {
dpr[i] += dpr[i - 1];
dpc[i] += dpc[i - 1];
long long t = r.top();
r.pop();
dpr[i] += t;
t -= m * p;
r.push(t);
long long d = c.top();
c.pop();
dpc[i] += d;
d -= p * n;
c.push(d);
}
long long ans = -9e16;
for (long long i = 0; i <= k; i++) {
ans = max(ans, dpr[i] + dpc[k - i] - ((i) * (k - i) * p));
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
string w;
int n, a, b, k;
int my_pow(int n, int k) {
if (k == 0) return 1;
int g = my_pow(n, k / 2);
g = 1ll * g * g % mod;
if (k & 1) g = 1ll * g * n % mod;
return g;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> a >> b >> k;
cin >> w;
int ra = my_pow(a, mod - 2);
ra = my_pow(ra, k);
long long ans = 0;
for (int i = 0; i < k; i++) {
long long s = 1ll * my_pow(a, n - i) * my_pow(b, i) % mod;
long long c = 1ll * ra * my_pow(b, k) % mod;
int t = (n - i) / k + 1;
if (c != 1)
s = 1ll * s * (my_pow(c, t) - 1) % mod * my_pow(c - 1, mod - 2) % mod;
else
s = 1ll * s * t % mod;
if (w[i] != '+') s = mod - s;
ans += s;
if (ans >= mod) ans -= mod;
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
int main() {
int(n);
scanf("%d", &n);
long long me, nouse;
scanf("%I64d%I64d", &me, &nouse);
priority_queue<long long> hh, use;
vector<pair<long long, long long> > pp;
for (int i = (1); i < (n); ++i) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
if (x > me)
hh.push(-(y - x + 1));
else
pp.push_back(make_pair(x, y));
}
int an = ((int)(hh).size()) + 1;
sort((pp).begin(), (pp).end());
reverse((pp).begin(), (pp).end());
int m = ((int)(pp).size());
pp.push_back(make_pair(0, -1));
{
while (!hh.empty() && me - pp[0].first >= -hh.top()) {
me -= -hh.top();
use.push(-hh.top());
hh.pop();
}
an = min(an, ((int)(hh).size()) + 1);
}
for (int i = 0, j; i < m; i = j) {
for (j = i; j < m && pp[j].first == pp[i].first; j++) {
long long v = (pp[j].second - pp[j].first + 1);
if (!use.empty() && v < use.top()) {
me += use.top() - v;
long long gg = use.top();
use.pop();
use.push(v);
hh.push(-gg);
} else
hh.push(-v);
}
while (!hh.empty() && me - pp[j].first >= -hh.top()) {
me -= -hh.top();
use.push(-hh.top());
hh.pop();
}
an = min(an, ((int)(hh).size()) + 1);
}
cout << an;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using D = float;
int n;
int parents[(int)1e5];
D p_fail[(int)1e5];
D contrib[(int)1e5];
vector<int> g[(int)1e5];
array<D, 2> dfs(int root, int parent) {
parents[root] = parent;
D expect_sum = 0;
D expect_num = 0;
for (auto child : g[root]) {
if (child == parent) continue;
auto expect = dfs(child, root);
expect_sum += p_fail[child] * expect[0] + (1 - p_fail[child]) * expect[1];
expect_num += 1 - p_fail[child];
}
contrib[root] = 1 - expect_num;
return {expect_sum, expect_sum + contrib[root]};
}
D result;
D query(int node, D np_fail) {
result -= (1 - p_fail[node]) * contrib[node];
result += (1 - np_fail) * contrib[node];
if (node != 0) {
result -= (1 - p_fail[parents[node]]) * contrib[parents[node]];
contrib[parents[node]] += (1 - p_fail[node]);
contrib[parents[node]] -= (1 - np_fail);
result += (1 - p_fail[parents[node]]) * contrib[parents[node]];
}
p_fail[node] = np_fail;
return result;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < (n); i++) cin >> p_fail[i];
for (int i = 0; i < (n - 1); i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
auto expect = dfs(0, -1);
result = p_fail[0] * expect[0] + (1 - p_fail[0]) * expect[1];
int q;
cin >> q;
cout << fixed << setprecision(15);
for (int i = 0; i < (q); i++) {
int node;
D np_fail;
cin >> node >> np_fail;
cout << query(node, np_fail) << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int check = 0;
sort(s.begin(), s.end());
for (int i = 0; i < (s.size() - 1); i++) {
if (s[i] - '0' + 1 != s[i + 1] - '0') {
check = 1;
break;
}
}
if (check)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
set<long long> lu;
long long num;
long long n_pos;
long long sum;
int main() {
cin >> l >> r;
lu.insert(4);
for (long long i = 1; i <= 10; i++)
for (long long j = 0; j < (1 << i); j++) {
for (long long k = 0; k < i; k++) {
if (j & 1 << k) {
num *= 10;
num += 7;
} else {
num *= 10, num += 4;
}
}
lu.insert(num);
num = 0;
}
n_pos = l;
int o_pos;
while (n_pos <= r) {
o_pos = n_pos;
n_pos = *lu.lower_bound(n_pos) + 1;
sum += (min(n_pos, r + 1) - o_pos) * (n_pos - 1);
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int main() {
scanf("%s", s);
int len = strlen(s) - 1;
long long b = 0, ans = 0;
for (int i = len; i >= 0; i--) {
if (s[i] == 'a') {
ans = (ans + b) % 1000000007;
b = b * 2 % 1000000007;
} else {
b++;
b %= 1000000007;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[10000000];
bool test(long long int x, int w, int l) {
int index1 = 0;
int index2 = 0;
long long int arr2[2 * w];
long long int arr1[w - 1];
for (int i = 0; i < w; i++) arr2[i] = 0;
for (int i = 0; i < w; i++) arr1[i] = arr[i];
arr2[0] = x;
while (index1 < w && index2 < w) {
while (arr1[index1] > 0 && index2 < w && index1 < w) {
long long int sapos = min(arr2[index2], arr1[index1]);
arr2[index2] -= sapos;
arr2[index1 + 1] += sapos;
arr1[index1] -= sapos;
if (index1 - index2 >= l) return false;
while (arr2[index2] == 0) {
index2++;
}
}
index1++;
}
for (int i = 0; i < w; i++) {
if (arr2[i] != 0) return false;
}
return true;
}
int main() {
int w, l;
cin >> w >> l;
for (int i = 0; i < w - 1; i++) cin >> arr[i];
arr[w - 1] = 1000000000000;
long long int lo, hi;
lo = 0;
hi = 100000000000000;
while (hi - lo > 1) {
long long int mid = (lo + hi) / 2;
bool b = test(mid, w, l);
if (b)
lo = mid;
else
hi = mid;
}
cout << lo << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
int n, k, t;
int main() {
scanf("%d", &t);
long long x1, x2, y1, y2;
long long ans = 0;
while (t--) {
scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2);
ans = 1 + (y2 - y1) * (x2 - x1);
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct abc {
int rc, x;
} st[100000];
int k = 0, ans = 0;
int main() {
ios_base::sync_with_stdio(false);
int n, m, C = 0;
cin >> n >> m;
int a[n][m];
if (n < m) {
int i, j, A, B;
for (i = 0; i < n; i++) {
A = INT_MAX;
for (j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j]) {
C = 1;
}
if (a[i][j] < A) {
A = a[i][j];
}
if (i > 0) {
a[i - 1][j] -= B;
}
}
ans += A;
int kk = k + A;
for (; k < kk; k++) {
st[k].rc = 1;
st[k].x = i + 1;
}
B = A;
}
for (j = 0; j < m; j++) {
a[n - 1][j] -= B;
}
int ca, cb;
for (int c = 0; c < m; c++) {
ca = INT_MAX;
for (int r = 0; r < n; r++) {
if (a[r][c] < ca) {
ca = a[r][c];
}
if (c > 0) {
a[r][c - 1] -= cb;
}
}
ans += ca;
int kk = k + ca;
for (; k < kk; k++) {
st[k].rc = 2;
st[k].x = c + 1;
}
cb = ca;
}
for (int r = 0; r < n; r++) {
a[r][m - 1] -= cb;
}
} else {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j]) C = 1;
}
}
int ca, cb;
for (int c = 0; c < m; c++) {
ca = INT_MAX;
for (int r = 0; r < n; r++) {
if (a[r][c] < ca) {
ca = a[r][c];
}
if (c > 0) {
a[r][c - 1] -= cb;
}
}
ans += ca;
int kk = k + ca;
for (; k < kk; k++) {
st[k].rc = 2;
st[k].x = c + 1;
}
cb = ca;
}
for (int r = 0; r < n; r++) {
a[r][m - 1] -= cb;
}
int ra, rb;
for (int r = 0; r < n; r++) {
ra = INT_MAX;
for (int c = 0; c < m; c++) {
if (a[r][c] < ra) {
ra = a[r][c];
}
if (r > 0) {
a[r - 1][c] -= rb;
}
}
ans += ra;
int kk = k + ra;
for (; k < kk; k++) {
st[k].rc = 1;
st[k].x = r + 1;
}
rb = ra;
}
for (int c = 0; c < m; c++) {
a[n - 1][c] -= rb;
}
}
int flag = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] != 0) {
flag = 1;
break;
}
}
if (flag) break;
}
if (C) {
if (flag == 1) {
cout << -1 << endl;
} else {
cout << ans << endl;
for (int i = 0; i < k; i++) {
if (st[i].rc == 1)
cout << "row ";
else
cout << "col ";
cout << st[i].x << endl;
}
}
} else {
cout << 0 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string S;
unsigned long long x = 1000000007;
int main() {
cin >> S;
unsigned long long tot = 0;
unsigned long long temp = 0;
for (int i = S.length() - 1; i >= 0; i--) {
if (S[i] == 'b') {
temp++;
} else {
tot += temp;
temp *= 2;
tot = tot % x;
temp = temp % x;
}
}
cout << tot % x << endl;
}
| 3 |
#include <bits/stdc++.h>
typedef long long ll;
#define endl '\n'
using namespace std;
//#define __int128_t ll
const int N=400010;
int a[N],b[N];
int inv[N];
//struct node{
// int mn,mx,cmp;
// node(){
// mn=1;
// mx=0;
// cmp=-1;
// }
//};
//node Merge(node A,node B){
// if (A.cmp==-1) return B;
// if (B.cmp==-1) return A;
// A.mn=min(A.mn,B.mn);
//}
//int t[N];
//void upd(int n,int pos,int x){
// for (;pos<=n;pos|=pos+1){
// t[pos]=max(t[pos],x);
// }
//}
//int get(int pos){
// int mx=0;
// for (;pos>=0;pos&=pos+1,pos--){
// mx=max(mx,t[pos]);
// }
// return mx;
//}
//int dp[N];
int type[N];
void solve(){
int n;cin>>n;
for (int i=1;i<=n;i++) cin>>a[i]>>b[i];
int Mn=n+n+1;
int Mx=0;
for (int i=1;i<=n;i++){
Mx=max(Mx,min(a[i],b[i]));
Mn=min(Mn,max(a[i],b[i]));
}
if (Mx>Mn){
cout<<-1<<endl;
return;
}
vector<pair<pair<int,int>,int> >v;
for (int i=1;i<=n;i++){
if (a[i]>b[i]){
swap(a[i],b[i]);
inv[i]=1;
}
v.push_back({{a[i],b[i]},inv[i]});
}
sort(v.begin(),v.end());
for (int i=0;i<n;i++){
a[i+1]=v[i].first.first;
b[i+1]=v[i].first.second;
inv[i+1]=v[i].second;
}
// dp[0]=0;
// upd(2*n,0,0);
// for (int i=1;i<=n;i++){
// dp[i]=get(b[i])+1;
// upd(n+n,b[i],dp[i]);
// if (dp[i]>2){
// cout<<-1<<endl;
// return;
// }
// }
int mn=n+n+1;
for (int i=1;i<=n;i++){
mn=min(mn,b[i]);
// cout<<b[i]<<" "<<inv[i]<<endl;
if (mn==b[i]){
type[i]^=1;
}
}
int mx=0;
for (int i=n;i>=1;i--){
mx=max(mx,b[i]);
if (mx==b[i]){
type[i]^=2;
}
}
for (int i=1;i<=n;i++){
if (type[i]==0){
cout<<-1<<endl;
return;
}
}
vector<pair<int,int> >u;
vector<pair<pair<int,int>,int> >V;
for (int i=n;i>=1;i--){
if (type[i]==2){
u.push_back({b[i],i});
V.push_back({{u.size(),u.size()},inv[i]});
}
if (type[i]==1){
pair<int,int>fnd={b[i],100000001};
int L=upper_bound(u.begin(),u.end(),fnd)-u.begin()+1;
if (L<=u.size()){
// cout<<"SEG "<<L<<" "<<u.size()<<endl;
V.push_back({{L,u.size()},(inv[i]^1)});
}
}
}
sort(V.begin(),V.end());
int res=0;
if (!V.empty()){
int R=V[0].first.second;
int cnt=1;
int sum=V[0].second;
for (int i=1;i<V.size();i++){
if (V[i].first.first<=R) {
sum+=V[i].second;
R=max(R,V[i].first.second);
cnt++;
} else {
res+=min(sum,cnt-sum);
cnt=1;
sum=V[i].second;
R=V[i].first.second;
}
}
res+=min(sum,cnt-sum);
}
cout<<res<<endl;
return;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt=1;
while (tt--){
solve();
}
return 0;
}
/**
1
5 5 100
4
5
4
3
1
OK
FAIL
OK
OK
OK
FAIL
OK
0 1 0 0 0
1
5 5 100
4
5
4
2
1
FAIL
FAIL
FAIL
OK
FAIL
OK
OK
FAIL
FAIL
FAIL
OK
! 10
**/
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, ans;
cin >> n >> k;
if (n % 2 == 0) {
ans = n / 2;
} else {
ans = (n / 2) + 1;
}
if (k <= ans) {
cout << (2 * k - 1) << endl;
} else {
cout << (k - ans) * 2;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int gl, gr;
cin >> gl >> gr;
int bl, br;
cin >> bl >> br;
if (bl == gr - 1 || bl == gr || (bl >= gr - 1 && bl <= 2 * gr + 2))
cout << "YES" << endl;
else if (br == gl - 1 || br == gl || (br >= gl - 1 && br <= 2 * gl + 2))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
long long a, b, n, m;
int g[410][410];
long long buf;
int rs[100000];
deque<int> us;
int bfs(int pos, int acc) {
rs[1] = 0;
us.push_back(1);
while (!us.empty()) {
pos = us.front();
us.pop_front();
for (int i = 1; i <= n; i++) {
if (g[pos][i] == acc && pos != i && (rs[pos] + 1 < rs[i])) {
rs[i] = rs[pos] + 1;
us.push_back(i);
}
}
}
return rs[n] == inf ? -1 : rs[n];
}
int main() {
bool f;
cin >> n >> m;
for (int i = 0; i <= n; i++) rs[i] = inf;
for (int i = 0; i < m; i++) {
cin >> a >> b;
g[a][b] = 1;
g[b][a] = 1;
}
if (g[1][n])
f = true;
else
f = false;
if (f) {
cout << bfs(1, 0);
} else {
cout << bfs(1, 1);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, m, n, j;
string name, ip, com;
map<string, string> h;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> name >> ip;
h[ip] = name;
}
for (i = 0; i < m; i++) {
cin >> com >> ip;
ip.pop_back();
cout << com << " " << ip << "; #" << h[ip] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e18;
int n, m, S, T;
long long L;
struct Edge {
int fr, to;
int id;
int next;
} e[10010 * 2];
int wall[10010];
long long len[10010];
int head[1010];
int ne;
void add(int a, int b, int id) {
int t = ne++;
e[t].fr = a;
e[t].to = b;
e[t].id = id;
e[t].next = head[a];
head[a] = t;
}
queue<int> q;
bool inq[1010];
long long minL[1010];
int from[1010];
void spfa() {
for (int i = 0; i < n; i++) {
inq[i] = 0;
minL[i] = MAX;
from[i] = -1;
}
while (!q.empty()) q.pop();
q.push(S);
inq[S] = 1;
minL[S] = 0;
from[S] = -1;
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = head[u]; i != -1; i = e[i].next) {
int t = e[i].to;
if (minL[u] + len[e[i].id] < minL[t]) {
minL[t] = minL[u] + len[e[i].id];
from[t] = u;
if (inq[t] == 0) {
q.push(t);
inq[t] = 1;
}
}
}
}
}
int solve() {
for (int i = 0; i < m; i++) {
if (wall[i] == 1) {
len[i] = MAX;
}
}
spfa();
if (minL[T] < L) return 0;
for (int i = 0; i < m; i++) {
if (wall[i] == 1) {
len[i] = 1;
}
}
spfa();
if (minL[T] > L) return 0;
minL[T] = 0;
while (minL[T] != L) {
spfa();
int u = T;
while (from[u] != -1) {
int f = from[u];
bool br = 0;
for (int i = head[f]; i != -1; i = e[i].next) {
if (e[i].to == u) {
int id = e[i].id;
if (wall[id] == 1) {
len[id] += L - minL[T];
br = 1;
break;
}
}
}
if (br == 1) break;
u = f;
}
}
return 1;
}
int main() {
cin >> n >> m >> L >> S >> T;
memset(head, -1, sizeof head);
ne = 0;
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
wall[i] = (w == 0) ? 1 : 0;
len[i] = w;
add(u, v, i);
add(v, u, i);
}
int res = solve();
if (res == 0)
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < ne; i += 2) {
long long l = len[e[i].id];
cout << e[i].fr << " " << e[i].to << " " << l << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N;
int c[1000005];
long long dp[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 0; i < (N); i++) {
cin >> c[i + 1];
}
long long maxPlus = c[1];
long long maxMin = -1 * c[1];
for (int i = (1); i < (N + 1); i++) {
maxPlus = max(maxPlus, dp[i - 1] + c[i]);
maxMin = max(maxMin, dp[i - 1] - c[i]);
dp[i] = max(maxPlus - c[i], maxMin + c[i]);
}
cout << dp[N] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge>> adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
Graph() { adj.clear(); }
void resize(int n) { adj.resize(n + 5); }
void add(int s, edge e) { adj[s].push_back(e); }
void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
int deg(int v) { return adj[v].size(); }
vector<edge> &operator[](int t) { return adj[t]; }
};
const int maxn = 2200, maxm = 2200, maxt = 2200;
vector<vector<vector<int>>> nc;
vector<vector<int>> nb, lnk;
int n, m;
string S[maxn], T;
int blks[maxm];
pair<int, int> f[maxt][maxt];
void init_str(string &S, vector<vector<int>> &vec) {
int len = (int)((S).size());
vec.resize(len + 1);
vec[len].resize(26);
fill((vec[len]).begin(), (vec[len]).end(), 0x3F3F3F3F);
for (int j = len - 1; j >= 0; --j) {
vec[j] = vec[j + 1];
vec[j][S[j] - 'a'] = j;
}
}
void init() {
nc.resize(n);
for (int i = 0; i < n; ++i) init_str(S[i], nc[i]);
init_str(T, lnk);
nb.resize(m + 1);
nb[m].resize(26);
fill((nb[m]).begin(), (nb[m]).end(), 0x3F3F3F3F);
for (int i = m - 1; i >= 0; --i) {
nb[i] = nb[i + 1];
for (int j = 0; j < 26; ++j)
if (nc[blks[i]][0][j] != 0x3F3F3F3F) nb[i][j] = i;
}
}
pair<int, int> find_next_char(pair<int, int> now, int c) {
if (nc[blks[now.first]][now.second + 1][c] == 0x3F3F3F3F)
now.first = nb[now.first + 1][c], now.second = -1;
if (now.first == 0x3F3F3F3F) return make_pair(0x3F3F3F3F, 0);
return make_pair(now.first, nc[blks[now.first]][now.second + 1][c]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> S[i];
cin >> m;
for (int i = 0; i < m; ++i) cin >> blks[i], --blks[i];
cin >> T;
init();
memset(f, 0x3F, sizeof(f));
f[0][0] = make_pair(0, -1);
int ans = 0;
for (int i = 0; i <= (int)((T).size()); ++i)
for (int j = 0; j <= i + 1; ++j)
if (f[i][j].first != 0x3F3F3F3F) {
for (int c = 0; c < 26; ++c)
if (lnk[i][c] != 0x3F3F3F3F)
chkmin(f[lnk[i][c] + 1][j + 1], find_next_char(f[i][j], c));
ans = max(ans, j);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 125, MAXK = 6, MOD = 1000 * 1000 * 1000 + 7;
int cnt[(MAXM + 1) / 2];
int gen(int pos, int k, int m, int x, bitset<MAXM> &bs) {
if (k == MAXK) return x;
int res = x;
for (int i = pos; i <= m - i; i++) {
if (!cnt[i] || bs[i]) continue;
bitset<MAXM> tobs =
bs | (bs << i) | (bs >> (m - i)) | (bs << (m - i)) | (bs >> i);
res = (res + gen(i + 1, k + 1, m, (long long)x * cnt[i] % MOD, tobs)) % MOD;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m, t;
cin >> n >> m >> t;
for (int i = 0; i < t; i++) {
int a;
cin >> a;
a %= m;
if (a > m - a) a = m - a;
cnt[a]++;
}
bitset<MAXM> bs;
bs[0] = 1;
cout << gen(0, 0, m, 1, bs) << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 5e6 + 10;
const int sz = 1 << 21;
pair<pair<int, int>, int> a[maxi];
map<int, int> mp;
int tree[maxi];
int b[maxi];
int n, x;
void update(int x, int val) {
int idx = x + sz - 1;
tree[idx] = max(tree[idx], val);
idx /= 2;
while (idx) {
tree[idx] = max(tree[2 * idx], tree[2 * idx + 1]);
idx >>= 1;
}
}
int get(int node, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return 0;
if (tl >= l && tr <= r) return tree[node];
int mid = (tl + tr) / 2;
int val1 = get(2 * node, tl, mid, l, r);
int val2 = get(2 * node + 1, mid + 1, tr, l, r);
return max(val1, val2);
}
int main() {
cin >> n;
int cur = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
b[++cur] = x;
a[i].first.first = x;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
b[++cur] = x;
a[i].first.second = x;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
b[++cur] = x;
a[i].second = x;
}
sort(b + 1, b + cur + 1);
int p = 0;
for (int i = 1; i <= cur; i++)
if (i == 1 || b[i] != b[i - 1]) mp[b[i]] = ++p;
for (int i = 1; i <= n; i++) {
a[i].first.first = mp[a[i].first.first];
a[i].first.second = mp[a[i].first.second];
a[i].second = mp[a[i].second];
}
int ans = 0;
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
int last = 1;
for (int i = 1; i <= n; i++) {
if (a[i].first.first != a[i - 1].first.first) {
for (int j = last; j < i; j++) update(a[j].first.second, a[j].second);
last = i;
}
int cnt = get(1, 1, sz, a[i].first.second + 1, sz);
if (cnt > a[i].second) ans++;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int A[100005];
long long ans;
int main() {
int a, b, n, c, x;
cin >> a >> b >> c;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
m[A[i]]++;
}
for (int i = 1; i <= n; i++) {
if (A[i] > b && A[i] < c) {
ans += m[A[i]];
m[A[i]] = 0;
}
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int res = 0, flag = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
res = res * 10 + ch - '0';
ch = getchar();
}
return res * flag;
}
int n, logn, f[1000001][21][2];
const int Mod = 1e9 + 7;
int main() {
n = read();
logn = log2(n);
f[1][logn][0] = 1;
f[1][logn - 1][1] = ((1 << (logn - 1)) * 3 <= n);
for (register int i = 2; i <= n; ++i)
for (register int j = 0; j <= logn; ++j) {
f[i][j][0] =
((((long long)f[i - 1][j][0] * (n / (1 << j) - i + 1)) % Mod +
((long long)f[i - 1][j + 1][0] *
(n / (1 << j) - n / (1 << (j + 1)))) %
Mod) %
Mod +
((long long)f[i - 1][j][1] * (n / (1 << j) - n / ((1 << j) * 3))) %
Mod) %
Mod;
f[i][j][1] =
(((long long)f[i - 1][j][1] * (n / ((1 << j) * 3) - i + 1)) % Mod +
((long long)f[i - 1][j + 1][1] *
(n / ((1 << j) * 3) - n / ((1 << (j + 1)) * 3))) %
Mod) %
Mod;
}
printf("%d\n", f[n][0][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::string NumberToString(T Number) {
std::ostringstream ss;
ss << Number;
return ss.str();
}
long long gcd(long long a, long long b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
vector<int> adj[205];
int cost[205];
bool visit[205];
string toLower(string str) {
string usr = "";
for (int i = 0; i < (int)str.size(); i++) {
if (isalpha(str[i])) {
usr += tolower(str[i]);
} else
usr += str[i];
}
return usr;
}
int BFS(int s) {
cost[s] = 1;
visit[s] = true;
queue<int> Q;
Q.push(s);
int mx = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i];
if (visit[v] == false) {
cost[v] = cost[u] + 1;
mx = max(cost[v], mx);
visit[v] = true;
Q.push(v);
}
}
}
return mx;
}
int main() {
int n;
scanf("%d", &n);
map<string, int> mp;
int k = 1;
for (int i = 0; i < n; i++) {
string u, r, v;
cin >> u >> r >> v;
if (mp[toLower(v)] == 0) {
mp[toLower(v)] = k++;
}
if (mp[toLower(u)] == 0) {
mp[toLower(u)] = k++;
}
adj[mp[toLower(v)]].push_back(mp[toLower(u)]);
}
memset(visit, false, sizeof(visit));
memset(cost, 0, sizeof(cost));
printf("%d\n", BFS(mp["polycarp"]));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 501;
const long long inf = LLONG_MAX;
vector<int> g[N];
int lnk[N], pre[N];
bool vis[N];
long long a[N], b[N], w[N][N], sl[N];
long long match(int nl, int nr) {
nr = max(nl, nr);
fill_n(g + 1, nl, vector<int>());
fill_n(lnk + 1, nr, 0);
for (int i = 1; i <= nl; ++i) a[i] = *max_element(w[i] + 1, w[i] + nr + 1);
fill_n(b + 1, nr, 0);
for (int i = 1, j, u, vt; i <= nl; ++i) {
fill_n(vis + 1, nr, 0);
fill_n(sl, nr + 1, inf);
lnk[0] = i;
for (j = 0; u = lnk[j]; j = vt) {
long long d = inf;
vis[j] = 1;
for (int v = 1; v <= nr; ++v) {
long long t = a[u] + b[v] - w[u][v];
if (vis[v]) continue;
if (sl[v] > t) sl[v] = t, pre[v] = j;
if (sl[v] < d) d = sl[v], vt = v;
}
for (int v = 0; v <= nr; ++v) {
if (vis[v])
a[lnk[v]] -= d, b[v] += d;
else
sl[v] -= d;
}
}
for (; j; j = pre[j]) lnk[j] = lnk[pre[j]];
}
long long res = 0;
for (int i = 1; i <= nl; ++i) res += a[i] + b[i];
return res;
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
long long a, b, k;
scanf("%lld %lld %lld", &a, &b, &k);
for (int j = 1; j <= n; ++j)
w[i][j] = max(0ll, a - b * (min((long long)j, k + 1) - 1));
}
printf("%lld\n", match(n, n));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r, d[62][62][62], dp[1005][62][62];
int s[100005], t[100005], k[100005];
int main() {
scanf("%d%d%d", &n, &m, &r);
for (int k = 0; k < m; k++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &d[k][i][j]);
for (int t = 0; t < n; t++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
d[k][i][j] = min(d[k][i][j], d[k][i][t] + d[k][t][j]);
}
int Max = -1;
for (int i = 0; i < r; i++) {
scanf("%d%d%d", &s[i], &t[i], &k[i]);
s[i]--, t[i]--, k[i]++;
Max = max(Max, k[i]);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
dp[1][i][j] = 0x3f3f3f3f;
for (int k = 0; k < m; k++) dp[1][i][j] = min(dp[1][i][j], d[k][i][j]);
}
for (int k = 2; k <= Max; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
dp[k][i][j] = dp[k - 1][i][j];
for (int t = 0; t < n; t++)
dp[k][i][j] = min(dp[k][i][j], dp[k - 1][i][t] + dp[1][t][j]);
}
for (int i = 0; i < r; i++) printf("%d\n", dp[k[i]][s[i]][t[i]]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long cnt, mini = 1e9, maxi = -1;
long long n, m, k, x;
long long mini1 = 1e9, maxi1 = -1, cnt1, cnt2, cnt3, ans, sum;
int main() {
ios_base::sync_with_stdio(0);
string a, s;
cin >> a;
s = a;
for (int i = 0; i < a.size(); i++) {
if (a[i] == 'C' || a[i] == 'B' || a[i] == 'D' || a[i] == 'E' ||
a[i] == 'F' || a[i] == 'G' || a[i] == 'J' || a[i] == 'K' ||
a[i] == 'L' || a[i] == 'N' || a[i] == 'P' || a[i] == 'Q' ||
a[i] == 'R' || a[i] == 'S' || a[i] == 'Z') {
cout << "NO";
return 0;
}
}
reverse(s.begin(), s.end());
if (a == s) {
cout << "YES";
return 0;
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
int n, m, ans;
string a[MAXN];
bool t[MAXN], ok;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int p = 0; p < m; p++) {
ok = true;
for (int i = 1; i < n; i++)
if (!t[i] && a[i][p] > a[i + 1][p]) ok = false;
if (!ok) {
ans++;
continue;
}
for (int i = 1; i < n; i++)
if (a[i][p] != a[i + 1][p]) t[i] = true;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool isValid(string& x, string& y) {
int found = y.find(x);
if (found == string::npos) return false;
for (int i = 0; i < found; ++i) {
if (y[i] == '0') return false;
}
for (int i = found + x.length(); i < y.length(); ++i) {
if (y[i] == '0') return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
unsigned long long x, y;
cin >> x >> y;
bitset<64> b1(x);
bitset<64> b2(y);
string xString = b1.to_string();
string yString = b2.to_string();
int index = 0;
while (xString[index] == '0') {
index++;
}
xString = xString.substr(index);
index = 0;
while (yString[index] == '0') {
index++;
}
yString = yString.substr(index);
if (isValid(xString, yString)) {
int temp = yString.find(xString);
if (temp != 0 && xString.back() == '0' &&
temp + xString.length() == yString.length()) {
} else {
cout << "YES\n";
return 0;
}
}
index = -1;
for (int i = 0; i < xString.length(); ++i)
if (xString[i] == '1') index = i;
string xNoTrailing = xString.substr(0, index + 1);
if (isValid(xNoTrailing, yString)) {
cout << "YES\n";
return 0;
}
reverse(xNoTrailing.begin(), xNoTrailing.end());
if (isValid(xNoTrailing, yString)) {
cout << "YES\n";
return 0;
}
xString.push_back('1');
reverse(xString.begin(), xString.end());
if (isValid(xString, yString)) {
cout << "YES\n";
return 0;
}
cout << "NO\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
template <typename first>
inline first abs(const first& a) {
return a < 0 ? -a : a;
}
template <typename first>
inline first sqr(const first& a) {
return a * a;
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
const int INF = 1000 * 1000 * 1000;
long long c[51] = {0LL,
0LL,
3LL,
6LL,
12LL,
23LL,
54LL,
85LL,
150LL,
408LL,
562LL,
1541LL,
3002LL,
5307LL,
12208LL,
20743LL,
50381LL,
124977LL,
152029LL,
359498LL,
684180LL,
1081539LL,
3237552LL,
7178036LL,
14098937LL,
17724970LL,
59376847LL,
84071740LL,
203004953LL,
317544656LL,
604058870LL,
2046199308LL,
2204277251LL,
8527213096LL,
11816358072LL,
20491257044LL,
61947009164LL,
126411736298LL,
143599289310LL,
499373316031LL,
796020681876LL,
1871509509299LL,
3922069193205LL,
7529257751876LL,
17324782011524LL,
29238521227978LL,
53153974982529LL,
102063103466563LL,
196360980655640LL,
312947656150253LL,
966809786466498LL};
long long bit[60];
int main() {
for (int i = 0; i < int(60); i++) bit[i] = (1LL << i);
int n;
cin >> n;
for (int i = 0; i < int(n); i++) {
if (c[n] & bit[i])
putchar('1');
else
putchar('0');
putchar(' ');
}
puts("");
for (int i = 0; i < int(n); i++) printf("1 ");
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
long long n, k, d1, d2;
long long x1, x2, x3, av;
bool tag = false;
cin >> n >> k >> d1 >> d2;
if (n % 3) {
printf("no\n");
continue;
}
av = n / 3;
if ((2 * d1 + d2 + k) % 3 == 0 && (-d1 + d2 + k) % 3 == 0 &&
(-d1 - 2 * d2 + k) % 3 == 0) {
x1 = (2 * d1 + d2 + k) / 3;
x2 = (-d1 + d2 + k) / 3;
x3 = (-d1 - 2 * d2 + k) / 3;
if (x1 >= 0 && x1 <= av && x2 >= 0 && x2 <= av && x3 >= 0 && x3 <= av)
tag = true;
}
if ((2 * d1 - d2 + k) % 3 == 0 && (-d1 - d2 + k) % 3 == 0 &&
(-d1 + 2 * d2 + k) % 3 == 0) {
x1 = (2 * d1 - d2 + k) / 3;
x2 = (-d1 - d2 + k) / 3;
x3 = (-d1 + 2 * d2 + k) / 3;
if (x1 >= 0 && x1 <= av && x2 >= 0 && x2 <= av && x3 >= 0 && x3 <= av)
tag = true;
}
if ((-2 * d1 + d2 + k) % 3 == 0 && (d1 + d2 + k) % 3 == 0 &&
(d1 - 2 * d2 + k) % 3 == 0) {
x1 = (-2 * d1 + d2 + k) / 3;
x2 = (d1 + d2 + k) / 3;
x3 = (d1 - 2 * d2 + k) / 3;
if (x1 >= 0 && x1 <= av && x2 >= 0 && x2 <= av && x3 >= 0 && x3 <= av)
tag = true;
}
if ((-2 * d1 - d2 + k) % 3 == 0 && (d1 - d2 + k) % 3 == 0 &&
(d1 + 2 * d2 + k) % 3 == 0) {
x1 = (-2 * d1 - d2 + k) / 3;
x2 = (d1 - d2 + k) / 3;
x3 = (d1 + 2 * d2 + k) / 3;
if (x1 >= 0 && x1 <= av && x2 >= 0 && x2 <= av && x3 >= 0 && x3 <= av)
tag = true;
}
if (tag)
printf("yes\n");
else
printf("no\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_heap = priority_queue<T>;
template <class T>
ostream &operator<<(ostream &os, min_heap<T> H) {
while (!H.empty()) {
os << H.top() << " ";
H.pop();
}
os << endl;
return os << "";
}
template <class T>
ostream &operator<<(ostream &os, max_heap<T> H) {
while (!H.empty()) {
os << H.top() << " ";
H.pop();
}
os << endl;
return os << "";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << P.first << " " << P.second;
}
template <class T>
ostream &operator<<(ostream &os, vector<T> arr) {
for (long long i = 0; i < (long long)arr.size(); i++) {
os << arr[i] << " ";
}
return os << "";
}
template <class T>
ostream &operator<<(ostream &os, vector<vector<T>> matrix) {
os << endl;
for (long long i = 0; i < (long long)matrix.size(); i++) {
for (long long j = 0; j < (long long)matrix[i].size(); j++) {
os << matrix[i][j] << " ";
}
os << endl;
}
return os << "";
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
for (auto s : S) {
os << s << " ";
}
return os << "";
}
template <class T>
ostream &operator<<(ostream &os, multiset<T> S) {
for (auto s : S) {
os << s << " ";
}
return os << "";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << endl;
for (auto m : M) {
os << m << endl;
}
return os << "";
}
template <class L, class R>
ostream &operator<<(ostream &os, multimap<L, R> M) {
os << endl;
for (auto m : M) {
os << m << endl;
}
return os << "";
}
void solve() {
long long N, K;
cin >> N >> K;
cout << "? ";
for (long long i = 2; i <= K + 1; i++) {
cout << i << " ";
}
cout << endl;
long long pos, val;
cin >> pos >> val;
long long type = -1;
vector<long long> state(N + 1);
for (long long i = 2; i <= N; i++) {
if (i != pos) {
cout << "? ";
for (long long j = 2; j <= K + 1; j++) {
if (j == i) {
cout << 1 << " ";
} else {
cout << j << " ";
}
}
cout << endl;
long long new_pos, new_val;
cin >> new_pos >> new_val;
state[i] = (new_pos == pos);
if (!state[i]) {
if (new_val > val) {
type = 0;
} else {
type = 1;
}
}
}
}
if (type == -1) {
cout << "? ";
for (long long i = 2; i <= K + 1; i++) {
if (i == pos) {
cout << 1 << " ";
} else {
cout << i << " ";
}
}
cout << endl;
long long new_pos, new_val;
cin >> new_pos >> new_val;
if (new_val > val) {
cout << "! " << 1 << endl;
} else {
cout << "! " << K << endl;
}
} else {
long long cnt = 0;
for (long long i = 2; i <= K + 1; i++) {
if (i != pos) {
if ((type) && state[i]) {
cnt++;
} else if ((!type) && (!state[i])) {
cnt++;
}
}
}
cout << "! " << cnt + 1 << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long no_of_testcases = 1;
for (long long i = 1; i <= no_of_testcases; i++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
long long a[N], pr[N], po[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, p, q, r;
cin >> n >> p >> q >> r;
for (int i = 0; i < n; ++i) {
cin >> a[i];
pr[i] = max(a[i] * p, i ? pr[i - 1] : LLONG_MIN);
}
po[n - 1] = r * a[n - 1];
for (int i = n - 2; i >= 0; --i) {
po[i] = max(po[i + 1], a[i] * r);
}
long long ans = LLONG_MIN;
for (int i = 0; i < n; ++i) ans = max(ans, pr[i] + q * a[i] + po[i]);
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
void solve() {
long long int n;
cin >> n;
long long int ans = n / 2 + 2;
if (ans % 2 == 0) {
ans /= 2;
ans %= 1000000007;
ans = (ans * ans) % 1000000007;
} else {
long long int f = ans / 2;
f %= 1000000007;
long long int s = (ans + 1) / 2;
s %= 1000000007;
ans = (f * s) % 1000000007;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, i, j, ant, v[100010], maxi, lg;
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
for (i = 1; i <= n; i++) {
lg = 1;
while (v[i] == v[i + 1]) {
i++;
lg++;
}
maxi = max(lg, maxi);
}
cout << n - maxi;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a;
for (int i = 1; i <= a; i++) {
cin >> b >> c;
if (b == c)
cout << '0';
else {
if (c > b && (c - b) % 2 == 1) cout << '1';
if (c > b && (c - b) % 2 == 0) cout << '2';
if (c < b && (b - c) % 2 == 0) cout << '1';
if (c < b && (b - c) % 2 == 1) cout << '2';
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5;
long long n, sum, mx, e, rt;
char c[N];
long long vis[N], siz[N], fa[N];
long long ans[N], s[N];
long long t[(1 << 22) + 5], q[N];
long long nex[N], to[N], h[N], a[N];
void add(long long f, long long t) { nex[++e] = h[f], to[e] = t, h[f] = e; }
void get_root(long long x, long long f) {
long long son = 0;
fa[x] = f, siz[x] = 1;
for (long long i = h[x]; i; i = nex[i]) {
if (to[i] == f || vis[to[i]]) continue;
get_root(to[i], x), siz[x] += siz[to[i]];
son = max(son, siz[to[i]]);
}
son = max(son, sum - siz[x]);
if (son < mx) rt = x, mx = son;
}
void ins(long long x, long long f, long long d) {
d ^= a[x], t[d]++;
for (long long i = h[x]; i; i = nex[i]) {
if (to[i] == f || vis[to[i]]) continue;
ins(to[i], x, d);
}
}
void ask(long long x, long long f, long long d) {
d ^= a[x], s[x] = t[d];
for (long long i = 0; i <= 20; ++i) s[x] += t[d ^ (1 << i)];
for (long long i = h[x]; i; i = nex[i]) {
if (to[i] == f || vis[to[i]]) continue;
ask(to[i], x, d), s[x] += s[to[i]];
}
ans[x] += s[x];
}
void del(long long x, long long f, long long d) {
d ^= a[x], t[d]--;
for (long long i = h[x]; i; i = nex[i]) {
if (to[i] == f || vis[to[i]]) continue;
del(to[i], x, d);
}
}
void solve(long long x) {
vis[x] = 1;
long long top = 0;
for (long long i = h[x]; i; i = nex[i])
if (!vis[to[i]]) q[++top] = to[i];
t[a[x]] = 1;
for (long long i = 1; i <= top; ++i) ask(q[i], x, 0), ins(q[i], x, a[x]);
for (long long i = 1; i <= top; ++i) ans[x] += s[q[i]];
for (long long i = 1; i <= top; ++i) del(q[i], x, a[x]);
t[a[x]] = 0;
for (long long i = top; i >= 1; --i) ask(q[i], x, 0), ins(q[i], x, a[x]);
for (long long i = top; i >= 1; --i) del(q[i], x, a[x]);
for (long long i = h[x]; i; i = nex[i]) {
if (vis[to[i]]) continue;
mx = sum = siz[to[i]], rt = 0;
get_root(to[i], x), solve(rt);
}
}
signed main() {
long long x, y;
scanf("%lld", &n), mx = sum = n;
for (long long i = 1; i < n; ++i)
scanf("%lld%lld", &x, &y), add(x, y), add(y, x);
scanf("%s", c + 1);
for (long long i = 1; i <= n; ++i) a[i] = 1 << (c[i] - 'a');
get_root(1, 0), solve(rt);
for (long long i = 1; i <= n; ++i) printf("%lld ", ans[i] + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, m;
cin >> n >> m;
vector<long long int> v;
long long int dp[n];
for (long long int i = 0; i < n; i++) {
long long int x;
double y;
cin >> x >> y;
dp[i] = 1;
v.push_back(x);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = i - 1; j >= 0; j--) {
if (v[i] >= v[j]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
ans = max(ans, dp[i]);
}
ans = n - ans;
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, a[N], p[N], x, y, ans, rt;
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
int main(int argc, char **argv) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) p[i] = i;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] == i)
rt = i, ++ans;
else {
x = find(i), y = find(a[i]);
if (x == y)
a[i] = i, ++ans;
else
p[x] = y;
}
}
if (!rt) {
for (int i = 1; i <= n; ++i)
if (a[i] == i) rt = i;
++ans;
}
for (int i = 1; i <= n; ++i)
if (a[i] == i) a[i] = rt;
cout << ans - 1 << endl;
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int state;
cin >> state;
int new_state;
if (state >= 0) {
new_state = state;
} else {
int ult = -1 * state % 10;
int penult = -1 * state % 100 / 10;
if (ult >= penult) {
new_state = state / 10;
} else {
if (state / 100 == 0) {
new_state = ult * -1;
} else {
string state_string = to_string(state / 100);
string ult_string = to_string(ult);
string con = state_string + ult_string;
new_state = stoi(con);
}
}
}
cout << new_state << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<set<char> > v(m);
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) v[j].insert(s[j]);
}
long long out = 1;
for (int i = 0; i < m; i++) {
out = (out * v[i].size()) % 1000000007;
}
cout << out % 10000000007 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int read() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
const int MaxN = 201234;
int n, m, K, on, l[MaxN], r[MaxN], deg[MaxN], ord[MaxN], ans[MaxN];
vector<int> e[MaxN], val[MaxN];
queue<int> q;
int main() {
int i;
n = read();
m = read();
K = read();
for (i = 1; i <= n; i++) {
r[i] = read();
if (!r[i])
l[i] = 1, r[i] = K;
else
l[i] = r[i];
}
for (i = 1; i <= m; i++) {
int u = read(), v = read();
e[u].emplace_back(v);
++deg[v];
}
for (i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int c = q.front();
q.pop();
ord[++on] = c;
for (auto y : e[c])
if (!--deg[y]) q.push(y);
}
if (on != n) return puts("-1"), 0;
for (i = 1; i <= n; i++) {
int x = ord[i];
for (auto y : e[x]) cmin(r[y], r[x] - 1);
}
for (i = n; i; i--) {
int x = ord[i];
for (auto y : e[x]) cmax(l[x], l[y] + 1);
}
for (i = 1; i <= n; i++)
if (l[i] > r[i]) return puts("-1"), 0;
for (i = 1; i <= n; i++) val[l[i]].push_back(i);
set<pair<int, int> > s;
for (i = 1; i <= K; i++) {
for (auto x : val[i]) s.insert(make_pair(r[x], x));
if (s.empty()) return puts("-1"), 0;
pair<int, int> v = *s.begin();
for (ans[v.second] = i, s.erase(s.begin());
!s.empty() && (v = *s.begin()).first == i;
ans[v.second] = i, s.erase(s.begin()))
;
}
for (i = 1; i <= n; i++)
for (auto y : e[i])
if (ans[y] >= ans[i]) return puts("-1"), 0;
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char t;
int n, m, sum = 0;
cin >> n >> m;
bool check[n][m];
int row[n], col[m];
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> t;
if (t == '*') {
check[i][j] = true;
sum++;
row[i]++;
col[j]++;
} else
check[i][j] = false;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if ((check[i][j] && row[i] + col[j] - 1 == sum) ||
(!check[i][j] && row[i] + col[j] == sum)) {
cout << "YES" << endl;
cout << i + 1 << " " << j + 1;
return 0;
}
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], lev, vis[100005];
vector<int> adj[100005];
multiset<int> second[2];
map<int, int> mp[2];
void dfs(int u, int v) {
vis[u] = 1;
second[v].insert(a[u]);
mp[v][a[u]]++;
int first = 0;
for (auto it : adj[u]) {
if (!vis[it]) {
dfs(it, 1 - v);
first = 1;
}
}
if (first == 0) lev = v;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
adj[x].push_back(i);
adj[i].push_back(x);
}
dfs(1, 0);
int x = 0;
for (auto it : second[lev]) {
x ^= it;
}
long long ans = 0;
for (auto it : second[lev]) {
int q = x ^ it, t;
if (second[1 - lev].find(q) != second[1 - lev].end()) {
t = mp[1 - lev][q];
ans += t;
}
}
if (x == 0) {
ans += 1ll * (second[1 - lev].size() * (second[1 - lev].size() - 1)) / 2;
ans += 1ll * (second[lev].size() * (second[lev].size() - 1)) / 2;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
void sc(int &x) { scanf("%d", &x); }
void sc(int &x, int &y) { scanf("%d%d", &x, &y); }
void sc(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void sc(long long &x) { scanf("%lld", &x); }
void sc(long long &x, long long &y) { scanf("%lld%lld", &x, &y); }
void sc(long long &x, long long &y, long long &z) {
scanf("%lld%lld%lld", &x, &y, &z);
}
void sc(char *x) { scanf("%s", x); }
void sc(char *x, char *y) { scanf("%s%s", x, y); }
void sc(char *x, char *y, char *z) { scanf("%s%s%s", x, y, z); }
void out(int x) { printf("%d\n", x); }
void out(long long x) { printf("%lld\n", x); }
void out(int x, int y) { printf("%d %d\n", x, y); }
void out(long long x, long long y) { printf("%lld %lld\n", x, y); }
void out(int x, int y, int z) { printf("%d %d %d\n", x, y, z); }
void out(long long x, long long y, long long z) {
printf("%lld %lld %lld\n", x, y, z);
}
void ast(long long x, long long l, long long r) { assert(x >= l && x <= r); }
using namespace std;
const int N = 6e3 + 5, mod = 1e9 + 7;
int n, x[N], y[N];
int vis[2][2];
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
int cal(int i, int j) {
int xx = abs(x[i] - x[j]), yy = abs(y[i] - y[j]);
xx = gcd(xx, yy);
return xx * 2;
}
void sol(int cas) {
sc(n);
for (int i = 1; i <= n; i++) sc(x[i], y[i]);
for (int i = 1; i <= n; i++) x[i] >>= 1, y[i] >>= 1, x[i] &= 1, y[i] &= 1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
for (int j = n; j >= i + 1; j--) {
for (int h = 0; h <= 1; h++)
for (int k = 0; k <= 1; k++) {
int s = x[i] * y[j] + x[j] * y[i] + x[i] * k + h * y[i] + x[j] * k +
h * y[j];
s &= 1;
if (s == 0) ans += vis[h][k];
}
vis[x[j]][y[j]]++;
}
}
out(ans);
}
void init() {}
int main() {
srand(time(0));
init();
int t = 1, cas = 0;
while (t--) {
sol(++cas);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
double win[100][100];
double live[1 << 18];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) scanf("%lf", &win[i][j]);
live[(1 << n) - 1] = 1;
for (int m = (1 << n) - 1; m > 0; m--) {
int c = 0;
for (int i = 0; i < n; i++)
if ((m >> i) & 1) c++;
for (int i = 0; i < n; i++)
if ((m >> i) & 1)
for (int j = 0; j < n; j++)
if ((m >> j) & 1)
if (i != j)
live[m - (1 << i)] += live[m] * win[j][i] * 2 / c / (c - 1);
}
for (int i = 0; i < n; ++i) printf("%.6lf ", live[1 << i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string n;
int main() {
int n, c, i;
cin >> n >> c;
for (i = 1;; ++i) {
if (i > n) i = 1;
if (c < i)
break;
else
c -= i;
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ObeX[1001];
int ObeY[1001];
int ClueX[1001];
int ClueY[1001];
int Clue[1001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> ObeX[i] >> ObeY[i];
}
for (int i = 0; i < N; i++) {
cin >> ClueX[i] >> ClueY[i];
}
int TreaX;
int TreaY;
bool notFind = false;
for (int i = 0; i < N; i++) {
memset(Clue, 0, sizeof(Clue));
notFind = false;
TreaX = ObeX[0] + ClueX[i];
TreaY = ObeY[0] + ClueY[i];
for (int j = 1; j < N; j++) {
for (int k = 0; k < N; k++) {
if (!Clue[k]) {
notFind = true;
if (ObeX[j] + ClueX[k] == TreaX && ObeY[j] + ClueY[k] == TreaY) {
notFind = false;
Clue[k] = true;
break;
}
}
}
if (notFind) break;
}
if (!notFind) {
break;
}
}
cout << TreaX << " " << TreaY << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7, MAX = 1e6 + 5;
const long long inf = 1e18 + 5;
const double pi = 3.14159265358979323846;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
using namespace std;
bool correct(int i, int j, int n, int m) {
if (i < 0 || i >= n || j < 0 || j >= m) {
return false;
}
return true;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return (a / gcd(a, b)) * b; }
long long power(long long x, long long y) {
long long temp = 1ll;
while (y) {
if (y & 1) temp = (temp * x);
x = (x * x);
y = y >> 1;
}
return temp;
}
bool sieve[10000002];
vector<long long> primes;
void makeSieve() {
int N = 1e5 + 1;
for (int i = 0; i < N; i++) {
if (i & 1)
sieve[i] = true;
else
sieve[i] = false;
}
sieve[1] = false;
sieve[2] = true;
for (int i = 3; i * i <= N; i += 2) {
if (sieve[i]) {
for (int j = i * i; j <= N; j += (2 * i)) sieve[j] = false;
}
}
for (int i = 3; i < N; i++) {
if (sieve[i]) primes.push_back(i);
}
}
bool pot(long long n) {
if (n == 0) return 0;
while (n != 1) {
if (n % 2 != 0) return 0;
n = n / 2;
}
return 1;
}
long long w[100001];
bool comparer(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
if (n == 1) {
if (s[0] != '?') {
cout << s << endl;
} else {
cout << "R" << endl;
}
continue;
}
int i = 0, j = n - 1;
for (i = 0; i < n; i++) {
if (s[i] != '?') {
break;
}
}
for (; j >= 0; j--) {
if (s[j] != '?') {
break;
}
}
if (i == n) {
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
cout << "B";
} else {
cout << "R";
}
}
cout << endl;
continue;
}
if (i == j) {
for (int k = j + 1; k < n; k++) {
if (s[k - 1] == 'B') {
s[k] = 'R';
} else {
s[k] = 'B';
}
}
for (int k = i - 1; k >= 0; k--) {
if (s[k + 1] == 'B') {
s[k] = 'R';
} else {
s[k] = 'B';
}
}
cout << s << endl;
continue;
}
for (int k = j + 1; k < n; k++) {
if (s[k - 1] == 'B') {
s[k] = 'R';
} else {
s[k] = 'B';
}
}
for (int k = i - 1; k >= 0; k--) {
if (s[k + 1] == 'B') {
s[k] = 'R';
} else {
s[k] = 'B';
}
}
for (int k = i; k < j; k++) {
if (s[k] == '?') {
if (s[k - 1] == 'B') {
s[k] = 'R';
} else {
s[k] = 'B';
}
}
}
cout << s << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
int array[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> array[i][j];
}
}
int pos[k];
for (int i = 0; i < k; i++) cin >> pos[i];
for (int i = 0; i < k; i++) {
pair<int, int> currentpos;
currentpos.first = 0;
currentpos.second = pos[i] - 1;
while (currentpos.first != n) {
int row = currentpos.first;
int column = currentpos.second;
if (array[currentpos.first][currentpos.second] == 1) {
currentpos.second++;
} else if (array[currentpos.first][currentpos.second] == 2) {
currentpos.first++;
} else {
currentpos.second--;
}
array[row][column] = 2;
}
cout << currentpos.second + 1;
cout << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210000;
int n, m;
int g[MAXN];
int v[MAXN], b[MAXN], c[MAXN];
void init() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &g[i]);
for (int i = 1; i <= m; i++) scanf("%d", &v[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
;
}
int cal(int a, int b) {
int ans = 0;
for (int now = a; b > c[now]; now = g[now]) {
if (!c[now]) ans++;
c[now] = b;
--b;
}
return ans;
}
void solve() {
int res = 0;
for (int i = 1; i <= m; i++) {
int a = (v[i] + res - 1) % n + 1;
res = cal(a, b[i]);
printf("%d\n", res);
}
}
int main() {
init();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int i;
char a[100], b[100], c[100];
scanf("%s %s %s", a, b, c);
for (i = 0; i < strlen(a) + 4; i++) {
if ((a[0] == 's' && b[0] == 'p' && c[0] == 'p') ||
(a[0] == 'p' && b[0] == 'r' && c[0] == 'r') ||
(a[0] == 'r' && b[0] == 's' && c[0] == 's')) {
printf("F");
return 0;
}
if ((a[0] == 's' && b[0] == 'r' && c[0] == 's') ||
(a[0] == 'p' && b[0] == 's' && c[0] == 'p') ||
(a[0] == 'r' && b[0] == 'p' && c[0] == 'r')) {
printf("M");
return 0;
}
if ((a[0] == 's' && b[0] == 's' && c[0] == 'r') ||
(a[0] == 'p' && b[0] == 'p' && c[0] == 's') ||
(a[0] == 'r' && b[0] == 'r' && c[0] == 'p')) {
printf("S");
return 0;
}
}
printf("?");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int q = 0;
char ch = ' ';
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') q = q * 10 + ch - '0', ch = getchar();
return q;
}
const int N = 100005;
double P[N][110], ans;
int n, m, a[N], b[N];
double C(int d, int u) {
if (d < u || d < 0 || u < 0) return 0;
double ans = 1;
for (register int i = d - u + 1; i <= d; ++i) ans *= i;
for (register int i = 1; i <= u; ++i) ans /= i;
return ans;
}
int main() {
n = read();
for (register int i = 1; i <= n; ++i)
a[i] = b[i] = read(), P[i][a[i]] = 1, ans += (a[i] == 0);
m = read();
while (m--) {
int x = read(), y = read(), k = read();
ans -= P[x][0];
for (register int i = 0; i <= a[x]; ++i) {
double tmp = 0, all = C(b[x], k);
for (register int j = 0; j <= k; ++j)
tmp += P[x][i + j] * C(b[x] - i - j, k - j) * C(i + j, j);
P[x][i] = tmp / all;
}
ans += P[x][0], b[x] -= k, b[y] += k;
printf("%.10lf\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void dbg(long long a) { cout << "Hello " << a << endl; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
bool flag = true;
vector<char> smaller(k, '?');
for (long long i = 0; i < k; i++) {
int temp_idx = i;
bool one = false;
bool zero = false;
while (temp_idx < n) {
if (s[temp_idx] == '1') {
one = true;
}
if (s[temp_idx] == '0') {
zero = true;
}
temp_idx += k;
}
if (one && zero) {
flag = false;
}
if (one) {
smaller[i] = '1';
}
if (zero) {
smaller[i] = '0';
}
}
int count = 0;
int q_count = 0;
for (long long i = 0; i < k; i++) {
if (smaller[i] == '1') {
count++;
}
if (smaller[i] == '0') {
count--;
}
if (smaller[i] == '?') {
q_count++;
}
}
if (count) {
if (abs(count) > q_count) {
flag = false;
}
}
string ans = flag ? "YES" : "NO";
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Ma = 200000;
int n;
pair<pair<int, string>, pair<string, int> > a[Ma];
int p[Ma], u[Ma];
string second[Ma];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first.second >> a[i].second.first;
a[i].second.second = i;
}
for (int i = 1; i <= n; i++) {
cin >> p[i];
a[p[i]].first.first = i;
}
sort(a + 1, a + 1 + n);
second[1] = min(a[1].first.second, a[1].second.first);
for (int i = 2; i <= n; i++) {
if (min(a[i].first.second, a[i].second.first) > second[i - 1]) {
second[i] = min(a[i].first.second, a[i].second.first);
continue;
}
if (max(a[i].first.second, a[i].second.first) > second[i - 1]) {
second[i] = max(a[i].first.second, a[i].second.first);
continue;
}
cout << "NO";
cerr << i << endl;
return 0;
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
edge(int _to = 0, int _next = 0) : to(_to), next(_next) {}
} e[30010 << 1];
int n, m;
int g[30010], nume;
int f[30010];
int dis[210][30010], s[30010], l[30010];
vector<pair<int, int> > S[30010];
void addEdge(int u, int v) {
e[nume] = edge(v, g[u]);
g[u] = nume++;
}
namespace Tree {
int size[30010], son[30010], top[30010], pre[30010], dep[30010], w[30010],
pt[30010], numw;
void dfs(int x, int p) {
size[x] = 1;
son[x] = 0;
pre[x] = p;
for (int i = g[x]; ~i; i = e[i].next)
if (e[i].to ^ p) {
dep[e[i].to] = dep[x] + 1;
dfs(e[i].to, x);
size[x] += size[e[i].to];
if (size[e[i].to] > size[son[x]]) son[x] = e[i].to;
}
}
void dfs2(int x, int p) {
pt[w[x] = ++numw] = x;
if (son[x]) {
top[son[x]] = top[x];
dfs2(son[x], x);
}
for (int i = g[x]; ~i; i = e[i].next)
if (e[i].to != p && e[i].to != son[x]) {
top[e[i].to] = e[i].to;
dfs2(e[i].to, x);
}
}
void build() {
dfs(s[1], 0);
top[s[1]] = s[1];
dfs2(s[1], 0);
}
int getLCA(int x, int y) {
while (top[x] ^ top[y]) {
if (dep[top[x]] < dep[top[y]]) x ^= y ^= x ^= y;
x = pre[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
int getDis(int x, int y) { return dep[x] + dep[y] - 2 * dep[getLCA(x, y)]; }
int getPos(int x, int p) {
int s1 = s[x], s2 = s[x + 1];
int len = l[x];
if ((dis[x][p] + dis[x + 1][p] - len) & 1) return -1;
int d1 = dis[x][p] - (dis[x][p] + dis[x + 1][p] - len) / 2;
if (d1 < 0 || d1 > len) return -1;
return d1;
}
int goUp(int x, int d) {
while (dep[x] - dep[top[x]] + 1 <= d) {
d -= dep[x] - dep[top[x]] + 1;
x = pre[top[x]];
}
return pt[w[x] - d];
}
int go(int x, int y, int d) {
int lca = getLCA(x, y);
if (dep[x] - dep[lca] >= d) return goUp(x, d);
d = dep[x] + dep[y] - 2 * dep[lca] - d;
return goUp(y, d);
}
bool insert(int x) {
if (m == 1) {
S[s[1]].push_back(make_pair(dis[1][x], x));
return 1;
}
int mindep = n;
for (int i = 1; i < m; i++) {
int len = l[i], pos = getPos(i, x);
if (pos == -1) return 0;
if (dis[i][x] - pos < mindep) mindep = dis[i][x] - pos;
}
for (int i = 1; i < m; i++) {
int len = l[i], pos = getPos(i, x);
if (dis[i][x] - pos == mindep) {
int temp = go(s[i], s[i + 1], pos);
S[temp].push_back(make_pair(dis[i][x] - pos, x));
return 1;
}
}
return 0;
}
bool gao_insert(int x) {
int last = x, lastdep = 0;
sort(S[x].begin(), S[x].end());
for (int i = 0; i < S[x].size(); i++) {
if (S[x][i].first == lastdep) return 0;
if (S[x][i].first - lastdep > 1) {
if (i == 0) return 0;
last = S[x][i - 1].second;
lastdep = S[x][i - 1].first;
if (S[x][i].first - lastdep > 1) return 0;
}
addEdge(last, S[x][i].second);
addEdge(S[x][i].second, last);
}
return 1;
}
} // namespace Tree
namespace Check {
int d[30010];
bool check(int id) {
int S = s[id];
static queue<int> Q;
for (int i = 1; i <= n; i++) d[i] = -1;
Q.push(S);
d[S] = 0;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = g[x]; ~i; i = e[i].next)
if (d[e[i].to] == -1) {
d[e[i].to] = d[x] + 1;
Q.push(e[i].to);
}
}
for (int i = 1; i <= n; i++)
if (d[i] != dis[id][i]) return 0;
return 1;
}
} // namespace Check
int getf(int x) {
if (f[x] == x) return x;
return f[x] = getf(f[x]);
}
bool gao(int x) {
static int pt[30010];
int s1 = 0, s2 = 0;
for (int i = 1; i <= n; i++) {
if (dis[x][i] == 0) s1 = i;
if (dis[x + 1][i] == 0) s2 = i;
}
if (!s1 || !s2) return 0;
int len = dis[x][s2];
l[x] = len;
for (int i = 0; i <= len; i++) pt[i] = 0;
for (int i = 1; i <= n; i++)
if (dis[x][i] + dis[x + 1][i] == len) {
if (pt[dis[x][i]]) return 0;
pt[dis[x][i]] = i;
}
for (int i = 1; i <= len; i++) {
if (!pt[i - 1] || !pt[i]) return 0;
if (getf(pt[i - 1]) != getf(pt[i])) {
f[f[pt[i - 1]]] = f[pt[i]];
addEdge(pt[i - 1], pt[i]);
addEdge(pt[i], pt[i - 1]);
}
}
return 1;
}
int main() {
memset(g, -1, sizeof g);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &dis[i][j]);
if (!dis[i][j]) s[i] = j;
}
for (int i = 1; i < m; i++)
if (!gao(i)) {
puts("-1");
return 0;
}
Tree::build();
for (int i = 1; i <= n; i++)
if (getf(i) != getf(s[1]))
if (!Tree::insert(i)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++)
if (!Tree::gao_insert(i)) {
puts("-1");
return 0;
}
for (int i = 1; i <= m; i++)
if (!Check::check(i)) {
puts("-1");
return 0;
}
Tree::build();
for (int i = 1; i <= n; i++)
if (i != s[1]) printf("%d %d\n", Tree::pre[i], i);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 2e5 + 5;
int n, m, G[N], a[N], x, y, l, r;
bool ispal(int x, int y) {
for (int i = x; i <= y; i++)
if (a[i] != a[n - i + 1]) return false;
return true;
}
bool ok(int x, int y) {
memset(G, 0, sizeof G);
for (int i = x; i <= y; i++) G[a[i]]++;
if (x == l) {
if (y < (l + r) / 2) {
for (int i = x; i <= y; i++)
if (--G[a[n - i + 1]] < 0) return 0;
return ispal(y + 1, r - y);
} else {
for (int i = r; i >= y + 1; i--)
if (--G[a[i]] < 0) return 0;
int s = 0;
for (int i = 1; i <= n; i++) s += G[i] & 1;
return s <= 1;
}
} else {
if (x > (l + r) / 2) {
for (int i = x; i <= y; i++) {
if (--G[a[n - i + 1]] < 0) return 0;
}
return ispal(l + y - x + 1, x - 1);
} else {
for (int i = l; i <= x - 1; i++)
if (--G[a[i]] < 0) return 0;
int s = 0;
for (int i = 1; i <= n; i++) s += G[i] & 1;
return s <= 1;
}
}
}
int find_left() {
int bas = l, son = r;
while (bas < son) {
int orta = bas + son >> 1;
if (ok(l, orta))
son = orta;
else
bas = orta + 1;
}
return bas;
}
int find_right() {
int bas = l, son = r;
while (bas < son) {
int orta = bas + son >> 1;
if (orta == bas) orta++;
if (ok(orta, r))
bas = orta;
else
son = orta - 1;
}
return bas;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
l = 1, r = n;
for (int i = 1; i <= n + 1 >> 1; i++)
if (a[i] == a[n - i + 1])
l++, r--;
else
break;
if (l > r) {
cout << (long long)n * (n + 1) / 2 << '\n';
return 0;
}
if (!ok(l, r)) {
cout << 0 << '\n';
return 0;
}
int L = find_left();
int R = find_right();
cout << (n - L + 1) * l + (long long)(R - l) * l << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000100;
struct node {
int w, flag;
int a, b;
int id;
long long num;
} a[M];
int n, pos[M], m, s[M];
bool cmp(const node &x, const node &y) {
if (x.w == y.w) return x.flag > y.flag;
return x.w < y.w;
}
int fa[M];
bool cmp1(const node &x, const node &y) { return x.id < y.id; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i].w, &a[i].flag);
a[i].id = i;
}
sort(a + 1, a + 1 + m, cmp);
for (int i = 1; i <= n; i++) fa[i] = i;
int k = 1;
for (int i = 1; i <= m; i++)
if (a[i].flag) {
a[i].a = k;
pos[k] = i;
a[i].num = (long long)(k - 1) * k / 2 + 1;
a[i].b = ++k;
}
bool flag = 0;
for (int i = 1; i <= m; i++)
if (a[i].flag)
if (a[i].num < (long long)i) {
flag = 1;
break;
}
if (flag) {
printf("-1\n");
return 0;
}
pos[n] = m + 1;
int h = 3, s1 = 1;
for (int i = 1; i < n; i++) {
for (int j = pos[i] + 1; j < pos[i + 1];) {
a[j].a = s1;
a[j].b = h;
s1++;
if (s1 == h - 1) {
s1 = 1;
h++;
}
j++;
}
}
if (flag) {
printf("-1\n");
return 0;
}
sort(a + 1, a + 1 + m, cmp1);
for (int i = 1; i <= m; i++) printf("%d %d\n", a[i].a, a[i].b);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
const int xn = 3e3 + 10;
const int xm = 1e6 + 10;
const int inf = 1e9 + 10;
long long power(long long a, long long b) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2) % md
: power(a * a % md, b / 2) % md));
}
int n, p, s, dp[xn][xn], dp2[xn][xn];
pair<pair<int, int>, int> a[xn];
bool par[xn][xn], par2[xn][xn];
vector<int> Ans1, Ans2;
bool cmp(pair<pair<int, int>, int> i, pair<pair<int, int>, int> j) {
return i.first.first > j.first.first;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> p >> s;
for (int i = 1; i <= n; i++) cin >> a[i].first.first, a[i].second = i;
for (int i = 1; i <= n; i++) cin >> a[i].first.second;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0) {
dp[i][j] = dp[i - 1][j] + a[i].first.second;
continue;
}
if (i == j) {
dp[i][j] = dp[i - 1][j - 1] + a[i].first.first;
par[i][j] = true;
continue;
}
dp[i][j] = max(dp[i - 1][j - 1] + a[i].first.first,
dp[i - 1][j] + a[i].first.second);
if (dp[i][j] == dp[i - 1][j - 1] + a[i].first.first) par[i][j] = true;
}
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= n - i + 1; j++) {
if (j == 0) {
dp2[i][j] = dp2[i + 1][j];
continue;
}
if (j == n - i + 1) {
dp2[i][j] = dp2[i + 1][j - 1] + a[i].first.second;
par2[i][j] = true;
continue;
}
dp2[i][j] = max(dp2[i + 1][j - 1] + a[i].first.second, dp2[i + 1][j]);
if (dp2[i][j] == dp2[i + 1][j - 1] + a[i].first.second) par2[i][j] = true;
}
}
int mx = 0;
for (int i = p; i <= p + s; i++)
mx = max(mx, dp[i][p] + dp2[i + 1][s - i + p]);
for (int i = p; i <= p + s; i++) {
if (mx > dp[i][p] + dp2[i + 1][s - i + p]) continue;
int x = i, y = p;
while (x) {
if (par[x][y])
Ans1.push_back(a[x].second), y--;
else
Ans2.push_back(a[x].second);
x--;
}
x = i + 1, y = s - i + p;
while (x <= n) {
if (par2[x][y]) Ans2.push_back(a[x].second), y--;
x++;
}
break;
}
sort(Ans1.begin(), Ans1.end());
sort(Ans2.begin(), Ans2.end());
cout << mx << '\n';
for (int i = 0; i < Ans1.size(); i++) cout << Ans1[i] << ' ';
cout << '\n';
for (int i = 0; i < Ans2.size(); i++) cout << Ans2[i] << ' ';
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int find(vector<int> &a, int b) {
if (b < 0) return 1;
vector<int> b0, b1;
for (long long i = 0; i < a.size(); i++) {
if (a[i] & (1 << b))
b1.push_back(a[i]);
else
b0.push_back(a[i]);
}
if (b0.size() == 0)
return find(b1, b - 1);
else if (b1.size() == 0)
return find(b0, b - 1);
else
return 1 + max(find(b0, b - 1), find(b1, b - 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
long long n;
cin >> n;
vector<int> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
cout << n - find(v, 29) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const int rms = (1 << 20) - 1;
const int hrms = rms / 2;
struct mdf {
long double x, y;
long double ang;
mdf(long double x_ = 0.0, long double y_ = 0.0, long double a_ = 0.0)
: x(x_), y(y_), ang(a_) {}
};
int n, m;
int tp, x, y;
long double sqr(long double x) { return x * x; }
mdf operator+(const mdf& a, const mdf& b) {
return mdf(a.x + b.x * cos(a.ang) - b.y * sin(a.ang),
a.y + b.y * cos(a.ang) + b.x * sin(a.ang), a.ang + b.ang);
}
mdf rmq[rms + 1];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
rmq[i + 1 + hrms] = mdf(1.0, 0.0, 0.0);
}
for (int i = hrms; i > 0; i--) {
rmq[i].x = rmq[i * 2].x + rmq[i * 2 + 1].x;
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &tp, &x, &y);
if (tp == 1) {
long double curlen = sqrt(sqr(rmq[x + hrms].x) + sqr(rmq[x + hrms].y));
rmq[x + hrms].x *= (curlen + y) / curlen;
rmq[x + hrms].y *= (curlen + y) / curlen;
} else {
long double ang = atan2(rmq[x + hrms].y, rmq[x + hrms].x);
long double curlen = sqrt(sqr(rmq[x + hrms].x) + sqr(rmq[x + hrms].y));
ang -= y * pi / 180.0;
rmq[x + hrms].x = curlen * cos(ang);
rmq[x + hrms].y = curlen * sin(ang);
rmq[x + hrms].ang -= y * pi / 180.0;
}
int ps = x + hrms;
while (ps > 1) {
ps /= 2;
rmq[ps] = rmq[ps * 2] + rmq[ps * 2 + 1];
}
printf("%.10lf %.10lf\n", (double)rmq[1].x, (double)rmq[1].y);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
if (n > k)
cout << 1;
else if (k % n == 0)
cout << (k / n);
else
cout << (k / n) + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[1010];
int main() {
cin >> s + 1;
bool f = 0;
int l = strlen(s + 1);
int cnt = 0;
int i;
for (i = l; i >= 1; i--) {
if (s[i] == '0') cnt++;
if (cnt >= 6) break;
}
if (cnt >= 6) {
for (; i >= 1; i--) {
if (s[i] == '1') {
f = 1;
break;
}
}
}
puts((f) ? "yes" : "no");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, i;
cin >> n;
if (n & 1) {
for (i = 0; i < n; i++) cout << i << " ";
cout << endl;
cout << n - 1 << " ";
for (i = 0; i < n - 1; i++) cout << i << " ";
cout << endl;
cout << n - 1 << " ";
for (i = 1; i < n; i++) cout << (2 * i - 1) % n << " ";
} else
cout << -1;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define start cin>>t;while(t--)
#define f1 for(ll i=0;i<n;i++)
#define fv for(auto i: v)
#define w1 while(n--)
#define ll long long int
#define pnew printf("\n");
#define prill printf("%lld",
#define vall v.begin(),v.end()
#define so_gr sort(vall,greater<>());
/*vector<int> primes;
bitset<1000000000> mark;
void sieve(int n) {
for(int i = 2; i*i<=n; i++){
if(mark[i] == false){
for(int j = i+i; j<=n; j+=i) {
mark[j] = true;
}
}
}
for(int i = 2; i<=n; i++){
if(mark[i] == false)
primes.push_back(i);
}
}*/
int main(){
ll t,n,k,in,d,x;
start{
cin>>n;
vector<ll>v;
f1{
cin>>in;
v.push_back(in);
if(i>0){
d=(d&in);
}
else
d=in;
}
ll d1=count(vall,d);
if(d1>1){
x=d1*(d1-1);
x%=1000000007;
ll x1=1;
for(ll i=2;i<=(n-2);i++){
x1*=i;
x1%=1000000007;
}
cout<<((x*x1)%1000000007)<<endl;
}
else{
cout<<0<<endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
double h, l;
scanf("%lf%lf", &h, &l);
printf("%.15lf\n", ((h * h + l * l) * 0.5 / h) - h);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = (long long)1e5 + 9;
const long long mod = (long long)10007;
long long a[maxn];
int main() {
std::ios::sync_with_stdio(0);
long long i, j, k, t, q, m, l, r, n;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
long long ans = 0;
for (i = 1; i <= n / 2; i++) {
ans = (ans + (2 * a[i] * a[n - i + 1]) % mod) % mod;
}
if (n % 2) {
ans = (ans + (a[(n + 1) / 2] * a[(n + 1) / 2]) % mod) % mod;
}
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
struct graph {
map<int, int> edge[200];
};
int dist[200];
int dfs(graph &g, int s, int t, int cap = 1 << 29) {
if (s == t or not cap) return cap;
int res = 0;
for (auto it = g.edge[s].begin(); cap and it != g.edge[s].end(); ++it) {
if (dist[it->first] == dist[s] + 1) {
int add = dfs(g, it->first, t, min(cap, it->second));
g.edge[it->first][s] += add;
it->second -= add;
res += add;
cap -= add;
}
}
if (not res) dist[s] = -2;
return res;
}
int maxflow(int s, int t, graph g) {
for (int res = 0;;) {
memset(dist, -1, sizeof dist);
vector<int> bfs = {s};
dist[s] = 0;
for (int i = 0; i < bfs.size(); i++) {
int x = bfs[i];
for (auto y : g.edge[x]) {
if (y.second and !~dist[y.first]) {
dist[y.first] = dist[x] + 1;
bfs.push_back(y.first);
}
}
}
if (!~dist[t]) {
return res;
}
res += dfs(g, s, t);
}
}
vector<pair<int, int>> child[200];
vector<int> answer[200];
int par[200];
int rnk[200];
int find(int a) { return par[a] == a ? a : par[a] = find(par[a]); }
int merge(int a, int b) {
a = find(a);
b = find(b);
if (rnk[a] < rnk[b]) swap(a, b);
if (a == b) return a;
par[b] = a;
rnk[a]++;
return a;
}
void run() {
int res = 0;
graph g;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
g.edge[a][b] = c;
g.edge[b][a] = c;
}
int gom_hu[200] = {};
int p[200] = {};
for (int i = 1; i < n; i++) {
gom_hu[i] = maxflow(i, p[i], g);
res += gom_hu[i];
for (int j = i + 1; j < n; j++) {
if (p[j] == p[i] and ~dist[j]) {
p[j] = i;
}
}
}
vector<pair<int, pair<int, int>>> important;
for (int i = 1; i < n; i++) {
important.push_back({gom_hu[i], {p[i], i}});
}
sort(important.begin(), important.end());
cout << res << endl;
for (int i = n; i--;) {
answer[i] = {i};
par[i] = i;
}
for (int i = important.size(); i--;) {
int a = find(important[i].second.first);
int b = find(important[i].second.second);
vector<int> tmp;
for (auto j : answer[a]) tmp.push_back(j);
for (auto j : answer[b]) tmp.push_back(j);
int c = merge(a, b);
answer[c] = tmp;
}
for (int i = 0; i < n; i++)
cout << answer[find(0)][i] + 1 << (i + 1 == n ? '\n' : ' ');
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.