solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long L, R, n;
int c[10], a[19], b[19];
int ret;
bool check(int step, int lim) {
if (step < 0) return 1;
if (lim == 3) {
int l = b[step], u = a[step];
if (l == u) {
if (!c[l]) return 0;
--c[l];
int res = check(step - 1, 3);
++c[l];
return res;
}
for (int j = l + 1; j < u; ++j)
if (c[j]) return 1;
if (c[l]) {
--c[l];
if (check(step - 1, 1)) {
++c[l];
return 1;
}
++c[l];
}
if (c[u]) {
--c[u];
if (check(step - 1, 2)) {
++c[u];
return 1;
}
++c[u];
}
return 0;
}
int l = 0, u = 10, x = -1;
if (lim == 1)
l = b[step] + 1, x = b[step];
else
u = a[step], x = a[step];
for (int j = l; j < u; ++j)
if (c[j]) return 1;
if (!c[x]) return 0;
--c[x];
int res = check(step - 1, lim);
++c[x];
return res;
}
void get(int step, int cnt) {
if (step == 10) {
c[0] = n - cnt;
if (check(n - 1, 3)) ++ret;
return;
}
for (int i = 0; i < n - cnt + 1; ++i) {
c[step] = i;
get(step + 1, cnt + i);
c[step] = 0;
}
}
void calc() {
while (R) a[n++] = R % 10, R /= 10;
for (int i = 0; i < n; ++i) b[i] = L % 10, L /= 10;
get(1, 0);
}
int main() {
cin >> L >> R;
calc();
cout << ret << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int from[5050], to[5050];
vector<pair<int, int> > v[1010];
int d[1010], cnt[1010];
bool in[1010], out[1010];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> from[i] >> to[i];
from[i]--, to[i]--;
v[from[i]].push_back(make_pair(to[i], 2));
v[to[i]].push_back(make_pair(from[i], -1));
}
in[0] = 1, out[n - 1] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) in[to[j]] |= in[from[j]];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) out[from[j]] |= out[to[j]];
memset(d, 0x3f, sizeof(d));
d[0] = 0;
cnt[0] = 1;
bool update = 1;
while (update) {
update = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (int)v[i].size(); j++) {
if (!in[v[i][j].first] || !out[v[i][j].first]) continue;
if (d[v[i][j].first] > d[i] + v[i][j].second) {
d[v[i][j].first] = d[i] + v[i][j].second;
cnt[v[i][j].first] = cnt[i] + 1;
if (cnt[v[i][j].first] > n + 1) {
cout << "No" << endl;
return 0;
}
update = 1;
}
}
}
}
cout << "Yes" << endl;
for (int i = 0; i < m; i++) {
int val = d[to[i]] - d[from[i]];
if (val == 1 || val == 2)
cout << val << endl;
else
cout << "1" << endl;
}
return 0;
}
| 9 |
#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<stack>
#include<queue>
#include<set>
#include<cstring>
#define ESP 10e-9
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x);
using namespace std;
vector<pair<pair<int,int>,int> >odd;
vector<pair<pair<int,int>,int> >eve;
int a[300005];
int ans[300005];
int main()
{
int t;
cin>>t;
while (t--)
{
memset(ans,0,sizeof(ans));
int n,m;
cin>>n>>m;
odd.clear();
eve.clear();
for (int i=0;i<n;i++)
{
cin>>a[i];
}
for (int i=0;i<n;i++)
{
char c;
cin>>c;
int f;
if (c=='L')
{
f=0;
}
else
{
f=1;
}
if (a[i] & 1)
{
odd.pb(mp(mp(a[i],f),i));
}
else
{
eve.pb(mp(mp(a[i],f),i));
}
}
sort(odd.begin(),odd.end());
sort(eve.begin(),eve.end());
//////clide in begining
for (int i=1;i<odd.size();i++)
{
if (odd[i].first.first==odd[i-1].first.first)
{
ans[odd[i].second]=0;
ans[odd[i-1].second]=0;
i++;
}
}
//// face to face
stack<int> st;
for (int i=0;i<odd.size();i++)
{
if (ans[odd[i].second]) continue;
if (odd[i].first.second==1)
{
st.push(i);
continue;
}
if (st.empty())
{
continue;
}
int tp=st.top();
st.pop();
int tans=(odd[i].first.first-odd[tp].first.first)>>1;
ans[odd[i].second]=tans;
ans[odd[tp].second]=tans;
//cout<<"**"<<endl;
}
//cout<<"**"<<endl;
////face to back
//while (!st.empty())st.pop();
int lst=-1;
for (int i=0;i<odd.size();i++)
{
if (ans[odd[i].second]) continue;
if (odd[i].first.second==1) continue;
if (lst==-1)
{
lst=i;
continue;
}
int tmp=(odd[i].first.first-odd[lst].first.first)>>1;
//cout<<tmp<<"**"<<endl;
ans[odd[i].second]=odd[lst].first.first+tmp;
ans[odd[lst].second]=odd[lst].first.first+tmp;
lst=-1;
}
lst=-1;
for (int i=odd.size()-1;i>=0;i--)
{
if (ans[odd[i].second]) continue;
if (odd[i].first.second==0) continue;
if (lst==-1)
{
lst=i;
continue;
}
int tmp=m-((odd[lst].first.first-odd[i].first.first)>>1);
ans[odd[i].second]=-odd[i].first.first+tmp;
ans[odd[lst].second]=-odd[i].first.first+tmp;
lst=-1;
}
//cout<<"**"<<endl;
//back to back
int aa=-1,bb=-1;
for (int i=0;i<odd.size();i++)
{
//cout<<i<<endl;
if (ans[odd[i].second]) continue;
if (aa==-1)
{
aa=i;
}
else
{
bb=i;
}
}
if (bb==-1)
{
}
else
{
int dd1=odd[aa].first.first,dd2=m-odd[bb].first.first;
int taa=aa,tbb=bb;
aa=odd[taa].first.first-min(dd1,dd2);
bb=odd[tbb].first.first+min(dd1,dd2);
ans[odd[taa].second]=min(dd1,dd2);
ans[odd[tbb].second]=min(dd1,dd2);
if (aa==0)
{
int tans=m-((bb-aa)>>1);
ans[odd[taa].second]+=tans;
ans[odd[tbb].second]+=tans;
}
else
{
int tmp=(bb-aa)>>1;
ans[odd[taa].second]+=aa+tmp;
ans[odd[tbb].second]+=aa+tmp;
}
}
//cout<<"**"<<endl;
/////
//////clide in begining
for (int i=1;i<eve.size();i++)
{
if (eve[i].first.first==eve[i-1].first.first)
{
ans[eve[i].second]=0;
ans[eve[i-1].second]=0;
i++;
}
}
//// face to face
while (!st.empty())st.pop();
for (int i=0;i<eve.size();i++)
{
if (ans[eve[i].second]) continue;
if (eve[i].first.second==1)
{
st.push(i);
continue;
}
if (st.empty())
{
continue;
}
int tp=st.top();
st.pop();
int tans=(eve[i].first.first-eve[tp].first.first)>>1;
ans[eve[i].second]=tans;
ans[eve[tp].second]=tans;
}
//cout<<"**"<<endl;
////face to back
//while (!st.empty())st.pop();
lst=-1;
for (int i=0;i<eve.size();i++)
{
if (ans[eve[i].second]) continue;
if (eve[i].first.second==1) continue;
if (lst==-1)
{
lst=i;
continue;
}
int tmp=(eve[i].first.first-eve[lst].first.first)>>1;
ans[eve[i].second]=eve[lst].first.first+tmp;
ans[eve[lst].second]=eve[lst].first.first+tmp;
lst=-1;
}
lst=-1;
for (int i=eve.size()-1;i>=0;i--)
{
if (ans[eve[i].second]) continue;
if (eve[i].first.second==0) continue;
if (lst==-1)
{
lst=i;
continue;
}
int tmp=m-((eve[lst].first.first-eve[i].first.first)>>1);
ans[eve[i].second]=-eve[i].first.first+tmp;
ans[eve[lst].second]=-eve[i].first.first+tmp;
lst=-1;
}
//cout<<"**"<<endl;
//back to back
aa=-1;
bb=-1;
for (int i=0;i<eve.size();i++)
{
//cout<<i<<endl;
if (ans[eve[i].second]) continue;
if (aa==-1)
{
aa=i;
}
else
{
bb=i;
}
}
if (bb==-1)
{
}
else
{
int dd1=eve[aa].first.first,dd2=m-eve[bb].first.first;
int taa=aa,tbb=bb;
aa=eve[taa].first.first-min(dd1,dd2);
bb=eve[tbb].first.first+min(dd1,dd2);
ans[eve[taa].second]=min(dd1,dd2);
ans[eve[tbb].second]=min(dd1,dd2);
if (aa==0)
{
int tans=m-((bb-aa)>>1);
ans[eve[taa].second]+=tans;
ans[eve[tbb].second]+=tans;
}
else
{
int tmp=(bb-aa)>>1;
ans[eve[taa].second]+=aa+tmp;
ans[eve[tbb].second]+=aa+tmp;
}
}
for (int i=0;i<n;i++)
{
if (ans[i]==0)cout<<-1<<" ";
else cout<<ans[i]<<" ";
}
cout<<endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int mod[2] = {98765431, (int)1e9 + 9};
int base = 71;
int n;
int a[N];
int b[N], c[N];
int num[N];
map<pair<long long, long long>, int> mp;
int nbit(int x) {
int ans = 0;
while (x) ans += x & 1, x /= 2;
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
c[i] = (a[i] >> 16);
b[i] = (a[i] - (c[i] << 16));
}
for (int i = 0; i < (1 << 16); i++) {
for (int j = 0; j < n; j++) num[j] = nbit(b[j] ^ i);
pair<long long, long long> h = {0, 0};
for (int j = 0; j < n; j++) {
h.first = (h.first * base + (num[j] - num[0])) % mod[0];
h.second = (h.second * base + (num[j] - num[0])) % mod[1];
}
if (!mp[h]) mp[h] = i + 1;
}
for (int i = 0; i < (1 << 16); i++) {
for (int j = 0; j < n; j++) num[j] = nbit(c[j] ^ i);
pair<long long, long long> h = {0, 0};
for (int j = 0; j < n; j++) {
h.first = (h.first * base - (num[j] - num[0])) % mod[0];
h.second = (h.second * base - (num[j] - num[0])) % mod[1];
}
if (mp[h]) {
cout << (i << 16) + mp[h] - 1 << endl;
return 0;
}
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long Linf = 1e18 + 5;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
inline int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
vector<long long> v;
int main() {
long long n;
cin >> n;
for (int(k) = (0); (k) <= (62); (k)++) {
long long x = 0LL;
for (int(i) = (0); (i) <= (k - 1); (i)++) x += (1LL << (i));
long long l = 0, r = n + n;
while (l + 1 < r) {
long double m = (l + r) >> 1;
if (m * (m - 1) / 2LL + m * x <= n)
l = m;
else
r = m;
}
long long a = l;
if (a * (a - 1) / 2LL + a * x == n && a % 2 == 1)
v.push_back(a * (1LL << (k)));
}
if (v.size() == 0) {
cout << -1 << endl;
return 0;
}
sort(v.begin(), v.end());
for (int(i) = (0); (i) < (v.size()); (i)++) {
cout << v[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N], n;
int dp[N][2];
int solve(int idx, int player) {
if (idx >= n) return 0;
if (dp[idx][player] != -1) return dp[idx][player];
int op1 = solve(idx + 1, 1 - player) + (player * a[idx]);
int op2 = solve(idx + 2, 1 - player) + ((player) * (a[idx] + a[idx + 1]));
return dp[idx][player] = min(op1, op2);
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
cout << solve(0, 1) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
const int MAXN = 100010;
const long long MOD = 1e9 + 7;
int sum[MAXN];
int src[MAXN], N, num;
int val[MAXN], cnt[MAXN];
long long pow_mod(long long x, long long cnt) {
long long ret = 1;
while (cnt) {
if (cnt & 1LL) ret = ret * x % MOD;
x = x * x % MOD;
cnt >>= 1LL;
}
return ret;
}
int main() {
while (scanf("%d", &N) != EOF) {
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= N; i++) scanf("%d", &src[i]);
for (int i = 1; i <= N; i++) cnt[src[i]]++;
sort(src + 1, src + 1 + N);
memset(sum, 0, sizeof(sum));
sum[src[N]] = cnt[src[N]];
for (int i = src[N] - 1; i >= 1; i--) sum[i] = sum[i + 1] + cnt[i];
long long ans = 1;
for (int i = 2; i <= src[N]; i++) {
num = 0;
for (int j = 1; j * j <= i; j++) {
if (j * j == i)
val[num++] = j;
else if (i % j == 0) {
val[num++] = j;
val[num++] = i / j;
}
}
sort(val, val + num);
long long res = (long long)sum[val[num - 1]];
long long ret = (pow_mod((long long)num, res) -
pow_mod((long long)(num - 1), res) + MOD) %
MOD;
for (int j = 0; j < num - 1; j++) {
res = (long long)sum[val[j]] - sum[val[j + 1]];
ret = (ret * pow_mod((long long)(j + 1), res)) % MOD;
}
ans = (ans + ret) % MOD;
}
printf("%I64d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
template <class T = int>
T __rand(T range = numeric_limits<T>::max()) {
return (T)(rng() % range);
}
template <class T>
ostream& operator,(ostream& out, const T& thing) {
return out << ", " << thing;
}
template <class U, class V>
ostream& operator<<(ostream& out, const pair<U, V>& p) {
return (out << "(" << p.first, p.second) << ")";
}
template <class A, class B>
ostream& operator<<(ostream& out, const tuple<A, B>& t) {
return (out << "(" << get<0>(t), get<1>(t)) << ")";
}
template <class A, class B, class C>
ostream& operator<<(ostream& out, const tuple<A, B, C>& t) {
return (out << "(" << get<0>(t), get<1>(t), get<2>(t)) << ")";
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& container) {
out << "{";
if (((int)container.size())) out << container[0];
for (int i = 0; i++ < ((int)container.size()) - 1;) out, container[i];
return out << "}";
}
template <class x>
vector<typename x::value_type> $v(const x& a) {
return vector<typename x::value_type>(a.begin(), a.end());
}
template <class u>
vector<typename iterator_traits<u>::value_type> $v(u a, u b) {
return vector<typename iterator_traits<u>::value_type>(a, b);
}
struct point {
long long x, y;
point() {}
point(long long x_, long long y_) : x(x_), y(y_) {}
};
point operator-(const point& u, const point& v) {
return point(u.x - v.x, u.y - v.y);
}
long long cross(const point& u, const point& v) {
return u.x * v.y - u.y * v.x;
}
struct line : point {
using point::point;
long long operator()(long long x_) { return x * x_ + y; }
};
bool is_lower(const line& left, const line& mid, const line& right) {
return cross(right - mid, left - mid) >= 0;
}
const int maxn = 2020;
const long long inf = (long long)1e15;
const long long rem = (long long)(1e9 + 7);
int n, m;
long long q;
vector<tuple<int, int, long long>> edge_list;
long long cur_dist[2][maxn];
long long mpow(long long base, long long exp) {
long long ans = 1;
for (; exp > 0; exp >>= 1) {
if (exp & 1) (ans *= base) %= rem;
(base *= base) %= rem;
}
return ans;
}
void custom_input() {
n = 2000;
m = 1999;
q = (int)1e9;
for (int i = -1; ++i < m;) {
edge_list.emplace_back(i + 1, i + 2, 999999);
}
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = -1; ++i < m;) {
int u, v, c;
cin >> u >> v >> c;
edge_list.emplace_back(u, v, c);
}
for (int u = 0; u++ < n;) cur_dist[0][u] = -inf;
cur_dist[0][1] = 0;
long long ans = 0;
int state;
for (int i = 0; i++ < m * 3;) {
state = i & 1;
for (int u = 0; u++ < n;) cur_dist[state][u] = -inf;
for (auto [u, v, c] : edge_list) {
cur_dist[state][v] = max(cur_dist[state][v], cur_dist[!state][u] + c);
cur_dist[state][u] = max(cur_dist[state][u], cur_dist[!state][v] + c);
}
long long cur_ans = 0;
for (int u = 0; u++ < n;) {
cur_ans = max(cur_ans, cur_dist[state][u]);
}
(ans += cur_ans) %= rem;
--q;
if (q == 0) {
cout << ans;
return 0;
}
}
vector<line> hull;
for (int u = 0; u++ < n;) {
;
hull.emplace_back(-inf, cur_dist[state][u]);
}
for (auto [u, v, c] : edge_list) {
hull[u - 1].x = max(hull[u - 1].x, c);
hull[v - 1].x = max(hull[v - 1].x, c);
}
hull.resize(remove_if(hull.begin(), hull.end(),
[](const line& u) { return u.y < 0; }) -
hull.begin());
sort(hull.begin(), hull.end(), [](const line& u, const line& v) {
if (u.x == v.x) return u.y < v.y;
return u.x < v.x;
});
int new_len = 1;
for (int i = 1; i < ((int)hull.size()); ++i) {
while (new_len and hull[new_len - 1].x == hull[i].x) --new_len;
hull[new_len++] = hull[i];
}
hull.resize(new_len);
hull.insert(hull.begin(), line(0, 0));
new_len = min(2, ((int)hull.size()));
for (int i = 2; i < ((int)hull.size()); ++i) {
while (new_len > 2 and
is_lower(hull[new_len - 2], hull[new_len - 1], hull[i])) {
--new_len;
}
hull[new_len++] = hull[i];
}
hull.resize(new_len);
long long inv2 = mpow(2, rem - 2);
long long pos = 1;
for (int i = 0; i < ((int)hull.size()) - 1 and pos <= q; ++i) {
long long left = pos, right = q + 1;
while (left < right) {
long long mid = (left + right) / 2;
if (hull[i + 1](mid) > hull[i](mid))
right = mid;
else
left = mid + 1;
}
long long cnt = (left - pos) % rem;
;
long long t = cnt * (pos + left - 1) % rem * inv2 % rem;
(ans += cnt * hull[i].y % rem) %= rem;
(ans += t * hull[i].x % rem) %= rem;
pos = left;
};
long long cnt = (q - pos + 1) % rem;
long long t = cnt * (q + pos) % rem * inv2 % rem;
;
(ans += cnt * hull.back().y % rem) %= rem;
(ans += t * hull.back().x % rem) %= rem;
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int MAXN = 5010;
long long dp[2][MAXN];
void getmin(long long& x, long long y) { x > y ? x = y : 0; }
int X[MAXN], A[MAXN], B[MAXN], C[MAXN], D[MAXN];
int L[2][MAXN], R[2][MAXN];
int n, S, E;
inline int tr(int x) { return x == 1 ? -1 : 1; }
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> S >> E;
for (int i = 1; i <= n; ++i) std::cin >> X[i];
for (int i = 1; i <= n; ++i) std::cin >> A[i];
for (int i = 1; i <= n; ++i) std::cin >> B[i];
for (int i = 1; i <= n; ++i) std::cin >> C[i];
for (int i = 1; i <= n; ++i) std::cin >> D[i];
for (int i = 1; i <= n; ++i) L[0][i] = D[i] - X[i];
for (int i = 1; i <= n; ++i) L[1][i] = B[i] - X[i];
for (int i = 1; i <= n; ++i) R[0][i] = C[i] + X[i];
for (int i = 1; i <= n; ++i) R[1][i] = A[i] + X[i];
memset(dp, 0x3f, sizeof dp);
const long long INF = **dp;
int now = 1, lst = 0;
dp[now][0] = 0;
const int RAN = n;
for (int i = 1; i <= n; ++i) {
std::swap(now, lst);
memset(dp[now], 0x3f, sizeof(dp[now]));
for (int j = (i > S) + (i > E); j <= RAN; ++j)
if (dp[lst][j] < INF) {
long long v = dp[lst][j];
if (i == S) {
getmin(dp[now][j + 1], v + L[0][i]);
if (j > (i > E) || i == n) getmin(dp[now][j], v + R[0][i]);
} else if (i == E) {
getmin(dp[now][j + 1], v + L[1][i]);
if (j > (i > S) || i == n) getmin(dp[now][j], v + R[1][i]);
} else {
if (j > 1) getmin(dp[now][j - 1], v + R[0][i] + R[1][i]);
getmin(dp[now][j + 1], v + L[0][i] + L[1][i]);
if (j > (i > S)) getmin(dp[now][j], v + R[0][i] + L[1][i]);
if (j > (i > E)) getmin(dp[now][j], v + L[0][i] + R[1][i]);
}
}
}
std::cout << dp[now][1] << std::endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, x2, y2;
struct rct {
int x, y, x2, y2;
} v[200005];
struct rctXd {
int val;
bool operator<(const rctXd& oth) const {
if (v[val].x2 == v[oth.val].x2) {
if (v[val].x == v[oth.val].x) return val < oth.val;
return v[val].x < v[oth.val].x;
}
return v[val].x2 > v[oth.val].x2;
}
};
struct rctXc {
int val;
bool operator<(const rctXc& oth) const {
if (v[val].x == v[oth.val].x) {
if (v[val].x2 == v[oth.val].x2) return val < oth.val;
return v[val].x2 > v[oth.val].x2;
}
return v[val].x < v[oth.val].x;
}
};
struct rctYd {
int val;
bool operator<(const rctYd& oth) const {
if (v[val].y2 == v[oth.val].y2) {
if (v[val].y == v[oth.val].y) return val < oth.val;
return v[val].y < v[oth.val].y;
}
return v[val].y2 > v[oth.val].y2;
}
};
struct rctYc {
int val;
bool operator<(const rctYc& oth) const {
if (v[val].y == v[oth.val].y) {
if (v[val].y2 == v[oth.val].y2) return val < oth.val;
return v[val].y2 > v[oth.val].y2;
}
return v[val].y < v[oth.val].y;
}
};
void citire() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i].x >> v[i].y >> v[i].x2 >> v[i].y2;
}
}
bool solve(set<rctXc>& Xc, set<rctXd>& Xd, set<rctYc>& Yc, set<rctYd>& Yd) {
if (Xc.size() == 1) {
return 1;
}
auto itXc = Xc.begin();
auto itYc = Yc.begin();
auto itXd = Xd.begin();
auto itYd = Yd.begin();
int mXc = v[itXc->val].x2, mXd = v[itXd->val].x, mYd = v[itYd->val].y,
mYc = v[itYc->val].y2;
vector<int> deSters;
int ok = 0;
itXc++;
itYc++;
itXd++;
itYd++;
for (int i = 2; i <= min(Xc.size() / 2 + 2, Xc.size()); i++) {
if (v[itXc->val].x >= mXc) {
itXc = Xc.begin();
for (int j = 1; j < i; j++) {
deSters.push_back(itXc->val);
itXc++;
}
ok = 1;
break;
}
if (v[itXd->val].x2 <= mXd) {
itXd = Xd.begin();
for (int j = 1; j < i; j++) {
deSters.push_back(itXd->val);
itXd++;
}
ok = 1;
break;
}
if (v[itYd->val].y2 <= mYd) {
itYd = Yd.begin();
for (int j = 1; j < i; j++) {
deSters.push_back(itYd->val);
itYd++;
}
ok = 1;
break;
}
if (v[itYc->val].y >= mYc) {
itYc = Yc.begin();
for (int j = 1; j < i; j++) {
deSters.push_back(itYc->val);
itYc++;
}
ok = 1;
break;
}
mXc = max(mXc, v[itXc->val].x2);
mXd = min(mXd, v[itXd->val].x);
mYc = max(mYc, v[itYc->val].y2);
mYd = min(mYd, v[itYd->val].y);
itXc++;
itYc++;
itXd++;
itYd++;
}
if (!ok) return 0;
set<rctXc> Xc2;
set<rctXd> Xd2;
set<rctYc> Yc2;
set<rctYd> Yd2;
for (auto it : deSters) {
Xc.erase({it});
Xd.erase({it});
Yc.erase({it});
Yd.erase({it});
Xc2.insert({it});
Xd2.insert({it});
Yc2.insert({it});
Yd2.insert({it});
}
return solve(Xc, Xd, Yc, Yd) && solve(Xc2, Xd2, Yc2, Yd2);
}
int main() {
ios::sync_with_stdio(false);
citire();
set<rctXc> Xc;
set<rctXd> Xd;
set<rctYc> Yc;
set<rctYd> Yd;
for (int i = 1; i <= n; i++) {
Xc.insert({i});
Xd.insert({i});
Yc.insert({i});
Yd.insert({i});
}
if (solve(Xc, Xd, Yc, Yd)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[109], s, qzh[109], n, m, r, l;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
qzh[i] = qzh[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
cin >> l >> r;
if (qzh[r] > qzh[l - 1]) s += qzh[r] - qzh[l - 1];
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int main() {
int n;
cin >> n;
int k = 0;
int max = 0;
for (int i = 1; i <= 2 * n; i++) {
int x;
cin >> x;
if (s.find(x) == s.end()) {
k++;
s.insert(x);
} else
k--;
if (max < k) max = k;
}
cout << max;
}
| 0 |
#include <bits/stdc++.h>
char s[1001000], kkk;
int ans[1001000], at = 0;
int main() {
gets(s);
int st = 0, ls, ed, flag = 1;
ans[at++] = 0;
for (ed = st; s[ed] != '.'; ed++)
;
if (ed > 8 || ed < 1) flag = 0;
st = ed + 1;
for (; flag;) {
ed = st;
for (; s[ed] && s[ed] != '.'; ed++)
;
if (s[ed] == '.') {
if (ed - st < 2 || ed - st > 11) {
flag = 0;
break;
} else if (ed - st < 10) {
ans[at++] = st + 1;
} else if (ed - st == 10) {
ans[at++] = st + 2;
} else if (ed - st == 11) {
ans[at++] = st + 3;
}
} else if (s[ed] == 0) {
if (ed - st > 3 || ed - st < 1) flag = 0;
break;
}
st = ed + 1;
}
if (!flag)
puts("NO");
else {
puts("YES");
int i;
for (i = 0; i < at - 1; i++) {
kkk = s[ans[i + 1]];
s[ans[i + 1]] = 0;
puts(s + ans[i]);
s[ans[i + 1]] = kkk;
}
puts(s + ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100005;
char s[N];
int T, h, t, n, m = 1, cur = 1, ans, l[15], r[15], c[N][11], a[N][27], L[N],
par[N], d[N], f[N];
void extend(int i, int t, int ch) {
int x = cur, y = cur = ++m;
L[y] = i, ++c[y][t];
for (; x && !a[x][ch]; x = par[x]) a[x][ch] = y;
if (!x)
par[y] = 1;
else {
int z = a[x][ch];
if (L[z] == L[x] + 1)
par[y] = z;
else {
int u = ++m;
L[u] = L[x] + 1, memcpy(a[u], a[z], sizeof(a[u])), par[u] = par[z],
par[z] = par[y] = u;
for (; x && a[x][ch] == z; x = par[x]) a[x][ch] = u;
}
}
}
bool vaild(int x) {
if (!*c[x]) return 0;
for (int i = 1; i <= n; ++i)
if (l[i] > c[x][i] || c[x][i] > r[i]) return 0;
return 1;
}
int main() {
scanf("%s%d", s + 1, &n), T = strlen(s + 1);
for (int i = 1; i <= n; ++i)
scanf("%s%d%d", s + T + 2, l + i, r + i), T += strlen(s + T + 2) + 1;
for (int i = 1; i <= T; ++i)
if (!s[i])
extend(i, ++t, 0);
else
extend(i, t, s[i] - 96);
for (int i = 1; i <= m; ++i) ++d[par[i]];
h = 0, t = 0;
for (int i = 1; i <= m; ++i)
if (!d[i]) f[++t] = i;
while (h < t) {
int x = f[++h], y = par[x];
ans += (L[x] - L[y]) * vaild(x);
*c[y] |= *c[x];
for (int i = 1; i <= n; ++i) c[y][i] += c[x][i];
if (!--d[y]) f[++t] = y;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int pol = x1 + y1;
int mn = min(x2, y2);
int vas = mn + x2 - mn + y2 - mn;
if (pol <= vas || (x1 <= x2 && y1 <= y2)) {
cout << "Polycarp";
} else
cout << "Vasiliy";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 70009;
string s, a, b;
int n, q;
int id[500009], tot, len[N], F[431][N], p[5][N], wt[N], cnt;
vector<int> vt[N];
int H(string s) {
int sum = 0;
for (auto it : s) sum = sum * 26 + it - 'a' + 1;
return sum;
}
int main() {
cin >> s >> q;
n = s.length();
for (int l = 1; l <= 4; l++)
for (int j = 0; j + l <= n; j++) {
int k = H(s.substr(j, l));
if (!id[k]) id[k] = ++tot, len[tot] = l;
vt[id[k]].push_back(j);
p[l][j] = id[k];
}
memset(F, 0x3f, sizeof F);
for (int i = 1; i <= tot; i++)
if (vt[i].size() > 400) {
cnt++;
wt[i] = cnt;
int siz = vt[i].size(), l = 0, r = 0;
for (int j = 1; j < siz; j++) {
l = vt[i][j - 1], r = vt[i][j];
for (int k = l; k <= r; k++)
for (int o = 1; o <= 4; o++)
F[cnt][p[o][k]] = min(F[cnt][p[o][k]], min(max(k - l + o, len[i]),
max(r + len[i] - k, o)));
}
l = 0, r = vt[i][0];
for (int j = l; j <= r; j++)
for (int o = 1; o <= 4; o++)
F[cnt][p[o][j]] = min(F[cnt][p[o][j]], max(r + len[i] - j, o));
l = vt[i][siz - 1], r = n - 1;
for (int j = l; j <= r; j++)
for (int o = 1; o <= 4; o++)
F[cnt][p[o][j]] = min(F[cnt][p[o][j]], max(j + o - l, len[i]));
}
while (q--) {
cin >> a >> b;
int ha = H(a), hb = H(b);
int x = id[ha], y = id[hb];
if (!x || !y)
puts("-1");
else if (vt[x].size() > 400)
cout << F[wt[x]][y] << '\n';
else if (vt[y].size() > 400)
cout << F[wt[y]][x] << '\n';
else {
int sum = n + 1, alen = a.length(), blen = b.length();
for (unsigned i = 0, j = 0; i < vt[x].size(); i++) {
while (j < vt[y].size() - 1 && vt[y][j] < vt[x][i]) j++;
if (vt[y][j] > vt[x][i]) {
if (j) sum = min(sum, vt[x][i] - vt[y][j - 1] + alen);
sum = min(sum, vt[y][j] - vt[x][i] + blen);
} else
sum = min(sum, vt[x][i] - vt[y][j] + alen);
}
cout << max(sum, max(alen, blen)) << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chmin(T &a, const T &b) {
return a > b ? a = b, true : false;
}
template <typename T>
bool chmax(T &a, const T &b) {
return a < b ? a = b, true : false;
}
const int maxN = 2000 + 5;
const int P = 1000000007;
int n, m;
char b[maxN][maxN];
int suf[maxN][maxN], dow[maxN][maxN], h[maxN][maxN], g[maxN][maxN];
int ph[maxN][maxN], pg[maxN][maxN];
void inc(int &x, int y) { (x += y) >= P ? x -= P : 233; }
void dec(int &x, int y) { (x -= y) < 0 ? x += P : 233; }
int solve() {
if (n == 1 && m == 1) return 1;
memset(suf, 0, sizeof(suf));
memset(dow, 0, sizeof(dow));
for (int i = 1; i <= n; ++i) {
suf[i][m + 1] = 0;
for (int j = m; j >= 0; --j) suf[i][j] = suf[i][j + 1] + (b[i][j] == 'R');
}
for (int j = 1; j <= m; ++j) {
dow[n + 1][j] = 0;
for (int i = n; i >= 0; --i) dow[i][j] = dow[i + 1][j] + (b[i][j] == 'R');
}
memset(h, 0, sizeof(h));
memset(g, 0, sizeof(g));
h[1][1] = g[1][1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (i > 1) {
h[i][j] = g[i - 1][j];
ph[i][j] = ph[i - 1][j];
if (ph[i][j] == 0) ph[i][j] = 1;
while (ph[i][j] < i && dow[ph[i][j] + 1][j] > n - i) ++ph[i][j];
dec(h[i][j], g[ph[i][j] - 1][j]);
}
inc(h[i][j], h[i][j - 1]);
if (j > 1) {
g[i][j] = h[i][j - 1];
pg[i][j] = pg[i][j - 1];
if (pg[i][j] == 0) pg[i][j] = 1;
while (pg[i][j] < j && suf[i][pg[i][j] + 1] > m - j) ++pg[i][j];
dec(g[i][j], h[i][pg[i][j] - 1]);
}
inc(g[i][j], g[i - 1][j]);
}
}
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
dec(h[i][j], h[i][j - 1]), dec(g[i][j], g[i - 1][j]);
for (int i = 1; i <= n; ++i)
;
;
for (int i = 1; i <= n; ++i)
;
;
int i = n, j = m;
long long ans = h[i][j] + g[i][j];
return (ans % P + P) % P;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; ++i) cin >> (b[i] + 1);
cout << solve() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
vector<int> parent;
long long ans1 = 0;
int find(int x) {
if (parent[x] != x) parent[x] = find(parent[x]);
return parent[x];
}
void Union(int u, int v, vector<int>& rank) {
u = find(u);
v = find(v);
if (rank[u] < rank[v]) swap(u, v);
ans1 -= (long long)rank[u] * (rank[u] - 1) / 2;
ans1 -= (long long)rank[v] * (rank[v] - 1) / 2;
rank[u] += rank[v];
ans1 += (long long)(rank[u]) * (rank[u] - 1) / 2;
parent[v] = u;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
vector<pair<int, pair<int, int>>> adj(n - 1);
for (int i = 0; i < n - 1; i++) {
cin >> adj[i].second.first >> adj[i].second.second >> adj[i].first;
adj[i].second.first--;
adj[i].second.second--;
}
vector<pair<int, int>> q(m);
for (int i = 0; i < m; i++) {
cin >> q[i].first;
q[i].second = i;
}
sort(q.begin(), q.end());
sort(adj.begin(), adj.end());
int j = 0;
parent = vector<int>(n, 0);
vector<int> rank(n, 1);
for (int i = 0; i < n; i++) parent[i] = i;
long long ans[m];
for (int i = 0; i < m; i++) {
while (j < n - 1 && adj[j].first <= q[i].first) {
int u = adj[j].second.first;
int v = adj[j].second.second;
Union(u, v, rank);
j++;
}
ans[q[i].second] = ans1;
}
for (int i = 0; i < m; i++) cout << ans[i] << " ";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
const int MXN = 1e6 + 5;
const long long MNN = 1e5 + 1;
const long long MOD = 1000000007;
const long long INF = 1e18;
const int OO = 1e9 + 500;
using namespace std;
long long n, cnt[MXN], num[MXN], up[MXN];
long long ans;
vector<pair<long long, long long> > g[MXN];
map<int, bool> mp;
void dfs(int x, int p) {
cnt[x] = 1;
for (auto i : g[x]) {
if (i.first == p) continue;
dfs(i.first, x);
if (mp[i.second] == 1) {
num[x] += cnt[i.first];
} else {
num[x] += num[i.first];
}
cnt[x] += cnt[i.first];
}
}
void dfs1(int x, int p) {
for (auto i : g[x]) {
if (i.first == p) continue;
if (mp[i.second] == 1) {
up[i.first] = n - cnt[i.first];
} else {
up[i.first] = up[x] + num[x] - num[i.first];
}
dfs1(i.first, x);
}
}
void goodNum(long long t) {
if (t > OO) {
return;
}
mp[t] = 1;
goodNum(t * 10 + 4);
goodNum(t * 10 + 7);
}
int main() {
ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
goodNum(0);
dfs(1, 0);
dfs1(1, 0);
for (int i = 1; i <= n; i++) {
ans += num[i] * (num[i] - 1);
ans += up[i] * (up[i] - 1);
ans += 2 * up[i] * num[i];
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int s[4005], dp[2005];
vector<int> v;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> s[i];
v.clear();
for (int i = 1; i <= 2 * n; i++) {
int j = i;
while (j + 1 <= 2 * n && s[j + 1] < s[i]) j++;
v.push_back(j - i + 1);
i = j;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) dp[i] = 0;
for (int i : v)
for (int j = n; j >= i; j--) dp[j] |= dp[j - i];
cout << (dp[n] ? "YES" : "NO") << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
int dp[100005][2];
vector<int> vis;
bool draw = 0;
stack<int> ans;
int dfs(int s, int ch) {
if (dp[s][ch] == 2) draw = 1;
vis[s] = 1;
if (dp[s][ch] == -1) {
vector<int>::iterator it = g[s].begin();
dp[s][ch] = 2;
int u = 0;
for (; it != g[s].end(); it++) {
int y = dfs(*it, ch ^ 1);
if (y == 1) {
ans.push(s);
return dp[s][ch] = 1;
}
u++;
}
if (u == 0 && ch == 1) {
ans.push(s);
return 1;
}
dp[s][ch] = 0;
return dp[s][ch];
} else
return dp[s][ch];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
g.resize(n + 1);
vis.resize(n + 1, 0);
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
for (int j = 0; j < c; j++) {
int v;
cin >> v;
g[i].push_back(v);
}
}
int s;
cin >> s;
dfs(s, 0);
if (ans.size() != 0) {
cout << "Win"
<< "\n";
while (!ans.empty()) {
cout << ans.top() << " ";
ans.pop();
}
} else if (draw)
cout << "Draw";
else
cout << "Lose";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
int main() {
cin >> m >> n;
cout << m * n / 2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100100, LG = 18;
int n, head[MAX], to[MAX * 2], nxt[MAX * 2], Ecnt, par[MAX][LG], dpth[MAX];
class Node {
public:
int A[11], sz;
Node() {
memset(A, 100, sizeof A);
sz = 0;
}
void insert(int v) {
if (v > MAX || binary_search(A, A + 11, v)) return;
A[10] = v;
sort(A, A + 11);
sz++;
}
void print(int c) {
c = min(c, sz);
printf("%d", c);
for (int i = 0; i < c; i++) printf(" %d", A[i]);
puts("");
}
} sparse[MAX][LG];
Node merge(Node v, Node u) {
for (int i = 0; i < 10; i++) v.insert(u.A[i]);
return v;
}
void addedge(int a, int b) {
nxt[Ecnt] = head[a];
head[a] = Ecnt;
to[Ecnt++] = b;
}
void ini() {
Ecnt = 0;
memset(head, -1, (n + 1) * sizeof head[0]);
}
void dfs(int v, int p, int d) {
dpth[v] = d;
par[v][0] = p;
for (int j = 1; j < LG; j++) {
par[v][j] = par[par[v][j - 1]][j - 1];
sparse[v][j] = merge(sparse[v][j - 1], sparse[par[v][j - 1]][j - 1]);
}
for (int i = head[v]; i != -1; i = nxt[i])
if (to[i] != p) dfs(to[i], v, d + 1);
}
int lca(int v, int u) {
if (dpth[v] > dpth[u]) swap(v, u);
int d = dpth[u] - dpth[v];
for (int i = 0; i < LG; i++)
if (d & (1 << i)) {
u = par[u][i];
d -= 1 << i;
}
for (int i = LG - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
if (u != v) u = par[u][0];
return u;
}
Node getIDs(int v, int p) {
Node ret;
int d = dpth[v] - dpth[p];
for (int i = 0; i < LG; i++)
if (d & (1 << i)) {
ret = merge(ret, sparse[v][i]);
v = par[v][i];
d -= 1 << i;
}
return merge(ret, sparse[v][d]);
;
}
int main() {
int q, a, b, k, m;
scanf("%d%d%d", &n, &m, &q);
ini();
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
addedge(a, b);
addedge(b, a);
}
for (int i = 1; i <= m; i++) {
int c;
scanf("%d", &c);
sparse[c][0].insert(i);
}
dfs(1, 0, 1);
while (q--) {
scanf("%d%d%d", &a, &b, &k);
int l = lca(a, b);
merge(getIDs(a, l), getIDs(b, l)).print(k);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Ntest = 1e5 + 5;
long long gcd(long long a, long long b) {
long long temp;
while (b > 0) {
temp = a % b;
a = b;
b = temp;
}
return a;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long fpow(long long b, long long exp, long long mod) {
if (exp == 0) return 1;
long long t = fpow(b, exp / 2, mod);
if (exp & 1) return t * t % mod * b % mod;
return t * t % mod;
}
long long divmod(long long i, long long j, long long mod) {
i %= mod, j %= mod;
return i * fpow(j, mod - 2, mod) % mod;
}
clock_t time_p = clock();
void TimeTaken() {
time_p = clock() - time_p;
cerr << "Completion time : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
void solve() {
int n;
cin >> n;
int count = 0;
for (int i = 1; i < n; i++) {
if (n % i == 0) count++;
}
cout << count;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 15;
int n, a;
string solve() {
map<int, int> m;
cin >> n;
for (int i = 0, ggdem = n; i < ggdem; i++) cin >> a, m[a]++;
for (int i = 0, ggdem = 20; i < ggdem; i++) {
if ((1 << i) == 2048) {
if (m[1 << i]) return "YES";
return "NO";
}
while (m[1 << i] > 1) {
m[1 << i] -= 2;
m[1 << (i + 1)]++;
}
}
assert(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) cout << solve() << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
const double Eps = 1e-12;
struct Point {
double x, y;
Point(double _x = 0, double _y = 0) { x = _x, y = _y; }
};
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
double operator*(Point A, Point B) { return A.x * B.y - A.y * B.x; }
bool operator==(Point A, Point B) { return A.x == B.x & A.y == B.y; }
int dcmp(double v) {
if (fabs(v) < Eps) return 0;
return v > 0 ? 1 : -1;
}
struct Line {
Point a, b;
double an;
int num;
Line(Point _a = 0, Point _b = 0, double _an = 0, int _num = 0) {
a = _a, b = _b, an = _an, num = _num;
}
};
bool operator==(Line A, Line B) { return A.a == B.a & A.b == B.b; }
Line c[N], q[N], s[N];
int top(0);
bool be[N];
bool cmp2(Line A, Line B) { return A.num < B.num; }
bool cmp1(Line A, Line B) {
if (!dcmp(A.an - B.an)) return dcmp((B.b - A.a) * (B.a - A.a)) > 0;
return A.an < B.an;
}
Point Cross(Line A, Line B) {
double ts = (B.b - B.a) * (A.a - B.a) / ((A.b - A.a) * (B.b - B.a));
return Point(A.a.x + ts * (A.b.x - A.a.x), A.a.y + ts * (A.b.y - A.a.y));
}
bool Check(Line A, Line B, Line C) {
Point now = Cross(A, B);
return dcmp((C.b - now) * (C.a - now)) > 0;
}
int main() {
int n;
register int i;
double Ra, Rb;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
c[i].num = i;
scanf("%lf%lf", &Ra, &Rb);
c[i].a = Point(-Rb, 2 * Ra - Rb);
c[i].b = Point(Rb, Rb);
c[i].an = atan2((c[i].b.y - c[i].a.y), (c[i].b.x - c[i].a.x));
}
c[++n] = Line(Point(Eps, 1), Point(Eps, 0), 0, 0);
c[n].an = atan2((c[n].b.y - c[n].a.y), (c[n].b.x - c[n].a.x));
c[++n] = Line(Point(0, 0), Point(1, 1 + Eps), 0, 0);
c[n].an = atan2((c[n].b.y - c[n].a.y), (c[n].b.x - c[n].a.x));
sort(c + 1, c + n + 1, cmp1);
int k = 0;
c[0].an = 0;
for (i = 1; i <= n; ++i) {
if (c[i].an != c[i - 1].an) ++k;
s[k] = c[i];
}
q[++top] = s[1], q[++top] = s[2];
for (i = 1; i <= k; ++i)
if (i > 2) {
for (; top > 1 & Check(q[top], q[top - 1], s[i]); top--)
;
q[++top] = s[i];
}
for (i = 1; i <= top; ++i) be[q[i].num] = 1;
for (i = n - 1; i >= 1; --i)
if (be[c[i + 1].num] & c[i] == c[i + 1]) be[c[i].num] = 1;
for (i = 1; i <= n; ++i)
if (be[i]) printf("%d ", i);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;
long long n, i, j;
vector<long long> m;
bool viv = false;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
sort(s.begin(), s.end());
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[50 + 5];
bool Sum[(int)1e4 * 50 + 5];
vector<int> vec;
int main() {
int N, D, ans = 0, maxi = 0, tot = 0;
scanf("%d %d", &N, &D);
for (int i = 0; i < N; i++) {
scanf("%d", &arr[i]);
tot += arr[i];
}
Sum[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = tot - arr[i]; j >= 0; j--)
if (Sum[j] && !Sum[j + arr[i]]) {
vec.push_back(j + arr[i]);
Sum[j + arr[i]] = 1;
}
}
sort(vec.begin(), vec.end());
while (1) {
int low = lower_bound(vec.begin(), vec.end(), maxi + D) - vec.begin();
if (low == (int)vec.size() || vec[low] > maxi + D) low--;
if (vec[low] <= maxi || vec[low] > maxi + D) break;
maxi = vec[low];
ans++;
}
printf("%d %d\n", maxi, ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007LL;
long long int fastpow(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % MOD;
base = (base * base) % MOD;
exp /= 2;
}
return res % MOD;
}
bool isprime[1000005] = {false};
long long int lpf[1000005];
vector<long long int> prims;
void sieve() {
isprime[1] = true;
lpf[1] = 1;
lpf[2] = 2;
isprime[2] = false;
for (long long int i = 2; i <= 1000005; ++i) {
if (isprime[i] == false) {
prims.push_back(i);
lpf[i] = i;
for (long long int j = i + i; j <= 1000005; j += i) {
lpf[j] = i;
isprime[j] = true;
}
}
}
}
template <typename T>
T mult(T x, T y, T mod) {
return (((x % mod) * (y % mod)) % mod);
}
template <typename T>
T add(T x, T y, T mod) {
return (((x % mod) + (y % mod)) % mod);
}
template <typename T>
T gcd(T x, T y) {
return (!y ? x : gcd(y, x % y));
}
template <typename T>
T lcm(T x, T y) {
return ((x * y) / gcd(x, y));
}
int solveit();
int32_t main() {
solveit();
return 0;
}
int solveit() {
long long int Numb, XO, YO;
cin >> Numb;
vector<pair<long long int, long long int> > vecA, vecB;
for (long long int i = 0; i < Numb; i++) {
cin >> XO >> YO;
vecA.push_back({XO, YO});
}
for (long long int i = 0; i < Numb; i++) {
cin >> XO >> YO;
vecB.push_back({XO, YO});
}
map<pair<long long int, long long int>, long long int> make_pair;
for (long long int i = 0; i < Numb; i++) {
for (long long int j = 0; j < Numb; j++) {
XO = vecB[j].first + vecA[i].first + 0;
YO = vecB[j].second;
make_pair[{XO, YO + vecA[i].second}]++;
YO += vecA[i].second;
}
}
for (auto itr : make_pair) {
if (itr.second == Numb) {
return cout << itr.first.first << " " << itr.first.second, 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[1000010];
int ans = 0, M = 0;
scanf("%s", s);
for (int i = 0; i < strlen(s); i++) {
if (s[i] == 'M')
M++;
else if (M) {
ans++;
ans = ans > M ? ans : M;
}
}
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
void precalc() {}
const int maxn = 2e5 + 10;
struct tree {
int x[4 * maxn];
int mx;
int n;
void build(int _n, int _mx) {
for (n = 1; n < _n; n <<= 1)
;
mx = _mx;
memset(x, 0, sizeof(x));
}
void set(int pos, int val) {
int j = n + pos;
x[j] = min(mx, x[j] + val);
for (j >>= 1; j > 0; j >>= 1) {
x[j] = x[2 * j] + x[2 * j + 1];
}
}
int get(int v, int L, int R, int l, int r) {
if (L >= r || l >= R) {
return 0;
}
if (l <= L && R <= r) {
return x[v];
}
int M = (L + R) / 2;
return get(2 * v, L, M, l, r) + get(2 * v + 1, M, R, l, r);
}
int get(int l, int r) {
if (l >= r) {
return 0;
}
return get(1, 0, n, l, r);
}
} ta, tb;
int n, k, a, b, q;
bool read() {
if (scanf("%d%d%d%d%d", &n, &k, &a, &b, &q) < 5) {
return false;
}
return true;
}
void solve() {
ta.build(n, a);
tb.build(n, b);
for (int i = 0; i < q; ++i) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int d, x;
scanf("%d%d", &d, &x);
d--;
ta.set(d, x);
tb.set(d, x);
} else {
assert(tp == 2);
int p;
scanf("%d", &p);
--p;
int res = tb.get(0, p) + ta.get(p + k, n);
printf("%d\n", res);
}
}
}
int main() {
srand(rdtsc());
precalc();
while (true) {
if (!read()) {
break;
}
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int func(string &t, string &p) {
int c = 0;
for (int i = 0; i < t.length() && c < p.length(); i++) {
if (t[i] == p[c]) c++;
}
if (c == p.length()) return 1;
return 0;
}
int main() {
string t;
string p;
cin >> t >> p;
int n = t.length();
vector<int> v(n);
int ans = 0;
for (int i = 0; i < n; i++) cin >> v[i];
int mi = 0, ma = n - 1;
string k;
while (mi <= ma) {
k = t;
int mid = (mi + ma) / 2;
for (int i = 0; i <= mid; i++) k[v[i] - 1] = '0';
if (func(k, p)) {
ans = mid + 1;
mi = mid + 1;
} else {
ma = mid - 1;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long int n;
cin >> n;
if (n % 3 == 0)
cout << n / 3 << " " << n / 3 << endl;
else if (n % 3 == 1)
cout << (n / 3 + 1) << " " << n / 3 << endl;
else
cout << (n / 3) << " " << (n / 3 + 1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long combinatorial(long long x1, long long x2) {
long long sum = 1, sum2 = 1;
long long i;
for (i = x1; i > x1 - x2; i--) sum *= i;
for (i = 1; i <= x2; i++) sum2 *= i;
return sum / sum2;
}
int main() {
long long int i, n, v[100000], count, x[3];
while (scanf("%lld", &n) != EOF) {
for (i = 0; i < n; i++) scanf("%lld", &v[i]);
sort(v, v + n);
count = 0;
if (v[0] == v[1] && v[1] == v[2]) {
for (i = 0; i < n; i++) {
if (v[i] == v[0]) count++;
}
printf("%lld\n", combinatorial(count, 3));
continue;
} else if (v[0] == v[1]) {
for (i = 0; i < n; i++) {
if (v[i] == v[2]) count++;
}
printf("%lld\n", count);
continue;
} else if (v[1] == v[2]) {
for (i = 0; i < n; i++) {
if (v[i] == v[1]) count++;
}
printf("%lld\n", combinatorial(count, 2));
continue;
} else if (v[0] != v[1] && v[1] != v[2]) {
for (i = 0; i < n; i++) {
if (v[i] == v[2]) count++;
}
printf("%lld\n", count);
continue;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N = 2e5 + 5;
int n;
int a[N];
int32_t main()
{
IOS;
int t;
cin >> t;
while(t--)
{
cin >> n;
int ans = 0, sum = 0;
for(int i = 1; i <= n; i++)
{
cin >> a[i];
sum += a[i];
}
sort(a + 1, a + n + 1);
for(int i = 1; i <= n; i++)
{
int mx = a[n];
if(i == n)
mx = a[n - 1];
int reqd = mx * (n - 1) - (sum - a[i]);
int have = a[i];
if(have <= reqd)
ans = max(ans, reqd - have);
else
{
have -= reqd;
ans = max(ans, (n - 1 - (have % (n - 1))) % (n - 1));
}
}
cout << ans << endl;
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
struct bien1 {
int x, y;
};
struct bien {
int sl;
int itest;
bien1 a[110];
};
bien d[200010];
int n;
long long a[200010];
int kq;
void timkhoang() {
for (int i = 1; i < 100000; i++) {
long long gt1 = (long long)i * i;
for (int j = (i + 1); j <= (i + 500); j++) {
long long gt2 = (long long)j * j;
long long can = gt2 - gt1;
if (can > 200000) break;
if (d[can].itest == 1) {
d[can].a[d[can].sl].x = i;
d[can].a[d[can].sl].y = j;
d[can].sl++;
}
}
}
}
void solve() {
timkhoang();
kq = 1;
long long minn = 0;
for (int i = 2; i <= n; i += 2) {
long long gt = -1;
long long maxx = -1;
if (d[a[i]].itest != 1) {
kq = -1;
return;
}
for (int j = 0; j < d[a[i]].sl; j++) {
long long x = d[a[i]].a[j].x;
x = x * x;
long long y = d[a[i]].a[j].y;
y = y * y;
if (x > minn) {
if (y < maxx || maxx == -1) {
maxx = y;
gt = x - minn;
}
}
}
if (gt == -1) {
kq = -1;
return;
}
a[i - 1] = gt;
minn = maxx;
}
}
void output() {
if (kq == -1)
printf("No\n");
else {
printf("Yes\n");
for (int i = 1; i <= n; i++) printf("%I64d ", a[i]);
}
}
int main() {
while (scanf("%d", &n) > 0) {
for (int i = 2; i <= n; i += 2) {
scanf("%I64d", &a[i]);
d[a[i]].itest = 1;
d[a[i]].sl = 0;
}
solve();
output();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int dest, back;
long long f, c;
};
struct PushRelabel {
vector<vector<Edge>> g;
vector<long long> ec;
vector<Edge*> cur;
vector<vector<int>> hs;
vector<int> H;
PushRelabel(int n) : g(n), ec(n), cur(n), hs(2 * n), H(n) {}
void add_edge(int s, int t, long long cap, long long rcap = 0) {
if (s == t) return;
Edge a = {t, (int)(g[t]).size(), 0, cap};
Edge b = {s, (int)(g[s]).size(), 0, rcap};
g[s].push_back(a);
g[t].push_back(b);
}
void add_flow(Edge& e, long long f) {
Edge& back = g[e.dest][e.back];
if (!ec[e.dest] && f) hs[H[e.dest]].push_back(e.dest);
e.f += f;
e.c -= f;
ec[e.dest] += f;
back.f -= f;
back.c += f;
ec[back.dest] -= f;
}
long long maxflow(int s, int t) {
int v = (int)(g).size();
H[s] = v;
ec[t] = 1;
vector<int> co(2 * v);
co[0] = v - 1;
for (int i = 0; i < (v); ++i) cur[i] = g[i].data();
for (auto& e : g[s]) add_flow(e, e.c);
for (int hi = 0;;) {
while (hs[hi].empty())
if (!hi--) return -ec[s];
int u = hs[hi].back();
hs[hi].pop_back();
while (ec[u] > 0)
if (cur[u] == g[u].data() + (int)(g[u]).size()) {
H[u] = 1e9;
for (auto& e : g[u])
if (e.c && H[u] > H[e.dest] + 1) H[u] = H[e.dest] + 1, cur[u] = &e;
if (++co[H[u]], !--co[hi] && hi < v)
for (int i = 0; i < (v); ++i)
if (hi < H[i] && H[i] < v) --co[H[i]], H[i] = v + 1;
hi = H[u];
} else if (cur[u]->c && H[u] == H[cur[u]->dest] + 1)
add_flow(*cur[u], min(ec[u], cur[u]->c));
else
++cur[u];
}
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> xa(m), xb(m), ya(m), yb(m);
set<int> xv, yv;
for (int i = 0; i < m; i++) {
cin >> xa[i] >> ya[i] >> xb[i] >> yb[i];
xa[i]--;
ya[i]--;
xv.insert(xa[i]);
xv.insert(xb[i]);
yv.insert(ya[i]);
yv.insert(yb[i]);
}
xv.insert(0);
xv.insert(n);
yv.insert(0);
yv.insert(n);
vector<int> xl, yl;
for (int x : xv) {
xl.push_back(x);
}
for (int y : yv) {
yl.push_back(y);
}
int a = (int)xl.size() - 1;
int b = (int)yl.size() - 1;
PushRelabel flow(a + b + 2);
for (int i = 0; i < a; i++) {
flow.add_edge(a + b, i, xl[i + 1] - xl[i]);
}
for (int i = 0; i < b; i++) {
flow.add_edge(i + a, a + b + 1, yl[i + 1] - yl[i]);
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
bool needs = false;
for (int c = 0; c < m; c++) {
if (xl[i + 1] <= xa[c] || xb[c] <= xl[i]) continue;
if (yl[j + 1] <= ya[c] || yb[c] <= yl[j]) continue;
needs = true;
}
if (needs) {
flow.add_edge(i, j + a, 1e16);
}
}
}
cout << flow.maxflow(a + b, a + b + 1) << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
if (n % 2) {
cout << "black";
} else {
cout << "white\n1 2";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100000 + 5], u[100000 + 5], p[100000 + 5], r[100000 + 5];
int main() {
int n, b;
cin >> n;
a[1] = 0;
for (int i = 2; i <= n; i++) {
for (int k = 2; 2 * i - k * (k - 1) > 0; k++)
if ((2 * i - k * (k - 1)) % (2 * k) == 0) {
b = (2 * i - k * (k - 1)) / (2 * k);
int e = p[b + k - 1] ^ p[b - 1];
u[e] = i;
if (e == 0 && r[i] == 0) r[i] = k;
}
int m = 0;
while (u[m] == i) m++;
a[i] = m;
p[i] = p[i - 1] ^ m;
}
cout << (a[n] == 0 ? -1 : r[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 2e5 + 30;
struct SuffixArray {
vector<int> sa, lcp;
SuffixArray(const vector<int> &xx, int lim = 100030) {
int n = ((int)(xx).size()) + 1, k = 0, a, b;
vector<int> x((xx).begin(), (xx).end() + 1), y(n), ws(max(n, lim)), rank(n);
x.back() = 0;
sa = lcp = y, iota((sa).begin(), (sa).end(), 0);
for (int j = 0, p = 0; p < n; j = max(1, j * 2), lim = p) {
p = j, iota((y).begin(), (y).end(), n - j);
for (int i = (0); i < (n); ++i)
if (sa[i] >= j) y[p++] = sa[i] - j;
fill((ws).begin(), (ws).end(), 0);
for (int i = (0); i < (n); ++i) ws[x[i]]++;
for (int i = (1); i < (lim); ++i) ws[i] += ws[i - 1];
for (int i = n; i--;) sa[--ws[x[y[i]]]] = y[i];
swap(x, y), p = 1, x[sa[0]] = 0;
for (int i = (1); i < (n); ++i)
a = sa[i - 1], b = sa[i],
x[b] = (y[a] == y[b] && y[a + j] == y[b + j]) ? p - 1 : p++;
}
for (int i = (1); i < (n); ++i) rank[sa[i]] = i;
for (int i = 0, j; i < n - 1; lcp[rank[i++]] = k)
for (k &&k--, j = sa[rank[i] - 1]; xx[i + k] == xx[j + k]; k++)
;
}
};
int n, K, L[N], id[N], cnt[N], D[N], top, near[N], lz[N << 2];
ll ans[N];
void dolz(int id, int l, int r) {
if (l == r || !lz[id]) return;
if (l != r)
lz[id << 1] = max(lz[id << 1], lz[id]),
lz[(id << 1) | 1] = max(lz[(id << 1) | 1], lz[id]);
lz[id] = 0;
}
void update(int id, int l, int r, int L, int R, int v) {
dolz(id, l, r);
if (l > R || r < L) return;
if (L <= l && r <= R) {
lz[id] = max(lz[id], v);
dolz(id, l, r);
return;
}
int m = (l + r) >> 1;
update(id << 1, l, m, L, R, v);
update((id << 1) | 1, m + 1, r, L, R, v);
}
void cal(int id, int l, int r) {
dolz(id, l, r);
if (l == r) {
cnt[l] = lz[id];
return;
}
int m = (l + r) >> 1;
cal(id << 1, l, m);
cal((id << 1) | 1, m + 1, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> K;
vector<int> tem;
int nn = 26;
string t;
for (int i = (1); i <= (n); ++i) {
string s;
cin >> s;
for (int j = (0); j < (((int)(s).size())); ++j) {
id[((int)(tem).size())] = i;
tem.emplace_back((s[j] - 'a') + 1);
}
if (i < n) tem.emplace_back(nn + 1), nn++;
if (K == 1) ans[i] = ((int)(s).size()) * 1LL * (((int)(s).size()) + 1) / 2;
t += s + '#';
}
if (K == 1) {
for (int i = (1); i <= (n); ++i) cout << ans[i] << ' ';
return 0;
}
SuffixArray SA(tem);
nn = ((int)(tem).size());
int l = 1, numd = 0;
for (int i = (1); i <= (nn); ++i)
if (id[SA.sa[i]]) {
if (++cnt[id[SA.sa[i]]] == 1) numd++;
while (l < i && (!id[SA.sa[l]] || numd > K ||
(numd == K && id[SA.sa[l]] && cnt[id[SA.sa[l]]] > 1))) {
if (id[SA.sa[l]] && --cnt[id[SA.sa[l]]] == 0) numd--;
l++;
}
if (numd == K) near[i] = l;
}
D[0] = 0;
for (int i = (1); i <= (nn); ++i) {
while (top && SA.lcp[D[top]] >= SA.lcp[i]) top--;
L[i] = D[top] + 1;
D[++top] = i;
}
D[0] = nn + 1;
top = 0;
for (int i = (nn); i >= (1); --i) {
while (top && SA.lcp[D[top]] >= SA.lcp[i]) top--;
int r = D[top] - 1;
if (near[r] >= L[i] - 1) update(1, 1, nn, max(1, L[i] - 1), r, SA.lcp[i]);
D[++top] = i;
}
cal(1, 1, nn);
for (int i = (1); i <= (nn); ++i) ans[id[SA.sa[i]]] += cnt[i];
for (int i = (1); i <= (n); ++i) cout << ans[i] << ' ';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
long long n, arr[N], dp[N][2];
long long fun(long long i, long long flag) {
if (i > n) {
return 0;
}
if (dp[i][flag] != -1) {
return dp[i][flag];
}
if (flag == 1) {
return dp[i][flag] =
max(arr[i] + fun(i + 1, (long long)2), fun(i + 1, (long long)1));
} else {
return dp[i][flag] =
min(arr[i] + fun(i + 1, (long long)2), fun(i + 1, (long long)1));
}
}
long long power_mod(long long x, long long y) {
x %= 1000000007;
long long res = 1;
while (y) {
if (y & 1) {
res = (res * x) % 1000000007;
}
y /= 2;
x = (x * x) % 1000000007;
}
return res;
}
void solve() {
long long total = 0;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
total += arr[i];
}
memset(dp, -1, sizeof(dp));
fun((long long)1, (long long)1);
cout << total - dp[1][1] << " " << dp[1][1] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
long long int nC2(long long int n) { return (n * (n - 1)) / 2; }
long long int nC3(long long int n) { return (n * (n - 1) * (n - 2)) / 6; }
long long int bad_triangles(long long int a, long long int b, long long int c,
long long int l) {
long long int i, bad = 0, val;
for (i = 0; i < l + 1; ++i) {
val = ((a - (b + c) + i) < (l - i) ? (a - (b + c) + i) : (l - i));
if (val >= 0) bad += nC2(val + 2);
}
return bad;
}
int main() {
long long int a, b, c, l, ans = 0;
scanf("%lld", &a);
scanf("%lld", &b);
scanf("%lld", &c);
scanf("%lld", &l);
ans += nC3(l + 3);
cerr << "ans"
<< ": " << ans << endl;
;
ans -= bad_triangles(a, b, c, l);
cerr << "ans"
<< ": " << ans << endl;
;
ans -= bad_triangles(b, a, c, l);
cerr << "ans"
<< ": " << ans << endl;
;
ans -= bad_triangles(c, b, a, l);
cerr << "ans"
<< ": " << ans << endl;
;
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s[1001000];
int p[1001000];
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
map<int, int> f;
for (int i = (1); i <= (n); ++i) {
cin >> s[i] >> p[i];
if (s[i][1] == 'D')
f[p[i]] = 1;
else
f.erase(p[i]);
}
f[0] = 1;
for (int i = (n); i >= (1); --i) {
if (s[i][1] == 'C') {
auto it = f.lower_bound(p[i]);
if (it == f.begin()) {
f.insert(pair<int, int>(0, 0));
it = f.begin();
} else
it--;
f[p[i]] = it->second;
int bef = it->first;
while (true) {
it = f.end();
if (it == f.begin()) break;
it--;
if (it->first == p[i]) break;
f.erase(it);
}
while (true) {
if (it == f.begin()) break;
if (f.begin()->first == bef) break;
f.erase(f.begin());
}
} else {
auto it = f.lower_bound(p[i]);
if (it == f.begin()) {
f.insert(pair<int, int>(0, 0));
it = f.begin();
} else
it--;
f[it->first] = (f[it->first] + f[p[i]]) % MOD;
f.erase(p[i]);
}
if (f.empty()) {
cout << 0;
return 0;
}
}
cout << f[0];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 777;
int a[N][N];
double f[N][N], p[N][N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++) {
scanf("%d", a[i] + j);
}
}
for (int i = 0; i < (1 << n); i++) {
p[0][i] = 1.0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << n); j++) {
double cur = 0.0;
for (int k = 0; k < (1 << n); k++) {
int meet = j ^ k;
int bits = 0;
while (meet > 0) {
bits++;
meet /= 2;
}
if (bits == i) {
cur += a[j][k] * 0.01 * p[i - 1][k];
}
}
cur *= p[i - 1][j];
p[i][j] = cur;
}
}
for (int i = 0; i < (1 << n); i++) {
f[0][i] = 0.0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << n); j++) {
f[i][j] = 0.0;
for (int k = 0; k < (1 << n); k++) {
int meet = j ^ k;
int bits = 0;
while (meet > 0) {
bits++;
meet /= 2;
}
if (bits == i) {
f[i][j] = max(f[i][j], f[i - 1][k]);
}
}
f[i][j] += f[i - 1][j];
f[i][j] += (1 << (i - 1)) * p[i][j];
}
}
double ans = 0.0;
for (int j = 0; j < (1 << n); j++) {
ans = max(ans, f[n][j]);
}
printf("%.17f\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long maxn = 1005;
const long long mod = 1e9 + 7;
long long n, m;
long long a[maxn][maxn];
long long vis[maxn];
long long rmax[maxn], cmax[maxn];
map<long long, long long> ma;
map<long long, long long> r[maxn], c[maxn];
long long dp[maxn][maxn];
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%lld", &a[i][j]);
int cnt;
for (int i = 1; i <= n; i++) {
ma.clear();
cnt = 0;
for (int j = 1; j <= m; j++) {
if (ma[a[i][j]]) continue;
vis[++cnt] = a[i][j];
ma[a[i][j]] = 1;
}
sort(vis + 1, vis + cnt + 1);
for (int j = 1; j <= cnt; j++) r[i][vis[j]] = j;
rmax[i] = cnt;
}
for (int j = 1; j <= m; j++) {
ma.clear();
cnt = 0;
for (int i = 1; i <= n; i++) {
if (ma[a[i][j]]) continue;
vis[++cnt] = a[i][j];
ma[a[i][j]] = 1;
}
sort(vis + 1, vis + cnt + 1);
for (int i = 1; i <= cnt; i++) c[j][vis[i]] = i;
cmax[j] = cnt;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = max(r[i][a[i][j]] - 1, c[j][a[i][j]] - 1) +
max(rmax[i] - r[i][a[i][j]], cmax[j] - c[j][a[i][j]]) + 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%lld ", dp[i][j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long oo = INT_MAX;
const long long MOD = 1e9 + 7;
const long long sz = 1e5 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long tc = 1;
while (tc--) {
long long n;
cin >> n;
vector<long long> a(n + 1);
for (long long i = 1; i < n + 1; ++i) cin >> a[i];
vector<long long> primes = {2, 3, 5, 7, 11, 13, 17, 19,
23, 29, 31, 37, 41, 43, 47, 53};
vector<long long> fact(61, 0);
for (long long i = 0; i < 61; ++i) {
for (long long j = 0; j < 16; ++j) {
if (!(i % primes[j])) fact[i] |= (1 << j);
}
}
vector<vector<long long>> dp(101, vector<long long>((1 << 16), -1));
vector<vector<long long>> path(101, vector<long long>((1 << 16), -1));
function<long long(long long, long long)> rec = [&](long long idx,
long long mask) {
if (idx > n) return (long long)0;
if (dp[idx][mask] != -1) return dp[idx][mask];
dp[idx][mask] = 1e17;
for (long long i = 1; i < 61; ++i) {
if (mask & fact[i]) continue;
long long cost = rec(idx + 1, mask | fact[i]) + abs(a[idx] - i);
if (cost < dp[idx][mask]) {
dp[idx][mask] = cost;
path[idx][mask] = i;
}
}
return dp[idx][mask];
};
rec(1, 0);
long long mask = 0;
for (long long i = 1; i < n + 1; ++i) {
cout << path[i][mask] << " ";
mask |= fact[path[i][mask]];
}
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int in() {
int n;
scanf("%d", &n);
return n;
}
long long Lin() {
long long n;
scanf("%lld", &n);
return n;
}
double Din() {
double n;
scanf("%lf", &n);
return n;
}
const long long inf = 1e17;
const long long mod = 1e9 + 7;
const int N = 3e6 + 5;
vector<int> g[N], edge;
int a[N], b[N], p[N], day[N], vis[N], t = 1;
map<int, int> idx;
bool kuhn(int u) {
if (vis[u] == t) return false;
vis[u] = t;
for (auto v : g[u]) {
if (p[v] == -1) {
p[v] = u;
return true;
}
}
for (auto v : g[u]) {
if (kuhn(p[v])) {
p[v] = u;
return true;
}
}
return false;
}
int solve() {
int n = in();
for (int i = 1; i <= n; i++) {
a[i] = in(), b[i] = in();
edge.push_back(a[i]), edge.push_back(b[i]);
}
sort(edge.begin(), edge.end());
int m = n + 1;
for (int i = 0; i < edge.size(); i++) {
if (i > 0 && edge[i] != edge[i - 1]) m++;
idx[edge[i]] = m;
day[m] = edge[i];
}
for (int i = 1; i <= n; i++) {
int u = idx[a[i]], v = idx[b[i]];
g[i].push_back(u), g[u].push_back(i), g[i].push_back(v), g[v].push_back(i);
}
int ans = 0;
memset(p, -1, sizeof p);
for (int i = n + 1; i <= m; i++) {
if (kuhn(i)) ans++, t++;
}
if (ans != n) return printf("-1\n");
ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, day[p[i]]);
}
printf("%d\n", ans);
return 0;
}
int main() {
int test = 1;
while (test--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Trie {
int son[2], num;
Trie() {
memset(son, -1, sizeof son);
num = 0;
}
} trie[300010 * 31];
int cnt = 1;
int a[300010];
void Insert(int x) {
int dep = 30, now = 1;
trie[now].num++;
while (dep >= 0) {
int t = (x >> dep) & 1;
if (trie[now].son[t] == -1) trie[now].son[t] = ++cnt;
now = trie[now].son[t];
trie[now].num++;
dep--;
}
}
int Find(int x) {
int dep = 30, now = 1, ans = 0;
trie[now].num--;
while (dep >= 0) {
int t = (x >> dep) & 1, g = now;
if (trie[now].son[t] == -1) {
now = trie[now].son[t ^ 1];
trie[now].num--;
if (!trie[now].num) trie[g].son[t ^ 1] = -1;
ans += (t ^ 1) * (1 << dep);
} else {
now = trie[now].son[t];
trie[now].num--;
if (!trie[now].num) trie[g].son[t] = -1;
ans += t * (1 << dep);
}
dep--;
}
return ans;
}
int main() {
int n, x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
Insert(x);
}
for (int i = 1; i <= n; i++) {
int t = Find(a[i]);
printf("%d ", a[i] ^ t);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s1[200100], s2[200100];
vector<int> pos[26];
long long sum1[27][200100];
long long sum2[27][200100];
int main() {
int n;
scanf("%d", &n);
long long res2 = 0;
for (int i = (1); i < (n + 1); ++i) res2 += (n - i + 1) * 1ll * (n - i + 1);
scanf("%s%s", &s1, &s2);
for (int i = (0); i < (n); ++i) pos[s2[i] - 'A'].push_back(i);
for (int i = (0); i < (26); ++i) {
for (int j = (0); j < (pos[i].size()); ++j) {
sum1[i][j] += pos[i][j] + 1;
if (j) sum1[i][j] += sum1[i][j - 1];
}
for (int j = (int)pos[i].size() - 1; j >= 0; --j) {
sum2[i][j] += n - pos[i][j];
if (j != (int)pos[i].size() - 1) sum2[i][j] += sum2[i][j + 1];
}
}
double res1 = 0;
for (int i = (0); i < (n); ++i) {
int v = s1[i] - 'A';
int l = 0;
int r = (int)pos[v].size() - 1;
int best = -1;
while (l <= r) {
int m = (l + r) / 2;
if (pos[v][m] <= i) {
best = m;
l = m + 1;
} else
r = m - 1;
}
if (best != -1) res1 += (sum1[v][best]) * 1ll * (n - i);
if (res1 < 0) cout << "FAIL" << endl;
best++;
if (best != pos[v].size()) res1 += (sum2[v][best]) * 1ll * (i + 1);
if (res1 < 0) cout << "FAIL" << endl;
}
double res = res1 / (double)res2;
printf("%.15lf\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, flag, cnt, res, i, p;
char str[2010];
int C[2010];
vector<pair<int, int>> V[2 * 2010];
void dfs(int i) {
int j, sz, k, e;
sz = V[i].size();
for (j = 0; j < sz; j++) {
k = V[i][j].first;
e = V[i][j].second;
if (C[k] == -1) {
if (e == 0)
C[k] = C[i];
else
C[k] = 1 - C[i];
dfs(k);
} else if ((e == 0 && C[i] != C[k]) || (e == 1 && C[i] == C[k]))
flag = 1;
}
}
int main() {
scanf("%s", str);
n = strlen(str);
reverse(str, str + n);
for (m = 1; m < n; m++) {
for (i = 0; i < n + m + 2; i++) V[i].clear();
V[n + m].push_back(make_pair(n + m + 1, 1));
V[n + m + 1].push_back(make_pair(n + m, 1));
for (i = 0; i < n - 1 - i; i++) {
V[i].push_back(make_pair(n - 1 - i, 0));
V[n - 1 - i].push_back(make_pair(i, 0));
}
V[n + m - 1].push_back(make_pair(n + m + 1, 0));
V[n + m + 1].push_back(make_pair(n + m - 1, 0));
for (i = 0; i < m - 1 - i; i++) {
V[n + i].push_back(make_pair(n + m - 1 - i, 0));
V[n + m - 1 - i].push_back(make_pair(n + i, 0));
}
for (i = 0; i < m; i++)
if (str[i] == '1') {
V[i].push_back(make_pair(n + i, 1));
V[n + i].push_back(make_pair(i, 1));
} else if (str[i] == '0') {
V[i].push_back(make_pair(n + i, 0));
V[n + i].push_back(make_pair(i, 0));
}
for (i = m; i < n; i++)
if (str[i] == '1') {
V[i].push_back(make_pair(n + m + 1, 0));
V[n + m + 1].push_back(make_pair(i, 0));
} else if (str[i] == '0') {
V[i].push_back(make_pair(n + m, 0));
V[n + m].push_back(make_pair(i, 0));
}
flag = 0;
cnt = 0;
memset(C, -1, sizeof C);
for (i = 0; i < n + m + 2; i++)
if (C[i] == -1) {
C[i] = 0;
dfs(i);
cnt++;
}
if (!flag) {
p = 1;
for (i = 0; i + 1 < cnt; i++) p = 2 * p % 998244353;
res = (res + p) % 998244353;
}
}
printf("%d\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1E-14;
const long long mod = 1000000007;
using namespace std;
int n;
long long m;
int l, r;
int a[55];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
l = 0;
r = n - 1;
long long p = 1LL << (n - 1);
m--;
for (int i = 0; i < n; i++) {
p /= 2;
if (m < p) {
a[l] = i + 1;
l++;
} else {
a[r] = i + 1;
r--;
m -= p;
}
}
for (int i = 0; i < n; i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int MAXN = 100000 * 3 + 10, MAXL = 10 + 2;
map<long long, pair<long long, long long> > f[MAXL];
long long n;
pair<long long, long long> DFS(long long n, int Maxdigt) {
if (n == 0 && Maxdigt == 0) return make_pair(0, 0);
if (n < 10) return make_pair(1LL, -(n - max((long long)Maxdigt, n)));
if (f[Maxdigt].find(n) != f[Maxdigt].end()) return f[Maxdigt][n];
unsigned long long Pow = 1;
long long N = n;
for (; Pow <= N; Pow *= 10)
;
Pow /= 10;
pair<long long, long long> Tohka = make_pair(0, 0);
while (N > 0) {
long long k = N / Pow;
pair<long long, long long> NC = DFS(N % Pow, max(k, (long long)Maxdigt));
Tohka.first += NC.first;
N -= N % Pow + NC.second;
}
Tohka.second = -N;
f[Maxdigt][n] = Tohka;
return Tohka;
}
int main() {
cin >> n;
cout << DFS(n, 0).first << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define INF 1000000000
#define INFLL 0x3f3f3f3f3f3f3f3fLL
#define EPS 10e-9
#define MOD 1000000007
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define st first
#define nd second
#define sz(v) int(v.size())
#define all(X) (X).begin(), (X).end()
#define FOR(I, A, B) for(int I = A; I < B; I++)
#define RFOR(I, A, B) for(int I = A; I >= B; I--)
typedef long long ll;
typedef pair<int,int> ii;
typedef pair<int,ii> iii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
typedef vector<iii> viii;
typedef vector<ll> vll;
int test(int mask){
int ans = 0;
for(int i = 0; i < 9; i++){
if((1<<i) & mask){
ans*=10;
ans+=(1+i);
}
}
return ans;
}
int sum_dig(int val){
int ans = 0;
while(val > 0){
ans += (val%10);
val /= 10;
}
return ans;
}
int solvre(int x){
vector<int> ans;
for(int mask = 0; mask < 1<<10; mask++){
int val = test(mask);
if(sum_dig(val) == x){
ans.pb(val);
}
}
sort(all(ans));
if(sz(ans) == 0) return -1;
return ans[0];
}
int main(){
int t;
cin >> t;
while(t--){
int x;
cin >> x;
cout << solvre(x) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long T, t, n, k, d, i;
int main() {
scanf("%lld", &T);
for (t = 1; t <= T; t++) {
scanf("%lld%lld", &n, &k);
d = n;
for (i = 2; i <= n; i++) {
if (n % i == 0) {
d = i;
break;
}
if (i * i >= n) break;
}
cout << n + d + (2 * (k - 1)) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9';) {
if (ch == '-') f = -1;
ch = getchar();
}
for (; ch >= '0' && ch <= '9';) {
first = first * 10 + ch - '0';
ch = getchar();
}
return first * f;
}
int n, k;
char s[2000010];
int f[2000010];
inline void Up(int &first, int second) {
first += second;
if (first >= 1000000007) first -= 1000000007;
}
int last[2000010];
int main() {
n = read(), k = read();
scanf("%s", s + 1);
f[0] = 1;
int m = strlen(s + 1);
for (int i = 1; i <= n + m; i++) {
f[i] = 1ll * f[i - 1] * 2 % 1000000007;
int c, pos = INT_MAX;
if (i <= m) {
c = s[i] - 'a';
pos = last[c];
} else {
for (int j = 0; j <= k - 1; j++) {
if (last[j] < pos) {
pos = last[j];
c = j;
}
}
}
f[i] = 1ll * (f[i] - f[pos - 1] + 1000000007) % 1000000007;
last[c] = i;
}
printf("%d\n", f[n + m]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1 << 20];
int n, k;
namespace Flow {
const int MAXN = (int)2e4 + 5;
const int INF = (int)1e9;
struct Edge {
int to, f, c, w;
Edge() : to(0), f(0), c(0), w(0) {}
Edge(int to, int c, int w) : to(to), f(0), c(c), w(w) {}
};
vector<int> adj[MAXN];
bool was[MAXN];
int par[MAXN];
int dist[MAXN];
vector<Edge> e;
int L, R, S, T;
void addEdge(int u, int v, int w) {
adj[u].push_back((int)(e).size());
e.push_back(Edge(v, 1, w));
adj[v].push_back((int)(e).size());
e.push_back(Edge(u, 0, -w));
}
void init(int _L, int _R) {
L = _L, R = _R;
S = 0;
T = L + R + 1;
for (int i = 1; i <= L; i++) {
addEdge(S, i, 0);
}
for (int i = 1; i <= R; i++) {
addEdge(L + i, T, 0);
}
}
bool spfa() {
for (int i = S; i <= T; i++) {
dist[i] = -INF;
was[i] = 0;
par[i] = -1;
}
queue<int> q;
dist[S] = 0;
was[S] = 1;
q.push(S);
while (!q.empty()) {
int v = q.front();
q.pop();
was[v] = 0;
for (int id : adj[v]) {
int to = e[id].to, w = e[id].w;
if (e[id].f < e[id].c && dist[to] < dist[v] + w) {
dist[to] = dist[v] + w;
par[to] = id;
if (!was[to]) {
was[to] = 1;
q.push(to);
}
}
}
}
assert(dist[S] == 0);
return dist[T] != -INF;
}
int mcf(int k) {
int flow = 0, res = 0;
while (flow != k) {
if (!spfa()) break;
for (int v = T, id; v != S; v = e[id ^ 1].to) {
id = par[v];
e[id].f++;
e[id ^ 1].f--;
res += e[id].w;
}
flow++;
}
return res;
}
} // namespace Flow
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < (1 << n); i++) {
cin >> a[i];
}
int lim = k * 2 * n;
priority_queue<array<int, 3>> S;
for (int i = 0; i < (1 << n); i++) {
if (__builtin_popcount(i) % 2 == 0) {
for (int b = 0; b < n; b++) {
int j = (i ^ (1 << b));
S.push({-(a[i] + a[j]), i, j});
while ((int)(S).size() > lim) {
S.pop();
}
}
}
}
map<int, int> M0, M1;
int sz0 = 0, sz1 = 0;
vector<array<int, 3>> edges;
while (!S.empty()) {
array<int, 3> cur = S.top();
S.pop();
int w = -cur[0], a = cur[1], b = cur[2];
if (!M0[a]) M0[a] = ++sz0;
if (!M1[b]) M1[b] = ++sz1;
edges.push_back({M0[a], M1[b], w});
}
Flow::init(sz0, sz1);
for (auto &[u, v, w] : edges) {
Flow::addEdge(u, sz0 + v, w);
}
cout << Flow::mcf(k) << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using vi = vector<int>;
using pii = pair<int, int>;
const int mxn = 1000006;
int n, m, s, t;
vi e[mxn];
bool v[mxn];
int p[mxn];
bool ins[mxn];
vector<pii> path[mxn];
int a[mxn][20];
int h[mxn];
void dfs(int x, int p) {
v[x] = true;
h[x] = h[p] + 1;
a[x][0] = p;
::p[x] = p;
for (int i = 1; i < 20; ++i) a[x][i] = a[a[x][i - 1]][i - 1];
for (auto i : e[x])
if (!v[i]) {
dfs(i, x);
}
}
int jump(int x, int d) {
for (int i = 20; i--;)
if (d >> i & 1) x = a[x][i];
return x;
}
int son(int o, int x) { return jump(x, h[x] - h[o] - 1); }
struct Splay {
struct Node {
int p, son[2];
int &operator[](int s) { return son[s]; }
} node[mxn];
int sid(int x) { return x == node[node[x].p][1]; }
void link(int x, int s, int y) {
if (x) node[x][s] = y;
if (y) node[y].p = x;
}
void cut(int x, int s, int y) { node[x][s] = node[y].p = 0; }
void zig(int x) {
int y = node[x].p, s = sid(x);
link(y, s, node[x][!s]);
link(node[y].p, sid(y), x);
link(x, !s, y);
}
int splay(int x, int top = 0) {
while (node[x].p && node[x].p != top) {
int y = node[x].p;
if (node[y].p && node[y].p != top) zig(sid(x) == sid(y) ? y : x);
zig(x);
}
return x;
}
int next(int x, int s = 1) {
for (splay(x), x = node[x][s]; node[x][!s]; x = node[x][!s]) {
}
return splay(x);
}
int ins(int x, int y, int s = 0) {
next(x, s);
link(x, s, y);
return splay(y);
}
bool isleft(int x, int y, int s = 0) {
splay(x, splay(y));
return node[y][s] == x;
}
} Q;
deque<int> q;
vector<pii> edge;
int d[mxn];
bool deb;
void foo(int x, int y) {
vi s;
while (!ins[y]) {
ins[y] = true;
q.push_back(y);
s.push_back(y), y = p[y];
}
assert(x != y);
assert(h[x] < h[y]);
assert((Q.splay(x, Q.splay(y)), Q.node[x].p == y));
if (!Q.isleft(x, y)) {
swap(x, y);
reverse(s.begin(), s.end());
}
int t = x;
for (auto i : s) t = Q.ins(t, i, 1);
}
void check() {
if (count(d + 1, d + n + 1, 0)) {
puts("No");
return;
}
for (int i = 1; i <= n; ++i) {
int c[2] = {};
for (auto j : e[i]) ++c[d[j] > d[i]];
if (i == s && c[0]) {
puts("No");
return;
}
if (i == t && c[1]) {
puts("No");
return;
}
if (i != s && i != t && (!c[0] || !c[1])) {
puts("No");
return;
}
}
puts("Yes");
for (auto i : edge) {
if (d[i.first] < d[i.second])
printf("%d %d\n", i.first, i.second);
else
printf("%d %d\n", i.second, i.first);
}
}
int main() {
int tc;
cin >> tc;
while (tc--) {
scanf("%d%d%d%d", &n, &m, &s, &t);
edge = {};
for (int i = 1; i <= n; ++i) Q.node[i] = {};
Q.ins(s, t, 1);
for (int i = 1; i <= n; ++i) e[i] = {};
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
edge.push_back({x, y});
e[x].push_back(y);
e[y].push_back(x);
}
fill(v, v + n + 1, false);
v[t] = true;
p[t] = 0;
h[t] = 1;
fill(a[t], end(a[t]), 0);
a[t][0] = t;
dfs(s, t);
if (count(v + 1, v + n + 1, false)) {
puts("No");
continue;
}
for (int i = 1; i <= n; ++i) path[i] = {};
for (int i = 1; i <= n; ++i)
for (auto j : e[i])
if (h[j] > h[i] && p[j] != i) {
path[i].push_back({i, j});
}
fill(ins, ins + n + 1, false);
ins[t] = true;
ins[s] = true;
q = {};
q.push_back(s);
q.push_back(t);
while (!q.empty()) {
int x = q.front();
q.pop_front();
for (auto i : path[x]) {
if (ins[son(i.first, i.second)]) {
foo(i.first, i.second);
} else {
assert(i.first == x);
path[son(i.first, i.second)].push_back(i);
}
}
path[x] = {};
}
fill(d, d + n + 1, 0);
int cnt = 0;
for (int i = s; i; i = Q.next(i)) d[i] = ++cnt;
if (!deb) check();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int l, r;
cin >> l >> r;
long long int x = r + 1;
if (x & 1) x++;
if ((l % x) >= (x / 2)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAX_N = int(3e5) + 10;
int p[MAX_N];
struct Event {
int minL, maxL;
int minR, maxR;
Event() {}
Event(int minL, int maxL, int minR, int maxR)
: minL(minL), maxL(maxL), minR(minR), maxR(maxR) {}
};
int nE;
Event events[MAX_N * 2];
vector<Event*> byMinL[MAX_N], byMaxL[MAX_N];
struct Tree {
Tree *pl, *pr;
int l, r;
int add;
int cnt[6];
void update() {
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < 6; ++i) {
cnt[min(i + pl->add, 5)] += pl->cnt[i];
cnt[min(i + pr->add, 5)] += pr->cnt[i];
}
}
Tree(int l, int r) : l(l), r(r), add(0) {
if (l + 1 == r) {
memset(cnt, 0, sizeof cnt);
cnt[0] = 1;
return;
}
pl = new Tree(l, l + r >> 1);
pr = new Tree(l + r >> 1, r);
update();
}
void addIt(int L, int R, int a) {
if (L >= r || l >= R) return;
if (L <= l && R >= r) {
add += a;
return;
}
pl->addIt(L, R, a);
pr->addIt(L, R, a);
update();
}
int calc(int L, int R, int a) {
if (L >= r || l >= R) return 0;
a += add;
if (L <= l && R >= r) {
int ans = 0;
for (int i = 0; i < 5; ++i) {
if (i + a <= 4) ans += cnt[i];
}
return ans;
}
return pl->calc(L, R, a) + pr->calc(L, R, a);
}
} * root;
void addEvent(int a, int b, int c, int d) {
Event& e = events[nE++] = Event(a, b, c, d);
byMinL[e.minL].push_back(&e);
byMaxL[e.maxL].push_back(&e);
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p[i];
--p[i];
}
root = new Tree(0, n);
for (int i = 0; i + 1 < n; ++i) {
int a = p[i], b = p[i + 1];
if (a > b) swap(a, b);
addEvent(0, a, a, b - 1);
addEvent(a + 1, b, b, n - 1);
}
int a = p[0];
addEvent(0, a, a, n - 1);
a = p[n - 1];
addEvent(0, a, a, n - 1);
long long ans = 0;
for (int i = 0; i < n; ++i) {
for (vector<Event*>::iterator it = byMinL[i].begin(); it != byMinL[i].end();
++it) {
Event* e = *it;
root->addIt(e->minR, e->maxR + 1, 1);
}
ans += root->calc(i + 1, n, 0);
for (vector<Event*>::iterator it = byMaxL[i].begin(); it != byMaxL[i].end();
++it) {
Event* e = *it;
root->addIt(e->minR, e->maxR + 1, -1);
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long spf[101];
long long fac[101];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 101; i++) spf[i] = i;
for (long long i = 4; i < 101; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 101; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 101; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0 || y < 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r > n) return 0;
if (r == 0 || r == n) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
long long bit[7][14][100001];
void update(long long ind, long long val, long long type, long long sub) {
while (ind <= 100000) {
bit[type][sub][ind] += val;
ind += ind & (-ind);
}
}
long long get(long long ind, long long type, long long sub) {
long long tot = 0;
while (ind > 0) {
tot += bit[type][sub][ind];
ind -= ind & (-ind);
}
return tot;
}
void solve() {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
for (long long j = 2; j <= 6; j++) {
long long temp = i % (2 * j - 2);
update(i, a[i], j, temp);
}
}
long long m;
cin >> m;
while (m--) {
long long t;
cin >> t;
if (t == 1) {
long long i, val;
cin >> i >> val;
for (long long j = 2; j <= 6; j++) {
long long temp = i % (2 * j - 2);
update(i, -a[i], j, temp);
update(i, val, j, temp);
}
a[i] = val;
} else {
long long l, r, z;
cin >> l >> r >> z;
long long ans = 0, cur = l % (2 * z - 2);
for (long long j = 1; j <= z + z - 2; j++) {
ans += (j <= z ? j : z + z - j) * (get(r, z, cur) - get(l - 1, z, cur));
cur = (cur + 1) % ((2 * z - 2));
}
cout << ans << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test = 1;
while (test--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool o;
char ch, SSS[1 << 17], *A = SSS, *B = SSS;
inline char gc() {
return A == B && (B = (A = SSS) + fread(SSS, 1, 1 << 17, stdin), A == B)
? EOF
: *A++;
}
template <typename _Tp>
inline void rd(_Tp &x);
template <typename _Tq>
inline void wr(_Tq x);
template <typename _Tp>
inline _Tp mx(_Tp x, _Tp y);
template <typename _Tp>
inline _Tp mn(_Tp x, _Tp y);
int n, m, up, x, y;
int opt[300001], type[300001], a[300001], b[300001], c[300001];
int ans[300001];
int s[600001];
int cnt;
struct p {
int opt, x, y, v, id;
} q[600001];
inline void nw(int id, int type, int x, int y, int v = 0) {
cnt++;
q[cnt].id = id;
q[cnt].opt = type;
q[cnt].x = x;
q[cnt].y = y;
q[cnt].v = v;
}
inline void add(int x, int v) {
while (x <= up) {
s[x] += v;
x += ((x) & (-x));
}
}
inline int query(int x) {
int tp = 0;
while (x) {
tp += s[x];
x -= ((x) & (-x));
}
return tp;
}
inline bool cmp(p i, p j) { return i.x != j.x ? i.x < j.x : i.opt == 1; }
inline void solve1(int l, int r) {
if (l == r) return;
int m = (l + r) >> 1;
solve1(l, m), solve1(m + 1, r);
cnt = 0;
for (int i = l; i <= m; i++) {
if (type[i] == 1) {
nw(i, 1, a[i], b[i], 1);
nw(i, 1, a[i] + c[i] + 1, b[i], -1);
}
}
for (int i = m + 1; i <= r; i++) {
if (opt[i] == 2) nw(i, 2, a[i], b[i]);
}
stable_sort(q + 1, q + 1 + cnt, cmp);
for (int i = 1; i <= cnt; i++) {
if (q[i].opt == 1) {
add(q[i].y, q[i].v);
q[i].y = a[q[i].id] + b[q[i].id] + c[q[i].id] + 1;
} else
ans[q[i].id] += query(q[i].y);
}
for (int i = 1; i <= cnt; i++) {
if (q[i].opt == 1)
add(q[i].y, q[i].v);
else
ans[q[i].id] -= query(q[i].x + q[i].y);
}
}
inline void solve2(int l, int r) {
if (l == r) return;
int m = (l + r) >> 1;
solve2(l, m), solve2(m + 1, r);
cnt = 0;
for (int i = l; i <= m; i++) {
if (type[i] == 4) {
nw(i, 1, a[i] - c[i], a[i] + b[i] - c[i], 1);
nw(i, 1, a[i] + 1, a[i] + b[i] - c[i], -1);
}
}
for (int i = m + 1; i <= r; i++) {
if (opt[i] == 2) nw(i, 2, a[i], b[i]);
}
stable_sort(q + 1, q + 1 + cnt, cmp);
for (int i = 1; i <= cnt; i++) {
if (q[i].opt == 1) {
add(q[i].y, q[i].v);
q[i].y = b[q[i].id] + 1;
} else
ans[q[i].id] += query(q[i].x + q[i].y);
}
for (int i = 1; i <= cnt; i++) {
if (q[i].opt == 1)
add(q[i].y, q[i].v);
else
ans[q[i].id] -= query(q[i].y);
}
}
int main() {
rd(n), rd(m), up = n << 1;
for (int i = 1; i <= m; i++) {
rd(opt[i]);
if (opt[i] == 1)
rd(type[i]), rd(a[i]), rd(b[i]), rd(c[i]);
else
rd(a[i]), rd(b[i]);
}
solve1(1, m), solve2(1, m);
for (int i = 1; i <= m; i++) {
x = a[i], y = b[i];
a[i] = y, b[i] = n - x + 1;
if (opt[i] == 1) {
if (type[i] == 1 || type[i] == 4)
type[i] = -1;
else
type[i] = type[i] == 2 ? 4 : 1;
}
}
solve1(1, m), solve2(1, m);
for (int i = 1; i <= m; i++)
if (opt[i] == 2) wr(ans[i]), putchar(10);
}
template <typename _Tp>
inline void rd(_Tp &x) {
o = 0;
x = 0;
while (ch ^ 45 && (ch < 48 || ch > 57)) ch = gc();
if (ch == 45) o = 1, ch = gc();
while (ch > 47 && ch < 58) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = gc();
}
if (o) x = -x;
}
template <typename _Tp>
inline void wr(_Tp x) {
if (x < 0) x = -x, putchar(45);
if (x < 10) {
putchar(x + 48);
return;
}
wr(x / 10);
putchar(x % 10 + 48);
}
template <typename _Tp>
inline _Tp mx(_Tp x, _Tp y) {
return x > y ? x : y;
}
template <typename _Tp>
inline _Tp mn(_Tp x, _Tp y) {
return x < y ? x : y;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, m, x, y, k, i, j, ans = 0, c = 0, sum = 0;
string s;
cin >> n >> k;
vector<long long int> v(n + 1);
std::vector<long long int> vv(n + 1);
for (i = 1; i <= n; i++) {
cin >> v[i];
vv[i] = v[i];
}
ans = LLONG_MIN;
for (i = max(1ll, n - 4 * k); i <= n; i++) {
for (j = i + 1; j <= n; j++) {
long long int more = k * (v[i] | v[j]);
long long int idx = i * j;
ans = max(ans, idx - more);
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100500;
const int MAXK = 1000;
int n;
int block_cnt;
int block_sz;
int l[MAXK], r[MAXK];
char s[MAXN];
int q;
int a[MAXN], b[MAXN];
int lena[MAXN], lenb[MAXN];
char as[5], bs[5];
map<pair<int, int>, int> diff;
map<int, vector<int> > all_block_lft;
map<int, vector<int> > all_block_rght;
set<int> all_q;
int code(const char *s, int len) {
int res = 0;
for (int i = 0; i < 4; ++i) {
int cur_dig = (i >= len) ? 0 : s[i] - 'a' + 1;
res = res * 27 + cur_dig;
}
return res;
}
int main() {
scanf(" %s", s);
n = strlen(s);
block_sz = min(n, int(sqrt(n + 10.) / 5 + 1.) + 1);
block_cnt = (n + block_sz - 1) / block_sz;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf(" %s %s", as, bs);
a[i] = code(as, strlen(as)), b[i] = code(bs, strlen(bs));
lena[i] = strlen(as), lenb[i] = strlen(bs);
diff[make_pair(a[i], b[i])] = diff[make_pair(b[i], a[i])] = 2 * n;
all_q.insert(a[i]);
all_q.insert(b[i]);
}
for (int id = 0; id < block_cnt; ++id) {
int lb = id * block_sz;
int rb = min(n - 1, (id + 1) * block_sz - 1);
for (int fp = lb; fp <= rb; ++fp) {
for (int cnt = 1; cnt <= n - fp && cnt <= 4; ++cnt) {
int a_str = code(s + fp, cnt);
set<int>::iterator s_it = all_q.find(a_str);
if (s_it != all_q.end()) {
{
vector<int> &tmp = all_block_lft[a_str];
if (tmp.empty() || tmp.back() < lb) {
tmp.push_back(fp);
}
}
{
vector<int> &tmp = all_block_rght[a_str];
if (tmp.empty() || tmp.back() < lb) {
tmp.push_back(fp);
} else {
tmp.back() = fp;
}
}
}
for (int sp = fp; sp <= rb; ++sp) {
for (int cnt1 = 1; cnt1 <= n - sp && cnt1 <= 4; ++cnt1) {
int b_str = code(s + sp, cnt1);
map<pair<int, int>, int>::iterator it =
diff.find(make_pair(a_str, b_str));
if (it != diff.end()) {
it->second = min(it->second, max(cnt, sp - fp + cnt1));
}
}
}
}
}
}
for (int i = 0; i < q; ++i) {
int res = min(diff[make_pair(a[i], b[i])], diff[make_pair(b[i], a[i])]);
for (int it = 0; it < 2; ++it) {
vector<int> &ar = all_block_rght[a[i]];
vector<int> &br = all_block_lft[b[i]];
int asz = int(ar.size());
int bsz = int(br.size());
for (int lb = 0, rb = 0; lb < asz; ++lb) {
while (rb < bsz && br[rb] < ar[lb]) ++rb;
if (rb != bsz) {
res = min(res, max(lena[i], br[rb] - ar[lb] + lenb[i]));
}
}
swap(a[i], b[i]);
swap(lena[i], lenb[i]);
}
if (res > n) {
res = -1;
}
printf("%d\n", res);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i, cnt = 0;
for (i = 1; i <= n / 2; i++) {
if (n % i == 0) {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct pinfo {
int k;
vector<int> princ;
} _pinfo;
int main() {
int t;
cin >> t;
int n;
int k;
int x;
while (t--) {
cin >> n;
vector<_pinfo> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].k;
for (int j = 0; j < p[i].k; j++) {
cin >> x;
p[i].princ.push_back(x);
}
}
vector<bool> prince(n, false);
vector<bool> princess(n, false);
for (int i = 0; i < n; i++) {
for (int j = 0; j < p[i].k; j++) {
if (!prince[p[i].princ[j] - 1]) {
prince[p[i].princ[j] - 1] = true;
princess[i] = true;
break;
}
}
}
vector<int> unmarry;
vector<int> princeunmarry;
for (int i = 0; i < n; i++) {
if (!prince[i]) {
princeunmarry.push_back(i);
}
}
for (int i = 0; i < n; i++) {
if (!princess[i]) {
unmarry.push_back(i);
}
}
if (unmarry.size() == 0) {
cout << "OPTIMAL" << '\n';
continue;
} else {
cout << "IMPROVE" << '\n';
int i = 0;
while (i < 1) {
cout << unmarry[i] + 1 << " " << princeunmarry[i] + 1 << '\n';
i++;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 200003;
int n;
int maxspd = INF;
int noa = 0;
int stk[N];
int main() {
scanf("%d", &n);
int ans = 0, spd = 0, top = 0;
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
switch (t) {
case 1:
scanf("%d", &spd);
while (top > 0 && stk[top] < spd) ++ans, --top;
break;
case 2:
if (noa > 0) ans += noa;
noa = 0;
break;
case 3:
scanf("%d", &maxspd);
if (spd > maxspd)
++ans;
else
stk[++top] = maxspd;
break;
case 4:
noa = 0;
break;
case 5:
top = 0;
maxspd = INF;
break;
case 6:
noa++;
break;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, sx, sy, fx, fy, vis[60][60];
char a[60][60];
long long nx[] = {0, 0, -1, 1};
long long ny[] = {-1, 1, 0, 0};
vector<pair<long long, long long> > land1, land2;
bool check(long long x, long long y) {
if (x > n || x < 1 || y > n || y < 1) return 0;
return 1;
}
bool dfs(long long x, long long y) {
bool s = false;
for (int i = 0; i < 4; i++) {
long long r = x + nx[i], c = y + ny[i];
if (check(r, c) && (!vis[r][c])) {
land1.push_back(make_pair(r, c));
vis[r][c] = 1;
s = s | dfs(r, c);
}
}
if (x == fx && y == fy) return true;
return s;
}
void dfs2(long long x, long long y) {
for (int i = 0; i < 4; i++) {
long long r = x + nx[i], c = y + ny[i];
if (check(r, c) && (!vis[r][c])) {
land2.push_back(make_pair(r, c));
vis[r][c] = 1;
dfs2(r, c);
}
}
}
long long dis(pair<long long, long long> x1, pair<long long, long long> x2) {
long long ans = ((x1.first - x2.first) * (x1.first - x2.first)) +
((x1.second - x2.second) * (x1.second - x2.second));
return ans;
}
int main() {
cin >> n;
cin >> sx >> sy >> fx >> fy;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
if (a[i][j] == '1') vis[i][j] = 1;
}
land1.push_back(make_pair(sx, sy));
if (dfs(sx, sy))
cout << 0;
else {
long long mini = 1e18;
land2.push_back(make_pair(fx, fy));
dfs2(fx, fy);
for (int i = 0; i < land1.size(); i++)
for (int j = 0; j < land2.size(); j++) {
long long dist = dis(land1[i], land2[j]);
mini = min(mini, dist);
}
cout << mini;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, MOD = 1e9 + 7, nax = 1000005;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, k, d1, d2;
cin >> n >> k >> d1 >> d2;
if (n % 3 != 0) {
cout << "no\n";
continue;
}
string ans = "no";
for (int s1 = -1; s1 <= 1; s1++) {
for (int s2 = -1; s2 <= 1; s2++) {
if (s1 == 0 || s2 == 0) continue;
long long D1 = d1 * s1;
long long D2 = d2 * s2;
long long x2 = (k - D1 + D2) / 3;
if ((k - D1 + D2) % 3 != 0) {
continue;
}
if (x2 >= 0 && x2 <= k) {
long long x1 = D1 + x2;
long long x3 = x2 - D2;
if (x1 >= 0 && x1 <= k && x3 >= 0 && x3 <= k) {
if (x1 <= n / 3 && x2 <= n / 3 && x3 <= n / 3) {
assert(abs(x1 - x2) == d1);
assert(abs(x2 - x3) == d2);
ans = "yes";
}
}
}
}
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, t, x, y, p, q, i, j, k, e1, e2;
cin >> t;
while (t--) {
cin >> x >> y >> p >> q;
if (x * q == p * y) {
printf("0\n");
continue;
}
if (p == q || !p) {
printf("-1\n");
continue;
}
a = ceil((y - x + 0.0) / (q - p));
e1 = p * a, e2 = q * a;
if (e1 < x) e1 = p * ceil((0.0 + x) / p), e2 = q * ceil((x + 0.0) / p);
printf("%I64d\n", e2 - y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long sum[n];
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
sum[n - 1] = arr[n - 1];
for (int i = n - 2; i >= 0; i--) sum[i] = sum[i + 1] + arr[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += arr[i];
ans += sum[i];
}
ans -= arr[n - 1];
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, w, ans = 0;
vector<string> levels;
int cost(string a, string b) {
int diff = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] != b[i]) diff++;
}
return diff * w;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k >> w;
for (int i = 0; i < k; i++) {
string temp = "", s;
for (int j = 0; j < n; j++) {
cin >> s;
temp = temp + s;
}
levels.push_back(temp);
}
vector<vector<pair<int, int> > > graph(k + 1);
for (int i = 0; i < k; i++) {
graph[0].push_back(make_pair(n * m, i + 1));
for (int j = 0; j < i; j++) {
int temp2 = cost(levels[j], levels[i]);
graph[i + 1].push_back(make_pair(temp2, j + 1));
graph[j + 1].push_back(make_pair(temp2, i + 1));
}
}
int visit[k + 1];
memset(visit, 0, sizeof(visit));
vector<pair<int, int> > answer;
priority_queue<pair<int, pair<int, int> > > pq;
for (int i = 0; i < graph[0].size(); i++) {
pq.push(make_pair(-n * m, make_pair(0, graph[0][i].second)));
}
while (!pq.empty()) {
pair<int, pair<int, int> > temp1 = pq.top();
pq.pop();
int cost1 = -temp1.first, parent = temp1.second.first,
node = temp1.second.second;
if (visit[node] == 1) continue;
ans += cost1;
visit[node] = 1;
answer.push_back(make_pair(node, parent));
for (int i = 0; i < graph[node].size(); i++) {
pq.push(make_pair(-graph[node][i].first,
make_pair(node, graph[node][i].second)));
}
}
cout << ans << "\n";
for (int i = 0; i < answer.size(); i++) {
cout << answer[i].first << " " << answer[i].second << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n = 0;
std::cin >> n;
int k = n / 2;
std::cout << k << '\n';
if (n % 2 == 0) {
for (int i = 0; i < n / 2; i++) std::cout << 2 << ' ';
} else {
for (int i = 0; i < n / 2 - 1; i++) std::cout << 2 << ' ';
std::cout << 3;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t;
cin >> t;
vector<long long> a;
for (long long i = 1; i <= sqrt(1e10); i++) {
a.push_back(i * i);
}
while (t--) {
long long x;
cin >> x;
auto pos = upper_bound(a.begin(), a.end(), x);
if (pos == a.end()) {
cout << "-1\n";
continue;
}
bool ok = 0;
for (long long i = pos - a.begin(); i < a.size(); i++) {
long long n = sqrt(a[i]);
long long l = 1, r = n + 1;
while (r - l > 1) {
long long m = (l + r) >> 1;
if (n * n - (n / m) * (n / m) <= x) {
l = m;
} else {
r = m;
}
}
if (n * n - (n / l) * (n / l) == x) {
cout << n << " " << l << "\n";
ok = 1;
break;
}
}
if (!ok) {
cout << "-1\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, p[111], q[111], s[111], f[111], g[111];
int run(int h[]) {
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 0; i <= k; i++) {
bool same = 1;
for (int j = 1; j <= n; j++)
if (p[j] != s[j]) same = 0;
if (same) return i;
for (int j = 1; j <= n; j++) q[j] = p[h[j]];
for (int j = 1; j <= n; j++) p[j] = q[j];
}
return k + 1;
}
bool ok(int x, int y) {
if (!x || !y) return 0;
if (x == 1 && y == 1) return k == 1;
return x <= k && (x - k) % 2 == 0 || y <= k && (y - k) % 2 == 0;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &f[i]), g[f[i]] = i;
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
int x = run(f), y = run(g);
if (ok(x, y))
puts("YES");
else
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T, class U>
inline void Max(T &a, U b) {
if (a < b) a = b;
}
template <class T, class U>
inline void Min(T &a, U b) {
if (a > b) a = b;
}
inline void add(int &a, int b) {
a += b;
while (a >= 998244353) a -= 998244353;
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = ans * (long long)a % 998244353;
a = (long long)a * a % 998244353;
b >>= 1;
}
return ans;
}
string s, t, ss;
int query(int first, int second, int x1, int y1) {
cout << "? " << first << " " << second << " " << x1 << " " << y1 << "\n";
fflush(stdout);
cin >> t;
return t == "YES";
}
int main() {
int j, i, k, ca = 0, m = 0, K, n;
scanf("%d", &n);
int first = 1, second = 1;
s = "! ";
while (abs(first - n) + abs(second - n) - 1 >= n - 1) {
k = query(first, second + 1, n, n);
if (k)
s += 'R', second++;
else
s += 'D', first++;
}
int tx = first, ty = second;
first = n, second = n;
while (abs(first - 1) + abs(second - 1) - 1 >= n - 1) {
k = query(1, 1, first - 1, second);
if (k)
ss += "D", first--;
else
ss += "R", second--;
}
reverse(ss.begin(), ss.end());
s += ss;
puts(s.c_str());
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], jumlah = 0, jumlahnol = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> satu;
vector<int> nol;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
jumlah++;
satu.push_back(i);
if (a[i + 1] == 0) {
jumlahnol++;
nol.push_back(i + 1);
}
}
}
if (jumlah == 0)
cout << jumlah << endl;
else {
int indx = satu[satu.size() - 1];
for (int i = 0; i < nol.size(); i++) {
if (nol[i] < indx) jumlah++;
}
cout << jumlah << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int have[2][maxn];
int n;
bool work(int k) {
for (int i = 1; i <= n; i++)
if (!have[k][i]) return 0;
for (int i = 1; i <= n; i++)
if (k == 0)
printf("%d %d\n", i, have[k][i]);
else
printf("%d %d\n", have[k][i], i);
return 1;
}
int main() {
cin >> n;
char c;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
do c = getchar();
while (c != '.' && c != 'E');
if (c == '.') {
have[0][i] = j;
have[1][j] = i;
}
}
if (work(0)) return 0;
if (!work(1)) printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p = 100003;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
cout << p << " " << p << endl;
cout << 1 << " " << 2 << " " << p - (n - 2) << endl;
for (int i = 1; i < n - 1; i++) {
cout << i + 1 << " " << i + 2 << " " << 1 << endl;
}
int s = 1, e = 3;
for (int i = 0; i < m - (n - 1); i++) {
cout << s << " " << e << " " << p << endl;
e++;
if (e > n) s = s + 1, e = s + 2;
}
}
| 4 |
#include <bits/stdc++.h>
const long long inf = 20000000000000000;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
if (n & 1)
cout << (n / 2) * (n / 2 + 1) << endl;
else
cout << (n / 2) * (n / 2) << endl;
for (int i = 1; i <= n / 2; i++) {
for (int j = n / 2 + 1; j <= n; j++) {
cout << i << " " << j << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
unordered_map<string, int> hmap0, hmap1;
string str;
long long int count0 = 0, count1 = 0;
long long int count00 = 0, count11 = 0;
for (int i = 0; i < n; i++) {
cin >> str;
if (str.substr(0, 1) == "0" && str.substr(str.size() - 1, 1) == "1") {
hmap0[str] = i + 1;
count0++;
} else if (str.substr(0, 1) == "1" && str.substr(str.size() - 1) == "0") {
hmap1[str] = i + 1;
count1++;
} else if (str.substr(0, 1) == "0") {
count00++;
} else {
count11++;
}
}
if (count11 > 0 && count00 > 0 && count1 == 0 && count0 == 0) {
cout << "-1" << endl;
} else if (count1 == 0 && count0 == 0 && (count11 > 0 || count00 > 0)) {
cout << "0" << endl << endl;
} else if (count1 == count0 || count1 - count0 == 1 ||
count0 - count1 == 1) {
cout << "0" << endl << endl;
} else {
if (count0 > count1) {
vector<int> vec;
int count = 0;
unordered_map<string, int>::iterator itr;
for (itr = hmap0.begin(); itr != hmap0.end(); itr++) {
string s1;
s1 = itr->first;
reverse(s1.begin(), s1.end());
if (hmap1.find(s1) == hmap1.end()) {
vec.push_back(itr->second);
count0--;
count1++;
count++;
}
if (count0 == count1 || count0 - count1 == 1) {
break;
}
}
if (count0 == count1 || count0 - count1 == 1) {
cout << count << endl;
for (int i = 0; i < vec.size(); i++) {
cout << vec[i] << " ";
}
cout << endl;
} else {
cout << "-1ss" << endl;
}
}
if (count1 > count0) {
vector<int> vec;
int count = 0;
unordered_map<string, int>::iterator itr;
for (itr = hmap1.begin(); itr != hmap1.end(); itr++) {
string s1;
s1 = itr->first;
reverse(s1.begin(), s1.end());
if (hmap0.find(s1) == hmap0.end()) {
vec.push_back(itr->second);
count1--;
count0++;
count++;
}
if (count0 == count1 || count1 - count0 == 1) {
break;
}
}
if (count0 == count1 || count1 - count0 == 1) {
cout << count << endl;
for (int i = 0; i < vec.size(); i++) {
cout << vec[i] << " ";
}
cout << endl;
} else {
cout << "-1" << endl;
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3010;
struct GG {
int x, cnt;
bool operator<(const GG& obj) const { return cnt > obj.cnt; }
} p[maxn];
int vis[maxn][maxn];
long long group[maxn][maxn];
long long sum[maxn][maxn];
long long rest[maxn];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i < n + 1; i++) {
int g;
long long c;
scanf("%d %lld", &g, &c);
p[g].cnt++;
group[g][0]++;
group[g][group[g][0]] = c;
}
int wrong = 0;
for (int i = 2; i < m + 1; i++) {
p[i].x = i;
sort(group[i] + 1, group[i] + 1 + group[i][0]);
for (int j = 1; j < group[i][0] + 1; j++)
sum[i][j] = sum[i][j - 1] + group[i][j];
if (group[i][0] >= group[1][0]) wrong = max(wrong, (int)group[i][0]);
}
if (!wrong) {
printf("0\n");
return 0;
}
sort(p + 2, p + m + 1);
long long ans = 1e18;
for (int i = group[1][0] + 1; i < wrong + 2; i++) {
int cnt = group[1][0];
long long s = 0;
for (int j = 2; j < n + 1; j++) {
if (p[j].cnt >= i) {
int num = (p[j].cnt - (i - 1));
s += sum[p[j].x][num];
cnt += num;
for (int k = 1; k < num + 1; k++) vis[p[j].x][k] = i;
}
}
if (cnt > i) continue;
int num = 0;
for (int j = 2; j < m + 1; j++) {
for (int k = 1; k < group[j][0] + 1; k++)
if (vis[j][k] != i) rest[num++] = group[j][k];
}
sort(rest, rest + num);
for (int j = 0; j < i - cnt; j++) s += rest[j];
ans = min(ans, s);
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n < m) {
cout << -1;
return 0;
}
int min = n / 2 + n % 2;
while (min % m != 0) {
min++;
}
cout << min;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct trie {
struct tree {
long long al[26];
bool ex;
} nxt[100005];
long long cnt, dep[100005];
void insert(char *s) {
long long l = strlen(s), rt = 0;
for (register long long i = 0; i < l; i++) {
long long c = s[i] - 'a';
if (!nxt[rt].al[c]) nxt[rt].al[c] = ++cnt, dep[cnt] = dep[rt] + 1;
rt = nxt[rt].al[c];
}
nxt[rt].ex = 1;
}
} tr;
priority_queue<long long> q[100005];
long long n, ans = 0;
char s[100005];
template <typename T>
inline void read(T &x) {
T c = getchar(), f = 0;
for (; c < 48 || 57 < c; c = getchar())
if (c == '-') f = 1;
for (x = 0; 48 <= c && c <= 57; c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
if (f) x = -x;
}
template <typename T>
inline void print(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) print(x / 10);
putchar(x % 10 + 48);
}
inline void merge(long long x, long long y) {
while (!q[y].empty()) q[x].push(q[y].top()), q[y].pop();
}
void dfs(long long x) {
for (register long long i = 0; i < 26; i++)
if (tr.nxt[x].al[i]) dfs(tr.nxt[x].al[i]);
for (register long long i = 0; i < 26; i++)
if (tr.nxt[x].al[i]) merge(x, tr.nxt[x].al[i]);
if (!x) return;
if (tr.nxt[x].ex)
ans += tr.dep[x], q[x].push(tr.dep[x]);
else
ans -= q[x].top() - tr.dep[x], q[x].pop(), q[x].push(tr.dep[x]);
}
signed main() {
scanf("%lld", &n);
for (register long long i = 1; i <= n; i++) scanf("%s", s), tr.insert(s);
dfs(0), printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18 + 1;
const long long int MOD = 1000000007L;
clock_t time_p = clock();
void timer() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
template <typename Arg1>
ostream& operator<<(ostream& out, const vector<Arg1>& a) {
out << "[ ";
for (const auto& x : a) out << x << " ";
return out << "]";
}
long long int s, b;
bool bpm(bool bpGraph[1000][1000], int u, bool seen[], int matchR[]) {
for (int v = 0; v < b; v++) {
if (bpGraph[u][v] && !seen[v]) {
seen[v] = true;
if (matchR[v] < 0 || bpm(bpGraph, matchR[v], seen, matchR)) {
matchR[v] = u;
return true;
}
}
}
return false;
}
int maxBPM(bool bpGraph[1000][1000]) {
int matchR[b];
memset(matchR, -1, sizeof(matchR));
int result = 0;
for (int u = 0; u < s; u++) {
bool seen[b];
memset(seen, 0, sizeof(seen));
if (bpm(bpGraph, u, seen, matchR)) result++;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
long long int adj[n][n];
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
if (i == j) {
adj[i][j] = 0;
continue;
}
adj[i][j] = INF;
}
}
for (int i = 0; i < (m); ++i) {
long long int u, v;
cin >> u >> v;
u--;
v--;
if (u == v) {
continue;
}
adj[u][v] = 1;
adj[v][u] = 1;
}
long long int k, h;
cin >> s >> b >> k >> h;
vector<long long int> xs(s), as(s), fs(s);
for (int i = 0; i < (s); ++i) {
cin >> xs[i] >> as[i] >> fs[i];
xs[i]--;
}
vector<long long int> xb(b), db(b);
for (int i = 0; i < (b); ++i) {
cin >> xb[i] >> db[i];
xb[i]--;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]);
}
}
}
bool adj1[1000][1000];
for (int i = 0; i < (1000); ++i) {
for (int j = 0; j < (1000); ++j) {
adj1[i][j] = false;
}
}
for (int i = 0; i < s; i++) {
for (int j = 0; j < b; j++) {
if (adj[xs[i]][xb[j]] <= fs[i] && as[i] >= db[j]) {
adj1[i][j] = true;
}
}
}
long long int val = maxBPM(adj1);
long long int temp = 0;
for (int i = 0; i < (s); ++i) {
bool found = false;
for (int j = 0; j < (b); ++j) {
if (adj1[i][j]) {
found = true;
break;
}
}
if (found) {
temp++;
}
}
long long int ans = min(val * k, s * h);
cout << ans << endl;
timer();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 200 + 10;
const int inf = 1 << 28;
int n, m, k;
int a[maxn];
int d[maxn][maxn];
int pos[7];
int dp[1 << 7][maxn];
string mat[maxn];
void solve(int mask, int id) {
int goal = dp[mask][id];
mat[id / m][id % m] = 'X';
if (a[id] == goal) return;
if (id % m && goal == dp[mask][id - 1] + a[id]) {
solve(mask, id - 1);
return;
}
if (id % m + 1 < m && goal == dp[mask][id + 1] + a[id]) {
solve(mask, id + 1);
return;
}
if (id - m >= 0 && goal == dp[mask][id - m] + a[id]) {
solve(mask, id - m);
return;
}
if (id + m < n && goal == dp[mask][id + m] + a[id]) {
solve(mask, id + m);
return;
}
for (int sub = (mask - 1) & mask; sub; sub = (sub - 1) & mask)
if (goal == dp[mask ^ sub][id] + dp[sub][id] - a[id]) {
solve(mask ^ sub, id);
solve(sub, id);
continue;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
n *= m;
for (int i = 0, _n = (int)(n); i < _n; i++) cin >> a[i];
for (int i = 0, _n = (int)(k); i < _n; i++) {
int x, y;
cin >> x >> y;
x--, y--;
pos[i] = x * m + y;
}
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++) {
if (i == j)
d[i][j] = 0;
else if (i / m == j / m && abs(i - j) == 1)
d[i][j] = a[j];
else if (i % m == j % m && abs(i - j) == m)
d[i][j] = a[j];
else
d[i][j] = inf;
}
for (int k = 0, _n = (int)(n); k < _n; k++)
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++)
smin(d[i][j], d[i][k] + d[k][j]);
for (int mask = 0, _n = (int)(1 << k); mask < _n; mask++)
for (int i = 0, _n = (int)(n); i < _n; i++) dp[mask][i] = inf;
for (int mask = (int)(1), _n = (int)(1 << k); mask < _n; mask++) {
if ((mask & (mask - 1)) == 0) {
for (int i = 0, _n = (int)(n); i < _n; i++) {
int p = pos[__builtin_ctz(mask)];
dp[mask][i] = d[p][i] + a[p];
}
continue;
}
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int sub = (mask - 1) & mask; sub; sub = (sub - 1) & mask)
smin(dp[mask][i], dp[mask ^ sub][i] + dp[sub][i] - a[i]);
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++)
smin(dp[mask][i], dp[mask][j] + d[j][i]);
}
int fmask = (1 << k) - 1;
int ans = inf;
for (int i = 0, _n = (int)(n); i < _n; i++) smin(ans, dp[fmask][i]);
cout << ans << endl;
for (int i = 0, _n = (int)(n / m); i < _n; i++) mat[i] = string(m, '.');
solve(fmask, min_element(dp[fmask], dp[fmask] + n) - dp[fmask]);
for (int i = 0, _n = (int)(n / m); i < _n; i++) cout << mat[i] << endl;
{ return 0; }
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long nax = 6e5 + 69;
const long long nochoice = 3e5 + 5;
const long long INF = 1e12;
long long ans = 0;
long long n, k, par[nax], cost[nax];
string s;
vector<long long> g[nax];
void init() {
for (long long i = 1; i <= k; ++i) {
long long pos = i * 2, neg = i * 2 + 1;
par[pos] = pos, par[neg] = neg;
cost[pos] = 1, cost[neg] = 0;
}
par[nochoice * 2] = nochoice * 2, par[nochoice * 2 + 1] = nochoice * 2 + 1;
cost[nochoice * 2] = 0, cost[nochoice * 2 + 1] = INF;
}
long long Find(long long a) {
if (a == par[a]) return a;
return (par[a] = Find(par[a]));
}
void Unite(long long x, long long y, bool same) {
long long posx = x * 2, negx = x * 2 + 1;
long long posy = y * 2, negy = y * 2 + 1;
posx = Find(posx), negx = Find(negx), posy = Find(posy), negy = Find(negy);
if (same) {
if (posx == posy) {
assert(negx == negy);
return;
}
ans -= min(cost[posx], cost[negx]);
ans -= min(cost[posy], cost[negy]);
cost[posy] += cost[posx];
cost[negy] += cost[negx];
par[negx] = negy;
par[posx] = posy;
} else {
if (posx == negy) {
assert(negx == posy);
return;
}
ans -= min(cost[posx], cost[negx]);
ans -= min(cost[posy], cost[negy]);
cost[posy] += cost[negx];
cost[negy] += cost[posx];
par[negx] = posy;
par[posx] = negy;
}
ans += min(cost[negy], cost[posy]);
}
void solve() {
cin >> n >> k;
cin >> s;
s = ' ' + s;
for (long long i = 1; i <= k; ++i) {
long long c;
cin >> c;
for (long long j = 1; j <= c; ++j) {
long long x;
cin >> x;
g[x].push_back(i);
}
}
init();
for (long long i = 1; i <= n; ++i) {
if ((long long)g[i].size() == 1) {
Unite(g[i][0], nochoice, s[i] == '0');
} else if ((long long)g[i].size() == 2) {
Unite(g[i][0], g[i][1], s[i] == '1');
}
cout << ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, data[400050], done[400050], f[5][20][400050];
int Rand() { return (rand() << 15) | rand(); }
int Read() {
int result = 0;
char flag = getchar();
for (; flag < '0' || '9' < flag; flag = getchar())
;
for (; '0' <= flag && flag <= '9'; flag = getchar()) {
result = 10 * result + flag - 48;
}
return result;
}
void Init_RMQ() {
int Log = done[n], flag, i, j;
for (flag = 0; flag <= 4; flag++) {
for (i = 1; i <= Log; i++) {
for (j = 1; j + (1 << i) - 1 <= n; j++) {
f[flag][i][j] =
min(f[flag][i - 1][j], f[flag][i - 1][j + (1 << (i - 1))]);
}
}
}
return;
}
int Ask(int nowleft, int nowright, int flag) {
int Log = (int)(done[nowright - nowleft + 1]);
return min(f[flag][Log][nowleft], f[flag][Log][nowright - (1 << Log) + 1]);
}
int Same(int r1, int c1, int r2, int c2) {
int answer = min(max(c1 - c2, c2 - c1), min(c2, data[r2] - c2) + 1), low, mid,
high, temp;
low = 0;
high = r2;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(mid, r2, 4) < c2) {
low = mid;
} else {
high = mid;
}
}
temp = Ask(high, r2, 2) + 2 * r2 - c2;
if (c1 < c2) {
temp++;
}
answer = min(answer, temp);
if (low != 0) {
temp = f[0][0][low] + 2 * r2 + c2;
if (c1 < c2) {
temp++;
}
answer = min(answer, temp);
}
low = r2;
high = n + 1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(r2, mid, 4) >= c2) {
low = mid;
} else {
high = mid;
}
}
temp = Ask(r2, low, 3) - 2 * r2 - c2;
if (c1 < c2) {
temp++;
}
answer = min(answer, temp);
if (high != n + 1) {
temp = f[1][0][high] - 2 * r2 + c2;
if (c1 < c2) {
temp++;
}
answer = min(answer, temp);
}
return answer;
}
int DR(int r1, int c1, int r2, int c2) {
int answer = 999999999, temp, low, mid, high, tl, th;
if (Ask(r1, r2, 4) > c2) {
low = 0;
high = r1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(mid, r1, 4) < c2) {
low = mid;
} else {
high = mid;
}
}
answer = min(answer, r2 - r1 + 1 + Ask(high, r1, 2) + 2 * r1 - c2);
if (low != 0) {
answer = min(answer, r2 - r1 + 1 + f[0][0][low] + 2 * r1 + c2);
}
}
low = r1;
high = r2;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(mid, r2, 4) < c2) {
low = mid;
} else {
high = mid;
}
}
tl = Ask(low, r2, 4);
th = Ask(high, r2, 4);
answer = min(answer, r2 - r1 + 1 + max(tl - c2, c2 - tl));
answer = min(answer, r2 - r1 + 1 + max(th - c2, c2 - th));
temp = min(c1, Ask(r1 + 1, r2, 4));
answer = min(answer, r2 - r1 + Same(r2, temp, r2, c2));
return answer;
}
int DL(int r1, int c1, int r2, int c2) {
int answer = 999999999, temp, low, mid, high, tl, th;
if (Ask(r1, r2, 4) > c2) {
low = 0;
high = r1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(mid, r1, 4) < c2) {
low = mid;
} else {
high = mid;
}
}
answer = min(answer, r2 - r1 + Ask(high, r1, 2) + 2 * r1 - c2);
if (low != 0) {
answer = min(answer, r2 - r1 + f[0][0][low] + 2 * r1 + c2);
}
}
low = r1;
high = r2;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(mid, r2, 4) < c2) {
low = mid;
} else {
high = mid;
}
}
tl = Ask(low, r2, 4);
th = Ask(high, r2, 4);
answer = min(answer, r2 - r1 + 1 + max(tl - c2, c2 - tl));
answer = min(answer, r2 - r1 + 1 + max(th - c2, c2 - th));
temp = min(c1, Ask(r1 + 1, r2, 4));
answer = min(answer, r2 - r1 + Same(r2, temp, r2, c2));
return answer;
}
int UR(int r1, int c1, int r2, int c2) {
int answer = 999999999, temp, low, mid, high, tl, th;
temp = min(c1, Ask(r2, r1 - 1, 4));
answer = min(answer, r1 - r2 + Same(r2, temp, r2, c2));
low = r2;
high = r1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(r2, mid, 4) >= c2) {
low = mid;
} else {
high = mid;
}
}
tl = Ask(r2, low, 4);
th = Ask(r2, high, 4);
answer = min(answer, r1 - r2 + 1 + max(tl - c2, c2 - tl));
answer = min(answer, r1 - r2 + 1 + max(th - c2, c2 - th));
if (Ask(r2, r1, 4) > c2) {
low = r1;
high = n + 1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(r1, mid, 4) >= c2) {
low = mid;
} else {
high = mid;
}
}
answer = min(answer, r1 - r2 + 1 + Ask(r1, low, 3) - 2 * r1 - c2);
if (high != n + 1) {
answer = min(answer, r1 - r2 + 1 + f[1][0][high] - 2 * r1 + c2);
}
}
return answer;
}
int UL(int r1, int c1, int r2, int c2) {
int answer = 999999999, temp, low, mid, high, tl, th;
temp = min(c1, Ask(r2, r1 - 1, 4));
answer = min(answer, r1 - r2 + Same(r2, temp, r2, c2));
low = r2;
high = r1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(r2, mid, 4) >= c2) {
low = mid;
} else {
high = mid;
}
}
tl = Ask(r2, low, 4);
th = Ask(r2, high, 4);
answer = min(answer, r1 - r2 + 1 + max(tl - c2, c2 - tl));
answer = min(answer, r1 - r2 + 1 + max(th - c2, c2 - th));
if (Ask(r2, r1, 4) > c2) {
low = r1;
high = n + 1;
while (low + 1 < high) {
mid = (low + high) >> 1;
if (Ask(r1, mid, 4) >= c2) {
low = mid;
} else {
high = mid;
}
}
answer = min(answer, r1 - r2 + Ask(r1, low, 3) - 2 * r1 - c2);
if (high != n + 1) {
answer = min(answer, r1 - r2 + f[1][0][high] - 2 * r1 + c2);
}
}
return answer;
}
int main() {
int q, i, r1, c1, r2, c2;
srand((unsigned)time(0));
n = Read();
for (i = 1; i <= n; i++) {
data[i] = Read();
f[0][0][i] = -data[i] - 2 * i;
f[1][0][i] = -data[i] + 2 * i;
f[2][0][i] = data[i] - 2 * i;
f[3][0][i] = data[i] + 2 * i;
f[4][0][i] = data[i];
}
for (i = 1; i <= n; i++) {
done[i] = (int)(log2(i));
}
Init_RMQ();
q = Read();
for (i = 1; i <= q; i++) {
r1 = Read();
c1 = Read();
r2 = Read();
c2 = Read();
if (r1 == r2) {
printf("%d\n", Same(r1, c1, r2, c2));
} else if (r1 < r2) {
if (c1 < c2) {
printf("%d\n", DR(r1, c1, r2, c2));
} else {
printf("%d\n", DL(r1, c1, r2, c2));
}
} else {
if (c1 < c2) {
printf("%d\n", UR(r1, c1, r2, c2));
} else {
printf("%d\n", UL(r1, c1, r2, c2));
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, pc, pw[2000005], mu[2000005], p[2000005], b[4000005];
bool vis[2000005];
long long pow(long long x, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret = ret * x % 1000000007;
x = x * x % 1000000007;
k >>= 1;
}
return ret;
}
int main() {
long long i, j, x, ans = 0;
cin >> n >> k;
for (i = 1; i <= k; i++) pw[i] = pow(i, n);
mu[1] = 1;
for (x = 2; x <= k; x++) {
if (!vis[x]) {
p[++pc] = x;
mu[x] = -1;
}
for (j = 1; x * p[j] <= k; j++) {
vis[x * p[j]] = true;
if (x % p[j] == 0) {
mu[x * p[j]] = 0;
break;
} else {
mu[x * p[j]] = -mu[x];
}
}
}
for (x = 1; x <= k; x++) {
for (i = 1; i * x <= k; i++) {
b[i * x] =
(b[i * x] + pw[i] * (1000000007 + mu[x]) % 1000000007) % 1000000007;
b[i * x] = (b[i * x] - pw[i - 1] * (1000000007 + mu[x] % 1000000007)) %
1000000007;
if (b[i * x] < 0) b[i * x] += 1000000007;
}
}
for (i = 1; i <= k; i++) {
b[i] = (b[i] + b[i - 1]) % 1000000007;
ans = (ans + (b[i] ^ i) % 1000000007) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1.6e5 + 5;
int n, m, cnt, num, ans, sum, down[205][205], righ[205][205], first[N],
nex[N << 1], to[N << 1], match[N];
bool vis[N], color[N];
char c[205][205];
inline void dadd(int u, int v) {
to[++num] = v;
nex[num] = first[u];
first[u] = num;
to[++num] = u;
nex[num] = first[v];
first[v] = num;
}
void build(int x, int y) {
if (c[x][y] == '.') return;
if (x != n && c[x + 1][y] == '#') down[x][y] = ++cnt, color[cnt] = 1;
if (y != m && c[x][y + 1] == '#') righ[x][y] = ++cnt;
if (x != 1 && c[x - 1][y] == '#') {
if (y != 1 && c[x][y - 1] == '#') dadd(down[x - 1][y], righ[x][y - 1]);
if (y != m && c[x][y + 1] == '#') dadd(down[x - 1][y], righ[x][y]);
}
if (x != n && c[x + 1][y] == '#') {
if (y != 1 && c[x][y - 1] == '#') dadd(down[x][y], righ[x][y - 1]);
if (y != m && c[x][y + 1] == '#') dadd(down[x][y], righ[x][y]);
}
}
bool find(int u) {
for (int i = first[u]; i; i = nex[i]) {
int v = to[i];
if (vis[v]) continue;
vis[v] = 1;
if (!match[v] || find(match[v])) {
match[v] = u;
return 1;
}
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", c[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (c[i][j] == '#') ans++;
build(i, j);
}
for (int i = 1; i <= cnt; i++)
if (color[i]) {
memset(vis, 0, sizeof(vis));
if (find(i)) sum++;
}
printf("%d", ans - (cnt - sum));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 65;
const int inf = 1e9;
int a[N][N][N];
int b[N][N];
int dp[N][N][N];
int main() {
int n, m, r;
scanf("%d%d%d", &n, &m, &r);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
scanf("%d", &a[i][j][k]);
}
}
}
for (int t = 1; t <= m; t++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
a[t][i][j] = min(a[t][i][j], a[t][i][k] + a[t][k][j]);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= n; k++) {
dp[i][j][k] = i == j ? 0 : inf;
}
}
}
for (int t = 1; t <= m; t++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j][0] = min(a[t][i][j], dp[i][j][0]);
}
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int x = 1; x <= n; x++) {
dp[i][j][k] = min(dp[i][j][k], dp[i][x][k - 1] + dp[x][j][0]);
}
}
}
}
int x, y, z;
for (int i = 1; i <= r; i++) {
scanf("%d%d%d", &x, &y, &z);
if (z > n) z = n;
int ans = dp[x][y][0];
for (int i = 1; i <= z; i++) {
ans = min(dp[x][y][i], ans);
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, k;
int a[maxn], w[maxn], sz[maxn], up[maxn], dp[maxn];
vector<int> E[maxn];
int flag;
void dfs1(int x, int fa, int m) {
sz[x] = 1;
for (int i = 0; i < E[x].size(); i++) {
int v = E[x][i];
if (v == fa) continue;
dfs1(v, x, m);
sz[x] += sz[v];
w[x] += w[v];
}
}
void dfs2(int x, int fa, int m) {
int Max1 = 0, Max2 = 0, tot = 0;
for (int i = 0; i < E[x].size(); i++) {
int v = E[x][i];
if (v == fa) continue;
if (w[x] - w[v] == sz[x] - sz[v] && up[x]) up[v] = 1;
dfs2(v, x, m);
if (a[v] < m) continue;
if (sz[v] == w[v]) {
tot += sz[v];
} else {
if (dp[v] > Max1)
Max2 = Max1, Max1 = dp[v];
else if (dp[v] > Max2)
Max2 = dp[v];
}
}
if (a[x] < m) return;
if (tot + Max1 + Max2 + up[x] * (n - sz[x]) + 1 >= k) flag = 1;
dp[x] = tot + Max1 + 1;
}
int check(int x) {
for (int i = 1; i <= n; i++) dp[i] = up[i] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= x)
w[i] = 1;
else
w[i] = 0;
}
flag = 0;
dfs1(1, -1, x);
up[1] = w[1];
dfs2(1, -1, x);
return flag;
}
void input() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
}
}
void work() {
int l = 0, r = 1e6 + 6, ans;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d\n", ans);
}
int main() {
input();
work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7FFFFFFF;
struct point_int {
int x, y;
point_int() {}
point_int(int a, int b) { x = a, y = b; }
};
struct point_double {
double x, y;
point_double() {}
point_double(double a, double b) { x = a, y = b; }
};
struct Node {
int v, w;
Node() {}
bool operator<(const Node &a) const { return w > a.w; }
Node(int _v, int _w) { v = _v, w = _w; }
};
namespace my {
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T big_mod(T n, T p, T m) {
if (p == 0) return (T)1;
T x = big_mod(n, p / 2, m);
x = (x * x) % m;
if (p & 1) x = (x * n) % m;
return x;
}
template <class T>
T multiplication(T n, T p, T m) {
if (p == 0) return (T)0;
T x = multiplication(n, p / 2, m);
x = (x + x) % m;
if (p & 1) x = (x + n) % m;
return x;
}
template <class T>
T my_pow(T n, T p) {
if (p == 0) return 1;
T x = my_pow(n, p / 2);
x = (x * x);
if (p & 1) x = (x * n);
return x;
}
template <class T>
double getdist(T a, T b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
template <class T>
T extract(string s, T ret) {
stringstream ss(s);
ss >> ret;
return ret;
}
template <class T>
string tostring(T n) {
stringstream ss;
ss << n;
return ss.str();
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
T MIN3(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T MAX3(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
void print_vector(T &v) {
int sz = v.size();
if (sz) cout << v[0];
for (int i = 1; i < sz; i++) cout << ' ' << v[i];
cout << endl;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConsonant(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
} // namespace my
int read_int() {
int n;
scanf("%d", &n);
return n;
}
int read_LLD() {
long long int n;
scanf("%lld", &n);
return n;
}
inline int buffer_input() {
char inp[1000];
scanf("%s", inp);
return atoi(inp);
}
int posS[1000005];
int posE[1000005];
map<int, int> M;
int main() {
int N;
cin >> N;
fill(posS, posS + 1000005, inf);
fill(posE, posE + 1000005, -inf);
for (int i = 1; i <= N; i++) {
int x;
cin >> x;
posS[x] = min(posS[x], i);
posE[x] = max(posE[x], i);
M[x]++;
}
int Max = -1;
int val;
int beauty;
for (auto x : M) {
if (x.second > Max) {
val = x.first;
Max = x.second;
beauty = posE[val] - posS[val] + 1;
} else if (x.second == Max) {
if (beauty > (posE[x.first] - posS[x.first] + 1)) {
beauty = posE[x.first] - posS[x.first] + 1;
val = x.first;
}
}
}
cout << posS[val] << " " << posE[val] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int toNum(char x) {
if (x >= '0' && x <= '9') return x - '0';
return x - 'A' + 10;
}
char NumToChar(int x) {
if (x < 10) return x + '0';
return x - 10 + 'A';
}
struct lnum {
vector<int> a;
int _base;
void norm() {
while (!a.empty() && a.back() == 0) a.pop_back();
}
lnum() {}
lnum(string s, int b) {
_base = b;
while (!s.empty()) {
a.push_back(toNum(*(s.end() - 1)));
s.erase(s.end() - 1);
}
norm();
}
int toInt() {
int res = 0;
for (int i = (int)a.size() - 1; i >= 0; i--) res = res * _base + a[i];
return res;
}
void toSis(int toB) {
vector<int> tmp;
norm();
while (!a.empty()) {
int carry = 0;
for (int i = (int)a.size() - 1; i >= 0; i--) {
a[i] += carry;
carry = (a[i] % toB) * _base;
a[i] /= toB;
}
tmp.push_back(carry / _base);
norm();
}
a = tmp;
_base = toB;
norm();
}
void print() {
norm();
if (a.empty()) cout << '0';
for (int i = (int)a.size() - 1; i >= 0; i--) cout << NumToChar(a[i]);
}
};
int toInt(string t) {
int res = 0;
for (size_t i = 0; i < t.length(); i++) res = res * 10 + t[i] - '0';
return res;
}
string toRome(int x) {
string t;
int x1000 = (x / 1000) % 10, x100 = (x / 100) % 10, x10 = (x / 10) % 10,
x1 = x % 10;
while (x1000--) t += "M";
if (x100 == 9) {
t += "CM";
x100 = 0;
}
if (x100 >= 5) {
t += "D";
x100 -= 5;
}
if (x100 == 4) {
t += "CD";
x100 = 0;
}
while (x100--) {
t += "C";
}
if (x10 == 9) {
t += "XC";
x10 = 0;
}
if (x10 >= 5) {
t += "L";
x10 -= 5;
}
if (x10 == 4) {
t += "XL";
x10 = 0;
}
while (x10--) {
t += "X";
}
if (x1 == 9) {
t += "IX";
x1 = 0;
}
if (x1 >= 5) {
t += "V";
x1 -= 5;
}
if (x1 == 4) {
t += "IV";
x1 = 0;
}
while (x1--) {
t += "I";
}
return t;
}
int main() {
ios_base::sync_with_stdio(0);
int a;
string bb, c;
cin >> a >> bb >> c;
lnum x = lnum(c, a);
if (bb == "R") {
cout << toRome(x.toInt());
} else {
x.toSis(toInt(bb));
x.print();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAX_N = 1000000;
const int MOD = 1000000007;
std::vector<int> groups;
int table[1 + MAX_N], dp[1 + MAX_N];
std::deque<int> tablePositions;
int main() {
std::string s;
std::cin >> s;
groups.push_back(0);
int cnt = 0;
for (int i = 0; i < s.size(); ++i)
if (s[i] == '0')
++cnt;
else {
groups.push_back(cnt);
cnt = 0;
}
groups.push_back(cnt);
dp[1] = groups[1] + 1;
for (int i = 2; i < groups.size(); ++i) {
if (i < groups.size() - 1) dp[i] = dp[i - 1];
for (int lastDigit = 0; lastDigit <= groups[i]; ++lastDigit) {
dp[i] = (dp[i] + dp[i - 1]) % MOD;
while (!tablePositions.empty() && tablePositions.front() < lastDigit)
tablePositions.pop_front();
if (i < groups.size() - 1 && !tablePositions.empty())
dp[i] = (dp[i] + MOD - table[tablePositions.front()]) % MOD;
}
tablePositions.push_front(groups[i]);
table[groups[i]] = dp[i - 1];
}
if (groups.size() == 2) dp[groups.size() - 1]--;
printf("%d", dp[groups.size() - 1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int wh(char ch) {
if (ch == 'A') return 0;
if (ch == 'T') return 1;
if (ch == 'G') return 2;
if (ch == 'C') return 3;
return 4;
}
int tree[4][11][11][100007], n;
char s[100007], t[100007];
void update(int i, int k, int r, int idx, int val) {
while (idx <= n) {
tree[i][k][r][idx] += val;
idx += (idx & -idx);
}
}
int query(int i, int k, int r, int idx) {
int sum = 0;
while (idx) {
sum += tree[i][k][r][idx];
idx -= (idx & -idx);
}
return sum;
}
int main() {
int i, j, k, r, l, tp, pos, q, len, sum;
scanf("%s", &s[1]);
n = strlen(&s[1]);
for (i = 1; s[i]; i++) {
j = wh(s[i]);
for (k = 1; k <= 10; k++) {
r = (i - 1) % k + 1;
update(j, k, r, i, +1);
}
}
scanf("%d", &q);
while (q--) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d %s", &pos, t);
for (k = 1; k <= 10; k++) {
r = (pos - 1) % k + 1;
update(wh(s[pos]), k, r, pos, -1);
update(wh(t[0]), k, r, pos, +1);
}
s[pos] = t[0];
} else {
scanf("%d %d %s", &l, &r, t);
sum = 0;
len = strlen(t);
for (i = 0, j = l; t[i] && j <= r; i++, j++) {
sum += query(wh(t[i]), len, (j - 1) % len + 1, r);
sum -= query(wh(t[i]), len, (j - 1) % len + 1, l - 1);
}
cout << sum << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 1e5;
int n, m, q;
int us[N], vs[N], ww[N];
vector<int> g[N];
long long dist[N];
int dist2[N];
vector<int> que[N * 2];
void dijkstra() {
for (int i = 0; i < n; i++) {
dist[i] = 1e16;
}
priority_queue<pair<long long, int>> q;
q.emplace(0, 0);
dist[0] = 0;
while (!q.empty()) {
long long d = -q.top().first;
int u = q.top().second;
q.pop();
if (dist[u] < d) continue;
for (int id : g[u]) {
int v = vs[id];
if (dist[v] > dist[u] + ww[id]) {
dist[v] = dist[u] + ww[id];
q.emplace(-dist[v], v);
}
}
}
}
int cap;
void dijkstra2() {
if (cap == 0) return;
que[0].push_back(0);
for (int i = 0; i < n; i++) {
dist2[i] = cap;
}
dist2[0] = 0;
for (int d = 0; d < cap; d++) {
while (!que[d].empty()) {
int u = que[d].back();
que[d].pop_back();
if (dist2[u] < d) continue;
for (int id : g[u]) {
int v = vs[id];
int w = min<long long>(cap, ww[id] + dist[u] - dist[v]);
if (dist2[v] > dist2[u] + w && dist2[u] + w < cap) {
dist2[v] = dist2[u] + w;
que[dist2[v]].push_back(v);
}
}
}
}
for (int i = 0; i < n; i++) {
dist[i] += dist2[i];
}
cap = 0;
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &us[i], &vs[i], &ww[i]);
us[i]--;
vs[i]--;
g[us[i]].push_back(i);
}
dijkstra();
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
dijkstra2();
int v;
scanf("%d", &v);
if (dist[v - 1] >= 1e16) {
puts("-1");
} else {
printf("%lld\n", dist[v - 1]);
}
} else {
int c;
scanf("%d", &c);
while (c--) {
int l;
scanf("%d", &l);
ww[l - 1]++;
}
cap += n;
if (cap == n * 2) dijkstra2();
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0, ans1 = 0;
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '<')
ans++;
else
break;
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '>')
ans1++;
else
break;
}
cout << ans + ans1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[50001];
deque<int> q;
int p[50001] = {0};
int color[50001] = {0};
void dfs(int u) {
color[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (color[v] == 0) p[v] = u, dfs(v);
}
q.push_front(u);
}
int main() {
int n, r1, r2;
cin >> n >> r1 >> r2;
int city;
for (int i = 1; i <= n; i++)
if (i != r1) {
cin >> city;
adj[i].push_back(city), adj[city].push_back(i);
}
dfs(r2);
for (int i = 1; i < n; i++)
if (i != r2) cout << p[i] << ' ';
if (r2 != n) cout << p[n];
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int c, d;
cin >> c >> d;
a = abs(a - c);
b = abs(b - d);
cout << max(a, b);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) : x(_x), y(_y) {}
void input() { scanf("%lf%lf", &x, &y); }
} p0, p1, p2;
double t1, t2;
double sqr(double a) { return a * a; }
double dist(Point p1, Point p2) {
return sqrt(sqr(p1.x - p2.x) + sqr(p1.y - p2.y));
}
double solve(Point s, Point e, Point m, double t) {
if (dist(s, m) + dist(m, e) <= t + dist(s, e))
return dist(s, e) + t - dist(m, e);
double low = 0.0, high = 1.0, mid;
for (int step = 1; step <= 1000; step++) {
mid = (low + high) / 2.0;
Point p = Point(s.x + mid * (m.x - s.x), s.y + mid * (m.y - s.y));
if (dist(s, p) + dist(p, e) <= t + dist(s, e))
low = mid;
else
high = mid;
}
return mid * dist(s, m);
}
int main() {
while (~scanf("%lf%lf", &t1, &t2)) {
p0.input();
p1.input();
p2.input();
double low = 0.0, high = 1.0, mid, midd, ans = 0.0;
ans = max(ans, min(solve(p0, p1, p1, t2), solve(p0, p2, p1, t1)));
ans = max(ans, min(solve(p0, p1, p2, t2), solve(p0, p2, p2, t1)));
if (dist(p0, p2) + dist(p2, p1) <= t2 + dist(p0, p1)) {
ans = max(ans, min(dist(p0, p1) + t2, dist(p0, p2) + dist(p2, p1) + t1));
}
for (int step = 1; step <= 1000; step++) {
mid = low + (high - low) / 3.0;
midd = high - (high - low) / 3.0;
Point pa = Point(p1.x + (p2.x - p1.x) * mid, p1.y + (p2.y - p1.y) * mid);
Point pb =
Point(p1.x + (p2.x - p1.x) * midd, p1.y + (p2.y - p1.y) * midd);
double r1 = min(solve(p0, p1, pa, t2), solve(p0, p2, pa, t1));
double r2 = min(solve(p0, p1, pb, t2), solve(p0, p2, pb, t1));
if (r1 > r2)
high = midd, ans = max(ans, r1);
else
low = mid, ans = max(ans, r2);
}
printf("%.5lf\n", ans);
}
return 0;
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.