solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, a[N], cnt[20][2], child[N], s[N];
bool visit[N];
long long sum;
vector<int> G[N];
void dfs(int u, int p) {
child[u] = 1;
for (auto v : G[u]) {
if (visit[v] || v == p) continue;
dfs(v, u);
child[u] += child[v];
}
}
int find_cen(int u, int p, int r) {
for (auto v : G[u]) {
if (visit[v] || v == p) continue;
if (child[v] * 2 >= child[r]) return find_cen(v, u, r);
}
return u;
}
void change(int u, int p, int val) {
for (int j = 0; j < 20; ++j) {
cnt[j][s[u] >> j & 1] += val;
}
for (auto v : G[u]) {
if (v == p || visit[v]) continue;
s[v] = s[u] ^ a[v];
change(v, u, val);
}
}
void cal(int u, int p) {
sum += s[u];
for (int j = 0; j < 20; ++j) {
sum += (1LL << j) * cnt[j][(s[u] >> j & 1) ^ 1];
}
for (auto v : G[u]) {
if (v == p || visit[v]) continue;
s[v] = s[u] ^ a[v];
cal(v, u);
}
}
void solve(int u) {
dfs(u, u);
u = find_cen(u, u, u);
visit[u] = 1;
for (auto v : G[u]) {
if (visit[v]) continue;
s[v] = a[u] ^ a[v];
cal(v, u);
s[v] = a[v];
change(v, u, 1);
}
for (auto v : G[u]) {
if (visit[v]) continue;
s[v] = a[v];
change(v, u, -1);
}
for (auto v : G[u]) {
if (visit[v]) continue;
solve(v);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum += a[i];
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
solve(1);
cout << sum;
}
| 5 |
#include<bits/stdc++.h>
#define MOD 1000000007
int n,m,k,f[6600][6600],Ans;
inline int Mod(int u){return u < MOD?u:u-MOD;}
int main()
{
std::cin >> n >> m >> k,f[0][0] = 1;
for(int i = 1;i<=(n+m-1)/(k-1);++i)
{
for(int j = 0;j<=m;++j) for(int l = 1;l<k;++l) f[i][j+l] = Mod(f[i][j+l]+f[i-1][j]);
for(int j = 1;j<=m;++j)
{
int nxt = i*(k-1)+1 - j;
if(nxt&&nxt <= n && (n-nxt) % (k-1) == 0 && (m-j)%(k-1) == 0) Ans = Mod(Ans + f[i][j]);
}
for(int j = 0;j<=m;++j) f[i][j] = Mod(f[i][j]+f[i-1][j]);
}
printf("%d\n",Ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool com(pair<int, int> A, pair<int, int> B) {
if (A.first == B.first) {
return A.second < B.second;
}
return A.first < B.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a;
vector<pair<int, int> > v;
cin >> n;
for (int i = 1; i <= n * 2; i++) {
cin >> a;
v.push_back({a, i});
}
long long ans = 0;
sort(v.begin(), v.end(), com);
int in = 1;
for (int i = 0; i < v.size(); i += 2) {
ans += abs(v[i].second - in);
in = v[i].second;
}
in = 1;
for (int i = 1; i < v.size(); i += 2) {
ans += abs(v[i].second - in);
in = v[i].second;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t, T, x, y, sum, cnt, ans, a[100005], d[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
}
a[n + 1] = 0;
a[n + 2] = 1000000000;
sort(a + 1, a + n + 3);
for (int i = (1); i <= (m); i++) {
cin >> x >> y >> t;
x--;
int l = lower_bound(a + 1, a + n + 3, x) - a;
int r = upper_bound(a + 1, a + n + 3, y) - a - 1;
if (l >= r || l > 1) continue;
d[l]++;
d[r]--;
}
for (int i = (1); i <= (n + 1); i++) {
d[i] += d[i - 1];
if (i == 1)
ans = d[1];
else
ans = min(ans, d[i] + i - 1);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main() {
double a, b; cin >> a >> b;
cout.precision(6);
cout << fixed << a * b / 3.305785 << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int sum = 0, fg = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = (sum << 3) + (sum << 1) + c - '0';
c = getchar();
}
return sum * fg;
}
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
long long a[N], inv[N], finv[N], sum[N], f[N];
void init(int n) {
a[0] = 1;
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1] * i % MOD;
}
inv[1] = 1;
for (int i = 2; i <= n; i++) {
inv[i] = (MOD - MOD / i * inv[MOD % i] % MOD) % MOD;
}
finv[0] = finv[1] = 1;
for (int i = 2; i <= n; i++) {
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
int main() {
int n = read(), k = read();
init(n);
sum[0] = f[0] = 1;
for (int i = 1; i <= n; i++) {
if (i - k >= 0) {
f[i] = a[i - 1] * (sum[i - 1] + MOD - sum[i - k - 1]) % MOD;
} else {
f[i] = a[i - 1] * sum[i - 1] % MOD;
}
sum[i] = (f[i] * finv[i] + sum[i - 1]) % MOD;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + f[i - 1] * a[n - 1] % MOD * finv[i - 1]) % MOD;
}
printf("%d", (a[n] + MOD - ans) % MOD);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
int c1 = 0, c2 = 0, c3 = 0, ans = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j + 1 < s.size(); j++) {
if (s[j] == 'A' && s[j + 1] == 'B') ans++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A') c1++;
if (s[0] == 'B') c2++;
if (s[s.size() - 1] == 'A') c3++;
}
ans += min(c2, c3);
if (c2 == c3 && c1 == c3 && c1) ans--;
cout << ans << endl;
return 0;
}
| 0 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#define MO 998244353
#define MAXN 300000
using namespace std;
typedef long long LL;
LL N,A,B,K;
LL fact[MAXN+5],inv[MAXN+5];
LL PowMod(LL a,LL b)
{
a%=MO;
LL ret=1LL;
while(b)
{
if(b&1)
ret=ret*a%MO;
a=a*a%MO;
b>>=1;
}
return ret;
}
void prepare()
{
fact[0]=1LL;
for(int i=1;i<=MAXN;i++)
fact[i]=fact[i-1]*i%MO;
inv[MAXN]=PowMod(fact[MAXN],MO-2);
for(int i=MAXN-1;i>=0;i--)
inv[i]=inv[i+1]*(i+1)%MO;
}
LL C(LL n,LL m)
{
if(m>n)
return 0;
return fact[n]*inv[m]%MO*inv[n-m]%MO;
}
int main()
{
prepare();
scanf("%lld %lld %lld %lld",&N,&A,&B,&K);
LL x,y;
LL ans=0;
for(LL x=0;x<=N;x++)
{
if(K-x*A<0)
break;
if((K-x*A)%B!=0)
continue;
y=(K-x*A)/B;
ans=(ans+C(N,x)*C(N,y)%MO)%MO;
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int const LINF = numeric_limits<long long int>::max();
int const INF = numeric_limits<int>::max();
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int pow_mod(long long int a, long long int e, long long int m) {
long long int res = 1;
while (e) {
if (e & 1) res = res * a % m;
a = a * a % m;
e >>= 1;
}
return res;
}
long long int inv_mod(long long int b, long long int m) {
b %= m;
long long int x = 0, y = 1, r, q, a = m;
while (b) {
q = a / b;
r = a % b;
a = b;
b = r;
r = x;
x = y;
y = r - q * y;
}
x += m;
return x % m;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
long long int s = 0;
while (true) {
long long int tmp = a + b + s * (s + 1) / 2;
if (tmp % 2 == 0 && (tmp / 2) >= max(a, b)) {
break;
}
s++;
}
cout << s << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
long long kmax = ((n - m + 1) * (n - m)) / 2;
long long kmin = 0;
long long d = n / m;
long long r = n % m;
for (long long i = 0; i < r; i++) {
kmin += ((d + 1) * d) / 2;
}
long long l = m - r;
for (long long j = 0; j < l; j++) {
kmin += ((d) * (d - 1)) / 2;
}
cout << kmin << " " << kmax;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
pair<int, int> a[2005];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1, [](pair<int, int> x, pair<int, int> y) {
if (x.first == y.first) return x.second < y.second;
return x.first > y.first;
});
sort(a + 1, a + k + 1, [](pair<int, int> x, pair<int, int> y) {
if (x.second == y.second) return x.first < y.first;
return x.second < y.second;
});
int sum = 0;
for (int i = 1; i <= k; i++) sum += a[i].first;
cout << sum << '\n';
int pi = 0;
for (int i = 1; i <= k; i++) {
if (i > 1) cout << ' ';
if (i != k)
cout << a[i].second - pi;
else
cout << n - pi << '\n';
pi = a[i].second;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
double f[1007][10007];
double cal(int n, int m) {
if (n == 0) {
return 1.0 / (m + 1);
}
if (m == 0) {
return 1.0;
}
if (f[n][m]) {
return f[n][m];
}
double A = (1 - cal(m - 1, n)) * m / (m + 1);
double B = (1 - cal(m - 1, n)) * m / (m + 1) + 1.0 / (m + 1);
double C = 1 - cal(m, n - 1);
double p = (C - 1) / ((A - 1) - (B - C));
return f[n][m] = p * A + (1 - p);
}
int main() {
int N, M;
scanf("%d%d", &N, &M);
printf("%.10lf %.10lf", cal(N, M), 1 - cal(N, M));
}
| 5 |
#include <bits/stdc++.h>
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<int, int> operator+(const pair<int, int> &l, const pair<int, int> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<int, int> operator-(const pair<int, int> &l, const pair<int, int> &r) {
return {l.first - r.first, l.second - r.second};
}
int pr[10000100];
int inv[10000010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int comb(int nn, int rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (int i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
vector<pair<int, int> > G[500020];
int dp[1 << 22];
int sz[500020];
int memo[500020];
int ans[500020] = {};
vector<int> oi;
int P = 0;
int oi_in[500020];
int oi_out[500020];
int dep[500020];
int dfs_s(int r, int e = 0, int d = 0) {
oi_in[r] = P;
oi[P] = r;
P++;
dep[r] = d;
sz[r] = 1;
memo[r] = e;
for (auto v : G[r]) sz[r] += dfs_s(v.first, e ^ (1 << v.second), d + 1);
oi_out[r] = P;
return sz[r];
}
vector<int> ve;
int ch(int r, int l) {
int ma = -1;
for (auto v : ve) {
ma = max(ma, dp[memo[r] ^ v]);
}
if (ma == -1) return -1;
return ma + dep[r] - 2 * dep[l];
}
void dfs(int r, bool keep) {
int ma = -1;
int hv = -1;
for (auto v : G[r])
if (ma < sz[v.first]) ma = sz[v.first], hv = v.first;
for (auto v : G[r])
if (v.first != hv) dfs(v.first, false);
if (hv != -1) dfs(hv, true);
ans[r] = max(ans[r], ch(r, r));
dp[memo[r]] = max(dp[memo[r]], dep[r]);
for (auto v : G[r])
if (v.first != hv) {
for (int i = oi_in[v.first]; i < oi_out[v.first]; i++)
ans[r] = max(ans[r], ch(oi[i], r));
for (int i = oi_in[v.first]; i < oi_out[v.first]; i++)
dp[memo[oi[i]]] = max(dp[memo[oi[i]]], dep[oi[i]]);
}
if (!keep) {
for (int i = oi_in[r]; i < oi_out[r]; i++) dp[memo[oi[i]]] = -1;
}
}
int dfs_las(int r) {
for (auto v : G[r]) ans[r] = max(ans[r], dfs_las(v.first));
return ans[r];
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int i = 0; i < (1 << 22); i++) dp[i] = -1;
int n;
cin >> n;
oi.resize(n);
for (int i = 2; i <= n; i++) {
int y;
char c;
cin >> y >> c;
G[y].push_back(make_pair(i, c - 'a'));
}
dfs_s(1);
ve.push_back(0);
for (int i = 0; i < 22; i++) ve.push_back(1 << i);
dfs(1, true);
dfs_las(1);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(){
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a), q(b), r(c), d(0);
rep(i, a) cin >> p[i];
rep(i, b) cin >> q[i];
rep(i, c) cin >> r[i];
sort(p.begin(), p.end(), greater<int>());
sort(q.begin(), q.end(), greater<int>());
rep(i, x) d.emplace_back(p[i]);
rep(i, y) d.emplace_back(q[i]);
rep(i, c) d.emplace_back(r[i]);
sort(d.begin(), d.end(), greater<int>());
ll ans = 0;
rep(i, x + y) ans += d[i];
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long solve(long long a, long long b, long long c, long long d) {
if (b == 0 && d == 0) return 1;
if (b == 0 || d == 0) return 0;
long long ans = 0;
for (int i = 0; i <= 1; i++) {
long long a0 = i * c + d % c;
if (a0 > b || a0 > d) break;
if ((b - a0) % a == 0)
ans = (ans + solve(a, (b - a0) / a, c, (d - a0) / c)) % 1000000007;
}
return ans % 1000000007;
}
int main() {
long long t, a, b;
cin >> t >> a >> b;
if (t == 1 && a == 1) {
if (b == 1)
cout << "inf" << endl;
else
cout << 0 << endl;
return 0;
}
cout << solve(t, a, a, b) % 1000000007;
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <sstream>
using namespace std;
int main(){
string str;
while(getline(cin, str)){
stringstream ss;
vector<int> hand;
if(str == "0") break;
int begin = 0;
int point = 0;
int one = 0;
bool isbust = false;
for(int i=0; i<str.size(); i++){
if(str[i] == ' ' || i == str.size()-1){
int tmp;
ss << str.substr(begin, i-begin+1);
ss >> tmp;
if(tmp < 10){
hand.push_back(tmp);
}else{
hand.push_back(10);
}
begin = i + 1;
}
}
for(int i=0; i<hand.size(); i++){
if(hand[i] == 1){
one++;
}else{
point += hand[i];
}
}
point += one*11;
while(one--&&point>21){
point -= 10;
}
if(point > 21){
cout << "0" << endl;
}else{
cout << point << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> p[101];
bool arr[99999999];
int ans[101];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].first.second >> p[i].first.first;
p[i].second = i;
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
while (arr[p[i].first.second]) {
p[i].first.second++;
}
ans[p[i].second] = p[i].first.second;
arr[p[i].first.second] = 1;
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long labs(long long a) { return a < 0 ? (-a) : a; }
void FAIL() {
cout << "Error occurred" << endl;
exit(0);
}
struct Pair {
int parent;
int first;
int second;
int cnt;
Pair(int p) : parent(p), cnt(0) {}
Pair(int p, int c) : parent(p), cnt(c) {}
bool IsInt() { return cnt < 0; }
void Add(int i) {
if (cnt == 0)
first = i;
else if (cnt == 1)
second = i;
else
FAIL();
cnt++;
}
};
vector<Pair> pairs;
int cur = 0;
void Cout(int i) {
if (pairs[i].IsInt()) {
printf("int");
} else {
printf("pair<");
Cout(pairs[i].first);
printf(",");
Cout(pairs[i].second);
printf(">");
}
}
int main() {
string s;
string ans = "";
int n;
cin >> n;
pairs.reserve(2 * n);
pairs.push_back(Pair(-1));
while (cin >> s) {
if (s == "pair") {
pairs[cur].Add(pairs.size());
pairs.push_back(Pair(cur));
cur = pairs.size() - 1;
} else {
pairs[cur].Add(pairs.size());
pairs.push_back(Pair(cur, -1));
while (pairs[cur].cnt == 2) {
if (cur == 0) FAIL();
cur = pairs[cur].parent;
}
}
}
if (cur != 0 || pairs[cur].cnt != 1) {
FAIL();
}
Cout(pairs[0].first);
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
using namespace std;
const long long N = 2e3 + 100, OO = 1e9 + 7, K = 3e5 + 100, T = 5, M2 = 1e9 + 7,
M = 998244353, P = 6151, SQ = 810, lg = 20;
long long fac[N], inv[N], dp[N][N], a[N][N], fen[4][N], n, d;
bool mark[N];
long long pw(long long x, long long y) {
if (y == 0) return 1;
long long cnt = pw(x, y / 2);
cnt = (cnt * cnt) % M;
cnt = (cnt * (y % 2 == 1 ? x : 1)) % M;
return cnt;
}
void init() {
fac[0] = 1;
for (long long i = 1; i <= N - lg; i++) fac[i] = (fac[i - 1] * i) % M;
inv[N - lg] = pw(fac[N - lg], M - 2);
for (long long i = N - lg - 1; ~i; i--) inv[i] = (inv[i + 1] * (i + 1)) % M;
}
long long c(long long x, long long y) {
return ((fac[x] * inv[y] % M) * inv[x - y]) % M;
}
void upd(bool b, long long x, long long y) {
for (; x <= n; x += (x & -x)) fen[b][x] += y;
}
long long get(bool b, long long x) {
long long cnt = 0;
for (; x; x -= (x & -x)) cnt += fen[b][x];
return cnt;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
init();
cin >> n;
dp[0][0] = 1;
for (long long len = 1; len <= n; len++) {
for (long long i = 0; i <= len; i++) {
long long j = len - i;
if (i) {
dp[i][j] = dp[i - 1][j] * i % M;
if (j) dp[i][j] = (dp[i][j] + dp[i][j - 1] * j) % M;
} else if (j > 1)
dp[i][j] = dp[i + 1][j - 2] * (j - 1) % M;
}
}
d = dp[0][n];
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) cin >> a[i][j];
for (long long i = 1; i <= n; i++) upd(0, i, +1);
long long ans = 0;
for (long long i = 1; i <= n; i++)
upd(0, a[1][i], -1), ans = (ans + get(0, a[1][i]) * fac[n - i] % M) % M;
ans = (ans * pw(d, n - 1)) % M;
for (long long j = 2; j <= n; j++) {
for (long long i = 1; i <= n; i++) upd(0, i, +1), mark[i] = false;
long long cnt = 0, num = 0, cmp = n;
for (long long i = 1; i <= n; i++) {
if (mark[a[j - 1][i]]) {
if (num) cnt = (cnt + get(1, a[j][i] - 1) * dp[num - 1][cmp] % M) % M;
if (cmp) cnt = (cnt + get(0, a[j][i] - 1) * dp[num][cmp - 1] % M) % M;
} else {
if (cmp) cnt = (cnt + get(1, a[j][i] - 1) * dp[num][cmp - 1] % M) % M;
if (cmp > 1) {
long long h = get(0, a[j][i] - 1);
if (a[j - 1][i] < a[j][i]) h--;
cnt = (cnt + h * dp[num + 1][cmp - 2] % M) % M;
}
}
if (mark[a[j][i]]) {
if (mark[a[j - 1][i]])
num--, upd(1, a[j][i], -1), mark[a[j][i]] = mark[a[j - 1][i]] = false;
else
upd(1, a[j][i], -1), upd(0, a[j - 1][i], -1), upd(1, a[j - 1][i], +1),
cmp--, mark[a[j][i]] = false, mark[a[j - 1][i]] = true;
} else {
if (mark[a[j - 1][i]])
upd(0, a[j][i], -1), cmp--, mark[a[j - 1][i]] = false,
mark[a[j][i]] = true;
else
upd(0, a[j - 1][i], -1), upd(0, a[j][i], -1), upd(1, a[j - 1][i], +1),
cmp -= 2, num++, mark[a[j - 1][i]] = mark[a[j][i]] = true;
}
}
cnt = (cnt * pw(d, n - j)) % M;
ans = (ans + cnt) % M;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const long long INF = 1e18;
long long t[4 * MAXN], lazy[4 * MAXN];
void build(int v, int l, int r, int a[]) {
if (l == r) {
t[v] = a[l];
return;
}
int m = (l + r) >> 1;
build(2 * v, l, m, a);
build(2 * v + 1, m + 1, r, a);
t[v] = min(t[2 * v], t[2 * v + 1]);
return;
}
void push(int v) {
t[v * 2] += lazy[v];
lazy[v * 2] += lazy[v];
t[v * 2 + 1] += lazy[v];
lazy[v * 2 + 1] += lazy[v];
lazy[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, int addend) {
if (l > tr || r < tl) return;
if (tl >= l && tr <= r) {
t[v] += addend;
lazy[v] += addend;
} else {
push(v);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, r, addend);
update(v * 2 + 1, tm + 1, tr, l, r, addend);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
long long get_value(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return INF;
if (tl >= l && tr <= r) return t[v];
push(v);
int tm = (tl + tr) / 2;
return min(get_value(v * 2, tl, tm, l, r),
get_value(v * 2 + 1, tm + 1, tr, l, r));
}
int main() {
long long n, j = 0, m, x;
char temp;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
build(1, 0, n - 1, a);
cin >> m;
int b[3];
for (int i = 0; i < m; ++i) {
do {
scanf("%d%c", &b[j], &temp);
j++;
} while (temp != '\n');
j--;
if (j == 2) {
if (b[0] <= b[1]) {
update(1, 0, n - 1, b[0], b[1], b[2]);
} else {
update(1, 0, n - 1, b[0], n - 1, b[2]);
update(1, 0, n - 1, 0, b[1], b[2]);
}
} else {
if (b[0] <= b[1]) {
x = get_value(1, 0, n - 1, b[0], b[1]);
} else {
x = min(get_value(1, 0, n - 1, 0, b[1]),
get_value(1, 0, n - 1, b[0], n - 1));
}
cout << x << "\n";
}
j = 0;
}
}
| 3 |
#include <bits/stdc++.h>
const int INF = 2000000777;
int n, m;
int tab[20][10004];
int cost[17][17];
int endcost[17][17];
int dp[16][16][70000];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m;
for (int i = 0; i < (17); ++i)
for (int j = 0; j < (17); ++j) cost[i][j] = endcost[i][j] = INF;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) std::cin >> tab[i][j];
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j) {
for (int k = 0; k < (m - 1); ++k)
endcost[i][j] =
std::min(endcost[i][j], std::abs(tab[i][k] - tab[j][k + 1]));
if (i == j) continue;
for (int k = 0; k < (m); ++k)
cost[i][j] = std::min(cost[i][j], std::abs(tab[i][k] - tab[j][k]));
}
if (n == 1) {
std::cout << endcost[0][0];
return 0;
}
for (int i = 0; i < (n); ++i) dp[i][i][1 << i] = INF;
for (int mask = 0; mask < (1 << n); ++mask) {
if (mask == ((1 << n) - 1)) {
int best = 0;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j) {
if (i == j) continue;
best = std::max(best, std::min(dp[i][j][mask], endcost[i][j]));
}
std::cout << best;
return 0;
}
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j) {
if (!((1 << i) & mask) || !((1 << j) & mask)) continue;
for (int k = 0; k < (n); ++k) {
if ((1 << k) & mask) continue;
if (i == j)
dp[i][k][mask | (1 << k)] =
std::max(dp[i][k][mask | (1 << k)],
std::min(dp[i][i][mask], cost[i][k]));
else
dp[i][k][mask | (1 << k)] =
std::max(dp[i][k][mask | (1 << k)],
std::min(dp[i][j][mask], cost[j][k]));
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int getMaxArea(int hist[], int n) {
stack<int> s;
int max_area = 0;
int tp;
int area_with_top;
int i = 0;
while (i < n) {
if (s.empty() || hist[s.top()] <= hist[i])
s.push(i++);
else {
tp = s.top();
s.pop();
area_with_top = hist[tp] * (s.empty() ? i : i - s.top() - 1);
if (max_area < area_with_top) max_area = area_with_top;
}
}
while (s.empty() == false) {
tp = s.top();
s.pop();
area_with_top = hist[tp] * (s.empty() ? i : i - s.top() - 1);
if (max_area < area_with_top) max_area = area_with_top;
}
return max_area;
}
int d[5010][5010];
int main() {
int n, m;
scanf("%d", &n);
;
scanf("%d", &m);
;
char s[5010];
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = m - 1; j >= 0; j--) {
if (s[j] == '1')
d[i][j] = 1 + d[i][j + 1];
else
d[i][j] = 0;
}
}
int ans = 0, hist[5010];
for (int i = 0; i < m; i++) {
int h[5010] = {}, in = 0;
for (int j = 0; j < n; j++) h[d[j][i]]++;
for (int j = 0; j < (m + 2); j++)
while (h[j]) {
hist[in++] = j;
h[j]--;
}
ans = max(ans, getMaxArea(hist, n));
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2> &p) const {
auto h1 = std::hash<T1>{}(p.first);
auto h2 = std::hash<T2>{}(p.second);
return h1 ^ h2;
}
};
using vote = pair<int, int>;
using Unordered_map = unordered_map<vote, int, pair_hash>;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int b[n];
for (int i = 0; i < n; i++) cin >> b[i];
int c = 0, d = 0, e = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) c++;
if (b[i] == 1) d++;
if (a[i] == b[i] && a[i] == 1) e++;
}
if (e == c)
cout << -1;
else {
c -= e;
d -= e;
if ((d + 1) % c == 0)
cout << (d + 1) / c;
else
cout << (d + 1) / c + 1;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int ans[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> ans[a[i] - 1];
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 1;
const int INF = 1e9 * 2;
const int MOD = 1e9 + 7;
bool used[101];
int n, m, x;
vector<pair<int, int> > h;
int main(void) {
cin >> n;
int a;
pair<int, int> pr[n];
for (int i = 0; i < n; ++i) {
cin >> a;
pr[i] = make_pair(a, i);
}
sort(pr + 1, pr + n);
if (pr[0].first == 0) {
cout << -1;
return 0;
}
for (int j = n - 1; j > 0; --j)
if (pr[0].first) {
used[j] = 1;
pr[0].first--;
h.push_back(make_pair(1, pr[j].second + 1));
} else
break;
for (int i = n - 1; i > 0; --i) {
for (int j = n - 1; j > 0; --j) {
if (pr[i].first && !used[j]) {
used[j] = 1;
pr[i].first--;
h.push_back(make_pair(pr[i].second + 1, pr[j].second + 1));
} else if (!pr[i].first)
break;
}
}
for (int i = 1; i < n; ++i)
if (!used[i]) {
cout << -1;
return 0;
}
cout << h.size() << endl;
for (int i = 0; i < h.size(); ++i) {
cout << h[i].first << ' ' << h[i].second << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
vector<long long> v;
cin >> n;
long long a = 1;
while (a * (a + 1) / 2 <= n) v.push_back(a * (a + 1) / 2), a++;
for (long long i = 1; i * (i + 1) / 2 <= n; i++) {
int cur = n - i * (i + 1) / 2;
if (binary_search(v.begin(), v.end(), cur)) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MOD = (int)1e9 + 7;
inline int lgput(int a, int b) {
int ans = 1;
while (b > 0) {
if (b & 1) ans = (1LL * ans * a) % MOD;
b >>= 1;
a = (1LL * a * a) % MOD;
}
return ans;
}
inline void mod(int &x) {
if (x >= MOD) x -= MOD;
}
inline void add(int &x, int y) {
x += y;
mod(x);
}
inline void sub(int &x, int y) {
x += MOD - y;
mod(x);
}
inline void mul(int &x, int y) { x = (1LL * x * y) % MOD; }
inline int inv(int x) { return lgput(x, MOD - 2); }
using namespace std;
const int MAXN = 2005;
char mat[MAXN + 1][MAXN + 1];
int u[MAXN + 1][MAXN + 1], l[MAXN + 1][MAXN + 1];
int cnt_d[MAXN + 1][MAXN + 1], cnt_r[MAXN + 1][MAXN + 1];
int sp_l[MAXN + 1][MAXN + 1], sp_u[MAXN + 1][MAXN + 1];
int main() {
int i, j, n, m;
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> mat[i] + 1;
}
if (max(n, m) == 1) {
cout << 1;
return 0;
}
for (i = n; i >= 1; i--) {
for (j = m; j >= 1; j--) {
cnt_r[i][j] = cnt_r[i][j + 1] + (mat[i][j] == 'R');
cnt_d[i][j] = cnt_d[i + 1][j] + (mat[i][j] == 'R');
}
}
add(sp_l[1][1], 1);
sub(sp_l[1][m - cnt_r[1][1] + 1], 1);
add(sp_u[1][1], 1);
sub(sp_u[n - cnt_d[1][1] + 1][1], 1);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
add(sp_u[i][j], sp_u[i - 1][j]);
add(sp_l[i][j], sp_l[i][j - 1]);
l[i][j] = sp_l[i][j];
u[i][j] = sp_u[i][j];
if ((i == n && j == m) || (i == 1 && j == 1)) continue;
add(sp_u[i + 1][j], l[i][j]);
sub(sp_u[n - cnt_d[i + 1][j] + 1][j], l[i][j]);
add(sp_l[i][j + 1], u[i][j]);
sub(sp_l[i][m - cnt_r[i][j + 1] + 1], u[i][j]);
}
}
if (mat[n][m] == 'R') {
cout << 0;
return 0;
}
cout << (l[n][m] + u[n][m]) % MOD;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll=long long;
int main(){
int x;
cin>>x;
int n=2;
vector<int>ans;
while(ans.size()<x){
bool ng=false;
for(int j=2; j<=sqrt(n); ++j){
if(n%j==0)ng=true;
}
if(!ng)if(n%5==1)ans.push_back(n);
n++;
}
rep(i,x)cout<<ans[i]<<" ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
int main() {
int t;
cin >> t;
while (t--) {
ll a, b;
cin >> a >> b;
ll c = a * b;
ll ans = ((ll) sqrt(c) - 1) * 2;
if ((ll) sqrt(c) * (ll) sqrt(c) == c && a != b)
ans--;
if ((ll) sqrt(c) * ((ll) sqrt(c) + 1) < c)
ans++;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
string s;
cin>>s;
int c=0;
for(int i=0; i<n; i++) if(s[i]=='E') c++;
int mn=n;
for(int i=0; i<n; i++){
if(s[i]=='E') c--;
mn=min(mn, c);
if(s[i]=='W') c++;
}
cout<<mn<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int mod = 1e9 + 7;
const int N = 2e5 + 7;
const ll INF = 1e18;
const double PI = 3.1415926535897932384626;
void solve() {
int n, m;
cin >> n >> m;
int r = 0;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
r += a;
cout << r / m << " ";
r %= m;
}
}
void fastIO(string name = "") {
cin.tie(0)->sync_with_stdio(0);
if (int((name).size())) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
}
int main() {
fastIO("");
int tc = 1;
while (tc--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
//container util
//------------------------------------------
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
//constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
struct Trie{
int num;
Trie* chd[27];
Trie(){
REP(i,27) chd[i] = nullptr;
num = 0;
}
void insert(int l, int b, int e, VS& vs, VS& idx){
num = e - b;
if(e - b == 1)
return;
int s = min(SZ(vs[b]),SZ(vs[e-1]));
int i;
for(i=l;i<s;++i){
if(vs[b][i] != vs[e-1][i]){
break;
}
}
int prv = b;
char c = vs[b][i];
for(int j=b;j<e;++j){
idx[j].PB(vs[j][i]);
if(vs[j][i] != c){
chd[c-'`'] = new Trie();
chd[c-'`']->insert(i+1, prv, j, vs, idx);
prv = j;
c = vs[j][i];
}
}
chd[c-'`'] = new Trie();
chd[c-'`']->insert(i+1, prv, e, vs, idx);
}
int index(string& s, string& ord, int l = 0){
if(l == SZ(s)) return 0;
int res = 0;
int i = 0;
while(ord[i] != s[l]){
if(chd[ord[i]-'`'] != nullptr)
res += chd[ord[i]-'`']->num;
++i;
}
res += chd[ord[i]-'`']->index(s, ord, l+1);
return res;
}
};
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int N; cin >> N;
VS data(N);
vector<pair<string,int>> vs(N);
REP(i,N){
cin >> vs[i].FF;
vs[i].FF += "`";
vs[i].SS = i;
}
SORT(vs);
VI inv(N);
REP(i,N) inv[vs[i].SS] = i;
REP(i,N) data[i] = vs[i].FF;
VS idx(N);
Trie trie;
trie.insert(0, 0, N, data, idx);
int Q; cin >> Q;
while(Q--){
int k;
string ord;
cin >> k >> ord;
--k;
ord = "`" + ord;
cout << trie.index(idx[inv[k]], ord)+1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int D, G;
cin >> D >> G;
vector<int> p(D);
vector<int> c(D);
for (int i=0; i<D; i++){
cin >> p[i] >> c[i];
}
int ans = 1000000000;
for(int i=0; i< (1 << D);i++){
int score=0, solved=0, other=-1, hoge=i;
for (int j=0; j<D; j++){
if (hoge&1){
score += 100*(j+1)*p[j]+c[j];
solved += p[j];
} else {
other = j;
}
hoge >>= 1;
}
if (score < G){
if (G > score+p[other]*100*(other+1)) continue;
solved += ceil((G-score)/(double)(100*(other+1)));
}
ans = min(ans, solved);
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool del[200006];
vector<int> ss[26];
int main() {
int k, m, a, len, i, j, id;
char str[110], s[3];
while (scanf("%d", &k) != EOF) {
scanf("%s", str);
len = strlen(str);
memset(del, 0, sizeof(bool) * (len * k));
for (i = 0; i < 26; i++) ss[i].clear();
for (j = 0; j < k; j++) {
for (i = 0; i < len; i++) ss[str[i] - 'a'].push_back(i + j * len);
}
scanf("%d", &m);
while (m--) {
scanf("%d%s", &a, s);
id = s[0] - 'a';
del[ss[id][a - 1]] = 1;
ss[id].erase(ss[id].begin() + a - 1);
}
for (j = 0; j < k; j++) {
for (i = 0; i < len; i++) {
if (!del[i + j * len]) printf("%c", str[i]);
}
}
printf("\n");
}
return 0;
}
| 3 |
#include<iostream>
#include<algorithm>
#include<iomanip>
using namespace std;
int n;
double t[110],v[110],sum[110];
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>t[i+1];
sum[i+1]=sum[i]+t[i+1];
}
for(int i=0;i<n;i++)cin>>v[i+1];
double ans=0;
double p=0;
int f=0;
for(double i=0.5;i<=sum[n];i+=0.5)
{
if(i>sum[f])f++;
double now=v[f];
for(int j=0;j<=n+1;j++)
{
double c=now;
if(j<f)
{
c=v[j]+i-sum[j];
}
else if(j>f)
{
c=v[j]+sum[j-1]-i;
}
if(now>c)now=c;
}
ans+=(p+now)/4.0;
p=now;
}
cout<<fixed<<setprecision(9)<<ans<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
string s;
map<string, int> polling;
int max_count = 0;
for(int i = 0; i < n; ++i){
cin >> s;
polling[s]++;
max_count = max(max_count, polling[s]);
}
for(auto p: polling){
if(p.second == max_count) cout << p.first << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ini[202020], fim[202020], ptr = 1, sta[202020 * 3], stb[202020 * 3],
lazy[202020 * 3], base[202020];
vector<int> adj[202020];
void upd_lazy(int b, int l, int r) {
if (lazy[b] == 0) return;
swap(sta[b], stb[b]);
if (l != r) {
int fe = b << 1, fd = fe | 1;
lazy[fe] ^= 1;
lazy[fd] ^= 1;
}
lazy[b] = 0;
}
void upd(int b, int l, int r, int first, int second) {
upd_lazy(b, l, r);
if (l > second || r < first) return;
if (l >= first && r <= second) {
lazy[b] ^= 1;
upd_lazy(b, l, r);
return;
}
int fe = b << 1, fd = fe | 1, m = (l + r) >> 1;
upd(fe, l, m, first, second), upd(fd, m + 1, r, first, second);
sta[b] = sta[fe] + sta[fd];
stb[b] = stb[fe] + stb[fd];
}
int query(int b, int l, int r, int first, int second) {
if (l > second || r < first) return 0;
upd_lazy(b, l, r);
if (first <= l && r <= second) return sta[b];
int fe = b << 1, fd = fe | 1, m = (l + r) >> 1;
return query(fe, l, m, first, second) + query(fd, m + 1, r, first, second);
}
void build(int b, int l, int r) {
if (l == r) {
if (base[l] == 1) sta[b]++;
if (base[l] == 0) stb[b]++;
return;
}
int fe = b << 1, fd = fe | 1, m = (l + r) >> 1;
build(fe, l, m), build(fd, m + 1, r);
sta[b] = sta[fe] + sta[fd];
stb[b] = stb[fe] + stb[fd];
}
void dfs(int v) {
ini[v] = ptr++;
for (int(i) = (0); (i) < (((int)(adj[v]).size())); (i)++) dfs(adj[v][i]);
fim[v] = ptr - 1;
}
int main() {
memset(base, -1, sizeof(base));
int n;
scanf("%d", &n);
for (int(i) = (1); (i) < (n); (i)++) {
int p;
scanf("%d", &p);
p--;
adj[p].push_back(i);
}
dfs(0);
for (int(i) = (0); (i) < (n); (i)++) {
int v;
scanf("%d", &v);
base[ini[i]] = v;
}
build(1, 0, 202020);
int q;
scanf("%d", &q);
while (q--) {
char s[5];
int v;
scanf("%s%d", s, &v);
v--;
if (s[0] == 'g')
printf("%d\n", query(1, 0, 202020, ini[v], fim[v]));
else
upd(1, 0, 202020, ini[v], fim[v]);
}
}
| 5 |
#include <bits/stdc++.h>
const int N = 1e5 + 51;
struct edge {
int to, next, w;
} e[N << 1];
int head[N], cnt;
void addedge(int x, int y, int z) {
e[++cnt] = (edge){y, x[head], z}, x[head] = cnt;
e[++cnt] = (edge){x, y[head], z}, y[head] = cnt;
}
int col[N], par[N], vis[N], pt, pv, ans, a2, mxdep;
std::vector<int> v;
void upd(int x) {
if (x > ans) ans = x, a2 = 0;
a2 += x == ans;
}
void dfs1(int x, int p, int d, int *arr) {
x[par] = p, x[arr] = d;
if (x[col] && d > pv) pv = d, pt = x;
for (int i = x[head], nx; i; i = e[i].next)
if ((nx = e[i].to) != p) dfs1(nx, x, d + e[i].w, arr);
}
int dfs2(int x, int p, int d) {
if (x[col]) mxdep = std::max(mxdep, d);
int c = x[col];
for (int i = x[head], nx; i; i = e[i].next)
if ((nx = e[i].to) != p && !nx[vis]) c += dfs2(nx, x, d + e[i].w);
if (!x[col]) upd(c);
return c;
}
int n, x, y, z, s, t, disL[N], disR[N], L[N], R[N], sz[N], dep[N], sL, sR;
std::vector<int> lnk;
int main() {
for (scanf("%d%d", &n, &x); x--;) scanf("%d", &y), y[col] = 1;
for (int i = 1; i < n; i++) scanf("%d%d%d", &x, &y, &z), addedge(x, y, z);
dfs1(1, 0, 0, disL), s = pt, pv = -1;
dfs1(s, 0, 0, disL), t = pt, pv = -1;
dfs1(t, 0, 0, disR);
for (int i = s; i; i = i[par]) lnk.push_back(i), i[vis] = 1;
for (int i : lnk) mxdep = -1, i[sz] = dfs2(i, 0, 0), x[dep] = mxdep;
for (int i : lnk) {
if (i[disL] < i[disR]) i[R] += i[sz], sR += i[sz];
}
std::reverse(lnk.begin(), lnk.end());
for (int i : lnk) {
if (i[disL] > i[disR]) i[L] += i[sz];
}
for (int i : lnk) {
sR -= i[R];
if (!i[col]) upd(sL + sR + i[sz]);
sL += i[L];
}
printf("%d %d", ans, a2);
}
| 5 |
#include <bits/stdc++.h>
using std::lower_bound;
using std::max;
using std::min;
using std::random_shuffle;
using std::reverse;
using std::sort;
using std::swap;
using std::unique;
using std::upper_bound;
using std::vector;
void open(const char *s) {}
void open2(const char *s) {}
int rd() {
int s = 0, c, b = 0;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-') {
c = getchar();
b = 1;
}
do {
s = s * 10 + c - '0';
} while ((c = getchar()) >= '0' && c <= '9');
return b ? -s : s;
}
void put(int x) {
if (!x) {
putchar('0');
return;
}
static int c[20];
int t = 0;
while (x) {
c[++t] = x % 10;
x /= 10;
}
while (t) putchar(c[t--] + '0');
}
int upmin(int &a, int b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int upmax(int &a, int b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
const long long p = 1000000007;
const int N = 2000010;
int pri[N], cnt, b[N];
int c[N];
int s[N];
int a[N];
void init() {
int maxn = 2000000;
for (int i = 2; i <= maxn; i++) {
if (!b[i]) {
pri[++cnt] = i;
c[i] = i;
}
for (int j = 1; j <= cnt && i * pri[j] <= maxn; j++) {
b[i * pri[j]] = 1;
c[i * pri[j]] = pri[j];
if (i % pri[j] == 0) break;
}
}
}
std::pair<int, int> d[N];
std::pair<int, int> s1[N], s2[N];
int n, t;
int bb[N];
int main() {
open("d");
scanf("%d", &n);
int flag = 0;
init();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1, std::greater<int>());
for (int i = 1; i <= n; i++) {
if (s[a[i]] == 0) {
s[a[i]]++;
if (a[i] == 2) s[a[i]]++;
bb[i] = 2;
if (!s1[a[i]].first) {
if (std::pair<int, int>(a[i], i) > s1[a[i]]) {
s2[a[i]] = s1[a[i]];
s1[a[i]] = std::pair<int, int>(a[i], i);
} else
s2[a[i]] = max(s2[a[i]], std::pair<int, int>(a[i], i));
continue;
}
}
if (s[a[i]] == 1) {
s[a[i]]++;
t = 0;
for (int j = a[i] - 1; j != 1; j /= c[j])
if (!t || d[t].first != c[j])
d[++t] = std::pair<int, int>(c[j], c[j]);
else
d[t].second *= c[j];
for (int j = 1; j <= t; j++) {
int v = d[j].first;
d[j].first = d[j].second;
d[j].second = i;
if (d[j] > s1[v]) {
s2[v] = s1[v];
s1[v] = d[j];
} else
s2[v] = max(s2[v], d[j]);
}
bb[i] = 1;
} else
flag = 1;
}
for (int i = 1; i <= n && !flag; i++)
if (bb[i] == 2) {
if (s1[a[i]].second == i) {
if (s2[a[i]].first == s1[a[i]].first) {
flag = 1;
break;
}
} else {
flag = 1;
break;
}
} else if (bb[i] == 1) {
t = 0;
for (int j = a[i] - 1; j != 1; j /= c[j])
if (!t || d[t].first != c[j])
d[++t] = std::pair<int, int>(c[j], c[j]);
else
d[t].second *= c[j];
int ff = 1;
for (int j = 1; j <= t; j++) {
int v = d[j].first;
if (s1[v].second == i) {
if (s2[v].first == s1[v].first)
;
else
ff = 0;
}
}
if (ff) {
flag = 1;
break;
}
}
long long ans = 1;
for (int i = 1; i <= 2000000; i++)
if (s1[i].first) ans = ans * s1[i].first % p;
if (flag) ans++;
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int T = 1e9 + 7;
long long f[30], s, q;
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= (a / b) * x;
return;
}
void pre(int n) {
long long x, y;
q = 1;
for (int i = 1; i < n; i++) exgcd(i, T, x, y), q *= x, q %= T;
return;
}
int cal(long long a, int b) {
long long ans = q;
a %= T;
for (int i = 0; i < b; i++) ans *= (a - i), ans %= T;
return ans;
}
int main() {
int n;
cin >> n >> s;
for (int i = 1; i <= n; i++) cin >> f[i];
pre(n);
long long ans = cal(s + n - 1, n - 1);
for (int i = 1; i < (1 << n); i++) {
int cnt = 0;
long long buf = s + n - 1;
for (int j = 0; j < n; j++)
if (i & (1 << j)) buf -= f[j + 1] + 1, cnt++;
if (buf < n - 1) continue;
if (cnt & 1)
ans -= cal(buf, n - 1);
else
ans += cal(buf, n - 1);
ans %= T;
}
if (ans < 0) ans += T;
cout << ans << endl;
return 0;
}
| 5 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
#define mpr make_pair
#define dingyi int mid = l + r >> 1, ls = p << 1, rs = p << 1 | 1
#define y0 y_csyakioi_0
#define y1 y_csyakioi_1
#define rep(i, x, y) for(int i = x; i <= y; ++i)
#define per(i, x, y) for(int i = x; i >= y; --i)
#define repg(i, u) for(int i = head[u]; i; i = e[i].nxt)
inline int read(){
int x = 0, f = 1; char ch = getchar();
while(ch < '0' || ch > '9'){ if(ch == '-') f = -1; ch = getchar(); }
while(ch >= '0' && ch <= '9'){ x = x * 10 + (ch ^ 48); ch = getchar(); }
return x * f;
}
const int N = 1010, mod = 998244353;
int n, a[N], x, y, ans, k, sum;
inline int fpow(int x, int p){ int ans = 1; for(; p; p >>= 1, x = 1ll * x * x % mod) if(p & 1) ans = 1ll * ans * x % mod; return ans; }
inline void mian(){
n = read(); rep(i, 1, n) sum += (a[i] = read());
if(n == 1){ puts("0"); return; }
sort(a + 1, a + n + 1); a[++n] = sum;
x = y = 1;
int j = 0; rep(i, 1, sum){
x = 1ll * x * (2 * sum - i) % mod; y = 1ll * y * (sum - i + 1) % mod;
while(j <= n && a[j + 1] == i){
++j; k = (1ll * x * fpow(y, mod - 2) % mod - 1 + mod) % mod;
if(j != n) ans = (ans + k) % mod;
else ans = (ans - k + mod) % mod;
}
}
ans = 1ll * ans * sum % mod * fpow(sum - 1, mod - 2) % mod;
printf("%d\n", (mod - 2ll * ans % mod) % mod);
}
int main(){ int qwq = 1; while(qwq--) mian(); return 0; }
| 5 |
#include <cstdio>
#include <algorithm>
using namespace std;
char mark[4] = "+-*";
int oper(int cmd, int lhs, int rhs){
switch(cmd){
case 0: return lhs + rhs;
case 1: return lhs - rhs;
case 2: return lhs * rhs;
}
return 0;
}
int main(){
int n[4];
bool success;
while( true ){
success = false;
scanf("%d %d %d %d", n, n+1, n+2, n+3);
if( n[0] + n[1] + n[2] + n[3] == 0) break;
sort(n, n + 4);
int i, j, k;
do{
for(i = 0; !success && i < 3; i++){
int t1 = oper(i, n[0], n[1]);
for(j = 0; !success && j < 3; j++){
int t2 = oper(j, t1, n[2]);
for(k = 0; !success && k < 3; k++){
int res = oper(k, t2, n[3]);
if( res == 10 ){
success = true;
break;
}
}
}
}
}while( !success && next_permutation(n, n + 4) );
if( success ){
char str1[12], str2[24], str3[32];
i--; j--;
sprintf(str1, "(%d %c %d)", n[0], mark[i], n[1]);
sprintf(str2, "(%s %c %d)", str1, mark[j], n[2]);
sprintf(str3, "(%s %c %d)", str2, mark[k], n[3]);
printf("%s\n", str3);
continue;
}
do{
for(i = 0; !success && i < 3; i++){
int t1 = oper(i, n[0], n[1]);
for(j = 0; !success && j < 3; j++){
int t2 = oper(j, n[2], n[3]);
for(k = 0; !success && k < 3; k++){
int res = oper(k, t1, t2);
if( res == 10 ){
success = true;
break;
}
}
}
}
}while( !success && next_permutation(n, n + 4) );
if( success ){
i--; j--;
char str1[8], str2[16], str3[24];
sprintf(str1, "(%d %c %d)", n[0], mark[i], n[1]);
sprintf(str2, "(%d %c %d)", n[2], mark[j], n[3]);
sprintf(str3, "(%s %c %s)", str1, mark[k], str2);
printf("%s\n", str3);
continue;
}
do{
for(i = 0; !success && i < 3; i++){
int t1 = oper(i, n[1], n[2]);
for(j = 0; !success && j < 3; j++){
int t2 = oper(j, t1, n[3]);
for(k = 0; !success && k < 3; k++){
int res = oper(k, n[0], t2);
if( res == 10 ){
success = true;
break;
}
}
}
}
}while( !success && next_permutation(n, n + 4) );
if( success ){
char str1[8], str2[16], str3[24];
sprintf(str1, "(%d %c %d)", n[1], mark[i], n[2]);
sprintf(str2, "(%s %c %d)", str1, mark[j], n[3]);
sprintf(str3, "(%d %c %s)", n[0], mark[k], str2);
printf("%s\n", str3);
continue;
}
puts("0");
}
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
int bind(int a, int b){
int x = 1;
while(b >= x)x *= 10;
return a * x + b;
}
int a[1080];
void solve(int n, int K){
set<int> s;
for(int i = 0;i < n;i++){
cin >> a[i];
}
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
for(int k = 0;k < n;k++){
for(int l = 0;l < n;l++){
if(i == j || i == k || i == l || j == k || j == l || k == l)continue;
int ans = a[i];
if(K >= 2)ans = bind(a[j], ans);
if(K >= 3)ans = bind(a[k], ans);
if(K >= 4)ans = bind(a[l], ans);
s.insert(ans);
}
}
}
}
cout << s.size() << endl;
}
int main(){
int n, k;
while(true){
cin >> n >> k;
if(n == 0 && k == 0)return 0;
solve(n, k);
}
}
| 0 |
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
struct St{
int x;
int y;
int sp;
};
int ydir[12] = {-1, 0, 1, -2, 2, -2, 2, -2, 2, -1, 0, 1};
int xdir[12] = {-2, -2, -2, -1, -1, 0, 0, 1, 1, 2, 2, 2};
bool bfs(bool a[11][11][11], St py, int n)
{
bool f = false;
queue<St> que;
que.push(py);
St s, t;
while(!que.empty()){
s = que.front();
que.pop();
if(s.sp == n){
f = true;
break;
}
t.sp = s.sp+1;
for(int i = 0; i < 12; i++){
t.y = s.y + ydir[i];
t.x = s.x + xdir[i];
if(0 <= t.x && t.x <= 9 && 0 <= t.y && t.y <= 9 && a[t.x][t.y][t.sp]){
que.push(t);
a[t.x][t.y][t.sp] = false;
}
}
}
return f;
}
int main()
{
int n, s, t;
St py;
bool a[11][11][11];
while(cin>>py.x>>py.y && (py.x+py.y)){
cin >> n;
py.sp = 0;
fill(&a[0][0][0], &a[10][10][10], false);
for(int i = 1; i <= n; i++){
cin >> s >> t;
for(int j = -1; j < 2; j++){
for(int k = -1; k < 2; k++){
int dx = s+j, dy = t+k;
if(0 <= dx && dx <= 9 && 0 <= dy && dy <= 9){
a[dx][dy][i] = true;
}
}
}
}
cout << ((bfs(a, py, n))? "OK" : "NA") << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, p, k, mod, ans;
int sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
int mul(int a, int b) { return (int)((long long)a * b % mod); }
int power(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
int main() {
vector<int> a;
scanf("%d%d%d", &n, &mod, &k);
int x;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a.push_back(sub(power(x, 4), mul(x, k)));
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
int j = i;
while (a[j] == a[i] && j < n) {
ans += (j - i);
j++;
}
i = j - 1;
}
printf("%d\n", ans);
}
| 2 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int N;
cin>>N;
int H[16],W[16];
for(int i=0;i<N;i++){
cin>>H[i]>>W[i];
}
int g[4][4];
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
char c;
cin>>c;
g[i][j]=
(c=='R')?1:
(c=='G')?2:3;
}
}
int dp[1<<16];
fill(begin(dp),end(dp),99);
dp[0]=0;
for(int i=0;i<1<<16;i++){
int cg[10][10]={};
for(int j=0;j<4;j++){
for(int k=0;k<4;k++){
if(!(i>>j*4+k&1)){
cg[j+3][k+3]=g[j][k];
}
}
}
for(int j=0;j<N;j++){
for(int k=0;k<7;k++){
for(int l=0;l<7;l++){
bool c[4]={};
int nb=i;
for(int m=0;m<H[j];m++){
for(int n=0;n<W[j];n++){
int y=k+m;
int x=l+n;
c[cg[y][x]]=true;
if(3<=y&&y<=6&&3<=x&&x<=6){
nb|=1<<(y-3)*4+x-3;
}
}
}
if(c[1]+c[2]+c[3]==1){
dp[nb]=min(dp[nb],dp[i]+1);
}
}
}
}
}
cout<<dp[(1<<16)-1]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> arr[n];
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
sort(arr, arr + n);
long long diff[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
diff[i][j] = 0;
else if (i > j)
diff[i][j] = diff[i - 1][j] + arr[i].first - arr[j].first;
}
}
long long dp[n];
dp[0] = arr[0].second;
for (int i = 1; i < n; i++) {
long long m = LONG_MAX;
for (int j = i - 1; j >= 0; j--) {
m = ((m) < (dp[j] + diff[i - 1][j])) ? (m) : (dp[j] + diff[i - 1][j]);
}
dp[i] = m + arr[i].second;
}
long long m = LONG_MAX;
for (int i = 0; i < n; i++) {
m = ((m) < (dp[i] + diff[n - 1][i])) ? (m) : (dp[i] + diff[n - 1][i]);
}
cout << m;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dsu, whereset;
vector<set<int>> se;
void build(int n) {
dsu.resize(n);
whereset.resize(n);
se.resize(n);
for (int i = 0; i < n; i++) {
dsu[i] = i;
se[i].insert(i);
whereset[i] = i;
}
}
int Find(int a) { return (dsu[a] == a ? a : dsu[a] = Find(dsu[a])); }
long long ans = 0;
void Union(int a, int b, int val) {
a = Find(a);
b = Find(b);
if (rand() % 2) swap(a, b);
dsu[b] = a;
dsu[val] = a;
if (se[whereset[a]].size() < se[whereset[b]].size()) {
for (int i : se[whereset[a]]) {
if (se[whereset[b]].find(val - i - 1) != se[whereset[b]].end()) ans++;
}
for (int i : se[whereset[a]]) se[whereset[b]].insert(i);
se[whereset[b]].insert(val);
whereset[a] = whereset[b];
} else {
for (int i : se[whereset[b]]) {
if (se[whereset[a]].find(val - i - 1) != se[whereset[a]].end()) ans++;
}
for (int i : se[whereset[b]]) se[whereset[a]].insert(i);
se[whereset[a]].insert(val);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> p(n), pos(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
pos[p[i]] = i;
}
build(n);
for (int i = 0; i < n; i++) {
if (pos[i] > 0 && pos[i] < n - 1 && p[pos[i] + 1] < i &&
p[pos[i] - 1] < i) {
Union(p[pos[i] - 1], p[pos[i] + 1], i);
} else if (pos[i] < n - 1 && p[pos[i] + 1] < i) {
dsu[i] = Find(dsu[p[pos[i] + 1]]);
se[whereset[dsu[i]]].insert(i);
} else if (pos[i] > 0 && p[pos[i] - 1] < i) {
dsu[i] = Find(dsu[p[pos[i] - 1]]);
se[whereset[dsu[i]]].insert(i);
}
}
cout << ans;
}
| 5 |
#include <iostream>
#include <string>
using namespace std;
int main () {
string S;
cin >> S;
cout<< (S[0] == S[1] || S[1] == S[2] || S[2] == S[3] ? "Bad" : "Good")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[300010][9];
pair<int, int> mx[257];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> A[i][j];
}
mx[0] = make_pair(2 * 1e9, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
pair<int, int> maxi = make_pair(2 * 1e9, -1);
for (int k = 0; k < m; k++) {
if (j & (1 << k)) {
maxi = min(maxi, make_pair(A[i][k], i));
}
}
mx[j] = max(mx[j], maxi);
}
}
pair<int, pair<int, int> > res = make_pair(-1, make_pair(-1, -1));
for (int i = 0; i < (1 << m); i++) {
res = max(
res, make_pair(min(mx[i].first, mx[i ^ ((1 << m) - 1)].first),
make_pair(mx[i].second, mx[i ^ ((1 << m) - 1)].second)));
}
cout << res.second.first + 1 << " " << res.second.second + 1 << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct song {
int l, p;
bool operator<(const song& k) const {
return p * (100 - k.p) * l > k.p * (100 - p) * k.l;
}
};
song s[50005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d", &s[i].l, &s[i].p);
sort(s + 1, s + n + 1);
double a = 0, b = 0;
for (int i = 1; i <= n; i++) {
b += (100 - s[i].p) * a + 100 * s[i].l;
a += (s[i].p + .0) * s[i].l / 100;
}
printf("%.10lf\n", b / 100);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int64_t N;
cin >> N;
auto R = N >> 1;
int64_t ans = R * (R + 1) * (2 * R + 1) / 3 * 4;
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, n, T, t, x, y, u;
int main() {
int ncase = 0;
char str[200];
while (scanf("%s", str) == 1) {
long long ans = 0;
long long exp[209];
exp[0] = 1;
for (int i = 1; i < 209; i++) exp[i] = (exp[i - 1] * 2 % 1000000007);
n = strlen(str);
for (int i = 0; i < n; ++i) {
if (str[i] == '1') ans = (ans + exp[2 * n - 2 - i]) % 1000000007;
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long MOD = 998244353;
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x, v, h;
cin >> n >> x >> v >> h;
cout << min(abs(v - h) + x, n - 1) << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
float mem[201][201][401];
int k, l;
float pd(int n, int m, int c, vector<float> &probas, vector<int> &premios) {
if (n == 0) {
return c >= -k and m >= l;
}
if (mem[n][m][min(400, c + 200)] < 0) {
mem[n][m][min(400, c + 200)] =
pd(n - 1, m + 1, c + premios[n], probas, premios) * probas[n] +
pd(n - 1, m, c, probas, premios) * (1 - probas[n]);
}
return mem[n][m][min(400, c + 200)];
}
int main() {
int n, p, a;
cin >> n >> l >> k;
vector<float> probas(n + 1);
vector<int> premios(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> p;
probas[i] = (float)p / 100;
}
for (int i = 1; i <= n; ++i) {
cin >> a;
premios[i] = a;
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int m = 0; m < 401; ++m) mem[i][j][m] = -1;
cout << pd(n, 0, 0, probas, premios);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001000;
int main() {
int z[MAXN];
memset(z, 0, sizeof(z));
string s;
cin >> s;
int n = s.size();
int toCheck = 0;
int last = 0;
for (int i = 1; i < n; i++) {
int j = last + z[last] - i;
if (j < 0)
j = 0;
else
j = min(z[i - last], j);
while (s[i + j] == s[j] && i + j < n) j++;
z[i] = j;
if (i + z[i] > last + z[last]) last = i;
}
for (int i = 1; i < n; i++) {
int j = z[i];
if (i + z[i] == n) j--;
toCheck = max(j, toCheck);
}
int ans = -1;
for (int i = n - toCheck; i < n; i++) {
if (i + z[i] == n) {
ans = z[i];
break;
}
}
if (ans == -1)
cout << "Just a legend";
else {
for (int i = 1; i < n; i++)
if (z[i] >= ans) {
for (int j = 0; j < ans; j++) cout << s[i + j];
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
void go(int &t, int &tr, int d, int r, int j) {
if (r) d++;
if (t < d) return;
t = d;
tr = j * 4 + r + 1;
}
int main() {
char s[1000010];
assert(scanf("%s", s + 1) == 1);
s[0] = '0';
int n = strlen(s);
int d[n + 1][2], r[n + 1][2];
memset(d, 0x7f, sizeof(d[0][0]) * (n + 1) * 2);
d[0][0] = 0, r[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) {
if (d[i][j] > n) continue;
if (!j && s[i] == '0') {
go(d[i + 1][0], r[i + 1][0], d[i][j], 0, j);
go(d[i + 1][1], r[i + 1][1], d[i][j], 1, j);
} else if (!j && s[i] == '1') {
go(d[i + 1][0], r[i + 1][0], d[i][j], 1, j);
} else if (j && s[i] == '0') {
go(d[i + 1][1], r[i + 1][1], d[i][j], -1, j);
} else if (j && s[i] == '1') {
go(d[i + 1][0], r[i + 1][0], d[i][j], -1, j);
go(d[i + 1][1], r[i + 1][1], d[i][j], 0, j);
}
}
int rr = 0;
int ans_p[d[n][rr]], ans_k[d[n][rr]], ans = d[n][rr];
for (int i = n; i > 0; i--) {
int nr = r[i][rr] / 4;
int t = r[i][rr] % 4 - 1;
if (t) ans_p[d[i][rr] - 1] = n - i, ans_k[d[i][rr] - 1] = t;
rr = nr;
}
printf("%d\n", ans);
for (int i = 0; i < ans; i++)
printf("%c2^%d\n", ans_k[i] > 0 ? '+' : '-', ans_p[i]);
return 0;
}
| 4 |
#include <stdio.h>
int main() {
int a, b, c, d;
scanf("%d%d%d%d", &a ,&b ,&c, &d);
printf("%d", (a-c)*(b-d));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:102400000,102400000")
const double eps = 1e-9;
vector<int> f[100010];
int deep[100010];
int p[18][100010];
int num[100010];
void dfs(int x, int fu) {
deep[x] = deep[fu] + 1;
num[x] = 1;
p[0][x] = fu;
for (int i = 0; i < f[x].size(); i++) {
int v = f[x][i];
if (v != fu) {
dfs(v, x);
num[x] += num[v];
}
}
}
int LCA(int a, int b) {
int i, j;
if (deep[a] < deep[b]) swap(a, b);
for (i = 0; (1 << i) <= deep[a]; i++)
;
i--;
for (j = i; j >= 0; j--)
if (deep[a] - (1 << j) >= deep[b]) a = p[j][a];
if (a == b) return a;
for (j = i; j >= 0; j--) {
if (p[j][a] != p[j][b]) {
a = p[j][a];
b = p[j][b];
}
}
return p[0][a];
}
int main() {
int n, m, i, j, k;
cin >> n;
for (i = 0; i <= n; i++) f[i].clear();
for (i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
f[a].push_back(b);
f[b].push_back(a);
}
deep[0] = 0;
dfs(1, 0);
for (i = 1; (1 << i) < n; i++) {
for (j = 1; j <= n; j++) p[i][j] = p[i - 1][p[i - 1][j]];
}
cin >> m;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
if (deep[a] < deep[b]) swap(a, b);
int c = LCA(a, b);
int tmpa = a, tmpb = b;
if ((deep[a] + deep[b] - 2 * deep[c]) % 2 == 1) {
printf("0\n");
continue;
}
int d = (deep[a] + deep[b] - 2 * deep[c]) / 2 - 1;
for (i = 0; i < 18; i++)
if ((d >> i) & 1) tmpa = p[i][tmpa];
if (deep[a] == deep[b]) {
for (i = 0; i < 18; i++)
if ((d >> i) & 1) tmpb = p[i][tmpb];
printf("%d\n", n - num[tmpa] - num[tmpb]);
} else
printf("%d\n", num[p[0][tmpa]] - num[tmpa]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int find(int val, int arr[], int n) {
for (int i = 0; i < n; i++) {
if (arr[i] == val) return 1;
}
return 0;
}
int main() {
int a, b, m1 = INT_MAX, m2 = INT_MAX, k, flag = 0;
cin >> a >> b;
int* arr1 = new int[a];
int* arr2 = new int[b];
int* ar = new int[10];
for (int i = 0; i < 10; i++) ar[i] = 0;
for (int i = 0; i < a; i++) {
cin >> k;
arr1[i] = k;
ar[k] += 1;
if (k < m1) m1 = k;
}
for (int i = 0; i < b; i++) {
cin >> k;
arr2[i] = k;
ar[k] += 1;
if (k < m2) m2 = k;
}
k = 1;
while (k != 10) {
if (ar[k] > 1) {
cout << k << endl;
flag = 1;
break;
}
k++;
}
if (m1 <= m2 && flag == 0) {
if (find(m1, arr2, b)) {
cout << m1 << endl;
flag = 1;
} else if (find(m2, arr1, a)) {
cout << m2 << endl;
flag = 1;
}
}
if (flag == 0) {
if (m1 > m2) {
int temp = m1;
m1 = m2;
m2 = temp;
}
cout << 10 * m1 + m2 << endl;
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int x, y, r;
cin >> x >> y;
while (y > 0) {
r = x % y;
x = y;
y = r;
}
cout << x << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int L[N], R[N];
vector<int> In[N], Out[N];
set<pair<pair<int, int>, int> > st;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d%d", L + i, R + i);
In[L[i]].push_back(i);
Out[R[i]].push_back(i);
}
vector<int> Ans;
for (int x = 1; x < N; x++) {
for (int i : In[x]) {
st.insert(pair<pair<int, int>, int>(pair<int, int>(R[i], L[i]), i));
}
while (st.size() > k) {
auto P = *st.rbegin();
Ans.push_back(P.second);
st.erase(P);
}
for (int i : Out[x]) {
st.erase(pair<pair<int, int>, int>(pair<int, int>(R[i], L[i]), i));
}
}
sort(Ans.begin(), Ans.end());
cout << Ans.size() << endl;
for (int x : Ans) printf("%d ", x);
puts("");
}
| 4 |
#include <bits/stdc++.h>
char b[5000];
int main() {
int i, j, k;
while (scanf("%s", b) == 1) {
k = 0;
for (i = 0; b[i]; i++) {
if (b[i] == '/') {
k -= 2;
for (j = 0; j < k; j++) printf(" ");
printf("</%c>\n", b[i + 1]);
i++;
} else if (isalpha(b[i])) {
for (j = 0; j < k; j++) printf(" ");
printf("<%c>\n", b[i]);
k += 2;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void mx(T& a, const T& b) {
if (a < b) a = b;
}
template <class T>
void mn(T& a, const T& b) {
if (a > b) a = b;
}
int A[200];
int I[200];
int n, k;
inline int solve(int l, int r) {
vector<int> a, b;
copy(A + l, A + r, back_inserter(a));
copy(A, A + l, back_inserter(b));
copy(A + r, A + n, back_inserter(b));
partial_sort(a.begin(), a.begin() + min(k, (int)a.size()), a.end());
partial_sort(b.begin(), b.begin() + min(k, (int)b.size()), b.end(),
greater<int>());
int sum = 0;
for (int i = l; i < r; ++i) sum += A[i];
for (int i = 0; i < min(k, (int)min(a.size(), b.size())); ++i)
if (a[i] < b[i]) {
sum -= a[i];
sum += b[i];
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> A[i];
int ans = -10000;
for (int r = 0; r <= n; ++r)
for (int l = 0; l < r; ++l) mx(ans, solve(l, r));
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[7001][3], ne[3], a[7001][3], k[3], sum[7001][3];
bool b[7001][3];
inline int max(int x, int y) { return x > y ? x : y; }
void dfs(int x, int y) {
if (b[x][y]) return;
b[x][y] = 1;
int t = ne[y];
for (int i = 1; i <= k[t]; i++) {
int xt = x - a[i][t];
if (xt <= 0) xt += n;
if (xt == 1) continue;
dp[xt][t] = max(dp[xt][t], 4 - dp[x][y]);
if (++sum[xt][t] == k[t] || dp[xt][t] == 3) dfs(xt, t);
}
}
int main() {
scanf("%d", &n);
scanf("%d", &k[1]);
for (int i = 1; i <= k[1]; i++) scanf("%d", &a[i][1]);
scanf("%d", &k[2]);
for (int i = 1; i <= k[2]; i++) scanf("%d", &a[i][2]);
dp[1][1] = dp[1][2] = 1;
ne[1] = 2;
ne[2] = 1;
dfs(1, 1);
dfs(1, 2);
for (int j = 1; j <= 2; j++) {
for (int i = 2; i <= n; i++) {
if (!b[i][j]) dp[i][j] = 2;
printf(dp[i][j] == 3 ? "Win " : dp[i][j] == 2 ? "Loop " : "Lose ");
}
printf("\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Q = 200100;
int x[Q], y[Q], pos[Q];
char d[Q];
struct Node {
int l, r, left, up;
int lazy_left, lazy_up;
Node() {}
Node(int l, int r) : l(l), r(r), left(0), up(0), lazy_left(0), lazy_up(0) {}
} node[4 * Q];
void build_tree(int seg, int l, int r) {
node[seg] = Node(l, r);
if (l != r) {
int mid = (l + r) / 2;
build_tree(2 * seg, l, mid);
build_tree(2 * seg + 1, mid + 1, r);
}
}
void update(int seg) {
bool leaf = (node[seg].l == node[seg].r);
if (node[seg].lazy_left) {
if (leaf)
node[seg].left = max(node[seg].left, node[seg].lazy_left);
else {
node[2 * seg].lazy_left =
max(node[2 * seg].lazy_left, node[seg].lazy_left);
node[2 * seg + 1].lazy_left =
max(node[2 * seg + 1].lazy_left, node[seg].lazy_left);
}
}
if (node[seg].lazy_up) {
if (leaf)
node[seg].up = max(node[seg].up, node[seg].lazy_up);
else {
node[2 * seg].lazy_up = max(node[2 * seg].lazy_up, node[seg].lazy_up);
node[2 * seg + 1].lazy_up =
max(node[2 * seg + 1].lazy_up, node[seg].lazy_up);
}
}
node[seg].lazy_left = node[seg].lazy_up = 0;
}
void modify(int seg, int l, int r, bool left, int v) {
update(seg);
if (node[seg].l > r || node[seg].r < l) return;
if (node[seg].l >= l && node[seg].r <= r) {
if (left)
node[seg].lazy_left = v;
else
node[seg].lazy_up = v;
update(seg);
return;
}
modify(2 * seg, l, r, left, v);
modify(2 * seg + 1, l, r, left, v);
}
int query(int seg, int p, bool left) {
update(seg);
if (node[seg].l > p || node[seg].r < p) return INT_MAX;
if (node[seg].l == p && node[seg].r == p)
return left ? node[seg].left : node[seg].up;
return min(query(2 * seg, p, left), query(2 * seg + 1, p, left));
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
vector<pair<int, int> > arr;
for (int i = 1; i <= q; i++) {
scanf("%d %d %c", &x[i], &y[i], &d[i]);
swap(x[i], y[i]);
arr.push_back(make_pair(y[i], i));
}
sort(arr.begin(), arr.end());
map<int, int> compX, compY;
for (int i = 0; i < arr.size(); i++) {
if (i > 0 && y[arr[i - 1].second] == arr[i].first) {
arr[i].first = arr[i - 1].first;
} else
arr[i].first = i + 1;
pos[arr[i].second] = arr[i].first;
compX[x[arr[i].second]] = compY[y[arr[i].second]] = pos[arr[i].second];
}
build_tree(1, 1, q);
for (int i = 1; i <= q; i++) {
if (d[i] == 'L') {
int last = query(1, pos[i], true);
printf("%d\n", y[i] - last);
modify(1, compY[last] + 1, pos[i], false, x[i]);
modify(1, pos[i], pos[i], true, y[i]);
} else {
int last = query(1, pos[i], false);
printf("%d\n", x[i] - last);
if (!last)
modify(1, pos[i], q, true, y[i]);
else
modify(1, pos[i], compX[last] - 1, true, y[i]);
modify(1, pos[i], pos[i], false, x[i]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
int t;
cin>>t;
while(t--)
{
int n,m;
cin>>n>>m;
string a[n],b[n-1];
for(int i=0;i<n;i++) cin>>a[i];
for(int i=0;i<n-1;i++) cin>>b[i];
int occa[m][26],occb[m][26];
for(int i=0;i<m;i++) for(int j=0;j<26;j++) occa[i][j] = 0,occb[i][j] =0;
for(int i=0;i<n;i++) for(int j=0;j<m;j++)
{
occa[j][a[i][j]-'a']++;
if(i < n-1) occb[j][b[i][j]-'a']++;
}
string ans="";
for(int i=0;i<m;i++) for(int j=0;j<26;j++)
{
if(occa[i][j] > occb[i][j]) {
ans.push_back(j+'a');
break;
}
}
cout<<ans<<'\n';
fflush(stdout);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int i, int j) {
if (j == 0)
return i;
else
return gcd(j, i % j);
}
const double e = 0.0000005;
const double pi = 3.14159265359;
template <typename T>
inline T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
const long long INF = 10000000000000;
const int Y = 100001;
int IDX[3 * Y + 1];
int arr[3 * Y];
int team[Y][3];
int way[3 * Y];
int IDX2[3 * Y];
int main() {
srand(10241274216);
cout.precision(10);
cout.tie(0);
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, k;
cin >> n;
for (int i = 1; i <= 3 * n; ++i) {
int tmp;
cin >> tmp;
IDX2[tmp] = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> team[i][j];
way[3 * i - j] = team[i][j];
IDX[team[i][j]] = 3 * i - j;
}
}
cin >> k;
int L = -1;
int to = IDX[k];
if (to % 3 == 2) {
++to;
} else {
if (to % 3 == 1) to += 2;
}
int mn = IDX2[k], mn1 = IDX2[k];
int mx = 0;
for (int j = 0; j <= 2; ++j) {
if (way[to - j] != k) mx = max(mx, way[to - j]);
mn = min(mn, IDX2[way[to - j]]);
}
if (mn != mn1) {
for (int i = 1; i <= 3 * n; ++i) {
if (i != k) cout << i << " ";
}
return 0;
}
for (int i = 1; i <= to; ++i) {
if (way[i] <= mx) {
arr[++L] = way[i];
}
}
++L;
sort(arr, arr + L);
int last = L;
for (int i = 1; i <= 3 * n; ++i) {
if (way[i] > mx || i > to) {
arr[last++] = way[i];
}
}
sort(arr + L, arr + last);
for (int i = 0; i <= 3 * n; ++i) {
if (arr[i] != k && arr[i] != 0) {
cout << arr[i] << " ";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fact[200001];
long long mod = 998244353;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long arr[n];
vector<long long> v;
long long a = 0, b = 0;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] >= 0)
a += (arr[i] + 1) / 2, v.push_back((arr[i] + 1) / 2);
else {
b += (arr[i] - 1) / 2, v.push_back((arr[i] - 1) / 2);
}
}
if (a == abs(b)) {
for (long long i = 0; i < n; i++) cout << v[i] << endl;
} else {
if (a > abs(b)) {
long long k = a - abs(b);
for (long long i = 0; i < n; i++) {
if (v[i] > 0 && k != 0 && v[i] > arr[i] / 2) v[i]--, k--;
cout << v[i] << endl;
}
} else {
long long k = abs(b) - a;
for (long long i = 0; i < n; i++) {
if (v[i] < 0 && k != 0 && abs(v[i]) > abs(arr[i] / 2)) v[i]++, k--;
;
cout << v[i] << endl;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[202020];
string S;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> K;
for (i = 0; i < (N); i++) cin >> A[i];
cin >> S;
signed long long ret = 0;
for (i = 0; i < N;) {
j = i;
vector<int> V;
while (j < N && S[i] == S[j]) {
V.push_back(A[j]);
j++;
}
i = j;
sort((V.begin()), (V.end()));
reverse((V.begin()), (V.end()));
for (j = 0; j < (min(K, (int)V.size())); j++) ret += V[j];
}
cout << ret << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
while (~scanf("%d%d%d%d", &n, &a, &b, &c)) {
int ans = 0;
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
int tmp = n - i - j * 2;
if (tmp >= 0 && tmp <= 0.5 * a) ans++;
}
}
printf("%d\n", ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[312345];
int dad[312345];
int sz[312345];
int mx[312345];
int cut[312345];
void dfsCount(int x) {
int vs = v[x].size();
for (int i = 0; i < vs; i++) {
int y = v[x][i];
dfsCount(y);
sz[x] += sz[y];
mx[x] = max(mx[x], sz[y]);
}
sz[x]++;
}
void dfs(int x) {
int vs = v[x].size();
if (vs == 0) {
cut[x] = x;
return;
}
for (int i = 0; i < vs; i++) {
int y = v[x][i];
dfs(y);
if (cut[x] == 0) {
int c = cut[y];
while (c != x) {
int now = max(mx[c], sz[x] - sz[c]);
if (now <= sz[x] / 2) {
cut[x] = c;
break;
}
c = dad[c];
}
}
}
if (cut[x] == 0) cut[x] = x;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
v[p].push_back(i);
dad[i] = p;
}
dfsCount(1);
dfs(1);
{}
for (int i = 1; i <= q; i++) {
int x;
cin >> x;
cout << cut[x] << "\n";
}
return 0;
}
| 4 |
#include <iostream>
#include <map>
using namespace std;
#define N 1000000
typedef pair<int,int>P;
bool isprime[N+1];
int cave [1000][1000];
int xindex[N+1];
int yindex[N+1];
P dp[1000][1000];
int m,n;
P find(int cx,int cy){
P ans;
if(isprime[n])
dp[cx][cy].first=1,dp[cx][cy].second=cave[cx][cy];
else
dp[cx][cy].first=0,dp[cx][cy].second=0;
ans=dp[cx][cy];
for(int y=cy+1;y<1000;y++){
for(int x=0;x<1000;x++){
if(cave[x][y]<=m){
bool isP=isprime[cave[x][y]];
bool pass=false;
if(x&&cave[x-1][y-1]<=m&&dp[x-1][y-1].first!=-1){
if(dp[x][y].first<dp[x-1][y-1].first||(dp[x][y].first==dp[x-1][y-1].first&&dp[x][y].second<dp[x-1][y-1].second)){
dp[x][y]=dp[x-1][y-1];
pass=true;
}
}
if(cave[x][y-1]<=m&& dp[x][y-1].first!=-1){
if(dp[x][y].first<dp[x][y-1].first||(dp[x][y].first==dp[x][y-1].first&&dp[x][y].second<dp[x][y-1].second)){
dp[x][y]=dp[x][y-1];
pass=true;
}
}
if(x<999&&cave[x+1][y-1]<=m&&dp[x+1][y-1].first!=-1){
if(dp[x][y].first<dp[x+1][y-1].first||(dp[x][y].first==dp[x+1][y-1].first&&dp[x][y].second<dp[x+1][y-1].second)){
dp[x][y]=dp[x+1][y-1];
pass=true;
}
}
if(isP&&pass)
dp[x][y].first++,dp[x][y].second=cave[x][y];
if(ans.first<dp[x][y].first||(ans.first==dp[x][y].first&&ans.second<dp[x][y].second))
ans=dp[x][y];
//cout << ans.first <<" " << ans.second << endl;
}
}
}
return ans;
}
int main(void){
// prime generator
for(int i=0;i<=N;i++)
isprime[i]=true;
isprime[0]=isprime[1]=false;
for(int i=2;i<=N;i++)
if(isprime[i])
for(int j=2*i;j<=N;j+=i)
isprime[j]=false;
// cave generator
int x=499,y=500,tmp=1;
cave[x][y]=1;
xindex[1]=x;
yindex[1]=y;
for(int i=1;i<=N;){
for(int j=0;j<tmp;j++){
if(i>N)
break;
x++;
i++;
cave[x][y]=i;
xindex[i]=x;
yindex[i]=y;
}
for(int j=0;j<tmp;j++){
if(i>N)
break;
y--;
i++;
cave[x][y]=i;
xindex[i]=x;
yindex[i]=y;
}
tmp++;
for(int j=0;j<tmp;j++){
if(i>N)
break;
x--;
i++;
cave[x][y]=i;
xindex[i]=x;
yindex[i]=y;
}
for(int j=0;j<tmp;j++){
if(i>N)
break;
y++;
i++;
cave[x][y]=i;
xindex[i]=x;
yindex[i]=y;
}
tmp++;
}
while(cin >> m >> n ,m|n){
for(int i=0;i<1000;i++)
for(int j=0;j<1000;j++)
dp[i][j].first=dp[i][j].second=-1;
P ans=find(xindex[n],yindex[n]);
if(ans.first==0)
ans.second=0;
cout << ans.first << " " << ans.second << endl;
}
}
| 0 |
// D - Xor Sum 4
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rp(i,s,e) for(int i=(s);i<(e);++i)
#define MOD 1000000007
ll O[60];
int main(){
int ans=0, N; cin>>N;
rp(i,0,N){ ll j,a; scanf("%lld",&a); for(j=0; a; a>>=1) O[j++]+=a&1; }
rp(i, 0, 60) ans = (ans + (O[i]*(N-O[i]) % MOD) * ((1LL<<i) % MOD)) % MOD;
cout<< ans <<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long md = 1000000007;
inline long long mulD(long long a, long long b) {
long long r = 0;
while (b > 0) {
if (b & 1) {
r = r + a % md;
r = r % md;
}
b /= 2;
a = 2 * a % md;
a = a % md;
}
return r % md;
;
}
inline long long exp(long long a, long long b) {
long long r = 1LL;
while (b > 0) {
if (b & 1) {
r = r * (a % md);
r = (r + md) % md;
}
b /= 2;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
inline long long poww(long long a, long long b) {
long long r = 1LL;
while (b > 0) {
if (b & 1) r = r * a;
b /= 2;
a = a * a;
}
return (long long)r;
}
long long a[100000 + 1], l[100000 + 2], r[100000 + 2];
int main() {
long long t, i, s, j, m, x, y, z, k, q, n, p, T;
string s1, s2, s3;
x = 0;
p = 0;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 1; i <= n; ++i) l[i] = min(l[i - 1] + 1, a[i]);
for (i = n; i >= 1; --i) r[i] = min(r[i + 1] + 1, a[i]);
p = 0;
for (i = 1; i <= n; ++i) p = max(p, min(l[i], r[i]));
cout << p;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[50], v1, v2;
bool b[50];
struct st {
int x, y, z;
void set(int i, int j, int k) {
x = i;
y = j;
z = k;
}
void put() { printf("%d %d %d\n", x, y, z); }
} a[50];
void dfs(int x) {
if (b[x]) return;
b[x] = 1;
v2.push_back(x);
for (int i = 0; i < v[x].size(); i++) dfs(v[x][i]);
}
int main() {
int i, j, k, n, m, x, z, y;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &j, &k);
v[j].push_back(k);
v[k].push_back(j);
}
for (i = 1; i <= n; i++)
if (v[i].size() == 0) v1.push_back(i), b[i] = 1;
k = 1;
for (i = 1; i <= n; i++) {
if (b[i]) continue;
dfs(i);
if (v2.size() > 3) {
printf("-1\n");
return 0;
}
while (v2.size() < 3) {
if (v1.size() == 0) {
printf("-1\n");
return 0;
}
v2.push_back(v1.back());
v1.pop_back();
}
a[k++].set(v2[0], v2[1], v2[2]);
v2.clear();
}
for (i = 0; i < v1.size(); i += 3) a[k++].set(v1[i], v1[i + 1], v1[i + 2]);
for (i = 1; i <= n / 3; i++) a[i].put();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long double pi = acos(-1);
int n, m, x[N], y[N], f[20][N << 1], tp;
long double d[N], ang[N];
pair<long double, long double> I[N << 1], st[N];
bool check(long double mid) {
for (int i = 1; i <= n; i++) {
long double w = acos(mid / d[i]);
I[i] = make_pair(ang[i] - w + pi, ang[i] + w + pi);
if (I[i].second >= 2 * pi) I[i].first -= 2 * pi, I[i].second -= 2 * pi;
if (I[i].second < 0) I[i].first += 2 * pi, I[i].second += 2 * pi;
}
sort(I + 1, I + n + 1);
tp = 0;
for (int i = 1; i <= n; i++) {
while (tp && st[tp].second >= I[i].second) --tp;
st[++tp] = I[i];
}
int fr = 1;
while (st[tp].first >= st[fr].first + 2 * pi) ++fr;
for (int i = 1; i <= tp - fr + 1; i++) st[i] = st[i + fr - 1];
tp -= fr - 1;
for (int i = 1; i <= tp; i++) {
I[i] = st[i];
I[i + tp] = make_pair(st[i].first + 2 * pi, st[i].second + 2 * pi);
}
for (int i = 1, j = 1; i <= 2 * tp + 1; i++) {
while (j <= 2 * tp && I[j].first <= I[i].second) ++j;
f[0][i] = j;
}
for (int j = 1; j <= 18; j++)
for (int i = 1; i <= 2 * tp + 1; i++) f[j][i] = f[j - 1][f[j - 1][i]];
for (int i = 1; i <= tp; i++) {
int need = 1, cur = i;
for (int j = 18; ~j; j--)
if (f[j][cur] < i + tp) need += (1 << j), cur = f[j][cur];
if (need <= m) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
long double l = 0, r = 1e9;
for (int i = 1; i <= n; i++) {
d[i] = sqrt(1ll * x[i] * x[i] + 1ll * y[i] * y[i]);
ang[i] = atan2(y[i], x[i]);
r = min(r, d[i]);
}
for (int i = 1; i <= 100; i++) {
long double mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%.6Lf\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<long long> gera_primos(long long n) {
set<long long> primos;
vector<bool> crivo(n + 1);
primos.insert(2);
for (long long i = 3; i <= n; i += 2) {
if (crivo[i]) continue;
primos.insert(i);
for (long long j = i; j <= n; j += i) {
crivo[j] = true;
}
}
return primos;
}
struct Link {
long long from, to, t;
};
struct Node {
bool visitado = false;
bool cor = false;
vector<Link> in, out;
};
long long a[30][30];
bool check(long long n, long long m) {
for (long long i = 0; i < (long long)n; i++) {
for (long long j = 0; j < (long long)m; j++) {
if (a[i][j] != j + 1) return false;
}
}
return true;
}
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < (long long)n; i++) {
for (long long j = 0; j < (long long)m; j++) {
cin >> a[i][j];
}
}
vector<long long> b;
for (long long i = 1; i < (long long)m + 1; i++) b.push_back(i);
for (long long l = 0; l < (long long)m; l++) {
for (long long r = l + 1; r < (long long)m + 1; r++) {
if (l < m - 1) {
if (r == m) break;
swap(b[l], b[r]);
}
for (long long i = 0; i < (long long)n; i++) {
long long dif = 0;
for (long long j = 0; j < (long long)m; j++) {
if (a[i][j] != b[j]) dif++;
}
if (dif != 0 and dif != 2) goto end;
}
puts("YES");
return 0;
end:
swap(b[l], b[r]);
}
}
puts("NO");
}
| 2 |
#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int inf = 1 << 28;
constexpr long long mod = 998244353LL;
using namespace std;
template <typename Monoid>
struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid& M1) : f(f), M1(M1) {
sz = 1;
while (sz < n) sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid& x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid& x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
if (a >= b) return M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) L = f(L, seg[a++]);
if (b & 1) R = f(seg[--b], R);
}
return f(L, R);
}
};
void suzuken() {
int n;
scanf("%d", &n);
vector<long long> a(n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]), a[i]--;
vector<long long> b(n);
for (int i = 0; i < n; i++) scanf("%lld", &b[i]), b[i]--;
{
auto c = a;
auto d = b;
sort(c.begin(), c.end());
sort(d.begin(), d.end());
if (c != d) {
puts("NO");
return;
}
}
vector<queue<int>> g(n);
for (int i = 0; i < n; i++) {
g[a[i]].push(i);
}
SegmentTree<int> seg(
n, [](int a, int b) { return min(a, b); }, inf);
for (int i = 0; i < n; i++) {
if (!g[i].empty()) {
seg.set(i, g[i].front());
g[i].pop();
}
}
seg.build();
for (int i = 0; i < n; i++) {
int cur = seg.query(b[i], b[i] + 1);
long long mn = seg.query(0, b[i]);
if (mn < cur) {
puts("NO");
return;
}
if (g[b[i]].empty()) {
seg.update(b[i], inf);
} else {
seg.update(b[i], g[b[i]].front());
g[b[i]].pop();
}
}
puts("YES");
}
int main() {
int kkt;
scanf("%d", &kkt);
while (kkt--) {
suzuken();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, q, k, a[12][100010], b[100010][12], cnt, u;
bitset<(1 << 12)> S[100010];
bool cmp(const int &x, const int &y) { return a[x][u] < a[y][u]; }
signed main() {
n = read(), k = read(), q = read();
for (int i = 0; i < k; i++)
for (int j = 1; j <= n; j++) a[i][j] = read();
for (int i = 0; i < k; i++) {
for (int j = 0; j < (1 << k); j++) S[i][j] = (j & (1 << i)) > 0;
}
for (u = 1; u <= n; u++) {
for (int j = 0; j < k; j++) b[u][j] = j;
sort(b[u], b[u] + k, cmp);
}
cnt = k - 1;
for (int i = 1; i <= q; i++) {
int op = read(), x = read() - 1, y = read();
if (op == 1) S[++cnt] = S[x] | S[y - 1];
if (op == 2) S[++cnt] = S[x] & S[y - 1];
if (op == 3) {
u = 0;
for (int j = k - 1; j >= 0; j--) {
u |= 1 << b[y][j];
if (S[x][u]) {
printf("%d\n", a[b[y][j]][y]);
break;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool cs(int n) {
if (n == 1) {
return false;
}
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
bool ch(int n) {
int n1 = 0, t = n;
while (t != 0) {
n1 = n1 * 10 + t % 10;
t /= 10;
}
if (n1 == n) {
return true;
}
return false;
}
int main() {
int p, q;
cin >> p >> q;
int ss = 0, sh = 0;
int ans = 0;
for (int i = 1; i <= 2123456; i++) {
if (cs(i)) {
ss++;
}
if (ch(i)) {
sh++;
}
if (ss * q <= sh * p) {
ans = i;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, mod = 998244353;
inline int pls(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline int dec(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b) { return 1ll * a * b % mod; }
inline int read() {
int s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
inline int qpow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) res = mul(res, a);
return res;
}
inline void chkmin(int &x, int y) {
if (y < x) x = y;
}
int n;
string s[N], ans, tr[N];
int to[305];
map<string, int> p;
inline void query(int l, int r) {
cout << "? " << l << ' ' << r << endl;
int t = (r - l + 1) * (r - l + 2) / 2;
for (int i = 1; i <= t; i++) cin >> s[i];
}
inline void query(int l, int r, int op) {
cout << "? " << l << ' ' << r << endl;
int t = (r - l + 1) * (r - l + 2) / 2;
for (int i = 1; i <= t; i++) {
cin >> s[i];
sort(s[i].begin(), s[i].end());
p[s[i]] += op;
}
}
inline bool cmp(string a, string b) { return a.size() < b.size(); }
int main() {
cin >> n;
if (n == 1) {
query(1, 1);
cout << "! " << s[1] << endl;
} else if (n == 2) {
string t;
query(1, 1);
t = t + s[1];
query(2, 2);
t = t + s[1];
cout << "! " << t << endl;
} else {
query(1, n, 1);
query(2, n, -1);
int cnt = 0;
for (auto t : p) {
if (t.second != 0) tr[++cnt] = t.first;
}
sort(tr + 1, tr + cnt + 1, cmp);
ans = tr[1];
for (int i = 2; i <= cnt; i++) {
memset(to, 0, sizeof(to));
for (int j = 0; j < tr[i].size(); j++) to[tr[i][j] - 'a']++;
for (int j = 0; j < ans.size(); j++) to[ans[j] - 'a']--;
for (int j = 0; j < 26; j++)
if (to[j] > 0) {
ans = ans + (char)('a' + j);
break;
}
}
cout << "! " << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
cout << a[(n - 1) / 2] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int x, y, z;
cin >> x >> y >> z;
cout << x - min(y, z) + 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, k;
vector<pair<int, int> > c[10010];
vector<tuple<int, int, int> > cells;
int ___next[10010], ___prev[10010], ___right[10010], node[10010], pos[10010];
long long res;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q >> k;
--k;
for (int i = 1; i <= q; ++i) {
int x, y;
cin >> x >> y;
c[x].push_back({y, i});
cells.push_back({y, x, i});
}
cells.push_back({0, n + 1, 0});
cells.push_back({m + 1, n + 1, q + 1});
sort(cells.begin(), cells.end());
res = (1ll * n * (n + 1) / 2) * (1ll * m * (m + 1) / 2);
for (int u = 1; u <= n; ++u) {
int sz = 0;
for (auto [y, x, id] : cells) {
if (x < u) continue;
___next[sz] = sz + 1;
___prev[sz] = sz - 1;
pos[id] = sz;
node[sz++] = y;
}
long long cur = 0;
for (int i = 0; i < sz && node[i] != m + 1; ++i) {
if (k >= 0)
cur += (node[i + 1] - node[i]) * (node[i + 1] - node[i] - 1) / 2;
for (int j = i + 1; j < sz && j <= i + k && node[j] != m + 1; ++j) {
cur += (node[j + 1] - node[j]) * (node[i + 1] - node[i]);
}
}
for (int v = n; v >= u; --v) {
res -= cur;
for (auto [x, id] : c[v]) {
int ___left = node[pos[id]] - node[___prev[pos[id]]];
int ___right = node[___next[pos[id]]] - node[pos[id]];
if (k == 0) cur += ___left * ___right;
vector<int> deltaL(k + 10, -1);
vector<int> deltaR(k + 10, -1);
for (int i = 1, j = ___next[pos[id]]; i <= k && node[j] != m + 1;
++i, j = ___next[j]) {
deltaR[i] = node[___next[j]] - node[j];
if (i == k) cur += deltaR[i] * ___left;
}
for (int i = 1, j = ___prev[pos[id]]; i <= k && node[j] != 0;
++i, j = ___prev[j]) {
deltaL[i] = node[j] - node[___prev[j]];
if (i == k) cur += deltaL[i] * ___right;
}
for (int i = 1; i <= k; ++i)
if (deltaL[i] != -1 && deltaR[k - i] != -1)
cur += deltaL[i] * deltaR[k - i];
___next[___prev[pos[id]]] = ___next[pos[id]];
___prev[___next[pos[id]]] = ___prev[pos[id]];
}
}
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int inf = 1000000010;
const int MAXN = 200010;
struct edge {
int u, v, c, t, res;
} E[MAXN];
int n, m, k, u, v, x, y, t, a, b, N;
int comp[MAXN * 2];
bool mark[MAXN * 2];
int del[MAXN * 2];
int del2[MAXN * 2];
map<int, int> deg[MAXN];
map<int, vector<int>> GRAPH[MAXN];
vector<int> GRAPH2[MAXN];
vector<int> G[2 * MAXN];
vector<int> GR[2 * MAXN];
vector<int> topol;
void add_edge(int x, int y) {
G[x].push_back(y);
GR[y].push_back(x);
}
void add(int x, int y) {
add_edge(x ^ 1, y);
add_edge(y ^ 1, x);
}
void add2(int x, int y) {
add_edge(x ^ 1, y);
add_edge(y ^ 1, x);
del[x ^ 1]++;
del[y ^ 1]++;
del2[y]++;
del2[x]++;
}
void dfs1(int node) {
mark[node] = 1;
for (int v : G[node])
if (!mark[v]) dfs1(v);
topol.push_back(node);
}
void dfs2(int node, int id) {
comp[node] = id;
for (int v : GR[node])
if (!comp[v]) dfs2(v, id);
}
bool check(int T) {
for (int i = 0; i < 2 * MAXN; i++) {
while (del[i]) {
G[i].pop_back();
del[i]--;
}
while (del2[i]) {
GR[i].pop_back();
del2[i]--;
}
}
for (int i = 1; i <= m; i++)
if (E[i].t > T) add2(2 * i ^ 1, 2 * i ^ 1);
memset(comp, 0, sizeof(comp));
memset(mark, 0, sizeof(mark));
topol.clear();
for (int i = 2; i < 2 * MAXN; i++)
if (!mark[i]) dfs1(i);
reverse(topol.begin(), topol.end());
int id = 1;
for (int v : topol)
if (!comp[v]) dfs2(v, id++);
for (int i = 2; i < 2 * N + 2; i++)
if (comp[i] == comp[i ^ 1]) return 0;
for (int i = 1; i <= m; i++) E[i].res = (comp[2 * i] > comp[2 * i + 1]);
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> x >> y;
E[i] = {u, v, x, y};
deg[u][x]++;
deg[v][x]++;
GRAPH[u][x].push_back(i);
GRAPH[v][x].push_back(i);
GRAPH2[u].push_back(i);
GRAPH2[v].push_back(i);
}
for (int i = 1; i <= n; i++)
for (pair<int, int> p : deg[i])
if (p.second > 2) return cout << "No" << '\n', 0;
for (int i = 1; i <= n; i++)
for (auto it : GRAPH[i])
if (it.second.size() == 2) add(it.second[0] * 2, it.second[1] * 2);
N = m;
for (int i = 1; i <= n; i++)
if (GRAPH2[i].size() >= 2) {
k = GRAPH2[i].size();
for (int j = 0; j < k; j++) {
int a = GRAPH2[i][j];
add(2 * a ^ 1, 2 * (++N));
if (j) add(2 * (N - 1) ^ 1, 2 * N);
if (j) add(2 * a ^ 1, 2 * (N - 1) ^ 1);
}
}
int dwn = -1, up = inf;
while (up - dwn > 1) {
int mid = (dwn + up) / 2;
if (check(mid))
up = mid;
else
dwn = mid;
}
if (!check(up)) return cout << "No" << '\n', 0;
vector<int> out;
for (int i = 1; i <= m; i++)
if (E[i].res) out.push_back(i);
cout << "Yes\n" << up << ' ' << out.size() << '\n';
for (int i : out) cout << i << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#define SIZE 200005
#define INF 10000000000000000LL
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
typedef pair <ll,P> PP;
struct edge
{
int to;
ll cost;
edge(int to=0,ll cost=0):to(to),cost(cost){}
};
struct UF
{
int par[SIZE],rank[SIZE];
void init(int n)
{
for(int i=0;i<n;i++)
{
par[i]=i;
rank[i]=0;
}
}
int find(int x)
{
if(par[x]==x) return x;
return par[x]=find(par[x]);
}
void unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y) return;
if(rank[x]<rank[y]) par[x]=y;
else
{
par[y]=x;
if(rank[x]==rank[y]) rank[x]++;
}
}
bool same(int x,int y)
{
return find(x)==find(y);
}
};
UF uf;
vector <edge> vec[SIZE];
ll X[SIZE];
int v1[SIZE],v2[SIZE];
ll d1[SIZE],d2[SIZE];
int id[SIZE],ch[SIZE];
int now_id;
void dfs(int v=0,int p=-1)
{
id[v]=now_id++;
d1[v]=d2[v]=INF;
v1[v]=v2[v]=-1;
for(int i=0;i<vec[v].size();i++)
{
edge e=vec[v][i];
if(e.to!=p)
{
dfs(e.to,v);
ll vl=d1[e.to]+e.cost;
int vv=v1[e.to];
if(vl>e.cost+X[e.to])
{
vl=e.cost+X[e.to];
vv=e.to;
}
if(vl<d1[v])
{
swap(vl,d1[v]);
swap(vv,v1[v]);
}
}
}
ch[v]=now_id;
}
void make(int v=0,int p=-1)
{
for(int i=0;i<vec[v].size();i++)
{
edge e=vec[v][i];
if(e.to!=p)
{
ll vl=d1[v]+e.cost;
int vv=v1[v];
if(id[e.to]<=id[vv]&&id[vv]<ch[e.to])
{
vl=d2[v]+e.cost;
vv=v2[v];
}
if(vl>e.cost+X[v])
{
vl=e.cost+X[v];
vv=v;
}
if(vl<d1[e.to])
{
swap(vl,d1[e.to]);
swap(vv,v1[e.to]);
}
make(e.to,v);
}
}
}
int A[SIZE],B[SIZE];
ll C[SIZE];
int main()
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++) scanf("%lld",&X[i]);
for(int i=0;i<n-1;i++)
{
int a,b;
ll c;
scanf("%d %d %lld",&a,&b,&c);a--,b--;
vec[a].push_back(edge(b,c));
vec[b].push_back(edge(a,c));
A[i]=a,B[i]=b,C[i]=c;
}
dfs();
make();
uf.init(n+2);
ll ret=0;
for(int i=0;i<n;i++)
{
if(v1[v1[i]]==i&&i<v1[i]) continue;
ret+=d1[i]+X[i];
uf.unite(i,v1[i]);
}
for(int i=0;i<n-1;i++)
{
if(!uf.same(A[i],B[i]))
{
ret+=min(X[A[i]],d1[A[i]]);
ret+=min(X[B[i]],d1[B[i]]);
ret+=C[i];
}
}
printf("%lld\n",ret);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
const int oo = 1e9;
const int MX = 100000000;
int n, sz[N];
vector<int> g[N];
int dp[N][N][2];
void dfs(int u, int p) {
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == p) continue;
dfs(v, u);
sz[u] += sz[v];
}
if (!sz[u]) sz[u]++;
for (int i = 0; i <= sz[u]; ++i) dp[u][i][0] = dp[u][i][1] = oo;
if (sz[u] == 1) dp[u][1][0] = dp[u][0][1] = 0;
int all = 0;
if (sz[u] > 1) {
dp[u][0][0] = dp[u][0][1] = 0;
for (auto v : g[u]) {
if (v == p) continue;
all += sz[v];
for (int rem = all; rem >= 0; --rem) {
for (int my = 0; my <= 1; ++my) {
int ret = oo;
for (int take = 0; take <= min(rem, sz[v]); ++take)
for (int nc = 0; nc <= 1; ++nc)
ret = min(ret,
dp[v][take][nc] + (my != nc) + dp[u][rem - take][my]);
dp[u][rem][my] = ret;
}
}
}
}
}
int main() {
cin >> n;
for (int u, v, i = 0; i < n - 1; ++i) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
int root = -1;
for (int i = 1; i <= n; ++i) {
if (g[i].size() > 1) {
root = i;
break;
}
}
dfs(root, -1);
int f = sz[root] / 2;
printf("%d\n", min(dp[root][f][1], dp[root][f][0]));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 32;
long long timer, cc1, cc;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
boost();
long long i, t, q, l, r, ans, mid, c = 0, j, z, tc, n, k;
long long h, m, u, mm, w, x, y, l1, r1, d = 0, mask, v, mx;
long double f, f1;
cin >> t;
vector<pair<long long, long long> > g;
while (t--) {
cin >> n;
long long a[n];
g.clear();
priority_queue<pair<long long, long long> > pq;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > 0) {
pq.push(make_pair(a[i], i + 1));
}
}
while (!pq.empty()) {
auto p = pq.top();
pq.pop();
if (!pq.empty()) {
auto p1 = pq.top();
pq.pop();
l = p.first;
l--;
r = p1.first;
r--;
g.push_back(make_pair(p.second, p1.second));
if (l > 0) pq.push(make_pair(l, p.second));
if (r > 0) pq.push(make_pair(r, p1.second));
} else
break;
}
cout << ((long long)g.size()) << '\n';
for (auto x : g) {
cout << x.first << " " << x.second << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000;
const int maxc = 1000010;
int n, c, bit[maxc];
vector<int> str[maxn];
inline void add(int p, int v) {
++p;
for (; p <= maxc; p += p & -p) bit[p] += v;
}
inline int que(int p) {
int ret = 0;
++p;
for (; p; p -= p & -p) ret += bit[p];
return ret;
}
inline void insert(int l, int r) {
if (l == r) add(0, 1), add(c, -1);
if (l > r) add(c - l + 1, 1), add(c - r + 1, -1);
if (r > l) add(0, 1), add(c - r + 1, -1), add(c - l + 1, 1), add(c, -1);
}
inline void check(int x, int y) {
int l = 0, r = 0;
while (l < str[x].size() && r < str[y].size() && str[x][l] == str[y][r])
++l, ++r;
if (l == str[x].size()) add(0, 1), add(c, -1);
if (l != str[x].size() && r == str[y].size()) return;
if (l != str[x].size() && r != str[y].size()) insert(str[x][l], str[y][r]);
}
int main() {
scanf("%d %d", &n, &c);
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
str[i].resize(t);
for (int j = 0; j < t; ++j) scanf("%d", &str[i][j]);
if (i) check(i - 1, i);
}
bool flag = false;
for (int i = 0; i < c; ++i)
if (que(i) == n - 1) {
printf("%d\n", i);
flag = true;
break;
}
if (!flag) printf("-1\n");
return 0;
}
| 4 |
#include<stdio.h>
int main() {
int i;
int n;
for (i=0; i<7; i++) {
int a, b;
scanf("%d %d", &a, &b);
printf("%d\n", a - b);
}
}
| 0 |
#include<iostream>
#include<algorithm>
#include<string.h>
#include<utility>
#include<vector>
#include<queue>
#include<cmath>
#include<math.h>
#include<stack>
#include<map>
#include<set>
#include<cstdlib>
#include<bitset>
using namespace std;
#define FOR(i,j,k) for(int i=j;i<=k;i++)
#define FORD(i,j,k) for(int i=j;i>=k;i--)
#define LL long long
#define ii pair<int,int>
//#define maxn 2400000
#define SZ(x) x.size()
#define INF (1<<29)
#define pb push_back
#define mp make_pair
#define maxb 1010
#define sc(x) scanf("%d",&x)
#define mes(x) memset(x.0.sizeof(x))
#define mod 1000000007
#define maxn 600010
#define N 510
#define Q 500010
template<class T> bool chkmax(T& a,const T& b){return a<b?a=b,1:0;}
int read()
{
int num=0; char ch=getchar();
while(ch<'0'||ch>'9') ch=getchar(); //过滤前面非数字字符
while(ch>='0'&&ch<='9') {num*=10;num+=ch-'0';ch=getchar();}
return num;
}
LL read1()
{
LL num=0; char ch=getchar();
while(ch<'0'||ch>'9') ch=getchar(); //过滤前面非数字字符
while(ch>='0'&&ch<='9') {num*=10;num+=ch-'0';ch=getchar();}
return num;
}
int T,n,b;
int cnt;
int a[200010];
string x;
int main(){
scanf("%d",&T);
while(T--){
scanf("%d",&n);
FOR(i,1,n) scanf("%d",&a[i]);
LL ans=0;
ans+=n+(n-1);
FOR(i,3,n) {
if(a[i-2]<a[i-1]&&a[i-1]>a[i]) ans++;
else if(a[i-2]>a[i-1]&&a[i-1]<a[i]) ans++;
}
FOR(i,4,n) {
if(a[i-3]<a[i-2]&&a[i-2]>a[i-1]&&a[i-1]<a[i]&&a[i-3]>a[i-1]&&a[i-2]>a[i]) ans++;
else if(a[i-3]>a[i-2]&&a[i-2]<a[i-1]&&a[i-1]>a[i]&&a[i-3]<a[i-1]&&a[i-2]<a[i]) ans++;
//else if(a[i-3]>a[i-2]&&a[i-2]==a[i-1]&&a[i-1]<a[i]) ans++;
//else if(a[i-3]<a[i-2]&&a[i-2]==a[i-1]&&a[i-1]>a[i]) ans++;
}
cout<<ans<<endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n / 2 << endl;
if (n % 2) {
while (n > 3) {
cout << 2 << " ";
n -= 2;
}
cout << 3;
} else {
while (n) {
cout << 2 << " ";
n -= 2;
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, Ans, f[N], fa[N], dep[N], dfn[N], Son[N];
vector<int> G[N];
void dfs(int u) {
dfn[++m] = u;
for (auto v : G[u])
if (v != Son[u]) dfs(v);
if (Son[u]) dfs(Son[u]);
}
int main() {
scanf("%d", &n);
for (int i = 2, u; i <= n; ++i) {
scanf("%d", &u);
fa[i] = ++u;
G[u].push_back(i);
dep[i] = dep[u] + 1;
}
for (int i = n; i > 1; --i)
if (f[i] + 1 >= f[fa[i]]) {
f[fa[i]] = f[i] + 1;
Son[fa[i]] = i;
}
dfs(1);
for (int i = 1; i <= n; ++i) printf("%d%c", dfn[i] - 1, " \n"[i == n]);
for (int i = 2; i <= n; ++i) Ans += dep[dfn[i - 1]] - dep[fa[dfn[i]]];
printf("%d\n", Ans);
for (int i = 2; i <= n; ++i)
for (int j = dep[dfn[i - 1]] - dep[fa[dfn[i]]]; j; --j)
printf("%d ", dfn[i] - 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[10][10];
const char *q = "BRWY";
int c[10], z[10], d[4][4];
bool b[10][10];
int id[10][10];
bool adj[10][10];
int A[22][22];
const int S = 21, T = 20;
bool u[22];
vector<pair<int, int> > zz;
bool dfs(int x) {
u[x] = true;
if (A[x][T]) {
--A[x][T];
++A[T][x];
return true;
}
int y0 = x < 10 ? 10 : 0, y1 = x >= 10 && x < 20 ? 10 : 20;
for (int y(y0); y < y1; ++y) {
if (A[x][y] && (y == T || !u[y] && dfs(y))) {
--A[x][y];
++A[y][x];
return true;
}
}
return false;
}
int best = -1;
pair<int, int> p[100];
int m;
char dr[100][100], ans[100][100];
void put(int i0, int j0, int i1, int j1, int col) {
int x = zz[col].first, y = zz[col].second;
if ((s[i1][j1] == x) + (s[i0][j0] == y) >
(s[i1][j1] == y) + (s[i0][j0] == x)) {
swap(x, y);
}
dr[i0 * 2][j0 * 2] = q[x];
dr[i1 * 2][j1 * 2] = q[y];
}
void check() {
int r = 0;
int d[10], e[10];
m = 0;
for (int i(0); i < 10; ++i) {
d[i] = c[i];
e[i] = z[i];
for (; d[i] > 0 && e[i] > 0;) {
r += 2;
--d[i];
--e[i];
p[m++] = pair<int, int>(i, i);
}
}
if (r + (28 - m) <= best) return;
memset(A, 0, sizeof A);
int flow = 0;
for (int i(0); i < 10; ++i) {
A[S][i] = d[i];
A[i + 10][T] = e[i];
}
for (int i(0); i < 10; ++i)
for (int j(0); j < 10; ++j) {
if (adj[i][j]) {
A[i][j + 10] = 28;
for (; A[S][i] && A[i][j + 10] && A[j + 10][T];) {
++r;
--A[S][i];
--A[i][j + 10];
--A[j + 10][T];
++A[T][j + 10];
++A[j + 10][i];
++A[i][S];
}
}
}
for (; memset(u, 0, sizeof u), dfs(S); ++r)
;
if (r > best) {
for (int i(0); i < 10; ++i)
for (int j(0); j < 10; ++j) {
for (int k(0); k < A[j + 10][i]; ++k) {
--d[i];
--e[j];
p[m++] = pair<int, int>(j, i);
}
}
for (int i(0); i < 10; ++i)
for (int j(0); j < 10; ++j) {
for (; d[i] > 0 && e[j] > 0;) {
--d[i];
--e[j];
p[m++] = pair<int, int>(j, i);
}
}
best = r;
for (int i(0); i < 7; ++i)
for (int j(0); j < 8; ++j) dr[i * 2][j * 2] = '.';
for (int i(0); i < 7; ++i)
for (int j(0); j < 8; ++j) {
if (dr[i * 2][j * 2 + 1] == '-') {
int x = id[s[i][j]][s[i][j + 1]];
for (int l(0); l < m; ++l) {
if (p[l].first == x) {
put(i, j, i, j + 1, p[l].second);
p[l] = p[--m];
break;
}
}
} else if (dr[i * 2 + 1][j * 2] == '|') {
int x = id[s[i][j]][s[i + 1][j]];
for (int l(0); l < m; ++l) {
if (p[l].first == x) {
put(i, j, i + 1, j, p[l].second);
p[l] = p[--m];
break;
}
}
}
}
for (int i(0); i < 13; ++i)
for (int j(0); j < 15; ++j) ans[i][j] = dr[i][j];
}
}
void go(int i, int j) {
if (i == 7) {
check();
return;
}
if (j == 8) {
go(i + 1, 0);
return;
}
if (!b[i][j]) {
go(i, j + 1);
return;
}
if (b[i][j + 1]) {
b[i][j] = b[i][j + 1] = false;
z[id[s[i][j]][s[i][j + 1]]]++;
dr[i * 2][j * 2 + 1] = '-';
go(i, j + 1);
dr[i * 2][j * 2 + 1] = '.';
z[id[s[i][j]][s[i][j + 1]]]--;
b[i][j] = b[i][j + 1] = true;
}
if (b[i + 1][j]) {
b[i][j] = b[i + 1][j] = false;
z[id[s[i][j]][s[i + 1][j]]]++;
dr[i * 2 + 1][j * 2] = '|';
go(i, j + 1);
dr[i * 2 + 1][j * 2] = '.';
z[id[s[i][j]][s[i + 1][j]]]--;
b[i][j] = b[i + 1][j] = true;
}
}
int main() {
for (int i(0); i < 7; ++i) {
gets(s[i]);
for (int j(0); j < 8; ++j) {
b[i][j] = true;
s[i][j] = find(q, q + 4, s[i][j]) - q;
}
}
for (int i(0); i < 4; ++i)
for (int j = 3; j >= i; --j) {
id[i][j] = int((zz).size());
id[j][i] = int((zz).size());
cin >> c[int((zz).size())];
zz.push_back(pair<int, int>(i, j));
}
for (int i(0); i < 10; ++i)
for (int j(0); j < 10; ++j)
if (zz[i].first == zz[j].first || zz[i].first == zz[j].second ||
zz[i].second == zz[j].first || zz[i].second == zz[j].second) {
adj[i][j] = true;
}
for (int i(0); i < 13; ++i)
for (int j(0); j < 15; ++j) dr[i][j] = '.';
go(0, 0);
cout << best << endl;
for (int i(0); i < 13; ++i) cout << ans[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lli;
lli rec(int l, int r, vector<int> &A) {
if(r-l <= 1) return 0;
int m = (l+r)/2;
lli res = rec(l, m, A) + rec(m, r, A);
queue<int> a, b;
for(int i = l; i < m; ++i) a.push(A[i]);
for(int i = m; i < r; ++i) b.push(A[i]);
int k = l;
while(a.size() && b.size()) {
if(a.front() <= b.front()) {
A[k++] = a.front();
a.pop();
} else {
A[k++] = b.front();
b.pop();
res += a.size();
}
}
while(a.size()) {
A[k++] = a.front();
a.pop();
}
while(b.size()) {
A[k++] = b.front();
b.pop();
}
return res;
}
int main() {
int n;
vector<int> A;
cin >> n;
A.resize(n);
for(int i = 0; i < n; ++i) cin >> A[i];
cout << rec(0, n, A) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct __st {
int at, lt;
int ind;
} st;
bool cmp(st a, st b) {
if (a.at == b.at)
return a.ind < b.ind;
else
return a.at < b.at;
}
void solve(int t) {
int n;
cin >> n;
vector<st> v(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v[i].ind = i;
v[i].at = x;
v[i].lt = y;
}
sort(v.begin(), v.end(), cmp);
int tm = 1;
int ans[n];
for (int i = 0; i < n; i++) {
while (v[i].at > tm) tm++;
if (v[i].lt < tm)
ans[v[i].ind] = 0;
else {
ans[v[i].ind] = tm;
++tm;
}
}
for (int i : ans) cout << i << " ";
cout << "\n";
}
int main(void) {
int i, T = 1;
cin >> T;
for (int i = 1; i <= T; i++) solve(i);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, c1, c2, a, in1, in2;
c1 = c2 = 0;
cin >> n >> t;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
for (int j = 0; j < n; j++) {
if (v[j] == 1)
c1++;
else
c2++;
}
for (int i = 0; i < t; i++) {
cin >> in1 >> in2;
if ((in2 - in1 + 1) % 2 != 0) {
cout << 0 << endl;
} else {
if (c1 >= (in2 - in1 + 1) / 2 && c2 >= (in2 - in1 + 1) / 2) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
vector<int> adj[N];
int n, a[N];
bool dp[N];
void readInput() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[--a].push_back(--b);
adj[b].push_back(a);
}
}
void dfs(int x, int par) {
for (auto v: adj[x])
if (v != par) {
dfs(v, x);
if (a[v] < a[x])
dp[x] |= !dp[v];
}
}
void solve() {
for (int i = 0; i < n; i++) {
dfs(i, i);
if (dp[i])
cout << i + 1 << ' ';
for (int i = 0; i < n; i++)
dp[i] = false;
}
cout << endl;
}
int main() {
ios:: sync_with_stdio(0), cin.tie(0), cout.tie(0);
readInput(), solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int INF = 2000000005;
const long long BIG_INF = 2000000000000000005;
const int mod = 1000000007;
const int P = 31;
const long double PI = 3.141592653589793238462643;
using namespace std;
vector<pair<int, int> > dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool valid(int x, int y, int n, int m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
mt19937 rng(1999999973);
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, h, m, ans = 0;
cin >> n >> h >> m;
vector<int> v(n, h);
for (int i = 0; i < m; i++) {
int l, r, x;
cin >> l >> r >> x;
l--, r--;
for (int j = l; j <= r; j++) v[j] = min(v[j], x);
}
for (int i = 0; i < n; i++) ans += v[i] * v[i];
cout << ans;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.