solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int ms = 10 + 10;
pair<int, int> a[ms], b[ms];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int x, y;
cin >> x >> y;
for (int i = 0; i < x; ++i) {
cin >> a[i].first >> a[i].second;
if (a[i].first > a[i].second) swap(a[i].first, a[i].second);
}
for (int i = 0; i < y; ++i) {
cin >> b[i].first >> b[i].second;
if (b[i].first > b[i].second) swap(b[i].first, b[i].second);
}
vector<int> res;
for (int i = 0; i < x; ++i) {
vector<int> tmp;
for (int j = 0; j < y; ++j) {
if (a[i] == b[j]) continue;
if (a[i].first == b[j].first || a[i].first == b[j].second)
tmp.push_back(a[i].first);
else if (a[i].second == b[j].first || a[i].second == b[j].second)
tmp.push_back(a[i].second);
}
sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
if (tmp.size() > 1) {
cout << "-1";
return 0;
}
for (int j : tmp) res.push_back(j);
}
for (int j = 0; j < x; ++j) {
vector<int> tmp;
for (int i = 0; i < x; ++i) {
if (a[i] == b[j]) continue;
if (a[i].first == b[j].first || a[i].first == b[j].second)
tmp.push_back(a[i].first);
else if (a[i].second == b[j].first || a[i].second == b[j].second)
tmp.push_back(a[i].second);
}
sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
if (tmp.size() > 1) {
cout << "-1";
return 0;
}
}
sort(res.begin(), res.end());
res.erase(unique(res.begin(), res.end()), res.end());
if (res.size() != 1)
cout << "0";
else
cout << res[0];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
int a, b, c, d, e, f, minn = 23332323, x, y;
int dis(int x, int y, int _x, int _y) { return abs(x - _x) + abs(y - _y); }
void a_to_b(int x, int y, int _x, int _y) {
while (x != _x || y != _y) {
if (x != _x) {
if (x > _x)
x--;
else
x++;
print(x, ' ');
print(y, '\n');
} else {
if (y > _y)
y--;
else
y++;
print(x, ' ');
print(y, '\n');
}
}
}
int main() {
cin >> a >> b >> c >> d >> e >> f;
for (register int i = min(a, c); i <= max(a, c); i++) {
for (register int j = min(b, d); j <= max(b, d); j++) {
if (dis(a, b, i, j) + dis(c, d, i, j) + dis(e, f, i, j) < minn) {
minn = dis(a, b, i, j) + dis(c, d, i, j) + dis(e, f, i, j);
x = i;
y = j;
}
}
}
cout << minn + 1 << endl;
a_to_b(x, y, a, b);
a_to_b(x, y, c, d);
a_to_b(x, y, e, f);
print(x, ' ');
print(y, '\n');
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
vector<int> G[N];
int n, m, L[N], R[N];
bool vis[N];
queue<int> Q;
vector<int> cur;
vector<vector<int> > ans;
void Delete(int x) {
R[L[x]] = R[x];
L[R[x]] = L[x];
}
bool Find(int u, int v) {
vector<int>::iterator it = lower_bound(G[u].begin(), G[u].end(), v);
return it != G[u].end() && *it == v;
}
void BFS(int S) {
cur.clear();
vis[S] = 1;
Q.push(S);
Delete(S);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
cur.push_back(u);
for (int i = R[0]; i <= n; i = R[i]) {
if (Find(u, i)) continue;
Delete(i);
vis[i] = 1;
Q.push(i);
}
}
ans.push_back(cur);
}
int main() {
scanf("%d%d", &n, &m);
for (int u, v, i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; ++i) sort(G[i].begin(), G[i].end());
for (int i = 0; i <= n; ++i) {
L[i] = i - 1;
R[i] = i + 1;
}
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
BFS(i);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); ++i) {
printf("%d", ans[i].size());
for (int j = 0; j < (int)ans[i].size(); ++j) printf(" %d", ans[i][j]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1 || n == 2 || n == 4) {
cout << -1 << endl;
continue;
}
if (n % 3 == 0) {
cout << n / 3 << " " << 0 << " " << 0 << endl;
continue;
} else if (n % 3 == 1) {
int count7 = 0;
while (n % 3 != 0) {
n = n - 7;
count7++;
}
cout << n / 3 << " " << 0 << " " << count7 << endl;
} else {
int count5 = 0;
while (n % 3 != 0) {
n = n - 5;
count5++;
}
cout << n / 3 << " " << count5 << " " << 0 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double amin = 10, amax = 1e10;
int num;
const double EPS = 1e-6;
for (int i = 1; i <= (n); i++) {
cin >> num;
amax = min(amax, 10.0 * (1 + num) / i - EPS);
amin = max(amin, num * 10.0 / i);
}
double bmax = (n + 1) * amax - num * 10;
double bmin = (n + 1) * amin - num * 10;
bmax /= 10;
bmin /= 10;
if ((int)bmax != (int)bmin) {
cout << "not unique" << endl;
} else {
cout << "unique" << endl;
cout << num + (int)bmax << endl;
}
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
using namespace std;
#define N 200012
typedef long long ll;
const int p=1e9+7;
int n,m;
int a[N],dp[18][N];
int f[N],inv[N],finv[N],siz[N];
inline int C(int nn,int mm)
{
if(nn==mm||mm==0)return 1;
else if(nn<mm)return 0;
else return 1ll*f[nn]*finv[mm]%p*finv[nn-mm]%p;
}
int main()
{
scanf("%d%d",&n,&m);
f[1]=inv[1]=finv[1]=1;
for(int i=2;i<=200000;i++)
{
inv[i]=1ll*(p-p/i)*inv[p%i]%p;
f[i]=1ll*f[i-1]*i%p;
finv[i]=1ll*finv[i-1]*inv[i]%p;
}
for(int i=1;i<=m;i++)scanf("%d",&a[i]);
sort(a+1,a+1+m);reverse(a+1,a+1+m);
dp[0][0]=1;if(a[m]==2){puts("0");return 0;}
for(int i=1;i<=m;i++)
{
for(int j=0;j<(1<<n);j++)
{
(dp[i][j]+=dp[i-1][j])%=p;
for(int k=1;k<=n;k++)
{
if(j&(1<<(k-1)))continue;
dp[i][j|(1<<(k-1))]+=1ll*dp[i-1][j]*f[1<<(k-1)]%p*C((1<<n)-a[i]-j,(1<<(k-1))-1)%p;
dp[i][j|(1<<(k-1))]%=p;
}
}
}
int ans=0;
for(int s=0;s<(1<<n);s++)
{siz[s]=siz[s>>1]+(s&1);
int te=1ll*dp[m][s]*f[(1<<n)-s-1]%p;
if(siz[s]&1)ans=(ans-te+p)%p;
else ans=(ans+te)%p;
}
ans=1ll*ans*(1<<n)%p;
printf("%d\n",ans);
}
/*
4 4
2 8 11 13
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N,M,V,P;
cin >> N >> M >> V >> P;
vector<long long> A(N);
vector<long long> Asum(N+1);
for(int i=0;i<N;i++) cin >> A[i];
A.push_back(1001001001);
sort(A.begin(),A.end());
reverse(A.begin(),A.end());
Asum[0] = 0;
for(int i=1;i<=N;i++) Asum[i] = A[i]+Asum[i-1];
for(int i=P+1;i<=N;i++){
if(i!=N) if(A[i]==A[i+1]) continue;
if(A[P]>A[i]+M || (double)(Asum[i-1]-Asum[P-1]+M*(max((long long)0,V-(N-(i-P)))))/(double)(i-P) > A[i]+M){
long long ans = i-1;
while(A[ans]==A[i]) ans--;
cout << ans << endl;
return 0;
}
}
cout << N << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int main() {
ios::sync_with_stdio(false);
int n, m;
long long res = 0;
cin >> n >> m;
for (int i = (2); i < (n + 1); i += 2)
for (int j = (2); j < (m + 1); j += 2) res += (n - i + 1) * (m - j + 1);
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 100;
const int INF = 1e9;
const double eps = 1e-7;
void solve() {
int n;
cin >> n;
vector<long long> a(n + 1, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.begin() + n);
for (int i = n - 1; i > -1; i--) {
cout << a[i % 2 ? n - 1 - i / 2 : i / 2] << ' ';
}
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cassert>
#include <climits>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <fstream>
using namespace std;
#define TOSTRING(x) #x
#define SZ(x) (int)(x).size()
#define REP(i,n) for(int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REPR(i,n) for(int i=(n)-1;i>=0;i--)
#define ALL(s) (s).begin(), (s).end()
#define so(V) sort(ALL(V))
#define rev(V) reverse(ALL(V))
#define uni(v) v.erase( unique(ALL(v)) , v.end());
#define PAU
typedef long long unsigned int llu;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<vb> vvb;
const double EPS = 1e-9;
const int MOD = 1e9 + 7;
const int INF = (1 << 28);
const ll LINF = 1e18;
const double PI = acos(-1);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vi coin({25, 10, 5, 1});
int ans = 0;
REP(i, 4) {
while (coin[i] <= N) {
N -= coin[i];
ans++;
}
}
cout << ans << endl;
PAU;
return 0;
}
| 0 |
#include<cstdio>
using namespace std;
int main()
{
char ch,ph;
scanf("%c %c",&ch,&ph);
ch==ph?printf("=\n"):(ch>ph?printf(">\n"):printf("<\n"));
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string hola;
string chau = "NO";
int gente[4];
int autos[12];
int choques[4];
int accidentes = 0;
for (int i = 0; i < 4; i++) {
cin >> autos[i * 3];
cin >> autos[i * 3 + 1];
cin >> autos[i * 3 + 2];
cin >> gente[i];
choques[i] = 0;
}
choques[0] = autos[0] + autos[1] + autos[2] + autos[3] + autos[7] + autos[11];
choques[1] = autos[3] + autos[4] + autos[5] + autos[6] + autos[10] + autos[2];
choques[2] = autos[6] + autos[7] + autos[8] + autos[9] + autos[1] + autos[5];
choques[3] =
autos[9] + autos[10] + autos[11] + autos[0] + autos[4] + autos[8];
for (int i = 0; i < 4; i++) {
if (choques[i] > 0) {
if (choques[i] < choques[i] + gente[i]) {
accidentes = 1;
}
}
}
if (accidentes == 1) {
hola = "YES";
} else {
hola = chau;
}
cout << hola << endl;
}
| 1 |
// 0130
#include <iostream>
#include <deque>
#include <string>
const int C = 'a';
using namespace std;
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
string str;
cin>>str;
deque<char> dq;
dq.push_back(str[0]);
int ch[26] = {0};
ch[str[0]-C]++;
for(int j=1;j<str.length();j+=3){
if((str[j] == '-') && (str[j+1] == '>') && (ch[str[j+2]-C] == 0)){
dq.push_back(str[j+2]);
ch[str[j+2]-C]++;
}
if((str[j] == '<') && (str[j+1] == '-') && (ch[str[j+2]-C] == 0)){
dq.push_front(str[j+2]);
ch[str[j+2]-C]++;
}
}
for(deque<char>::iterator itr = dq.begin();itr != dq.end();itr++)
cout<<*itr;
cout<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string i2s(int x) {
stringstream ss;
ss << x;
return ss.str();
}
int s2i(string str) {
istringstream ss(str);
int nro;
ss >> nro;
return nro;
}
int n, A[100005], B[100005], a, b;
int main() {
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &B[i]);
}
long long sum = 0;
for (int i = 0; i < n; i++) {
a = B[i] / 2;
b = (B[i] + 1) / 2;
if (a > A[i] || b > A[i] || a < 1 || b < 1)
sum -= 1;
else
sum += (long long)a * (long long)b;
}
printf("%lld\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long INF = 1000000007;
const long double cp = 2 * asin(1.0);
const long double eps = 1e-9;
const long long mod = 1000000007;
using namespace std;
int main() {
string s;
long long k, len, mx = 0;
cin >> s >> k;
for (int(i) = 0; (i) < (k); i++) s += '?';
for (int l = 1; l <= s.size(); l++) {
for (int i = 0; i < s.size(); i++) {
bool f = true;
for (int j = i; j < l + i; j++) {
if (s[j] == s[j + l] || s[j + l] == '?')
f = true;
else {
f = false;
break;
}
}
if (f) {
mx = l * 2;
break;
}
}
}
cout << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int LOG = 19;
int n, m;
int a[N], jl[LOG][N], jr[LOG][N];
int tr[LOG][N << 1], tl[LOG][N << 1];
void build(int id) {
for (int i = 1; i <= m; i++) {
tl[id][i + N] = jl[id][i];
tr[id][i + N] = jr[id][i];
}
for (int i = N - 1; i >= 1; i--) {
tl[id][i] = min(tl[id][i + i], tl[id][i + i + 1]);
tr[id][i] = max(tr[id][i + i], tr[id][i + i + 1]);
}
}
int getr(int id, int l, int r) {
int res = 0;
for (l += N, r += N; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
if (l & 1) res = max(res, tr[id][l]);
if (~r & 1) res = max(res, tr[id][r]);
}
return res;
}
int getl(int id, int l, int r) {
int res = 1e9;
for (l += N, r += N; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
if (l & 1) res = min(res, tl[id][l]);
if (~r & 1) res = min(res, tl[id][r]);
}
return res;
}
pair<int, int> cc(int id, int l, int r) {
return pair<int, int>(getl(id, l, r), getr(id, l, r));
}
pair<int, int> calc(int id, int l, int r) {
if (r - l + 1 >= n) return pair<int, int>(1, n);
return cc(id, l, r);
}
int main() {
scanf("%d", &n);
m = 3 * n;
for (int i = 1; i <= m; i++) {
if (i <= n) {
scanf("%d", a + i);
} else
a[i] = a[i - n];
jr[0][i] = min(m, i + a[i]);
jl[0][i] = max(1, i - a[i]);
}
if (n == 1) {
puts("0");
return 0;
}
for (int it = 1; it < LOG; it++) {
build(it - 1);
for (int i = 1; i <= m; i++) {
auto x = calc(it - 1, jl[it - 1][i], jr[it - 1][i]);
if (x.second - x.first + 1 >= n) x = pair<int, int>(1, n);
tie(jl[it][i], jr[it][i]) = x;
}
}
build(LOG - 1);
for (int i = n + 1; i <= n + n; i++) {
int ans = 0;
int l = i, r = i;
for (int j = LOG - 1; j >= 0; j--) {
auto x = calc(j, l, r);
if (x.second - x.first + 1 < n) {
ans += 1 << j;
tie(l, r) = x;
}
}
printf("%d ", ans + 1);
}
puts("");
return 0;
}
| 4 |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <stdio.h>
#include <string.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, l, t;
cin >> n >> l >> t;
vector<int> x(n), w(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> w[i];
}
int m[3] = { 0, t % l, l - t % l }, q = t / l, d = 0;
for (int i = 0; i < n; i++) {
x[i] += m[w[i]];
d += w[i] == 1 ? q : -q - 1;
if (x[i] >= l) x[i] -= l, d++;
}
d %= n;
if (d < 0) d += n;
sort(x.begin(), x.end());
for (int i = 0; i < n; i++) {
int i1 = i + d;
if (i1 >= n) i1 -= n;
cout << x[i1] << "\n";
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n);
int i;
for (i = 0; i < n; i++) {
cin >> p[i];
}
sort(p.begin(), p.end(), greater<int>());
int result = 0;
for (i = 0; i < n; i++) {
if (p[i] >= i + 1) {
result = max(result, i + 1);
}
}
cout << result << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
template <typename T>
void __RI(T &x) {
int ch = getchar(), neg = 1;
x = 0;
for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = getchar())
;
if (ch == EOF) return;
if (ch == '-') neg = -1, ch = getchar();
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
x *= neg;
}
void R(int &x) { __RI(x); }
void R(int64_t &x) { __RI(x); }
template <typename T1, typename T2>
void R(std::pair<T1, T2> &x) {
R(x.first);
R(x.second);
}
template <typename T>
void R(std::vector<T> &x) {
for (auto &i : x) {
R(i);
}
}
template <typename T>
void R(T &x) {
std::cin >> x;
}
template <typename T, typename... Args>
void R(T &x, Args &...args) {
R(x), R(args...);
}
template <typename T>
void RA(T *arr, int l, int r) {
arr += l;
int p = r - l + 1;
while (p--) R(*arr++);
}
char space = ' ';
template <typename T>
void __WI(T x) {
if (x == 0) putchar('0');
if (x < 0) putchar('-'), x = -x;
char ch[64];
int pos = 0;
while (x) ch[pos++] = x % 10 + 48, x /= 10;
while (pos) putchar(ch[--pos]);
}
void W() {}
void W(const int &x) { __WI(x); }
void W(const int64_t &x) { __WI(x); }
void W(const double &x) { printf("%lf", static_cast<double>(x)); }
void W(const char &x) { putchar(x); }
void W(const std::string &x) { printf("%s", x.c_str()); }
template <typename T1, typename T2>
void W(const std::pair<T1, T2> &x) {
W(x.first);
W(space);
W(x.second);
}
template <typename T>
void W(const std::vector<T> &x) {
for (auto it = x.cbegin(); it != x.cend(); it++) {
W(*it);
W(space);
}
W('\n');
}
template <typename T>
void W(const T &x) {
std::cout << x;
}
template <typename T, typename... Args>
void W(const T &x, const Args &...args) {
W(x), W(space), W(args...);
}
template <typename... Args>
void WL(const Args &...args) {
W(args...), W('\n');
}
template <typename T>
void WA(T *arr, int l, int r) {
arr += l;
int p = r - l;
while (p--) W(*arr++), W(space);
W(*arr);
}
template <typename T>
void WAL(T *arr, int l, int r) {
arr += l;
int p = r - l;
while (p--) W(*arr++), W(space);
WL(*arr);
}
}; // namespace IO
int n, m, d;
int a[310], b[310], t[310];
long long dp[2][150010];
long long tor[150010], tol[150010];
void preduce(int x, int id) {
tol[0] = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
if ((i - 1) % x == 0)
tol[i] = dp[id][i - 1];
else
tol[i] = max(tol[i - 1], dp[id][i - 1]);
}
tor[n] = -0x3f3f3f3f;
for (int i = n - 1; i >= 0; i--) {
if (i % x == x - 1)
tor[i] = dp[id][i];
else
tor[i] = max(tor[i + 1], dp[id][i]);
}
}
long long query(int cen, int x) {
int l = max(cen - x, 0);
int r = min(cen + x + 1, n);
if (l == 0) return tol[r];
long long ans = tor[l];
if (r / (2 * x + 1) * (2 * x + 1) >= l) ans = max(ans, tol[r]);
return ans;
}
int main() {
IO::R(n, m, d);
for (int i = 0; i < m; i++) IO::R(a[i], b[i], t[i]);
for (int i = 0; i < m; i++) a[i]--;
for (int i = 0; i < n; i++) dp[0][i] = b[0] - abs(a[0] - i);
for (int i = 1; i < m; i++) {
long long tp = (long long)d * (long long)(t[i] - t[i - 1]);
tp = min(tp, (long long)n);
int x = int(tp);
preduce(x << 1 | 1, (i - 1) % 2);
for (int j = 0; j < n; j++)
dp[i % 2][j] = b[i] - abs(a[i] - j) + query(j, x);
}
long long ans = -0x3f3f3f3f;
for (int i = 0; i < n; i++) ans = max(ans, dp[(m - 1) % 2][i]);
IO::WL(ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, i, j, a, b, q, n;
cin >> n >> k;
a = n / k;
if (a % 2 == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<queue>
#include<list>
#include<set>
using namespace std;
#define N 100001
#define MOD 10007
struct Node{
int id;
int con[2];
int cost[2];
Node():id(-1){}
Node(int id,int con1, int cost1, int con2, int cost2):id(id){
con[0]=con1;con[1]=con2;
cost[0]=cost1;cost[1]=cost2;
}
};
typedef vector<Node> Graph;
typedef list< pair<Graph,set<int> > > Forest;
void bfs(int st, bool vis[N], const Graph &G, Forest &F){
queue<int> qi;
Graph ret;
set<int> g;
qi.push(st);
vis[st]=true;
ret.push_back( G[st] );
while(!qi.empty()){
int now = qi.front();
qi.pop();
g.insert( now );
for(int i = 0; i < 2; ++i){
for(int j = 0; j < 2; ++j){
if( G[ G[now].con[i] ].con[j] == now &&
!vis[ G[now].con[i] ] ){
ret.push_back( G[ G[now].con[i] ] );
qi.push( G[now].con[i] );
vis[ G[now].con[i] ] = true;
}
}
}
}
F.push_back( make_pair( ret, g ) );
}
int main()
{
while(true){
int answer = 1;
int n;
bool vis[N]={false,};
Graph G;
Forest F;
cin >> n;
if( n == 0 )break;
for(int i = 0; i < n; ++i){
int con1,cost1,con2,cost2;
cin >> con1 >> cost1 >> con2 >> cost2;
G.push_back( Node(i,con1,cost1,con2,cost2) );
}
for(int i = 0; i < n; ++i){
if( !vis[i] ){
bfs(i,vis,G,F);
}
}
for(Forest::iterator itg = F.begin(); itg != F.end(); ++itg){
int max_w = -1;
int cnt = 0;
/*
cout << itg->first.size() << endl;
for(int i = 0; i < itg->first.size(); ++i){
cout << itg->first[i].id << " : ";
for(int j = 0; j < 2; ++j){
cout << itg->first[i].con[j] << ' ' << itg->first[i].cost[j] << " ";
}
cout << endl;
}
*/
if( itg->first.size() == 1 ) continue;
for(int i = 0; i < itg->first.size(); ++i){
for(int j = 0; j < 2; ++j){
if( itg->second.find( itg->first[i].con[j] ) !=
itg->second.end() ){
max_w = max( max_w, itg->first[i].cost[j] );
}
}
}
for(int i = 0; i < itg->first.size(); ++i){
for(int j = 0; j < 2; ++j){
if( itg->second.find( itg->first[i].con[j] ) !=
itg->second.end() ){
if( max_w == itg->first[i].cost[j] ){
++cnt;
}
}
}
}
cnt/=2;
answer *= cnt;
answer %= MOD;
}
cout << answer << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], asum;
vector<int> ans;
int main() {
scanf("%d", &n);
for (int i = 0; i <= n - 1; ++i) scanf("%d", &a[i]);
for (int b = 31; b >= 0; --b) {
ans.clear();
for (int i = 0; i <= n - 1; ++i)
if ((a[i] >> b) & 1 == 1) ans.push_back(a[i]);
if (ans.size() == 0) continue;
asum = ans[0];
for (int i = 1; i < ans.size(); ++i) asum &= ans[i];
int x = round(pow(2, b));
if (asum % x == 0) {
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
return 0;
}
}
printf("%d\n", n);
for (int i = 0; i <= n - 1; ++i) printf("%d ", a[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, arr[200001], m, mx;
map<int, int> ma;
int main() {
ios::sync_with_stdio(false);
cin >> n;
arr[1] = 1;
ma[1]++;
for (int i = 2; i <= n; i++) {
cin >> m;
arr[i] = arr[m] + 1;
ma[arr[i]]++;
mx = max(arr[i], mx);
}
for (int i = 1; i <= mx; i++) {
ans += (ma[i] % 2);
}
cout << ans;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int h,w,n;
cin >> h >> w >> n;
int sup=max(h,w);
cout << (n-1)/sup+1 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int a[100001], b[100001], ans[100001];
map<int, int> M;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= n; ++i) ans[a[i]] = b[i];
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int c = 26;
vector<string> s;
vector<long long int> mp[c];
bitset<c> vis, used;
long long int n, deg[26];
string ans;
bool topological() {
long long int cnt = c;
deque<long long int> q;
for (int i = 0; i < c; i++) {
if (!deg[i] && used[i])
q.push_back(i);
else if (!used[i])
cnt--;
}
while (q.size()) {
long long int cur = q.front();
q.pop_front();
ans += char(cur + 'a'), vis[cur] = true, cnt--;
for (long long int i : mp[cur]) {
if (vis[i]) continue;
deg[i]--;
if (!deg[i]) {
q.push_front(i);
}
}
}
if (cnt) return false;
return true;
}
bool check(string s) {
bool succeed = false;
if (s.length() > ans.length()) return false;
for (int i = 0; i < ans.length() - s.length() + 1; i++) {
succeed = false;
for (int j = 0; j < s.length(); j++) {
if (s[j] != ans[j + i]) break;
if (j == s.length() - 1) succeed = true;
}
if (succeed) return true;
}
return false;
}
bool solve() {
for (string ss : s) {
if (ss.length() > c) return false;
for (int i = 0; i < ss.length() - 1; i++) {
int f = ss[i] - 'a', to = ss[i + 1] - 'a';
mp[f].push_back(to), deg[to]++;
used[f] = true, used[to] = true;
}
int lst = ss[ss.length() - 1] - 'a';
used[lst] = true;
}
for (int i = 0; i < c; i++) {
sort(mp[i].begin(), mp[i].end());
}
if (!topological()) return false;
for (string ss : s) {
if (!check(ss)) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n, s.resize(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
if (solve()) {
cout << ans << "\n";
} else
cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n,b[505*505];
struct note{
int x,i;
}a[505];
bool cmp(note x,note y){
return x.x<y.x;
}
void ex(){
puts("No");
exit(0);
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&a[i].x),a[i].i=i;
int N=n*n;
std::sort(a+1,a+n+1,cmp);
for (int i=1;i<=n;i++){
int now=1;
for (int j=1;j<a[i].x && now<a[i].i;j++)
if (!b[j]) b[j]=a[i].i,now++;
b[a[i].x]=a[i].i;
if (now<a[i].i) ex();
}
for (int i=n;i>=1;i--){
int now=n;
for (int j=N;j>=a[i].x && now>a[i].i;j--)
if (!b[j]) b[j]=a[i].i,now--;
if (now>a[i].i) ex();
}
puts("Yes");
for (int i=1;i<=N;i++) printf("%d ",b[i]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, a[420], p, z = -1;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
p = a[j], x = 1;
for (int k = i, u = a[i] - 1; k <= j; k++)
x += u / a[k], p += u / a[k] * a[k], u %= a[k];
for (int k = y = 0, u = p; k < n; k++) y += u / a[k], u %= a[k];
if (x < y && (z == -1 || z > p)) z = p;
}
}
printf("%d", z);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct camel {
int x, y;
};
int main() {
int n;
bool r = false;
cin >> n;
camel arr[n];
for (int i = 0; i < n; i++) cin >> arr[i].x >> arr[i].y;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (arr[i].x + arr[i].y == arr[j].x)
if (arr[j].x + arr[j].y == arr[i].x) r = true;
}
if (r)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i;
i = n;
int ans[n + 1];
int prev = -1;
int tot = 0;
while (i >= 2) {
cout << "? " << 1 << " " << i << endl;
int x;
cin >> x;
if (prev != -1) {
ans[i + 1] = prev - x;
} else {
tot = x;
}
prev = x;
i--;
}
cout << "? " << 2 << " " << n << endl;
int x;
cin >> x;
ans[1] = tot - x;
ans[2] = prev - ans[1];
cout << "! ";
for (i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
struct Node {
int x, y, w;
};
struct Id {
int bl, ps;
};
int n, m, k, q;
int len[N];
int ll[N], rr[N], uu[N], dd[N];
Id id[N][N];
bool fl[N];
vector<Node> v[N];
vector<pair<int, int> > vp[N];
vector<long long> ds[N];
bool in(int x, int l, int r) { return x <= r && x >= l; }
void go(int a, int b, int c, int d, long long &s) {
if (!in(a, 1, n) || !in(b, 1, m) || !in(c, 1, n) || !in(d, 1, m)) return;
if (id[a][b].bl != id[c][d].bl) return;
if (!fl[id[a][b].bl]) return;
if (id[a][b].ps > id[c][d].ps) {
if (id[a][b].ps == id[c][d].ps + 1) {
vp[id[a][b].bl].push_back(make_pair(id[c][d].ps, -1));
}
} else {
if (id[a][b].ps + 1 == id[c][d].ps) {
vp[id[a][b].bl].push_back(make_pair(id[a][b].ps, 1));
}
}
}
long long solve(int u, int l, int d, int r) {
long long s = 0;
for (int i = 0; i < k; ++i) vp[i].clear();
for (int i = l; i <= r; ++i) {
go(u, i, u - 1, i, s);
go(d, i, d + 1, i, s);
}
for (int i = u; i <= d; ++i) {
go(i, l, i, l - 1, s);
go(i, r, i, r + 1, s);
}
for (int i = 0; i < k; ++i) sort(vp[i].begin(), vp[i].end());
for (int i = 0; i < k; ++i)
if (!vp[i].empty()) {
for (int j = 0; j < vp[i].size(); ++j) {
s = s + vp[i][j].second * ds[i][vp[i][j].first];
}
if (vp[i].back().second == -1) {
s = s + ds[i].back();
}
}
for (int i = 0; i < k; ++i) {
if (in(ll[i], l, r) && in(rr[i], l, r) && in(uu[i], u, d) &&
in(dd[i], u, d)) {
if (fl[i]) s += ds[i].back();
}
}
return s;
}
void get(vector<Node> &v, vector<long long> &d) {
d.push_back(v[0].w);
for (int i = 1; i < v.size(); ++i) {
d.push_back(v[i].w + d.back());
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) id[i][j] = {-1, -1};
for (int i = 0; i < k; ++i) {
scanf("%d", len + i);
ll[i] = INT_MAX, uu[i] = INT_MAX;
rr[i] = 0, dd[i] = 0;
for (int j = 0, x, y, w; j < len[i]; ++j) {
scanf("%d%d%d", &x, &y, &w);
v[i].push_back({x, y, w});
id[x][y] = {i, j};
ll[i] = min(y, ll[i]);
rr[i] = max(y, rr[i]);
uu[i] = min(x, uu[i]);
dd[i] = max(x, dd[i]);
}
get(v[i], ds[i]);
}
fill(fl, fl + k, true);
scanf("%d", &q);
while (q--) {
char cmd[20];
scanf("%s", cmd);
if (cmd[0] == 'S') {
int i;
scanf("%d", &i);
--i;
fl[i] = !fl[i];
} else {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf("%lld\n", solve(x1, y1, x2, y2));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<char, bool> m;
vector<long long> v;
long long d[1000006];
int main() {
long long ans = 0, a, b, c;
for (int i = 1; i < 1000001; i++) {
for (int j = i; j < 1000001; j += i) {
d[j]++;
}
}
cin >> a >> b >> c;
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
for (int k = 1; k <= c; k++) {
ans += d[i * j * k] % 1073741824LL;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 2e5 + 10;
long long fp(long long a, long long b) {
long long ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans % mod;
}
long long jc[20], jie[N][20], sum[N], cnt1[N], cnt2[N];
long long n, q, x, s, m, l, r, d, a1, a2, f, u1 = 7, u2 = 2;
long long C(long long x, long long y) {
return (jc[x] / jc[y] / jc[x - y]) % mod;
}
int main() {
scanf("%lld%lld", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
sum[i] = (sum[i - 1] + x) % mod;
cnt1[i] = (cnt1[i - 1] + fp(x, u1)) % mod;
cnt2[i] = (cnt2[i - 1] + fp(x, u2)) % mod;
}
jie[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 15; j++) jie[i][j] = (jie[i - 1][j] + fp(i, j)) % mod;
jc[0] = 1;
for (int i = 1; i <= 15; i++) jc[i] = jc[i - 1] * i;
while (q--) {
scanf("%lld%lld%lld", &l, &r, &d);
m = r - l + 1;
s = sum[r] - sum[l - 1];
f = ((s - ((m - 1) * m / 2) % mod * (d % mod) % mod + mod) % mod *
fp(m, mod - 2) % mod +
mod) %
mod;
a1 = 0;
a2 = 0;
for (int j = 0; j <= u1; j++) {
long long dj = (fp(d, j) + mod) % mod, fj = (fp(f, u1 - j) + mod) % mod;
a1 = ((a1 + jie[m - 1][j] % mod * C(u1, j) % mod * dj % mod * fj % mod) %
mod +
mod) %
mod;
}
for (int j = 0; j <= u2; j++) {
long long dj = (fp(d, j) + mod) % mod, fj = (fp(f, u2 - j) + mod) % mod;
a2 = ((a2 + jie[m - 1][j] % mod * C(u2, j) % mod * dj % mod * fj % mod) %
mod +
mod) %
mod;
}
long long b1 = (cnt1[r] - cnt1[l - 1] + mod) % mod;
long long b2 = (cnt2[r] - cnt2[l - 1] + mod) % mod;
if (a1 != b1 || a2 != b2)
printf("No\n");
else
printf("Yes\n");
}
return 0;
}
| 6 |
#include<stdio.h>
int main()
{
int n;
scanf("%d",&n);
int flag=0;
for(int i=0;i<=25;i++)
for(int j=0;j<=15;j++)
if(4*i+7*j==n) {
flag=1;
break;
}
if(flag) printf("Yes");
else printf("No");
} | 0 |
#include <iostream>
#include <vector>
using namespace std;
int N, Q;
string str;
vector<char> t, d;
int is_down(int k) {
int pos = k;
for (int i = 0; i < Q; i++) {
if (pos == -1 || pos == N) return pos;
if (str[pos] == t[i]) {
if (d[i] == 'L') pos--;
else pos++;
}
}
return pos;
}
int main() {
cin >> N >> Q;
cin >> str;
for (int i = 0; i < Q; i++)
{
char tmp1, tmp2;
cin >> tmp1 >> tmp2;
t.push_back(tmp1);
d.push_back(tmp2);
}
//左に落ちないゴーレムのうち、最も左端のものを二分探索
int left= -1, right = N;
while (left +1 < right) {
int mid = (left + right) / 2;
if (is_down(mid) == -1) left = mid;
else right = mid;
}
int remainL = right;
//右に落ちないゴーレムのうち、最も右端のものを二分探索
left = -1, right = N;
while (left + 1 < right) {
int mid = (left + right) / 2;
if (is_down(mid) == N) right = mid;
else left = mid;
}
int remainR = left;
int ans = remainR - remainL + 1;
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
namespace _buff {
const size_t BUFF = 1 << 19;
char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
char getc() {
if (ib == ie) {
ib = ibuf;
ie = ibuf + fread(ibuf, 1, BUFF, stdin);
}
return ib == ie ? -1 : *ib++;
}
} // namespace _buff
LL read() {
using namespace _buff;
LL ret = 0;
bool pos = true;
char c = getc();
for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
assert(~c);
}
if (c == '-') {
pos = false;
c = getc();
}
for (; c >= '0' && c <= '9'; c = getc()) {
ret = (ret << 3) + (ret << 1) + (c ^ 48);
}
return pos ? ret : -ret;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
const size_t N = 1e5 + 5;
using P = pair<int, int>;
P get_slope(P a, P b) {
int dx = b.first - a.first;
int dy = b.second - a.second;
int g = gcd(abs(dx), abs(dy));
return {dx / g, dy / g};
}
int n, fen[N];
void add(int p, int val) {
for (; p <= n; p += p & (-p)) {
fen[p] += val;
}
}
int query(int p) {
int ret = 0;
for (; p; p ^= p & (-p)) {
ret += fen[p];
}
return ret;
}
int query(int l, int r) { return query(r) - query(l - 1); }
vector<P> vc[N], que[N];
int ans[N];
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
int k = read() - 1;
P lst = {read(), read()}, cur = lst;
while (k--) {
P cur = {read(), read()};
vc[i].emplace_back(get_slope(lst, cur));
lst = cur;
}
vc[i].emplace_back(get_slope(lst, cur));
}
int q = read();
for (int i = 0; i < q; ++i) {
int l = read(), r = read();
que[r].emplace_back(l, i);
}
map<P, int> mp;
for (int i = 1; i <= n; ++i) {
for (auto p : vc[i]) {
if (mp.count(p)) {
add(mp[p], -1);
}
add(mp[p] = i, 1);
}
for (auto q : que[i]) {
ans[q.second] = query(q.first, i);
}
}
for (int i = 0; i < q; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> a1, a2;
vector<int> b1, b2;
int subsolve(vector<int>& box, vector<int>& spec) {
int N = (int) box.size();
int M = (int) spec.size();
vector<int> good (M+5, 0);
int cumulate = 0;
for (int i=M-1; i>=0; i--) {
int& sp = spec[i];
if (binary_search(box.begin(), box.end(), sp)) cumulate++;
good[i] = cumulate;
}
int ans=good[0];
for (int i=0; i<M; i++) {
int boxcnt = (int)(upper_bound(box.begin(), box.end(), spec[i]) - box.begin());
// _ * _ _ _ * _ _ *
// # # # # # # # #
// [spec[i] - boxcnt + 1, spec[i] + 1)
int left_spec = (int)(lower_bound(spec.begin(), spec.end(), spec[i] - boxcnt + 1) - spec.begin());
ans = max(ans, (i-left_spec+1) + good[i+1]);
}
return ans;
}
void solve() {
a1.clear(); a2.clear(); b1.clear(); b2.clear();
cin >> n >> m;
for (int i=0; i<n; i++) {
int tmp; scanf("%d", &tmp);
if (tmp > 0) a1.push_back(tmp);
else a2.push_back(-tmp);
}
for (int i=0; i<m; i++) {
int tmp; scanf("%d", &tmp);
if (tmp > 0) b1.push_back(tmp);
else b2.push_back(-tmp);
}
sort(a1.begin(), a1.end());
sort(a2.begin(), a2.end());
sort(b1.begin(), b1.end());
sort(b2.begin(), b2.end());
printf("%d\n", subsolve(a1, b1) + subsolve(a2, b2));
}
int main() {
int t; cin >> t;
while (t--)
solve();
} | 3 |
#include <iostream>
using namespace std;
int main() {
string s = "CODEFESTIVAL2016";
string v;
cin >> v;
int a = 0;
for (int i = 0; i < 16; i++) {
if (s[i] != v[i])
a++;
}
cout << a << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j, ans = 0;
cin >> n >> k;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
if (a[i] <= k)
ans++;
else
break;
}
for (j = n - 1; j > i; j--) {
if (a[j] <= k)
ans++;
else
break;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
const int P = 1e9 + 7;
int n, p;
int f[N][2][2][2];
int col[N];
inline void add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
inline int pow_mod(int x, int k) {
int res = 1, base = x;
while (k) {
if (k & 1) res = 1LL * res * base % P;
k >>= 1;
base = 1LL * base * base % P;
}
return res;
}
int main() {
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; ++i) scanf("%d", col + i);
memset(f, 0, sizeof f);
f[0][0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int w = 0; w <= 1; ++w)
for (int b = 0; b <= 1; ++b)
for (int k = 0; k <= 1; ++k) {
if (!f[i - 1][w][b][k]) continue;
if (col[i] == 0 || col[i] == -1) {
if (b) {
add(f[i][w][b][k],
1LL * f[i - 1][w][b][k] * pow_mod(2, i - 2) % P);
add(f[i][1][b][k ^ 1],
1LL * f[i - 1][w][b][k] * pow_mod(2, i - 2) % P);
} else {
add(f[i][1][b][k ^ 1],
1LL * f[i - 1][w][b][k] * pow_mod(2, i - 1) % P);
}
}
if (col[i] == 1 || col[i] == -1) {
if (w) {
add(f[i][w][b][k],
1LL * f[i - 1][w][b][k] * pow_mod(2, i - 2) % P);
add(f[i][w][1][k ^ 1],
1LL * f[i - 1][w][b][k] * pow_mod(2, i - 2) % P);
} else {
add(f[i][w][1][k ^ 1],
1LL * f[i - 1][w][b][k] * pow_mod(2, i - 1) % P);
}
}
}
}
int res = 0;
add(res, f[n][0][0][p]);
add(res, f[n][1][1][p]);
add(res, f[n][0][1][p]);
add(res, f[n][1][0][p]);
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long xx = 2e5;
long long v[xx + 10];
long long p1[xx], p2[xx];
void make_first(long long h) {
long long node = 1;
p1[1] = 0;
for (long long i = 1; i < h + 1; i++) {
if (v[i - 1] == 1) {
long long root = node;
for (long long j = 0; j < v[i]; j++) {
++node;
p1[node] = root;
}
} else {
long long r2 = node;
long long r1 = node - 1;
++node;
p1[node] = r1;
for (long long j = 0; j < v[i] - 1; j++) {
++node;
p1[node] = r2;
}
}
}
}
long long mx_node = 0;
void make_second(long long h) {
long long node = 1;
for (long long i = 1; i < h + 1; i++) {
long long root = node;
for (long long j = 0; j < v[i]; j++) {
++node;
p2[node] = root;
mx_node = max(mx_node, node);
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long h;
cin >> h;
for (long long i = 0; i < h + 1; i++) {
cin >> v[i];
}
bool per = true;
if (h >= 2) {
for (long long i = 2; i < h + 1; i++) {
if (v[i] > 1 && v[i - 1] > 1) {
per = false;
break;
}
}
}
if (per) {
cout << "perfect" << '\n';
return 0;
}
make_first(h);
make_second(h);
cout << "ambiguous" << '\n';
for (long long i = 1; i <= mx_node; i++) cout << p1[i] << " ";
cout << '\n';
for (long long i = 1; i <= mx_node; i++) cout << p2[i] << " ";
cout << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long optFrom[57];
int main() {
int N;
scanf("%d ", &N);
;
long long K;
cin >> K;
optFrom[N - 1] = 1LL;
optFrom[N - 2] = 2LL;
for (int i = (N - 3); i >= (0); i--) {
optFrom[i] = optFrom[i + 1] + optFrom[i + 2];
}
optFrom[N] = 1LL;
for (int i = (0); i < (N); i++) {
if (K > optFrom[i + 1]) {
printf("%d %d ", i + 1 + 1, i + 1);
K -= optFrom[i + 1];
i++;
} else {
printf("%d ", i + 1);
}
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000001;
int n, a, t, x;
map<int, map<int, int>> m;
void update(int idx, int val, int x) {
while (idx <= inf) {
m[x][idx] += val;
idx += (idx & -idx);
}
}
int read(int idx, int x) {
int sum = 0;
while (idx > 0) {
sum += m[x][idx];
idx -= (idx & -idx);
}
return sum;
}
int main() {
scanf("%d", &n);
while (n--) {
scanf("%d %d %d", &a, &t, &x);
if (a == 1) {
update(t, 1, x);
} else if (a == 2) {
update(t, -1, x);
} else {
printf("%d\n", read(t, x));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int xx[3], yy[3], n, tot[3], sum = 0;
int board[202][202];
int ans[202][202];
int cnt = 0;
int mnx, mxx, mny, mxy;
void init() {
mnx = mny = 2e9;
mxx = mxy = -2e9;
cnt = 0;
memset(board, 0, sizeof(board));
}
bool paint(int sy, int sx, int ly, int lx, int num) {
for (int i = sy; i < sy + ly; i++) {
for (int j = sx; j < sx + lx; j++) {
if (board[i][j]) return false;
board[i][j] = num;
}
}
return true;
}
int dy[4] = {0, 0, 1, -1};
int dx[4] = {1, -1, 0, 0};
bool isCan(int y, int x) {
if (y >= 0 && x >= 0 && y < n && x < n && board[y][x] == 0) return true;
return false;
}
void dfs(int y, int x, int num) {
cnt++;
mnx = min(mnx, x);
mxx = max(mxx, x);
mny = min(mny, y);
mxy = max(mxy, y);
board[y][x] = num;
for (int k = 0; k < 4; k++) {
int ny = y + dy[k];
int nx = x + dx[k];
if (isCan(ny, nx)) dfs(ny, nx, num);
}
}
void output() {
cout << n << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << (char)(board[i][j] + 'A' - 1);
}
cout << endl;
}
exit(0);
}
bool can() {
vector<int> ord = {0, 1, 2};
do {
int w1, h1, w2, h2, w3, h3;
for (int i = 0; i < 2; i++) {
if (i == 0) w1 = xx[ord[0]], h1 = yy[ord[0]];
if (i == 1) w1 = yy[ord[0]], h1 = xx[ord[0]];
for (int j = 0; j < 2; j++) {
if (j == 0) w2 = xx[ord[1]], h2 = yy[ord[1]];
if (j == 1) w2 = yy[ord[1]], h2 = xx[ord[1]];
for (int k = 0; k < 2; k++) {
if (k == 0) w3 = xx[ord[2]], h3 = yy[ord[2]];
if (k == 1) w3 = yy[ord[2]], h3 = xx[ord[2]];
int can = 1;
init();
if (i == 1 && j == 0 && k == 1) {
int abc = 3;
}
can &= paint(0, 0, w1, h1, ord[0] + 1);
can &= paint(n - w2, n - h2, w2, h2, ord[1] + 1);
if (!can) continue;
for (int t = 0; t < n; t++)
for (int c = 0; c < n; c++) {
if (!board[t][c]) dfs(t, c, ord[2] + 1);
}
if (cnt == xx[ord[2]] * yy[ord[2]] &&
(mxx - mnx + 1) * (mxy - mny + 1) == cnt) {
output();
}
}
}
}
} while (next_permutation(ord.begin(), ord.end()));
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> xx[0] >> yy[0] >> xx[1] >> yy[1] >> xx[2] >> yy[2];
for (int i = 0; i < 3; i++) {
tot[i] = xx[i] * yy[i];
sum += tot[i];
}
n = -1;
for (int i = 1; i <= 300; i++) {
if (i * i == sum) {
n = i;
break;
}
}
if (n == -1) {
cout << -1;
exit(0);
}
for (int i = 0; i < 3; i++) {
if (max(xx[i], yy[i]) > n) {
cout << -1;
exit(0);
}
}
can();
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
int n, w, t1[N], t2[N], cont[N];
set<pair<int, int> > s1, s2;
long long ans = 0;
void take1(int i, int a) {
ans += a;
s1.erase(pair<int, int>(a, i));
if (!cont[i]) {
s1.insert(pair<int, int>(t2[i] - t1[i], i));
s2.erase(pair<int, int>(t2[i], i));
}
cont[i]++;
w--;
}
void take2(int i) {
ans += t2[i];
cont[i] = 2;
s2.erase(pair<int, int>(t2[i], i));
s1.erase(pair<int, int>(t1[i], i));
w -= 2;
}
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> t1[i] >> t2[i];
s1.insert(pair<int, int>(t1[i], i));
s2.insert(pair<int, int>(t2[i], i));
}
while (w) {
if ((w & 1) || s1.size() == 1 || s2.size() == 0) {
pair<int, int> p = *s1.begin();
take1(p.second, p.first);
} else {
pair<int, int> p1 = *s1.begin();
pair<int, int> p2 = *++s1.begin();
pair<int, int> p3 = *s2.begin();
if (p1.first + p2.first <= p3.first) {
take1(p1.second, p1.first);
take1(p2.second, p2.first);
} else {
take2(p3.second);
}
}
}
cout << ans << endl;
string s = "";
for (int i = 0; i < n; i++) s += '0' + cont[i];
cout << s << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main()
{
int A, B, C, D;
while(cin >> A >> B >> C >> D, A || B || C || D) {
cout << max(0, (B * C - A + D - 1) / D) << endl;
}
return 0;
} | 0 |
#include<vector>
#include<algorithm>
#include<iostream>
#include<utility>
#include<climits>
using namespace std;
class LCA{
int n;
std::vector<int> _depth,idx;
static int calcsize(int n){
int res=1;
while(res<n)res<<=1;
return res;
}
int minimum(int a,int b,int k,int l,int r)const{
if(r<=a||b<=l)return _depth.size()-1;
if(a<=l&&r<=b)return idx[k];
else{
int vl=minimum(a,b,k*2+1,l,(l+r)/2);
int vr=minimum(a,b,k*2+2,(l+r)/2,r);
return _depth[vl]<_depth[vr]?vl:vr;
}
}
void buildRMQ(){
n=calcsize(_depth.size());
idx.resize(2*n-1);
for(int i=0;i<(int)_depth.size();i++)idx[n-1+i]=i;
for(int i=_depth.size();i<n;i++)idx[n-1+i]=_depth.size();
_depth.push_back(INT_MAX);
for(int i=n-2;i>=0;i--){
idx[i]=_depth[idx[i*2+1]]<_depth[idx[i*2+2]]?idx[i*2+1]:idx[i*2+2];
}
}
std::vector<int> eulertour;
std::vector<int> in;
void dfs(const std::vector<int> edge[],int d,int u){
in[u]=eulertour.size();
eulertour.push_back(u);
_depth.push_back(d);
for(int i=0;i<edge[u].size();i++){
dfs(edge,d+1,edge[u][i]);
eulertour.push_back(u);
_depth.push_back(d);
}
}
public:
LCA(const std::vector<int> edge[],int n,int root):in(n){
dfs(edge,1,root);
eulertour.push_back(root);
_depth.push_back(0);
buildRMQ();
}
int query(int u,int v)const{//uとvの最小共通祖先
if(u==v)return u;
if(in[u]>in[v])std::swap(u,v);
return eulertour[minimum(in[u], in[v],0,0,n)];
}
int depth(int u)const{//rootの深さが1
return _depth[in[u]];
}
};
vector<int> edge[100000];
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
int k,v;
cin>>k;
for(int j=0;j<k;j++){
cin>>v;
edge[i].push_back(v);
}
}
LCA lca(edge,n,0);
int q,u,v;
cin>>q;
for(int i=0;i<q;i++){
cin>>u>>v;
cout<<lca.query(u,v)<<endl;
}
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 = 2e5 + 5;
long long r[N][5];
long long better(long long x, long long y) {
long long cnt = 0;
for (long long i = 0; i < 5; i++) {
if (r[x][i] < r[y][i]) cnt++;
}
return (cnt >= 3);
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 5; j++) {
cin >> r[i][j];
}
}
long long best = 0;
for (long long i = 1; i < n; i++) {
if (better(i, best)) {
best = i;
}
}
bool ok = 1;
for (long long i = 0; i < n; i++) {
if (i == best) continue;
if (!better(best, i)) best = -2;
}
cout << best + 1 << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast")
using namespace std;
const int inf = 2e9 + 7;
const long long INF = INT64_MAX;
double eps = 1e-6;
const int mod = 998244353;
const int N = 1e3 + 10;
const double pi = acos(-1.0);
long double res;
double dp[N][N];
double work(int w, int b) {
if (w < 0 || b < 0) return 0;
double& now = dp[w][b];
if (now) return now;
if (!w) {
return now = 0;
}
if (!b) {
return now = 1;
}
long double sum = b + w, tmp;
now += w / sum;
tmp = b / sum;
b--;
sum--;
if (b) {
tmp *= b / sum;
b--;
sum--;
now += tmp * ((w / sum) * work(w - 1, b) + (b / sum) * work(w, b - 1));
}
return now;
}
int main() {
int w, b;
cin >> w >> b;
work(w, b);
cout << fixed << setprecision(10) << dp[w][b];
}
| 4 |
// Do you knOW what it feels like?
// To be TorTured by your own MinD?
// I don't wanna feel the PAIN.
// I BeG you to KILL me, pleASE...
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("Os")
#define F first
#define S second
#define pb push_back
#define SZ(x) (ll)(x.size())
#define all(x) x.begin(),x.end()
typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const ll maxn=1e5+10, lg=17, mod=1e9+7, inf=1e18;
const int S=200005,M=1e9+7;
int n,x,y,c,w,m[S],f,s,d,i;
vector<int> G[S];
long long fc[S]={1},iv[S],k,b,a=1;
int main(){
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
cin>>n>>x>>y;
fill(m,m+n,M);
for(i=0;i<n;i++){
cin>>c>>w;
G[--c].push_back(w);
m[c]=min(m[c],w);
if(c!=f){
if(w<m[f]){
s=f;f=c;
}else if(w<m[s])s=c;
}
fc[i+1]=fc[i]*(i+1)%M;
}
for(iv[n]=1,k=M-2,b=fc[n];k;k/=2,(b*=b)%=M)if(k&1)(iv[n]*=b)%=M;
for(i=n;i>0;i--)iv[i-1]=iv[i]*i%M;
for(i=0;i<n;i++)if(y-m[f]>=m[i]){
w=max(y-m[f==i?s:f],x-m[i]);c=0;
for(int t:G[i])if(t<=w)c++;
d+=c;
a=a*fc[d]%M*iv[d-c]%M*iv[c]%M;
}
cout<<a;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
map<int, set<pair<int, int>>> subs;
string s1, s2;
bool mem_can[2][50 + 1][50 + 1][26];
bool in_mem_can[2][50 + 1][50 + 1][26];
bool can(bool one, int s, int e, int c) {
bool& ans = mem_can[one][s][e][c];
if (not in_mem_can[one][s][e][c]) {
if (s == e) {
ans = (one ? s1 : s2)[s] == c;
} else {
ans = false;
for (auto p : subs[c]) {
for (int k = s; k < e; k++) {
ans |= can(one, s, k, p.first) and can(one, k + 1, e, p.second);
}
}
}
in_mem_can[one][s][e][c] = true;
}
return ans;
}
int mem[50 + 1][50 + 1];
int opt(int i, int j) {
int& ans = mem[i][j];
if (ans == -1) {
if (i == 0 and j == 0) {
ans = 0;
} else {
ans = 100;
for (int a = 1; a <= i; a++) {
for (int b = 1; b <= j; b++) {
for (int c = 0; c < 26; c++) {
if (can(1, a, i, c) and can(0, b, j, c)) {
ans = min(ans, 1 + opt(a - 1, b - 1));
}
}
}
}
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s1 >> s2;
for (char& c : s1) {
c -= 'a';
}
for (char& c : s2) {
c -= 'a';
}
s1.insert(0, " ");
s2.insert(0, " ");
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string sub;
cin >> sub;
for (char& c : sub) {
c -= 'a';
}
if (not subs.count(sub[0])) {
subs[sub[0]] = set<pair<int, int>>();
}
subs[sub[0]].insert({sub[3], sub[4]});
}
memset(in_mem_can, false, sizeof in_mem_can);
memset(mem, -1, sizeof mem);
int ans = opt(s1.length() - 1, s2.length() - 1);
cout << (ans >= 100 ? -1 : ans) << '\n';
return 0;
}
| 5 |
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define endl '\n'
const int N=5010;
const ll mod=1000000007;
ll a[N];
ll c[N];
ll dp[N][N];
void solve(){
int n,k,q;cin>>n>>k>>q;
for (int i=1;i<=n;i++) cin>>a[i];
for (int i=1;i<=n;i++) dp[0][i]=1ll;
for (int i=1;i<=k;i++){
for (int j=1;j<=n;j++){
dp[i][j]=(dp[i-1][j-1]+dp[i-1][j+1])%mod;
}
}
for (int i=1;i<=n;i++){
for (int j=0;j<=k;j++){
c[i]+=dp[j][i]*dp[k-j][i];
c[i]%=mod;
}
}
ll res=0ll;
for (int i=1;i<=n;i++){
res+=a[i]*c[i];
res%=mod;
}
for (int i=1;i<=q;i++){
int ind,x;cin>>ind>>x;
res+=mod-a[ind]*c[ind]%mod;
a[ind]=x;
res+=a[ind]*c[ind];
res%=mod;
cout<<res<<endl;
}
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt=1;
while (tt--){
solve();
}
return 0;
}
| 4 |
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n, team[101] = { 0 }, name[100] , a, b, c, d, hoz, iya;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
name[i]=1;
for (int i = 1; i <= n*(n - 1) / 2; i++)
{
cin >> a >> b >> c >> d;
if (c > d)
team[a] += 3;
else if (c == d)
{
team[a]++;
team[b]++;
}
else
team[b] += 3;
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
if (team[i] < team[j])
{
name[i]++;
}
}
}
for (int i = 1; i <= n; i++)
cout << name[i] << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long mod = (1e+9) + 7;
const long long sz = 2e5 + 9;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b, long long m = mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
b = b >> 1;
a = (a * a) % m;
}
return res;
}
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s[2];
cin >> s[0] >> s[1];
long long row = 0;
long long i;
for (i = 0; i < n; i++) {
if (s[row][i] >= '3') {
if (s[row ^ 1][i] <= '2')
break;
else
row ^= 1;
}
}
if (i == n && row == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
signed main() {
unordered_map<char, int>a;
string b;
cin >> b;
for (char c:b) {
a[c]++;
}
for (char d = 'a'; d <= 'z'; d++) {
if (a[d] & 1) {
puts("No");
return 0;
}
}
puts("Yes");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
string ans, s;
int len, L;
inline void check(int y, int m, int d) {
string res = "";
for (int i = 1; i <= 4; ++i) {
res += char(y % 10 + '0');
y /= 10;
}
res += '-';
for (int i = 1; i <= 2; ++i) {
res += char(m % 10 + '0');
m /= 10;
}
res += '-';
for (int i = 1; i <= 2; ++i) {
res += char(d % 10 + '0');
d /= 10;
}
reverse(res.begin(), res.end());
if (s.find(res) == string::npos) return;
int book = 0;
for (int i = 0; i < L; ++i) {
if (s.substr(i, 10) == res) {
book++;
if (book > len) {
len = book;
ans = res;
}
}
}
}
int main() {
cin >> s;
L = s.size();
for (int y = 2013; y <= 2015; ++y) {
for (int m = 1; m <= 12; ++m) {
for (int d = 1; d <= mon[m]; ++d) {
check(y, m, d);
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bitset<1 << 17> bad = 0;
bitset<1 << 17> badnw = 0;
int n, p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
vector<vector<int> > a(p, vector<int>(p));
string s;
cin >> s;
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> a[i][j];
vector<vector<int> > f(p);
vector<vector<int> > pf(n + 1, vector<int>(p, 0));
for (int i = 1; i <= n; i++) {
pf[i] = pf[i - 1];
pf[i][s[i - 1] - 'a']++;
f[s[i - 1] - 'a'].push_back(i - 1);
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (!a[i][j]) {
badnw = 0;
badnw.flip();
int next = 0;
for (int c = 0; c < f[i].size(); c++) {
while (next < f[j].size() && f[j][next] <= f[i][c]) next++;
if (next == f[j].size()) continue;
int mask = (1 << p) - 1;
bool good = true;
for (int k = 0; k < p; k++) {
if (pf[f[j][next]][k] - pf[f[i][c] + 1][k]) {
mask ^= (1 << k);
good &= (i != k && j != k);
}
}
if (good) {
badnw[mask] = 0;
}
}
for (int m = (1 << p) - 1; m >= 0; m--) {
if (!badnw[m]) {
for (int k = 0; k < p; k++) {
if (j != k && i != k && (m & (1 << k))) badnw[m ^ (1 << k)] = 0;
}
}
}
badnw.flip();
bad |= badnw;
}
}
}
bitset<1 << 17> dp = 0;
dp[(1 << p) - 1] = 1;
int ans = n;
for (int i = (1 << p) - 2; i >= 0; i--) {
if (bad[i]) {
continue;
}
for (int add = 0; add < p; add++) {
if (!(i & (1 << add))) {
dp[i] = dp[i] | dp[i | (1 << add)];
}
}
if (dp[i]) {
int siz = 0;
for (int have = 0; have < p; have++) {
if ((1 << have) & i) siz += f[have].size();
}
ans = min(ans, siz);
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void swapi(int *a, int *b) {
int temp;
temp = *a;
*a = *b;
*b = temp;
}
void swapc(char *a, char *b) {
char temp;
temp = *a;
*a = *b;
*b = temp;
}
template <typename T>
void fscan(T &x) {
x = 0;
bool neg = 0;
register T c = getchar();
if (c == '-') neg = 1, c = getchar();
while ((c < 48) || (c > 57)) c = getchar();
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x << 3) + (x << 1) + (c & 15);
if (neg) x *= -1;
}
template <typename T>
void fprint(T n) {
bool neg = 0;
if (n < 0) n *= -1, neg = 1;
char snum[65];
int i = 0;
do {
snum[i++] = n % 10 + '0';
n /= 10;
} while (n);
--i;
if (neg) putchar('-');
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i, min, last, min1;
cin >> n;
int v[n];
for (i = 0; i < n; i++) {
cin >> v[i];
}
min = v[0];
for (i = 0; i < n; i++) {
if (v[i] < min) min = v[i];
}
for (i = 0; i < n; i++) {
if (v[i] == min) {
last = i;
break;
}
}
min1 = n;
for (i = last + 1; i < n; i++) {
if (v[i] == min) {
if (i - last < min1) min1 = i - last;
last = i;
}
}
cout << min1 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, a;
cin >> n;
vector<long long> v;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
vector<vector<long long>> ans(n + 1);
set<int> s;
set<int> sind;
for (int i = 1; i <= n; i++) {
long long max = 0, ind2;
for (int j = 0; j < n; j++) {
if (v[j] > max && sind.find(j) == sind.end()) {
max = v[j];
ind2 = j;
}
}
s.insert(ind2);
sind.insert(ind2);
for (int j : s) ans[i].push_back(v[j]);
}
cin >> m;
long long k, pos;
for (int i = 0; i < m; i++) {
cin >> k >> pos;
cout << ans[k][pos - 1] << endl;
}
}
| 2 |
#include <iostream>
#include <vector>
using namespace std;
int data[100100];
int main(void)
{
int n, L;
cin >> n >> L;
for (int i = 0; i < n; i++){
cin >> data[i];
}
if (n == 1) {
cout << L - data[0] << endl;
return 0;
}
vector <int> a;
bool flag = ((data[0] < data[1]) ? true : false);
for (int i = 1; i < n; i++){
if (flag && data[i] < data[i - 1]) {
a.push_back(i-1);
flag = false;
}
if (!flag && data[i - 1] < data[i]){
a.push_back(i-1);
flag = true;
}
// cout << "*" << i-1 << " " << i << endl;
}
a.push_back(100550);
int res = 0, tmp = 0, cnt = 0;
for (int i = 0; i < n; i++){
tmp += (L - data[i]);
//cout << L-data[i] << " ";
if (i == a[cnt]){
//cout << tmp << endl;
cnt++;
res = max(res, tmp);
tmp = (L - data[i]);
}
}
res = max(res, tmp);
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[100000];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int A = 0, D = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 'A') {
A++;
}
if (a[i] == 'D') {
D++;
}
}
if (A > D) {
cout << "Anton";
}
if (A < D) {
cout << "Danik";
}
if (A == D) {
cout << "Friendship";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int INF=1001001001;
int N;
int t[10000];
int dp[2][5010][2];
int main(){
cin>>N;
for(int i=0;i<N-1;i++)cin>>t[i];
fill_n(**dp,2*5010*2,INF);
dp[0][0][0]=dp[0][1][1]=0;
for(int i=0;i<N-1;i++){
for(int j=0;j<=N/2;j++){
dp[(i+1)&1][j][0]=min(dp[i&1][j][0],dp[i&1][j][1]+t[i]);
if(j)dp[(i+1)&1][j][1]=min(dp[i&1][j-1][0]+t[i],dp[i&1][j-1][1]);
}
for(int j=0;j<=N/2;j++){
dp[i&1][j][0]=dp[i&1][j][1]=INF;
}
}
cout<<min(dp[(N-1)&1][N/2][0],dp[(N-1)&1][N/2][1])<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double clf = 1e-8;
const int MMAX = 0x7fffffff;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};
ostream &operator<<(ostream &out, pair<int, int> &p) {
out << p.first << " " << p.second;
}
istream &operator>>(istream &in, pair<int, int> &p) {
in >> p.first >> p.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long c, num;
cin >> c >> num;
long long t1 = num / c, t2 = num % c;
cout << t1 * t1 * (c - t2) + (t1 + 1) * (t1 + 1) * t2 << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int a,b;
int main()
{
cin>>a>>b;
if(a%2&&b%2) cout<<"Odd";
else cout<<"Even";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a;
cin >> b;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < a.size(); i += 2) {
int x, y;
if (a[i] == '8')
x = 1;
else if (a[i] == '(')
x = 0;
else if (a[i] == '[')
x = 2;
if (b[i] == '8')
y = 1;
else if (b[i] == '(')
y = 0;
else if (b[i] == '[')
y = 2;
if (x == 0) {
if (y == 1)
cnt1++;
else if (y == 2)
cnt2++;
} else if (x == 1) {
if (y == 0)
cnt2++;
else if (y == 2)
cnt1++;
} else if (x == 2) {
if (y == 0)
cnt1++;
else if (y == 1)
cnt2++;
}
}
if (cnt1 == cnt2)
cout << "TIE";
else
cout << (cnt1 > cnt2 ? "TEAM 1 WINS" : "TEAM 2 WINS");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 5;
long long dat[MAXN], cur;
int p[MAXN], s[MAXN];
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
int main() {
int n = read(), c = read();
for (int i = 1; i <= n; i++) p[i] = read();
for (int i = 1; i <= n; i++) cur += (s[i] = read());
for (int i = 1; i <= n; i++) dat[i] = p[i] + 1ll * i * c - s[i];
long long ans = cur;
sort(dat + 1, dat + n + 1);
for (int i = 1; i <= n; i++) {
long long d = dat[i] - 1ll * c * i;
cur += d, ans = min(ans, cur);
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<functional>
#include<map>
using namespace std;
int main() {
int a;
cin >> a;
for (int b = 0; b < a; b++) {
string c; cin >> c;
if ((c.length() & 1)==0&&c.length()>=6) {
if (c[0] == '>'&&c[1] == '^'&&c[c.length() - 1] == '~'&&c[c.length() - 2] == '~') {
bool e = true;
for (int d = 2; d < c.length() - 2; d += 2) {
if (c[d] != 'Q' || c[d + 1] != '=')e = false;
}
if (e) {
puts("B");
continue;
}
}
if (c[0] == '>'&&c[1] == '\''&&c[c.length() - 1] == '~') {
bool k = true;
for (int j = 2; j < c.length() - 1; j++) {
if (j == c.length() / 2) {
if (c[j] != '#')k = false;
}
else {
if (c[j] != '=')k = false;
}
}
if (k) { puts("A"); continue; }
}
}
puts("NA");
}
} | 0 |
#include <iostream>
using namespace std;
class rout{
char t;
public:
rout(){
t='A';
}
void next(char n){
if(t == 'A'){
if(n == '1'){
t = 'Y';
}else{
t = 'X';
}
}else if(t == 'X'){
if(n == '1'){
t = 'Z';
}else{
t = 'E';
}
}else if(t == 'Y'){
if(n == '1'){
t = 'E';
}else{
t = 'X';
}
}else if(t == 'Z'){
if(n == '1'){
t = 'B';
}else{
t = 'W';
}
}else if(t == 'W'){
if(n == '1'){
t = 'Y';
}else{
t = 'B';
}
}else if(t == 'B'){
if(n == '1'){
t = 'X';
}else{
t = 'Y';
}
}
}
bool isOk(){
if(t=='B')
return true;
return false;
}
};
int main()
{
char str[101];
while(cin >> str){
if(str[0] == '#'){
break;
}
rout r;
int i = 0;
while(str[i] != '\0'){
r.next(str[i]);
i++;
}
if(r.isOk()){
cout << "Yes\n";
}else{
cout << "No\n";
}
}
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <cstdlib>
using namespace std;
#define Rep(i,l,r) for (int i = (l); i <= (r); ++ i)
#define RepD(i,r,l) for (int i = (r); i >= (l); -- i)
#define RepG(i,x) for (int i = hd[x]; i; i = e[i].nxt)
#define mkp make_pair
#define fi first
#define se second
typedef long long ll;
typedef pair <ll, ll> pll;
const int N = 2e4+5;
const ll inf = 1e15+7;
int n, cnt = 1, hd[N], vis[N], cur[N], S, T, qu[N*100];
ll d[N];
struct edge {int tt, nxt, c, f, w;} e[N<<1];
void addedge (int u, int v, int c, int w) {
e[++ cnt] = (edge){v,hd[u],c,0,w}, hd[u] = cnt;
e[++ cnt] = (edge){u,hd[v],0,0,-w}, hd[v] = cnt;
}
bool spfa () {
int fr = 1, ta = 0;
Rep(i,1,T) vis[i] = 0, d[i] = -inf, cur[i] = hd[i];
d[S] = 0, qu[++ ta] = S, vis[S] = 1;
while (fr<=ta) {
int x = qu[fr ++]; vis[x] = 0;
RepG(i,x) {
int v = e[i].tt, cl = e[i].c-e[i].f;
if (cl && d[v]<d[x]+e[i].w) {
d[v] = d[x]+e[i].w;
if (!vis[v]) vis[v] = 1, qu[++ ta] = v;
}
}
}
return d[T]>-inf;
}
ll dfs (int x, ll ff, ll &cst) {
vis[x] = 1;
if (x==T || !ff) return ff;
ll res = 0;
for (int &i = cur[x]; i; i = e[i].nxt) {
int v = e[i].tt, cl = e[i].c-e[i].f;
if (!vis[v] && cl && d[v]==d[x]+e[i].w) {
ll fl = dfs (v, min (ff, 1ll*cl), cst);
e[i].f += fl, e[i^1].f -= fl;
res += fl, ff -= fl, cst += e[i].w*fl;
}
if (!ff) break;
}
return res;
}
ll mcfl () {
ll cst = 0;
while (spfa ()) dfs (S, inf, cst);
return cst;
}
int main () {
scanf ("%d", &n);
S = 2*n+5, T = 2*n+6;
Rep(i,1,n) {
int x, y, c;
scanf ("%d%d%d", &x, &y, &c);
addedge (S, i, c, 0);
addedge (i, 2*n+1, c, x+y);
addedge (i, 2*n+2, c, x-y);
addedge (i, 2*n+3, c, y-x);
addedge (i, 2*n+4, c, -x-y);
}
Rep(i,1,n) {
int x, y, c;
scanf ("%d%d%d", &x, &y, &c);
addedge (n+i, T, c, 0);
addedge (2*n+1, n+i, c, -x-y);
addedge (2*n+2, n+i, c, y-x);
addedge (2*n+3, n+i, c, x-y);
addedge (2*n+4, n+i, c, x+y);
}
printf ("%lld\n", mcfl ());
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long l, r, k;
long long cnt[20][1 << 10][2];
long long sum[20][1 << 10][2];
long long power[20];
long long calc(string s) {
memset(cnt, 0, sizeof(cnt));
memset(sum, 0, sizeof(sum));
cnt[0][0][1] = 1;
int len = s.size();
for (int i = 0; i < len; ++i)
for (int mask = 0; mask < (1 << 10); ++mask) {
for (int digit = (i == 0 ? 1 : 0); digit <= 9; ++digit) {
cnt[i + 1][mask | (1 << digit)][0] += cnt[i][mask][0];
sum[i + 1][mask | (1 << digit)][0] +=
(sum[i][mask][0] + digit * power[len - i - 1] * cnt[i][mask][0]) %
mod;
if (sum[i + 1][mask | (1 << digit)][0] >= mod)
sum[i + 1][mask | (1 << digit)][0] -= mod;
}
for (int digit = (i == 0 ? 1 : 0); digit < s[i] - '0'; ++digit) {
cnt[i + 1][mask | (1 << digit)][0] += cnt[i][mask][1];
sum[i + 1][mask | (1 << digit)][0] +=
(sum[i][mask][1] + digit * power[len - i - 1] * cnt[i][mask][1]) %
mod;
if (sum[i + 1][mask | (1 << digit)][0] >= mod)
sum[i + 1][mask | (1 << digit)][0] -= mod;
}
int digit = s[i] - '0';
cnt[i + 1][mask | (1 << digit)][1] += cnt[i][mask][1];
sum[i + 1][mask | (1 << digit)][1] +=
(sum[i][mask][1] + digit * power[len - i - 1] * cnt[i][mask][1]) %
mod;
if (sum[i + 1][mask | (1 << digit)][1] >= mod)
sum[i + 1][mask | (1 << digit)][1] -= mod;
}
long long res = 0;
for (int mask = 0; mask < (1 << 10); ++mask)
if (__builtin_popcount(mask) <= k &&
(cnt[len][mask][0] || cnt[len][mask][1])) {
res += sum[len][mask][0];
if (res >= mod) res -= mod;
res += sum[len][mask][1];
if (res >= mod) res -= mod;
}
return res;
}
long long solve(long long n) {
int len = to_string(n).size();
long long res = 0;
for (int i = 1; i < len; ++i) res += calc(string(i, '9'));
res += calc(to_string(n));
return res;
}
int main() {
power[0] = 1;
for (int i = 1; i < 20; ++i) power[i] = power[i - 1] * 10;
cin >> l >> r >> k;
cout << (solve(r) - solve(l - 1) + mod) % mod;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
string s;
unsigned short int n, sf = 0, seatle = 0;
cin >> n >> s;
for (int i = 0; i < n - 1; ++i) {
if (s[i] == 'S' && s[i + 1] == 'F')
sf++;
else if (s[i] == 'F' && s[i + 1] == 'S')
seatle++;
}
if (sf > seatle)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 1e5 + 5;
int n, m;
int f[51][N];
unsigned long long sum[N];
int l[N], r[N];
unsigned long long g[N];
void add(unsigned long long &a, unsigned long long b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
cin >> n >> m;
for (int i = (1); i < (n + 1); i++) scanf("%d%d", &l[i], &r[i]);
for (int gc = (1); gc < (m + 1); gc++) {
int tot = m / gc;
for (int i = (1); i < (tot + 1); i++) f[1][i] = 0, sum[i] = 0;
for (int i = ((l[1] + gc - 1) / gc); i < (r[1] / gc + 1); i++) f[1][i] = 1;
for (int i = (1); i < (tot + 1); i++) sum[i] = (sum[i - 1] + f[1][i]) % mod;
for (int i = (2); i < (n + 1); i++) {
int mi = (l[i] + gc - 1) / gc, mx = r[i] / gc;
if (mi > mx) {
sum[tot] = 0;
break;
}
for (int j = (mi); j < (tot + 1); j++) {
if (j <= mx)
f[i][j] = sum[j - mi];
else
f[i][j] = (sum[j - mi] - sum[j - mx - 1] + mod) % mod;
}
sum[0] = 0;
for (int j = (1); j < (tot + 1); j++)
sum[j] = (sum[j - 1] + f[i][j]) % mod;
}
g[gc] = sum[tot];
}
for (int i = (m + 1) - 1; i >= (1); i--) {
for (int j = i + i; j <= m; j += i) g[i] = (g[i] - g[j] + mod) % mod;
}
printf("%lld\n", g[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
int n, ptr = 0;
map<pair<int, int>, int> ans;
map<vector<int>, int> mp;
vector<int> G[N];
int dfs(int v, int P) {
if (ans.find(make_pair(v, P)) != ans.end()) return ans[make_pair(v, P)];
vector<int> adj;
for (auto u : G[v]) {
if (u == P) continue;
adj.push_back(dfs(u, v));
}
sort((adj).begin(), (adj).end());
if (mp.find(adj) == mp.end()) {
mp[adj] = ++ptr;
}
ans[make_pair(v, P)] = mp[adj];
return mp[adj];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
set<int> tot;
for (int i = 1; i <= n; i++) {
if ((int)G[i].size() < 4) {
tot.insert(dfs(i, 0));
}
}
printf("%d", (int)tot.size());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
}
for (int i = 1; i <= n; i++) {
cin >> b;
}
cout << "Karen";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, tt, a[2501][2501];
bitset<2501> bit[2501], cnt;
pair<int, pair<int, int> > b[2501 * 2501];
void no() {
printf("NOT MAGIC\n");
exit(0);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
scanf("%d", a[i] + j), b[++tt] = make_pair(a[i][j], make_pair(i, j));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] != a[j][i]) no();
for (int i = 1; i <= n; i++)
if (a[i][i]) no();
sort(b + 1, b + tt + 1);
reverse(b + 1, b + tt + 1);
for (int i = 1, j = 1; i <= tt; i = j) {
while (b[j].first == b[i].first && j <= tt)
bit[b[j].second.first][b[j].second.second] = 1, j++;
for (int k = i; k < j; k++) {
cnt = bit[b[k].second.first] | bit[b[k].second.second];
if (cnt.count() != n) no();
}
}
printf("MAGIC\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
inline long long unsigned turn(string s) {
long long unsigned ans = 0;
for (int i = 0; i < (int)s.size(); i++) {
ans *= 10;
ans += s[i] - '0';
}
return ans;
}
int main() {
long long unsigned k, f, t;
string s;
cin >> k >> s;
f = turn(s);
if (k == f && !f && s.size() == 1) {
cout << "OK" << endl;
return 0;
}
if (s[0] == '0') {
cout << "WRONG_ANSWER" << endl;
return 0;
}
while (k) {
a[k % 10]++;
k /= 10;
}
int i = 1;
while (!a[i]) i++;
t = i;
a[i]--;
for (i = 0; i < 10; i++)
while (a[i]) {
t *= 10;
t += i;
a[i]--;
}
if (t == f)
cout << "OK" << endl;
else
cout << "WRONG_ANSWER" << endl;
return 0;
}
| 2 |
#include<iostream>
#include<string>
using namespace std;
int n;
string s;
int c[101];
int l,r,x;
int main(){
cin>>n>>s;
for(int i=0;i<n;i++){
if(s[i]=='(') l++;
else r++;
c[i] = l-r;
if(x>c[i]) x = c[i];
}
for(int i=0;i<-x;i++)
s = '(' +s;
for(int i=0;i<c[n-1]-x;i++)
s+= ')';
cout<<s<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9;
class union_find {
public:
union_find(int N)
: par(N, -1)
{}
int root(int x) {
return par[x] < 0 ? x : par[x] = root(par[x]);
}
bool unite(int x, int y) {
x = root(x), y = root(y);
if(x == y) {
return false;
}
if(par[x] < par[y]) {
par[x] += par[y];
par[y] = x;
} else {
par[y] += par[x];
par[x] = y;
}
return true;
}
int size(int x) {
return -par[root(x)];
}
private:
vector<int> par;
};
int main() {
int N, W, H;
cin >> N >> W >> H;
vector<vector<int>> sx(W), sy(H);
union_find uf(N);
bool f = false;
for(int i=0; i<N; ++i) {
int x, y;
cin >> x >> y;
x--; y--;
sx[x].push_back(i);
sy[y].push_back(i);
f |= x == 0 || x == W-1 || y == 0 || y == H-1;
}
for(int i=0; i<W; ++i) {
for(int j=0; j<(int)sx[i].size()-1; ++j) {
uf.unite(sx[i][j], sx[i][j+1]);
}
}
for(int i=0; i<H; ++i) {
for(int j=0; j<(int)sy[i].size()-1; ++j) {
uf.unite(sy[i][j], sy[i][j+1]);
}
}
int res = 0;
int cnt = 0;
for(int i=0; i<N; ++i) {
if(uf.root(i) == i) {
res += uf.size(i) - 1;
cnt++;
}
}
if(cnt != 1) {
res += cnt * 2 - 1 - f;
}
cout << res << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const int MAXN = 2 * 1e5;
int main() {
int n;
cin >> n;
int mini = inf;
int maxi = -inf;
int del = 0;
bool f = true;
for (int i = 0; i < n; i++) {
int c, d;
cin >> c >> d;
if (d == 1) {
if (maxi >= del) f = false;
mini = min(mini, del);
} else {
if (mini <= del) f = false;
maxi = max(maxi, del);
}
del = del + c;
}
if (!f) {
cout << "Impossible";
return 0;
}
if (maxi == -inf)
cout << "Infinity";
else {
cout << 1899 - maxi + del;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
multiset<int> a, b;
int ha[100005], hb[100005];
void fmain() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%d", ha + i);
for (int(i) = 0; (i) < (int)(n); (i)++) hb[i] = ha[i];
sort(hb, hb + n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
if (ha[i] != hb[i]) {
auto it = b.find(ha[i]);
if (it == b.end())
a.insert(ha[i]);
else
b.erase(it);
it = a.find(hb[i]);
if (it == a.end())
b.insert(hb[i]);
else
a.erase(it);
}
if (a.empty() && b.empty()) k++;
}
printf("%d\n", k);
}
int main() {
fmain();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
multiset<int> s;
int main(){
int h, w, a, b;
cin >> h >> w;
for (int i = 0; i < w; i++)
m[i] = i, s.insert(0);
for (int i = 0; i < h; i++){
cin >> a >> b;
a--;
auto pos = m.lower_bound(a);
int mx = -1;
while (pos != m.end() && pos->first <= b){
mx = max(mx, pos->second);
int x = pos->first - pos->second;
s.erase(s.find(x));
m.erase(pos++);
}
if (mx != -1 && b < w){
s.insert(b - mx);
m[b] = mx;
}
cout << (s.empty() ? -1 : *s.begin() + i + 1) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
double Get_d(double a, double b) { return sqrt(a * a + b * b); }
int r, d, x, y, R, n;
int main() {
scanf("%d%d", &r, &d);
int ans = 0;
scanf("%d", &n);
while (n--) {
scanf("%d%d%d", &x, &y, &R);
double D = Get_d(x, y);
if (D - R >= r - d && D + R <= r) ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
int c1 = 0, c2 = 0, c3 = 0;
cin >> a >> b;
for (int i = 1; i <= 6; ++i) {
int m = abs(i - a);
int n = abs(i - b);
if (m == n)
c3++;
else if (m <= n)
c1++;
else
c2++;
}
cout << c1 << " " << c3 << " " << c2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long M = 205;
const long long INF = 1e17;
long long memo[N][M];
vector<long long> entra[N];
vector<long long> sale[N];
long long rang_coin[N];
long long rang_time[N];
long long calc_coin[N];
long long calc_time[N];
long long dp(long long pos, long long m, long long n) {
if (pos > n) {
return 0;
}
if (memo[pos][m] != INF) {
return memo[pos][m];
}
long long ans = INF;
if (m > 0) {
ans = min(ans, dp(pos + 1, m - 1, n));
}
ans = min(ans, dp(calc_time[pos] + 1, m, n) + calc_coin[pos]);
memo[pos][m] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
cout << fixed;
long long n, m, k, s, t, d, w;
cin >> n >> m >> k;
for (long long i = 0; i <= n + 1; i++) {
for (long long j = 0; j <= m + 1; j++) {
memo[i][j] = INF;
}
}
for (long long i = 0; i < k; i++) {
cin >> s >> t >> d >> w;
entra[s].push_back(i);
sale[t].push_back(i);
rang_time[i] = d;
rang_coin[i] = w;
}
multiset<pair<long long, long long> > ms;
multiset<pair<long long, long long> >::iterator it;
for (long long i = 1; i <= n; i++) {
ms.insert(make_pair(0, i));
for (long long j = 0; j < entra[i].size(); j++) {
ms.insert(make_pair(rang_coin[entra[i][j]], rang_time[entra[i][j]]));
}
it = ms.end();
it--;
calc_coin[i] = (*it).first;
calc_time[i] = (*it).second;
for (long long j = 0; j < sale[i].size(); j++) {
ms.erase(
ms.find(make_pair(rang_coin[sale[i][j]], rang_time[sale[i][j]])));
}
ms.erase(ms.find(make_pair(0, i)));
}
cout << dp(1, m, n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
const int A = 1e6 + 3;
const int inf = 1e9;
int n, qf, qb, ans, par[A], d[A], minPrime[A], qu[N];
vector<int> a[A];
int main() {
for (int i = 2; i * i < A; i++)
if (minPrime[i] == 0) {
for (int j = i * i; j < A; j += i)
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
for (int i = 2; i < A; i++)
if (minPrime[i] == 0) minPrime[i] = i;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, u = 0, v = 0;
cin >> x;
while (x != 1) {
int tmp = minPrime[x], cnt = 0;
while (x != 1 && x % tmp == 0) {
x /= tmp;
cnt++;
}
if (cnt % 2 == 0) continue;
if (u == 0)
u = tmp;
else
v = tmp;
}
if (u == 0 && v == 0) {
u = 1;
v = 1;
} else if (v == 0)
v = 1;
a[u].push_back(v);
a[v].push_back(u);
}
ans = inf;
minPrime[1] = 1;
for (int i = 1; i <= 1000; i++)
if (minPrime[i] == i) {
qf = qb = 0;
qu[0] = i;
par[i] = -1;
for (int j = 1; j < A; j++) d[j] = inf;
d[i] = 0;
while (qf <= qb) {
bool skp = true;
int u = qu[qf++];
for (int j = 0; j < a[u].size(); j++) {
int v = a[u][j];
if (d[v] == inf) {
d[v] = d[u] + 1;
par[v] = u;
qu[++qb] = v;
} else {
if (par[u] == v && skp) {
skp = false;
continue;
}
ans = min(ans, d[u] + d[v] + 1);
}
}
}
}
cout << (ans == inf ? -1 : ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long nInf = -1000000000;
const long long pInf = 1000000000;
const long long mod = 1000000007;
const int MAXN = 1000;
void getdata();
void preproc();
void solve();
int y11, y2, m1, m2, d1, d2;
int month[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int countdays(int y, int m, int d);
int main() {
int t = 1;
for (int i = 0; i < t; i++) {
getdata();
preproc();
solve();
}
return 0;
}
void getdata() {
scanf("%d:%d:%d", &y11, &m1, &d1);
scanf("%d:%d:%d", &y2, &m2, &d2);
}
void preproc() {}
void solve() {
int am1 = countdays(y11, m1, d1);
int am2 = countdays(y2, m2, d2);
printf("%d\n", abs(am1 - am2));
}
bool leap(int y) {
if (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) return true;
return false;
}
int countdays(int y, int m, int d) {
int count = 0;
for (int i = 0; i < y; i++) {
if (leap(i)) {
count += 366;
} else {
count += 365;
}
}
for (int i = 1; i < m; i++) {
if (i == 2 && leap(y)) count++;
count += month[i];
}
count += d;
return count;
}
| 2 |
#include<iostream>
using namespace std;
int main()
{
int n,k,sum=0,x;
cin>>n>>k;
for(int i=0;i<n;i++)
{
cin>>x;
if(x>=k)
sum++;
}
cout<<sum;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<long long> c(n);
vector<long long> v(n);
for (int i = 0; i < n; ++i) cin >> c[i] >> v[i];
vector<long long> g(k);
for (int i = 0; i < k; ++i) cin >> g[i];
g.push_back(0);
sort(g.begin(), g.end());
for (int i = 0; i < g.size() - 1; ++i) g[i] = g[i + 1] - g[i];
g[g.size() - 1] = s - g[g.size() - 1];
long long l = 1, r = INT_MAX;
while (l <= r) {
long long mid = (l + r) / 2;
bool flag = true;
long long min_time = 0;
for (int i = 0; i < g.size(); ++i) {
if (g[i] > mid) {
flag = false;
break;
}
if (g[i] * 2 <= mid)
min_time += g[i];
else {
min_time += g[i] * 2 - (mid - g[i]);
}
}
if (!flag || min_time > t)
l = mid + 1;
else
r = mid - 1;
}
int ans = -1;
for (int i = 0; i < n; ++i) {
if (v[i] >= l && (ans == -1 || c[i] < ans)) ans = c[i];
}
cout << ans;
return 0;
}
| 1 |
#include<iostream>
#include<iomanip>
int main(){
double a, b, c, d, e, f;
while (std::cin >> a >> b >> c >> d >> e >> f){
double x, y;
y = (a*f - c*d) / (a*e - b*d);
x = (c - b*y) / a;
std::cout << std::fixed << std::setprecision(3) << x << " " << y << std::endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
typedef long long ll;
const int MAX_N = 1e5+10;
int main() {
int n,m; cin>>n>>m;
vector<int> p(MAX_N), y(MAX_N);
vector<vector<int>> yd(MAX_N);
rep(i,m){
cin>>p[i]>>y[i];
p[i]--;
yd[p[i]].push_back(y[i]);
}
rep(i,n) sort(yd[i].begin(),yd[i].end());
rep(i,m){
vector<int> pp=yd[p[i]];
int num=lower_bound(pp.begin(), pp.end(), y[i])-pp.begin();
printf("%06d%06d\n", p[i]+1, num+1);
}
} | 0 |
#include<iostream>
using namespace std;
int main(){
int a, b;
int nl = 0;
for ( int i = 0; i < 7; i++ ){
cin >> a >> b;
cout << a - b << endl;
}
} | 0 |
#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
//#define int long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int w, h; cin >> w >> h&&w;) {
static char c[21][21];
int n = 1;
static int pi[11], pj[11];
rep(i, 0, h)rep(j, 0, w) {
cin >> c[i][j];
if (c[i][j] == '*') {
pi[n] = i;
pj[n] = j;
n++;
}
else if (c[i][j] == 'o')
pi[0] = i, pj[0] = j;
}
static const int di[] = { 1,0,-1,0 };
static const int dj[] = { 0,1,0,-1 };
static int d[11][21][21];
memset(d, 0x3f, sizeof(d));
rep(i, 0, n) {
d[i][pi[i]][pj[i]] = 0;
}
auto inrange = [&](int i, int j) { return i >= 0 && i < h && j >= 0 && j < w; };
rep(k, 0, n) {
using P = pair<int, int>;
queue<P> q;
q.push(P(pi[k], pj[k]));
for (int ci, cj; !q.empty();) {
tie(ci, cj) = q.front(); q.pop();
for (int i = 0; i < 4; i++) {
int ni = ci + di[i], nj = cj + dj[i];
if (!inrange(ni, nj))continue;
if (c[ni][nj] == 'x')continue;
if (d[k][ni][nj] != INF)continue;
d[k][ni][nj] = d[k][ci][cj] + 1;
q.emplace(ni, nj);
}
}
}
static int dp[1 << 11][11];
memset(dp, 0x3f, sizeof(dp));
dp[1][0] = 0;
dump(n);
for (int mask = 0; mask < (1 << n); mask++) {
rep(i, 0, n) {
rep(j, 0, n) {
if (mask >> j & 1)continue;
if (dp[mask][i] == INF || d[i][pi[j]][pj[j]] == INF)continue;
dump(mask);
chmin(dp[mask | (1 << j)][j], dp[mask][i] + d[i][pi[j]][pj[j]]);
}
}
}
int ans = INF;
rep(i, 0, n)
chmin(ans, dp[(1 << n) - 1][i]);
cout << (ans == INF ? -1 : ans) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long n, i, j, ar[100005];
int main() {
long long k;
scanf("%lld", &n);
scanf("%lld", &k);
for (long long i = 0; i < n; i++) scanf("%lld", &ar[i]);
long long cnt = 0;
i = 0, j = n - 1;
while (ar[i] <= k && i < n) {
cnt++;
i++;
}
if (i < n) {
while (ar[j] <= k && j >= 0) {
cnt++;
j--;
}
}
printf("%lld", cnt);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int &v : a) cin >> v;
vector<bool> mark(n, false);
for (int i = n - 2; i >= 0; i--)
for (int j = i; j < n - 1; j++) {
if (a[j + 1] < a[j] && !mark[j]) {
swap(a[j + 1], a[j]);
mark[j] = true;
}
}
for (int i : a) cout << i << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T first, T second) {
while (second > 0) {
first %= second;
swap(first, second);
}
return first;
}
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
template <typename T>
inline void input(T &a) {
static int ed;
a = 0;
while (!isdigit(ed = getchar()) && ed != '-') {
}
char neg = 0;
if (ed == '-') {
neg = 1;
ed = getchar();
}
while (isdigit(ed)) {
a = 10 * a + ed - '0';
ed = getchar();
}
if (neg) a = -a;
}
template <typename T = int>
inline T nxt() {
T res;
input(res);
return res;
}
mt19937 generator;
long long mod = 1000000123;
int main() {
int n = nxt();
int m = nxt();
int a[n];
int b[n];
for (int i = 0; i < n; ++i) {
a[i] = nxt();
b[i] = a[i];
}
sort(b, b + n);
int pos[n];
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(b, b + n, a[i]) - b;
pos[a[i]] = i;
}
while (m--) {
int first = a[nxt() - 1];
int l = nxt();
vector<int> order;
order.push_back(first);
while (1) {
int p1 = upper_bound(b, b + n, b[first] + l) - b - 1;
int delta = 0;
l -= b[p1] - b[first];
delta += b[p1] - b[first];
int p2 = lower_bound(b, b + n, b[p1] - l) - b;
l -= b[p1] - b[p2];
delta += b[p1] - b[p2];
if (p1 == p2) {
cout << pos[p1] + 1 << "\n";
break;
}
if (first == p2) {
l %= delta;
}
first = p2;
}
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,x,m;
cin>>n>>x;
int mn=x;
for(int i=0;i<n;i++){
cin>>m;
x-=m;
mn=min(mn,m);
}
cout<<n+x/mn<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
unsigned long long int i, j, k, a, b, n, k1, k2, count = 0, t, count1 = 0;
char ch[1000], ch1[1000];
scanf("%s %s", ch, ch1);
n = strlen(ch);
for (i = 0; i < n; i++) {
if (ch[i] == ch1[n - 1 - i]) count++;
}
if (count == n)
printf("YES");
else
printf("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
const int MX = 1e5 + 5;
int n;
int first[MX];
void upd(int p, int v) {
while (p < MX) {
first[p] += v;
p += p & -p;
}
}
int query(int p) {
int ret = 0;
while (p) {
ret += first[p];
p -= p & -p;
}
return ret;
}
struct Query {
int l, r, idx;
Query(int L, int R, int I) {
l = L;
r = R;
idx = I;
}
bool operator<(Query const& other) const { return (r < other.r); }
};
int gcd(int a, int b) {
if (a > b) return gcd(b, a);
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int k, q;
cin >> n;
set<pair<int, int> > slopes[n];
for (int i = 0; i < n; i++) {
cin >> k;
pair<int, int> a[k];
for (int j = 0; j < k; j++) cin >> a[j].first >> a[j].second;
for (int j = 0; j < k; j++) {
int dx = a[j].first - a[(j + k - 1) % k].first,
dy = a[j].second - a[(j + k - 1) % k].second;
int g = gcd(abs(dx), abs(dy));
slopes[i].insert(make_pair(dx / g, dy / g));
}
}
cin >> q;
vector<Query> queries;
int l, r;
for (int i = 0; i < q; i++) {
cin >> l >> r;
l--;
r--;
queries.push_back(Query(l, r, i));
}
sort(queries.begin(), queries.end());
int ql, qr;
map<pair<int, int>, int> curSlopes;
int ans[q];
map<pair<int, int>, int> last;
r = -1;
for (int i = 0; i < q; i++) {
ql = queries[i].l;
qr = queries[i].r;
while (r < qr) {
r++;
for (auto& a : slopes[r]) {
if (last[a]) upd(last[a], -1);
last[a] = r + 1;
upd(last[a], 1);
}
}
ans[queries[i].idx] = query(qr + 1) - query(ql);
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 5;
const int mod = 1e9 + 7;
int n, m;
int fac[N], invf[N];
inline int po(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
k >>= 1;
}
return res;
}
inline int C(int x, int y) {
if (x < y) return 0;
return 1ll * fac[x] * invf[y] % mod * invf[x - y] % mod;
}
long long row[N], ans[N];
int main() {
ios::sync_with_stdio(0);
int i, j;
fac[0] = 1;
for (i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
invf[N - 1] = po(fac[N - 1], mod - 2);
for (i = N - 2; i >= 0; i--) invf[i] = long long(i + 1) * invf[i + 1] % mod;
int iv3 = po(3, mod - 2);
cin >> n >> m;
n *= 3;
ans[0] = n / 3 + 1;
ans[1] = (long long(3 + n) * n / 6) % mod;
for (i = 0; i <= n; i++) row[i] = C(n + 1, i + 1);
for (i = 2; i <= n; i++) {
long long w =
row[i] + 2 * row[i - 1] + row[i - 2] - 3 * ans[i - 1] - ans[i - 2];
w = (w % mod + mod) % mod;
ans[i] = iv3 * w % mod;
}
while (m--) {
int x;
cin >> x;
cout << ans[x] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n];
unordered_map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]]++;
}
int maxVal = 0;
for (auto x : m) {
maxVal = max(maxVal, x.second);
}
cout << n - maxVal;
}
int main() { solve(); }
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.