solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int read() {
int ret = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
for (; ch >= '0' && ch <= '9'; ch = getchar()) ret = ret * 10 + ch - '0';
return ret;
}
int m, n;
int a[105];
int l[105];
map<int, bool> s;
int main() {
s.clear();
scanf("%d%d", &n, &m);
memset(a, -1, sizeof(a));
for (int i = 1; i <= m; i++) {
scanf("%d", l + i);
}
for (int i = 1; i < m; i++) {
if (a[l[i]] == -1) {
a[l[i]] = (l[i + 1] - l[i] + n) % n;
if (a[l[i]] == 0) {
a[l[i]] = n;
}
if (s[a[l[i]]]) {
puts("-1");
return 0;
} else {
s[a[l[i]]] = true;
}
} else if (a[l[i]] != ((l[i + 1] - l[i] + n) % n == 0
? n
: (l[i + 1] - l[i] + n) % n)) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] == -1) {
for (int j = 1; j <= n; j++) {
if (s[j] == false) {
a[i] = j;
s[j] = true;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
queue<long long int> q;
vector<pair<long long int, long long int> > ans;
void bfs(long long int s, vector<long long int> g[]) {
bool b[n + 1];
for (long long int i = 0; i < n; i++) {
b[i] = false;
}
b[s] = true;
q.push(s);
while (!q.empty()) {
long long int x = q.front();
q.pop();
for (long long int i = 0; i < g[x].size(); i++) {
if (b[g[x][i]] == false) {
b[g[x][i]] = true;
ans.push_back(make_pair(x, g[x][i]));
q.push(g[x][i]);
}
}
}
}
int main() {
long long int m;
cin >> n >> m;
vector<long long int> g[n];
vector<long long int> deg(n, 0);
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
deg[x]++;
deg[y]++;
}
long long int pos = 0;
long long int x = deg[0];
for (long long int i = 1; i < n; i++) {
if (x < deg[i]) {
pos = i;
x = deg[i];
}
}
bfs(pos, g);
for (long long int i = 0; i < ans.size(); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<vector<int>> cnt(2, vector<int>(2));
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
a /= 2;
b /= 2;
cnt[a % 2][b % 2]++;
}
long long ans1 = 0, ans2 = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
ans1 += 1LL * cnt[i][j] * (cnt[i][j] - 1) * (n - 2) / 2;
ans2 += 1LL * cnt[i][j] * (cnt[i][j] - 1) * (cnt[i][j] - 2) / 6;
}
}
cerr << ans1 << endl;
cerr << ans2 << endl;
cout << ans1 - ans2 * 2 << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
constexpr long long mod = 998244353;
const long long INF = mod * mod;
template <typename T>
void chmin(T& a, T b) {
a = min(a, b);
}
template <typename T>
void chmax(T& a, T b) {
a = max(a, b);
}
template <typename T>
void cinarray(vector<T>& v) {
for (int i = 0; i < v.size(); i++) cin >> v[i];
}
template <typename T>
void coutarray(vector<T>& v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) cout << " ";
cout << v[i];
}
cout << "\n";
}
long long mod_pow(long long x, long long n, long long m = mod) {
if (n < 0) {
long long res = mod_pow(x, -n, m);
return mod_pow(res, m - 2, m);
}
if (abs(x) >= m) x %= m;
if (x < 0) x += m;
if (x == 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % m;
x = x * x % m;
n >>= 1;
}
return res;
}
struct modint {
int n;
modint() : n(0) { ; }
modint(long long m) {
if (m < 0 || mod <= m) {
m %= mod;
if (m < 0) m += mod;
}
n = m;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint& a, modint b) {
a.n += b.n;
if (a.n >= mod) a.n -= mod;
return a;
}
modint operator-=(modint& a, modint b) {
a.n -= b.n;
if (a.n < 0) a.n += mod;
return a;
}
modint operator*=(modint& a, modint b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, long long n) {
if (n == 0) return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
long long inv(long long a, long long p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
modint operator/=(modint& a, modint b) {
a = a / b;
return a;
}
const int max_n = 1 << 20;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
modint combP(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[a - b];
}
long long gcd(long long a, long long b) {
a = abs(a);
b = abs(b);
if (a < b) swap(a, b);
while (b) {
long long r = a % b;
a = b;
b = r;
}
return a;
}
mt19937 mt(time(0));
uniform_int_distribution<> ud(0, (1 << 20) - 1);
unsigned long long ranum() {
unsigned long long res = 0;
res |= ud(mt);
res |= (unsigned long long)ud(mt) << 20;
res |= (unsigned long long)ud(mt) << 40;
return res;
}
const int mn = 1 << 20;
bool isp[mn];
int chp[mn];
unsigned long long h[mn];
unsigned long long hs[mn];
unsigned long long hfact[mn];
void init() {
fill(isp + 2, isp + mn, true);
for (int i = 2; i < mn; i++) {
if (!isp[i]) continue;
h[i] = ranum();
chp[i] = i;
for (int j = 2 * i; j < mn; j += i) {
isp[j] = false;
chp[j] = i;
}
}
hs[1] = 0;
for (int i = 2; i < mn; i++) {
hs[i] = hs[i / chp[i]] ^ h[chp[i]];
hfact[i] = hfact[i - 1] ^ hs[i];
}
}
void solve() {
int n;
cin >> n;
unsigned long long z = 0;
for (int i = 1; i <= n; i++) {
z ^= hfact[i];
}
vector<int> ans;
if (z == 0) {
for (int i = 1; i <= n; i++) ans.push_back(i);
} else {
map<unsigned long long, int> mp;
for (int i = 1; i <= n; i++) mp[hfact[i]] = i;
for (int cnt = 1;; cnt++) {
vector<int> del;
unsigned long long cs = z;
function<bool(int, int)> dfs = [&](int dep, int loc) {
if (dep == cnt - 1) {
if (mp.find(cs) != mp.end()) {
del.push_back(mp[cs]);
return true;
}
return false;
}
if (loc > n) return false;
del.push_back(loc);
cs ^= hfact[loc];
if (dfs(dep + 1, loc + 1)) return true;
del.pop_back();
cs ^= hfact[loc];
if (dfs(dep, loc + 1)) return true;
return false;
};
if (dfs(0, 2)) {
vector<bool> can(n + 1, true);
for (int id : del) can[id] = false;
for (int i = 1; i <= n; i++)
if (can[i]) ans.push_back(i);
break;
}
}
}
cout << ans.size() << "\n";
coutarray(ans);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long prime_const = 1e9 + 7;
bool sort_function(long long a, long long b) { return a < b; }
long long minim(long long x, long long y) {
if (x < y)
return x;
else
return y;
}
long long maxim(long long x, long long y) {
if (x > y)
return x;
else
return y;
}
int main() {
string s;
long long d, v1, v2, mod, b, c, l, r, ans = 0, p, x, y, sum, o = 0, t, m, mz,
f1, f2, time, st, f, len, n, k, mid,
min, max, z = 0;
cin >> n >> m;
vector<vector<long long> > vert(n + 1), dop(n + 1);
vector<int> a(n + 1, -1);
for (int i = 0; i < m; i++) {
cin >> l >> r;
vert[l].push_back(r);
vert[r].push_back(l);
}
for (int i = 1; i <= n; i++) {
sort(vert[i].begin(), vert[i].end(), sort_function);
}
for (int i = 1; i < n + 1; i++) {
if (vert[i].size() == 0) {
for (int j = 1; j <= n; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
continue;
}
for (int j = 1; j < vert[i][0]; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
for (int qq = 0; qq < vert[i].size() - 1; qq++) {
for (int j = vert[i][qq] + 1; j < vert[i][qq + 1]; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
}
for (int j = vert[i][vert[i].size() - 1] + 1; j <= n; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
}
for (int i = 1; i <= n; i++) {
if (vert[i].size() == n - 1) {
a[i] = 2;
}
}
z = 0;
for (int i = 1; i < n + 1; i++)
if (a[i] != 2) {
a[i] = 1;
z = i;
break;
}
if (z == 0) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << "b";
}
return 0;
}
a[z] = 1;
for (int i = 0; i < vert[z].size(); i++) {
if (a[vert[z][i]] != 2) {
a[vert[z][i]] = 1;
}
}
for (int i = 0; i < dop[z].size(); i++) {
if (a[dop[z][i]] == 2) {
cout << "NO";
return 0;
}
a[dop[z][i]] = 3;
}
for (int i = 1; i <= n; i++)
if (a[i] != 2) {
k = a[i];
for (int j = 0; j < vert[i].size(); j++) {
if ((a[vert[i][j]] != 2) && (a[vert[i][j]] != k)) {
cout << "NO";
return 0;
}
}
for (int j = 0; j < dop[i].size(); j++) {
if ((a[dop[i][j]] == 2) || (a[dop[i][j]] == k)) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
cout << 'a';
}
if (a[i] == 2) {
cout << 'b';
}
if (a[i] == 3) {
cout << 'c';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, y;
scanf("%lld", &n);
;
scanf("%lld", &x);
;
scanf("%lld", &y);
;
string s;
{
char temp[1000000];
scanf("%s", temp);
s = temp;
};
int count0 = 0;
int i = 0;
int boo = 1;
while (i < n) {
if (boo && s[i] == '0') {
count0++;
boo = 0;
} else if (s[i] == '1') {
boo = 1;
}
i++;
}
long long int min1 = 1000000000000000001;
for (int i = 0; i < count0; i++) {
min1 = min(min1, (i)*x + (count0 - i) * y);
}
if (min1 != 1000000000000000001)
cout << min1 << endl;
else
cout << 0 << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define maxn 300013
#define maxm 23
#define ll long long
#define M1 (ll)998244353
#define M (ll)1000000007
#define eps 1e-10
int fa[maxn][23], _log=19;
int T;
int a[maxn], c[maxn];
int main() {
scanf("%d%d%d", &T, &a[1], &c[1]);
int typ, u, w;
for(int v=2; v<=T+1; v++){
scanf("%d", &typ);
if(typ==1){
scanf("%d%d%d", &u, &a[v], &c[v]);
fa[v][0]=u+1;
for(int i=1; i<=_log; i++){
fa[v][i]=fa[fa[v][i-1]][i-1];
}
}
else{
ll res=0, ans=0;
scanf("%d%d", &u, &w);
u++;
while(w && a[u]){
int cur=u;
for(int i=_log; i>=0; i--){
if(fa[cur][i] && a[fa[cur][i]]){
cur=fa[cur][i];
}
}
int t=min(w, a[cur]);
w-=t, a[cur]-=t;
res+=(ll)t;
ans+=(ll)t*c[cur];
}
printf("%lld %lld\n", res, ans);
fflush(stdout);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int c[maxn], s[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> c[i] >> s[i];
set<pair<int, int>> st[2];
for (int i = 0; i < n; ++i) st[c[i]].insert(make_pair(s[i], i));
vector<tuple<int, int, int>> ans;
int t = n - 1;
while (t--) {
int cur = -1;
if (st[0].size() == 1)
cur = 1;
else if (st[1].size() == 1)
cur = 0;
else
cur = (st[0].begin()->first < st[1].begin()->first ? 0 : 1);
int z, w;
tie(w, z) = *st[cur].begin();
st[cur].erase(make_pair(w, z));
int y, x;
tie(y, x) = *st[cur ^ 1].lower_bound(make_pair(w, -1));
ans.emplace_back(z, x, w);
st[cur ^ 1].erase(make_pair(y, x));
st[cur ^ 1].insert(make_pair(y - w, x));
}
for (auto i : ans) {
int a, b, c;
tie(a, b, c) = i;
cout << a + 1 << ' ' << b + 1 << ' ' << c << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
template <typename T_n>
void read(T_n &n) {
cin >> n;
}
template <typename T_n, typename T_a>
void read(T_a a[], T_n n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
template <typename T_n, typename T_a>
void read(vector<T_a> &a, T_n n) {
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
}
void _init_() { ios_base::sync_with_stdio(0), cin.tie(0); }
const int N = 1e5 + 9, SEG = 131072;
const int Mod_M = 1e8;
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == n - 1 && j == 0) {
printf("1%c", " \n"[j == n - 1]);
} else {
printf("%d%c", (i == j || i == j - 1) ? 1 : 0, " \n"[j == n - 1]);
}
}
}
}
int main() {
_init_();
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n_people, n_chips, i;
cin >> n_people >> n_chips;
int answer = 0;
int c_answer;
L1:
for (i = 1; i <= n_people; i++) {
c_answer = answer;
answer += i;
if (answer > n_chips) break;
}
if (answer <= n_chips) goto L1;
cout << (n_chips - c_answer);
return (0);
}
| 1 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 3005;
const double pi = acos(-1.0);
int n, l, t[N];
double ansx, ansy;
int main()
{
read(n); read(l);
for (int i = 1; i <= n; i++) read(t[i]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
{
double orz = pi * (t[i] + t[j]) / l;
ansx += cos(orz) * (n - (j - i << 1));
ansy += sin(orz) * (n - (j - i << 1));
}
double sum = 1.0 * n * (n - 1) * (n - 2) / 6;
return printf("%.14lf %.14lf\n", ansx / sum, ansy / sum), 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#include<numeric>
#include<cassert>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define rep(i,s,n) for(int i=(s); i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define IN(x,s,g) ((x) >= (s) && (x) < (g))
#define ISIN(x,y,w,h) (IN((x),0,(w)) && IN((y),0,(h)))
#define print(x) printf("%d\n",x)
using namespace std;
typedef unsigned int uint;
typedef long long ll;
const int _dx[] = {0,1,0,-1};
const int _dy[] = {-1,0,1,0};
int getInt(){
int ret = 0,c;
c = getchar();
while(!isdigit(c)) c = getchar();
while(isdigit(c)){
ret *= 10;
ret += c - '0';
c = getchar();
}
return ret;
}
vector<vector<int> > mul(const vector<vector<int> > &a, const vector<vector<int> > &b){
const int n = a.size();
vector<vector<int> > ret(n, vector<int>(n, 0));
REP(i,n) REP(j,n)
if(a[i][j] == 1)
REP(k,n)
if(b[j][k])
ret[i][k] = 1;
return ret;
}
vector<vector<int> > calc(const vector<vector<int> > &g, int z){
if(z == 0){
const int n = g.size();
vector<vector<int> > ret(n, vector<int>(n, 0));
REP(i,n) ret[i][i] = 1;
return ret;
}
if(z % 2 == 1){
return mul(g, calc(mul(g,g), z/2));
}else{
return calc(mul(g,g), z/2);
}
}
int main(){
while(true){
int n = getInt();
int m = getInt();
int z = getInt();
if(n + m + z == 0) break;
vector<pair<int,int> > state(4*m);
/* f => prevPos s => nowPos */
REP(i,m){
state[4*i+1].s = state[4*i].f = getInt() - 1;
state[4*i+1].f = state[4*i].s = getInt() - 1;
state[4*i+2].s = state[4*i].f;
state[4*i+2].f = n + state[4*i].s;
state[4*i+3].s = state[4*i].s;
state[4*i+3].f = n + state[4*i].f;
}
int mm = m + m + m + m;
vector<vector<int> > g(mm, vector<int>(mm));
REP(i,mm) REP(j,mm)
if(state[j].f == state[i].s && state[j].s != state[i].f)
g[i][j] = 1;
//puts("g:");
//REP(i,mm) { REP(j,mm) printf("%d ",g[i][j]); puts(""); }
vector<vector<int> > ans = calc(g, z);
//puts("ans:");
//REP(i,mm) { REP(j,mm) printf("%d ",ans[i][j]); puts(""); }
bool ok = false;
REP(i,mm) REP(j,mm) if(ans[i][j] == 1){
if(state[i].s == 0 && state[j].s == n - 1){
ok = true;
break;
}
}
puts(ok ? "yes" : "no");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long fermat_inv(long long y) { return power(y, 1000000007 - 2ll); }
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
vector<int> ctr(6, 0);
for (int i = 0; i < 6; i++) cin >> ctr[i];
int check = 1;
string s[] = {"S", "M", "L", "XL", "XXL", "XXXL"};
vector<int> ctr1(5, 0);
int n;
cin >> n;
string ans[n];
vector<int> pos[5];
for (int i = 0; i < n; i++) {
string w;
cin >> w;
int found = 0;
for (int j = 0; j < 6 && !found; j++) {
if (s[j] == w) {
if (ctr[j] > 0) {
ctr[j]--;
ans[i] = w;
} else
check = 0;
found = 1;
}
}
for (int j = 0; j < 5 && !found; j++) {
string p = s[j] + "," + s[j + 1];
if (w == p) {
pos[j].push_back(i);
ctr1[j]++;
found = 1;
}
}
}
for (int j = 0; j < 5; j++) {
if (ctr1[j] <= ctr[j]) {
for (int i = 0; i < ctr1[j]; i++) {
ans[pos[j][i]] = s[j];
}
continue;
} else if (ctr1[j] - ctr[j] <= ctr[j + 1]) {
for (int i = 0; i < ctr[j]; i++) {
ans[pos[j][i]] = s[j];
}
for (int i = ctr[j]; i < ctr1[j]; i++) {
ans[pos[j][i]] = s[j + 1];
}
ctr[j + 1] -= ctr1[j] - ctr[j];
} else {
check = 0;
break;
}
}
if (check) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << "\n";
} else
cout << "NO\n";
}
return 0;
}
| 4 |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cassert>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
typedef long long ll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000001
#define fi first
#define sc second
#define rep(i,x) for(int i=0;i<x;i++)
string s;
int main()
{
cin >> s;
int nx=0; string res = "";
for(int i=0;i<s.size();i++)
{
if(nx%2 == 0 && s[i]=='A')
{
nx++; res.pb(s[i]);
}
else if(nx%2 == 1 && s[i]=='Z')
{
nx++; res.pb(s[i]);
}
}
if(res.size()%2 == 1) res.resize(res.size()-1);
if(res.empty()) res = "-1";
cout << res << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[3000000];
int main() {
long long int i, j, n, m, sum = 0;
cin >> n >> m;
j = (n + 1) / 2;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
sum += a[i];
if (i == j)
a[i] = m;
else if (i < (j)) {
if (a[i] > m) a[i] = m;
} else {
if (a[i] < m) a[i] = m;
}
}
for (i = 1; i <= n; i++) {
sum -= a[i];
}
cout << abs(sum) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, fr[2010], dr[1010], st[1010], ok, j, mx, nrdist, aux;
struct chestie {
int ind, nr;
} v[2010];
void verif();
bool compind(chestie A, chestie B);
bool compnr(chestie A, chestie B);
int main() {
cin >> n;
ok = 1;
for (int i = 1; i <= n; i++) {
cin >> st[i];
v[i].nr = v[i].nr + st[i];
if (st[i] >= i) ok = 0;
}
for (int i = 1; i <= n; i++) {
cin >> dr[i];
v[i].ind = i;
v[i].nr = v[i].nr + dr[i];
if (fr[v[i].nr] == 0) nrdist++;
fr[v[i].nr] = 1;
if (v[i].nr > 2 * n - 2) ok = 0;
if (dr[i] >= (n - i + 1)) ok = 0;
}
verif();
if (fr[0] == 0) ok = 0;
if (ok == 0)
cout << "NO" << '\n';
else {
sort(v + 1, v + n + 1, compnr);
for (int i = 1; i <= n; i++)
if (v[i].nr > v[i - 1].nr + 1) {
j = i;
aux = v[i].nr;
while (j <= n && v[j].nr == aux) {
v[j].nr = v[i - 1].nr + 1;
j++;
}
j--;
}
sort(v + 1, v + n + 1, compind);
cout << "YES" << '\n';
for (int i = 1; i <= n; i++) cout << nrdist - v[i].nr << ' ';
cout << '\n';
}
return 0;
}
void verif() {
int vn, vns, vnd;
for (int i = 1; i <= n; i++) {
vn = 0;
vnd = vns = 0;
for (int j = i + 1; j <= n; j++)
if (v[j].nr < v[i].nr) vnd++;
for (int j = i - 1; j > 0; j--)
if (v[j].nr < v[i].nr) vns++;
if (vnd != dr[i]) {
ok = 0;
return;
}
if (vns != st[i]) {
ok = 0;
return;
}
vn = vns + vnd;
if (vn != v[i].nr) {
ok = 0;
return;
}
}
}
bool compnr(chestie A, chestie B) {
return (A.nr < B.nr || (A.nr == B.nr && A.ind < B.ind));
}
bool compind(chestie A, chestie B) { return A.ind < B.ind; }
| 3 |
#include <iostream>
#include <queue>
#include <string>
using namespace std;
int main(void)
{
priority_queue<int> queue;
string command;
int num;
while(true)
{
cin >> command;
if(command=="end")
{
break;
}
if(command=="extract")
{
cout << queue.top() << endl;
queue.pop();
}
else
{
cin >> num;
queue.push(num);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, a = "", b = "";
cin >> s;
long long int k = s.size();
for (long long int i = 0; i < k / 2; i++) {
a = a + s[i];
}
for (long long int i = k / 2; i < k; i++) {
b = b + s[i];
}
long long int z = 0, m = 0;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a[0] > b[0])
z = 1;
else if (a[0] == b[0])
z = -1;
else
z = 0;
if (n == 1) {
if (a[0] == b[0])
cout << "NO" << endl;
else
cout << "YES" << endl;
} else {
if (z == -1)
cout << "NO" << endl;
else {
for (long long int i = 1; i < k / 2; i++) {
if (z == 1) {
if (a[i] <= b[i]) {
m = 0;
break;
} else
m = 1;
} else {
if (a[i] >= b[i]) {
m = 0;
break;
} else {
m = 1;
}
}
}
if (m == 0)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
const int Maxn = 305;
const int S = 0;
const int T = 301;
int n, m;
vector<int> ss[Maxn];
int value[Maxn];
int match[Maxn << 1];
bool used[Maxn << 1];
vector<int> adj1[Maxn << 1];
vector<int> adj2[Maxn];
int dist[Maxn];
int capa[Maxn][Maxn];
int ans = 0;
bool dfs1(int now) {
used[now] = true;
for (auto v : adj1[now]) {
int w = match[v];
if (w == 0 || !used[w] && dfs1(w)) {
match[now] = v;
match[v] = now;
return true;
}
}
return false;
}
void perfect() {
memset(match, 0, sizeof match);
for (int i = 1; i <= n; i++) {
if (match[i] == 0) {
memset(used, 0, sizeof used);
dfs1(i);
}
}
}
bool bfs() {
memset(dist, -1, sizeof dist);
queue<int> q;
int x;
q.push(S);
dist[S] = 0;
while (!q.empty()) {
x = q.front();
q.pop();
for (auto v : adj2[x]) {
if (dist[v] == -1 && capa[x][v] > 0) {
q.push(v);
dist[v] = dist[x] + 1;
}
}
}
return dist[T] > 0;
}
int dfs(int now, int f) {
if (f == 0 || now == T) return f;
int w = 0, used = 0;
for (auto v : adj2[now]) {
if (dist[v] == dist[now] + 1 && capa[now][v] > 0) {
w = dfs(v, min(f - used, capa[now][v]));
if (w != 0) {
capa[now][v] -= w;
capa[v][now] += w;
used += w;
}
}
}
if (used == 0) dist[now] = -1;
return used;
}
void build() {
memset(capa, 0, sizeof capa);
for (int i = 1; i <= n; i++) {
if (value[i] < 0) {
adj2[S].push_back(i);
adj2[i].push_back(S);
capa[S][i] += -value[i];
} else {
adj2[i].push_back(T);
adj2[T].push_back(i);
capa[i][T] += value[i];
}
for (auto v : adj1[i]) {
adj2[i].push_back(match[v]);
adj2[match[v]].push_back(i);
capa[i][match[v]] += INF;
}
}
}
void calc() {
int flow = 0;
while (bfs()) {
flow += dfs(S, INF);
}
ans -= flow;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &m);
ss[i].resize(m);
for (int j = 0; j < m; j++) {
scanf("%d", ss[i].begin() + j);
adj1[i].push_back(ss[i][j] + Maxn);
adj1[ss[i][j] + Maxn].push_back(i);
}
}
for (int i = 1; i <= n; i++) scanf("%d", value + i);
for (int i = 1; i <= n; i++) {
if (value[i] < 0) ans -= value[i];
}
perfect();
build();
calc();
printf("%d\n", -ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, nr, inc, sf, i, sf1, v[100000];
bool ok;
int main() {
cin >> n;
if (n == 4)
cout << '1';
else if (n == 7)
cout << '2';
else {
nr = 2;
v[1] = 4;
v[2] = 7;
inc = 1;
sf = 2;
sf1 = 2;
ok = true;
while (ok == true) {
for (i = inc; i <= sf; ++i) {
++sf1;
v[sf1] = v[i] * 10 + 4;
if (v[sf1] == n) {
ok = false;
cout << sf1;
break;
}
++sf1;
v[sf1] = v[i] * 10 + 7;
if (v[sf1] == n) {
ok = false;
cout << sf1;
break;
}
}
inc = sf + 1;
sf = sf1;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c, v0, v1, a, l;
void solve() {
cin >> c >> v0 >> v1 >> a >> l;
int left = c - v0;
int ans = 1;
if (left <= 0) {
cout << 1 << "\n";
} else {
for (int i = 1; left > 0; i++) {
int x = v0 + i * a;
x = min(x, v1);
x -= l;
left -= x;
ans++;
}
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1, i = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m, k;
char s[105][105][105];
bool u[105][105][105];
bool p[105][105][105];
int dx[] = {1, 0, 0};
int dy[] = {0, 1, 0};
int dz[] = {0, 0, 1};
inline bool goes(int x0, int y0, int z0, int x1, int y1, int z1) {
for (int d = 0; d < 3; ++d) {
if (x0 + dx[d] == x1 && y0 + dy[d] == y1 && z0 + dz[d] == z1) {
return 1;
}
}
return 0;
}
void dfs(int x, int y, int z) {
u[x][y][z] = 1;
for (int d1 = 0; d1 < 3; ++d1) {
int nx1 = x + dx[d1];
int ny1 = y + dy[d1];
int nz1 = z + dz[d1];
if (nx1 == n || ny1 == m || nz1 == k || s[nx1][ny1][nz1] == '0') {
continue;
}
if (!u[nx1][ny1][nz1]) {
dfs(nx1, ny1, nz1);
}
for (int d2 = 0; d2 < 3; ++d2) {
int nnx = nx1 + dx[d2];
int nny = ny1 + dy[d2];
int nnz = nz1 + dz[d2];
if (nnx == n || nny == m || nnz == k || s[nnx][nny][nnz] == '0') {
continue;
}
bool ck = 1;
for (int d3 = 0; d3 < 3; ++d3) {
int nx2 = x + dx[d3];
int ny2 = y + dy[d3];
int nz2 = z + dz[d3];
if (d1 == d3 || nx2 == n || ny2 == m || nz2 == k ||
s[nx2][ny2][nz2] == '0') {
continue;
}
if (goes(nx2, ny2, nz2, nnx, nny, nnz)) {
ck = 0;
}
}
p[nx1][ny1][nz1] |= ck;
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%s", s[i][j]);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int ii = 0; ii < k; ++ii) {
if (s[i][j][ii] == '1' && !u[i][j][ii]) {
dfs(i, j, ii);
}
}
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int ii = 0; ii < k; ++ii) {
res += p[i][j][ii];
}
}
}
printf("%d", res);
return 0;
}
| 4 |
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <unordered_map>
using namespace std;
#define REP(i, a, b) for(int i = (a); i < int(b); ++i)
#define rep(i, n) REP(i, 0, n)
template<class T> inline void chmax(T &a, const T &b) { if(a < b) a = b; }
template<class T> inline void chmin(T &a, const T &b) { if(a > b) a = b; }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
constexpr int MAX_H = 20;
for(int r, n; cin >> r >> n && r;) {
unordered_map<int, int> max_height;
rep(i, n) {
int xl, xr, h;
cin >> xl >> xr >> h;
REP(x, xl, xr) {
chmax(max_height[x], h);
}
}
double ans = MAX_H;
REP(i, -r, r) {
const int h = max_height[i] + r;
const int x = (i < 0 ? i + 1 : i);
const double y = sqrt(r * r - x * x);
chmin(ans, h - y);
}
cout << ans << endl;
}
return EXIT_SUCCESS;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, ans;
int main() {
cin >> n;
vector<int> h(n);
for (i = 0; i < n; i++) cin >> h[i];
ans = h[0] + 1;
for (i = 1; i < n; i++) {
if (h[i] < h[i - 1])
ans += h[i - 1] - h[i] + 2;
else
ans += h[i] - h[i - 1] + 2;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double PI = acos(-1.);
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 262144 * 8 + 5;
char s[MAXN];
char t[MAXN];
struct CP {
double x, y;
CP() {}
CP(double x, double y) : x(x), y(y) {}
inline double real() { return x; }
inline CP operator*(const CP& r) const {
return CP(x * r.x - y * r.y, x * r.y + y * r.x);
}
inline CP operator-(const CP& r) const { return CP(x - r.x, y - r.y); }
inline CP operator+(const CP& r) const { return CP(x + r.x, y + r.y); }
inline CP conj(const CP& r) { return CP(r.x, -r.y); }
};
CP a[MAXN], b[MAXN];
int r[MAXN], res[MAXN];
void fft_init(int nm, int k) {
for (int i = 0; i < nm; ++i) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (k - 1));
}
void fft(CP ax[], int nm, int op) {
for (int i = 0; i < nm; ++i)
if (i < r[i]) swap(ax[i], ax[r[i]]);
for (int h = 2, m = 1; h <= nm; h <<= 1, m <<= 1) {
CP wn = CP(cos(op * 2 * PI / h), sin(op * 2 * PI / h));
for (int i = 0; i < nm; i += h) {
CP w(1, 0);
for (int j = i; j < i + m; ++j, w = w * wn) {
CP t = w * ax[j + m];
ax[j + m] = ax[j] - t;
ax[j] = ax[j] + t;
}
}
}
if (op == -1)
for (int i = 0; i < nm; ++i) ax[i].x /= nm;
}
void trans(int ax[], int bx[], int n, int m, int mul) {
int nm = 1, k = 0;
while (nm < 2 * n || nm < 2 * m) nm <<= 1, ++k;
for (int i = 0; i < n; ++i) a[i] = CP(ax[i], 0);
for (int i = 0; i < m; ++i) b[i] = CP(bx[i], 0);
for (int i = n; i < nm; ++i) a[i] = CP(0, 0);
for (int i = m; i < nm; ++i) b[i] = CP(0, 0);
fft_init(nm, k);
fft(a, nm, 1);
fft(b, nm, 1);
for (int i = 0; i < nm; ++i) a[i] = a[i] * b[i];
fft(a, nm, -1);
nm = n + m - 1;
for (int i = 0; i < nm; ++i) res[i] += (int)(a[i].real() + 0.5) * mul;
}
int s1[MAXN], t1[MAXN];
int ans[MAXN];
int getid(char x) {
if (x == 'V') return 1;
if (x == 'K') return -1;
return 0;
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
scanf("%d %s", &n, s);
for (int i = 0; i <= 2 * n; i++) res[i] = 0;
for (int i = 0; i < n; i++) {
s1[i] = getid(s[i]) * getid(s[i]) * getid(s[i]);
t1[i] = getid(s[i]);
}
reverse(t1, t1 + n);
trans(s1, t1, n, n, 1);
for (int i = 0; i < n; i++) {
s1[i] = getid(s[i]);
t1[i] = getid(s[i]) * getid(s[i]) * getid(s[i]);
}
reverse(t1, t1 + n);
trans(s1, t1, n, n, 1);
for (int i = 0; i < n; i++) {
s1[i] = getid(s[i]) * getid(s[i]);
t1[i] = getid(s[i]) * getid(s[i]);
}
reverse(t1, t1 + n);
trans(s1, t1, n, n, -2);
for (int i = 0; i <= n; i++) ans[i] = 0;
for (int i = 0; i < n; i++)
if (res[i] == 0) ans[n - i - 1] = 1;
ans[n] = 1;
vector<int> v;
for (int i = n; i >= 1; i--) {
for (int j = i + i; j <= n; j += i) ans[i] &= ans[j];
if (ans[i]) v.push_back(i);
}
printf("%d\n", v.size());
reverse(v.begin(), v.end());
for (int i : v) printf("%d ", i);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323;
long long int mod = 1000000000 + 7;
const double pii = acos(-1.0);
const long long int INF = 1e18;
const long long int inf = 1e9;
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long powe(long long x, long long y) {
x = x % mod, y = y % (mod - 1);
long long ans = 1;
while (y > 0) {
if (y & 1) {
ans = (1ll * x * ans) % mod;
}
y >>= 1;
x = (1ll * x * x) % mod;
}
return ans;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
bool isPrime(long long int n) {
if (n < 2) return false;
for (long long int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long ncr(long long n, long long r) {
long long res = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long add(long long a, long long b) { return ((a % mod + b % mod) % mod); }
long long sub(long long a, long long b) {
return ((a % mod - b % mod + mod) % mod);
}
long long mul(long long a, long long b) {
return (((a % mod) * (b % mod)) % mod);
}
long long divi(long long a, long long b) {
return (mul(a, powe(b, mod - 2)) % mod);
}
void fun() {}
const long long int N = 2e5 + 7;
std::vector<long long int> adj[N];
bool visited[N];
long long int len, point;
set<long long int> path;
long long int parent[N];
void dfs(long long int node, long long int dist) {
visited[node] = true;
for (auto child : adj[node]) {
if (!visited[child]) {
if (len <= dist) {
len = dist;
point = child;
}
dfs(child, dist + 1);
}
}
}
void find_par(long long int node, long long int par = 0) {
visited[node] = true;
parent[node] = par;
for (auto child : adj[node]) {
if (!visited[child]) {
find_par(child, node);
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
fun();
long long int tests = 1;
while (tests--) {
long long int n;
cin >> n;
for (long long int i = 1; i < n; i++) {
long long int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
long long int a = 1, b = 1, c = 1;
dfs(1, 0);
a = point;
memset(visited, false, sizeof(visited));
len = 0;
dfs(point, 0);
b = point;
memset(visited, false, sizeof(visited));
find_par(point, point);
point = a;
while (point != b) {
path.insert(point);
point = parent[point];
}
path.insert(b);
std::vector<long long int> distance(N);
memset(visited, false, sizeof(visited));
queue<long long int> q;
for (long long int i : path) visited[i] = true, q.push(i);
while (!q.empty()) {
long long int ye = q.front();
q.pop();
visited[ye] = true;
for (auto child : adj[ye]) {
if (!visited[child]) {
q.push(child);
distance[child] = distance[ye] + 1;
}
}
}
long long int duri = 0;
for (long long int i = 1; i <= n; i++) {
if (i == a or i == b) continue;
if (distance[i] >= duri) {
duri = distance[i];
c = i;
}
}
memset(parent, 0, sizeof(parent));
memset(visited, false, sizeof(visited));
find_par(c, c);
point = b;
while (point != c) {
path.insert(point);
point = parent[point];
}
path.insert(c);
point = a;
while (point != c) {
path.insert(point);
point = parent[point];
}
path.insert(c);
cout << (long long int)(path.size()) - 1 << '\n';
cout << a << ' ' << b << ' ' << c << '\n';
}
cerr << "time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int c1 = 0;
int c2 = 0;
int c3 = 0;
int c4 = 0;
int a;
int b;
int m[n][2];
for (int i = 0; i < n; i++) {
cin >> a >> b;
m[i][0] = a;
m[i][1] = b;
if (a == 1) {
c1++;
}
if (a == 0) {
c2++;
}
if (b == 0) {
c4++;
}
if (b == 1) {
c3++;
}
}
int ans = min(c1, c2);
int ans2 = min(c3, c4);
cout << ans + ans2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long nCr(int n, int r) {
if (r > n - r) r = n - r;
long long ans = 1;
int i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long a, b, c, d, e, g, h, n, t, f, k, l, m,
f1 = 0, flag = 0, flag1 = 0, co = 0, co1 = 0, co2 = 0, arr1[100001] = {0},
arr[100001] = {0}, sum = 0, sum1 = 0, ma = 0, mi = 1000000000000000001;
long long co3 = 0, co4 = 0, co5 = 0, co6 = 0, co7 = 0, co8 = 0;
double pi = 2 * acos(0.0);
string str, str1, str2, str3;
char ch;
vector<long long> v;
vector<long long> v1;
vector<string> vs;
vector<string> vs1;
map<int, int> mp;
set<long long> s;
set<long long> s1;
set<long long>::iterator it;
queue<long long> q;
int x[] = {1, 1, 1, 0, 0, -1, -1, -1};
int y[] = {0, 1, -1, 1, -1, 1, -1, 0};
cin >> a >> b;
for (int i = 0; i < a; i++) {
cin >> c;
mp[c] = 1;
}
for (int i = 1;; i++) {
if (mp[i] == 1)
continue;
else {
b -= i;
if (b < 0) break;
v.push_back(i);
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool seen[200];
int lvl[200];
int main() {
int N, K;
cin >> N >> K;
memset(seen, false, sizeof(seen));
for (int i = 0; i < N; ++i) cin >> lvl[i];
int Q;
cin >> Q;
int T = N / K;
double mi = 1e9, ma = 0;
int CNT = 0;
for (int q = 0; q < Q; ++q) {
double f = 0;
for (int i = 0; i < T; ++i) {
int idx;
cin >> idx;
idx--;
if (!seen[idx]) CNT++;
f += lvl[idx];
seen[idx] = true;
}
mi = min(mi, f);
ma = max(ma, f);
}
vector<int> V;
for (int i = 0; i < N; ++i)
if (!seen[i]) V.push_back(lvl[i]);
sort(V.begin(), V.end());
if (V.size() >= T && CNT < T * K) {
double f = 0;
for (int i = 0; i < min(T, (int)V.size()); ++i) f += V[i];
mi = min(mi, f);
ma = max(ma, f);
f = 0;
for (int i = (int)V.size() - 1; i >= (int)V.size() - T; --i) f += V[i];
mi = min(mi, f);
ma = max(ma, f);
}
printf("%0.10lf %0.10lf\n", mi / (double)T, ma / (double)T);
}
| 2 |
#include <bits/stdc++.h>
bool vis[30][30];
int n, p;
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d %d", &n, &p);
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++)
for (int j = 1; j <= 2; j++) {
vis[i][(i + j) % n] = 1;
vis[(i + j) % n][i] = 1;
}
int pp = p;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (!vis[i][j]) {
if (!pp) break;
vis[i][j] = 1;
vis[j][i] = 1;
pp--;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (vis[i][j]) printf("%d %d\n", i + 1, j + 1);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma optimize(2)
const int inf = 0x7FFFFFFF;
template <class T>
inline void MAX(T &x, T y) {
if (y > x) x = y;
}
template <class T>
inline void MIN(T &x, T y) {
if (y < x) x = y;
}
template <class T>
inline void rd(T &x) {
x = 0;
char o, f = 1;
while (o = getchar(), o < 48)
if (o == 45) f = -f;
do x = (x << 3) + (x << 1) + (o ^ 48);
while (o = getchar(), o > 47);
x *= f;
}
template <class T>
void wt(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) wt(x / 10);
putchar('0' + x % 10);
}
const long long llinf = 4223372036854775807;
const long long mod = (0 ? 1000000007 : 998244353);
const long long mod2 = 999998639;
const long long m1 = 998244353;
const long long m2 = 1000001011;
const long long pr = 233;
const double eps = 1e-7;
const long long maxm = 1;
const long long maxn = 510000;
long long date[110000];
long long pre[110000];
void work() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> date[i];
for (long long i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + date[i];
}
long long q;
cin >> q;
long long l, r;
for (long long i = 1; i <= q; i++) {
cin >> l >> r;
cout << (pre[r] - pre[l - 1]) / 10 << endl;
}
}
signed main() {
long long t = 1;
while (t--) {
work();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ed[2000];
int sho[1200][1200];
int col[1200];
int n, m;
int makk[1200];
int sp[1200];
void dfs(int v, int ccc) {
sp[v] = ccc;
for (int a = 0; a < ed[v].size(); a++) {
if (sp[ed[v][a]] == -1) dfs(ed[v][a], ccc);
}
}
void getsho(int v) {
int q[3000];
int dp[3000];
int c[3000];
for (int a = 0; a < n; a++) c[a] = -1;
q[0] = v;
dp[0] = 0;
c[v] = 1;
int bb = 0;
int ee = 0;
while (bb <= ee) {
int vx = q[bb];
sho[v][vx] = dp[bb];
for (int a = 0; a < ed[vx].size(); a++) {
if (c[ed[vx][a]] == -1) {
int vu = ed[vx][a];
c[vu] = 1;
ee++;
q[ee] = vu;
dp[ee] = dp[bb] + 1;
}
}
bb++;
}
}
int isok;
void kolo(int v, int c) {
col[v] = c;
for (int a = 0; a < ed[v].size(); a++) {
if (col[ed[v][a]] == c)
isok = 0;
else if (col[ed[v][a]] == -1)
kolo(ed[v][a], 1 - c);
}
}
int main() {
cin >> n >> m;
for (int a = 0; a < 1200; a++) makk[a] = 0;
isok = 1;
int x, y;
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++) sho[a][b] = 1000000;
for (int a = 0; a < m; a++) {
cin >> x >> y;
ed[x - 1].push_back(y - 1);
ed[y - 1].push_back(x - 1);
}
for (int a = 0; a < 1100; a++) col[a] = -1;
kolo(0, 0);
if (!isok) {
cout << -1;
return 0;
}
for (int a = 0; a < n; a++) sp[a] = -1;
int ccc = -1;
for (int a = 0; a < n; a++) {
if (sp[a] == -1) {
ccc++;
dfs(a, ccc);
}
}
for (int a = 0; a < n; a++) getsho(a);
int mini = 0;
for (int a = 0; a < n; a++) {
for (int b = a + 1; b < n; b++) {
if (sp[a] == sp[b] && sho[a][b] > makk[sp[a]] && sho[a][b] < 100000)
makk[sp[a]] = sho[a][b];
}
}
int ss = 0;
for (int a = 0; a < 1200; a++) ss += makk[a];
cout << ss;
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
int main() {
int n;
while (scanf("%d", &n), ~n) {
double x = 1, y = 0;
rep(i, n - 1) {
double X = ((x - y) - (x + y)) / 2, Y = ((x - y) + (x + y)) / 2;
double d = sqrt(i + 1);
x += X / d; y += Y / d;
}
printf("%.7lf\n%.7lf\n", x, y);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
string s1 = s.substr(0, 2);
for (int i = 3; i < s.length(); i = i + 2) {
s1 = s1 + s[i];
}
cout << s1 << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n,q,b,c;
cin>>n;
ll sum=0;
map<int,ll>m;
int a[n];for(int i=0;i<n;i++)cin>>a[i],sum+=a[i],m[a[i]]++;
cin>>q;
while(q--){
cin>>b>>c;
sum+=(c-b)*m[b];
m[c]+=m[b],m[b]=0;
cout<<sum<<endl;
}
//cout<<sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void comparearr(int A[], int B[], int n) {
int sumA = 0, sumB = 0;
for (int i = 0; i < n; i++) sumA = sumA + A[i];
for (int i = 0; i < n; i++) sumB = sumB + B[i];
if (sumA >= sumB)
cout << "Yes";
else
cout << "No";
}
int main() {
int n;
cin >> n;
int A[50], B[50];
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) cin >> B[i];
comparearr(A, B, n);
}
| 1 |
// C - Sequence
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define up(i,s,e,d) for(int i=(s);i<(e);i+=(d))
int main(){
int N; cin>>N;
vector<ll> A(N);
ll csum = 0;
ll a = 0;
up(i,0,N,1){
cin>>A[i];
csum += A[i];
if(i%2==0 && csum<=0){//even +
a += abs(csum) + 1;
csum = 1;
}
if(i%2==1 && csum>=0){//odd -
a += abs(csum) + 1;
csum = -1;
}
}
csum = 0;
ll b = 0;
up(i,0,N,1){
csum += A[i];
if(i%2==1 && csum<=0){//odd +
b += abs(csum) + 1;
csum = 1;
}
if(i%2==0 && csum>=0){//even -
b += abs(csum) + 1;
csum = -1;
}
}
cout<< (a<b?a:b) <<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INFI = (1LL << 30) - 100;
const long long INFL = (1LL << 62) - 100;
const double eps = 1e-10;
const long double pi = acos(-1.0);
const int MAXN = 200010;
int cows[MAXN], clf[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &cows[i]);
}
for (int i = n; i >= 1; i--) {
clf[i] += clf[i + 1] + !cows[i];
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (cows[i]) {
sum += clf[i + 1];
}
}
printf("%I64d", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long SZ = 2000010;
const double PI = 3.1415926535897932384626433832795;
const double EPS = 1e-6;
const long long MUL = 239017;
string a, b1, b2;
map<string, vector<string>> d;
map<vector<string>, vector<string>> rd;
set<string> x;
int main() {
srand(330699524);
ios::sync_with_stdio(false);
cout.precision(20);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
a += '/';
int m = 0;
b1 = b2 = "";
for (char i : a) {
if (i == '/') m++;
if (m < 3)
b1 += i;
else
b2 += i;
}
b2.pop_back();
d[b1].push_back(b2);
}
for (auto &i : d) {
x.clear();
for (string j : i.second) x.insert(j);
i.second.clear();
for (string j : x) i.second.push_back(j);
rd[i.second].push_back(i.first);
}
int ans = 0;
for (auto i : rd)
if (i.second.size() > 1) ans++;
cout << ans << "\n";
for (auto i : rd)
if (i.second.size() > 1) {
for (string j : i.second) cout << j << " ";
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
vector<long long> dp;
long long gg(long long i, long long j) {
j = min(j, (long long)v.size() - 1);
long long res = dp[j];
if (i > 0) res -= dp[i - 1];
return res;
}
int main() {
int n;
cin >> n;
v.resize(n);
dp.resize(n);
for (int i = (0); i < (n); i += 1) cin >> v[i];
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long x = 0;
for (int i = (0); i < (n); i += 1) {
x += v[i];
dp[i] = x;
}
long long r1 = 0;
for (int i = (0); i < (n); i += 1) r1 += v[i] * i;
int q;
cin >> q;
while (q--) {
long long k;
cin >> k;
if (k == 1) {
cout << r1 << endl;
} else {
long long s = 0;
long long rame = 1;
int i = 0;
long long prnt = 0;
while (s < n) {
long long g = gg(s, s + rame - 1);
prnt += g * i;
s += rame;
i++;
rame *= k;
}
cout << prnt << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 52;
const int Mod = 1e9 + 7;
void add(int &x, int y) {
x += y;
if (x >= Mod) x -= Mod;
}
int mul(long long x, int y) { return x * y % Mod; }
int n;
int d[N];
int dp[2][N][N][N][N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &d[i]);
dp[0][d[1] == 2][d[1] == 3][d[2] == 2][d[2] == 3] = 1;
int s = 0;
for (int i = 3; i <= n; i++) {
for (int j1 = 0; j1 <= i; j1++)
for (int j2 = 0; j2 <= i - j1; j2++)
for (int k1 = 0; k1 <= i - j1 - j2; k1++)
for (int k2 = 0; k2 <= i - j1 - j2 - k1; k2++) {
int &val = dp[s][j1][j2][k1][k2], d1 = d[i] == 2, d2 = d[i] == 3;
if (!val) continue;
if (!j1 && !j2) {
if (k1) add(dp[s ^ 1][k1 - 1][k2][d1][d2], mul(val, k1));
if (k2) add(dp[s ^ 1][k1 + 1][k2 - 1][d1][d2], mul(val, k2));
}
if (j1) add(dp[s ^ 1][j1 - 1][j2][k1 + d1][k2 + d2], mul(val, j1));
if (j2)
add(dp[s ^ 1][j1 + 1][j2 - 1][k1 + d1][k2 + d2], mul(val, j2));
if (j1 && k1)
add(dp[s ^ 1][j1 - 1][j2][k1 + d2 - 1][k2], mul(val, j1 * k1));
if (j2 && k1)
add(dp[s ^ 1][j1 + 1][j2 - 1][k1 + d2 - 1][k2],
mul(val, j2 * k1));
if (j1 && k2)
add(dp[s ^ 1][j1 - 1][j2][k1 + d2 + 1][k2 - 1],
mul(val, j1 * k2));
if (j2 && k2)
add(dp[s ^ 1][j1 + 1][j2 - 1][k1 + d2 + 1][k2 - 1],
mul(val, j2 * k2));
if (d1) {
val = 0;
continue;
}
if (j1 && k1 > 1)
add(dp[s ^ 1][j1 - 1][j2][k1 - 2][k2],
mul(val, j1 * k1 * (k1 - 1) / 2));
if (j2 && k1 > 1)
add(dp[s ^ 1][j1 + 1][j2 - 1][k1 - 2][k2],
mul(val, j2 * k1 * (k1 - 1) / 2));
if (j1 && k1 && k2)
add(dp[s ^ 1][j1 - 1][j2][k1][k2 - 1], mul(val, j1 * k2 * k1));
if (j2 && k1 && k2)
add(dp[s ^ 1][j1 + 1][j2 - 1][k1][k2 - 1],
mul(val, j2 * k2 * k1));
if (j1 && k2 > 1)
add(dp[s ^ 1][j1 - 1][j2][k1 + 2][k2 - 2],
mul(val, j1 * k2 * (k2 - 1) / 2));
if (j2 && k2 > 1)
add(dp[s ^ 1][j1 + 1][j2 - 1][k1 + 2][k2 - 2],
mul(val, j2 * k2 * (k2 - 1) / 2));
val = 0;
}
s ^= 1;
}
printf("%d\n", dp[s][0][0][0][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void _print() { cout << '\n'; }
void print() { cout << '\n'; }
template <typename T, typename... Ts>
void _print(const T& value, const Ts&... values) {
cout << ' ' << value;
_print(values...);
}
template <typename T, typename... Ts>
void print(const T& value, const Ts&... values) {
cout << value;
_print(values...);
}
const int N = 1e5 + 5;
using ll = long long;
struct Query {
int id;
pair<int, int> seg1, seg2;
Query(int _1, pair<int, int> _2, pair<int, int> _3)
: id(_1), seg1(_2), seg2(_3){};
};
int par[18][N], depth[N], sta[N], en[N], child[N];
int ansQuery[N];
bool done[N];
vector<int> a[N];
int n, Time = 0;
vector<Query> query[N];
const int INF = 1e9;
class ITrangeMaxMin {
private:
int n, f[4 * N];
void init(int k, int l, int r) {
f[k] = -INF;
if (l == r) return;
init(k * 2, l, ((l + r) / 2));
init(k * 2 + 1, ((l + r) / 2) + 1, r);
}
void update(int k, int l, int r, int pos, int val) {
if (r < pos || pos < l || l > r) return;
if (pos <= l && r <= pos) {
f[k] = val;
return;
}
update(k * 2, l, ((l + r) / 2), pos, val);
update(k * 2 + 1, ((l + r) / 2) + 1, r, pos, val);
f[k] = max(f[k * 2], f[k * 2 + 1]);
}
int get(int k, int l, int r, int L, int R) {
if (r < L || R < l || l > r) return -INF;
if (L <= l && r <= R) return f[k];
return max(get(k * 2, l, ((l + r) / 2), L, R),
get(k * 2 + 1, ((l + r) / 2) + 1, r, L, R));
}
public:
void init(int _n) {
n = _n;
init(1, 0, n + 1);
}
int get(int l, int r) { return get(1, 0, n + 1, l, r); };
void update(int pos, int val) { update(1, 0, n + 1, pos, val); };
} IT;
void pdfs(int u, int p) {
par[0][u] = p;
sta[u] = ++Time;
for (auto v : a[u]) {
if (v != p) {
depth[v] = depth[u] + 1;
pdfs(v, u);
}
}
en[u] = Time;
}
void dfsCen(int u, int p) {
child[u] = 1;
for (auto v : a[u]) {
if (v != p && !done[v]) {
dfsCen(v, u);
child[u] += child[v];
}
}
}
int lca(int p, int q) {
if (depth[p] < depth[q]) swap(p, q);
for (int i = (17); i >= (0); i--) {
if (depth[par[i][p]] >= depth[q]) p = par[i][p];
}
if (p == q) return p;
for (int i = (17); i >= (0); i--) {
if (par[i][p] != par[i][q]) p = par[i][p], q = par[i][q];
}
return par[0][p];
}
int jump(int p, int d) {
for (int i = (0); i <= (17); i++)
if (((d >> i) & 1)) p = par[i][p];
return p;
}
int jumpTow(int u, int d, int v) {
int p = lca(u, v);
int dx = depth[u] - depth[p] + depth[v] - depth[p];
if (d < depth[u] - depth[p])
return jump(u, d);
else
return jump(v, dx - d);
}
void makelca() {
pdfs(1, 1);
for (int i = (1); i <= (17); i++) {
for (int j = (1); j <= (n); j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
}
}
}
void prepQuery(int u, int v, int id) {
if (depth[u] < depth[v]) swap(u, v);
int p = lca(u, v);
int d = depth[u] - depth[p] + depth[v] - depth[p];
auto sep = jumpTow(u, d / 2, v);
if (v != p && sep == p) sep = jumpTow(u, d / 2 - 1, v);
query[u].push_back({id, {sta[sep], en[sep]}, {sta[sep], en[sep]}});
query[v].push_back({id, {1, sta[sep] - 1}, {en[sep] + 1, n}});
}
int findCen(int u) {
dfsCen(u, u);
int sz = child[u];
while (true) {
up:
for (auto v : a[u]) {
if (child[v] < child[u] && child[v] * 2 > sz) {
u = v;
goto up;
}
}
return u;
}
}
void dfsMod(int u, int p, int d, int type) {
for (auto v : a[u]) {
if (v == p || done[v]) continue;
dfsMod(v, u, d + 1, type);
}
if (type == 1)
IT.update(sta[u], d);
else
IT.update(sta[u], -INF);
}
void handleQuery(int u, int d) {
if (query[u].empty()) return;
for (auto cur : query[u]) {
auto& ret = ansQuery[cur.id];
ret = max(ret, IT.get(cur.seg1.first, cur.seg1.second) + d);
ret = max(ret, IT.get(cur.seg2.first, cur.seg2.second) + d);
}
}
void dfsSolve(int u, int p, int d) {
for (auto v : a[u]) {
if (v == p || done[v]) continue;
dfsSolve(v, u, d + 1);
}
handleQuery(u, d);
}
void solve(int u) {
u = findCen(u);
dfsMod(u, u, 0, 1);
handleQuery(u, 0);
for (auto v : a[u]) {
if (done[v]) continue;
dfsMod(v, u, 1, -1);
dfsSolve(v, u, 1);
dfsMod(v, u, 1, 1);
}
dfsMod(u, u, u, -1);
done[u] = true;
for (auto v : a[u]) {
if (!done[v]) solve(v);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (1); i <= (n - 1); i++) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
makelca();
IT.init(n);
int q;
cin >> q;
for (int Q = (0); Q <= (q - 1); Q++) {
int u, v;
cin >> u >> v;
prepQuery(u, v, Q);
}
solve(1);
for (int i = (0); i <= (q - 1); i++) cout << ansQuery[i] << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int e, f, g;
if (d > 2 * c || 2 * d < c) {
cout << -1 << endl;
return 0;
}
g = max(d, c);
f = max(b, 2 * d + 1);
if (f > 2 * b) {
cout << -1 << endl;
return 0;
}
e = max(a, f + 1);
if (e > 2 * a) {
cout << -1 << endl;
return 0;
}
cout << e << endl;
cout << f << endl;
cout << g << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
static const int N=100;
int main()
{
int n;
int p[N+1],m[N+1][N+1];
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>p[i-1]>>p[i];
}
for(int i=1;i<=n;i++)m[i][i]=0;
for(int l=2;l<=n;l++)
{
for(int i=1;i<=n-l+1;i++)
{
int j=i+l-1;
m[i][j]=(1<<21);
for(int k=i;k<=j-1;k++)
{
m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
}
}
}
cout<<m[1][n]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int T, n;
int ans, mx, tot, cnt;
int c[26], b[maxN + 1];
int top, now;
char s[maxN + 1];
pair<int, int> p[maxN + 1], q[maxN + 1], stk[maxN + 1];
inline void clear() {
for (int i = 0; i < 26; i++) c[i] = 0;
for (int i = 0; i <= n; i++) b[i] = 0;
mx = tot = cnt = ans = 0;
}
inline void update(int x) {
b[c[x]]--;
c[x]--;
b[c[x]]++;
}
inline int add(pair<int, int> t, bool flag) {
if (!flag) {
stk[++top] = t;
now += t.second;
return 0;
}
pair<int, int> s = stk[top--];
update(s.first);
update(t.first);
while (!b[mx] && mx) mx--;
tot -= 2;
printf("%d %d\n", now + 1, now + t.second);
ans -= t.second;
now -= s.second;
return s.second;
}
inline void work() {
clear();
scanf("%s", s + 1);
ans = n = strlen(s + 1);
int last = 0;
for (int i = 1; i < n; i++)
if (s[i] == s[i + 1]) {
p[++cnt] = make_pair(s[i] - 'a', i - last);
c[s[i] - 'a']++;
last = i;
}
for (int i = 0; i < 26; i++) mx = max(mx, c[i]), tot += c[i], b[c[i]]++;
printf("%d\n", max((tot + 1) / 2, mx) + 1);
top = now = 0;
for (int i = 1; i <= cnt; i++) {
int tk = add(p[i], top && stk[top].first != p[i].first && 2 * mx < tot);
if (i < cnt) p[i + 1].second += tk;
}
for (int i = 1; i <= top; i++) q[i] = stk[i];
int id = -1, t = top;
for (int i = 0; i < 26; i++)
if (mx == c[i]) id = i;
top = now = 0;
for (int i = 1; i <= t; i++) {
int tk = add(q[i], top && ((stk[top].first == id) ^ (q[i].first == id)));
if (i < t) q[i + 1].second += tk;
}
for (int i = 1; i <= top; i++)
printf("1 %d\n", stk[i].second), ans -= stk[i].second;
if (ans) printf("1 %d\n", ans);
}
int main() {
scanf("%d", &T);
while (T--) work();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int maxnum = a[0];
for (i = 1; i < n; i++) {
if (a[i] > maxnum) maxnum = a[i];
}
int maxlen = 1;
int len = 1;
for (i = 0; i < n; i++) {
if (a[i] == maxnum) {
int j;
for (j = i + 1; j < n; j++) {
if (a[j] == maxnum) {
len++;
a[j] = -1;
} else
break;
}
if (len > maxlen) maxlen = len;
len = 1;
}
}
cout << maxlen << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isLeapYear(int year) {
return ((year % 400 == 0 || year % 100 != 0) && year % 4 == 0);
}
int main() {
int n, days = 1, ourYearDay = 0, max = 1000000;
cin >> n;
bool isLeap = isLeapYear(n), ready = false;
for (int year = 0; year <= max; year++) {
if (year == n) {
ourYearDay = days;
ready = true;
} else {
if (ready && (ourYearDay == days) && (isLeapYear(year) == isLeap)) {
cout << year << endl;
return 0;
}
}
if (isLeapYear(year)) {
days += 2;
} else {
days++;
}
days %= 7;
}
}
| 2 |
#include <bits/stdc++.h>
long long m[200000], t[200000], ans, n;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; ++i) scanf("%I64d", &m[i]), t[i] = m[i] + 1;
for (int i = 2; i <= n; ++i)
if (t[i] < t[i - 1]) t[i] = t[i - 1];
for (int i = n; i >= 2; --i)
if (t[i - 1] < t[i] - 1) t[i - 1] = t[i] - 1;
for (int i = 1; i <= n; ++i) ans += t[i] - 1 - m[i];
printf("%I64d", ans);
return 0;
}
| 3 |
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int main(){
int x; cin>>x;
int ret=sqrt(2*x);
while(ret*(ret+1)/2<x) ret++;
cout<<ret<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define MOD 1000000007
#define LLI long long int
using namespace std;
int N;
LLI dp[22][1<<21] = {};
int a[21][21] = {};
int main() {
int i,j;
int N;
cin >> N;
for( i=0; i<N; i++) {
for( j=0; j<N; j++) {
cin >> a[i][j];
}
}
dp[0][0] = 1;
for( i=0; i<N; i++) {
for( j=0; j < N; j++) {
if( !a[i][j])
continue;
for( int k=0; k<(1<<N); k++) {
if( k&(1<<j) ) {
dp[i+1][k] += dp[i][k^(1<<j)];
dp[i+1][k] %= MOD;
}
}
}
}
LLI ans = dp[N][(1<<N)-1];
printf("%lld\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
double sq(double a) { return a * a; }
struct pos {
double y, x;
double sqdis(const pos& b) const { return sq(x - b.x) + sq(y - b.y); }
double dis(const pos& b) const { return sqrt(sqdis(b)); }
double cj(const pos& b) const { return x * b.y - y * b.x; }
};
pos p, ps[100000];
int main() {
int n;
double ty, tx, tmp, mx = 0, mi = 5e12;
double dis[3];
int i;
scanf("%d", &n);
scanf("%lf%lf", &p.x, &p.y);
for (i = 0; i < n; i++) {
scanf("%lf%lf", &tx, &ty);
ps[i].y = ty - p.y;
ps[i].x = tx - p.x;
}
for (i = 0; i < n; i++) {
tmp = sq(ps[i].y) + sq(ps[i].x);
if (tmp > mx) mx = tmp;
}
for (i = 0; i < n; i++) {
dis[0] = ps[i].sqdis(ps[(i + 1) % n]);
dis[1] = ps[i].sqdis((pos){0, 0});
dis[2] = ps[(i + 1) % n].sqdis((pos){0, 0});
if (dis[0] + dis[1] < dis[2] || dis[0] + dis[2] < dis[1])
tmp = min(dis[1], dis[2]);
else
tmp = sq(ps[i].cj(ps[(i + 1) % n]) / ps[i].dis(ps[(i + 1) % n]));
if (tmp < mi) mi = tmp;
}
printf("%.18lf\n", acos(-1) * (mx - mi));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 6;
long long int binpower(long long int a, long long int b, long long int m) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b = b >> 1;
}
return res;
}
void solve() {
int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
vector<int> arr(n);
for (auto& i : arr) cin >> i;
long long int sum = 0;
sort(arr.begin(), arr.end());
k++;
for (int i = 0; i < n - 1; i++) {
if (k == 0) break;
int nextval = arr[i + 1];
long long int poss = (binpower(10LL, nextval, 1e18) - sum - 1) /
binpower(10LL, arr[i], 1e18);
poss = min(k, poss);
k -= poss;
sum += poss * (binpower(10, arr[i], 1e18));
}
if (k > 0) {
sum += k * (binpower(10, arr[n - 1], 1e18));
}
cout << sum << endl;
}
}
int32_t main(int argc, char* argv[]) { solve(); }
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int ma;
int a[111], b[111], v[111][111];
int main() {
scanf("%d%d", &n, &m);
ma = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &v[i][j]);
ma = max(ma, v[i][j]);
}
a[i] = v[i][0];
}
k = 2000000000;
b[0] = 0;
for (int j = 1; j < m; j++) b[j] = v[0][j] - v[0][j - 1];
for (int i = 0; i < n; i++)
for (int j = 1; j < m; j++) {
int x = v[i][j] - v[i][j - 1];
if (x != b[j]) {
if (b[j] < 0 && x > 0) k = x - b[j];
if (b[j] > 0 && x < 0) k = b[j] - x;
}
}
if (k <= ma || k <= 0)
printf("NO\n");
else {
bool chk = true;
for (int i = 0; i < m; i++) {
b[i] %= k;
if (b[i] < 0) b[i] += k;
}
for (int i = 0; i < n && chk; i++)
for (int j = 1; j < m && chk; j++)
if (v[i][j] != (1LL * v[i][j - 1] + b[j]) % k) chk = false;
if (chk == false)
printf("NO\n");
else {
printf("YES\n%d\n", k);
for (int i = 0; i < n; i++) printf("%d%c", a[i], i < n - 1 ? ' ' : '\n');
for (int i = 0; i < m; i++) {
if (i) b[i] = (1LL * b[i] + b[i - 1]) % k;
printf("%d%c", b[i], i < m - 1 ? ' ' : '\n');
}
}
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int n,r,b;
char x;
int main()
{
cin>>n;
for (int i=1;i<=n;++i) cin>>x,(x=='R'?r++:b++);
cout<<(r>b?"Yes\n":"No\n");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, d;
cin >> n >> d >> m;
long long int a[n];
vector<long long int> r, l;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > m)
r.push_back(a[i]);
else
l.push_back(a[i]);
}
sort(r.rbegin(), r.rend());
sort(l.rbegin(), l.rend());
long long int nl = l.size(), nr = r.size();
vector<long long int> sr(n + 1), sl(n + 1);
for (int i = 0; i < nl; i++) sl[i + 1] = sl[i] + l[i];
for (int i = 0; i < nr; i++) sr[i + 1] = sr[i] + r[i];
long long int ans = 0;
for (int i = 0; i <= nl; i++) {
int x = n - i;
int id = min(nr, (x + d) / (d + 1));
ans = max(ans, sr[id] + sl[i]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include<iostream>
#include<cstdio>
using namespace std;
#define MAX 450
inline int read()
{
int x=0;bool t=false;char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=true,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return t?-x:x;
}
int n,H,f[MAX],In[MAX],Ot[MAX];bool vis[MAX];
int getf(int x){return x==f[x]?x:f[x]=getf(f[x]);}
int main()
{
n=read();H=read();
for(int i=1;i<=H+H;++i)f[i]=i,vis[i]=false;
for(int i=1;i<=n;++i)
{
int a=read(),b=read(),c=read(),d=read();
int l=(c>0?c:-a)+H,r=(d>0?-d:b)+H;
if(getf(l)!=getf(r))f[getf(l)]=getf(r);
In[r]+=1;Ot[l]+=1;
}
for(int i=-H;i<0;++i)if(In[i+H]>Ot[i+H]){puts("NO");return 0;}
for(int i=1;i<=H;++i)if(In[i+H]<Ot[i+H]){puts("NO");return 0;}
for(int i=0;i<=H+H;++i)if(In[i]!=Ot[i])vis[getf(i)]=true;
for(int i=0;i<=H+H;++i)if(In[i]&&Ot[i]&&!vis[getf(i)]){puts("NO");return 0;}
puts("YES");
return 0;
}
| 0 |
#include<stdio.h>
int main()
{
int a,b;
scanf("%d %d",&a,&b);
if(a+b==15)printf("+");
else if(a*b==15)printf("*");
else printf("x");
printf("\n");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const long long int N = 1e5 + 5;
long long int n, m, ans = 0;
long long int dp[N], deg[N];
vector<long long int> graph[N];
void solve() {
cin >> n >> m;
for (int i = (1); i <= (m); ++i) {
long long int u, v;
cin >> u >> v;
deg[u]++, deg[v]++;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = (1); i <= (n); ++i) dp[i] = 1;
for (int i = (1); i <= (n); ++i) {
for (long long int v : graph[i]) {
if (v < i) continue;
dp[v] = max(dp[v], dp[i] + 1);
}
ans = max(ans, dp[i] * deg[i]);
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
while (t--) solve();
}
| 2 |
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#define REP(i,k,n) for(int i=k;i<n;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1<<30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
vector<string> split(const string &str, char delim) {
vector<string> res;
size_t current = 0, found;
while((found = str.find_first_of(delim, current)) != string::npos) {
res.push_back(string(str, current, found - current));
current = found + 1;
}
res.push_back(string(str, current, str.size() - current));
return res;
}
string func(string a,string b) {
string ret;
if(a.size() < b.size()) swap(a,b);
reverse(a.begin(),a.end());
reverse(b.begin(),b.end());
int carry = 0;
rep(i,b.size()) {
int x = a[i] - '0';
int y = b[i] - '0';
int z = x + y + carry;
carry = z / 10;
ret.push_back('0' + (z%10));
}
REP(i,b.size(),a.size()) {
int x = a[i] - '0';
int z = x + carry;
carry = z / 10;
ret.push_back('0' + (z%10));
}
if(carry) ret.push_back('0' + carry);
reverse(ret.begin(),ret.end());
return ret;
}
int main() {
string s;
while(cin >> s) {
vector<string> t = split(s,'+');
vector<string> v = split(t[1], '=');
string a = t[0], b = v[0] , c = v[1];
bool flag = true;
rep(i,10) {
string A = a, B = b, C = c;
rep(j,a.size()) {
if(i == 0 && j == 0 && a.size() >= 2) continue;
if(a[j] == 'X') A[j] = '0' + i;
}
rep(j,b.size()) {
if(i == 0 && j == 0 && b.size() >= 2) continue;
if(b[j] == 'X') B[j] = '0' + i;
}
rep(j,C.size()) {
if(i == 0 && j == 0 && c.size() >= 2) continue;
if(c[j] == 'X') C[j] = '0' + i;
}
bool ch = true;
rep(j,A.size()) if(A[j] == 'X') ch = false;
rep(j,B.size()) if(B[j] == 'X') ch = false;
rep(j,C.size()) if(C[j] == 'X') ch = false;
// cout << "i:" << i << endl;
// cout << A << endl;
// cout << B << endl;
// cout << C << endl;
if(ch && func(A,B) == C) {
cout << i << endl;
flag = false;
}
}
if(flag) cout << "NA" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, t, a[33][33], p[33], i, j, ans, x, use;
long long q[1 << 22];
char c[210000];
int main() {
scanf("%d%d%d%s", &n, &k, &t, c + 1);
for (i = 0; i <= k; ++i)
for (j = 1; j <= k; ++j) scanf("%d", &a[i][j]);
memset(p, -1, sizeof(p));
for (i = 1; i <= n; ++i) {
x = c[i] - 64;
for (j = 1; j <= k; ++j) {
if (p[j] >= 0) {
q[p[j]] += a[j][x];
q[p[j] | (1 << j - 1)] -= a[j][x];
q[p[j] | (1 << x - 1)] -= a[j][x];
q[p[j] | (1 << j - 1) | (1 << x - 1)] += a[j][x];
}
p[j] |= 1 << x - 1;
}
p[x] = 0;
use |= 1 << x - 1;
}
for (i = 0; i < k; ++i) q[1 << i] += a[0][i + 1];
for (i = 0; i < k; ++i)
for (j = 0; j < 1 << k; ++j)
if (j >> i & 1) q[j] += q[j ^ 1 << i];
for (i = 0; i < 1 << k; ++i)
if ((i & use) == i && q[i] <= t && i != use) ans++;
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int i = 0, j = 0;
while (b != d && i <= 100 && j <= 100) {
if (b > d) {
d += c;
j++;
} else {
b += a;
i++;
}
}
if (i <= 100 && j <= 100)
cout << d << endl;
else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int x[2000], y[2000], p[2000];
while (cin >> n) {
int i, j;
for (i = 0; i <= n; i++) cin >> x[i] >> y[i];
int cnt = 0, sum = 0;
x[n + 1] = x[1];
y[n + 1] = y[1];
for (i = 1; i <= n; i++)
if ((x[i] - x[i - 1]) * (y[i + 1] - y[i]) >
(y[i] - y[i - 1]) * (x[i + 1] - x[i]))
cnt++;
else
cnt--;
for (i = 1; i <= n; i++)
if ((x[i] - x[i - 1]) * (y[i + 1] - y[i]) >
(y[i] - y[i - 1]) * (x[i + 1] - x[i]))
sum++;
cout << sum << endl;
}
return 0;
}
| 4 |
#include<stdio.h>
int main(){
double r;
double PI=3.141592653589;
scanf("%lf",&r);
printf("%f %f",r*r*PI,r*2*PI);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 1e5 + 5;
long long n, d, b;
long long a[N];
long long answer(long long Q) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
v[i / (d + 1)] += a[i];
}
long long ans = 0;
long long bal = 0;
for (long long i = 0; i < n; i++) {
bal += v[i];
if (bal < b)
ans++;
else
bal -= b;
}
return ans;
}
void solve() {
cin >> n >> d >> b;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long x = answer((n + 1) / 2);
reverse(a, a + n);
amax(x, answer(n / 2));
cout << x;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(5e4) + 100;
const int MOD = int(360);
const int oo = INT_MAX;
const long double PI = acos(-1.0);
const long double EPS = 1e-9;
struct pt {
long double x, y;
pt() {}
pt(long double x, long double y) : x(x), y(y) {}
};
inline long double x(pt P) { return P.x; }
inline long double y(pt P) { return P.y; }
istream& operator>>(istream& in, pt& p) {
long double x, y;
in >> x >> y;
p = pt(x, y);
return in;
}
ostream& operator<<(ostream& out, const pt& p) {
out << "(" << double(p.x) << ", " << double(p.y) << ")";
return out;
}
pt operator+(const pt& A, const pt& B) { return pt(x(A) + x(B), y(A) + y(B)); }
pt operator-(const pt& A, const pt& B) { return pt(x(A) - x(B), y(A) - y(B)); }
pt operator*(const pt& A, const pt& B) {
return pt(x(A) * x(B) - y(A) * y(B), x(A) * y(B) + y(A) * x(B));
}
pt operator*(const pt& A, const long double& B) {
return pt(x(A) * B, y(A) * B);
}
pt operator*(const long double& B, const pt& A) {
return pt(x(A) * B, y(A) * B);
}
pt operator/(const pt& A, const long double& B) {
return pt(x(A) / B, y(A) / B);
}
inline long double norm(pt A) { return x(A) * x(A) + y(A) * y(A); }
inline long double abs(pt A) { return sqrt(norm(A)); }
inline long double cross(pt A, pt B) { return x(A) * y(B) - y(A) * x(B); }
inline long double dot(pt A, pt B) { return x(A) * x(B) + y(A) * y(B); }
inline bool same(long double a, long double b) {
return a + EPS > b && b + EPS > a;
}
inline bool samePt(pt A, pt B) { return same(x(A), x(B)) && same(y(A), y(B)); }
inline long double dist(pt A, pt B) { return abs(B - A); }
inline pt rotcw(pt p) { return p * pt(0, -1); }
inline bool segContains(pt X, pt A, pt B) {
if (samePt(X, A) || samePt(X, B)) return 1;
if (!same(0, cross(A - X, B - X))) return 0;
return (dot(A - X, B - X) < EPS);
}
pt linesIntersection(pt A, pt B, pt C, pt D) {
long double x = cross(C, D - C) - cross(A, D - C);
x /= cross(B - A, D - C);
return A + x * (B - A);
}
double signedArea(const vector<pt>& P) {
double result = 0.0;
for (int i = 0; i < (int)P.size() - 1; i++) result += cross(P[i], P[i + 1]);
return result / 2.0;
}
vector<pt> reorganize(vector<pt>& P) {
int n = int(P.size());
vector<pt> R(n);
if (P.size() == 1) {
R[0] = P[0];
return R;
}
if (signedArea(P) > EPS) {
reverse(P.begin(), P.end());
}
int s = 0;
for (int i = 1; i < n; ++i) {
if (x(P[s]) > x(P[i]) || (x(P[s]) == x(P[i]) && y(P[s]) > y(P[i]))) {
s = i;
}
}
R[0] = P[s];
for (int i = (s + 1) % n, j = 1; i != s; i = (i + 1) % n, ++j) {
if (samePt(P[i], P[(i - 1 + n) % n])) {
j--;
continue;
}
R[j] = P[i];
}
R[n - 1] = R[0];
return R;
}
vector<pt> convexPolygonSum(vector<pt>& P, vector<pt>& Q) {
P = reorganize(P);
Q = reorganize(Q);
int n = int(P.size()), m = int(Q.size());
vector<pt> R(n + m - 1);
R[0] = (P[0] + Q[0]);
int i = 1, j = 1, k = 1;
for (; i < n && j < m; ++k) {
if (cross(P[i] - P[i - 1], Q[j] - Q[j - 1]) < -EPS) {
R[k] = R[k - 1] + (P[i] - P[i - 1]);
++i;
} else {
R[k] = R[k - 1] + (Q[j] - Q[j - 1]);
++j;
}
}
while (i < n) {
R[k] = R[k - 1] + (P[i] - P[i - 1]);
++i;
++k;
}
while (j < m) {
R[k] = R[k - 1] + (Q[j] - Q[j - 1]);
++j;
++k;
}
vector<pt> T;
T.push_back(R[0]);
for (int i = 1; i + 1 < int(R.size()); ++i) {
if (same(cross(R[i] - R[i - 1], R[i + 1] - R[i - 1]), 0.0)) continue;
T.push_back(R[i]);
}
T.push_back(T[0]);
return T;
}
int inConvexPolygon(pt X, long double mnx, long double mxx, vector<pt>& P) {
if (x(X) < mnx || x(X) > mxx) return -1;
int lo = 1, hi = int(P.size()) - 1, mi;
while (lo <= hi) {
mi = (lo + hi) / 2;
if (cross(P[mi] - P[0], X - P[0]) < -EPS) {
lo = mi + 1;
} else {
hi = mi - 1;
}
}
lo = hi;
if (hi == -1) return -1;
long double c = cross(X - P[lo], X - P[lo + 1]);
if (same(c, 0.0)) return (segContains(X, P[lo], P[lo + 1]) ? 0 : -1);
if (c > EPS) return -1;
return 1;
}
int l, n, m, q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
while (cin >> l) {
vector<pt> P1(l + 1);
for (int i = 0; i < l; ++i) {
cin >> P1[i];
}
cin >> n;
vector<pt> P2(n + 1);
for (int i = 0; i < n; ++i) {
cin >> P2[i];
}
cin >> m;
vector<pt> P3(m + 1);
for (int i = 0; i < m; ++i) {
cin >> P3[i];
}
P1[l] = P1[0];
P2[n] = P2[0];
P3[m] = P3[0];
vector<pt> P = convexPolygonSum(P2, P3);
P = convexPolygonSum(P1, P);
long double mnx = x(P[0]);
long double mxx = -oo;
for (int i = 0; i < int(P.size()); ++i) {
mxx = max(mxx, x(P[i]));
}
cin >> q;
for (int i = 0; i < q; ++i) {
pt cur;
cin >> cur;
cur = 3.0 * cur;
if (inConvexPolygon(cur, mnx, mxx, P) >= 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 20, p = 37, mod = 1e9 + 143;
long long N, M, K, seg[4 * maxn], lazy[4 * maxn], pw[maxn], pre[maxn];
char ar[maxn];
long long build(long long k, long long b, long long s) {
if (s == b) return seg[k] = ar[s];
long long m = (s + b) >> 1;
long long l = build(2 * k, b, m), r = build(2 * k + 1, m + 1, s);
return seg[k] = (l + (r * pw[m - b + 1]) % mod) % mod;
}
void push(long long k, long long b, long long s) {
if (lazy[k] != -1) {
long long m = (s + b) >> 1;
lazy[2 * k] = lazy[k];
lazy[2 * k + 1] = lazy[k];
seg[2 * k] = (pre[m - b] * lazy[k]) % mod;
seg[2 * k + 1] = (pre[s - m - 1] * lazy[k]) % mod;
lazy[k] = -1;
}
}
long long upd(long long k, long long b, long long s, long long x, long long y,
long long z) {
if (s < x || b > y || y < x) return seg[k];
if (x <= b && s <= y) {
lazy[k] = z;
return seg[k] = (pre[s - b] * z) % mod;
}
long long m = (s + b) >> 1;
push(k, b, s);
long long l = upd(2 * k, b, m, x, y, z);
long long r = upd(2 * k + 1, m + 1, s, x, y, z);
return seg[k] = (l + (r * pw[m - b + 1]) % mod) % mod;
}
long long find(long long k, long long b, long long s, long long x,
long long y) {
if (s < x || b > y || y < x) return 0;
if (x <= b && s <= y) {
return (seg[k] * pw[b - x]) % mod;
}
long long m = (s + b) >> 1;
push(k, b, s);
long long l = find(2 * k, b, m, x, y), r = find(2 * k + 1, m + 1, s, x, y);
return (l + r) % mod;
}
int main() {
memset(lazy, -1, sizeof lazy);
scanf("%lld %lld %lld", &N, &M, &K);
pw[0] = pre[0] = 1;
for (long long i = 1; i <= N; i++)
scanf(" %c", &ar[i]), ar[i] -= '0', pw[i] = (pw[i - 1] * p) % mod,
pre[i] = (pre[i - 1] + pw[i]) % mod;
build(1, 1, N);
for (long long i = 1; i <= M + K; i++) {
long long komut, a, b, c;
scanf("%lld %lld %lld %lld", &komut, &a, &b, &c);
if (komut == 1)
upd(1, 1, N, a, b, c);
else {
if (find(1, 1, N, a, b - c) == find(1, 1, N, a + c, b))
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
int x[N][2];
int ans[N];
bool hear[N];
vector<pair<int, int> > G[N];
int color[N];
void dfs1(int s) {
color[s] = 1;
for (int i = 0; i < (int)G[s].size(); i++) {
int v = G[s][i].first;
if (color[v] == 0) {
if (G[s][i].second > 0) {
ans[G[s][i].second] = 1;
} else {
ans[-G[s][i].second] = 0;
}
dfs1(v);
}
}
color[s] = 2;
}
pair<int, int> cyc;
void dfs2(int s, int per = -1) {
color[s] = 1;
for (int i = 0; i < (int)G[s].size(); i++) {
int v = G[s][i].first;
if (color[v] == 0) {
dfs2(v, abs(G[s][i].second));
}
if ((color[v] == 1) && (per != abs(G[s][i].second))) {
cyc.first = s;
cyc.second = i;
}
}
color[s] = 2;
}
int color1[N];
void dfs3(int s, int per) {
color1[s] = 1;
for (int i = 0; i < (int)G[s].size(); i++) {
int v = G[s][i].first;
if (abs(G[s][i].second) == per) {
continue;
}
if (color1[v] == 0) {
ans[abs(G[s][i].second)] = (G[s][i].second > 0 ? 1 : 0);
dfs3(v, abs(G[s][i].second));
}
}
color1[s] = 2;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int r;
scanf("%d", &r);
if (x[abs(r)][0] == 0) {
x[abs(r)][0] = i * (r > 0 ? 1 : -1);
} else {
x[abs(r)][1] = i * (r > 0 ? 1 : -1);
}
}
}
for (int i = 1; i <= m; i++) {
if ((x[i][0] >= 0) && (x[i][1] >= 0)) {
ans[i] = 1;
hear[x[i][0]] = 1;
hear[x[i][1]] = 1;
} else if ((x[i][0] <= 0) && (x[i][1] <= 0)) {
ans[i] = 0;
hear[-x[i][0]] = 1;
hear[-x[i][1]] = 1;
} else {
int v1 = abs(x[i][0]);
int v2 = abs(x[i][1]);
G[v1].push_back(make_pair(v2, i * (x[i][1] > 0 ? 1 : -1)));
G[v2].push_back(make_pair(v1, i * (x[i][0] > 0 ? 1 : -1)));
}
}
for (int i = 1; i <= n; i++) {
if ((hear[i] == 1) && (color[i] == 0)) {
dfs1(i);
}
}
for (int i = 1; i <= n; i++) {
if (color[i] == 0) {
cyc.first = 0;
dfs2(i);
if (cyc.first == 0) {
cout << "NO" << endl;
return 0;
} else {
int s = cyc.first;
int j = cyc.second;
ans[abs(G[s][j].second)] = (G[s][j].second > 0 ? 1 : 0);
dfs3(G[s][j].first, abs(G[s][j].second));
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= m; i++) {
cout << ans[i];
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s[6] == '0')
cout << 0;
else if (s[6] == '2')
cout << 0;
else if (s[6] == '4')
cout << 0;
else if (s[6] == '6')
cout << 0;
else if (s[6] == '8')
cout << 0;
else
cout << 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int t, id, n, m, x, y, k, c, p, dif, ans, sum, pre, rem, cur, tmp, tot, r, l, u,
d, xx, yy;
int a[N], vis[N], f[N], b[N], cu[N];
vector<int> v, adj[N];
bool fl, ok;
int dp[N];
int mem[N];
int sol(int i = n) {
int &ret = mem[i];
if (~ret) return ret;
if (!i) return ret = 0;
ret = sol(i - 1) + 20;
int B90 = upper_bound(a + 1, a + n + 1, a[i] - 90) - (a + 1);
ret = min(ret, sol(B90) + 50);
int Bday = upper_bound(a + 1, a + n + 1, a[i] - 1440) - (a + 1);
ret = min(ret, sol(Bday) + 120);
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= (int)n; ++i) scanf("%d", &a[i]);
memset(mem, -1, sizeof mem);
;
sol();
for (int i = 1; i <= (int)n; ++i) printf("%d\n", mem[i] - mem[i - 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const MOD = 1e9 + 7;
int const N = 31;
int dp[N][2][2][2], dc[N][2][2][2];
int sum(int a, int b) { return (a + b) % MOD; }
void add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int mul(int a, int b) { return a * 1LL * b % MOD; }
void sub(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
void clear() {
for (int i = 0; i < N; ++i)
for (int a = 0; a < 2; ++a)
for (int b = 0; b < 2; ++b)
for (int c = 0; c < 2; ++c) dp[i][a][b][c] = dc[i][a][b][c] = 0;
}
bool bit(int mask, int id) { return ((1 << id) & mask); }
int calc(int x, int y, int k) {
if (x < 0 || y < 0) return 0;
clear();
int ret = 0;
dc[N - 1][0][0][0] = 1;
vector<int> vx, vy, vk;
for (int i = 0; i < N; ++i) {
vx.push_back(bit(x, i));
vy.push_back(bit(y, i));
vk.push_back(bit(k, i));
}
for (int i = N - 1; i >= 0; --i) {
for (int fx = 0; fx < 2; ++fx)
for (int fy = 0; fy < 2; ++fy)
for (int fk = 0; fk < 2; ++fk)
for (int cx = 0; cx < 2; ++cx)
for (int cy = 0; cy < 2; ++cy) {
if (!dc[i][fx][fy][fk] && !dp[i][fx][fy][fk]) continue;
if (fx == 0 && cx > vx[i]) continue;
if (fy == 0 && cy > vy[i]) continue;
int ck = (cx ^ cy);
if (fk == 0 && ck > vk[i]) continue;
int nfx = max(fx, (cx < vx[i] ? 1 : 0));
int nfy = max(fy, (cy < vy[i] ? 1 : 0));
int nfk = max(fk, (ck < vk[i] ? 1 : 0));
if (i > 0) {
add(dc[i - 1][nfx][nfy][nfk], dc[i][fx][fy][fk]);
int add1 = dp[i][fx][fy][fk];
int add2 = mul((1 << i), mul(dc[i][fx][fy][fk], ck));
int addv = sum(add1, add2);
add(dp[i - 1][nfx][nfy][nfk], addv);
} else {
if (fk == 0 && vk[i] == ck) continue;
add(ret, dc[i][fx][fy][fk]);
int add1 = dp[i][fx][fy][fk];
int add2 = mul((1 << i), mul(dc[i][fx][fy][fk], ck));
int addv = sum(add1, add2);
add(ret, addv);
}
}
}
return ret;
}
void solve() {
int x1, y1, x2, y2, k;
cin >> x1 >> y1 >> x2 >> y2 >> k;
int ans = 0;
--x1;
--y1;
--x2;
--y2;
add(ans, calc(x2, y2, k));
sub(ans, calc(x1 - 1, y2, k));
sub(ans, calc(x2, y1 - 1, k));
add(ans, calc(x1 - 1, y1 - 1, k));
cout << ans << endl;
}
int main() {
int test;
cin >> test;
while (test--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int M, N;
int A[26];
int main() {
scanf("%d", &M);
for (int i = 0; i < M; i++) scanf("%d", A + i), N += A[i];
for (int i = N; i >= 1; i--) {
int good = 1;
for (int j = 0; j < M; j++) good &= (A[j] % i == 0);
if (good) {
int odd = 0;
for (int j = 0; j < M; j++) odd += (A[j] / i) % 2;
if (odd <= 1) {
for (int j = 0; j < M; j++) A[j] /= i;
string base;
for (int j = 0; j < M; j++)
if (A[j] % 2 == 0)
for (int k = 0; k < A[j] / 2; k++) base += 'a' + j;
for (int j = 0; j < M; j++)
if (A[j] % 2 == 1)
for (int k = 0; k < A[j]; k++) base += 'a' + j;
for (int j = M - 1; j >= 0; j--)
if (A[j] % 2 == 0)
for (int k = 0; k < A[j] / 2; k++) base += 'a' + j;
int ans = i;
if (odd == 0) ans *= 2;
printf("%d\n", ans);
for (int j = 0; j < i; j++) printf("%s", base.c_str());
printf("\n");
return 0;
}
}
}
printf("0\n");
for (int i = 0; i < M; i++)
for (int j = 0; j < A[i]; j++) printf("%c", i + 'a');
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
long long int power(T a, T b) {
long long int pow = 1;
for (int i = 0; i < b; i++) {
pow *= a;
}
return pow;
}
int a[100005] = {0};
int main() {
int a;
cin >> a;
string s;
cin >> s;
int p = 0, m = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+')
m++;
else
m--;
if (m < 0) m = 0;
}
if (m < 0) m = 0;
cout << m << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " , ";
__f(comma + 1, args...);
}
inline long long int gcd(long long int a, long long int b) {
a = abs(a), b = abs(b);
while (b) a = a % b, swap(a, b);
return a;
}
inline long long int power(long long int a, long long int p) {
long long int res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x), p >>= 1;
}
return res;
}
inline long long int mul_mod(long long int a, long long int p,
long long int m) {
long long int res = 0, x = a % m;
while (p) {
if (p & 1) res = (res + x) % m;
x = (x << 1) % m, p >>= 1;
}
return res;
}
inline long long int big_mod(long long int a, long long int p,
long long int m) {
long long int res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m, p >>= 1;
}
return res;
}
long long int ext_gcd(long long int A, long long int B, long long int* X,
long long int* Y) {
long long int x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1, y2 = 0;
x1 = 0, y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1, r = r2 % r1;
x = x2 - (q * x1), y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long int mod_inv(long long int a, long long int m) {
long long int x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
const int INF = 1e9 + 9;
int n;
int grid[109][109];
int ans[109];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &grid[i][j]);
if (i != j) {
ans[i] |= grid[i][j];
}
}
}
for (int i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int main() {
int S;
cin >> S;
cout << S/3600 << ":" << S/60%60 << ":" << S%60 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k = 1;
cin >> n;
unordered_map<string, long long> map;
map["polycarp"] = 0;
vector<long long> v;
v.push_back(1);
for (long long i = 0; i < n; i++) {
string name1, s, name2;
cin >> name1 >> s >> name2;
transform(name1.begin(), name1.end(), name1.begin(), ::tolower);
transform(name2.begin(), name2.end(), name2.begin(), ::tolower);
v.push_back(1 + v[map[name2]]);
map[name1] = k++;
}
long long ans = 0;
for (long long i = 0; i < v.size(); i++) ans = max(ans, v[i]);
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
bool ispalindrome(string s) {
long long int len = s.length();
for (long long int i = 0; i < len; i++) {
if (s[i] != s[len - i - 1]) return false;
}
return true;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = ((res) * (a));
a = ((a) * (a));
b >>= 1;
}
return res;
}
long long is_prime(long long n) {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int i = 0;
for (i = 0; i < n; i++) {
if (s[i] != '.') break;
}
int j = i;
while (s[j] != '.') {
j++;
}
j--;
int r = 0, l = 0;
for (int k = i; k <= j; k++) {
if (s[k] == 'R')
r++;
else if (s[k] == 'L')
l++;
}
if (r == j - i + 1)
cout << i + 1 << " " << j + 2;
else if (l == j - i + 1)
cout << j + 1 << " " << i;
else {
int m = i;
if (s[m] == 'R') {
while (s[m] == 'R') m++;
cout << i + 1 << " " << m;
} else if (s[m] == 'L') {
while (s[m] == 'L') m++;
cout << m << " " << i + 1;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool isLeap(T y) {
return (y % 400 == 0) || (y % 100 ? y % 4 == 0 : false);
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int Prime[100005], PrIndx, PrTaken[100005], trace[100005];
void sieve(int n) {
double z = sqrt(n);
for (int i = 3; i <= z; i += 2) {
for (long long j = i * i; j <= n; j += i + i) PrTaken[j] = 1;
}
Prime[PrIndx++] = 2;
for (int i = 3; i <= n; i += 2)
if (!PrTaken[i]) Prime[PrIndx++] = i;
}
int arr[200];
vector<int> v[100005];
vector<pair<int, int> > v2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
sieve(1005);
string s;
cin >> s;
vector<int> vg;
for (int i = 0; i < PrIndx; i++) {
if (s.length() / Prime[i] > 1) vg.push_back(Prime[i]);
}
for (int i = 0; i < vg.size(); i++) {
int x = vg[i];
for (int j = 1; j <= (s.length() / x); j++) {
trace[j * x] = 1;
}
}
for (int i = 0; i < s.length(); i++) {
arr[s[i]]++;
}
int maxi = 0, save;
for (int i = 0; i < s.length(); i++) {
if (maxi < arr[s[i]]) {
maxi = arr[s[i]];
save = i;
}
}
int flag = 0;
vector<char> vv(1005);
for (int i = 1; i <= s.length(); i++) {
if (trace[i]) {
if (maxi == 0) {
flag = 1;
} else {
maxi--;
vv[i] = s[save];
}
}
}
if (flag) {
cout << "NO";
return 0;
}
vector<char> kk;
arr[s[save]] = maxi;
for (char c = 'a'; c <= 'z'; c++) {
for (int i = 0; i < arr[c]; i++) kk.push_back(c);
}
int gnt = 0;
for (int i = 1; i <= s.length(); i++) {
if (trace[i] == 0) {
vv[i] = kk[gnt++];
}
}
cout << "YES" << endl;
for (int i = 1; i <= s.length(); i++) cout << vv[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int id, val;
bool operator<(const Node& node) const { return val < node.val; }
} a[110000], b[110000];
int t1 = 0, t2 = 0;
int lst[110000], K = 0;
int main() {
int n, v, m, val;
int ret = 0;
scanf("%d%d", &n, &v);
for (int i = 0; i < n; i++) {
scanf("%d%d", &m, &val);
if (m == 1) {
a[t1].id = i + 1;
a[t1].val = val;
t1++;
} else {
b[t2].id = i + 1;
b[t2].val = val;
t2++;
}
}
sort(a, a + t1);
sort(b, b + t2);
while (v) {
if (t1 == 0 && t2 == 0) break;
if (v >= 2) {
if (t1 == 0) {
ret += b[--t2].val;
lst[K++] = b[t2].id;
v -= 2;
} else if (t2 == 0) {
ret += a[--t1].val;
lst[K++] = a[t1].id;
v--;
if (t1) {
ret += a[--t1].val;
lst[K++] = a[t1].id;
v--;
}
} else {
int va = 0, vb = 0;
if (t1 > 1)
va = a[t1 - 1].val + a[t1 - 2].val;
else
va = a[t1 - 1].val;
vb = b[t2 - 1].val;
if (va > vb) {
ret += a[--t1].val;
lst[K++] = a[t1].id;
v--;
} else {
ret += b[--t2].val;
lst[K++] = b[t2].id;
v -= 2;
}
}
} else {
if (t1) {
ret += a[--t1].val;
lst[K++] = a[t1].id;
v--;
} else {
break;
}
}
}
printf("%d\n", ret);
for (int i = 0; i < K; i++) {
if (i) putchar(' ');
printf("%d", lst[i]);
}
puts("");
return 0;
}
| 2 |
//02
#include<iostream>
#include<cmath>
using namespace std;
int main(){
for(int m;cin>>m,m;){
int mr=360;
double ms=0;
for(int i=0;i<m-1;i++){
int a;
cin>>a;
mr-=a;
ms+=sin(acos(-1)*a/180);
}
ms+=sin(acos(-1)*mr/180);
int nr=360;
double ns=0;
int n;
cin>>n;
for(int i=0;i<n-1;i++){
int a;
cin>>a;
nr-=a;
ns+=sin(acos(-1)*a/180);
}
ns+=sin(acos(-1)*nr/180);
int ans;
if(ms>ns+1e-9){
ans=1;
}else if(ms+1e-9<ns){
ans=2;
}else{
ans=0;
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
long long b[a];
for (long long i = 0; i < a; i++) {
cin >> b[i];
}
long long meow = 0;
for (long long i = a - 1; i > 0; i--) {
if (b[i] < b[i - 1]) {
meow = meow + b[i - 1] - b[i];
}
}
cout << meow;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a[7], i;
cin >> n;
for (i = 0; i < 7; i++) {
cin >> a[i];
}
while (n != 0) {
for (i = 0; i < 7; i++) {
n = n - a[i];
if (n <= 0) {
cout << i + 1;
return 0;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2100;
char c[N][N], ans[N][N];
bool chk[N][N];
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
vector<pair<int, int>> v, vec[N];
bool valid(int x, int y, int p, int q) {
return 0 <= x && x < p && 0 <= y && y < q;
}
bool check(int x, int y, int p, int q) {
int cnt = 0;
for (int i = 0; i < 4; i++) {
int ex = x + dx[i], ey = y + dy[i];
if (!valid(ex, ey, p, q)) continue;
if (c[ex][ey] == '.' && !chk[ex][ey]) cnt++;
}
if (cnt == 1)
return 1;
else
return 0;
}
void func(int x, int y, int p, int q, int id) {
if (chk[x][y]) return;
int ex, ey;
for (int i = 0; i < 4; i++) {
ex = x + dx[i], ey = y + dy[i];
if (!valid(ex, ey, p, q)) continue;
if (c[ex][ey] == '.' && !chk[ex][ey]) {
chk[x][y] = chk[ex][ey] = 1;
if (i == 0) {
ans[x][y] = '^';
ans[ex][ey] = 'v';
}
if (i == 1) {
ans[x][y] = '<';
ans[ex][ey] = '>';
}
if (i == 2) {
ans[x][y] = 'v';
ans[ex][ey] = '^';
}
if (i == 3) {
ans[x][y] = '>';
ans[ex][ey] = '<';
}
break;
}
}
for (int i = 0; i < 4; i++) {
int cx = ex + dx[i], cy = ey + dy[i];
if (!valid(cx, cy, p, q)) continue;
if (chk[cx][cy] || c[cx][cy] == '*') continue;
if (check(cx, cy, p, q)) {
vec[id + 1].push_back(make_pair(cx, cy));
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c[i][j];
ans[i][j] = c[i][j];
if (c[i][j] == '.') v.push_back(make_pair(i, j));
}
}
for (auto x : v) {
if (check(x.first, x.second, n, m)) {
vec[0].push_back(make_pair(x.first, x.second));
}
}
int fn = 0;
while (1) {
for (auto x : vec[fn]) {
func(x.first, x.second, n, m, fn);
}
if (!vec[++fn].size()) break;
}
int flag = 0;
for (auto x : v) {
if (!chk[x.first][x.second]) {
flag = 1;
break;
}
}
if (flag)
cout << "Not unique" << endl;
else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j];
}
cout << endl;
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int i, mn = INT_MAX, a, b;
long long int arr[n];
for (i = 0; i <= n - 1; i++) {
cin >> arr[i];
}
for (i = 0; i <= n - 1; i++) {
if (i == 0) {
if (abs(arr[n - 1] - arr[0]) < mn) {
mn = abs(arr[n - 1] - arr[0]);
a = n;
b = 1;
}
}
if (i >= 1) {
if (abs(arr[i] - arr[i - 1]) < mn) {
mn = abs(arr[i] - arr[i - 1]);
a = i;
b = i + 1;
}
}
}
cout << a << " " << b << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void cmax(T &x, T y) {
x < y ? x = y : x;
}
template <typename T>
inline void cmin(T &x, T y) {
y < x ? x = y : x;
}
char bf[1 << 21], *p1(bf), *p2(bf);
template <typename T>
inline void read(T &x) {
char t(
(p1 == p2 && (p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)),
flg(0);
x = 0;
for (; !isdigit(t);
t = (p1 == p2 &&
(p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
flg = t == '-';
for (; isdigit(t);
t = (p1 == p2 &&
(p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
x = x * 10 + (t & 15);
flg ? x = -x : x;
}
const int MAXN = 1e5 + 5;
int N, M, D;
bool vis[MAXN];
int hd[MAXN], nxt[MAXN << 1], to[MAXN << 1], tot;
inline void addegde(int x, int y) {
nxt[++tot] = hd[x], hd[x] = tot, to[tot] = y, nxt[++tot] = hd[y], hd[y] = tot,
to[tot] = x;
}
int w, s, A, B, d1[MAXN], d2[MAXN];
void DFS1(int u, int fa, int d) {
if (vis[u] && d > s) s = d, w = u;
for (int i(hd[u]), v(to[i]); i; v = to[i = nxt[i]])
if (v != fa) DFS1(v, u, d + 1);
}
void DFS2(int u, int fa, int *d) {
for (int i(hd[u]), v(to[i]); i; v = to[i = nxt[i]])
if (v != fa) d[v] = d[u] + 1, DFS2(v, u, d);
}
signed main() {
read(N), read(M), read(D);
int x, y;
while (M--) {
read(x), vis[x] = 1;
}
for (int i(2), I(N); i <= I; ++i) read(x), read(y), addegde(x, y);
DFS1(1, 0, 0), A = w, w = s = 0, DFS1(A, 0, 0), B = w;
DFS2(A, 0, d1), DFS2(B, 0, d2);
int ans(0);
for (int i(1), I(N); i <= I; ++i) ans += d1[i] <= D && d2[i] <= D;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) cin >> A[i];
int j = max_element(A.begin(), A.end()) - A.begin();
bool fail = false;
for (int i = 0; i < j; ++i) fail |= A[i] > A[i + 1];
for (int i = j + 1; i < n; ++i) fail |= A[i - 1] < A[i];
cout << (fail ? "no" : "yes") << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long sum[100005 << 2], col[100005 << 2], add[100005 << 2];
void build(int l, int r, int rt) {
sum[rt] = 0;
col[rt] = 0;
add[rt] = 0;
if (l == r) {
col[rt] = l;
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
}
void pushdown(int l, int r, int rt) {
if (add[rt]) {
int m = (l + r) >> 1;
add[rt << 1] += add[rt];
add[rt << 1 | 1] += add[rt];
sum[rt << 1] += (m - l + 1) * add[rt];
sum[rt << 1 | 1] += (r - m) * add[rt];
add[rt] = 0;
if (col[rt] != 0) {
col[rt << 1] = col[rt];
col[rt << 1 | 1] = col[rt];
}
}
}
void pushup(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
if (col[rt << 1] == col[rt << 1 | 1] && col[rt << 1] != 0)
col[rt] = col[rt << 1];
else
col[rt] = 0;
}
void update(int L, int R, long long val, int l, int r, int rt) {
if (L <= l && R >= r && col[rt] != 0) {
add[rt] += abs(val - col[rt]);
sum[rt] += (long long)(r - l + 1) * abs(val - col[rt]);
col[rt] = val;
return;
}
int m = (l + r) >> 1;
pushdown(l, r, rt);
if (L <= m) update(L, R, val, l, m, rt << 1);
if (R > m) update(L, R, val, m + 1, r, rt << 1 | 1);
pushup(rt);
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) {
return sum[rt];
}
int m = (l + r) >> 1;
pushdown(l, r, rt);
long long ans = 0;
if (L <= m) ans += query(L, R, l, m, rt << 1);
if (R > m) ans += query(L, R, m + 1, r, rt << 1 | 1);
return ans;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
build(1, n, 1);
long long x, y, z, a;
while (m--) {
scanf("%I64d", &a);
if (a == 1) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
update(x, y, z, 1, n, 1);
} else {
scanf("%I64d%I64d", &x, &y);
printf("%I64d\n", query(x, y, 1, n, 1));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> pq;
long long a[1002], b[1002], arr[1002];
int main() {
int n, k1, k2, k;
cin >> n >> k1 >> k2;
k = k1 + k2;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
cin >> b[i];
arr[i] = (long long)abs(a[i] - b[i]);
pq.push(arr[i]);
}
while (k > 0) {
long long curr = pq.top();
pq.pop();
pq.push(abs(curr - 1));
k--;
}
long long ans = 0;
while (!pq.empty()) {
long long curr = pq.top();
ans += (curr * curr);
pq.pop();
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long po(long long a, long long b) {
long long c = 1, d = a;
while (b) {
if (b & 1) c = 1LL * c * d % 1000000007;
d = 1LL * d * d % 1000000007;
b >>= 1;
}
return c;
}
int main() {
scanf("%d %d", &n, &m);
if (m == 1)
printf("%d\n", n + 1);
else
printf("%lld\n",
(((po(2 * m - 1, n) - po(m, n)) * po(m - 1, 1000000007 - 2) +
po(2 * m - 1, n)) %
1000000007 +
1000000007) %
1000000007);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= 1;
sum = sum + (long long int)a[i];
if (sum % 2 == 0) {
cout << 2 << endl;
} else
cout << 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> p[100005];
vector<int> ch[100005];
pair<int, int> dp[100005][18];
int d[100005];
void dfs(int cn) {
for (auto nn : ch[cn]) {
d[nn] = d[cn] + 1;
dfs(nn);
}
}
void prepro() {
for (int i = (1); i <= (signed)(n); i++) {
dp[i][0] = p[i];
}
for (int i = (1); i <= (signed)(18 - 1); i++) {
for (int j = (1); j <= (signed)(n); j++) {
dp[j][i].first = dp[dp[j][i - 1].first][i - 1].first;
dp[j][i].second =
dp[j][i - 1].second | dp[dp[j][i - 1].first][i - 1].second;
}
}
}
pair<int, pair<int, int> > lca(int a, int b) {
bool swp = false;
if (d[b] < d[a]) {
swap(a, b);
swp = true;
}
int bm1 = 0, bm2 = 0;
int dif = d[b] - d[a];
for (int i = (18 - 1); i >= 0; i--) {
if (dif >= (1 << i)) {
dif -= (1 << i);
bm2 |= dp[b][i].second;
b = dp[b][i].first;
}
}
if (a == b) {
if (swp)
return {a, {bm2, 0}};
else
return {a, {0, bm2}};
}
for (int i = (18 - 1); i >= 0; i--) {
if (dp[a][i].first != dp[b][i].first) {
bm1 |= dp[a][i].second;
bm2 |= dp[b][i].second;
a = dp[a][i].first;
b = dp[b][i].first;
}
}
bm1 |= p[a].second;
bm2 |= p[b].second;
a = p[a].first;
b = p[b].first;
if (a != b || a == 0) return {-1, {3, 3}};
if (swp)
return {a, {bm2, bm1}};
else
return {a, {bm1, bm2}};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (1); i <= (signed)(n); i++) {
cin >> p[i].first >> p[i].second;
++p[i].second;
if (p[i].first == -1) p[i].first = 0;
ch[p[i].first].push_back(i);
}
for (int i = (1); i <= (signed)(n); i++) {
if (p[i].first == 0) {
d[i] = 0;
dfs(i);
}
}
prepro();
int q;
cin >> q;
for (int _ = 0; _ < (signed)(q); _++) {
int t, u, v;
cin >> t >> u >> v;
pair<int, pair<int, int> > res = lca(u, v);
if (t == 1) {
if (u != v && res.first == u && res.second.second == 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
} else {
if (res.first != v && !(res.second.first & 2) &&
!(res.second.second & 1)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
return 0;
}
| 4 |
#include <iostream>
#include <cstring>
using namespace std;
typedef pair<int,int> P;
P t[101][101];
int loop[101][101];
int solve(int x,int y,int now){
while(loop[y][x] == 0){
loop[y][x] = now;
int nx = t[y][x].first;
int ny = t[y][x].second;
x = nx;
y = ny;
}
if(loop[y][x] == now) return 1;
return 0;
}
int main(void){
int n;
while(cin>>n && n){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>t[i][j].first>>t[i][j].second;
}
}
memset(loop,0,sizeof(loop));
int now = 1;
int ans = 0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(loop[i][j] == 0){
ans += solve(j,i,now);
now++;
}
}
}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, a, b;
cin >> n >> a >> b;
char str[n], word = 'a';
int j = 0;
for (int f = 0; f < n; f++) {
str[f] = word;
word++;
j++;
if (j == b) {
word = 'a';
j = 0;
}
}
int g = 0;
while (g < n) {
cout << str[g];
g++;
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, a, b;
cin >> n;
cin >> a;
cin >> b;
vector<int> aa(a);
vector<int> bb(b);
vector<int> cc(n);
vector<int> ans(n);
for (int i = 0; i < a; i++) {
cin >> aa[i];
}
for (int i = 0; i < b; i++) {
cin >> bb[i];
}
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
set_difference(bb.begin(), bb.end(), aa.begin(), aa.end(), cc.begin());
for (int i = 0; i < a; i++) {
ans[aa[i] - 1] = 1;
}
for (int i = 0; i < n; i++) {
if (cc[i] != 0) {
ans[cc[i] - 1] = 2;
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2 * 1e5 + 5;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> cnt(40, 0);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 39; j++) {
if (a[i] & (1ll << j)) cnt[j]++;
}
}
for (long long j = 39; j >= 0; j--) {
if (cnt[j] & 1) {
if (n & 1) {
if (cnt[j] % 4 == 1)
cout << "WIN\n";
else
cout << "LOSE\n";
} else {
cout << "WIN\n";
}
goto pp;
}
}
cout << "DRAW\n";
pp:
continue;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
Int k,a,b,ans; cin>>k>>a>>b;
if(b-a>2)ans=a+(k-(a-1))/2*(b-a)+(k-(a-1))%2;
else ans=k+1;
cout<<ans<<'\n';
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, i, j, k;
string S;
int a = 0, b = 0, c = 0;
cin >> S;
for (i = 0; i < S.size(); i++) {
if (S[i] == 'a')
a++;
else if (S[i] == 'b')
b++;
else
c++;
}
if (a == 0 || b == 0 || c == 0) {
cout << "NO\n";
return 0;
}
string s = S;
sort(s.begin(), s.end());
if (S == s && (a == c || b == c))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) {
return v;
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
const int N = 1e5 + 3;
const int nlog = 18;
int pr[N][nlog];
int pos[N], End[N];
vector<int> edge[N];
void dfs(int u, int p = 0) {
static int count = 0;
pos[u] = ++count;
pr[u][0] = p;
for (int i = 1; i < nlog; ++i) pr[u][i] = pr[pr[u][i - 1]][i - 1];
for (auto& v : edge[u]) {
if (v == p) continue;
dfs(v, u);
}
End[u] = count;
}
int anc(int x, int y) { return (pos[x] <= pos[y] && End[y] <= End[x]); }
int lca(int x, int y) {
if (anc(x, y)) return x;
if (anc(y, x)) return y;
for (int i = nlog - 1; i >= 0; --i) {
if (pr[x][i] && !anc(pr[x][i], y)) {
x = pr[x][i];
}
}
return pr[x][0];
}
template <typename T>
class Eins {
public:
vector<T> st;
int n;
Eins(int n = 0) : n(n) { st.resize(n + 1); }
void update(int i, T val) {
for (; i <= n; i += i & -i) st[i] += val;
}
T get(int i) {
T ans{};
for (; i; i -= i & -i) ans += st[i];
return ans;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
edge[u].emplace_back(v);
edge[v].emplace_back(u);
}
dfs(1);
Eins<int> Tree(n);
vector<int> kt(n + 1);
while (q--) {
int N, m, r;
cin >> N >> m >> r;
vector<int> node(N + 1);
for (int i = 1; i <= N; ++i) {
int x;
cin >> x;
node[i] = x;
kt[x] = 1;
Tree.update(pos[x], 1);
Tree.update(End[x] + 1, -1);
}
vector<int> num(N + 1);
int fix = Tree.get(pos[r]);
for (int i = 1; i <= N; ++i) {
int P = lca(r, node[i]);
int u = node[i];
num[i] = -1 + Tree.get(pos[u]) + fix - Tree.get(pos[P]) * 2 + kt[P];
}
for (int i = 1; i <= N; ++i) {
int u = node[i];
Tree.update(pos[u], -1);
Tree.update(End[u] + 1, 1);
kt[u] = 0;
}
bool flag = true;
for (int i = 1; i <= N; ++i) {
if (num[i] >= m) {
flag = false;
break;
}
}
if (!flag) {
cout << "0\n";
continue;
}
vector<Mint> dp(N + 1);
dp[0] = 1;
sort(num.begin() + 1, num.end());
for (int i = 1; i <= N; ++i) {
for (int j = min(i, m); ~j; --j) {
if (j <= num[i]) {
dp[j] = 0;
continue;
}
dp[j] *= (j - num[i]);
if (j) dp[j] += dp[j - 1];
}
}
Mint ans = 0;
for (int i = 1; i <= N; ++i) ans += dp[i];
cout << ans << "\n";
}
}
| 5 |
#include <iostream>
#include <fstream>
#include <typeinfo>
#include <vector>
#include <stack>
#include <cmath>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <iomanip>
#include <cctype>
#include <random>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<57;
const double pi=acos(-1);
const double eps=1e-6;
const ll mod=1e9+7;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,-0};
const int DX[8]={-1,-1,-1,0,1,1,1,0},DY[8]={1,0,-1,-1,-1,0,1,1};
class Graph{
private:
int V;
vvp List;
int Diametarfunc(int s,int& d){
int ansv;
vb used(V);
used[s]=1;
queue<P> que;
que.push(P(s,0));
while(!que.empty()){
P v=que.front();
que.pop();
if(v.second>d){
ansv=v.first;
d=v.second;
}
for(int i=0;i<List[v.first].size();i++){
P u=List[v.first][i];
if(!used[u.first]){
used[u.first]=1;
que.push(P(u.first,v.second+u.second));
}
}
}
return ansv;
}
int Diametar(){
int d=-1,ansl,ansr;
ansl=Diametarfunc(0,d);
d=-1;
ansr=Diametarfunc(ansl,d);
return d;
}
void change_edge(int s){
List[s][0].second++;
int t=List[s][0].first;
for(int i=0;i<List[t].size();i++) if(List[t][i].first==s) List[t][i].second++;
}
public:
Graph(int v){
V=v;
List=vvp(v);
}
void add_edge(int s,int t,int c){
List[s].push_back({t,c});
List[t].push_back({s,c});
}
int solve(){
int num=0;
for(int i=0;i<V;i++){
int S=List[i].size();
if(S==1) num++;
if(S==2) change_edge(i);
}
return num+Diametar();
}
};
int n;
int main(){
cin>>n;
Graph g(n);
for(int i=1;i<n;i++){
int s,t;
cin>>s>>t;
g.add_edge(s-1,t-1,0);
}
cout<<g.solve()<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
long long int n = 0, m = 0, k = 0, i = 0, j = 0, p = 0, q = 0, x = 0, y = 0,
z = 0, ans = 0, cnt = 0, l = 0, r = 0, mid = 0, lo = 0,
hi = 0;
string s;
bool flag = false;
cin >> x >> y >> m;
for (i = 0; i <= min(x, m); i++) {
long long int xx = i * 1E9;
if (((xx % m) != 0) && (m - (xx % m) > y)) {
flag = true;
k = i;
break;
}
}
if (!flag)
cout << "2" << endl;
else {
s = to_string(k);
while (s.length() < 9) s = "0" + s;
cout << "1 " << s << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int freq[26] = {};
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
freq[s[i] - 'a']++;
}
int ans = 1, flag = 0;
for (int i = 0; i < 26; i++) {
if (freq[i] > 0 && freq[i] % 2 == 1) {
flag++;
if (flag > 1) {
ans++;
freq[i]--;
}
}
}
if (ans % 2)
cout << "First\n";
else
cout << "Second\n";
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.