solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long sum4 = 0, sum7 = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '4')
sum4++;
else if (s[i] == '7')
sum7++;
}
if (sum4 == 0 && sum7 == 0)
cout << "-1";
else if (sum4 >= sum7)
cout << "4";
else
cout << "7";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long mod(long long n) {
if (n < 0) {
return (n % MOD + MOD) % MOD;
} else {
if (n < MOD)
return n;
else if (n < 2 * MOD)
return n - MOD;
else
return n % MOD;
}
}
long long fp(long long a, long long p) {
long long ans = 1, cur = a;
for (long long i = 0; (1ll << i) <= p; ++i) {
if ((p >> i) & 1) ans = mod(ans * cur);
cur = mod(cur * cur);
}
return ans;
}
long long dv(long long a, long long b) { return mod(a * fp(b, MOD - 2)); }
const long long N = 101;
long long m[N][N], ans[N][N], t[N][N];
void add(long long a[N][N], long long b[N][N]) {
for (long long i = 0; i < N; ++i) {
for (long long j = 0; j < N; ++j) {
t[i][j] = 0;
}
}
for (long long i = 0; i < N; ++i) {
for (long long j = 0; j < N; ++j) {
for (long long k = 0; k < N; ++k) {
t[i][j] = mod(t[i][j] + a[i][k] * b[k][j]);
}
}
}
for (long long i = 0; i < N; ++i) {
for (long long j = 0; j < N; ++j) {
a[i][j] = t[i][j];
}
}
}
void pw(long long p) {
for (long long i = 0; i < N; ++i) ans[i][i] = 1;
for (long long i = 0; (1ll << i) <= p; ++i) {
if ((p >> i) & 1) add(ans, m);
add(m, m);
}
}
bool a[N];
long long cnt[2];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
++cnt[a[i]];
}
long long l = cnt[0];
long long r = n - l;
long long op = n * (n - 1) / 2;
for (long long l1 = 0; l1 <= cnt[0] && l1 <= cnt[1]; ++l1) {
long long l0 = l - l1;
long long r0 = cnt[0] - l0;
long long r1 = cnt[1] - l1;
m[l1][l1] = op;
if (l1) {
m[l1][l1 - 1] = mod(l1 * r0);
m[l1][l1] = mod(m[l1][l1] - m[l1][l1 - 1]);
}
m[l1][l1 + 1] = mod(l0 * r1);
m[l1][l1] = mod(m[l1][l1] - m[l1][l1 + 1]);
}
pw(k);
long long sum = 0;
for (long long i = 0; i < l; ++i) sum += a[i];
cout << dv(ans[sum][0], fp(op, k)) << '\n';
}
| 6 |
#include<iostream>
#include<iomanip>
using namespace std;
#define BLANK 0
#define STORE 1
#define CHARGER 2
int main()
{
int n;
char s,t,b;
cout<<setprecision(8);
cout<<setiosflags(ios::fixed);
while(cin>>n,n){
int room[3+2][3+2]={0};
double dp[16][3+2][3+2]={0};
int dx[4]={-1,1,0,0};
int dy[4]={0,0,-1,1};
int i,j,y,x;
cin>>s>>t>>b;
s-='A';
t-='A';
b-='A';
for(i=0;i<3+2;i++){
room[0][i]=STORE;
room[i][0]=STORE;
room[3+2-1][i]=STORE;
room[i][3+2-1]=STORE;
}
room[(t/3)+1][(t%3)+1]=CHARGER;
room[(b/3)+1][(b%3)+1]=STORE;
dp[0][(s/3)+1][(s%3)+1]=1.0;
for(i=1;i<=n;i++){
for(y=1;y<=3;y++){
for(x=1;x<=3;x++){
for(j=0;j<4;j++){
int yy=y+dy[j],xx=x+dx[j];
if(room[yy][xx]==STORE){yy=y;xx=x;}
dp[i][yy][xx]+=dp[i-1][y][x]/4.0;
}
}
}
}
cout<<dp[n][(t/3)+1][(t%3)+1]<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, p;
cin >> s >> p;
for (int i = 0; i < s.size(); i++) {
s[i] = tolower(s[i]);
}
for (int i = 0; i < p.size(); i++) {
p[i] = tolower(p[i]);
}
if (s < p) {
cout << -1 << endl;
}
if (s > p) {
cout << 1 << endl;
}
if (s == p) {
cout << 0 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.X << ", " << pair.Y << ")";
}
const long double kEps = 1e-6;
long double sq(long double a) { return a * a; }
int main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
int n, d;
cin >> n >> d;
;
vector<pair<long double, int> > inters;
long double PI = acos(0) * 2;
for (int i = (1); i <= (n); ++i) {
int x, y, r;
cin >> x >> y >> r;
;
long double dis = sqrt(sq(x) + sq(y));
int least_mult = int((dis - r - kEps) / d) * d;
int greatest_mult = int((dis + r + kEps) / d) * (d + 1);
long double ang = atan2(y, x);
for (int R1 = least_mult; R1 <= greatest_mult; R1 += d) {
if (abs(dis - R1) > r || R1 <= 0) {
continue;
}
long double R2 = r;
long double diff = (sq(R1) - sq(R2)) / dis;
long double a = (dis + diff) / 2;
long double width = acos(a / R1);
pair<long double, long double> inter1 =
make_pair(ang - width - kEps, ang + width + kEps);
pair<long double, long double> inter2 =
make_pair(inter1.first - 2 * PI, inter1.first - 2 * PI);
pair<long double, long double> inter3 =
make_pair(inter1.first + 2 * PI, inter1.first + 2 * PI);
vector<pair<long double, long double> > vec;
vec.push_back(inter1);
vec.push_back(inter2);
vec.push_back(inter3);
for (auto p : vec) {
inters.push_back(make_pair(p.first, 1));
inters.push_back(make_pair(p.second, -1));
}
}
}
sort((inters).begin(), (inters).end());
int acc = 0;
int res = 0;
for (auto p : inters) {
acc += p.second;
maxi(res, acc);
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void file() {}
const long long N = 5e5 + 5;
const long long mod = 998244353;
long long A[N];
void init() {
A[0] = 1;
for (long long i = 1; i <= 5e5; i++) A[i] = A[i - 1] * i % mod;
}
long long pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long C(long long n, long long m) {
if (n < m || n < 0) return 0;
long long ans =
A[n] * pow(A[n - m], mod - 2) % mod * pow(A[m], mod - 2) % mod;
return ans;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
file();
init();
long long n, k;
cin >> n >> k;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans = (ans + C(n / i - 1, k - 1)) % mod;
}
cout << ans << "\n";
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 10;
int sz[N], n;
vector<int> adj[N];
void dfs(int root, int par = 0) {
int res = 0;
for (auto u: adj[root])
if (u ^ par) {
dfs(u, root);
sz[root] += sz[u];
res += sz[u] % 2;
}
sz[root]++;
res += (n - sz[root]) % 2;
if (res > 1) {
cout << "First\n";
exit(0);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1, v, u; i < n; i++) {
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
}
if (n & 1)
return cout << "First\n", 0;
dfs(1);
cout << "Second\n";
return 0;
}
| 0 |
#define _CRT_SECURE_NO_WARNINGS
//#define _GLIBCXX_DEBUG
#include <cstdio>
#include <iostream>
#include <vector>
#include <tuple>
#include <stack>
#include <tuple>
#include <set>
#include <queue>
#include <memory>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
#define all(c) (c).begin(), (c).end()
#define loop(i,a,b) for(ll i=a; i<ll(b); i++)
#define rep(i,b) loop(i,0,b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
template<class T> ostream & operator<<(ostream & os, vector<T> const &);
template<int n, class...T> typename enable_if<(n>=sizeof...(T))>::type _ot(ostream &, tuple<T...> const &){}
template<int n, class...T> typename enable_if<(n< sizeof...(T))>::type _ot(ostream & os, tuple<T...> const & t){ os << (n==0?"":" ") << get<n>(t); _ot<n+1>(os, t); }
template<class...T> ostream & operator<<(ostream & os, tuple<T...> const & t){ _ot<0>(os, t); return os; }
template<class T, class U> ostream & operator<<(ostream & os, pair<T,U> const & p){ return os << "(" << p.first << ", " << p.second << ") "; }
template<class T> ostream & operator<<(ostream & os, vector<T> const & v){ rep(i,v.size()) os << v[i] << (i+1==(int)v.size()?"":" "); return os; }
#ifdef DEBUG
#define dump(...) (cerr<<#__VA_ARGS__<<" = "<<mt(__VA_ARGS__)<<" ["<<__LINE__<<"]"<<endl)
#else
#define dump(...)
#endif
#define int ll
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, int id_) :
src(src_), dst(dst_), weight(weight_), id(id_) { }
};
bool operator < (const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src : e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
namespace segtree_rmq {
typedef ll dat_t;
dat_t const inf = (1LL<<31)-1;
dat_t const init = (1LL<<31)-1;
struct segment_tree {
vector<pair<dat_t,int>> dat;
int n;
segment_tree(int n_){
n = 1;
while(n < n_) n<<=1;
dat.resize(n*2);
for(int i=n; i<n+n; i++){
dat[i] = make_pair(init,i); // -infをdat[i]にするとvectorからのコンストラクタになる
}
for(int i=n-1; i>=1; i--){
dat[i] = min(dat[i<<1], dat[i<<1|1]);
}
}
// bottom-up
void set(int k, dat_t x){
int i = n+k; // leaf
dat[i] = make_pair(x,k);
while(i != 1){ // 1 is root
dat[i>>1] = min(dat[i], dat[i^1]);
i>>=1;
}
}
// top-down
pair<dat_t,int> get(int a, int b, int k, int l, int r){
if(r <= a || b <= l) return make_pair(inf,0);
if(a <= l && r <= b) return dat[k];
pair<dat_t,int> v1 = get(a,b,k<<1,l,(l+r)/2);
pair<dat_t,int> v2 = get(a,b,k<<1|1,(l+r)/2,r);
return min(v1,v2);
}
pair<dat_t,int> get(int a, int b){
return get(a,b,1,0,n);
}
};
}
namespace segtree_rangeaddsum {
typedef ll dat_t;
struct segment_tree {
vector<dat_t> partial, overall;
int n, n_org;
segment_tree(int n_){
n = 1;
n_org = n_;
while(n < n_) n<<=1;
partial.assign(n+n,0);
overall.assign(n+n,0);
}
void add(int a, int b, int x, int k, int l, int r){
if(a <= l && r <= b){
partial[k] += x;
} else if(l < b && a < r){
overall[k] += (min(b,r)-max(a,l)) * x;
add(a,b,x,k<<1,l,(l+r)/2);
add(a,b,x,k<<1|1,(l+r)/2,r);
}
}
void add(int a, int b, int x){
add(a,b,x,1,0,n);
}
dat_t sum(int a, int b, int k, int l, int r){
if(b <= l || r <= a){
return 0;
} else if(a <= l && r <= b){
return partial[k]*(r-l) + overall[k];
} else {
dat_t res = (min(b,r)-max(a,l)) * partial[k];
res += sum(a,b,k<<1,l,(l+r)/2);
res += sum(a,b,k<<1|1,(l+r)/2,r);
return res;
}
}
dat_t sum(int a, int b){
return sum(a,b,1,0,n);
}
void view(){
for(int i=0; i<n_org; i++){
cout << sum(i,i+1) << " ";
}
cout << endl;
}
};
}
class LowestCommonAncestor {
public:
int n;
LowestCommonAncestor(int n_)
: n(n_),
g(n),
ord(new int[n*2]),
depth(new int[n*2]),
id(new int[n]),
rmq(new segtree_rmq::segment_tree(n*2)) {
}
void add_edge(int a, int b, int id){
g[a].eb(a,b,0,id);
g[b].eb(b,a,0,id);
}
void compile(int root = 0){
int k = 0;
dfs(root,-1,0,k);
for(int i=0;i<k;i++){
rmq->set(i,depth[i]);
}
}
int lca(int u, int v){
int a = id[u], b = id[v];
return ord[rmq->get(min(a,b), max(a,b)+1).second];
}
Graph g;
unique_ptr<int[]> ord, depth, id;
unique_ptr<segtree_rmq::segment_tree> rmq;
void dfs(int v, int p, int d, int & k){
id[v] = k;
ord[k] = v; depth[k] = d;
k++;
for(auto & e : g[v]){
if(e.dst != p){
dfs(e.dst, v, d+1, k);
ord[k] = v; depth[k] = d;
k++;
}
}
}
};
typedef LowestCommonAncestor LCA;
int const MAX_N = 300010;
Graph g;
int N,Q;
int a[MAX_N], b[MAX_N];
int down_ord[MAX_N], up_ord[MAX_N]; // 辺のID->DFSで何番目に降りられたか/登られたか
int par_edge[MAX_N]; // 頂点のID->親につながる辺のID
int cur_ord; // DFSで今まで何本の辺を通ったか
// pair<ord,edge id>
vector<pair<int,int>> down, up;
void dfs(int v){
for(auto & e : g[v]){
down.eb(cur_ord,e.id);
down_ord[e.id] = cur_ord;
cur_ord++;
dfs(e.dst);
up.eb(cur_ord,e.id);
up_ord[e.id] = cur_ord;
cur_ord++;
}
}
signed main(){
// 親の方が頂点番号が小さい
cin >> N >> Q;
g.assign(N,{});
down.reserve(N);
up.reserve(N);
cur_ord = 0;
par_edge[0] = -1;
LCA lca(N);
rep(i,N-1){
cin >> a[i] >> b[i];
if(a[i] > b[i]) swap(a[i],b[i]);
g[a[i]].eb(a[i],b[i],0,i); // 下向きしか追加しない
lca.add_edge(a[i],b[i],i);
par_edge[b[i]] = i;
}
lca.compile(0);
dfs(0);
segtree_rangeaddsum::segment_tree dtree(down.size()), utree(up.size());
while(Q--){
char c;
cin >> c;
// lower_bound, upper_boundは手抜き。前計算すればO(1)にできる
if(c=='0'){
// 距離
int u,v;
cin >> u >> v;
int p = lca.lca(u,v);
int res = 0;
// d(p,u) + d(p,v)
for(auto & x : {u,v}){
if(x==p) continue;
// d(p,x)
{
// DFSで巡った順にp->xへ移動するときの辺の重みの和を求める。
// 下る辺を+, 登る辺を-にして足せば、重複が打ち消されて
// 直接p->xへ移動するときの和と同じになる
int beg = down_ord[g[p].front().id];
int en = down_ord[par_edge[x]]+1;
{
auto l = lower_bound(all(down), mp(beg,-1LL));
auto r = upper_bound(all(down), mp(en,-1LL));
res += dtree.sum(l-down.begin(), r-down.begin());
}
{
auto l = lower_bound(all(up), mp(beg,-1LL));
auto r = upper_bound(all(up), mp(en,-1LL));
res -= utree.sum(l-up.begin(), r-up.begin());
}
}
}
cout << res << endl;
} else {
// 加算
int v,w;
cin >> v >> w;
if(g[v].size()==0) continue;
{
auto lb = mp(down_ord[g[v].front().id], -1LL);
auto ub = mp(up_ord[g[v].back().id]+1, -1LL);
auto l = lower_bound(all(down), lb);
auto r = upper_bound(all(down), ub);
dtree.add(l-down.begin(), r-down.begin(), w);
}
{
auto lb = mp(down_ord[g[v].front().id], -1LL);
auto ub = mp(up_ord[g[v].back().id]+1, -1LL);
auto l = lower_bound(all(up), lb);
auto r = upper_bound(all(up), ub);
utree.add(l-up.begin(), r-up.begin(), w);
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long q;
int k;
long long solve() {
long long blocksz = (long long)k * k + 1;
long long blockidx = (q - 1) / blocksz;
vector<long long> path;
path.push_back(blockidx);
while (path.back() != 0) {
long long nxt = path.back() / k;
path.push_back(nxt);
}
reverse(path.begin(), path.end());
vector<long long> skipped(((int)(path).size()), -1LL);
skipped[0] = (long long)k * (k + 1) / 2;
for (int i = (1); i < (((int)(path).size())); ++i) {
int b = path[i] - path[i - 1] * k;
int off =
k - max(0LL, min((long long)k, skipped[i - 1] - path[i - 1] * blocksz -
(long long)b * k - 1));
skipped[i] =
(path[i - 1] * k + b) * blocksz - b + (long long)k * (k + 1) / 2 + off;
}
for (int i = (0); i < (((int)(path).size())); ++i)
assert(skipped[i] > path[i] * blocksz &&
skipped[i] <= (path[i] + 1) * blocksz);
if (q == skipped.back()) {
if (((int)(path).size()) == 1) return k + 1;
int b = path[((int)(path).size()) - 1] - path[((int)(path).size()) - 2] * k;
return (path[((int)(path).size()) - 2] * k + b + 1) * (k + 1);
} else {
long long blockpos = (q - 1) % blocksz - (q > skipped.back() ? 1 : 0);
return (blockidx * k + (blockpos / k)) * (k + 1) + (blockpos % k + 1);
}
return -1;
}
void run() {
scanf("%lld%d", &q, &k);
printf("%lld\n", solve());
}
void stress() {
int qlim = 100000000;
for (k = 2; k <= 2; ++k) {
vector<int> sums;
int at = 1, idx = 0, pos = 1;
vector<int> ans(qlim + 1, -1);
while (at <= qlim) {
int sum = 0;
for (int i = (0); i < (k); ++i) {
if (idx < ((int)(sums).size()) && sums[idx] == at) ++at, ++idx;
if (at <= qlim) ans[at] = pos;
sum += at, ++at, ++pos;
}
if (sum <= qlim) ans[sum] = pos;
sums.push_back(sum), ++pos;
}
printf("#");
for (q = 1; q <= qlim; ++q) {
long long have = solve();
long long want = ans[q];
if (have == want) continue;
printf("err have=%lld want=%lld\n", have, want);
printf("%lld %d\n", q, k);
break;
}
}
}
int main() {
int ncase;
scanf("%d", &ncase);
for (int i = (1); i <= (ncase); ++i) run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct aaa {
int l;
int r;
int type;
int k;
int id;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<aaa> v;
int n;
cin >> n;
int l, r;
for (int i = 0; i < (n); i++) {
cin >> l >> r;
v.push_back({l, r, 1, 0, i});
}
int m;
cin >> m;
int k;
for (int i = 0; i < (m); i++) {
cin >> l >> r >> k;
v.push_back({l, r, 0, k, i});
}
sort((v).begin(), (v).end(),
[](aaa &l, aaa &r) { return l.l == r.l ? l.type < r.type : l.l < r.l; });
multimap<int, pair<int, int>> mp;
vector<int> ans(n);
for (int i = 0; i < (n + m); i++) {
if (v[i].type == 0) {
mp.insert({v[i].r, {v[i].k, v[i].id}});
} else {
auto itr = mp.lower_bound(v[i].r);
while (1) {
if (itr == mp.end()) {
cout << "NO" << endl;
return 0;
}
if (itr->second.first > 0) break;
itr = mp.erase(itr);
}
itr->second.first--;
ans[v[i].id] = itr->second.second;
}
}
cout << "YES" << endl;
for (int i = 0; i < (n); i++) {
cout << ans[i] + 1 << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, dis = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
long long int d;
cin >> d;
if (c == '+')
x += d;
else if (c == '-' && (x - d) >= 0)
x -= d;
else
dis++;
}
cout << x << " " << dis;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int p,i,j,k,l,m,n,gx,gy,dp[17][17],map[17][17][17][17];
int N;
cin >> n;
for( N = 0; N < n; N++){
for(i = 0; i < 17; i++){
for(j = 0; j < 17; j++){
dp[i][j]=0;
for(k = 0; k < 17; k++){
for(l = 0; l < 17; l++){
map[i][j][k][l]=0;
}
}
}
}
dp[1][1]=1;
cin >> gx >> gy;
gx++;
gy++;
cin >> p;
for(m = 0; m < p; m++){
cin >> i >> j >> k >> l;
map[i+1][j+1][k+1][l+1]=1;
map[k+1][l+1][i+1][j+1]=1;
}
for(i = 1; i < gx+1; i++){
for(j = 1; j < gy+1; j++){
if(map[i][j][i-1][j]!=1){
dp[i][j]+=dp[i-1][j];
}
if(map[i][j][i][j-1]!=1){
dp[i][j]+=dp[i][j-1];
}
}
}
if( dp[gx][gy]==0){
cout<<"Miserable Hokusai!"<<endl;
}else{
cout << dp[gx][gy] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
char s[105];
int main() {
int n, p, q;
scanf("%d%d%d", &n, &p, &q);
scanf("%s", s);
if (n < p && n < q) {
puts("-1");
return 0;
}
if (n % p == 0) {
printf("%d\n", n / p);
for (int i = 0; i < n; i++) {
if (i % p == 0 && i != 0) printf("\n");
printf("%c", s[i]);
}
return 0;
}
if (n % q == 0) {
printf("%d\n", n / q);
for (int i = 0; i < n; i++) {
if (i % q == 0 && i != 0) printf("\n");
printf("%c", s[i]);
}
return 0;
}
int pos = 0;
for (; pos < n + 1; pos += p)
if ((n - pos) % q == 0) break;
if (pos >= n)
puts("-1");
else {
int j = 0;
printf("%d\n", pos / p + (n - pos) / q);
for (int i = 0; i < pos / p; i++) {
for (int k = 0; k < p; k++, j++) printf("%c", s[j]);
printf("\n");
}
for (int i = 0; i < (n - pos) / q; i++) {
for (int k = 0; k < q; k++, j++) printf("%c", s[j]);
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
char local = 'O';
using namespace std;
int main() {
long long n;
cin >> n;
string s = "abcd";
for (long long i = 0; i < n; i++) cout << s[i % 4];
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long double EPS = 1e-9;
long long int pow(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
y = y / 2, x = (x * x) % mod;
}
return res % mod;
}
vector<pair<int, int>> a, b, c, d;
bool sorterA(pair<int, int> &a, pair<int, int> &b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
bool sorterB(pair<int, int> &a, pair<int, int> &b) {
if (a.second == b.second) return a.first > b.first;
return a.second < b.second;
}
bool sorterD(pair<int, int> &a, pair<int, int> &b) {
if (a.second == b.second) return a.first < b.first;
return a.second > b.second;
}
bool sorterC(pair<int, int> &a, pair<int, int> &b) {
if (a.second == b.second) return a.first > b.first;
return a.second > b.second;
}
void task(int &x, int &y) {}
void solve() {
int n, x, y;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x == 0 || y == 0) cnt++;
if (x >= 0) {
if (y >= 0)
a.push_back(make_pair(x, y));
else
d.push_back(make_pair(x, y));
} else {
if (y >= 0)
b.push_back(make_pair(x, y));
else
c.push_back(make_pair(x, y));
}
}
sort((a).begin(), (a).end(), sorterA);
sort((b).begin(), (b).end(), sorterB);
sort((c).begin(), (c).end(), sorterC);
sort((d).begin(), (d).end(), sorterD);
cout << 6 * (a.size() + b.size() + c.size() + d.size()) - 2 * cnt << '\n';
for (auto e : a) {
int x = e.first;
int y = e.second;
if (x) cout << "1 " << x << " R" << '\n';
if (y) cout << "1 " << y << " U" << '\n';
cout << "2" << '\n';
if (y) cout << "1 " << y << " D" << '\n';
if (x) cout << "1 " << x << " L" << '\n';
cout << "3" << '\n';
}
for (auto e : b) {
int x = -e.first;
int y = e.second;
if (x) cout << "1 " << x << " L" << '\n';
if (y) cout << "1 " << y << " U" << '\n';
cout << "2" << '\n';
if (y) cout << "1 " << y << " D" << '\n';
if (x) cout << "1 " << x << " R" << '\n';
cout << "3" << '\n';
}
for (auto e : c) {
int x = -e.first;
int y = -e.second;
if (x) cout << "1 " << x << " L" << '\n';
if (y) cout << "1 " << y << " D" << '\n';
cout << "2" << '\n';
if (y) cout << "1 " << y << " U" << '\n';
if (x) cout << "1 " << x << " R" << '\n';
cout << "3" << '\n';
}
for (auto e : d) {
int x = e.first;
int y = -e.second;
if (x) cout << "1 " << x << " R" << '\n';
if (y) cout << "1 " << y << " D" << '\n';
cout << "2" << '\n';
if (y) cout << "1 " << y << " U" << '\n';
if (x) cout << "1 " << x << " L" << '\n';
cout << "3" << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int test_Cases = 1;
while (test_Cases--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 100010;
using namespace std;
int main() {
map<int, int> d;
int a;
int i = -1;
int g = 0;
int C[maxn];
int D[maxn];
int H[maxn][2];
int J[maxn];
memset(J, 0, sizeof(J));
scanf("%d", &a);
int first = 1;
int s = a;
while (s--) {
i++;
scanf("%d%d", &C[i], &D[i]);
if (s == 1) break;
}
int c;
i = 0;
int ok = 0;
int kk;
while (scanf("%d", &c) == 1) {
i++;
d[i] = c;
}
for (int i = 0; i < a - 1; i++) {
int ff, fff;
if (d[C[i]] != d[D[i]]) {
J[C[i]]++;
J[D[i]]++;
g++;
}
}
if (g == 0) {
printf("YES\n");
printf("%d", C[0]);
return 0;
}
for (int i = 1; i <= a; i++) {
if (J[i] == g) {
printf("YES\n");
printf("%d", i);
return 0;
}
}
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int ans[] = {15, 14, 12, 13, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7};
int main() {
int n;
scanf("%d", &n);
printf("%d\n", ans[n]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18;
const long long MB = 20;
const long long MOD = 1e9 + 7;
void solve() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> a(m);
long long sum = 0;
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
a[i] = {x, i};
sum += x;
}
reverse(a.begin(), a.end());
if (sum < n) {
cout << -1;
return;
}
vector<long long> ans(m);
long long id = 1;
for (long long i = 0; i < m; i++) {
long long x = a[i].first;
long long last = n - (m - i - 1);
if (x > last) {
cout << -1;
return;
}
ans[a[i].second] = min(last, id + x - 1) - x + 1;
id = ans[a[i].second] + x;
}
for (long long i : ans) cout << i << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
}
| 1 |
#include <stdio.h>
int a, b, c;
int main() {
scanf("%d%d%d", &a, &b, &c);
printf("%d %d %d\n", c, a, b);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n, o[200010];
map<long long, long long> m;
pair<long long, long long> query(long long l, long long r) {
cout << "? " << l + 1 << " " << r + 1 << '\n';
cout << flush;
long long x, y;
cin >> x >> y;
return {x, y};
}
long long func(long long l, long long r) {
if (l > r) return l;
pair<long long, long long> tem = query(l, r);
long long x = tem.first, f = tem.second;
if (m.count(x) == 1) {
if (m[x] == f) {
assert(r - l + 1 == f);
for (long long i = l; i <= r; i++) o[i] = x;
m.erase(m.find(x));
return r + 1;
} else {
long long ql = r - f + 1, qr = ql + m[x] - 1;
m.erase(m.find(x));
for (long long i = ql; i <= qr; i++) o[i] = x;
func(l, ql - 1);
return qr + 1;
}
} else if (f == r - l + 1) {
for (long long i = l; i <= r; i++) o[i] = x;
return r + 1;
} else {
m[x] = f;
long long ql = l;
while (m.count(x)) {
ql = func(ql, ql + f - 1);
}
return func(ql, r);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
func(0, n - 1);
cout << "!";
for (long long i = 0; i < n; i++) cout << " " << o[i];
cout << '\n';
return 0;
}
| 6 |
#include <iostream>
#include <string>
#include <algorithm>
#include <set>
#include <vector>
#include <cstring>
#include <climits>
#include <queue>
#include <map>
#include <sstream>
using namespace std;
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define EPS 1e-9
int main(){
int k;
while(scanf("%d",&k),k){
int s = 0;
for(int i=0; i<k*(k-1)/2; i++){
int t; scanf("%d",&t);
s += t;
}
printf("%d\n",s/(k-1));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 7 + 1e9;
const int inf = 1e9;
const int N = 1e5 + 5;
const int level = 40;
int in[N], w[N], to[N][level], _min[N][level];
long long sum[N][level];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < (n); i++) {
cin >> in[i];
to[i][0] = in[i];
}
for (int i = 0; i < (n); i++) {
cin >> w[i];
_min[i][0] = w[i];
sum[i][0] = w[i];
}
for (int j = 1; j < (level); j++) {
for (int i = 0; i < (n); i++) {
to[i][j] = to[to[i][j - 1]][j - 1];
_min[i][j] = min(_min[i][j - 1], _min[to[i][j - 1]][j - 1]);
sum[i][j] = sum[i][j - 1] + sum[to[i][j - 1]][j - 1];
}
}
for (int i = 0; i < (n); i++) {
long long s = 0;
int m = 1e9;
int cur = i;
long long cnt = k;
for (long long j = 39; j >= 0; --j) {
if ((1ll << j) <= cnt) {
cnt -= (1ll << j);
s += sum[cur][j];
m = min(m, _min[cur][j]);
cur = to[cur][j];
}
}
cout << s << " " << m << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
long long max(long long A, long long b) {
if (A > b) return A;
return b;
}
long long min(long long A, long long b) {
if (A < b) return A;
return b;
}
using namespace std;
vector<long long> v[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
long long neg = 0;
for (int i = 0; i < n; i++) {
long long s, r;
cin >> s >> r;
v[s].push_back(r);
if (r <= 0) neg++;
}
if (neg == n) {
cout << 0 << endl;
return 0;
}
for (int i = 1; i <= m; i++)
sort(v[i].begin(), v[i].end(), greater<long long>());
map<long long, long long> mp;
for (int i = 1; i <= m; i++) {
for (int j = 1; j < v[i].size(); j++) v[i][j] += v[i][j - 1];
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < v[i].size(); j++)
if (v[i][j] >= 0) mp[j] += v[i][j];
}
long long ans = INT_MIN;
map<long long, long long>::iterator it;
for (it = mp.begin(); it != mp.end(); it++) {
ans = max(ans, it->second);
}
if (ans < 0) ans = 0;
cout << ans << endl;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;cin>>a>>b;
if(a<2)a+=13;
if(b<2)b+=13;
cout<<(a>b?"Alice":a<b?"Bob":"Draw");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long double l =
sqrt(100.0 + 100.0 - 2 * 100.0 * cos(acos(-1.0) * 108.0 / 180.0));
long double h =
sqrt(100.0 -
(100.0 + 100.0 - 2 * 100.0 * cos(acos(-1.0) * 108.0 / 180.0)) / 4.0);
long double l2 = l / 2 - 5.0;
long double h2 = sqrt(100.0 - l2 * l2);
long double x0, y0;
x0 = -499.0;
y0 = 0.0;
cout << 5 + (n - 1) * 4 << endl;
vector<vector<pair<long double, long double> > > stars(n);
for (int i = 0; i < n; ++i) {
stars[i].push_back(make_pair(x0, y0));
stars[i].push_back(make_pair(x0 + l / 2.0, y0 + h));
stars[i].push_back(make_pair(x0 + l, y0));
stars[i].push_back(make_pair(x0 + l2 + 10.0, y0 - h2));
stars[i].push_back(make_pair(x0 + l2, y0 - h2));
x0 = stars[i][2].first;
y0 = stars[i][2].second;
}
cout << fixed << setprecision(10) << stars[0][0].first << " "
<< stars[0][0].second << endl;
for (int i = 0; i < stars.size(); ++i)
for (int j = 1; j < 5; ++j)
cout << fixed << setprecision(10) << stars[i][j].first << " "
<< stars[i][j].second << endl;
cout << 1 << " " << 2 << " " << 3 << " " << 4 << " " << 5 << endl;
int cur = 3;
for (int i = 1; i < n; ++i) {
cout << cur << " " << cur + 3 << " " << cur + 4 << " " << cur + 5 << " "
<< cur + 6 << endl;
cur += 4;
}
cout << 1 << " ";
cur = 3;
for (int i = 0; i < n; ++i) {
cout << cur << " ";
cur += 4;
}
cur -= 4;
for (int i = 0; i < n; ++i) {
cout << cur + 2 << " " << cur - 1 << " " << cur + 1 << " ";
if (cur != 3)
cout << cur - 4 << " ";
else
cout << 1;
cur -= 4;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ar[55][55];
bool vis[55];
int main() {
int n, i, a, j, l;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &ar[i][j]);
}
}
for (i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
for (j = 1; j <= n; j++) {
vis[ar[i][j]] = 1;
}
for (j = 1; j < n; j++) {
if (!vis[j]) break;
}
if (j == n) break;
}
for (j = 1; j <= n; j++) {
if (j > 1) printf(" ");
if (ar[i][j] == 0)
printf("%d", n);
else
printf("%d", ar[i][j]);
}
printf("\n");
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
using namespace std;
const int N = 100000;
int n, p;
int pre[N+1];
int find(int x)
{
while (x != pre[x])
x = pre[x];
return x;
}
int main(void)
{
while (scanf("%d%d", &n, &p) != EOF) {
if (!n && !p) break;
pre[1] = 1;
for (int i = 2; i <= n; i ++)
scanf("%d", &pre[i]);
long long sum = 0;
for (int i = 1; i <= p; i ++) {
char s[2];
int x;
scanf("%s%d", s, &x);
if (s[0] == 'M')
pre[x] = x;
else
sum += find(x);
}
printf("%lld\n", sum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void fileio(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const long long INF = 4e18;
inline long long read() {
long long x = 0;
bool flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return (flag ? x : ~(x - 1));
}
long long n, q, k, a[300001], c[300001], f[300002][20], p[300001][20];
deque<long long> que;
signed main() {
n = read();
q = read();
k = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = n; i; i--) {
while (que.size() && a[i] <= a[que.back()]) que.pop_back();
que.push_back(i);
while (i + k < que.front()) que.pop_front();
c[i] = a[que.front()];
}
f[n + 1][0] = n + 1;
for (long long i = n; i; i--) {
f[i][0] = i + k;
f[i][0] = min(f[i][0], n + 1);
while (c[i] < c[f[i][0]]) f[i][0] = f[f[i][0]][0];
p[i][0] = (f[i][0] - i + k - 1) / k * c[i];
}
for (long long i = 1; i <= 19; i++)
for (long long l = 1; l <= n + 1; l++) {
f[l][i] = f[f[l][i - 1]][i - 1];
p[l][i] = p[l][i - 1] + p[f[l][i - 1]][i - 1];
}
while (q--) {
long long l = read(), r = read(), ans = a[l];
for (long long i = 19; i >= 0; i--)
if (f[l][i] <= r) {
ans += p[l][i];
l = f[l][i];
}
ans += (r - l) / k * c[l];
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int S[2100];
vector<int> ans;
void op(int x) {
ans.push_back(x);
int T[2100];
for (int i = 0; i < n; i++) {
T[i] = S[i];
}
for (int i = 0; i < x; i++) {
S[i] = T[n - i - 1];
}
for (int i = x; i < n; i++) {
S[i] = T[i - x];
}
}
int main() {
char s[2100], t[2100];
scanf("%d%s%s", &n, s, t);
vector<int> pt[26];
for (int i = 0; i < n; i++) {
pt[t[i] - 'a'].push_back(i);
}
int ct[26] = {0};
bool F = 0;
for (int i = 0; i < n; i++) {
int c = s[i] - 'a';
if (ct[c] >= pt[c].size()) {
F = 1;
break;
}
S[i] = pt[c][ct[c]];
ct[c]++;
}
if (F) {
puts("-1");
return 0;
}
for (int i = 0; i < n - 1; i++) {
int a = i + 1, b = i;
int A, B;
for (int i = 0; i < n; i++) {
if (S[i] == a) {
A = i;
}
if (S[i] == b) {
B = i;
}
}
if (A > B) {
if (A < n - 1) {
op(n - A - 1);
}
op(n);
} else {
op(n - A - 1);
op(1);
}
for (int i = 0; i < n; i++) {
if (S[i] == b) {
B = i;
}
}
op(n - B);
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d%c", ans[i], i + 1 == ans.size() ? '\n' : ' ');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> graf[1007];
long long dp[1007][1007];
long long dpl[1007][1007];
long long mod = 1000000007;
void dod(long long &a, long long b) { a = (a + b) % mod; }
void dfs(int v, int oj) {
for (int i = 0; i < graf[v].size(); i++) {
if (graf[v][i] == oj) {
swap(graf[v][i], graf[v].back());
graf[v].pop_back();
i--;
continue;
}
dfs(graf[v][i], v);
}
for (int i = 0; i <= n * 2; i++)
for (int j = 0; j <= n * 2; j++) dpl[i][j] = 0;
dpl[0][k + 1] = 1;
for (int i = 0; i < graf[v].size(); i++) {
int u = graf[v][i];
for (int j = 0; j <= 2 * k + 1; j++) {
for (int l = 0; l <= 2 * k + 1; l++) {
if (j + l + 1 <= 2 * k + 1) {
dod(dpl[i + 1][min(j, l + 1)], dpl[i][j] * dp[u][l]);
} else {
dod(dpl[i + 1][max(j, l + 1)], dpl[i][j] * dp[u][l]);
}
}
}
}
for (int i = 0; i <= 2 * k + 1; i++) {
dod(dp[v][i], dpl[graf[v].size()][i]);
dod(dp[v][0], dpl[graf[v].size()][i]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int p1, p2;
scanf("%d%d", &p1, &p2);
graf[p1].push_back(p2);
graf[p2].push_back(p1);
}
dfs(1, 0);
long long w = 0;
for (int i = 0; i <= k; i++) dod(w, dp[1][i]);
printf("%lld\n", w);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define mod 998244353
#define int long long
using namespace std;
const int N=3*1e6+100;
int n,m,fac[N],inv[N],a,b;
inline int m_pow(int a,int b)
{
int ans=1;
while (b)
{
if (b&1) ans=(ans*a)%mod;
b>>=1;
a=(a*a)%mod;
}
return ans;
}
inline int c(int n,int m)
{
if (m>n) return 0;
return (fac[n]*(inv[m]*inv[n-m]%mod)%mod)%mod;
}
signed main()
{
scanf("%lld%lld",&n,&m);
fac[0]=1;
for (int i=1;i<=n+3*m;i++) fac[i]=(fac[i-1]*i)%mod;
inv[n+3*m]=m_pow(fac[n+3*m],mod-2);
for (int i=n+3*m-1;i>=0;i--) inv[i]=(inv[i+1]*(i+1))%mod;
for (int i=0;i<=m;i++)
{
if ((3*m-i)%2!=0) continue;
a=(a+(c(n,i)*c(n+(3*m-i)/2-1,n-1))%mod)%mod;
}
for (int i=2*m+1;i<=3*m;i++) b=(b+c(n+3*m-i-2,n-2))%mod;
b=(b*n)%mod;
printf("%lld\n",(a-b+mod)%mod);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
if (a && !b && !c) {
for (int i = 0; i <= a; i++) {
cout << 0;
}
cout << "\n";
continue;
} else if (!a && !b && c) {
for (int i = 0; i <= c; i++) {
cout << 1;
}
cout << "\n";
continue;
}
for (int i = 0; i <= a; i++) {
cout << 0;
}
for (int i = 0; i <= c; i++) {
cout << 1;
}
b--;
while (b >= 2) {
cout << "01";
b -= 2;
}
if (b) cout << 0;
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int INF = 16843009;
int n;
char a[N][N];
int memo[N + N][1 << N];
int dp(int d, int mask) {
if (d == n + n - 1) return 0;
int &ret = memo[d][mask];
if (ret != INF) return ret;
ret = d & 1 ? INF : -INF;
for (char c = 'a'; c <= 'z'; ++c) {
int newMask = 0;
for (int i = 0; i <= d; ++i) {
int j = d - i;
if (j >= n || a[i][j] != c || !((mask >> i) & 1)) continue;
newMask |= 1 << i;
newMask |= 1 << (i + 1);
}
if (!newMask) continue;
int score = (c == 'a') - (c == 'b');
if (d & 1)
ret = min(ret, dp(d + 1, newMask) + score);
else
ret = max(ret, dp(d + 1, newMask) + score);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf(" %c", &a[i][j]);
}
}
memset(memo, 1, sizeof memo);
int ans = dp(0, 1);
if (ans > 0)
puts("FIRST");
else if (ans < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long
int N;
int last, cnt;
const string s[9] =
{
".,!? ",
"abc",
"def",
"ghi",
"jkl",
"mno",
"pqrs",
"tuv",
"wxyz"
};
string Output(int n)
{
string res;
if (n == 0)
{
if (cnt > 0) res.push_back(s[last - 1][--cnt % s[last - 1].size()]);
cnt = 0;
return res;
}
last = n;
cnt++;
return "";
}
signed main()
{
cin >> N;
for (int i = 0; i < N; i++)
{
string S, ans;
cin >> S;
for (int j = 0; j < S.size(); j++)
{
ans += Output(S[j] - '0');
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, k;
ll s;
struct N {
ll x, y, z;
};
vector<vector<int>> p;
vector<N> ns;
bool c;
bool isc(N &l, N &r) {
ll x = abs(l.x - r.x);
ll y = abs(l.y - r.y);
ll z = abs(l.z - r.z);
ll w = s - x;
ll h = s - y;
ll d = s - z;
return w > 0 && h > 0 && d > 0;
}
ll f(N &l, N &r) {
ll x = abs(l.x - r.x);
ll y = abs(l.y - r.y);
ll z = abs(l.z - r.z);
ll w = s - x;
ll h = s - y;
ll d = s - z;
return 2 * w * h + 2 * h * d + 2 * d * w;
}
vector<bool> used;
int dfs(int i, int root, int from) {
if (used[i])
return 0;
used[i] = true;
int ret = 1;
for (auto &j : p[i]) {
if (j == root) {
if (root != from)
c = true;
continue;
}
ret += dfs(j, root, i);
}
return ret;
}
vector<int> buf;
set<int> visit;
void dfs2(int i, int from) {
if (visit.find(i) != visit.end())
return;
visit.insert(i);
if (from < 0) {
buf.push_back(i);
if (p[i].size() == 2) {
dfs2(p[i][1], i);
reverse(buf.begin(), buf.end());
}
if (p[i].size() > 0)
dfs2(p[i][0], i);
} else {
buf.push_back(i);
for (auto &j : p[i]) {
if (j == from)
continue;
dfs2(j, i);
}
}
}
ll solve(int i, bool loop, bool spe) {
buf.clear();
visit.clear();
dfs2(i, -1);
if (loop && spe) {
ll ret = 6 * s * s * buf.size();
for (int j = 0; j < buf.size(); j++) {
ret -= f(ns[buf[j]], ns[buf[(j + 1) % buf.size()]]);
}
return ret;
} else if (loop) {
ll ret = 6 * s * s * k;
vector<ll> sum(2 * buf.size() + 1);
ll submax = 0;
for (int j = 0; j < buf.size() * 2; j++) {
sum[j + 1] =
sum[j] + f(ns[buf[j % buf.size()]], ns[buf[(j + 1) % buf.size()]]);
}
for (int j = 0; j < buf.size(); j++) {
submax = max(submax, sum[j + k - 1] - sum[j]);
}
ret -= submax;
return ret;
} else {
ll ret = 6 * s * s * k;
vector<ll> sum(buf.size() + 1);
ll submax = 0;
for (int j = 1; j < buf.size(); j++) {
sum[j] = sum[j - 1] + f(ns[buf[j - 1]], ns[buf[j]]);
}
for (int j = 0; j + k - 1 < buf.size(); j++) {
submax = max(submax, sum[j + k - 1] - sum[j]);
}
ret -= submax;
return ret;
}
}
int main() {
while (true) {
ll ans = 100000000000LL;
cin >> n >> k >> s;
if (n == 0)
break;
ns.resize(n);
p.clear();
p.resize(n);
used.clear();
used.resize(n);
for (int i = 0; i < n; i++)
cin >> ns[i].x >> ns[i].y >> ns[i].z;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (isc(ns[i], ns[j])) {
p[i].push_back(j);
p[j].push_back(i);
}
}
for (int i = 0; i < n; i++) {
if (used[i])
continue;
c = false;
int size = dfs(i, i, -1);
if (size < k)
continue;
ans = min(ans, solve(i, c, k == size));
}
if (ans == 100000000000LL)
cout << -1 << endl;
else
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 * 1000 + 10;
int par[maxn], dp[maxn][2][2], up[maxn], siz[maxn], down[maxn], odds[maxn],
bothmost[maxn], bothflip[maxn], peek[maxn], parflip[maxn],
parflip_sibl[maxn], oddable[maxn], upgood[maxn], n;
vector<int> adj[maxn], vert;
void dfs(int u, int p = -1) {
vert.push_back(u);
par[u] = p;
for (int v : adj[u])
if (v != p) dfs(v, u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int fi, se;
cin >> fi >> se;
fi--, se--;
adj[fi].push_back(se);
adj[se].push_back(fi);
}
if (n % 2) return cout << 0 << endl, 0;
dfs(0);
for (int i = n - 1; i >= 0; i--) {
int u = vert[i];
siz[u]++;
if (i) siz[par[u]] += siz[u];
}
for (int u = 0; u < n; u++) {
sort((adj[u]).begin(), (adj[u]).end(),
[](int i, int j) -> bool { return siz[i] < siz[j]; });
if (u) adj[u].pop_back();
}
for (int i = n - 1; i >= 0; i--) {
int u = vert[i];
dp[u][0][siz[u] & 1 ^ 1] = 0;
dp[u][1][siz[u] & 1] = 0;
dp[u][0][siz[u] & 1] = 1;
int odds = siz[u] & 1;
int valids = 0;
for (auto v : adj[u]) {
valids += dp[v][0][siz[v] & 1];
odds += siz[v] & 1;
}
dp[u][0][siz[u] & 1] = (odds < 2) and (valids == ((int)(adj[u]).size()));
::odds[u] = odds;
odds -= siz[u] & 1;
if (odds > 3 or valids + 1 < ((int)(adj[u]).size()))
dp[u][1][siz[u] & 1 ^ 1] = 0;
else {
for (auto v : adj[u])
if (odds - (siz[v] & 1) + (siz[v] & 1 ^ 1) + (siz[u] & 1 ^ 1) <= 1 and
valids + (!dp[v][0][siz[v] & 1]) >= ((int)(adj[u]).size()))
dp[u][1][siz[u] & 1 ^ 1] += dp[v][1][siz[v] & 1 ^ 1];
if (valids == ((int)(adj[u]).size()) and odds == 0 and siz[u] % 2 == 1)
dp[u][1][siz[u] & 1 ^ 1]++;
}
down[u] = dp[u][0][siz[u] & 1];
}
for (int i = 0; i < n; i++) {
int u = vert[i];
if (i == 0) up[u] = true;
bool amigood = odds[u] <= 1;
int vgoods = 0;
for (auto v : adj[u]) vgoods += down[v];
vector<int> le[2][2];
for (int i = 0; i < 4; i++) le[i / 2][i & 1].push_back(i == 0);
for (auto v : adj[u]) {
up[v] = up[u] and amigood and
(vgoods - down[v] + 1 == ((int)(adj[u]).size()));
int nodds = odds[u] - (siz[u] & 1) + (siz[u] & 1 ^ 1) - (siz[v] & 1) +
(siz[v] & 1 ^ 1);
bothflip[v] =
(nodds <= 1) and (vgoods - down[v] + 1 == ((int)(adj[u]).size()));
nodds = odds[u] - (siz[u] & 1) + (siz[u] & 1 ^ 1);
parflip[v] =
(nodds <= 1) and (vgoods - down[v] + 1 == ((int)(adj[u]).size()));
parflip_sibl[v] = (nodds - (siz[v] & 1) <= 1) and
(vgoods - down[v] + 1 == ((int)(adj[u]).size()));
int tmp[2][2] = {0};
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++)
for (int xx = 0; xx <= x; xx++)
for (int yy = 0; yy <= y; yy++)
tmp[x][y] += le[xx][yy].back() * dp[v][x - xx][y - yy];
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++) le[x][y].push_back(tmp[x][y]);
}
int ri[2][2] = {0};
ri[0][0] = 1;
for (int j = ((int)(adj[u]).size()) - 1; j >= 0; j--) {
int v = adj[u][j];
int ucol = siz[u] & 1, nvcol = siz[v] & 1 ^ 1;
if (ucol ^ nvcol)
peek[v] = le[0][0][j] * ri[1][0] + le[1][0][j] * ri[0][0];
else if (!ucol and !nvcol) {
peek[v] = le[0][0][j] * (ri[1][0] + ri[1][1]) + le[0][1][j] * ri[1][0] +
le[1][0][j] * (ri[0][0] + ri[0][1]) + le[1][1][j] * ri[0][0] +
le[0][0][j] * ri[0][0];
} else
peek[v] = 0;
int tmp[2][2] = {0};
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++)
for (int xx = 0; xx <= x; xx++)
for (int yy = 0; yy <= y; yy++)
tmp[x][y] += ri[xx][yy] * dp[v][x - xx][y - yy];
memcpy(ri, tmp, sizeof ri);
}
}
for (int i = 1; i < n; i++) {
int u = vert[i];
bothmost[u] = bothflip[u] ? bothmost[par[u]] : u;
bool subtree_ok = true;
for (auto v : adj[u]) subtree_ok &= dp[v][0][0];
if (!subtree_ok) continue;
oddable[u]++;
oddable[par[u]]--;
if (!parflip_sibl[u]) continue;
oddable[par[u]]++;
if (bothmost[par[u]]) oddable[par[bothmost[par[u]]]]--;
}
for (int i = n - 1; i >= 0; i--) {
int u = vert[i];
if (u) oddable[par[u]] += oddable[u];
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
int u = vert[i];
int p = par[u];
if (bothflip[u]) {
upgood[u] = upgood[p];
if (p) upgood[u] += up[par[p]] * peek[p];
} else
upgood[u] = 0;
if (siz[u] % 2 == 0 and dp[0][0][0])
ans += 1LL * siz[u] * (n - siz[u]);
else if (siz[u] % 2 == 1) {
ans += 1LL * oddable[u] * up[p] * peek[u];
ans += 1LL * oddable[u] * upgood[u];
}
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
// interactions
inline int query(int l, int r)
{
printf ("? %d %d\n", l, r);
fflush(stdout);
int x;
scanf ("%d", &x);
return x;
}
int n;
int main()
{
scanf ("%d", &n);
int pos = query(1, n);
if (pos > 1 && query(1, pos) == pos)
{
int l = 1, r = pos - 1, mid, ans;
while (l <= r)
{
mid = (l + r) >> 1;
if (query(mid, pos) == pos) {
ans = mid;
l = mid + 1;
}
else r = mid - 1;
}
printf ("! %d\n", ans);
}
else
{
int l = pos + 1, r = n, mid, ans;
while (l <= r)
{
mid = (l + r) >> 1;
if (query(pos, mid) == pos) {
ans = mid;
r = mid - 1;
}
else l = mid + 1;
}
printf ("! %d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, sum, res, arr[400000];
int main() {
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr + 1, arr + n + 1);
res += sum;
for (long long int i = 1; i <= n - 1; i++) {
res += sum;
sum -= arr[i];
}
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int m, l, r;
while ( cin >> m >> l >> r, m ) {
l--; r--;
vector<int> P(m);
for ( int i = 0; i < m; i++ ) cin >> P[i];
int ans = 0;
int gap = 0;
for ( int i = l; i <= r; i++ ) {
if ( P[i]-P[i+1] >= gap ) {
ans = i;
gap = P[i]-P[i+1];
}
}
cout << ans+1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 212;
int n, k, x, a[MAX];
long long dp[MAX][MAX];
long long calc(int lo, int x) {
if (dp[lo][x]) return dp[lo][x];
int sz = n - lo;
if (x == 0) {
return (sz < k) ? 0 : -1;
}
if (sz > x * k + k - 1) {
return -1;
}
long long mx = -1;
for (int i = 0; i < k && lo + i < n; ++i) {
long long res = calc(lo + i + 1, x - 1);
if (res != -1) {
mx = max(mx, res + a[lo + i]);
}
}
return dp[lo][x] = mx;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> x;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
cout << calc(0, x) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < s.size(); i++)
if (s.substr(i, 7) == "abacaba") cnt++;
if (cnt >= 2) {
cout << "No" << endl;
continue;
} else {
if (cnt == 1) {
cout << "Yes" << endl;
for (int i = 0; i < s.size(); i++)
if (s[i] == '?') s[i] = 'z';
cout << s << endl;
} else {
string b = s;
string tt = "abacaba";
bool flag = false;
int p;
for (int i = 0; i < s.size(); i++) {
int j;
p = i;
for (j = 0; i < s.size() && j < 7; j++, i++) {
if (s[i] != tt[j] && s[i] != '?') break;
if (s[i] != tt[j] && s[i] == '?') s[i] = tt[j];
}
if (j == 7) flag = true;
if (flag) {
int cnt = 0;
for (int i = 0; i < s.size(); i++)
if (s.substr(i, 7) == "abacaba") cnt++;
if (cnt >= 2) {
flag = false;
}
}
if (flag) break;
s = b;
i = p;
}
if (flag) {
for (int i = 0; i < s.size(); i++)
if (s[i] == '?') s[i] = 'z';
}
if (!flag)
puts("No");
else {
puts("Yes");
cout << s << endl;
}
}
}
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
char c;
int n, count = 0, consecutive = 0;
std::cin >> n;
std::cin.get();
for (int i = 0; i < n; i++) {
c = std::cin.get();
if (c == 'x') {
if (consecutive == 2) {
count++;
} else {
consecutive++;
}
} else {
consecutive = 0;
}
}
std::cout << count;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
while (cin >> n, n) {
string s = "";
while (n) {
s = to_string(n % 8) + s;
n /= 8;
}
string ans = "";
for (int i = 0; i < int(s.size()); i++) {
if (s[i] <= '3') ans += s[i];
else if (s[i] <= '4') ans += s[i] + 1;
else ans += s[i] + 2;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
int n,m,u,v,vis[100007],id[100007];
long long c,dis[100007],d,ans=1e16,now=0;
vector < pair <int,long long> > edge[100007];
priority_queue < pair <long long,int> , vector < pair <long long,int> > , greater < pair <long long,int> > > pr;
int cmp(int a,int b){
return (dis[a]<dis[b] || (dis[a]==dis[b] && a<b));
}
signed main(){
//ios_base::sync_with_stdio(0);
cin>>n>>m>>c;
for(int i=1;i<=m;i++){
cin>>u>>v>>d;
edge[u].pb(mp(v,d));
edge[v].pb(mp(u,d));
now+=d;
}
for(int i=1;i<=n;i++) dis[i]=1e16;
dis[1]=0;
pr.push(mp(0,1));
while(!pr.empty()){
long long val=pr.top().fi;
int u=pr.top().se;
pr.pop();
if(dis[u]!=val) continue;
for(int i=0;i<(int)edge[u].size();i++){
int v=edge[u][i].fi;
long long l=edge[u][i].se;
if(dis[v]>val+l){
dis[v]=val+l;
pr.push(mp(dis[v],v));
}
}
}
for(int i=1;i<=n;i++) id[i]=i;
sort(id+1,id+1+n,cmp);
ans=now;
vis[1]=1;
vis[n+1]=1e16;
id[n+1]=n+1;
for(int i=2;i<=n;i++){
int j=id[i];
//cout<<dis[j]<<endl;
for(int ii=0;ii<edge[j].size();ii++){
v=edge[j][ii].fi;
d=edge[j][ii].se;
if(vis[v]==0) continue;
now-=d;
}
vis[j]=1;
if(dis[j]==dis[id[i+1]]) continue;
ans=min(ans,now+c*dis[j]);
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
long long a[107];
int main() {
long long n, q, i, j = 0, temp, t, k, ans = 0, sum = 0, cnt = 0, m, fg = 0, x,
y, mx = 0, mx1 = 0, mn = 10000000000000000,
mn1 = 10000000000000000;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
for (int i = 0; i < 106; i++) {
if (a[i] % 2 != 0) a[i]--;
sum += a[i];
}
cout << sum / 4 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
string t;
cin >> t;
long long int n = s.size();
bool ok = true;
for (long long int i = 0; i < n; i++) {
if (s[i] != t[i]) {
if (ok) {
s[i] = t[i];
}
ok = !ok;
}
}
if (ok) {
cout << (s) << endl;
} else {
cout << "impossible" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 300010;
int val[maxn << 2], ans[maxn];
void btree(int L, int R, int k) {
int ls, rs, mid;
val[k] = -1;
if (L == R) return;
ls = k << 1;
rs = ls | 1;
mid = (L + R) >> 1;
btree(L, mid, ls);
btree(mid + 1, R, rs);
}
void update(int L, int R, int l, int r, int k, int d) {
int ls, rs, mid;
if (val[k] != -1) return;
if (L == l && R == r) {
val[k] = d;
return;
}
ls = k << 1;
rs = ls | 1;
mid = (L + R) >> 1;
if (r <= mid)
update(L, mid, l, r, ls, d);
else if (l > mid)
update(mid + 1, R, l, r, rs, d);
else {
update(L, mid, l, mid, ls, d);
update(mid + 1, R, mid + 1, r, rs, d);
}
}
void qu(int L, int R, int k, int d) {
int ls, rs, mid;
if (L == R) {
if (val[k] != -1) d = val[k];
ans[L] = d;
return;
}
ls = k << 1;
rs = ls | 1;
mid = (L + R) >> 1;
if (val[k] != -1) d = val[k];
qu(L, mid, ls, d);
qu(mid + 1, R, rs, d);
}
int main() {
int i, l, r, x, n, m, ll, rr;
while (~scanf("%d%d", &n, &m)) {
btree(1, n, 1);
for (i = 0; i < m; i++) {
scanf("%d%d%d", &l, &r, &x);
ll = x - 1;
if (ll >= l) update(1, n, l, ll, 1, x);
rr = x + 1;
if (rr <= r) update(1, n, rr, r, 1, x);
}
qu(1, n, 1, 0);
printf("%d", ans[1]);
for (i = 2; i <= n; i++) printf(" %d", ans[i]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j, k, m, p, h = 0, n, kk = 0, x, mm;
cin >> n;
long long b[n];
vector<pair<long long, long long> > v;
vector<long long> a[n];
vector<long long> vv, v1;
for (i = 0; i < n; i++) {
cin >> m;
p = 0;
cin >> x;
a[i].push_back(x);
for (j = 1; j < m; j++) {
cin >> x;
a[i].push_back(x);
if (a[i][j] > a[i][j - 1]) {
p = 1;
}
}
sort(a[i].begin(), a[i].end());
if (a[i][0] != a[i][m - 1]) h++;
if (p == 0) {
b[i] = 0;
vv.push_back(i);
v1.push_back(a[i][m - 1]);
} else {
b[i] = 1;
kk++;
}
v.push_back(make_pair(a[i][0], a[i][m - 1]));
}
sort(v1.begin(), v1.end());
for (i = 0; i < n; i++) {
if (b[i] == 1) {
h += (n - 1);
} else {
h += kk;
mm = v1.size() -
(upper_bound(v1.begin(), v1.end(), v[i].first) - v1.begin());
h += mm;
if (v[i].first != v[i].second) h--;
}
}
cout << h << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[300010];
vector<int> u[300010];
int n, m, i, CNT, cnt1, cnt2, d[300010], t[300010], dist[300010], edge[300010],
x[300010], y[300010];
bool in[300010], used[300010];
deque<int> q;
int dfs(int poz) {
int cnt = 0;
for (auto it : u[poz]) cnt += dfs(it);
if (d[poz] == -1) return 0;
if (d[poz] != (cnt & 1)) {
used[edge[poz]] = 1;
CNT++;
return 1;
}
return 0;
}
void dfs2(int poz) {
for (auto it : u[poz]) {
dfs(it);
dist[poz] += dist[it];
}
dist[poz] += (d[poz] == 1);
if (t[poz] != -1)
if (dist[poz] & 1) used[edge[poz]] = 1, CNT++;
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> d[i];
if (d[i] == -1) cnt1 = i;
if (d[i] == 1) cnt2++;
}
for (i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
v[x[i]].push_back({y[i], i});
v[y[i]].push_back({x[i], i});
}
if (cnt1) {
memset(dist, 127, sizeof(dist));
dist[cnt1] = 0;
t[cnt1] = -1;
in[cnt1] = 1;
q.push_back(cnt1);
while (q.size()) {
int aux = q.front();
q.pop_front();
in[aux] = 0;
for (auto it : v[aux])
if (it.first != t[aux])
if (dist[it.first] > dist[aux] + 1) {
dist[it.first] = dist[aux] + 1;
t[it.first] = aux;
edge[it.first] = it.second;
if (!in[it.first]) {
in[it.first] = 1;
q.push_back(it.first);
}
}
}
for (i = 1; i <= n; i++)
if (t[i] != -1) u[t[i]].push_back(i);
dfs(cnt1);
cout << CNT << '\n';
for (i = 1; i <= m; i++)
if (used[i]) cout << i << '\n';
return 0;
}
if (cnt2 & 1) {
cout << -1;
return 0;
}
for (i = 1; i <= n; i++)
if (d[i] == 1) {
cnt1 = i;
break;
}
memset(dist, 127, sizeof(dist));
dist[cnt1] = 0;
t[cnt1] = -1;
in[cnt1] = 1;
q.push_back(cnt1);
while (q.size()) {
int aux = q.front();
q.pop_front();
in[aux] = 0;
for (auto it : v[aux])
if (it.first != t[aux])
if (dist[it.first] > dist[aux] + 1) {
dist[it.first] = dist[aux] + 1;
t[it.first] = aux;
edge[it.first] = it.second;
if (!in[it.first]) {
in[it.first] = 1;
q.push_back(it.first);
}
}
}
for (i = 1; i <= n; i++)
if (t[i] != -1) u[t[i]].push_back(i);
memset(dist, 0, sizeof(dist));
dfs2(cnt1);
cout << CNT << '\n';
for (i = 1; i <= m; i++)
if (used[i]) cout << i << '\n';
return 0;
}
| 2 |
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> vary;
int p,n,i;
cin >> p;
while (p--)
{
cin >> n;
if (n == 0)
{ long long int x;
cin >> x;
vary.push_back(x);
}
if (n == 1)
{
if (vary.size() <= 0)break;
cin >> i;
cout << vary[i] << endl;
}
if (n == 2)
{
if (vary.size() <= 0)break;
vary.pop_back();
}
}
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <climits>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <map>
#include <tuple>
#include <iostream>
#include <deque>
#include <array>
#include <set>
#include <functional>
#include <memory>
#include <stack>
#include <numeric>
#include <climits>
#include <cfloat>
struct Vector;
struct Point {
int x, y;
Vector operator-(const Point& that) const;
bool operator==(const Point& that) const;
};
struct Vector {
Point from, to;
int dx() const;
int dy() const;
int cross(const Vector& that) const;
int dot(const Vector& that) const;
bool is_left(const Point& that) const;
bool is_right(const Point& that) const;
bool is_on_line(const Point& that) const;
bool is_forward(const Point& that) const;
bool is_backward(const Point& that) const;
};
bool is_separated_by_white_to_white_line(const Vector& vec, const std::vector<Point>& black, const std::vector<Point>& white) {
return
(std::all_of(black.begin(), black.end(), [vec](const Point& p) {return vec.is_left(p); }) && std::all_of(white.begin(), white.end(), [vec](const Point& p) {return vec.is_right(p) || vec.is_on_line(p); })) ||
(std::all_of(black.begin(), black.end(), [vec](const Point& p) {return vec.is_right(p); }) && std::all_of(white.begin(), white.end(), [vec](const Point& p) {return vec.is_left(p) || vec.is_on_line(p); }));
}
bool is_separated_by_black_to_white_line(const Vector& vec, const std::vector<Point>& black, const std::vector<Point>& white) {
return
(std::all_of(black.begin(), black.end(), [vec](const Point& p) {return vec.is_left(p) || vec.is_forward(p); }) && std::all_of(white.begin(), white.end(), [vec](const Point& p) {return vec.is_right(p) || vec.is_backward(p); })) ||
(std::all_of(black.begin(), black.end(), [vec](const Point& p) {return vec.is_left(p) || vec.is_backward(p); }) && std::all_of(white.begin(), white.end(), [vec](const Point& p) {return vec.is_right(p) || vec.is_forward(p); })) ||
(std::all_of(black.begin(), black.end(), [vec](const Point& p) {return vec.is_right(p) || vec.is_forward(p); }) && std::all_of(white.begin(), white.end(), [vec](const Point& p) {return vec.is_left(p) || vec.is_backward(p); })) ||
(std::all_of(black.begin(), black.end(), [vec](const Point& p) {return vec.is_right(p) || vec.is_backward(p); }) && std::all_of(white.begin(), white.end(), [vec](const Point& p) {return vec.is_left(p) || vec.is_forward(p); }));
}
int main() {
while (true) {
int n, m; std::cin >> n >> m; if (n == 0 && m == 0) break;
std::vector<Point> white(n), black(m); for (auto& w : white) std::cin >> w.x >> w.y; for (auto& b : black) std::cin >> b.x >> b.y;
auto can_separate = false;
for (auto i = 0; i < n && !can_separate; ++i) {
const auto base = white[i];
for (auto j = i + 1; j < n && !can_separate; ++j) {
const auto vec = base - white[j];
can_separate |= is_separated_by_white_to_white_line(vec, black, white);
}
for (auto j = 0; j < m && !can_separate; ++j) {
const auto vec = base - black[j];
can_separate |= is_separated_by_black_to_white_line(vec, black, white);
}
}
if (can_separate) std::cout << "YES\n";
else std::cout << "NO\n";
}
}
int Vector::dx() const
{
return to.x - from.x;
}
int Vector::dy() const
{
return to.y - from.y;
}
int Vector::cross(const Vector& that) const { return dx() * that.dy() - dy() * that.dx(); }
int Vector::dot(const Vector& that) const
{
return dx() * that.dx() + dy() * that.dy();
}
bool Vector::is_left(const Point& that) const
{
return cross(that - from) < 0;
}
bool Vector::is_right(const Point& that) const
{
return cross(that - from) > 0;
}
bool Vector::is_on_line(const Point& that) const
{
return cross(that - from) == 0;
}
bool Vector::is_forward(const Point& that) const
{
return is_on_line(that) && dot(that - from) >= 0;
}
bool Vector::is_backward(const Point& that) const
{
return is_on_line(that) && dot(that - from) <= 0;
}
Vector Point::operator-(const Point& that) const { return Vector{ *this, that }; }
bool Point::operator==(const Point& that) const { return x == that.x && y == that.y; }
| 0 |
#include <bits/stdc++.h>
using std::cout;
using std::endl;
char input[200][20000];
int closest[200][20000];
int left[200][20000];
int right[200][20000];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", input[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) closest[i][j] = 10000000;
for (int i = 0; i < n; i++) {
bool check = false;
for (int j = 0; j < m; j++)
if (input[i][j] == '1') {
closest[i][j] = 0;
check = true;
}
if (!check) {
printf("-1\n");
return 0;
}
}
for (int i = 0; i < n; i++) {
left[i][0] = 0;
for (int j = 1; j < m; j++)
if (input[i][j] == '1')
left[i][j] = 0;
else
left[i][j] = left[i][j - 1] + 1;
int idx = 0;
while (input[i][idx] == '0') {
left[i][idx] = left[i][m - 1] + idx + 1;
idx++;
}
right[i][n - 1] = 0;
for (int j = m - 2; j >= 0; j--)
if (input[i][j] == '1')
right[i][j] = 0;
else
right[i][j] = right[i][j + 1] + 1;
idx = m - 1;
while (input[i][idx] == '0') {
right[i][idx] = right[i][0] + m - idx;
idx--;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
closest[i][j] = std::min(left[i][j], right[i][j]);
int min = 10000000, sum;
for (int j = 0; j < m; j++) {
sum = 0;
for (int i = 0; i < n; i++) sum += closest[i][j];
if (sum < min) min = sum;
}
printf("%d\n", min);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m;
cin >> m;
int a[m + 1];
a[0] = 0;
for (int i = 1; i <= m; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
int x, y;
cin >> x >> y;
for (int k = 1; k <= m; k++) {
if ((a[k] - a[0] >= x && a[k] - a[0] <= y) &&
(a[m] - a[k] >= x && a[m] - a[k] <= y)) {
cout << k + 1 << endl;
return 0;
}
}
cout << "0\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a[1000100], b[1000100];
int sta[1000100];
int main(void) {
int n, i;
int aa, bb;
int max, nmax, pmax;
long long ans;
int np;
int p1, p2, p12;
while (scanf("%d", &n) != EOF) {
max = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &bb);
b[i] = bb;
if (bb > max) {
max = bb;
nmax = 1;
pmax = i;
} else if (bb == max) {
nmax++;
}
}
for (i = 1; i <= n; i++) {
a[i] = b[(i + pmax - 2) % n + 1];
}
ans = 0;
np = 1;
sta[1] = a[1];
sta[0] = 2000000000;
for (i = 2; i <= n; i++) {
aa = a[i];
if (aa >= sta[1]) {
ans += np;
} else if (aa < sta[np]) {
ans += 1;
} else {
p1 = 1;
p2 = np;
while (p1 < p2) {
p12 = (p1 + p2) / 2;
if (aa < sta[p12]) {
p1 = p12 + 1;
} else {
p2 = p12;
}
}
ans += np - p1 + 2;
}
while (aa > sta[np]) {
np--;
}
sta[++np] = aa;
}
if (nmax == 1) {
if (np != 1) {
aa = sta[2];
for (i = 3; i <= np; i++) {
if (sta[i] != aa) {
ans++;
}
}
}
} else {
aa = sta[1];
for (i = 2; i <= np; i++) {
if (sta[i] != aa) {
ans++;
}
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void Print(int _x) { printf("%d\n", _x); }
void Print(long long _x) { printf("%lld\n", _x); }
template <typename T>
void Print(T _a[], int _s, int _t) {
for (int i = _s; i <= _t; i++) cout << _a[i] << " ";
cout << endl;
}
struct InputReader {
static const int bs = 100000;
char buf[bs];
int p;
inline InputReader() : p(bs) {}
inline void Flush() {
p = 0;
fread(buf, 1, bs, stdin);
}
inline char C() {
if (p >= bs) Flush();
return buf[p++];
}
int Getnum() {
char ch = C();
while (ch < '0' || ch > '9') ch = C();
return (int)(ch - '0');
}
inline int operator()() {
int ans = 0;
char ch = C();
int fu = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fu = -1;
ch = C();
}
while (ch >= '0' && ch <= '9') {
ans *= 10;
ans += ch - '0';
ch = C();
}
return ans * fu;
}
long long Readll() {
long long ans = 0LL;
long long fu = 1;
char ch = C();
while (ch < '0' || ch > '9') {
if (ch == '-') fu = -1;
ch = C();
}
while (ch >= '0' && ch <= '9') {
ans *= 10LL;
ans += ch - '0';
ch = C();
}
return ans * fu;
}
inline void Readstring(string &x) {
x.clear();
char ch = C();
while (!isdigit(ch) && !isalpha(ch)) ch = C();
while (isdigit(ch) || isalpha(ch)) {
x += ch;
ch = C();
}
}
inline void Readalpha(char &c) {
c = C();
while (!isalpha(c)) c = C();
}
inline void Specialread(char &c) {
c = C();
while (c != 'o' && c != 'x' && c != '?') c = C();
}
} In;
inline void Read(int &x) { x = In(); }
inline void Read(int &x, int &y) {
x = In();
y = In();
}
inline void Read(int &x1, int &x2, int &x3) {
x1 = In();
x2 = In();
x3 = In();
}
inline void Read(int &x1, int &x2, int &x3, int &x4) {
x1 = In();
x2 = In();
x3 = In();
x4 = In();
}
inline void Read(long long &x) { x = In.Readll(); }
inline void Read(long long &x, long long &y) {
x = In.Readll();
y = In.Readll();
}
inline void Read(long long &x1, long long &x2, long long &x3) {
x1 = In.Readll();
x2 = In.Readll();
x3 = In.Readll();
}
inline void Read(long long &x1, long long &x2, long long &x3, long long &x4) {
x1 = In.Readll();
x2 = In.Readll();
x3 = In.Readll();
x4 = In.Readll();
}
clock_t _starttime, _endtime;
inline void FILEIO() {}
inline void END() { exit(0); }
int n, m, k;
string s, t;
int mem[1010][1010][12][3];
inline int Dfs(int x, int y, int leftk, bool insub) {
if (mem[x][y][leftk][insub] != -1) return mem[x][y][leftk][insub];
if (!leftk) return 0;
if (x > n || y > m) {
if (insub && leftk <= 1) return 0;
return -(0x3f3f3f3f);
}
int ans = -(0x3f3f3f3f);
if (!insub) {
if (s[x] == t[y])
if (ans < Dfs(x + 1, y + 1, leftk, 1) + 1)
ans = Dfs(x + 1, y + 1, leftk, 1) + 1;
;
if (ans < Dfs(x + 1, y, leftk, 0)) ans = Dfs(x + 1, y, leftk, 0);
;
if (ans < Dfs(x, y + 1, leftk, 0)) ans = Dfs(x, y + 1, leftk, 0);
;
} else {
if (s[x] == t[y]) {
if (ans < Dfs(x + 1, y + 1, leftk, 1) + 1)
ans = Dfs(x + 1, y + 1, leftk, 1) + 1;
;
if (ans < Dfs(x + 1, y + 1, leftk - 1, 1) + 1)
ans = Dfs(x + 1, y + 1, leftk - 1, 1) + 1;
;
}
if (ans < Dfs(x + 1, y, leftk - 1, 0)) ans = Dfs(x + 1, y, leftk - 1, 0);
;
if (ans < Dfs(x, y + 1, leftk - 1, 0)) ans = Dfs(x, y + 1, leftk - 1, 0);
;
}
return mem[x][y][leftk][insub] = ans;
}
int main() {
FILEIO();
memset(mem, -1, sizeof(mem));
Read(n, m, k);
In.Readstring(s);
s = " " + s;
In.Readstring(t);
t = " " + t;
int ans = Dfs(1, 1, k, 0);
printf("%d\n", ans);
END();
}
| 4 |
#include <bits/stdc++.h>
long long s[100005];
long long ns[100005];
int main(void) {
int n, m, k, a, b, c;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
ns[a]++;
ns[b + 1]--;
s[a] += c - 1;
s[b + 1] -= (c + b - a);
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
ns[i] += ns[i - 1];
s[i] += s[i - 1] + ns[i];
}
for (int i = 0; i < k; i++) {
scanf("%d", &c);
sum += s[c];
}
printf("%I64d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> f(3000, 0);
string s = string(3000, 'R');
int k, a = 0;
void push(int v, char d) {
if (k <= 0 || v == 0) return;
if (k < v) v = k;
k -= v;
f[a] = v;
s[a] = d;
a++;
}
int main(void) {
int n, m;
cin >> n >> m >> k;
for (int i = 0; i < n - 1 && k > 0; i++) {
push(m - 1, 'R');
push(m - 1, 'L');
push(1, 'D');
}
if (k > 0) {
push(m - 1, 'R');
}
for (int i = 0; i < m - 1 && k > 0; i++) {
push(n - 1, 'U');
push(n - 1, 'D');
push(1, 'L');
}
if (k > 0) {
push(n - 1, 'U');
}
if (k == 0) {
puts("YES");
cout << a << endl;
for (int i = 0; i < a; i++) {
cout << f[i] << " " << s[i] << endl;
}
} else {
puts("NO");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int c = 200005;
long long n, q, t[c], s1[c], s2[c], mod = 1e9 + 7;
long long oszt(long long a) {
long long ans = 1, p = mod - 2;
while (p) {
if (p % 2) ans = ans * a % mod;
a = a * a % mod, p /= 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> t[i];
s1[i] = (s1[i - 1] + t[i]) % mod;
s2[i] = (s2[i - 1] + t[i] * t[i]) % mod;
}
for (int i = 1; i <= q; i++) {
long long l, r, db, d, sum, kezd;
cin >> l >> r >> d;
sum = (s1[r] - s1[l - 1] + mod) % mod, db = r - l + 1;
kezd = ((sum - db * (db - 1) / 2 % mod * d % mod) % mod + mod) % mod *
oszt(db) % mod;
long long ert = (kezd * kezd % mod * db +
(db - 1) * db % mod * (2 * db - 1) % mod * d % mod * d %
mod * oszt(6) % mod +
kezd * d % mod * db % mod * (db - 1) % mod) %
mod;
cout << (ert == (s2[r] - s2[l - 1] + mod) % mod ? "Yes" : "No") << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> cnt;
string s;
int n, ans;
int main() {
for (scanf("%d", &n); n; n--) {
cin >> s;
cnt[s]++;
}
for (auto v : cnt)
if (v.second > ans) ans = v.second;
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
int L[3 * N] = {0}, R[3 * N] = {0}, a[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
if (n == 1) {
puts("0");
return 0;
}
for (int i = m; i >= 1; i--) {
L[i + a[i] + N] = L[N + a[i] + i + 1] + 1;
R[a[i] - i + N] = R[N + a[i] - i - 1] + 1;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long mn = max(1, i - m - 1 + L[i + N]);
long long mx = min(n, i + m + 1 - R[i + N]);
ans += mx - mn + 1;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int llINF = 0x3f3f3f3f3f3f3f;
vector<long long int> p;
int main() {
long long int b = 1;
while (b <= 1e18 && b > 0) {
p.push_back(b);
b *= 3ll;
}
int q;
cin >> q;
while (q--) {
long long int n;
cin >> n;
vector<int> fac;
while (n != 0) {
fac.push_back(n % 3ll);
n /= 3ll;
}
int l0 = -1;
bool cagou = false;
for (int i = fac.size() - 1; i >= 0; i--) {
if (fac[i] == 0)
l0 = i;
else if (fac[i] == 2) {
if (l0 == -1) {
cagou = true;
break;
} else {
for (int j = 0; j < l0; j++) {
fac[j] = 0;
}
fac[l0] = 1;
break;
}
}
}
if (cagou) {
if (p.size() <= fac.size()) {
cout << "1350851717672992089" << endl;
} else
cout << p[fac.size()] << endl;
} else {
long long int ans = 0, bb = 1;
for (auto b : fac) {
ans += bb * (long long int)b;
bb *= 3ll;
}
cout << ans << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int32_t main() {
long long t, n, m, i, j, k, a, b, l, s;
cin >> t;
while (t--) {
cin >> a >> b >> n >> m;
if (a + b < n + m or min(a, b) < m)
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T>>;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 1e3 + 10;
int n, a[maxN], d[maxN];
vector<int> vec;
vector<pair<int, int>> ans;
namespace checker {
int nn;
int b[maxN];
void gen() {
n = nn = 1000;
for (int i = 1; i <= (int)(n); ++i) {
a[i] = b[i] = rng() % 1000 + 1;
}
}
void check() {
for (auto &p : ans) {
swap(b[p.first], b[p.second]);
}
cerr << "\n";
if (is_sorted(b + 1, b + n + 1)) {
cerr << "AC";
} else {
cerr << "WA";
}
}
} // namespace checker
void solve() {
cin >> n;
for (int i = 1; i <= (int)(n); ++i) {
cin >> a[i];
}
for (int i = 1; i <= (int)(n); ++i) {
d[i] = a[i];
}
vec.assign(n, 0);
iota((vec).begin(), (vec).end(), 1);
sort((vec).begin(), (vec).end(),
[](int x, int y) { return make_pair(a[x], x) < make_pair(a[y], y); });
for (auto &i : vec) {
vector<int> sorted;
for (int j = (int)(i + 1); j <= (int)(n); ++j) {
if (a[j] < a[i]) {
sorted.emplace_back(j);
}
}
sort((sorted).begin(), (sorted).end(),
[](int x, int y) { return make_pair(d[x], x) > make_pair(d[y], y); });
for (auto &j : sorted) {
ans.emplace_back(i, j);
swap(d[i], d[j]);
}
}
cout << (int)ans.size() << "\n";
for (auto &p : ans) {
cout << p.first << " " << p.second << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
int N, M, Q;
vector<int> P, A;
vector<int> prv_val;
vector<vector<int>> nx;
template <typename T>
struct SegTree {
int N;
int head;
vector<T> x;
T defaultT;
using func = function<T(const T &, const T &)>;
func merger;
T _get(int begin, int end, int pos, int l, int r) const {
if (r <= begin or l >= end) return defaultT;
if (l >= begin and r <= end) return x[pos];
return merger(_get(begin, end, 2 * pos + 1, l, (l + r) / 2),
_get(begin, end, 2 * pos + 2, (l + r) / 2, r));
}
SegTree(int N, T defaultT, func merger)
: N(N), defaultT(defaultT), merger(merger) {
int N_tmp = 1;
while (N_tmp < N) N_tmp <<= 1;
x.assign(N_tmp * 2, defaultT), head = N_tmp - 1;
}
SegTree(const vector<T> &vals, T defaultT, func merger)
: N(vals.size()), defaultT(defaultT), merger(merger) {
int N_tmp = 1;
while (N_tmp < N) N_tmp <<= 1;
x.assign(N_tmp * 2, defaultT), head = N_tmp - 1;
copy(vals.begin(), vals.end(), x.begin() + head);
for (int i = (head)-1, i_begin_ = (0); i >= i_begin_; i--)
x[i] = merger(x[i * 2 + 1], x[i * 2 + 2]);
}
SegTree() : SegTree(0, T(), [](T, T) { return T(); }) {}
void build(const vector<T> &vals) {
copy(vals.begin(), vals.end(), x.begin() + head);
for (int i = (head)-1, i_begin_ = (0); i >= i_begin_; i--)
x[i] = merger(x[i * 2 + 1], x[i * 2 + 2]);
}
void update(int pos, T val) {
pos += head, x[pos] = val;
while (pos)
pos = (pos - 1) / 2, x[pos] = merger(x[pos * 2 + 1], x[pos * 2 + 2]);
}
T get(int begin, int end) const {
return _get(begin, end, 0, 0, (int)x.size() / 2);
}
friend ostream &operator<<(ostream &os, const SegTree<T> &s) {
os << "[";
for (int i = (0), i_end_ = (s.N); i < i_end_; i++)
os << s.get(i, i + 1) << ",";
os << "]";
return os;
}
};
struct Doubling {
int N, LN;
vector<vector<int>> mat;
Doubling() : N(0), LN(0) {}
Doubling(const vector<int> vec_nxt, int INVALID = -1) : N(vec_nxt.size()) {
LN = 1;
while (1 << LN < N) LN++;
mat.assign(LN, vector<int>(N, INVALID));
mat[0] = vec_nxt;
for (int d = (0), d_end_ = (LN - 1); d < d_end_; d++)
for (int i = (0), i_end_ = (N); i < i_end_; i++)
if (mat[d][i] >= 0 and mat[d][i] < N) {
mat[d + 1][i] = mat[d][mat[d][i]];
}
}
int kth_forward(int now, int len) {
for (int d = 0; len and now >= 0 and now < N; d++, len >>= 1) {
if (len & 1) now = mat[d][now];
}
return now;
}
};
int main() {
cin >> N >> M >> Q;
P.resize(N), A.resize(M);
for (int i = (0), i_end_ = (N); i < i_end_; i++) cin >> P[i];
for (int i = (0), i_end_ = (M); i < i_end_; i++) cin >> A[i];
prv_val.resize(N + 1);
for (int i = (0), i_end_ = (N); i < i_end_; i++)
prv_val[P[(i + 1) % P.size()]] = P[i];
vector<int> nxt1(M, M);
map<int, vector<int>> ma;
for (int i = (0), i_end_ = (M); i < i_end_; i++) {
int a = A[i], prva = prv_val[a];
for (auto v : ma[prva]) nxt1[v] = i;
ma.erase(prva);
ma[a].push_back(i);
}
Doubling dbl(nxt1, M);
vector<int> r(M);
for (int i = (0), i_end_ = (M); i < i_end_; i++) {
int to = dbl.kth_forward(i, N - 1);
r[i] = to;
}
SegTree<int> rmq(r, 1e9, [](int a, int b) { return min(a, b); });
string ans;
for (int _ = (0), __end_ = (Q); _ < __end_; _++) {
int l, r;
cin >> l >> r;
int q = rmq.get(l - 1, r);
if (q < r)
ans += "1";
else
ans += "0";
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
#define MAXN 100005
using namespace std;
typedef long long LL;
LL N, M, A[MAXN], S[MAXN], t, P, sum, L[MAXN];
bool can(LL x) {
sum = 0, t = 0, P = 1;
memset(L,-1,sizeof(L));
for (LL i=N;i>0;--i) {
while (P <= N && A[i] + A[P] < x) P++;
if (P <= N) {
L[i] = P;
t += N-P+1ll;
sum += S[P] + (N-P+1ll) * A[i];
}
}
return t >= M;
}
int main () {
scanf("%lld%lld",&N,&M);
for (LL i=1;i<=N;++i) scanf("%lld",&A[i]);
sort(A+1,A+N+1);
for (LL i=N;i>0;--i) S[i] = A[i] + S[i+1];
LL lo = 0, hi = 2ll * A[N];
while (hi > lo) {
LL mid = (hi + lo + 1ll) / 2;
if (can(mid)) lo = mid;
else hi = mid-1ll;
}
assert(can(lo));
printf("%lld\n", sum - (t-M) * lo);
}
| 0 |
#include<iostream>
#include<vector>
#include<bitset>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
#include<list>
#include<queue>
#include<map>
using namespace std;
#define rep(i,x) for(int i=0;i<x;i++)
int INF=1e9;
const long long mod=1e9+7;
int main(){
int n;
cin>>n;
vector<int>x(n),y(n);
vector<pair<int,int> >p(n);
rep(i,n){
cin>>x[i]>>y[i];
p[i]=make_pair(x[i],y[i]);
}
sort(p.begin(),p.end());
rep(i,n){
cout<<p[i].first<<" "<<p[i].second<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int i, j, k, l, n, m, K[120], tmp, flag, bo;
struct point {
int x, y;
} a[120];
struct ppp {
double x, y;
} O;
double ans;
int dot(point &a, point &b, point &c, point &d) {
return (b.x - a.x) * (d.x - c.x) + (b.y - a.y) * (d.y - c.y);
}
double dist(ppp &a, point &b) {
return sqrt((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
}
void calc(double a, double b, double c, double d, double e, double f) {
O.y = (a * f - d * c) / (b * d - e * a);
O.x = (b * f - c * e) / (a * e - b * d);
}
bool Find(int x, int y) {
for (int i = 1; i <= n; ++i)
if (a[i].x == x && a[i].y == y) return 1;
return 0;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i].x, &a[i].y);
for (i = 1; i <= n; ++i) K[i] = a[i].x * a[i].x + a[i].y * a[i].y;
for (i = 1; i <= n; ++i)
for (j = i + 1; j <= n; ++j)
for (k = j + 1; k <= n; ++k) {
tmp = dot(a[i], a[j], a[i], a[k]);
bo = 0;
if (tmp < 0 || tmp == 0 && !Find(a[j].x + a[k].x - a[i].x,
a[j].y + a[k].y - a[i].y))
continue;
if (tmp == 0)
bo = 1, O.x = (a[j].x + a[k].x) / 2.0, O.y = (a[j].y + a[k].y) / 2.0;
tmp = dot(a[j], a[i], a[j], a[k]);
if (tmp < 0 || tmp == 0 && !Find(a[i].x + a[k].x - a[j].x,
a[i].y + a[k].y - a[j].y))
continue;
if (tmp == 0)
bo = 1, O.x = (a[i].x + a[k].x) / 2.0, O.y = (a[i].y + a[k].y) / 2.0;
tmp = dot(a[k], a[i], a[k], a[j]);
if (tmp < 0 || tmp == 0 && !Find(a[i].x + a[j].x - a[k].x,
a[i].y + a[j].y - a[k].y))
continue;
if (tmp == 0)
bo = 1, O.x = (a[i].x + a[j].x) / 2.0, O.y = (a[i].y + a[j].y) / 2.0;
if (!bo)
calc(a[j].x - a[i].x, a[j].y - a[i].y, (K[i] - K[j]) / 2.0,
a[k].x - a[i].x, a[k].y - a[i].y, (K[i] - K[k]) / 2.0);
double R = dist(O, a[i]);
for (l = 1; l <= n; ++l)
if (l != i && l != j && l != k && dist(O, a[l]) + eps < R) break;
if (l <= n) continue;
ans = max(ans, R);
flag = 1;
}
if (!flag)
printf("-1\n");
else
printf("%.6lf\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
const int inf = 1e9 + 7;
const long long INF = 1e18;
const int N = 1e6 + 10;
string s, l, r;
long long f[N];
int L, R, n;
int inc[N], decr[N];
vector<int> z_f(const string &s) {
int n = ((int)s.size());
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] - 1 > r) {
l = i, r = i + z[i] - 1;
}
}
return z;
}
long long dp(int idx) {
if (idx > n) return 0;
if (idx == n) return 1;
long long &ans = f[idx];
if (~ans) return ans;
ans = 0;
if (s[idx] == '0') {
ans = dp(idx + 1);
if (l == "0") {
ans += dp(idx + 1) - dp(idx + 2);
}
ans += M;
ans %= M;
return ans;
}
int lidx = idx + L + inc[idx];
int ridx = min(n, idx + R - decr[idx]);
if (lidx <= n) {
ans += dp(lidx) - dp(ridx + 1);
}
ans += M;
ans %= M;
ans += dp(idx + 1);
ans %= M;
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s >> l >> r;
memset(f, -1, sizeof f);
n = ((int)s.size());
L = ((int)l.size());
R = ((int)r.size());
string tmp = l + '#' + s;
vector<int> zl, zr;
zl = z_f(tmp);
for (int i = 0; i < (n); i++) {
int idx = zl[i + L + 1];
if (idx < L && i + idx < n && s[i + idx] < l[idx]) inc[i]++;
}
tmp = r + '#' + s;
zr = z_f(tmp);
for (int i = 0; i < (n); i++) {
int idx = zr[i + R + 1];
if (idx < R && i + idx < n && s[i + idx] > r[idx]) decr[i]++;
}
int ans = dp(0) - dp(1);
ans += M;
ans %= M;
cout << ans << endl;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define inf 2123333333
int fa[1010],in[1010],out[1010],n,h;
bool bo[1010];
inline int rd()
{
int x=0;char ch=getchar();
for (;ch<'0'||ch>'9';ch=getchar());
for (;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x;
}
inline int find(int x) { return (x==fa[x])?x:fa[x]=find(fa[x]); }
int main()
{
n=rd();h=rd();
for (int i=1;i<=h*2;i++) fa[i]=i;
for (int i=1;i<=n;i++)
{
int h1=rd(),h2=rd(),h3=rd(),h4=rd();
int x=(!h3)?h1:h3+h,y=(!h4)?h2+h:h4;
out[x]++;in[y]++;
int f1=find(x),f2=find(y);
if (f1!=f2) fa[f1]=f2;
}
for (int i=1;i<=h;i++) if (in[i]>out[i]) { puts("NO");return 0; }
for (int i=h+1;i<=h*2;i++) if (in[i]<out[i]) { puts("NO");return 0; }
for (int i=1;i<=h*2;i++) if (in[i]^out[i]) bo[find(i)]=true;
for (int i=1;i<=h*2;i++) if (!bo[find(i)]) if (in[i]||out[i]) { puts("NO");return 0; }
puts("YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
cout << x / 36 + (x % 36 == 35 ? 1 : 0) << ' '
<< (x % 36 < 35 ? (x % 36) / 3 + (x % 3 == 2 ? 1 : 0) : 0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main(){
cin >> s;
if (s[s.size() - 1] == 's') cout << s << "es";
else cout << s << "s";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int ans[100010];
int main() {
cin >> N >> K;
if (N == K) {
for (int i = 1; i <= N; i++) putchar('0');
puts("");
} else {
int p = (N - K) / 2;
int res = p;
for (int i = 1; i <= N; i++) {
if (res)
--res, putchar('0');
else
res = p, putchar('1');
}
puts("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x, y;
cin >> n;
vector<pair<long long, long long>> a, b;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
a.push_back(make_pair(x, y));
}
for (long long i = 0; i < n; i++) {
cin >> x >> y;
b.push_back(make_pair(x, y));
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
cout << a[0].first + b[n - 1].first << " " << a[0].second + b[n - 1].second;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 42;
bitset<N> cur[M], tmp;
bool cant[M];
bool can[M][M];
int arr[M];
map<string, int> mp;
char tmpread[50];
string s;
int n, m, t, cnt = 0, ans[(1 << (M / 2))];
int allans = 0;
vector<int> v;
void calc(int i, int mask2, int num) {
if (i == m) {
allans = max(allans, num + ans[mask2]);
return;
}
calc(i + 1, mask2, num);
for (int j = 0; j < (int)v.size(); j++) {
if (can[i][v[j]] == 0) return;
}
v.push_back(i);
calc(i + 1, (mask2 & arr[i]), num + 1);
v.pop_back();
}
int main() {
scanf("%d%d", &n, &m);
int idx = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &t);
if (t == 1) {
idx = i;
continue;
}
scanf("%s", tmpread);
s = (string)tmpread;
if (mp.find(s) == mp.end()) mp[s] = cnt++;
if (idx == -1) {
cant[mp[s]] = true;
continue;
}
cur[mp[s]][idx] = 1;
}
for (int i = 0; i < m; i++) {
can[i][i] = true;
for (int j = i + 1; j < m; j++) {
tmp = cur[i] & cur[j];
if (tmp.count() == 0)
can[i][j] = can[j][i] = true;
else
can[i][j] = can[j][i] = false;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m / 2; j++) {
if (can[i][j]) arr[i] |= (1 << j);
}
}
int tmp1, tmp2;
for (int i = 0; i < (1 << (m / 2)); i++) {
tmp1 = i;
tmp2 = 0;
for (int j = 0; j < m / 2; j++) {
if (((i >> j) & 1) == 1) {
ans[i] = max(ans[i], ans[i ^ (1 << j)]);
tmp2++;
tmp1 &= arr[j];
}
}
if (tmp1 == i) ans[i] = max(ans[i], tmp2);
}
calc(m / 2, (1 << (m / 2)) - 1, 0);
cout << allans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const int N = 2e6 + 100;
long long pref_pi[N];
const int NN = 2e5 + 100;
const int NP = 100;
long long dp[NN][NP];
vector<long long> primes;
bool isp[N];
void crivo() {
for (int i = 2; i < N; i++) isp[i] = 1;
for (int i = 1; i < N; i++) {
if (isp[i]) {
primes.push_back(i);
for (int j = 2 * i; j < N; j += i) isp[j] = 0;
}
pref_pi[i] = pref_pi[i - 1] + isp[i];
}
for (int i = 1; i < NN; i++) {
dp[i][0] = i;
for (int j = 1; j < NP; j++) {
dp[i][j] = dp[i][j - 1] - dp[i / primes[j - 1]][j - 1];
}
}
}
long long icbrt(long long x) {
int l = 1, r = 1e4;
long long ans = 1;
while (l <= r) {
long long mid = (l + r) / 2;
if (mid * mid * mid <= x)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
if (ans * ans * ans < x) ans++;
return ans;
}
long long solve(long long x, int k) {
if (x < NN and k < NP) return dp[x][k];
if (k == 0) return x;
if (x < primes[k - 1] * primes[k - 1]) return pref_pi[x] - (k - 1);
return solve(x, k - 1) - solve(x / primes[k - 1], k - 1);
}
map<long long, long long> memo;
long long pi(long long x) {
if (x < N) return pref_pi[x];
if (memo.count(x)) return memo[x];
int k = pref_pi[icbrt(x)];
long long res = solve(x, k) + (k - 1);
while (primes[k] * primes[k] <= x) {
res -= (pi(x / primes[k]) - k);
k++;
}
return memo[x] = res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
crivo();
long long n;
cin >> n;
long long ans = 0;
int i = 0;
for (long long p : primes) {
if (p > n / p) break;
if (1LL * p * p * p <= n) ans++;
ans += pi(n / p) - i - 1;
i++;
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAXN = 100010;
int bit[MAXN];
void update(int pos, int val){
while(pos <= n) {
bit[pos] += val;
pos += pos & -pos;
}
}
long long get(int pos){
long long ret = 0;
while(pos){
ret += bit[pos];
pos -= pos & -pos;
}
return ret;
}
int main(){
int q;
scanf("%d %d", &n, &q);
while(q--){
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if(a == 0) update(b, c);
else printf("%lld\n", get(c) - get(b - 1));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
const int MOD = 998244353;
long long dp[N];
string A, L, R;
int LZ[N], RZ[N];
void getZarr(string str, int Z[]) {
int n = str.length();
int L, R, k;
L = R = 0;
for (int i = 1; i < n; ++i) {
if (i > R) {
L = R = i;
while (R < n && str[R - L] == str[R]) R++;
Z[i] = R - L;
R--;
} else {
k = i - L;
if (Z[k] < R - i + 1)
Z[i] = Z[k];
else {
L = i;
while (R < n && str[R - L] == str[R]) R++;
Z[i] = R - L;
R--;
}
}
}
}
int comp_hash(int in, string &L, int LZ[]) {
if (LZ[in] == (int)L.length()) return 0;
return A[in + LZ[in]] < L[LZ[in]] ? -1 : 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> A >> L >> R;
bool isLZero = (L == "0");
getZarr(L + '$' + A, LZ);
getZarr(R + '$' + A, RZ);
for (int i = 0; i < (int)A.length(); i++) {
LZ[i] = LZ[i + L.length() + 1];
RZ[i] = RZ[i + R.length() + 1];
}
dp[A.length()] = 1;
for (int i = A.length() - 1; i >= 0; i--) {
int la = i + L.length() + 1;
int ra = i + R.length() - 1;
if (A[i] == '0') {
if (isLZero) dp[i] = dp[i + 1] - dp[i + 2];
dp[i] = (dp[i] + dp[i + 1]) % MOD;
continue;
}
long long ans = 0;
if (la <= ra) ans += dp[la] - dp[ra + 1];
int cl = comp_hash(i, L, LZ);
int cr = comp_hash(i, R, RZ);
if (L.length() == R.length()) {
if (cl >= 0 and cr <= 0)
ans += dp[i + L.length()] - dp[i + L.length() + 1];
} else {
if (cl >= 0) ans += dp[i + L.length()] - dp[i + L.length() + 1];
if (cr <= 0) ans += dp[i + R.length()] - dp[i + R.length() + 1];
}
dp[i] = (ans + dp[i + 1]) % MOD;
}
int ans = (dp[0] - dp[1]) % MOD;
if (ans < 0) ans += MOD;
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[300010], p[300010 << 1], dfn[300010], fa[300010][20];
int deep[300010], f[300010 << 1], F[300010 << 1][2], pre[300010 << 1],
suf[300010 << 1];
int t, T, cnt, stk[300010], top;
vector<int> pos[300010];
struct data {
int to, nxt;
} edge[300010 << 1], tree[300010 << 2];
void addedge(int x, int y) {
t++;
edge[t].to = y, edge[t].nxt = p[x], p[x] = t;
}
void new_addedge(int x, int y) {
T++;
tree[T].to = y, tree[T].nxt = p[x], p[x] = T;
}
void dfs(int k) {
dfn[k] = ++cnt;
for (int i = p[k]; i; i = edge[i].nxt)
if (edge[i].to != fa[k][0]) {
fa[edge[i].to][0] = k;
deep[edge[i].to] = deep[k] + 1;
dfs(edge[i].to);
}
}
bool cmp(const int& a, const int& b) { return dfn[a] < dfn[b]; }
int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int j = 19; ~j; j--)
if (deep[fa[x][j]] >= deep[y]) x = fa[x][j];
if (x == y) return x;
for (int j = 19; ~j; j--)
if (fa[x][j] != fa[y][j]) x = fa[x][j], y = fa[y][j];
return fa[x][0];
}
bool paint(int x, int y, int color) {
while (x != y) {
if (f[x] > n && f[x] != color) return 1;
f[x] = color;
x = fa[x][0];
}
return 0;
}
void dp(int k, int from) {
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) dp(tree[i].to, k);
if (k > n) {
F[k][0] = 0;
F[k][1] = 1;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from)
F[k][1] =
1ll * F[k][1] * (F[tree[i].to][0] + F[tree[i].to][1]) % 998244353;
} else {
F[k][0] = 1;
int cnt = 0;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) {
F[k][0] =
1ll * F[k][0] * (F[tree[i].to][0] + F[tree[i].to][1]) % 998244353;
pre[++cnt] = F[tree[i].to][0] + F[tree[i].to][1];
}
for (int i = 1; i <= cnt; i++) suf[i] = pre[i];
pre[0] = 1;
for (int i = 1; i <= cnt; i++)
pre[i] = 1ll * pre[i - 1] * pre[i] % 998244353;
suf[cnt + 1] = 1;
for (int i = cnt; i >= 1; i--)
suf[i] = 1ll * suf[i] * suf[i + 1] % 998244353;
int t = 0;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) {
t++;
F[k][1] = (F[k][1] + 1ll * pre[t - 1] * suf[t + 1] % 998244353 *
F[tree[i].to][1]) %
998244353;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y), addedge(y, x);
}
fa[1][0] = 1;
dfs(1);
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (int i = 1; i <= n; i++)
if (a[i])
f[i] = n + a[i], pos[a[i]].push_back(i);
else
f[i] = i;
for (int i = 1; i <= m; i++)
if (pos[i].size() > 1) {
sort(pos[i].begin(), pos[i].end(), cmp);
int root = (*pos[i].begin());
for (int j = 0; j < pos[i].size() - 1; j++)
if (deep[lca(pos[i][j], pos[i][j + 1])] < deep[root])
root = lca(pos[i][j], pos[i][j + 1]);
if (f[root] > n && f[root] != n + i) {
cout << 0;
return 0;
}
top = 0;
stk[++top] = root;
f[root] = n + i;
for (int j = ((*pos[i].begin()) == root); j < pos[i].size(); j++) {
int l = lca(stk[top], pos[i][j]);
if (l != stk[top]) {
while (top > 1 && deep[l] <= deep[stk[top - 1]]) {
if (paint(stk[top], stk[top - 1], n + i)) {
cout << 0;
return 0;
}
top--;
}
if (paint(stk[top], l, n + i)) {
cout << 0;
return 0;
}
stk[top] = l;
}
stk[++top] = pos[i][j];
}
while (top > 1) {
if (paint(stk[top], stk[top - 1], n + i)) {
cout << 0;
return 0;
}
top--;
}
}
memset(p, 0, sizeof(p));
for (int i = 1; i <= t; i += 2)
if (f[edge[i].to] != f[edge[i + 1].to])
new_addedge(f[edge[i].to], f[edge[i + 1].to]),
new_addedge(f[edge[i + 1].to], f[edge[i].to]);
dp(n + 1, n + 1);
cout << F[n + 1][1];
return 0;
}
| 6 |
#include <bits/stdc++.h>
inline long long gcd(long long a, long long b) {
return (b ? gcd(b, a % b) : a);
}
inline long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
inline int cmp(double x, double y = 0, double tol = 1e-7) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
using namespace std;
struct point {
long double x, y;
point(long double a = 0, long double b = 0) : x(a), y(b) {}
bool operator<(const point &a) const {
if (fabs(x - a.x) > 1e-7) return x < a.x;
return y < a.y;
}
point operator+(const point &a) const { return point(x + a.x, y + a.y); }
point operator-(const point &a) const { return point(x - a.x, y - a.y); }
point operator/(const long double a) const { return point(x / a, y / a); }
};
double dist(point a, point b) { return hypot(a.x - b.x, a.y - b.y); }
int main() {
point a, b, t;
cin >> a.x >> a.y;
cin >> b.x >> b.y;
cin >> t.x >> t.y;
int n, x, y;
cin >> n;
vector<point> v;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(point(x, y));
}
long double ans = 0;
for (int i = 0; i < n; i++) {
ans += 2 * dist(v[i], t);
}
vector<pair<long double, int> > v1, v2;
for (int i = 0; i < n; i++) {
v1.push_back(make_pair(dist(a, v[i]) - dist(v[i], t), i));
v2.push_back(make_pair(dist(b, v[i]) - dist(v[i], t), i));
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
long double sub = min(v1[0].first, v2[0].first);
for (int i = 0; i < 2 && i < (int)v1.size(); i++) {
for (int j = 0; j < 2 && j < (int)v2.size(); j++) {
if (v1[i].second != v2[j].second) {
sub = min(sub, v1[i].first + v2[j].first);
}
}
}
cout << setprecision(15) << fixed << ans + sub << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
int n, val[N + 5], cnt[N + 5], x, sum[N + 5], las[2 * N + 5], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]), cnt[val[i]]++;
for (int i = 1; i <= n; i++)
if (cnt[i] > cnt[x]) x = i;
int lim = sqrt(n) + 1;
for (int i = 1; i <= n; i++)
if (cnt[i] >= lim && i != x) {
int y = i;
for (int j = 1; j <= n; j++)
if (val[j] == x)
sum[j] = 1;
else if (val[j] == y)
sum[j] = -1;
else
sum[j] = 0;
for (int j = 0; j <= 2 * n; j++) las[j] = -1;
las[n] = 0;
sum[0] = n;
for (int j = 1; j <= n; j++) {
sum[j] += sum[j - 1];
if (las[sum[j]] != -1)
ans = max(ans, j - las[sum[j]]);
else
las[sum[j]] = j;
}
}
for (int i = 1; i < lim; i++) {
for (int j = 1; j <= n; j++) sum[j] = 0;
int l = 1, num = 0;
for (int j = 1; j <= n; j++) {
sum[val[j]]++;
if (sum[val[j]] == i)
num++;
else
while (sum[val[j]] > i) {
if (sum[val[l]] == i) num--;
sum[val[l]]--;
l++;
}
if (num >= 2) ans = max(ans, j - l + 1);
}
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807;
const long long INFINT = 2147483647;
const int N = 1000006;
const int NN = 1006;
const int MOD = 1000000007;
void DIE(string s) {
cout << s << '\n';
exit(0);
}
void DIE(char x) {
cout << x << '\n';
exit(0);
}
void DIE(long long x) {
cout << x << '\n';
exit(0);
}
void DIE(int x) {
cout << x << '\n';
exit(0);
}
void YES() { DIE("YES"); }
void Yes() { DIE("Yes"); }
void yes() { DIE("yes"); }
void NO() { DIE("NO"); }
void No() { DIE("No"); }
void no() { DIE("no"); }
int a[11] = {0, -1, -1, -1, 1, -1, 1, -1, 2, 1, 2};
int solve(int x) {
int ans = 0;
if (x % 4 == 0) return x / 4;
if (x & 1) {
x -= 9;
ans++;
}
if (x < 0) return -1;
if (x <= 10) {
if (a[x] == -1) return -1;
return a[x] + ans;
}
x -= 10;
ans += x / 4;
x %= 4;
x += 10;
while (x > 10) {
ans++;
x -= 4;
}
if (a[x] == -1) return -1;
return ans + a[x];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cout << solve(x) << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long limit = 100000 + 5;
long n;
int main() {
long i, j, k, t;
scanf("%ld", &n);
t = 1;
for (i = (1); i <= (n - 1); ++i) t = (t * 10) % 7;
k = 20;
while ((k + t) % 7) k += 30;
i = 1;
j = k;
while (k > 10) {
k = k / 10;
i++;
}
if (n < 4) {
if (n == 1 || n == 2) printf("-1");
if (n == 3) printf("210");
} else {
printf("1");
for (t = (2); t <= (n - i); ++t) printf("0");
printf("%ld", j);
}
scanf("%ld");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int acnt[10];
int main() {
string A, B;
cin >> A >> B;
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
if (A.size() < B.size()) {
cout << A;
exit(0);
}
for (auto w : A) acnt[w - '0']++;
string ans = "";
for (int diff = B.size() - 1; diff >= 0; diff--) {
for (int fix = 0; fix < 10; fix++) {
int cnt[10];
memcpy(cnt, acnt, sizeof(acnt));
string res;
int p = 0;
while (res.size() < diff) {
res += B[p];
cnt[B[p] - '0']--;
p++;
}
cnt[fix]--;
res += (char)('0' + fix);
for (int i = 9; i >= 0; i--) {
while (cnt[i] > 0) {
res += (char)(i + '0');
cnt[i]--;
}
}
int can = 1;
for (int i = 0; i < 10; i++) {
can &= (cnt[i] == 0);
}
if (res <= B && can) {
ans = max(ans, res);
}
}
}
cout << ans;
return 0;
}
| 3 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
#define MAX_N 300005
#define MOD 1000000007
//どこかでmake()することを忘れずに
ll inv[MAX_N],fac[MAX_N],finv[MAX_N];
void make()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i=2;i<MAX_N;i++){
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
fac[i] = fac[i-1] * (ll) i % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll comb(ll a,ll b)
{
if(b==0)return 1;
if(b<0)return 0;
if(a<b){
return 0;
}
return fac[a] * (finv[b] * finv[a-b] % MOD) % MOD;
}
int main(){
ll mod = MOD;
make();
ll n,m,k;
cin >> n >> m >> k;
ll ans = 0;
for(ll i=0;i<=k;i++){
ll x = i;
ll y = k-i;
ll tmp = comb(n+2*x+m+2*y,n+2*x);
tmp *= (mod+comb(n+x+x,x)-comb(n+x+x,x-1))%mod;
tmp %= mod;
tmp *= (mod+comb(m+y+y,y)-comb(m+y+y,y-1))%mod;
tmp %= mod;
ans += tmp;
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
int main() {
int n;
while (cin >> n) {
int a[100050];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
int ok = 1;
for (int i = 0; i < n; ++i)
if (a[i] % a[0] != 0) {
ok = 0;
break;
}
if (ok)
cout << a[0] << endl;
else
cout << -1 << endl;
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main(void){
int a,b;
cin>>a>>b;
cout<<((a*b%2==1)? "Odd":"Even")<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
signed main(){
int a,b,c;
while(scanf("%d%d%d",&a,&b,&c),(a+1)||(b+1)||(c+1)){
if((a+1)&&(b+1)&&a+b>=30){
if(a+b>79)printf("A\n");
else if(a+b>64)printf("B\n");
else if(a+b>49)printf("C\n");
else if(c>49)printf("C\n");
else printf("D\n");}
else printf("F\n");
}
}
| 0 |
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
const long double EPS = 1e-15;
const long double INF = 1e+10;
const long double PI = acos(-1);
int sig(long double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline long double ABS(long double a){return max(a,-a);}
struct Pt {
long double x, y;
Pt() {}
Pt(long double x, long double y) : x(x), y(y) {}
Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
Pt operator-() const { return Pt(-x, -y); }
Pt operator*(const long double &k) const { return Pt(x * k, y * k); }
Pt operator/(const long double &k) const { return Pt(x / k, y / k); }
long double ABS() const { return sqrt(x * x + y * y); }
long double abs2() const { return x * x + y * y; }
long double arg() const { return atan2(y, x); }
long double dot(const Pt &a) const { return x * a.x + y * a.y; }
long double det(const Pt &a) const { return x * a.y - y * a.x; }
};
long double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }
int iSP(Pt a, Pt b, Pt c) {
int s = sig((b - a).det(c - a));
if (s) return s;
if (sig((b - a).dot(c - a)) < 0) return -2; // c-a-b
if (sig((a - b).dot(c - b)) < 0) return +2; // a-b-c
return 0;
}
int iLL(Pt a, Pt b, Pt c, Pt d) {
if (sig((b - a).det(d - c))) return 1; // intersect
if (sig((b - a).det(c - a))) return 0; // parallel
return -1; // correspond
}
bool iLS(Pt a, Pt b, Pt c, Pt d) {
return (sig(tri(a, b, c)) * sig(tri(a, b, d)) <= 0);
}
bool iSS(Pt a, Pt b, Pt c, Pt d) {
return (iSP(a, b, c) * iSP(a, b, d) <= 0 && iSP(c, d, a) * iSP(c, d, b) <= 0);
}
bool iSSstrict(Pt a, Pt b, Pt c, Pt d) {
return (sig(tri(a, b, c)) * sig(tri(a, b, d)) < 0 && sig(tri(c, d, a)) * sig(tri(c, d, b)) < 0);
}
Pt pLL(Pt a, Pt b, Pt c, Pt d) {
b = b - a; d = d - c; return a + b * (c - a).det(d) / b.det(d);
}
Pt p[110];
Pt v;
int n;
long double z[110];
pair<long double,int>ev[110];
int vis[110];
int to[110];
long double tx[110];
long double fx[110];
long double calc2(long double y,int d){
long double ret=0;
int now=0;
int sz=0;
for(int i=0;i<n;i++){
if(iLS(Pt(0,y),Pt(1,y),p[i],p[i+1])){
ev[sz++]=make_pair(pLL(Pt(0,y),Pt(1,y),p[i],p[i+1]).x,i);
}
}
for(int i=0;i<n;i++)to[i]=-1;
std::sort(ev,ev+sz);
//printf("%d\n",sz);
for(int i=0;i<sz;i++){
to[ev[i].second]=ev[i^1].second;
tx[ev[i].second]=ev[i^1].first;
fx[ev[i].second]=ev[i].first;
}
for(int i=0;i<n;i++)vis[i]=0;
for(int i=0;i<n;i++){
if(vis[i])continue;
if(d==0&&p[i].y>y)continue;
if(d==1&&p[i].y<y)continue;
long double val=0;
int at=i;
Pt pos=p[i];
bool fl=true;
while(1){
if(fl)vis[at]=1;
if(fl&&~to[at]){
fl=false;
val+=pos.det(Pt(fx[at],y));
val+=(Pt(fx[at],y)).det(Pt(Pt(tx[at],y)));
pos=Pt(tx[at],y);
at=to[at];
}else{
fl=true;
val+=pos.det(p[at+1]);
at=(at+1)%n;
pos=p[at];
}
if(fl&&vis[at])break;
}
if(val<0)val=-val;
// if(val<0)printf("%Lf\n",val);
ret=max(ret,val/2);
}
//if(ret<1)printf("%Lf %d: %Lf\n",y,d,ret);
return ret;
}
long double calc(long double y){
return max(calc2(y-EPS*10000,0),calc2(y+EPS*10000,1));
}
int main(){
int a;
while(scanf("%d",&a),a){
n=a;
for(int i=0;i<110;i++)p[i]=Pt(0,0);
v=Pt(0,0);
long double X,Y;
scanf("%Lf%Lf",&X,&Y);
v=Pt(X,Y);
long double th=v.arg();
for(int i=0;i<a;i++){
scanf("%Lf%Lf",&X,&Y);
p[i]=Pt(X,Y);
p[i]=p[i]*Pt(cos(th),-sin(th));
z[i]=p[i].y;
// printf("%Lf %Lf\n",p[i].x,p[i].y);
}
p[a]=p[0];
std::sort(z,z+a);
long double ret=999999999;
for(int i=0;i<a;i++){
if(i==0||sig(z[i]-z[i-1])==0)continue;
ret=min(ret,calc(z[i]));
long double left=z[i-1];
long double right=z[i];
for(int j=0;j<100;j++){
long double M1=calc((left*2+right)/3);
long double M2=calc((left+right*2)/3);
ret=min(ret,min(M1,M2));
if(M1>M2)left=(left*2+right)/3;
else right=(right*2+left)/3;
}
}
printf("%.12Lf\n",ret);
}
}
| 0 |
#include <iostream>
#include <algorithm>
int main(){
char a[51][51],m[51][51];int i,j,k,h,w,c;
std::cin>>h>>w;
for(i=0;i<h;++i)for(j=0;j<w;++j)std::cin>>m[i][j];
int dx[]={0,0,1,1,1,-1,-1,-1},dy[]={1,-1,0,1,-1,0,1,-1};
for(i=0;i<h;++i){
for(j=0;j<w;++j){
if(m[i][j]=='#')std::cout<<'#';
else{
c=0;
for(k=0;k<8;++k)if(i+dy[k]>=0&&i+dy[k]<h&&j+dx[k]>=0&&j+dx[k]<w)(m[i+dy[k]][j+dx[k]]=='#'?++c:0);
std::cout<<c;
}
}
std::cout<<"\n";
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,d;
cin>>a>>b>>c>>d;
if(a+b>c+d)cout<<"Left\n";
else if(a+b<c+d)cout<<"Right\n";
else cout<<"Balanced\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7LL;
const int MAXN = 212345;
int vis[MAXN];
vector<int> g[MAXN];
long long dfs(int u) {
vis[u] = 1;
long long r = 1;
for (int v : g[u])
if (!vis[v]) r += dfs(v);
return r;
}
long long fexp(long long b, long long e) {
if (b == 1 || e == 0) return 1;
if (b == 0) return 0;
long long resp = fexp(b, e / 2);
resp = ((resp % MOD) * (resp % MOD)) % MOD;
if (e & 1) resp = ((resp % MOD) * (b % MOD)) % MOD;
return resp % MOD;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0, u, v, w; i < n - 1; ++i) {
cin >> u >> v >> w;
if (!w) {
g[u].push_back(v);
g[v].push_back(u);
}
}
long long r = fexp(n, k);
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
r = (r % MOD - fexp(dfs(i), k) % MOD) % MOD;
if (r < 0) r += MOD;
r %= MOD;
}
}
cout << r << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
long long int get_dist(pair<int, int> p1, pair<int, int> p2) {
return abs(p1.first - p2.first) + abs(p2.second - p1.second);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, y;
cin >> n;
vector<tuple<long long int, long long int, long long int>> v, vv;
int i = 0;
while (i < n) {
cin >> x >> y;
v.push_back(make_tuple(max(x, y), x, y));
i++;
}
sort(v.begin(), v.end());
map<int, pair<int, int>> anticlockwise_start, clockwise_start;
for (int i = 0; i < n;) {
int j = i;
anticlockwise_start[get<0>(v[i])] = {-1, INT_MAX};
clockwise_start[get<0>(v[i])] = {INT_MAX, -1};
while (j < n && get<0>(v[i]) == get<0>(v[j])) {
if (get<1>(v[j]) >= anticlockwise_start[get<0>(v[i])].first &&
get<2>(v[j]) <= anticlockwise_start[get<0>(v[i])].second)
anticlockwise_start[get<0>(v[i])] = {get<1>(v[j]), get<2>(v[j])};
if (get<1>(v[j]) <= clockwise_start[get<0>(v[i])].first &&
get<2>(v[j]) >= clockwise_start[get<0>(v[i])].second)
clockwise_start[get<0>(v[i])] = {get<1>(v[j]), get<2>(v[j])};
j++;
}
i = j;
}
map<pair<int, int>, long long int> dp;
long long int dist1, dist2;
dp[anticlockwise_start[get<0>(v[n - 1])]] = get_dist(
anticlockwise_start[get<0>(v[n - 1])], clockwise_start[get<0>(v[n - 1])]);
dp[clockwise_start[get<0>(v[n - 1])]] =
dp[anticlockwise_start[get<0>(v[n - 1])]];
int prev;
for (int i = n - 1; i >= 0;) {
if (get<0>(v[i]) == get<0>(v[n - 1])) {
prev = get<0>(v[n - 1]);
i--;
continue;
}
int j = i;
while (j >= 0 && get<0>(v[i]) == get<0>(v[j])) j--;
dist1 =
get_dist(anticlockwise_start[get<0>(v[i])], anticlockwise_start[prev]);
dist2 = get_dist(anticlockwise_start[get<0>(v[i])], clockwise_start[prev]);
dp[anticlockwise_start[get<0>(v[i])]] =
min(dp[anticlockwise_start[prev]] + dist1,
dp[clockwise_start[prev]] + dist2);
dist1 = get_dist(clockwise_start[get<0>(v[i])], anticlockwise_start[prev]);
dist2 = get_dist(clockwise_start[get<0>(v[i])], clockwise_start[prev]);
dp[clockwise_start[get<0>(v[i])]] =
min(dp[anticlockwise_start[prev]] + dist1,
dp[clockwise_start[prev]] + dist2);
dist1 = get_dist(clockwise_start[get<0>(v[i])],
anticlockwise_start[get<0>(v[i])]);
long long int temp = dp[anticlockwise_start[get<0>(v[i])]];
dp[anticlockwise_start[get<0>(v[i])]] =
dist1 + dp[clockwise_start[get<0>(v[i])]];
dp[clockwise_start[get<0>(v[i])]] = dist1 + temp;
prev = get<0>(v[i]);
i = j;
}
dist1 = get_dist({0, 0}, anticlockwise_start[prev]);
dist2 = get_dist({0, 0}, clockwise_start[prev]);
cout << min(dp[anticlockwise_start[prev]] + dist1,
dp[clockwise_start[prev]] + dist2);
return 0;
}
| 6 |
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<functional>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int INF = 100000000;
const double EPS = 0.0000001;
typedef pair<int,int> P;
int n,m,p;
int calc0(int A,int C,double D,int Y) {
int B;
int sumB=0;
rep(i,Y) {
B = A*D;
sumB += B;
A-=C;
}
return sumB+A;
}
int calc1(int A,int C,double D,int Y) {
int B;
rep(i,Y) {
B=A*D;
A=A+B-C;
}
return A;
}
void solve() {
//初期のお金
int s;cin>>s;
//年数,しゅるい
cin>>m>>p;
int maxi = 0;
rep(i,p) {
int a,c;
double b;
cin>>a>>b>>c;
rep(i,m) {
//単利
if(a==0) {
maxi=max(maxi,calc0(s,c,b,m));
}
else {
maxi=max(maxi,calc1(s,c,b,m));
}
}
}
cout<<maxi<<endl;
}
int main() {
cin>>n;
rep(i,n) solve();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int>pii;
typedef vector<int>vi;
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define fi first
#define se second
#define de(x) cout<<#x<<"="<<x<<"\n"
#define dd(x) cout<<#x<<"="<<x<<" "
#define pb(x) push_back(x)
#define all(x) x.begin(),x.end()
#define sz(x) (int)x.size()
#define lowbit(a) ((a)&-(a))
#define per(i,a,b) for(int i=(b)-1;i>=(a);--i)
#define mp make_pair
#define sec ((clock_t)1000)
const int N = 5e3 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
inline int add(int a,int b){return a + b >= mod?a + b - mod:a + b;}
inline int mul(int a,int b){return (ll)a*b%mod;}
int n , k , q;
int cnt[N][N],a[N],b[N];
int main(){
scanf("%d%d%d",&n,&k,&q);
rep(i , 1 , n + 1)cnt[0][i] = 1;
rep(i , 1 , k + 1){
rep(j , 1 , n + 1)
cnt[i][j] = add(cnt[i - 1][j - 1] , cnt[i - 1][j + 1]);
}
rep(i , 0 ,k + 1){
rep(j , 1 , n + 1)
a[j] = add(a[j],mul(cnt[i][j],cnt[k - i][j]));
}
rep(i , 1 , n + 1)scanf("%d",&b[i]);
int ans = 0,x,y;
rep(i , 1 , n + 1)ans = add(ans,mul(a[i],b[i]));
while(q--){
scanf("%d%d",&x,&y);
int dif = add(y ,mod - b[x]);
ans = add(ans,mul(dif,a[x]));
b[x] = y;
printf("%d\n",ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
constexpr int sz(const C &c) {
return int(c.size());
}
constexpr const char nl = '\n', sp = ' ';
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using i128 = __int128_t;
using ui128 = __uint128_t;
struct StableRoommates {
struct NoMatch {};
int N;
vector<int> mate;
StableRoommates(vector<vector<int>> prefs) : N(prefs.size()), mate(N, -1) {
if (N % 2 == 1 || N <= 0) return;
vector<vector<int>> rnk(N, vector<int>(N, 0));
vector<int> fr(N, 0), bk(N, N - 1), proposed(N, -1);
vector<vector<bool>> active(N, vector<bool>(N, true));
queue<int> q;
auto rem = [&](int i, int j) { active[i][j] = active[j][i] = false; };
auto clip = [&](int i) {
while (fr[i] < bk[i] && !active[i][prefs[i][fr[i]]]) fr[i]++;
while (fr[i] < bk[i] && !active[i][prefs[i][bk[i] - 1]]) bk[i]--;
if (fr[i] >= bk[i]) throw NoMatch();
};
auto add = [&](int i, int j) {
proposed[mate[i] = j] = i;
while (true) {
clip(j);
if (prefs[j][bk[j] - 1] != i)
rem(j, prefs[j][bk[j] - 1]);
else
break;
}
};
auto nxt = [&](int i) {
clip(i);
int j = prefs[i][fr[i]++];
clip(i);
prefs[i][--fr[i]] = j;
return proposed[prefs[i][fr[i] + 1]];
};
for (int i = 0; i < N; i++) {
q.push(i);
for (int j = 0; j < N - 1; j++) rnk[i][prefs[i][j]] = j;
}
try {
while (!q.empty()) {
int i = q.front();
q.pop();
while (true) {
clip(i);
int j = prefs[i][fr[i]], i2 = proposed[j];
if (i2 != -1 && rnk[j][i2] < rnk[j][i]) {
rem(i, j);
continue;
}
if (i2 != -1) {
mate[i2] = proposed[j] = -1;
q.push(i2);
}
add(i, j);
break;
}
}
int cur = 0;
while (true) {
for (; cur < N; cur++) {
clip(cur);
if (bk[cur] - fr[cur] > 1) break;
}
if (cur == N) break;
vector<int> cyc1, cyc2;
int i = cur, j = i;
do {
i = nxt(i);
j = nxt(nxt(j));
} while (i != j);
do {
cyc1.push_back(j);
j = nxt(j);
} while (i != j);
for (int k : cyc1) {
j = mate[k];
cyc2.push_back(j);
mate[k] = proposed[j] = -1;
rem(k, j);
}
for (int k = 0; k < sz(cyc1); k++)
add(cyc1[k], cyc2[(k + 1) % cyc2.size()]);
}
} catch (NoMatch &) {
fill(mate.begin(), mate.end(), -1);
}
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
vector<vector<int>> A(N, vector<int>(N)), prefs(N);
for (int i = 0; i < N; i++) {
prefs[i].reserve(N - 1);
for (int j = 0; j < N; j++)
if (i != j) {
cin >> A[i][j];
prefs[i].push_back(j);
}
sort(prefs[i].begin(), prefs[i].end(),
[&](int a, int b) { return A[i][a] < A[i][b]; });
}
StableRoommates sr(prefs);
if (sr.mate[0] == -1) {
cout << -1 << nl;
return 0;
}
for (int i = 0; i < N; i++) cout << sr.mate[i] + 1 << nl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
bool is_prime(int n) {
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
inline long long getPow(long long a, long long b) {
long long res = 1, tp = a;
while (b) {
if (b & 1ll) {
res *= tp;
res %= 1000000007;
}
tp *= tp;
tp %= 1000000007;
b >>= 1ll;
}
return res;
}
inline long long to_ll(string s) {
long long cur = 0;
for (int i = 0; i < s.size(); i++) {
cur = cur * 10 + s[i] - '0';
}
return cur;
}
inline string to_str(long long x) {
string s = "";
while (x) {
s += char(x % 10 + '0');
x /= 10;
}
reverse(s.begin(), s.end());
return s;
}
inline long long nxt() {
long long x;
scanf("%lld", &x);
return x;
}
void ok() {
puts("YES");
exit(0);
}
void panic() {
puts("NO");
exit(0);
}
const long long N = 1e6 + 5;
int main() {
long long n = nxt();
vector<long long> mas(n);
for (int i = 0; i < n; i++) {
mas[i] = nxt();
}
vector<pair<long long, long long> > ans(0);
for (int i = 0; i < n - 1; i++) {
long long indx = min_element(mas.begin() + i + 1, mas.end()) - mas.begin();
if (mas[indx] < mas[i]) {
ans.push_back({indx, i});
}
swap(mas[i], mas[indx]);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a[1000];
int main() {
int n, max = 0, hz = 0;
cin >> n;
if (n == 1) {
cout << 6;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = 0; k < 6; k++) {
if (a[i][k] == a[j][k]) hz++;
}
if (hz > max) max = hz;
hz = 0;
}
}
if (max >= 4)
cout << 0;
else if (max >= 2)
cout << 1;
else
cout << 2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int n, s = 1;
cin >> n;
for (int i = 1; i <= n; i++) {
s *= 2;
if (i == 13) {
s = 8092;
}
}
cout << s << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e6 + 4;
long long f[N], z[N], a[N], p[N];
int32_t main() {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", a + i);
f[a[i]]++;
}
long long m;
scanf("%lld", &m);
for (long long i = 1; i <= m; i++) scanf("%lld", p + i);
for (long long i = 1; i < N; i++) {
if (!f[i]) continue;
for (long long j = i; j < N; j += i) {
if (j / i != i)
z[j] += f[i] * f[j / i];
else
z[j] += f[i] * (f[i] - 1);
}
}
for (long long i = 1; i < N; i++) z[i] += z[i - 1];
for (long long i = 1; i <= m; i++) {
printf("%lld\n", n * (n - 1) - z[p[i] - 1]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long cc = 1000000009ll;
struct trie {
trie* next[5];
trie* fail;
int l;
int f;
} * root, *alloc, sav[1005];
char s[30];
queue<trie*> q;
long long dp[2005][205][22];
int n, m;
int cnt;
int ch(char c) {
if (c == 'A') return 0;
if (c == 'C') return 1;
if (c == 'G') return 2;
if (c == 'T') return 3;
}
void ins(char* s) {
int l = strlen(s);
trie* p = root;
for (int i = 0; i < l; i++) {
int w = ch(s[i]);
if (p->next[w] == NULL) {
memset(alloc, 0, sizeof(trie));
p->next[w] = alloc;
p->next[w]->f = cnt;
alloc++;
cnt++;
}
p = p->next[w];
}
p->l = strlen(s);
}
void build() {
while (!q.empty()) q.pop();
root->fail = NULL;
q.push(root);
while (!q.empty()) {
trie* cur = q.front();
q.pop();
for (int i = 0; i < 4; i++)
if (cur->next[i] != NULL) {
if (cur == root)
cur->next[i]->fail = root;
else {
trie* p = cur->fail;
cur->next[i]->fail = p->next[i];
if (cur->next[i]->fail == NULL) cur->next[i]->fail = root;
cur->next[i]->l = max(cur->next[i]->l, cur->next[i]->fail->l);
}
q.push(cur->next[i]);
} else {
if (cur == root)
cur->next[i] = root;
else
cur->next[i] = cur->fail->next[i];
}
}
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
alloc = sav;
memset(alloc, 0, sizeof(trie));
root = alloc;
root->f = 0;
alloc++;
cnt = 1;
for (int i = 0; i < m; i++) {
scanf("%s", s);
ins(s);
}
build();
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < cnt; j++)
for (int k = 0; k <= 10; k++)
if (dp[i][j][k]) {
for (int u = 0; u < 4; u++)
if (sav[j].next[u] != NULL) {
int nex = sav[j].next[u]->f;
int tl = sav[j].next[u]->l;
if (tl > k) {
dp[i + 1][nex][0] += dp[i][j][k];
dp[i + 1][nex][0] %= cc;
} else {
if (k + 1 > 10) continue;
dp[i + 1][nex][k + 1] += dp[i][j][k];
dp[i + 1][nex][k + 1] %= cc;
}
}
}
long long ans = 0;
for (int j = 0; j < cnt; j++) ans = (ans + dp[n][j][0]) % cc;
printf("%I64d\n", ans);
}
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.