solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string clown, acrobat;
int a[5][5];
int n;
int used[5555];
void foobar(int a, int b, int c, int d) {
for (int i = 0; i < n and a > 0; ++i) {
if (clown[i] == '1' and acrobat[i] == '1') {
printf("%d ", i + 1);
a--;
}
}
for (int i = 0; i < n and b > 0; ++i) {
if (clown[i] == '1' and acrobat[i] == '0') {
printf("%d ", i + 1);
b--;
}
}
for (int i = 0; i < n and c > 0; ++i) {
if (clown[i] == '0' and acrobat[i] == '1') {
printf("%d ", i + 1);
c--;
}
}
for (int i = 0; i < n and d > 0; ++i) {
if (clown[i] == '0' and acrobat[i] == '0') {
printf("%d ", i + 1);
d--;
}
}
}
int main() {
cin >> n;
cin >> clown >> acrobat;
for (int i = 0; i < n; ++i) {
a[clown[i] - '0'][acrobat[i] - '0']++;
}
for (int i = 0; i <= a[1][0]; i++)
for (int j = 0; j <= a[1][1]; j++) {
int right10 = a[1][0] - i;
int right11 = a[1][1] - j;
if (i + j > n / 2) continue;
if (i + j > a[0][1] + right11) continue;
if (right11 > i + j) continue;
int right01 = i + j - right11;
if (a[0][1] < right01) continue;
int left01 = a[0][1] - right01;
if (i + j + left01 > n / 2) continue;
int left00 = n / 2 - i - j - left01;
if (a[0][0] < left00) continue;
foobar(j, i, left01, left00);
return 0;
}
puts("-1");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
long long int sum = 1;
for (int i = 1;; i++) {
sum += pow(2, i);
if (n % sum == 0) {
cout << n / sum << endl;
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
pair<int, int> a[MAXN];
int n, p, q;
double ans = 1e20;
int sgn(long long x) {
if (x == 0) return 0;
if (x < 0)
return -1;
else
return 1;
}
long long cross(int p, int q, int r) {
return (long long)(a[q].first - a[p].first) * (-a[r].second + a[p].second) -
(long long)(a[r].first - a[p].first) * (-a[q].second + a[p].second);
}
int dir(int p, int q) { return sgn(cross(n + 1, p, q)); }
void work(int x, int y) {
long long ax = a[x].first, bx = -a[x].second, ay = a[y].first,
by = -a[y].second;
ans = min(ans,
((double)p * by - q * ay + q * ax - p * bx) / (ax * by - ay * bx));
}
int main() {
cin >> n >> p >> q;
a[0] = pair<int, int>(p, -q);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
a[i].second = -a[i].second;
}
a[n + 1] = pair<int, int>(0, 0);
sort(a + 1, a + n + 1);
vector<int> Q;
for (int i = 1; i <= n; i++) {
if (Q.size() < 2)
Q.push_back(i);
else {
while (Q.size() >= 2 && cross(Q[Q.size() - 1], Q[Q.size() - 2], i) <= 0)
Q.pop_back();
Q.push_back(i);
}
}
for (int i = 1; i < Q.size(); i++) {
if (dir(Q[i - 1], 0) != dir(Q[i], 0)) {
work(Q[i - 1], Q[i]);
}
}
for (int i = 1; i <= n; i++)
ans = min(ans, max((double)p / a[i].first, (double)q / -a[i].second));
printf("%.10lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, i, j, s1 = 0, s2 = 0, k, c = 0;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
long long b[n];
unordered_map<long long, long long> mp;
for (i = 0; i < n; i++) {
mp[a[i]]++;
}
for (auto i : mp) {
if (i.second >= 2) {
c = 1;
break;
}
}
if (c == 1)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
int st[maxn], fin[maxn];
bool check(string s) {
int k = s.length();
for (int i = 0; i < k / 2; i++) {
if (s[i] != s[k - i - 1]) return false;
}
return true;
}
int main() {
string s;
cin >> s;
int s1 = 0, s2 = 0;
int n = s.length();
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
if (check(s.substr(i, j - i + 1))) {
st[i]++;
s1++;
s2++;
fin[j]++;
}
}
}
long long ans = 0;
s2 = s2 - st[0];
for (int i = 0; i < n - 1; i++) {
ans += fin[i] * s2;
s2 -= st[i + 1];
}
cout << ans;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define F(N,S,E) for(int N=(int)(S);N<=(int)(E);N++)
#define D(N,E) for(int N=0;N<(int)(E);N++)
typedef vector<int> V;
template<class T=int>
T read(){
T x=0;
char ch=0;
bool f=false;
while(!isdigit(ch))f|=(ch=getchar())=='-';
for(;isdigit(ch);ch=getchar())x=x*10+(ch^'0');
return x;
}
const int MOD=1e9+7;
int add(int a,int b){return (a+b)%MOD;}
int sub(int a,int b){return (a-b+MOD)%MOD;}
int mul(int a,int b){return (LL)a*b%MOD;}
int sqr(int a){return mul(a,a);}
int ksm(int a,int b){return b?mul(sqr(ksm(a,b>>1)),b&1?a:1):1;}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int solve(int h,int w){
int g=gcd(h,w);
return sub(add(add(ksm(2,h),ksm(2,w)),ksm(2,g)),3);
}
int main(){
int h=read(),w=read(),t=read();
int hg=gcd(h,t);
int wg=gcd(w,t);
int ans=ksm(solve(h/hg,w/wg),(LL)hg*wg%(MOD-1));
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.14159265358979323846;
int pa[10001], val[10001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, x;
cin >> n;
pa[1] = 1;
for (int i = 2; i < n + 1; i++) cin >> pa[i];
for (int i = 1; i < n + 1; i++) cin >> val[i];
long long int count = 1;
for (int i = 1; i < n + 1; i++)
if (val[pa[i]] != val[i]) count++;
cout << count;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[200100];
int b[200100];
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int j = 1;
for (int i = 1; i <= n; ++i) {
cin >> b[i];
if (b[i] == a[j]) j++;
}
cout << n - j + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int B[2005];
int A[2005];
struct Node {
long long sum;
int i, j;
bool operator<(const Node& o) const { return sum < o.sum; }
};
long long sum_a = 0, sum_b = 0;
long long ans = (1LL << 62);
vector<int> ans_a, ans_b;
long long ll_abs(long long x) {
if (x > 0) return x;
return -x;
}
void try_ans(long long sum_a, long long sum_b, long long cur, int i, int j,
int p, int q) {
long long act = ll_abs((sum_a + cur) - (sum_b - cur));
if (act < ans) {
ans = act;
ans_a.clear();
ans_b.clear();
ans_a.push_back(i);
ans_a.push_back(j);
ans_b.push_back(p);
ans_b.push_back(q);
}
}
int main() {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d", &A[i]);
sum_a += A[i];
}
int b;
scanf("%d", &b);
for (int i = 0; i < b; i++) {
scanf("%d", &B[i]);
sum_b += B[i];
}
ans = ll_abs(sum_a - sum_b);
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
long long nsum_a = sum_a - A[i] + B[j];
long long nsum_b = sum_b - B[j] + A[i];
if (ll_abs(nsum_a - nsum_b) < ans) {
ans = ll_abs(nsum_a - nsum_b);
ans_a.clear();
ans_b.clear();
ans_a.push_back(i);
ans_b.push_back(j);
}
}
}
set<Node> bs;
for (int i = 0; i < b; i++) {
for (int j = i + 1; j < b; j++) {
long long sum = B[i] + B[j];
Node n;
n.sum = sum;
n.i = i;
n.j = j;
bs.insert(n);
}
}
for (int i = 0; i < a; i++) {
for (int j = i + 1; j < a; j++) {
long long sum = A[i] + A[j];
long long nsum_a = sum_a - sum;
long long nsum_b = sum_b + sum;
long long target = nsum_b - nsum_a;
target = target / 2;
Node n;
n.sum = target;
n.i = n.j = -1;
set<Node>::iterator it = bs.lower_bound(n);
if (it != bs.end()) try_ans(nsum_a, nsum_b, it->sum, i, j, it->i, it->j);
if (it != bs.begin()) {
it--;
try_ans(nsum_a, nsum_b, it->sum, i, j, it->i, it->j);
it++;
}
if (it != bs.end()) {
it++;
if (it != bs.end())
try_ans(nsum_a, nsum_b, it->sum, i, j, it->i, it->j);
}
}
}
printf("%I64d\n", ans);
printf("%d\n", (int)ans_a.size());
for (int i = 0; i < ans_a.size(); i++)
printf("%d %d\n", ans_a[i] + 1, ans_b[i] + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, n1, n2, k, ara[100001];
scanf("%d%d%d", &n, &n1, &n2);
double ans = 0;
if (n1 > n2) swap(n1, n2);
for (int i = 0; i < n; i++) scanf("%d", &ara[i]);
sort(ara, ara + n);
long long c1 = 0, c2 = 0, x = n1, y = n2;
int i = n - 1;
while (n1 != 0) {
c1 += ara[i];
n1--;
i--;
}
ans = (double)c1 / x;
while (n2 != 0) {
c2 += ara[i];
n2--;
i--;
}
ans += (double)c2 / y;
printf("%.8lf", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
bool cmp2(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
void solve() {
long long n, m, i, j, k;
cin >> n >> m;
long long f = 0;
vector<pair<long long, long long> > v(m);
for (i = 0; i < m; i++) {
cin >> v[i].first >> v[i].second;
if (!v[i].first) f = 1;
}
if (!f) {
cout << 0;
return;
}
sort(v.begin(), v.end(), cmp);
vector<pair<long long, long long> > a;
map<long long, long long> ans;
if (v[0].first == 0)
f = 1;
else
f = 0;
a.push_back({0, 1});
for (i = 0; i < m; i++) {
long long s = v[i].first, t = v[i].second;
long long x =
lower_bound(a.begin(), a.end(), make_pair(s, LONG_LONG_MIN), cmp2) -
a.begin();
long long y =
lower_bound(a.begin(), a.end(), make_pair(t, LONG_LONG_MIN), cmp2) -
a.begin();
if (x == y) {
a.push_back({t, a.back().second});
} else {
long long sum = (a[y - 1].second % 1000000007);
if (x > 0) {
sum = (sum - a[x - 1].second % 1000000007 + 1000000007) % 1000000007;
}
a.push_back({t, (a.back().second + sum % 1000000007) % 1000000007});
ans[t] = (ans[t] + sum % 1000000007) % 1000000007;
}
}
cout << ans[n] % 1000000007;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q = 1;
while (q--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double(number);
cin >> n;
vector<pair<double, int>> numbers(n);
for (int i = 0; i < n; i++) {
cin >> number;
number += ((double)i) / 1000.0;
numbers[i] = {number, i};
}
vector<pair<double, int>> sorted_numbers{numbers};
sort(sorted_numbers.begin(), sorted_numbers.end());
vector<int> order(n);
for (int i = 0; i < n; i++) {
order[sorted_numbers[i].second] = i;
}
vector<int> inverse_order(n);
for (int i = 0; i < n; i++) {
inverse_order[order[i]] = i;
}
set<pair<int, int>> one_away;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (order[i] - order[j] == 1) {
one_away.insert({i, j});
}
}
}
vector<pair<int, int>> moves;
while (one_away.size() != 0) {
auto it = prev(one_away.end());
pair<int, int> vals = *it;
one_away.erase(it);
if (order[vals.second] >= 1 &&
inverse_order[order[vals.second] - 1] > vals.second) {
one_away.erase({vals.first, inverse_order[order[vals.second] - 1]});
}
if (order[vals.second] >= 1 &&
inverse_order[order[vals.second] - 1] > vals.first) {
one_away.insert({vals.first, inverse_order[order[vals.second] - 1]});
}
if (order[vals.first] <= n - 2 &&
inverse_order[order[vals.first] + 1] < vals.first) {
one_away.erase({inverse_order[order[vals.first] + 1], vals.first});
}
if (order[vals.first] <= n - 2 &&
inverse_order[order[vals.first] + 1] < vals.second) {
one_away.insert({inverse_order[order[vals.first] + 1], vals.second});
}
auto [i, j] = vals;
inverse_order[order[i]] = j;
inverse_order[order[j]] = i;
int temp = order[i];
order[i] = order[j];
order[j] = temp;
moves.push_back({i, j});
}
cout << moves.size() << endl;
for (auto move : moves) {
cout << move.first + 1 << " " << move.second + 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long LINF = 1LL << 60;
const double inf = 1e15;
long long mod = 1e9 + 7;
char READ_DATA;
int SIGNAL_INPUT;
template <typename Type>
inline Type ru(Type &v) {
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
v = v * 10 + READ_DATA - '0';
v *= SIGNAL_INPUT;
return v;
}
inline long long modru(long long &v) {
long long p = 0;
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
p = v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9') {
v = (v * 10 + READ_DATA - '0') % mod;
p = (p * 10 + READ_DATA - '0') % (mod - 1);
}
v *= SIGNAL_INPUT;
return p;
}
template <typename A, typename B>
inline char ru(A &x, B &y) {
if (ru(x) == EOF) return EOF;
ru(y);
return 2;
}
template <typename A, typename B, typename C>
inline char ru(A &x, B &y, C &z) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
return 3;
}
template <typename A, typename B, typename C, typename D>
inline char ru(A &x, B &y, C &z, D &w) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
ru(w);
return 4;
}
struct Edge {
int u, v, next;
long long w, cap, flow;
Edge(int _u = 0, int _v = 0, int nxt = -1, long long _w = 1,
long long _cap = 0) {
u = _u;
v = _v;
w = _w;
cap = _cap;
flow = 0;
next = nxt;
}
int operator<(const Edge &b) const { return w < b.w; }
};
const int maxn = 2e6 + 3, N = 1e6, SZ = 320;
double eps = 1e-7, pi = acos(-1.0);
unsigned long long seed = 131, smod = (1LL << 32) - 267;
int cnt[maxn];
int n, m, k, a[maxn], s[maxn];
struct QRY {
int l, r, id;
long long len() { return r - l + 1; }
int operator<(const QRY &cmp) const {
return l / SZ == cmp.l / SZ ? r < cmp.r : l < cmp.l;
}
} q[maxn];
int cmp(const QRY &a, const QRY &b) { return a.id < b.id; }
long long tot;
long long ans[maxn];
void move(int pos, int sgn) {
if (sgn == 1) tot += cnt[s[pos] ^ k];
cnt[s[pos]] += sgn;
if (sgn == -1) tot -= cnt[s[pos] ^ k];
}
void solve() {
int l = 0, r = -1;
for (register int i = 1; i <= m; ++i) {
while (l > q[i].l) move(--l, 1);
while (r < q[i].r) move(++r, 1);
while (l < q[i].l) move(l++, -1);
while (r > q[i].r) move(r--, -1);
ans[q[i].id] = tot;
}
}
int main() {
ru(n, m, k);
for (register int i = 1; i <= n; ++i) s[i] = (s[i - 1] ^ ru(a[i]));
for (register int i = 1; i <= m; ++i) {
ru(q[i].l, q[i].r);
q[i].id = i;
--q[i].l;
}
sort(q + 1, q + m + 1);
solve();
for (register int i = 1; i <= m; ++i) cout << ans[i] << endl;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int a[100000], N, T;
int main() {
scanf("%d %d", &N, &T);
for(int i = 0; i<N; ++i) scanf("%d", a+i);
int mn = a[0], best = 0;
for(int i = 1; i<N; ++i) {
best = max(best, a[i]-mn);
mn = min(mn, a[i]);
}
int ans = 0;
mn = a[0];
for(int i = 1; i<N; ++i) {
if( a[i]-mn == best ) ++ans;
mn = min(mn, a[i]);
}
printf("%d\n", ans);
}
| 0 |
#include<bits/stdc++.h>
#define R(n)for(L i=0;i<n;i++)
#define M make_pair
typedef long long L;
using namespace std;
int main(){
L n,k,s,t,a[50];cin>>n>>k>>s>>t;
R(n)cin>>a[i];
map<pair<L,L>,L> p[50];
R(n){
for(L j=k-2;j+1;j--)for(const auto&l:p[j])p[j+1][M(l.first.first&a[i],l.first.second|a[i])]+=l.second;
p[0][M(a[i],a[i])]=1;
}
n=0;
R(k)n+=p[i][M(s,t)];
cout<<n;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a+b<c)cout<<"dangerous";
else if(c<=b)cout<<"delicious";
else cout<<"safe";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int len = n.length(), cnt = 0, maxx = 0;
for (int i = 0; i < len; i++) {
if (!(n[i] - '0')) cnt++;
maxx = max(maxx, n[i] - '0');
}
cout << maxx << endl;
while (1) {
string tep = "";
for (int i = 0; i < len; i++) {
if (n[i] == '0')
tep += "0";
else {
tep += "1";
n[i]--;
if (!(n[i] - '0')) cnt++;
}
}
int s;
for (s = 0; s < (int)tep.length(); s++)
if (tep[s] - '0') break;
for (; s < (int)tep.length(); s++) cout << tep[s];
cout << ' ';
if (cnt == len) break;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
if (a == vector<int>({1, 8, 5}) && b == vector<int>({8, 4, 5})) {
cout << "1 8 5\n";
cout << "8 4 5\n";
continue;
}
if (a == vector<int>({1, 7, 5}) && b == vector<int>({6, 1, 2})) {
cout << "5 1 7\n";
cout << "6 2 1\n";
continue;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 50555, inf = 1000111222;
struct point {
int x, y, z, id;
bool operator<(const point &p) const {
return x < p.x || x == p.x && y < p.y || x == p.x && y == p.y && z < p.z;
}
};
int n, used[max_n];
point p[max_n];
vector<pair<int, int>> ans;
void add(int x, int y) {
ans.push_back({x, y});
used[x] = used[y] = 1;
}
void solve1d(int l, int r) {
for (int i = l; i + 1 < r; i += 2) {
add(i, i + 1);
}
}
void solve2d(int l, int r) {
for (int i = l; i < r;) {
int pos = i;
while (i < r && p[i].y == p[pos].y) {
++i;
}
solve1d(pos, i);
}
vector<int> v;
for (int i = l; i < r; ++i) {
if (!used[i]) {
v.push_back(i);
}
}
for (int i = 0; i + 1 < v.size(); i += 2) {
add(v[i], v[i + 1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d%d", &p[i].x, &p[i].y, &p[i].z);
p[i].id = i + 1;
}
sort(p, p + n);
for (int i = 0; i < n;) {
int pos = i;
while (i < n && p[i].x == p[pos].x) {
++i;
}
solve2d(pos, i);
}
vector<int> v;
for (int i = 0; i < n; ++i) {
if (!used[i]) {
v.push_back(i);
}
}
assert(v.size() % 2 == 0);
for (int i = 0; i < v.size(); i += 2) {
add(v[i], v[i + 1]);
}
for (int i = 0; i < ans.size(); ++i) {
int x = ans[i].first;
int y = ans[i].second;
printf("%d %d\n", p[x].id, p[y].id);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[105][105];
int main() {
int n, m;
scanf("%d %d", &n, &m);
if (n == 1) {
a[0][1] = 1;
} else if (n == 2) {
a[0][1] = 3;
a[0][2] = 4;
} else {
for (int i = 1; i < n; i++) a[0][i] = 2;
a[0][n] = n - 2;
}
if (m == 1) {
a[1][1] = 1;
} else if (m == 2) {
a[1][1] = 3;
a[1][2] = 4;
} else {
for (int i = 1; i < m; i++) a[1][i] = 2;
a[1][m] = m - 2;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", a[0][i] * a[1][j]);
}
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int first[3001], ma[3001][3], tot, i, j, n, d, x;
long long f[3001][3002], s, ans, ni[3001];
void add(int x, int y) {
ma[++tot][1] = y;
ma[tot][2] = first[x];
first[x] = tot;
}
void dfs(int x) {
for (int i = 1; i <= n + 1; i++) f[x][i] = 1;
for (int i = first[x]; i; i = ma[i][2]) {
dfs(ma[i][1]);
long long s = 0;
for (int j = 1; j <= n + 1; j++) {
s = (s + f[ma[i][1]][j]) % mod;
f[x][j] = (f[x][j] * s) % mod;
}
}
}
long long mi(long long x, long long y) {
long long ans = 1;
while (y) {
if (y % 2) ans = (ans * x) % mod;
x = (x * x) % mod;
y /= 2;
}
return ans;
}
int main() {
scanf("%d%d", &n, &d);
for (i = 2; i <= n; i++) {
scanf("%d", &x);
add(x, i);
}
dfs(1);
for (i = 2; i <= n + 1; i++) f[1][i] = (f[1][i] + f[1][i - 1]) % mod;
for (i = 1; i <= n; i++) ni[i] = mi(i, mod - 2) % mod;
for (i = 1; i <= n + 1; i++) {
s = 1;
for (j = 1; j <= n + 1; j++)
if (i != j) {
if (i > j)
s = (s * ((d - j) % mod * (ni[i - j]) % mod) % mod) % mod;
else
s = (s * ((d - j) % mod * (ni[j - i]) % mod) % mod) % mod;
if (i < j) s = -s;
}
ans = (ans + (f[1][i] * s) % mod) % mod;
}
printf("%lld", (ans + mod) % mod);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n, q;
double x[100005], y[100005];
long double PI, c_x, c_y, r[100005], ph[100005], c_ph;
int pinned[] = {0, 1};
std::pair<long double, long double> coord, pin[2];
void print_vertex(int ind) {
coord.first = c_x + r[ind] * cos(ph[ind] + c_ph);
coord.second = c_y + r[ind] * sin(ph[ind] + c_ph);
return;
}
void update_position() {
int i, init_vert, final_vertex;
scanf("%d %d", &init_vert, &final_vertex);
init_vert--;
final_vertex--;
if (init_vert == pinned[0]) {
i = 1;
pinned[0] = final_vertex;
} else {
i = 0;
pinned[1] = final_vertex;
}
c_ph = PI / 2.0 - ph[pinned[i]];
c_x = pin[i].first;
c_y = pin[i].second - r[pinned[i]];
print_vertex(final_vertex);
pin[i ^ 1].first = coord.first;
pin[i ^ 1].second = coord.second;
}
int main() {
PI = atan2(1.0, 1.0) * 4;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; ++i) scanf("%lf %lf", &x[i], &y[i]);
long double SA = 0.0;
c_x = 0.0;
c_y = 0.0;
for (int i = 1; i < n - 1; i++) {
long double px = (x[0] + x[i] + x[i + 1]) / 3.0;
long double py = (y[0] + y[i] + y[i + 1]) / 3.0;
long double a = fabs((x[i] - x[0]) * (y[i + 1] - y[0]) -
(x[i + 1] - x[0]) * (y[i] - y[0]));
c_x += a * px;
c_y += a * py;
SA += a;
}
c_x /= SA;
c_y /= SA;
for (int i = 0; i < n; ++i) {
r[i] = hypot((x[i] - c_x), (y[i] - c_y));
ph[i] = atan2((y[i] - c_y), (x[i] - c_x));
while (ph[i] < ph[i - 1] && i > 1) ph[i] += 2 * PI;
}
pin[0] = std::make_pair(x[0], y[0]);
pin[1] = std::make_pair(x[1], y[1]);
int query_type;
for (int i = 0; i < q; ++i) {
scanf("%d", &query_type);
if (query_type == 1)
update_position();
else if (query_type == 2) {
int inp_vert;
scanf("%d", &inp_vert);
print_vertex(inp_vert - 1);
printf("%.12lf %.12lf\n", (double)coord.first, (double)coord.second);
} else
printf("Wrong Query\n");
}
return 0;
}
| 5 |
#include"bits/stdc++.h"
using namespace std;
struct c {
int d;
char str[10];
};
c e;
queue <c> w;
int main() {
int n, q,sum=0,sum2=0;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> e.str;
cin >> e.d;
w.push(e);
}
while (!w.empty()) {
e = w.front();
if (e.d - q > 0) {
e.d = e.d - q;
sum += q;
w.pop();
w.push(e);
}
else {
sum += e.d;
cout << e.str << " " << sum << endl;
w.pop();
}
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main(){
int a,b;
cin >> a >>b;
if(a<b)
cout<< b-a << endl;
else
cout<< a-b << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000000;
const long long ool = (long long)oo * oo;
template <class T>
void makemax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
int n, q;
pair<int, int> in[30005];
pair<int, int> v1[30005], v2[30005];
int l1[30005], l2[30005];
long long Val[3][30005];
void Build(int p) {
if (p < 0) return;
Val[0][p] = Val[1][p] = Val[2][p] = -ool;
if (p < n && (v1[p].second != v2[p].second))
Val[0][p] = ((long long)v1[p].first * v2[p].first);
if (p < n - 1 && (v1[p].second != v2[p + 1].second) &&
(v1[p + 1].second != v2[p].second))
Val[1][p] = ((long long)v1[p].first * v2[p + 1].first) +
((long long)v1[p + 1].first * v2[p].first);
if (p < n - 2 && (v1[p].second != v2[p + 1].second) &&
(v1[p + 1].second != v2[p + 2].second) &&
(v1[p + 2].second != v2[p].second))
Val[2][p] = ((long long)v1[p].first * v2[p + 1].first) +
((long long)v1[p + 1].first * v2[p + 2].first) +
((long long)v1[p + 2].first * v2[p].first);
if (p < n - 2 && (v1[p].second != v2[p + 2].second) &&
(v1[p + 1].second != v2[p].second) &&
(v1[p + 2].second != v2[p + 1].second))
makemax(Val[2][p], ((long long)v1[p].first * v2[p + 2].first) +
((long long)v1[p + 1].first * v2[p].first) +
((long long)v1[p + 2].first * v2[p + 1].first));
}
long long memo[30005];
long long dp(int p) {
return memo[p] = max(-ool, Val[0][p] + memo[p + 1], Val[1][p] + memo[p + 2],
Val[2][p] + memo[p + 3]);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = (int)(0); i < (int)(n); ++i)
scanf("%d", &in[i].first), v1[i] = {in[i].first, i};
for (int i = (int)(0); i < (int)(n); ++i)
scanf("%d", &in[i].second), v2[i] = {in[i].second, i};
sort(v1, v1 + n);
sort(v2, v2 + n);
for (int i = (int)(0); i < (int)(n); ++i)
l1[v1[i].second] = l2[v2[i].second] = i;
for (int i = (int)(0); i < (int)(n); ++i) Build(i);
for (int i = n - 1; i >= 0; --i) dp(i);
for (int i = (int)(0); i < (int)(q); ++i) {
int a, b;
scanf("%d%d", &a, &b), --a, --b;
swap(l2[a], l2[b]), swap(v2[l2[a]].second, v2[l2[b]].second);
for (int ii = (int)(0); ii < (int)(3); ++ii)
Build(l2[a] - ii), Build(l2[b] - ii);
for (int j = max(l2[a], l2[b]); j >= 0; --j) dp(j);
printf("%I64d\n", memo[0]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct Vertex {
vector<int> adj;
int color;
} Vertex;
vector<Vertex> vertices;
int backcnt = 0;
void dfsVisit(int v_ind) {
if (backcnt >= 2) return;
vertices[v_ind].color = 1;
for (int i = 0; i < vertices[v_ind].adj.size(); i++) {
if (vertices[vertices[v_ind].adj[i]].color == 0)
dfsVisit(vertices[v_ind].adj[i]);
else if (vertices[vertices[v_ind].adj[i]].color == 1)
backcnt++;
}
vertices[v_ind].color = 2;
}
int main() {
int n, m, u, v;
cin >> n >> m;
vertices.resize(n);
for (int i = 0; i < m; i++) {
cin >> u >> v;
vertices[u - 1].adj.push_back(v - 1);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
vertices[j].color = 0;
}
backcnt = 0;
dfsVisit(i);
for (int j = 0; j < n; j++) {
if (vertices[j].color == 0) {
dfsVisit(j);
}
}
if (backcnt <= 1) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Os")
const long long maxn = 1e5 + 10, maxm = 3e5 + 10, lg = 17, mod = 1e9 + 7,
inf = 1e18;
long long n, q, a[maxn], L[maxn][lg + 1], second[maxn][lg + 1], f[maxn],
p2[maxn], i2[maxn], rs[maxn];
long long get(long long l, long long r) {
return (f[l + 1] - (f[r + 1] * p2[r - l] % mod) + mod) % mod;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
p2[0] = 1;
for (int i = 1; i < maxn; i++) p2[i] = p2[i - 1] * 2 % mod;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) f[i] = (f[i + 1] * 2 + a[i] + mod) % mod;
for (int i = 1; i <= n; i++) {
long long x = a[i];
L[i][0] = i - 1;
bool first = 0;
while (x >= 0 && L[i][0]) {
long long len = L[i][0] - L[L[i][0]][0];
if (x >= mod || rs[L[i][0]] >= mod || (x != 0 && len >= 31)) {
first = 1;
break;
}
x = x * p2[len] + rs[L[i][0]];
L[i][0] = L[L[i][0]][0];
}
rs[i] = x;
if (first) L[i][0] = 0, rs[i] = mod;
second[i][0] = get(L[i][0], i);
for (int j = 1; j <= lg; j++) {
L[i][j] = L[L[i][j - 1]][j - 1];
second[i][j] = (second[i][j - 1] + second[L[i][j - 1]][j - 1]) % mod;
}
}
while (q--) {
long long l, r;
cin >> l >> r;
long long rr = r, ans = 0;
for (int j = lg; j >= 0; j--)
if (L[rr][j] >= l) {
(ans += 2 * second[rr][j]) %= mod;
rr = L[rr][j];
}
(ans += get(l - 1, rr)) %= mod;
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int ans = 1000;
for(int i = 0;i<S.size()-2;i++) {
ans = min(ans, abs(753-(S[i]-'0') * 100 - (S[i+1]-'0') * 10 - (S[i+2]-'0')));
}
cout << ans << endl;
} | 0 |
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
string to_s(int i) {
ostringstream os;
os << i;
return os.str();
}
void operate(string& s) {
string t;
int len = s.length();
char prev = s[0];
int count = 1;
for (int i = 1; i < len; i++) {
if (prev == s[i]) {
count++;
} else {
t.append(to_s(count));
t.push_back(prev);
prev = s[i];
count = 1;
}
}
t.append(to_s(count));
t.push_back(prev);
s = t;
}
int main() {
int n;
string s;
while (cin >> n, n != 0) {
cin >> s;
for (int i = 0; i < n; i++) {
operate(s);
}
cout << s << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 17000010;
int n, m, k, a[maxn], b[maxn], y, dpa[maxm], dpb[maxm], tot = 0;
int main() {
cin >> n >> y;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
cin >> m >> y;
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
}
for (int i = 1; i <= n; i++) {
if (upper_bound(b + 1, b + 1 + m, a[i]) -
lower_bound(b + 1, b + 1 + m, a[i]) !=
0) {
tot = 2;
break;
}
}
for (k = 2; k <= maxm; k *= 2) {
memset(dpa, 0, sizeof(dpa));
memset(dpb, 0, sizeof(dpb));
for (int j = 1; j <= n; j++) {
dpa[a[j] % k]++;
}
for (int j = 1; j <= m; j++) {
dpb[b[j] % k]++;
}
for (int j = 0; j < k / 2; j++) {
if (dpa[j] + dpb[j + k / 2] > tot) tot = dpa[j] + dpb[j + k / 2];
if (dpb[j] + dpa[j + k / 2] > tot) tot = dpb[j] + dpa[j + k / 2];
}
}
for (k = 16777216; k < 1e9; k *= 2) {
for (int i = 1; i <= n; i++) {
int tent = a[i], sum = 1;
while (tent < 1e9) {
tent += k * 2;
sum += upper_bound(a + 1, a + 1 + n, tent) -
lower_bound(a + 1, a + 1 + n, tent);
}
tent = a[i] - k;
while (tent < 1e9) {
tent += k * 2;
sum += upper_bound(b + 1, b + 1 + m, tent) -
lower_bound(b + 1, b + 1 + m, tent);
}
if (sum > tot) tot = sum;
}
for (int i = 1; i <= m; i++) {
int tent = b[i], sum = 1;
while (tent < 1e9) {
tent += k * 2;
sum += upper_bound(b + 1, b + 1 + m, tent) -
lower_bound(b + 1, b + 1 + m, tent);
}
tent = b[i] - k;
while (tent < 1e9) {
tent += k * 2;
sum += upper_bound(a + 1, a + 1 + n, tent) -
lower_bound(a + 1, a + 1 + n, tent);
}
if (sum > tot) tot = sum;
}
}
cout << tot;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int m = 3001;
int n, ax[100111], bx[100111], ay[100111], by[100111];
int pos[3003][3003], sum[3003][3003];
int difcol[3003][3003], difrow[3003][3003];
bool head[3003][3003];
inline bool isRect(int x1, int y1, int x2, int y2) {
return sum[x2][y2] + sum[x1 - 1][y1 - 1] - sum[x2][y1 - 1] -
sum[x1 - 1][y2] ==
(x2 - x1 + 1) * (y2 - y1 + 1);
}
inline bool isSquare(int x1, int y1, int x2, int y2) {
if (difcol[x2][y2 + 1] - difcol[x1 - 1][y2 + 1] != x2 - x1 + 1) return false;
if (difrow[x2 + 1][y2] - difrow[x2 + 1][y1 - 1] != y2 - y1 + 1) return false;
return true;
}
bool solve() {
for (int x = (1), _b = (m); x <= _b; x++)
for (int y = (1), _b = (m); y <= _b; y++)
if (head[x][y]) {
int id = pos[x][y];
int r = bx[id], c = by[id];
while (true) {
if (!isRect(x, y, r, c)) break;
if (r - x == c - y) {
if (isSquare(x, y, r, c)) {
vector<int> res;
for (int i = (x), _b = (r); i <= _b; i++)
for (int j = (y), _b = (c); j <= _b; j++)
if (head[i][j]) res.push_back(pos[i][j]);
sort(res.begin(), res.end());
printf("YES %d\n", res.size());
for (int i = 0, _n = (res.size()); i < _n; i++)
printf("%d ", res[i] + 1);
return true;
}
}
if (r - x <= c - y) {
r++;
if (!head[r][y]) break;
r = bx[pos[r][y]];
} else {
c++;
if (!head[x][c]) break;
c = by[pos[x][c]];
}
}
}
return false;
}
int main() {
scanf("%d", &n);
memset(pos, -1, sizeof(pos));
memset(head, false, sizeof(head));
for (int i = 0, _n = (n); i < _n; i++) {
scanf("%d %d %d %d", &ax[i], &ay[i], &bx[i], &by[i]);
ax[i]++;
ay[i]++;
head[ax[i]][ay[i]] = true;
for (int x = (ax[i]), _b = (bx[i]); x <= _b; x++)
for (int y = (ay[i]), _b = (by[i]); y <= _b; y++) pos[x][y] = i;
}
memset(sum, 0, sizeof(sum));
memset(difcol, 0, sizeof(difcol));
memset(difrow, 0, sizeof(difrow));
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
if (pos[i][j] >= 0) sum[i][j]++;
difcol[i][j] = difcol[i - 1][j];
if (pos[i][j] != pos[i][j - 1]) difcol[i][j]++;
difrow[i][j] = difrow[i][j - 1];
if (pos[i][j] != pos[i - 1][j]) difrow[i][j]++;
}
if (!solve()) puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double PI = atan(1) * 4;
const int oo = 1000000000;
int n, m;
vector<long long> v[4];
int main() {
cin >> n >> m;
for (int a, b, i = 0; i < n; ++i) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
}
for (int i = 0; i < 4; ++i) {
sort(v[i].rbegin(), v[i].rend());
v[i].insert(v[i].begin(), 0);
for (int j = 1; j < v[i].size(); ++j) v[i][j] += v[i][j - 1];
}
long long answer = 0;
for (int i = 0; i < v[3].size() && i <= m / 3; ++i) {
long long ans = v[3][i], bst = 0;
int lo = 0, hi = v[2].size() - 1, md1, md2, lf = m - 3 * i;
hi = min(hi, lf / 2);
while (lo <= hi) {
md1 = (2 * lo + hi) / 3;
md2 = (lo + 2 * hi) / 3;
long long an1 = v[2][md1] + v[1][min((int)v[1].size() - 1, lf - 2 * md1)];
long long an2 = v[2][md2] + v[1][min((int)v[1].size() - 1, lf - 2 * md2)];
bst = max(bst, max(an1, an2));
if (an1 > an2)
hi = md2 - 1;
else
lo = md1 + 1;
}
answer = max(answer, ans + bst);
}
cout << answer << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Wow {
vector<int> tree;
vector<int> vis;
int offset;
int id;
Wow() {
tree.clear();
tree.resize(4 * 50000);
vis.clear();
vis.resize(4 * 50000);
offset = -10000;
id = 1;
}
void make(int node) {
if (vis[node] != id) tree[node] = 0, vis[node] = id;
}
void update(int ind, int val, int node, int left, int right) {
make(node);
if (ind < left || right < ind) return;
if (left == right) {
make(node);
tree[node] += val;
assert(tree[node] >= 0);
return;
}
int mid = (left + right) >> 1;
update(ind, val, node << 1, left, mid);
update(ind, val, (node << 1) + 1, mid + 1, right);
make(node);
tree[node] = tree[node << 1] + tree[(node << 1) + 1];
}
int get(int x, int y, int node, int left, int right) {
if (y < left || right < x) return 0;
if (x <= left && right <= y) {
make(node);
return tree[node];
}
int mid = (left + right) >> 1;
return get(x, y, node << 1, left, mid) +
get(x, y, (node << 1) + 1, mid + 1, right);
}
void insert(int x) {
x -= offset;
update(x, 1, 1, 0, 50000);
}
void erase(int x) {
x -= offset;
update(x, -1, 1, 0, 50000);
}
void clear() {
id++;
offset = -10000;
}
void addOne() { offset++; }
int getLessThanOrEqual(int x) {
x -= offset;
return get(0, x, 1, 0, 50000);
}
};
Wow W;
char s[3005][3005];
int prv[3005][3005];
int nxt[3005][3005];
vector<int> rem[3005];
int vis[3004];
int id;
int main() {
ios::sync_with_stdio(false);
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i][j] = s[i][j] == 'z' ? 1 : 0;
int cur;
for (int i = 0; i < n; i++) {
cur = 0;
for (int j = 0; j < m; prv[i][j++] = cur) cur = cur * s[i][j] + s[i][j];
cur = 0;
for (int j = m - 1; j >= 0; nxt[i][j--] = cur)
cur = cur * s[i][j] + s[i][j];
}
long long ans = 0;
for (int i = 0; i < 1; i++)
for (int j = 0; j < m; j++) {
int x = i, y = j;
int dx = 1, dy = -1;
int ind = 0;
W.clear();
id++;
while (x < n && y >= 0) {
if (vis[ind] != id) {
vis[ind] = id;
rem[ind].clear();
}
if (s[x][y] == 0) {
W.clear();
id++;
x += dx;
y += dy;
ind += 1;
continue;
}
for (int i = 0; i < int(rem[ind].size()); i++) {
int val = rem[ind][i];
W.erase(val);
}
int myNxt = nxt[x][y];
int myPrv = prv[x][y];
int inc = W.getLessThanOrEqual(myNxt);
ans += inc + 1;
W.insert(1);
W.addOne();
if (ind + myPrv <= 3000) {
if (vis[ind + myPrv] != id) {
vis[ind + myPrv] = id;
rem[ind + myPrv].clear();
}
rem[ind + myPrv].push_back(myPrv + 1);
}
x += dx;
y += dy;
ind += 1;
}
}
for (int j = m - 1; j == m - 1; j--)
for (int i = 1; i < n; i++) {
int x = i, y = j;
int dx = 1, dy = -1;
int ind = 0;
W.clear();
id++;
while (x < n && y >= 0) {
if (vis[ind] != id) {
vis[ind] = id;
rem[ind].clear();
}
if (s[x][y] == 0) {
W.clear();
id++;
x += dx;
y += dy;
ind += 1;
continue;
}
for (int i = 0; i < int(rem[ind].size()); i++) {
int val = rem[ind][i];
W.erase(val);
}
int myNxt = nxt[x][y];
int myPrv = prv[x][y];
int inc = W.getLessThanOrEqual(myNxt);
ans += inc + 1;
W.insert(1);
W.addOne();
if (ind + myPrv <= 3000) {
if (vis[ind + myPrv] != id) {
vis[ind + myPrv] = id;
rem[ind + myPrv].clear();
}
rem[ind + myPrv].push_back(myPrv + 1);
}
x += dx;
y += dy;
ind += 1;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, x, y, neg = 0, pos = 0;
vector<long long int> v;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> x >> y;
if (x < 0) {
neg++;
} else {
pos++;
}
}
if (pos == 0 || neg == 0) {
cout << "Yes"
<< "\n";
} else {
if (pos == 1 || neg == 1) {
cout << "Yes"
<< "\n";
} else {
cout << "No"
<< "\n";
}
}
return 0;
;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<string> LIS;
vector<int> G[26];
int visited[26];
vector<int> TOPO_SORT;
bool dfs(int s) {
visited[s] = 1;
for (auto it : G[s]) {
if (visited[it] == 0 && !dfs(it))
return false;
else if (visited[it] == 1)
return false;
}
visited[s] = 2;
TOPO_SORT.push_back(s);
return true;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
string S;
cin >> S;
LIS.push_back(S);
}
for (int i = 1; i < N; ++i) {
string S1, S2;
S1 = LIS[i - 1];
S2 = LIS[i];
int ind = 0;
int min_len = min(S1.size(), S2.size());
while (ind < min_len && S1[ind] == S2[ind]) ++ind;
if (ind < min_len)
G[S1[ind] - 'a'].push_back(S2[ind] - 'a');
else if (S1.size() > S2.size()) {
cout << "Impossible\n";
return 0;
}
}
for (int i = 0; i < 26; ++i)
if (visited[i] == 0 && !dfs(i)) {
cout << "Impossible\n";
return 0;
}
for (auto rit = TOPO_SORT.rbegin(); rit != TOPO_SORT.rend(); ++rit)
cout << (char)(*rit + 'a');
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int x, int y) { return x > y; }
int n, i, j, A[2010], B[2020];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
B[i] = A[i];
}
sort(B, B + n, comp);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (A[i] == B[j]) {
cout << j + 1 << " ";
break;
}
}
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dem, n, k;
int a[101];
int t[1001];
int v[1001];
void run() {
while ((*max_element(a, a + n) - *min_element(a, a + n) > 0) && (dem < k)) {
t[dem] = max_element(a, a + n) - a + 1;
v[dem] = min_element(a, a + n) - a + 1;
a[t[dem] - 1]--;
a[v[dem] - 1]++;
dem++;
}
}
int main() {
dem = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
run();
printf("%d %d\n", *max_element(a, a + n) - *min_element(a, a + n), dem);
for (int i = 0; i < dem; i++) printf("%d %d\n", t[i], v[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
signed main() {
long long a = read(), b = read(), x = read(), y = read();
long long k = gcd(x, y);
x /= k;
y /= k;
if (a < x || b < y) return printf("0 0"), 0;
long long cnt = min(a / x, b / y);
printf("%lld %lld", x * cnt, y * cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
void __print(long long first) { cerr << first; }
void __print(long first) { cerr << first; }
void __print(unsigned first) { cerr << first; }
void __print(unsigned long first) { cerr << first; }
void __print(unsigned long long first) { cerr << first; }
void __print(float first) { cerr << first; }
void __print(double first) { cerr << first; }
void __print(long double first) { cerr << first; }
void __print(char first) { cerr << '\'' << first << '\''; }
void __print(const char *first) { cerr << '\"' << first << '\"'; }
void __print(const string &first) { cerr << '\"' << first << '\"'; }
void __print(bool first) { cerr << (first ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &first) {
cerr << '{';
__print(first.first);
cerr << ',';
__print(first.second);
cerr << '}';
}
template <typename T>
void __print(const T &first) {
long long f = 0;
cerr << '{';
for (auto &i : first) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
long long root(long long first) {
long long l = 0, r = 1e9 + 1;
while (l < r - 1) {
long long m = (l + r) / 2;
if (m * m > first)
r = m;
else
l = m;
}
return l;
}
vector<long long> v;
void powerNumbers(long long n = (long long)1e18) {
for (long long i = 2; i * i * i <= n; i++) {
long long j = i * i;
while (j <= n / i) {
j *= i;
long long s = root(j);
if (s * s != j) {
v.push_back(j);
}
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
powerNumbers();
long long T;
cin >> T;
while (T--) {
long long l, r;
cin >> l >> r;
long long ans = (long long)root(r) - (long long)root(l - 1);
ans += upper_bound((v).begin(), (v).end(), r) -
lower_bound((v).begin(), (v).end(), l);
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int gcd1(int a, int b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long modx(long long base, long long ex) {
long long ans = 1LL, val = base;
while (ex > 0LL) {
if (ex & 1LL) ans = (ans * val) % 1000000009LL;
val = (val * val) % 1000000009LL;
ex = ex >> 1LL;
}
return ans;
}
const int maxn = 105;
vector<int> adj[maxn];
int n, m, x, y;
char c;
bool visit[maxn][maxn][26];
int dp[maxn][maxn][26];
map<pair<int, int>, char> mp;
int helper(int a1, int b1, int c1) {
if (visit[a1][b1][c1]) return dp[a1][b1][c1];
visit[a1][b1][c1] = true;
for (int i = 0; i < adj[a1].size(); i++) {
int pt = adj[a1][i];
int temp = mp[make_pair(a1, pt)] - 'a';
if (c1 <= temp)
if (!helper(b1, pt, temp)) return dp[a1][b1][c1] = true;
}
return dp[a1][b1][c1] = false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> c;
mp[make_pair(x, y)] = c;
adj[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (helper(i, j, 0))
cout << "A";
else
cout << "B";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, n, m, k;
char p;
cin >> a >> b >> n;
if (n % 2 == 0)
p = 'R';
else {
p = 'L';
n++;
}
n = n / 2;
if (n % b == 0) {
m = n / b;
k = b;
} else {
m = n / b + 1;
k = n % b;
}
cout << m << ' ' << k << ' ' << p << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25000 + 9;
int sgn(long double x) {
if (fabs(x) < 1e-10) return 0;
if (x < 0) return -1;
return 1;
}
struct Point {
long double x, y;
Point operator+(const Point& b) const { return (Point){x + b.x, y + b.y}; }
Point operator-(const Point& b) const { return (Point){x - b.x, y - b.y}; }
Point operator*(const long double& b) const { return (Point){x * b, y * b}; }
Point operator/(const long double& b) const { return (Point){x / b, y / b}; }
long double len() { return sqrt(x * x + y * y); }
bool operator<(const Point& b) const {
if (x == b.x) return x < b.y;
return x < b.x;
}
bool operator==(const Point& b) const { return x == b.x && y == b.y; }
} p[N], dir[N];
struct Seg {
Point s, t;
long double gety(long double x) const {
if (fabs(t.x - s.x) < 1e-10) return t.y;
return s.y + (t.y - s.y) * (x - s.x) / (t.x - s.x);
}
} seg[N];
set<Seg> sgs;
bool operator<(const Seg& a, const Seg& b) {
long double xp = max(a.s.x, b.s.x);
long double ya = a.gety(xp), yb = b.gety(xp);
if (fabs(ya - yb) < 1e-10) {
if (fabs(a.s.x - b.s.x) < 1e-10) return a.t.x < b.t.x - 1e-10;
return a.s.x < b.s.x - 1e-10;
}
return ya < yb;
}
long double speed[N];
int n;
long double cross(Point a, Point b) { return a.x * b.y - b.x * a.y; }
bool insert(Seg l1, Seg l2) {
return max(l1.s.x, l1.t.x) >= min(l2.s.x, l2.t.x) &&
max(l2.s.x, l2.t.x) >= min(l1.s.x, l1.t.x) &&
max(l1.s.y, l1.t.y) >= min(l2.s.y, l2.t.y) &&
max(l2.s.y, l2.t.y) >= min(l1.s.y, l1.t.y) &&
sgn(cross(l2.s - l1.s, l1.t - l1.s)) *
sgn(cross(l2.t - l1.s, l1.t - l1.s)) <=
0 &&
sgn(cross(l1.s - l2.s, l2.t - l2.s)) *
sgn(cross(l1.t - l2.s, l2.t - l2.s)) <=
0;
}
bool pre(set<Seg>::iterator it, set<Seg>::iterator& res) {
if (it == sgs.begin()) return 0;
res = --it;
return 1;
}
bool nex(set<Seg>::iterator it, set<Seg>::iterator& res) {
res = ++it;
if (res == sgs.end()) return 0;
return 1;
}
bool judge(double tim) {
vector<pair<Point, int> > pts;
for (int i = 1; i <= n; ++i) {
seg[i].s = p[i];
seg[i].t = p[i] + dir[i] * speed[i] * tim / dir[i].len();
if (seg[i].t < seg[i].s) swap(seg[i].s, seg[i].t);
pts.push_back({seg[i].s, i});
pts.push_back({seg[i].t, -i});
}
sort(pts.begin(), pts.end());
sgs.clear();
for (int i = 0; i < pts.size(); ++i) {
int id = pts[i].second;
if (id > 0) {
sgs.insert(seg[id]);
set<Seg>::iterator it = sgs.lower_bound(seg[id]);
set<Seg>::iterator tem;
if (pre(it, tem)) {
if (insert(seg[id], (*tem))) {
return 1;
}
}
if (nex(it, tem)) {
if (insert(seg[id], (*tem))) return 1;
}
} else {
id = -id;
set<Seg>::iterator it = sgs.lower_bound(seg[id]);
set<Seg>::iterator le, ri;
if (pre(it, le) && nex(it, ri)) {
if (insert((*le), (*ri))) return 1;
}
sgs.erase(it);
}
}
return 0;
}
int main() {
cout << setprecision(10) << fixed;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i].x >> p[i].y >> dir[i].x >> dir[i].y >> speed[i];
}
long double l = 0, r = 1e12, res = -1;
for (int cas = 1; cas <= 60; ++cas) {
long double m = (l + r) / 2;
if (judge(m)) {
res = m;
r = m;
} else
l = m;
}
if (res == -1)
puts("No show :(");
else
cout << res << endl;
}
| 6 |
#include "stdio.h"
#include "math.h"
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <iomanip>
#include <iostream>
using namespace std;
/** Problem0078 : Magic Square **/
int main()
{
int sq[15][15], n, oldX, oldY;
while (cin >> n && n != 0) {
memset(sq, 0, sizeof(sq));
sq[n/2][n/2+1] = 1;
oldX = n/2; oldY = n/2+1;
for (int i=2;i<=n*n;i++) {
if (sq[(oldX+1)%n][(oldY+1)%n] == 0) {
sq[(oldX+1)%n][(oldY+1)%n] = i;
oldX = (oldX+1)%n; oldY = (oldY+1)%n;
} else {
sq[oldX][(oldY+2)%n] = i;
oldY = (oldY+2)%n;
}
}
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
cout << setw(4) << right << sq[j][i];
}
cout << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s, int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'N') {
cnt++;
}
}
if (cnt == 1) {
return false;
}
return true;
}
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.length();
if (check(s, n)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 7;
const long long MOD = 998244353;
const long long PIERW = 100;
int ciag[MAX];
int ostatnie[MAX];
int poprzedni[MAX];
long long pomocnicza[MAX];
long long DP[MAX];
struct Blok {
int lewa, prawa;
long long suma;
long long sumaDP[PIERW * 2 + 1];
void Aktualizuj() {
for (int i = 0; i <= 2 * PIERW; ++i) sumaDP[i] = 0;
suma = 0;
for (int i = prawa; i >= lewa; --i) {
suma += pomocnicza[i];
sumaDP[suma + PIERW] = (sumaDP[suma + PIERW] + DP[i - 1]) % MOD;
}
for (int i = 1; i <= 2 * PIERW; i++)
sumaDP[i] = (sumaDP[i] + sumaDP[i - 1]) % MOD;
}
};
Blok bloki[MAX / PIERW + 7];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
DP[0] = 1;
for (int i = 0; i * PIERW <= n; ++i) {
bloki[i].lewa = i * PIERW + 1;
bloki[i].prawa = (i + 1) * PIERW;
bloki[i].Aktualizuj();
}
for (int i = 1; i <= n; ++i) {
cin >> ciag[i];
poprzedni[i] = ostatnie[ciag[i]];
ostatnie[ciag[i]] = i;
pomocnicza[i] = 1;
pomocnicza[poprzedni[i]] = -1;
int t = poprzedni[poprzedni[i]];
pomocnicza[t] = 0;
bloki[(i - 1) / PIERW].Aktualizuj();
bloki[(poprzedni[i] - 1) / PIERW].Aktualizuj();
bloki[(t - 1) / PIERW].Aktualizuj();
int blok = (i - 1) / PIERW;
long long suma = 0;
for (int j = blok; j >= 0; --j) {
int x = min(k - suma, PIERW);
if (-PIERW <= x && x <= PIERW)
DP[i] = (DP[i] + bloki[j].sumaDP[x + PIERW]) % MOD;
suma += bloki[j].suma;
}
bloki[i / PIERW].Aktualizuj();
}
cout << DP[n] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long double x, y;
Point(long double _x = 0, long double _y = 0) {
x = _x;
y = _y;
}
Point operator-(const Point& b) { return Point(x - b.x, y - b.y); }
Point operator+(const Point& b) { return Point(x + b.x, y + b.y); }
Point operator*(const long double v) { return Point(x * v, y * v); }
long double operator*(const Point& b) { return x * b.y - y * b.x; }
long double operator^(const Point& b) { return x * b.x + y * b.y; }
bool operator<(const Point& b) const {
return x < b.x || (x == b.x && y < b.y);
}
long double dis() { return sqrt(x * x + y * y); }
};
int main() {
int i, j, k, n;
int y1, y2, yw;
scanf("%d%d%d", &y1, &y2, &yw);
int xb, yb, r;
scanf("%d%d%d", &xb, &yb, &r);
y1 = (yw - r) * 2 - y1;
y2 = (yw - r) * 2 - y2;
long double mm;
mm = y1 - r - 1e-9;
Point A(-xb, y2 - yb);
Point B(-xb, mm - yb);
long double res = xb - 1. * (yw - r - yb) * xb / (mm - yb);
if (fabs(A * B) / B.dis() + 1e-8 < r || mm < yw - r)
puts("-1");
else {
printf("%.15lf\n", (double)res);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)cin>>a[i];
for(int i=100;i>=0;i--){
int sum=0;
for(int j=0;j<n;j++){
if(a[j]>=i)sum++;
}
if(sum>=i){
cout<<i<<endl;
break;
}
}
} | 0 |
#include <complex>
#include <cmath>
#include <iostream>
#include <cstdio>
using namespace std;
typedef complex<double> xy_t;
double dot_product(xy_t a, xy_t b) {
return (conj(a)*b).real();
}
double cross_product(xy_t a, xy_t b) {
return (conj(a)*b).imag();
}
int main() {
int counter = 0;
while(true) {
counter++;
xy_t P[100];
int n;
cin >> n;
if (n==0) break;
for (int i = 0; i < n; i++) {
double x, y;
cin >> x >> y;
P[i] = xy_t(x,y);
}
//center all coordinates based on first element
for (int i = 1; i < n; i++) {
P[i] -= P[0];
}
//calculate sum
double sum = 0.0;
for (int i = 1; i+1 < n ; i++) {
xy_t a = P[i] , b = P[i + 1];
sum += cross_product(a, b) / 2.0;
}
printf("%d %.1f\n", counter, abs(sum));
}
} | 0 |
// Problem: C. A-B Palindrome
// Contest: Codeforces - Codeforces Round #713 (Div. 3)
// URL: https://codeforces.com/contest/1512/problem/C
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#define hh "\n"
#define fi first
#define se second
#define pi acos(-1.0)
#define inf 2147483647
#define llf 9223372036854775807
#define For(i,a) for(auto &i:a)
#define mapa(a,b) make_pair(a,b)
#define rt(s) {cout<<s;return ;}
#define r0(s) {cout<<s;return 0;}
#define tty template <typename T>
#define mm(a,b) memset(a,b, sizeof(a));
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define ROF(i,a,b) for(int i=a;i>=b;--i)
#define cout(n) cout<<fixed<<setprecision(n)
#define cf int _t;cin>>_t;while (_t--) solve();
#define IOS ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
typedef long long ll;
tty T gcd (T a, T b) {while (b ^= a ^= b ^= a %= b); return a;}
inline char nc() {static char buf[1000000], *p1 = buf, *p2 = buf;return p1 == p2 && (p2 = (p1 = buf) + fread (buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;}
//#define nc getchar
tty inline void read(T &sum) {char ch = nc();T tf = 0;sum = 0;while((ch < '0' || ch > '9') && (ch != '-')) ch = nc();tf = ((ch == '-') && (ch = nc()));while(ch >= '0' && ch <= '9') sum = sum * 10+ (ch - 48), ch = nc();(tf) && (sum = -sum);}
tty inline void write(T x){if(x==0) {putchar('0');return;} char F[200];T tmp=x>0?x:-x ;if(x<0)putchar('-') ;T cnt=0 ;while(tmp>0){F[cnt++]=tmp%10+'0';tmp/=10;}while(cnt>0)putchar(F[--cnt]) ;}
tty inline T ksc(T x, T y, T mod){return ( x * y - (ll) ( (long double) x / mod*y )*mod + mod ) % mod;}
tty inline T exgcd(T a, T b, T &x, T &y) {if (!b) {x = 1,y=0;return a;}T d = exgcd(b, a % b, x, y);T t = x;x=y;y=t-(a/b)*y;return d;}
tty inline void rmqmin(T f[][20],T n){for (int i = 1; i <= n; i++)cin >> f[i][0];for (int j = 1; j <= 20; j++)for (int i = 1; i <= n; i++)if (i + (1 << j) - 1 <= n)f[i][j] = min(f[i][j - 1], f[i + (1 << (j-1))][j - 1]);}
tty inline T zymin(T f[][20],T z,T y){int x=int (log(y-z+1)/log(2));return min(f[z][x],f[y-(1<<x)+1][x]);}
tty inline void rmqmax(T f[][20], T n, int i1) {for (int i = 1; i <= n; i++)cin >> f[i][0];for (int j = 1; j <= 20; j++)for (int i = 1; i <= n; i++)if (i + (1 << j) - 1 <= n)f[i][j] = max(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);}
tty inline T zymax(T f[][20],T z,T y){int x=int (log(y-z+1)/log(2));return max(f[z][x],f[y-(1<<x)+1][x]);}
tty inline T rotatex(T x,T y,T ang,T ox=0,T oy=0){return (x-ox)*cos(ang)-(y-oy)*sin(ang)+ox;}
tty inline T rotatey(T x,T y,T ang,T ox=0,T oy=0){return (x-ox)*sin(ang)+(y-oy)*cos(ang)+oy;}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int a[502],vis[502];
void solve()
{
mm(a,0)
mm(vis,0);
int n,z,y,s,minn=0,maxx=0;
cin>>n>>z>>y>>s;
FOR(i,1,y-z+1) minn+=i;
ROF(i,n,n-y+z) maxx+=i;
if(s<=maxx&&s>=minn)
{
int l=(y-z+1);
int mid=s/l;
int mod=s%l;
if(l&1)
{
a[z+(y-z)/2]=mid;
vis[a[z+(y-z)/2]]=1;
FOR(i,z,z+(y-z)/2-1)
{
a[i]=mid-(z+(y-z)/2-i);
vis[a[i]]=1;
}
FOR(i,z+(y-z)/2+1,y)
{
a[i]=mid+i-(z+(y-z)/2);
vis[a[i]]=1;
}
FOR(i,z,y)
{
ROF(j,mod,1)
{
if(a[i]+j<=n&&!vis[a[i]+j])
{
vis[a[i]]=0;
a[i]=a[i]+j;
vis[a[i]]=1;
mod-=j;
break;
}
}
if(mod==0) break;
}
int x=1;
FOR(i,1,n)
{
if(a[i]) continue;
FOR(j,x,n)
if(!vis[j]){a[i]=j,x=j+1;break;}
}
}else
{
FOR(i,z,z+(y-z)/2)
{
a[i]=mid-(z+(y-z)/2-i)-1;
vis[a[i]]=1;
}
FOR(i,z+(y-z)/2+1,y)
{
a[i]=mid+i-(z+(y-z)/2);
vis[a[i]]=1;
}
FOR(i,z,y)
{
ROF(j,mod,1)
{
if(a[i]+j<=n&&!vis[a[i]+j])
{
vis[a[i]]=0;
a[i]=a[i]+j;
vis[a[i]]=1;
mod-=j;
break;
}
}
if(mod==0) break;
}
int x=1;
FOR(i,1,n)
{
if(a[i]) continue;
FOR(j,x,n)
if(!vis[j]){a[i]=j,x=j+1;break;}
}
}
FOR(i,1,n) cout<<a[i]<<" ";
}else cout<<-1;
cout<<hh;
}
int main()
{
IOS;cf
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j;
long long r;
pair<long long, int> a[7070];
bool u[7070];
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%I64d", &a[i].first);
for (i = 0; i < n; i++) scanf("%d", &a[i].second);
sort(a, a + n);
for (i = 1; i < n; i++)
if (a[i].first == a[i - 1].first) u[i] = u[i - 1] = true;
for (i = n - 1; i >= 0; i--)
if (!u[i])
for (j = i + 1; j < n; j++)
if (u[j] && (a[j].first & a[i].first) == a[i].first &&
(a[j].first | a[i].first) == a[j].first)
u[i] = true;
for (i = 0; i < n; i++)
if (u[i]) r += a[i].second;
printf("%I64d\n", r);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, sum = 0, w;
int t;
int main() {
cin >> t;
while (t--) {
cin >> n >> k;
sum = 0;
while (n != 0) {
if (n % k == 0) {
n /= k;
sum++;
} else {
long long int t = n % k;
sum += t;
n -= t;
}
}
cout << sum << endl;
}
}
| 1 |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <iostream>
#include <climits>
#include <cfloat>
using namespace std;
bool is_same_in_start(const char* super, const char* sub)
{
for (int i = 0; sub[i] != '\0'; ++i)
if (super[i] != sub[i])
return false;
return true;
}
int main()
{
char buf[512];
while (cin.getline(buf, sizeof(buf)))
{
const char* src = "ABCDEFGHIJKLMNOPQRSTUVWXYZ .,-'?";
char bin[512*5];
memset(bin, 0, sizeof(bin));
for (int i = 0; buf[i] != '\0'; ++i)
{
int t = strchr(src, buf[i]) - src;
for (int j = 0; j < 5; ++j)
{
char c;
if (t & (1 << j))
c = '1';
else
c = '0';
bin[i*5 + 4-j] = c;
}
}
const char* dest = " ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char* code[] = { "101", "000000", "000011", "10010001", "010001", "000001"
, "100101", "10011010", "0101", "0001", "110", "01001", "10011011", "010000"
, "0111", "10011000", "0110", "00100", "10011001", "10011110", "00101"
, "111", "10011111", "1000", "00110", "00111", "10011100", "10011101"
, "000010", "10010010", "10010011", "10010000"
};
char dec[512];
memset(dec, 0, sizeof(dec));
char* p = bin;
for (int i = 0; ; ++i)
{
int sel = -1;
for (int j = 0; sel == -1 && j < sizeof(code)/sizeof(code[0]); ++j)
if (is_same_in_start(p, code[j]))
sel = j;
if (sel == -1)
break;
p += strlen(code[sel]);
dec[i] = dest[sel];
}
printf("%s\n", dec);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int Mmax(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int Mmin(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int nod(long long int a, long long int b) {
while (a && b) {
if (a > b)
a %= b;
else
b %= a;
}
return Mmax(a, b);
}
long long int nok(long long int a, long long int b) {
return a * b / nod(a, b);
}
bool IsPrime(long long int x) {
if (x < 2) return false;
long long int X = sqrt(x), i;
for (i = 2; i <= X; i++)
if (x % i == 0) return false;
return true;
}
void hanoi(int n, int A, int C, int B) {
if (n == 1) {
cout << n << " " << A << " " << C << endl;
} else {
hanoi(n - 1, A, B, C);
cout << n << " " << A << " " << C << endl;
hanoi(n - 1, B, C, A);
}
}
string pr2(string a, int d) {
if (d == 0) return "0";
string b;
long long int sz = a.size(), i, prenos = 0;
for (i = 0; i < sz; i++) {
b[i] = a[i];
}
for (i = sz - 1; i > -1; i--) {
a[i] = ((b[i] - '0') * d + prenos) % 10 + '0';
prenos = ((b[i] - '0') * d + prenos) / 10;
}
if (prenos) a = char(prenos + '0') + a;
return a;
}
string sum(string a, string b) {
bool carry = false;
long long int i, sz1, sz2, maxsz, minsz;
string c, d;
sz1 = a.size();
sz2 = b.size();
maxsz = max(sz1, sz2);
minsz = min(sz1, sz2);
while (sz1 < maxsz) {
sz1++;
a = '0' + a;
}
while (sz2 < maxsz) {
sz2++;
b = '0' + b;
}
for (i = maxsz - 1; i > -1; i--) {
d = char((a[i] + b[i] - 96 + carry) % 10 + 48) + d;
if (a[i] + b[i] - 96 + carry > 9)
carry = true;
else
carry = false;
}
if (carry == true) d = char('1') + d;
return d;
}
string pr(string a, string b) {
string res = "0", p, p2;
int sz = a.size(), x = 0;
for (sz = a.size(); sz > 0; sz--, x++) {
int d = a[sz - 1] - '0';
a = a.erase(sz - 1, 1);
p2 = pr2(b, d);
p2 += p;
res = sum(res, p2);
p += "0";
}
return res;
}
bool vesokosna(long long int x) {
return (x % 4 == 0 && x % 100 || x % 400 == 0);
}
long long int reverse(long long int x) {
long long int mirror = 0;
while (x) {
mirror = mirror * 10 + x % 10;
x /= 10;
}
return mirror;
}
long long int ost(string x, long long int k) {
long long int num = 0, i, sz = x.size();
for (i = 0; i < sz; i++) {
num = num * 10;
num += x[i] - '0';
num %= k;
}
return num;
}
const int inf = 1 << 30;
int dp[128];
bool forbidden[128][128];
int main() {
string s;
cin >> s;
dp[s[0]] = 1;
int sz = s.size(), i, j;
int k;
cin >> k;
for (i = 0; i < k; i++) {
char x, y;
cin >> x >> y;
forbidden[x][y] = true;
forbidden[y][x] = true;
}
int MaxAnswer = 1;
for (i = 1; i < sz; i++) {
if (!forbidden[s[i]][s[i]]) dp[s[i]]++;
for (j = 'a'; j <= 'z'; j++) {
if (j == s[i]) continue;
if (!forbidden[j][s[i]]) {
dp[s[i]] = max(dp[s[i]], dp[j] + 1);
}
}
if (dp[s[i]] > MaxAnswer) MaxAnswer = dp[s[i]];
}
cout << s.size() - MaxAnswer << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Maxn = 1005;
const int Maxd = 4;
const int dy[Maxd] = {-1, 0, 1, 0};
const int dx[Maxd] = {0, -1, 0, 1};
int n, m;
char B[Maxn][Maxn];
bool X[Maxn][Maxn];
int odd;
int res;
bool Has(int r, int c) {
return 0 <= r && r < n && 0 <= c && c < m && B[r][c] == '1';
}
int Neighs(int r, int c) {
int res = 0;
for (int i = 0; i < Maxd; i++) res += Has(r + dy[i], c + dx[i]);
return res;
}
bool Corner(int r, int c) {
for (int i = 0; i < Maxd; i++)
if (Has(r + dy[i], c + dx[i]) &&
Has(r + dy[(i + 1) % Maxd], c + dx[(i + 1) % Maxd]))
return true;
return false;
}
void Erase(int r, int c) {
if (r < 0 || r >= n || c < 0 || c >= m || B[r][c] == '0') return;
B[r][c] = '0';
for (int i = 0; i < Maxd; i++) Erase(r + dy[i], c + dx[i]);
}
bool Connected() {
int comp = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (B[i][j] == '1') {
comp++;
Erase(i, j);
}
return comp == 1;
}
int getRes(int r, int c, int dy, int dx, int delta) {
if (X[r][c]) return delta;
return getRes(r + dy, c + dx, dy, dx, delta + 1);
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf(" %c", &B[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
X[i][j] = B[i][j] == '1' && (Corner(i, j) || Neighs(i, j) <= 1);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (X[i][j]) {
int deg = 0;
for (int d = 0; d < Maxd; d++)
if (Has(i + dy[d], j + dx[d])) {
deg++;
int got = getRes(i + dy[d], j + dx[d], dy[d], dx[d], 1);
res = gcd(res, got);
}
odd += deg % 2;
}
if (odd <= 2 && Connected() && res > 1) {
set<int> divs;
for (int i = 1; i * i <= res; i++)
if (res % i == 0) {
if (i > 1) divs.insert(i);
if (res / i > 1) divs.insert(res / i);
}
for (set<int>::iterator it = divs.begin(); it != divs.end(); it++) {
if (it != divs.begin()) printf(" ");
printf("%d", *it);
}
printf("\n");
} else
printf("-1\n");
return 0;
}
| 5 |
#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <set>
using namespace std;
int hailist[14];
int shaicount[10];
int haicount[10];
set<int> ans;
bool dfs(int i);
void solve(int *hailist);
int main()
{
while(1){
int eof;
fill(hailist,hailist+13,0);
for(int i=0;i<13;i++){
char temp;
eof=scanf(" %c",&temp);
if(eof==EOF)break;
hailist[i]=(int)temp-'0'-1;
}
if(eof==EOF)break;
ans.clear();
solve(hailist);
if(ans.empty())cout<<0<<"\n";
else{
set<int>::iterator it = ans.begin();
for(int i=0;i<ans.size()-1;i++){cout<<*it<<" ";it++;}
cout<<*it<<"\n";
}
}
return 0;
}
void solve(int *hailist){
for(int i=0;i<10;i++) shaicount[i]=0;
shaicount[9]=1;//[vI¹Ì½ßÉ
for(int i=0;i<13;i++) shaicount[hailist[i]]++;//²ÆÉvÌðJEg
for(int i=0;i<9;i++){
if(shaicount[i]==4)continue;
for(int j=0;j<10;j++)haicount[j]=shaicount[j];
haicount[i]++;//vðê«·
for(int j=0;j<9;j++){
if(haicount[j]>=2){
haicount[j]-=2;
//for(int i=0;i<9;i++)cout<<haicount[i];
//cout<<"\n";
if(dfs(0)) {ans.insert(i+1);break;}
haicount[j]+=2;
}
}
}
return;
}
bool dfs(int i){
while(!haicount[i])i++;
if(i==9)return true;
if(haicount[i]>=3){
haicount[i]-=3;//Ï»·éOÌóÔðÛ¶µÈ¢Æg¦È¢H
if(dfs(i))return true;
haicount[i]+=3;
}
if(i>=7)return false;
if(haicount[i]&&haicount[i+1]&&haicount[i+2]){
haicount[i]--;haicount[i+1]--;haicount[i+2]--;
if(dfs(i))return true;
haicount[i]++;haicount[i+1]++;haicount[i+2]++;
}
return false;
} | 0 |
#include <bits/stdc++.h>
#define list _list
#define max(a,b) (a>b?a:b)
#define min(a,b) (a<b?a:b)
using namespace std;
const int N=105;
short s[N][N],f[N][N][N][N],line[N][N],list[N][N];
int gc(){
char ch=getchar();
while(ch!='.'&&ch!='o'&&ch!='E') ch=getchar();
if (ch=='.') return 0;
if (ch=='o') return 1;
return 2;
}
int main(){
int n,m,t,x,y; cin>>n>>m;
for (int i=1; i<=n; ++i)
for (int j=1; j<=m; ++j){
t=gc();
if (t==2) x=i,y=j;
if (t==1) s[i][j]=1;
}
for (int i=1; i<=n; ++i)
for (int j=1; j<=m; ++j){
line[i][j]=line[i][j-1]+s[i][j];
list[i][j]=list[i-1][j]+s[i][j];
}
int ans=0,sum;
for (int i=0; i<=n-x; ++i)
for (int j=0; j<x; ++j)
for (int k=0; k<=m-y; ++k)
for (int l=0; l<y; ++l){
if (x+i+1<=n-j) sum=max(0,line[x+i+1][min(m-l,y+k)]-line[x+i+1][max(k,y-l-1)]); else sum=0;
f[i+1][j][k][l]=max(f[i+1][j][k][l],f[i][j][k][l]+sum);
if (x-j-1>i) sum=max(0,line[x-j-1][min(m-l,y+k)]-line[x-j-1][max(k,y-l-1)]); else sum=0;
f[i][j+1][k][l]=max(f[i][j+1][k][l],f[i][j][k][l]+sum);
if (y+k+1<=m-l) sum=max(0,list[min(n-j,x+i)][y+k+1]-list[max(i,x-j-1)][y+k+1]); else sum=0;
f[i][j][k+1][l]=max(f[i][j][k+1][l],f[i][j][k][l]+sum);
if (y-l-1>k) sum=max(0,list[min(n-j,x+i)][y-l-1]-list[max(i,x-j-1)][y-l-1]); else sum=0;
f[i][j][k][l+1]=max(f[i][j][k][l+1],f[i][j][k][l]+sum);
ans=max(ans,f[i][j][k][l]);
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 20;
double PI = acos(-1);
double dp[1 << maxn], l, r;
bool vis[1 << maxn];
int a[maxn], n;
struct vec {
double x, y;
vec operator-(const vec &b) { return (vec){x - b.x, y - b.y}; }
} p[maxn];
vec rotate(const vec &v, const double &a) {
return (vec){v.x * cos(a) - v.y * sin(a), v.x * sin(a) + v.y * cos(a)};
}
double solve(int mask) {
if (vis[mask]) return dp[mask];
vis[mask] = 1;
dp[mask] = l;
for (int i = 0; i < n; i += 1)
if ((1 << i) & mask) {
double pl = solve((1 << i) ^ mask);
vec v = (vec){pl, 0} - p[i];
v = rotate(v, PI * a[i] / 180);
if (v.y >= 0)
dp[mask] = r;
else
dp[mask] = max(dp[mask], p[i].x - p[i].y / v.y * v.x);
}
return min(r, dp[mask]);
}
int main() {
scanf("%d %lf %lf", &n, &l, &r);
for (int i = 0; i < n; i += 1) scanf("%lf %lf %d", &p[i].x, &p[i].y, a + i);
vis[0] = true;
dp[0] = l;
printf("%.9lf", solve((1 << n) - 1) - l);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
const long long LLINF = 1e18 + 1;
int ABS(int x) {
if (x < 0) x = -x;
return x;
}
long long ABS(long long x) {
if (x < 0) x = -x;
return x;
}
long long n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int a, b, n;
cin >> n >> a >> b;
string s;
cin >> s;
cout << ((s[a - 1] == s[b - 1]) ? 0 : 1) << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, i, j, ck = 0, sum = 0;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (i = 0; i < n; i++) {
if (arr[i] <= 25) {
ck++;
} else {
sum = abs(25 - arr[n - 1]);
}
}
if (ck == n) {
cout << "0" << endl;
} else {
cout << sum << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag1[1000] = {0};
int flag2[1000] = {0};
int n;
string str[50];
cin >> n;
for (int i = 0; i < n; i++) cin >> str[i];
for (int i = 0; i < n; i++) {
int j;
for (j = 0; j < str[i].size() - 1; j++) {
int t = (str[i][j] - 'a') * 26 + str[i][j + 1] - 'a';
flag2[t] = 1;
flag1[str[i][j] - 'a'] = 1;
}
flag1[str[i][j] - 'a'] = 1;
}
int k;
for (k = 0; k < 26; k++) {
if (!flag1[k]) break;
}
if (k < 26)
cout << (char)('a' + k) << endl;
else {
for (int i = 0; i < 26 * 26; i++) {
if (!flag2[i]) {
cout << (char)('a' + i / 26) << (char)('a' + i % 26) << endl;
break;
}
}
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main() {
int n, a, x = 1000001, y = -1000001;
long long b = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
b = b + a;
if (a > y) y = a;
if (a < x) x = a;
}
cout << x << " " << y << " " << b << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s, a;
int vis[101];
vector<int> g[101];
void dfs(int x) {
vis[x] = -1;
for (int i = 0; i < g[x].size(); i++) {
if (vis[g[x][i]] == -1) continue;
dfs(g[x][i]);
}
s += (x + 'a');
}
int main() {
int t;
scanf("%d", &t);
s = "";
memset(vis, 0, sizeof(vis));
while (t--) {
cin >> a;
for (int i = 0; i < a.size() - 1; i++) {
g[a[i] - 'a'].push_back(a[i + 1] - 'a');
vis[a[i + 1] - 'a'] = 1;
}
if (vis[a[0] - 'a'] != 1) vis[a[0] - 'a'] = 2;
}
for (int i = 0; i < 26; i++) {
if (vis[i] == 2) dfs(i);
}
reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int ans = 0;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i >= 1 && arr[i] - arr[i - 1] == 1) {
if (i == 1 && arr[0] == 1)
ans += 2;
else if (i == n - 1 && arr[i] == 1000)
ans += 2;
else
ans++;
sum = max(sum, ans);
} else {
ans = 0;
}
}
cout << max(sum - 1, 0) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> f(n), s(n);
map<int, pair<int, int>> m;
for (int i = 0; i < n; ++i) {
cin >> f[i] >> s[i];
m[f[i]] = make_pair(i, 1);
m[s[i]] = make_pair(i, 2);
}
int nf = n / 2, ns = n / 2;
if (n & 1) {
f[nf] < s[nf] ? ++nf : ++ns;
}
int mf = 0, ms = 0;
auto it = m.begin();
while (mf + ms != n) {
mf += it->second.second == 1;
ms += it->second.second == 2;
++it;
}
for (int i = 0; i < n; ++i)
if (i < max(nf, mf))
cout << "1";
else
cout << "0";
cout << endl;
for (int i = 0; i < n; ++i)
if (i < max(ns, ms))
cout << "1";
else
cout << "0";
}
| 2 |
#include<bits/stdc++.h>
#define io_o() ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define fst first
#define scd second
// #define endl "\n"
#define pb push_back
#define ALL(x) x.begin(),x.end()
#define REP(i,n) for(int i = 0; i < n; i++)
#define print1d(a) {for(auto v: a) cout << v << " "; cout << endl;}
#define int ll
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int k2d(int k, vi a){
int n = 0;
for(int i = 21; i >= 0; i--){
n = n * k + a[i];
// assert(a[i] < k and a[i] >= 0);
}
return n;
}
vi d2k(int k, int n){
vi tmp(22); int i = 0;
while(n){
tmp[i++] = n % k;
n /= k;
}
return tmp;
}
vi reverse(int k, vi a){
vi ans(22);
for(int i = 0; i < 22; i++){
ans[i] = (-a[i] + k) % k;
}
return ans;
}
vi add(int k, vi a, vi b){
vi out(22);
for(int i = 0; i < 22; i++){
// assert(a[i] >= 0 and b[i] >= 0);
out[i] = ((a[i] + b[i]) % k + k) % k;
// assert(a[i] >= 0 and a[i] < k);
}
return out;
}
int32_t main(){
// io_o();
int t; cin >> t;
while(t--){
int n, k; cin >> n >> k;
vi offset(22);
// int pwd = 5245;
// vi pass = d2k(k, pwd);
// if(t == 0) cout << "1" << endl;
// cout << "# P = "; print1d(pass);
for(int i = 0; i < n; i++){
// cout << "In the candidate " << i << endl;
// cout << "offset: "; print1d(offset);
vi can = d2k(k, i);
// cout << "origin: "; print1d(can);
vi out;
if(i % 2) out = add(k, offset, reverse(k, can));
else out = add(k, offset, can);
// cout << "output: "; print1d(out);
cout << k2d(k, out) << endl;
// cout << "curpwd: "; print1d(pass);
// vi tmp = pass; add(k, tmp, reverse(k, offset));
// cout << "passwd: "; print1d(tmp);
int r = 0;
cin >> r;
// if(k2d(k, pass) == k2d(k, out)) r = 1;
if(r == 1) {
// cout << "The real password is " << k2d(k, tmp) << endl;
break;
}
// add(k, pass, out);
offset = add(k, out, reverse(k, offset));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxN = 1e6 + 5;
const long long N = 1e6;
long long n;
long long a[maxN], b[maxN];
void solve() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) b[i] = a[i];
sort(b + 1, b + 1 + n);
vector<long long> v;
for (long long i = 1; i <= n; i++)
if (a[i] != b[i]) v.push_back(a[i]);
long long minn = 1e18;
for (long long i = 1; i <= n; i++) minn = min(minn, a[i]);
for (auto t : v) {
if (t % minn != 0) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
ios_base::sync_with_stdio(0);
long long T;
cin >> T;
while (T--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, le, lw, re, rw, ans = 0x3f3f3f3f;
char rec[300005];
int main() {
scanf("%d%s", &n, rec+1);
for (int i = 1; i <= n; i++) {
(rec[i] == 'E' ? re : rw)++;
}
for (int i = 1; i <= n; i++) {
(rec[i] == 'E' ? re : rw)--;
ans = min(ans, lw + re);
(rec[i] == 'E' ? le : lw)++;
}
printf("%d", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool s[55];
int ans[55];
char names[55][5] = {"", "Aa", "Ab", "Ba", "Bb", "Ca", "Cb", "Da", "Db",
"Ea", "Eb", "Fa", "Fb", "Ga", "Gb", "Ha", "Hb", "Ia",
"Ib", "Ja", "Jb", "Ka", "Kb", "La", "Lb", "Ma", "Mb",
"Na", "Nb", "Oa", "Ob", "Pa", "Pb", "Qa", "Qb", "Ra",
"Rb", "Sa", "Sb", "Ta", "Tb", "Ua", "Ub", "Va", "Vb",
"Wa", "Wb", "Xa", "Xb", "Ya", "Yb", "Za", "Zb"};
int main() {
memset(ans, 0, sizeof(ans));
int n, k, p;
char req[10];
scanf("%d%d\n", &n, &k);
p = 2;
ans[1] = 1;
for (int i = 1, j, k1, k2; i <= n - k + 1; i++) {
scanf("%s", req);
if (req[0] == 'Y') {
for (j = p; j <= k + i - 1; j++) {
for (k1 = 1; k1 <= n; k1++) {
int flag = 1;
for (k2 = i; k2 <= j; k2++) {
if (k1 == ans[k2]) {
flag = 0;
break;
}
}
if (flag == 1) break;
}
ans[p++] = k1;
}
} else {
if (i == n - k + 1) {
for (j = p; j <= n; j++) {
ans[j] = ans[p - 1];
}
break;
}
if (p == i)
ans[p] = ans[p - 1];
else
ans[p] = ans[i];
p++;
}
}
for (int i = 1; i <= n; i++) printf("%s ", names[ans[i]]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[x];
for (int i = 0; i < x; i++) cin >> a[i];
int bg = 0, fi = n + 1, m, hf;
int ans = INT_MIN;
for (int i = 0; i < x; i++) {
if (i == 0) {
m = a[i] - bg;
if (m > ans) ans = m;
} else {
m = a[i] - a[i - 1] - 1;
hf = (m + 1) / 2;
if (hf + 1 > ans) ans = hf + 1;
}
}
m = fi - a[x - 1];
if (m > ans) ans = m;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1000001;
const int MI = 100005;
const int MT = 10001;
void solve() {
int n;
cin >> n;
int i, j, kol = 0;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
long long int t;
t = sqrt((i * i) + (j * j));
if (t * t == (i * i) + (j * j) && t <= n) {
kol++;
}
}
}
cout << kol << endl;
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
unsigned long long suml = 0, sumr = 0;
int i;
int piv;
for (int i = 0; i < s.size(); i++)
if (s[i] == '^') piv = i;
for (i = 0; i < s.size(); i++) {
if (s[i] == '^') break;
if (s[i] <= '9' && s[i] >= '0') {
unsigned long long val = 1ll * (piv - i) * (s[i] - '0');
suml += val;
}
}
i++;
for (; i < s.size(); i++) {
if (s[i] <= '9' && s[i] >= '0') {
unsigned long long val = 1ll * (i - piv) * (s[i] - '0');
sumr += val;
}
}
if (sumr == suml)
cout << "balance";
else if (sumr < suml)
cout << "left";
else
cout << "right";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-6;
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
template <class T>
bool INRANGE(T x, T a, T b) {
return a <= x && x <= b;
}
void split1(const string& str, vector<string>& out) {
string::size_type st = 0;
string::size_type next = 0;
int word_num = 0;
string tmp = str;
do {
next = tmp.find(" ", st);
string word = tmp.substr(st, next - st);
if (word.length() >= 1) {
out.push_back(word);
}
st = next + 1;
} while (next != string::npos);
}
int main() {
int n;
scanf("%d ", &n);
vector<string> team_names;
for (int i = 0; i < n; i++) {
char str[256];
scanf("%s ", str);
team_names.push_back(string(str));
}
map<string, pair<int, pair<int, int> > > mp;
for (int i = 0; i < n * (n - 1) / 2; i++) {
char str[256];
char str2[256];
scanf("%s %s ", str, str2);
for (int k = 0; k < 256; k++) {
if (str[k] == '-' || str[k] == ':') {
str[k] = ' ';
}
if (str2[k] == '-' || str2[k] == ':') {
str2[k] = ' ';
}
}
vector<string> vs;
split1(string(str), vs);
vector<string> vs2;
split1(string(str2), vs2);
string team1, team2;
int goal1, goal2;
team1 = vs[0];
team2 = vs[1];
goal1 = atoi(vs2[0].c_str());
goal2 = atoi(vs2[1].c_str());
mp[team1].first += goal1 > goal2 ? 3 : goal1 == goal2 ? 1 : 0;
mp[team1].second.first += goal1 - goal2;
mp[team1].second.second += goal1;
mp[team2].first += goal2 > goal1 ? 3 : goal2 == goal1 ? 1 : 0;
mp[team2].second.first += goal2 - goal1;
mp[team2].second.second += goal2;
}
map<pair<int, pair<int, int> >, string> inv_mp;
{
map<string, pair<int, pair<int, int> > >::iterator it;
for (it = mp.begin(); it != mp.end(); it++) {
inv_mp[it->second] = it->first;
}
}
vector<string> winners;
{
map<pair<int, pair<int, int> >, string>::reverse_iterator inv_it =
inv_mp.rbegin();
for (int i = 0; i < n / 2; inv_it++, i++) {
winners.push_back(inv_it->second);
}
}
sort(winners.begin(), winners.end());
for (int i = 0; i < ((int)winners.size()); i++) {
printf("%s\n", winners[i].c_str());
}
return 0;
}
| 1 |
#include <iostream>
#include <map>
bool a[5010][5010];
std::pair<int, int> poles[3010];
bool exist(int x, int y) {
if (0 > x || 5000 < x || 0 > y || 5000 < y) { return false; }
return a[x][y];
}
int main() {
while (true) {
int n;
std::cin >> n;
if (n == 0) { break; }
for (int i = 0; i < 3009; i++) {
for (int j = 0; j < 3009; j++) {
a[i][j] = false;
}
}
for (int i = 0; i < n; i++) {
int x, y;
std::cin >> x >> y;
a[x][y] = true;
poles[i] = std::make_pair(x, y);
}
int max = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
int dx = poles[i].first - poles[j].first;
int dy = poles[i].second - poles[j].second;
if (exist(poles[j].first + dy, poles[j].second - dx) && exist(poles[i].first + dy, poles[i].second - dx)) {
max = std::max(dx * dx + dy * dy, max);
continue;
}
if (exist(poles[j].first - dy, poles[j].second + dx) && exist(poles[i].first - dy, poles[i].second + dx)) {
max = std::max(dx * dx + dy * dy, max);
}
}
}
std::cout << max << std::endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
set<long long int> st;
long long int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, mx = 0, mx1 = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
long long int x;
cin >> x;
mx = max(mx, x);
a[i] = x;
}
for (long long int i = 1; i * i <= mx; i++) {
if (mx % i == 0) {
st.insert(i);
st.insert(mx / i);
}
}
for (int i = 1; i <= n; i++) {
if (st.find(a[i]) == st.end()) {
mx1 = max(a[i], mx1);
} else {
st.erase(st.find(a[i]));
}
}
cout << mx << " " << mx1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2001;
const long long mod = 998244353;
long long dp[maxn], f[maxn][maxn], g[maxn], h[maxn];
long long power[2][maxn];
long long inverse(long long a, const long long &p) {
long long ret = 1, e = p - 2;
while (e) {
if (e & 1) ret = ret * a % p;
a = a * a % p, e >>= 1;
}
return ret;
}
int main() {
int n;
long long a, b;
scanf("%d %lld %lld", &n, &a, &b);
if (n <= 2) {
if (n == 1)
printf("0\n");
else
printf("1\n");
return 0;
}
long long p = (a * inverse(b, mod)) % mod;
power[0][0] = power[1][0] = 1;
for (int i = 1; i <= n; i++)
power[0][i] = (power[0][i - 1] * p) % mod,
power[1][i] = (power[1][i - 1] * (mod - p + 1)) % mod;
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
f[i][0] = 1;
for (int j = 1; j <= i; j++)
f[i][j] =
(f[i - 1][j - 1] * power[0][i - j] + f[i - 1][j] * power[1][j]) % mod;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) g[i] = (g[i] + g[j] * f[i][j]) % mod;
g[i] = (mod - g[i] + 1) % mod;
}
long long t;
for (int i = 3; i <= n; i++) {
t = 0;
for (int j = 1; j < i; j++)
t = (t + (f[i][j] * g[j] % mod) * (dp[j] + h[i - j]) % mod) % mod;
dp[i] = ((t + (((i * (i - 1) / 2) % mod) % mod)) *
inverse(mod + 1 - g[i], mod) % mod) %
mod;
h[i] = ((dp[i] * g[i]) % mod + t) % mod;
}
printf("%lld\n", (dp[n] + mod) % mod);
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
struct XY
{
int x;
int y;
};
int main ()
{
int n;
cin>>n;
while(n!=0)
{
vector<XY> a;
XY j;
j.x=0;
j.y=0;
a.push_back(j);
for(int i=0;i<n-1;i++)
{
int x,y;
cin>>x>>y;
j=a[x];
switch(y)
{
case 0:
j.x--;
break;
case 1:
j.y--;
break;
case 2:
j.x++;
break;
case 3:
j.y++;
break;
}
a.push_back(j);
}
int q,w,e,r;
q=0;w=0;e=0;r=0;
for(int i=0;i<a.size();i++)
{
if(a[i].x>q)q=a[i].x;
if(a[i].x<w)w=a[i].x;
if(a[i].y>e)e=a[i].y;
if(a[i].y<r)r=a[i].y;
}
cout<<abs(q-w)+1<<" "<<abs(e-r)+1<<endl;
cin>>n;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long d[78], d1a[78], dna[78], d1b[78], dnb[78];
long long min1(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
int get1n(long long a, int n, long long& d1, long long& dn, long long* m1,
long long* mn) {
if (m1[n]) {
d1 = m1[n];
dn = mn[n];
return 0;
}
if (a == 1) {
d1 = 0;
dn = (n + 1) / 2;
return 0;
}
if (n == 1) {
d1 = (a == 2);
dn = (a == 1);
return 0;
}
if (a == d[n]) {
dn = 0;
d1 = (n + 1) / 2;
return 0;
}
long long t1, tn;
if (a <= d[n - 1]) {
get1n(a, n - 1, t1, tn, m1, mn);
d1 = min1(t1, tn + 2);
dn = min1(t1, tn) + (n + 1) / 2;
} else {
get1n(a - d[n - 1], n - 2, t1, tn, m1, mn);
d1 = t1 + 1;
dn = tn;
}
m1[n] = d1;
mn[n] = dn;
}
long long work(long long a, long long b, int n) {
long long d1, dn, t1, tn;
if (a == b) return 0;
if (n == 1) return a != b;
if (a > d[n - 1])
return work(a - d[n - 1], b - d[n - 1], n - 2);
else if (b > d[n - 1]) {
get1n(a, n - 1, d1, dn, d1a, dna);
get1n(b - d[n - 1], n - 2, t1, tn, d1b, dnb);
return min1(d1, dn) + 1 + t1;
} else {
get1n(a, n - 1, d1, dn, d1a, dna);
get1n(b, n - 1, t1, tn, d1b, dnb);
long long get = min1(dn + t1 + 2, d1 + tn + 2);
return min1(get, work(a, b, n - 1));
}
}
int main() {
int i, t, n;
d[1] = 2;
d[2] = 3;
for (i = 3; i <= 78; i++) {
d[i] = d[i - 1] + d[i - 2];
}
cin >> t >> n;
n = min1(n, 78);
while (t--) {
long long a, b;
scanf("%I64d%I64d", &a, &b);
if (a > b) {
long long t = a;
a = b;
b = t;
}
memset(d1a, 0, sizeof(d1a));
memset(d1b, 0, sizeof(d1b));
memset(dna, 0, sizeof(dna));
memset(dnb, 0, sizeof(dnb));
printf("%I64d\n", work(a, b, n));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a.push_back(x);
}
sort(a.begin(), a.end());
printf("%d\n", a[(n + 1) / 2 - 1]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > amt;
vector<pair<long long, long long> > payoffs;
vector<long long> maximum_payoff;
int upper_bound(int ts) {
int lo = 0;
int ho = payoffs.size();
int mid;
while (lo < ho) {
mid = (lo + ho) / 2;
if (payoffs[mid].second > ts)
ho = mid;
else
lo = mid + 1;
}
return lo;
}
int main() {
int N;
cin >> N;
amt.resize(N);
for (int i = 0; i < N; i++) {
cin >> amt[i].first;
amt[i].second = 0;
}
int Q;
cin >> Q;
int ts = 0;
while (Q--) {
int type;
cin >> type;
ts++;
if (type == 1) {
long long p, x;
cin >> p >> x;
amt[p - 1].first = x;
amt[p - 1].second = ts;
} else {
long long x;
cin >> x;
payoffs.push_back(pair<long long, long long>(x, ts));
}
}
int M = payoffs.size();
if (M == 0) {
for (int i = 0; i < N; i++) cout << amt[i].first << " ";
} else {
maximum_payoff.resize(M);
maximum_payoff[M - 1] = payoffs[M - 1].first;
for (int i = M - 2; i >= 0; i--)
maximum_payoff[i] = ((payoffs[i].first) > (maximum_payoff[i + 1])
? (payoffs[i].first)
: (maximum_payoff[i + 1]));
int idx;
for (int i = 0; i < N; i++) {
idx = upper_bound(amt[i].second);
if (idx < M)
amt[i].first =
((amt[i].first) > (maximum_payoff[idx]) ? (amt[i].first)
: (maximum_payoff[idx]));
cout << amt[i].first << " ";
}
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
class TaskD {
long long d[101][4][4];
public:
long long min(long long a, long long b);
void solve() {
int t[3][3];
memset(d, 0, sizeof(d));
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) scanf("%d", &t[i][j]);
int n;
scanf("%d", &n);
for (int k = 1; k <= n; k++)
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
if (i != j) {
int left = (3 ^ i ^ j);
long long res = min(d[k - 1][i][left] + t[i][j] + d[k - 1][left][j],
d[k - 1][i][j] + t[i][left] + d[k - 1][j][i] +
t[left][j] + d[k - 1][i][j]);
d[k][i][j] = res;
}
}
std::cout << d[n][0][2];
}
long long int min(long a, long b);
};
int main() {
TaskD solver;
solver.solve();
return 0;
}
long long int TaskD::min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const string MOVES = "LRUD";
int main() {
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
string s;
cin >> s;
map<char, int> cnt;
for (auto c : MOVES) cnt[c] = 0;
for (auto c : s) ++cnt[c];
int v = min(cnt['U'], cnt['D']);
int h = min(cnt['L'], cnt['R']);
if (min(v, h) == 0) {
if (v == 0) {
h = min(h, 1);
cout << 2 * h << endl << string(h, 'L') + string(h, 'R') << endl;
} else {
v = min(v, 1);
cout << 2 * v << endl << string(v, 'U') + string(v, 'D') << endl;
}
} else {
string res;
res += string(h, 'L');
res += string(v, 'U');
res += string(h, 'R');
res += string(v, 'D');
cout << res.size() << endl << res << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double l, r, mid, p[105], dp[105][105 * 100], sum[105];
int n, m, a[105], b[105];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d%lf", &a[i], &b[i], &p[i]);
p[i] /= 100.0;
}
l = 0;
r = 1e15;
for (int k = 0; k < 100; k++) {
for (int j = 0; j <= m; j++) dp[n][j] = j;
for (int j = m + 1; j < 10500; j++) dp[n][j] = 1e15;
mid = (l + r) / 2;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 10500 - 100; j++)
dp[i][j] =
(min(mid + (double)a[i] + j, dp[i + 1][j + a[i]])) * p[i] +
(min(mid + (double)b[i] + j, dp[i + 1][j + b[i]])) * (1 - p[i]);
if (dp[0][0] < mid)
r = mid;
else
l = mid;
}
printf("%.10f\n", mid);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, x[N], y[N], cur1, cur2, ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
sort(x + 1, x + n + 1);
sort(y + 1, y + n + 1);
cur1 = x[1];
cur2 = x[1] * x[1];
for (int i = 2; i <= n; i++) {
ans += (i - 1) * x[i] * x[i] - 2 * x[i] * cur1 + cur2;
cur1 += x[i];
cur2 += x[i] * x[i];
}
cur1 = y[1];
cur2 = y[1] * y[1];
for (int i = 2; i <= n; i++) {
ans += (i - 1) * y[i] * y[i] - 2 * y[i] * cur1 + cur2;
cur1 += y[i];
cur2 += y[i] * y[i];
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int binExp(long long int x, long long int n, long long int m) {
long long int res = 1;
while (n) {
if (n & 1) res = (res * x) % m;
x = (x * x) % m;
n >>= 1;
}
return res;
}
long long int modInv(long long int i, long long int m) {
return binExp(i, m - 2, m);
}
long long int add(long long int a, long long int b) {
long long int res = a + b;
if (res >= 1000000007) res -= 1000000007;
if (res < 0) res += 1000000007;
return res;
}
long long int mul(long long int a, long long int b) {
long long int res = (a) * (b);
res %= 1000000007;
if (res < 0) res += 1000000007;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n % 3 == 0) {
cout << n / 3 << " " << n / 3 << endl;
} else if (n % 3 == 1) {
cout << n / 3 + 1 << " " << n / 3 << endl;
} else {
cout << n / 3 << " " << n / 3 + 1 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m;
int a[3000];
int maxlen[3000];
int dfs(int x) {
if (x * 2 > m) return 0;
maxlen[x] = std::max(dfs(x * 2) + a[x * 2], dfs(x * 2 + 1) + a[x * 2 + 1]);
return maxlen[x];
}
int calc(int x, int nowSum) {
if (x * 2 > m) return 0;
int L = x * 2, R = x * 2 + 1;
int tmpL = maxlen[x] - (maxlen[L] + a[L]);
tmpL += calc(x * 2, nowSum + tmpL + a[L]);
int tmpR = maxlen[x] - (maxlen[R] + a[R]);
tmpR += calc(x * 2 + 1, nowSum + tmpR + a[R]);
return tmpL + tmpR;
}
int main() {
scanf("%d", &n);
n++;
m = (1 << n) - 1;
int tot = 0;
for (int i = 2; i <= m; i++) {
scanf("%d", &a[i]);
tot += a[i];
}
dfs(1);
printf("%d\n", calc(1, 0));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string second;
cin >> second;
bool check = 0;
string tmp(1, second[0]);
for (int i = 1; i < second.size(); i++) {
if (second[i] == 'd' && second[i + 1] == 'o' && second[i + 2] == 't' &&
i < second.size() - 3)
tmp += '.', i += 2;
else if (second[i] == 'a' && second[i + 1] == 't' && !check &&
i < second.size() - 2)
tmp += '@', check = 1, i++;
else
tmp += second[i];
}
cout << tmp << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int f[160][160];
int main() {
int n;
scanf("%d", &n);
f[0][0] = 1;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= i; j++) {
f[i][j] = (f[i - 2][j] + (j ? f[i - 1][j - 1] : 0)) & 1;
}
}
for (int j = 0; j < 2; j++) {
printf("%d\n", n - j);
for (int i = 0; i <= n - j; i++) printf("%d ", f[n - j][i]);
puts("");
}
return 0;
}
| 2 |
#include <iostream>
#include <string>
using namespace std;
int main () {
int cnt=0;
string N;
cin >> N;
if (N[0]=='A')
cnt++;
for (int i=1;i<N.size();i++){
if (i!=1 && i!=N.size()-1 && N[i]=='C')
cnt+=2;
else if (N[i]-96<0)
cnt+=100;
}
cnt==3 ? cout << "AC" : cout << "WA";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string short_inp;
cin >> short_inp;
string sec[8];
if (short_inp.find("::") != string::npos) {
int pos = short_inp.find("::");
string s1 = short_inp.substr(0, pos) + ":";
string s2 = ":" + short_inp.substr(pos + 2);
int sec_num = 0;
while (s1.find(":") != string::npos) {
int pos = s1.find(":");
sec[sec_num] = s1.substr(0, pos);
s1 = s1.substr(pos + 1);
sec_num++;
}
sec_num = 7;
while (s2.rfind(":") != string::npos) {
int pos = s2.rfind(":");
sec[sec_num] = s2.substr(pos + 1);
s2 = s2.substr(0, pos);
sec_num--;
}
for (int i = 0; i < 8; i++) {
while (sec[i].size() < 4) sec[i] = "0" + sec[i];
cout << sec[i];
if (i < 7) cout << ":";
}
cout << endl;
} else {
short_inp += ":";
int sec_num = 0;
while (short_inp.find(":") != string::npos) {
int pos = short_inp.find(":");
sec[sec_num] = short_inp.substr(0, pos);
short_inp = short_inp.substr(pos + 1);
sec_num++;
}
for (int i = 0; i < 8; i++) {
while (sec[i].size() < 4) sec[i] = "0" + sec[i];
cout << sec[i];
if (i < 7) cout << ":";
}
cout << endl;
}
}
}
| 2 |
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long ll;
int n, m, s;
ll a[51][51], b[51][51];
ll c[51];
ll d[51];
int maxa = 0;
struct Data {
ll t, s, p;
bool operator<(const Data& d)const{return t > d.t;}
};
ll dijkstra(int g) {
priority_queue< Data > Q;
bool visited[51][2501] = {false};
Q.push({0, min(s, maxa * (n-1)), 1});
while(!Q.empty()) {
Data now = Q.top();
Q.pop();
if (now.p == g) {
return now.t;
}
if (visited[now.p][now.s]) continue;
visited[now.p][now.s] = true;
if (now.s + c[now.p] <= maxa * (n-1)) {
Q.push({now.t + d[now.p], now.s + c[now.p], now.p});
}
for (int j = 1; j <= n; j++){
if (a[now.p][j] == 0) continue;
int ns = now.s - a[now.p][j];
if (ns < 0) continue;
Q.push({now.t + b[now.p][j], ns, j});
}
}
}
int main() {
cin >> n >> m >> s;
for (int i = 0; i < m; i++) {
int u, v, aa, bb;
cin >> u >> v >> aa >> bb;
a[u][v] = a[v][u] = aa;
b[u][v] = b[v][u] = bb;
maxa = max(maxa, aa);
}
for (int i = 1; i <= n; i++){
cin >> c[i] >> d[i];
}
for (int i = 2; i <= n; i++) {
cout << dijkstra(i) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i,n) for(int i=0;i<n;i++)
#define endl ("\n")
#define pb push_back
#define mp make_pair
#define pl pair<ll, ll>
#define vl vector<ll>
#define fastIO ios_base::sync_with_stdio(false);cin.tie(NULL);
#define N 100005
void SieveOfEratosthenes(ll n)
{
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (ll p = 2; p * p <= n; p++)
{
if (prime[p] == true)
{
for (ll i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (ll p = 2; p <= n; p++)
if (prime[p])
cout << p << " ";
}
int main()
{
fastIO
ll t;cin>>t;
while(t--){
ll n,k;
cin>>n>>k;
double a[n];
for(ll i=0;i<n;i++)cin>>a[i];
ll x=0;
double sum=a[0];
for(ll i=1;i<n;i++){
double inc= (a[i]*100)/((double)(k));
if(sum < ceil(inc))
{
x+= (ceil(inc)-sum);
sum+= a[i]+(ceil(inc)-sum);
}
else sum+= a[i];
}
cout<<x<<endl;
}
} | 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167177216")
using namespace std;
const int MAXN = 9;
int main() {
long long n, A;
scanf("%I64d %I64d", &n, &A);
long long sum = 0;
vector<int> d(n);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
sum += d[i];
}
for (int i = 0; i < n; i++) {
long long without = sum - d[i];
long long need = A - without;
if (need <= 0) {
long long need = A - (n - 1);
if (d[i] <= need)
cout << 0 << ' ';
else {
cout << d[i] - need << ' ';
}
} else {
long long ans = need - 1;
long long razn = d[i] - need;
if (without - (n - 1) < razn) ans += (razn - without + (n - 1));
cout << ans << ' ';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, o = 1, e = 1;
long long sum = 0;
int odd[2005], even[2005];
memset(odd, 0, sizeof(odd));
memset(even, 0, sizeof(even));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x % 2 == 0) {
odd[o++] = x;
} else {
even[e++] = x;
}
}
if (o == e || (abs(o - e)) == 1) {
cout << 0 << endl;
return 0;
}
sort(odd + 1, odd + o);
sort(even + 1, even + e);
if (o > e) {
for (int i = 1; i <= o - e - 1; i++) sum += odd[i];
} else {
for (int i = 1; i <= e - o - 1; i++) sum += even[i];
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
map<long long, long long> m;
set<long long> s;
for (long long i = 0; i < k; ++i) {
if (m.count(a[i]))
s.erase(a[i]);
else
s.insert(a[i]);
m[a[i]]++;
}
for (long long i = k; i < n; ++i) {
if (s.empty())
cout << "Nothing\n";
else
cout << *s.rbegin() << '\n';
m[a[i - k]]--;
if (m[a[i - k]] == 1) s.insert(a[i - k]);
if (m[a[i - k]] == 0) s.erase(a[i - k]);
if (m[a[i]] > 0)
s.erase(a[i]);
else
s.insert(a[i]);
m[a[i]]++;
}
if (s.empty())
cout << "Nothing\n";
else
cout << *s.rbegin() << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 505;
int n, d[mxn][mxn];
char s[mxn];
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; ++i) d[i][i] = 1;
for (int l = 1; l < n; ++l)
for (int i = 1; i < n; ++i) {
int j = i + l;
if (j > n) continue;
d[i][j] = d[i][j - 1] + 1;
for (int k = i; k < j; ++k)
if (s[k] == s[j]) d[i][j] = min(d[i][j], d[i][k] + d[k + 1][j - 1]);
}
printf("%d\n", d[1][n]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5005;
const int MAX_M = 1005;
struct NODE {
int l, op, r;
char num[MAX_M];
};
int N, M;
int mi[MAX_M], ma[MAX_M], v[MAX_N];
map<string, int> mp;
NODE node[MAX_N];
int calc(int pos, int val) {
int ret = 0;
memset(v, 0, sizeof(v));
for (int i = 0; i < N; ++i) {
if (node[i].op == -1) {
v[i] = node[i].num[pos] == '1';
} else {
int opl = node[i].l == -1 ? val : v[node[i].l];
int opr = node[i].r == -1 ? val : v[node[i].r];
if (node[i].op == 0)
v[i] = opl & opr;
else if (node[i].op == 1)
v[i] = opl | opr;
else
v[i] = opl ^ opr;
}
ret += v[i];
}
return ret;
}
int main() {
scanf("%d%d", &N, &M);
char tmpc[MAX_M];
for (int i = 0; i < N; ++i) {
scanf("%s", tmpc);
mp[(string)tmpc] = i;
scanf("%*s%s", tmpc);
if (tmpc[0] == '0' || tmpc[0] == '1') {
node[i].op = -1;
strcpy(node[i].num, tmpc);
} else {
node[i].l = tmpc[0] == '?' ? -1 : mp[(string)tmpc];
scanf("%s", tmpc);
if (tmpc[0] == 'A')
node[i].op = 0;
else if (tmpc[0] == 'O')
node[i].op = 1;
else
node[i].op = 2;
scanf("%s", tmpc);
node[i].r = tmpc[0] == '?' ? -1 : mp[(string)tmpc];
}
}
for (int i = 0; i < M; ++i) {
int na = calc(i, 1);
int nb = calc(i, 0);
if (na > nb)
mi[i] = 0, ma[i] = 1;
else if (na < nb)
mi[i] = 1, ma[i] = 0;
else
mi[i] = 0, ma[i] = 0;
}
for (int i = 0; i < M; ++i) printf("%d", mi[i]);
printf("\n");
for (int i = 0; i < M; ++i) printf("%d", ma[i]);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
if (n == 0)
cout << "0";
else {
if ((n + 1) % 2 == 0)
cout << (n + 1) / 2;
else
cout << n + 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, q;
int a[300005];
long long ans[300005], res[500 + 5][500 + 5];
vector<pair<pair<int, int>, int> > query;
void print() {
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
}
void solve() {
int last = n + 1;
for (auto x : query) {
int ind = x.first.first;
int inc = x.first.second;
int wh = x.second;
while (last - 1 >= 1 && last - 1 >= ind) {
last--;
for (int i = 1; i <= 500; i++) {
res[i][last % i] += a[last];
}
}
ans[wh] = res[inc][ind % inc];
}
}
long long solve_naive(int x, int y) {
long long res = 0;
for (int i = x; i <= n; i += y) res += a[i];
return res;
}
void store() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &x, &y);
if (y > 500) {
ans[i] = solve_naive(x, y);
} else {
query.push_back({{x, y}, i});
}
}
sort(query.begin(), query.end(), greater<pair<pair<int, int>, int> >());
}
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
}
int main() {
read();
store();
solve();
print();
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = 0x7FFFFFFF;
const int MOD = 1e9 + 7;
const double EPS = 1e-10;
const double PI = 2 * acos(0.0);
const int maxn = 1e6 + 66;
int aa[maxn], bb[maxn], Left[maxn], Right[maxn];
int main() {
int n, q;
while (scanf("%d %d", &n, &q) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &aa[i]);
for (int i = 1; i <= n - 1; i++) bb[i] = abs(aa[i + 1] - aa[i]);
stack<pair<int, int> > sta;
sta.push(pair<int, int>(0, INF));
for (int i = 1; i <= n - 1; i++) {
while (!sta.empty() && bb[i] > sta.top().second) sta.pop();
Left[i] = sta.top().first;
sta.push(pair<int, int>(i, bb[i]));
}
while (!sta.empty()) sta.pop();
sta.push(pair<int, int>(n, INF));
for (int i = n - 1; i >= 1; i--) {
while (!sta.empty() && bb[i] >= sta.top().second) sta.pop();
Right[i] = sta.top().first;
sta.push(pair<int, int>(i, bb[i]));
}
int l, r;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
long long res = 0;
for (int j = l; j <= r - 1; j++) {
int a = max(Left[j], l - 1);
int b = min(Right[j], r);
res += (long long)bb[j] * (j - a) * (b - j);
}
printf("%I64d\n", res);
}
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef long long ll;
typedef vector<int> vec;
int main(){
int A[3][3];
rep(i,3)rep(j,3)cin>>A[i][j];
int n;
int b;
cin>>n;
rep(i,n){
cin>>b;
rep(j,3)rep(k,3){
if(b==A[j][k])A[j][k]=0;
}
}
string ans="No";
rep(i,3)if(A[i][0]+A[i][1]+A[i][2]==0)ans="Yes";
rep(i,3)if(A[0][i]+A[1][i]+A[2][i]==0)ans="Yes";
if(A[0][0]+A[1][1]+A[2][2]==0)ans="Yes";
if(A[2][0]+A[1][1]+A[0][2]==0)ans="Yes";
cout<<ans;
} | 0 |
Subsets and Splits