code_file1
stringlengths 87
4k
| code_file2
stringlengths 82
4k
|
|---|---|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
//#pragma GCC target("avx,avx2,fma")
#define m_p make_pair
#define f first
#define s second
#define vec vector
#define sz(x) (int)x.size()
#define pw(x) (1LL<<x)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define endl '\n'
#define pb push_back
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifndef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef long double ld;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef unsigned long long ull;
template<class T> using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
auto rnd=bind(uniform_int_distribution<ll>(1,1e18),mt19937(time(0)));
template <class T> bool umin(T &a,const T &b){return (a>b?a=b,1:0);}
template <class T> bool umax(T &a,const T &b){return (a<b?a=b,1:0);}
const ll inf=1e18;
//const int N=1<<16;
signed main(){
fast_io;
int n,m;
cin>>n>>m;
vec<ll>a(n);
for(auto &z : a)
cin>>z;
vec<ll>mn=a;
ll mx=-inf;
vec<vec<int>>g(n,vec<int>());
for(int i=0;i<m;i++){
int a,b;
cin>>a>>b;
g[b-1].pb(a-1);
}
for(int i=0;i<n;i++){
for(auto &z : g[i]){
umax(mx,a[i]-mn[z]);
umin(mn[i],mn[z]);
}
}
cout<<mx;
return 0;
}
/*
qertwy
3
6 3
*/
| #include<bits/stdc++.h>
using namespace std;
//-std=c++11
// #define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
#define LL long long
#define FI ios_base::sync_with_stdio(false); cin.tie(NULL);
#define PREC cout << setprecision(10) << fixed;
#define int long long
const int MOD = 1e9 + 7;
const int INF = 1e9 + 9;
const int MX = 1e5 + 5;
int n;
int inp[8];
int m;
int l[MX], v[MX];
int sz;
set<int> allV;
map<int, int> mp;
struct SegTree {
vector<int> tree;
int DEFAULT;
void init(int n) {
tree.resize(4*n);
//depends on operation
DEFAULT = 0;
}
int combine(int x, int y) {
return max(x, y);
}
void update(int node, int st, int en, int id, int val) {
if(id < st || id > en) return;
if(st == en && st == id) {
tree[node] = max(tree[node], val);
return;
}
int mid = (st + en)/2;
update(2*node, st, mid, id, val);
update(2*node + 1, mid+1, en, id, val);
tree[node] = combine(tree[2*node], tree[2*node + 1]);
}
int query(int node, int st, int en, int i, int j) {
if(i > en || j < st) {
return DEFAULT;
}
if(i <= st && en <= j) {
return tree[node];
}
int mid = (st + en)/2;
int left = query(2*node, st, mid, i, j);
int right = query(2*node+1, mid+1, en, i, j);
return combine(left, right);
}
};
SegTree seg;
int calc(vector<int> x) {
vector<int> pla(n);
pla[0] = 0;
for(int i=1;i<n;i++) {
int sum = inp[x[i]];
int j = i-1;
int minD = 0;
while(j >= 0) {
sum += inp[x[j]];
auto it = allV.lower_bound(sum);
if(it == allV.begin()) {
j--;
continue;
}
it--;
int id = mp[*it];
int maxL = seg.query(1, 0, sz - 1, 0, id);
maxL = maxL - (pla[i-1] - pla[j]);
minD = max(minD, maxL);
j--;
}
pla[i] = pla[i-1] + minD;
}
int totD = pla[n-1] - pla[0];
return totD;
}
#undef int
int main() {
#define int long long
cin >> n >> m;
for(int i=0;i<n;i++) {
cin >> inp[i];
}
for(int i=0;i<m;i++) {
cin >> l[i] >> v[i];
allV.insert(v[i]);
}
//Base check
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
if(inp[i] > v[j]) {
cout << -1 << endl;
return 0;
}
}
}
sz = 0;
for(auto it : allV) {
mp[it] = sz;
sz++;
}
seg.init(sz);
for(int i=0;i<m;i++) {
int id = mp[v[i]];
seg.update(1, 0, sz-1, id, l[i]);
}
int ans = INF;
vector<int> x;
for(int i=0;i<n;i++) x.push_back(i);
ans = min(ans, calc(x));
while(next_permutation(x.begin(),x.end())) {
ans = min(ans, calc(x));
}
cout << ans << endl;
return 0;
} |
#pragma GCC optimize ("O2")
#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
//#include<atcoder/all>
//using namespace atcoder;
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
int to[400001], ne[400001], he[200001];
int Q[200001], pl[200001], dl[200001];
const int CM = 1 << 17, CL = 12;
char cn[CM + CL], * ci = cn + CM + CL, * owa = cn + CM, ct;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
if (ci - owa > 0) {
memcpy(cn, owa, CL);
ci -= CM;
fread(cn + CL, 1, CM, stdin);
}
ll tmp = *(ll*)ci;
int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
tmp = tmp << dig & ma1;
tmp = tmp * 10 + (tmp >> 8) & ma2;
tmp = tmp * 100 + (tmp >> 16) & ma3;
tmp = tmp * 10000 + (tmp >> 32) & ma4;
ci += 72 - dig >> 3;
return tmp;
}
int main() {
//cin.tie(0);
//ios::sync_with_stdio(false);
int N = getint(), K = getint();
int k = 1;
rep(i, N - 1) {
int u = getint(), v = getint();
to[k] = v;
ne[k] = he[u];
he[u] = k++;
to[k] = u;
ne[k] = he[v];
he[v] = k++;
}
int q = 0, p = 0;
Q[q++] = 1;
while (p < N) {
int u = Q[p++];
int tmp = 0;
int ind = he[u];
he[u] = 0;
while (ind) {
int v = to[ind];
tmp = ne[ind];
if (he[v] > 0) {
Q[q++] = v;
ne[ind] = he[u];
he[u] = -ind;
}
ind = tmp;
}
}
int are = 1000000, pd0 = are;
int L = 0, R = (N + K - 1) / K;
while (L + 1 < R) {
int wj = (L + R) / 2;
int num = 0;
for (int i = N - 1; i >= 0; i--) {
int po = pd0 - 1;
int dd = pd0;
int u = Q[i];
for (int ind = -he[u]; ind; ind = -ne[ind]) {
int v = to[ind];
if (po < pl[v]) po = pl[v];
if (dd < dl[v]) dd = dl[v];
}
if (po >= dd) dd = 0;
if (dd >= pd0 + wj) {
num++;
po = pd0 + wj;
dd = 0;
}
pl[u] = po - 1;
dl[u] = dd + 1;
if (num > K) break;
}
int are = num + (dl[1] > pd0);
if (are > K) L = wj;
else R = wj;
pd0 += are;
}
printf("%d", R);
Would you please return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<vector<int>> to(N);
for (int e = 0; e < N - 1; e++) {
int u, v;
cin >> u >> v;
u--, v--;
to[u].push_back(v), to[v].push_back(u);
}
int ng = -1, ok = N;
while (ok - ng > 1) {
const int c = (ok + ng) / 2;
int required = 0;
auto dfs = [&](auto self, int now, int prv) -> pair<int, int> {
int farthest_alive = 0;
int kouka = -1; // 何個さかのぼって消すか
for (auto nxt : to[now]) if (nxt != prv) {
auto [fa, k] = self(self, nxt, now);
if (fa >= 0) farthest_alive = max(farthest_alive, fa + 1);
if (k >= 0) kouka = max(kouka, k - 1);
}
if (farthest_alive <= kouka) {
farthest_alive = -1;
}
if (farthest_alive >= c) {
farthest_alive = -1;
required++;
kouka = c;
}
return {farthest_alive, kouka};
};
auto [f, k] = dfs(dfs, 0, -1);
if (f >= 0) required++;
(required <= K ? ok : ng) = c;
}
cout << ok << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef queue<ll> ql;
typedef deque<ll> dql;
typedef priority_queue<ll> pql;
typedef set<ll> sl;
typedef pair<ll, ll> pl;
typedef vector<vl> vvl;
typedef vector<pl> vpl;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define rep2(i, k, n) for(ll i = ll(k); i <= ll(n); i++)
#define rep3(i, n, k) for(ll i = ll(n); i >= ll(k); i--)
#define all(v) (v).begin(), (v).end()
ll mod(ll a, ll b) {if(b == 0) return 0; return (a % b + b) % b;}
template <typename T, typename U> bool chmin(T &a, const U b) {if(a > b) {a = b; return 1;} return 0;}
template <typename T, typename U> bool chmax(T &a, const U b) {if(a < b) {a = b; return 1;} return 0;}
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
//const ll MOD = 998244353;
const ll MAX = 2e5;
const ld eps = 1e-9;
const char newl = '\n';
ll n;
vvl G;
vl memo;
ll f(ll s) {
if(memo[s]) return memo[s];
vl v;
rep(i, n) if(s & (1LL << i)) v.push_back(i);
ll vs = v.size();
bool is_complete = 1;
rep(i, vs-1) {
if(!is_complete) break;
rep2(j, i+1, vs-1) if(!count(all(G[v[i]]), v[j])) {
is_complete = 0;
break;
}
}
if(is_complete) {
memo[s] = 1;
return 1;
}
ll res = vs;
for(ll t=(s-1)&s; t>0; t=(t-1)&s) chmin(res, f(t) + f(s-t));
memo[s] = res;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll m, a, b;
cin >> n >> m;
G = vvl(n);
memo = vl(1LL << n);
rep(_, m) {
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
cout << f((1LL << n) - 1) << newl;
return 0;
} | #include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <functional>
#include <bitset>
#ifdef VS
#define __builtin_clz(v) __lzcnt(v)
#endif
constexpr int MAXN = 18;
int n, m;
int gr[MAXN];
char dp[1 << MAXN];
std::bitset<1 << MAXN> may;
int32_t main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
gr[i] |= (1 << i);
}
for (int i = 0; i < m; i++) {
int u, v;
std::cin >> u >> v;
u--; v--;
gr[u] |= 1 << v;
gr[v] |= 1 << u;
}
may[0] = true;
for (int mask = 1; mask < (1 << n); mask++) {
int i = 31 - __builtin_clz(mask);
if ((may[mask ^ (1 << i)]) && ((gr[i] & mask) == mask)) {
may[mask] = true;
}
}
std::fill(dp, dp + (1 << n), n);
dp[0] = 0;
for (int mask = 1; mask < (1 << n); mask++) {
if (may[mask]) {
dp[mask] = 1;
continue;
}
for (int s_mask = mask; s_mask > 0; s_mask = (s_mask - 1) & mask) {
if (may[s_mask]) {
dp[mask] = std::min<char>(dp[mask], dp[mask ^ s_mask] + 1);
}
}
}
std::cout << (int)dp[(1 << n) - 1] << std::endl;
return 0;
} |
#include "iostream"
#include "algorithm"
#include "cstring"
#include "cstdio"
#include "cmath"
#include "vector"
#include "map"
#include "set"
#include "queue"
using namespace std;
#define MAXN 206
//#define int long long
#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)
#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)
#define pii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define vi vector<int>
#define all(x) (x).begin() , (x).end()
#define mem( a ) memset(a , 0 , sizeof a )
typedef long long ll;
#define fail return void( puts("-1") )
int n , m;
int c[MAXN];
int G[MAXN][MAXN];
vi g[MAXN];
int vis[MAXN];
set<pii> S;
void dfs( int u , int fa ) {
vis[u] = vis[fa] + 1;
for( int v : g[u] ) if( v != fa ) {
if( !vis[v] ) S.insert( mp( v , u ) ) , dfs( v , u );
else if( vis[v] < vis[u] ) S.insert( mp( v , u ) );// , cout << v << ' ' << u << endl;
}
}
void solve() {
cin >> n >> m;
vector<pii> ff;
rep( i , 1 , m ) {
int u , v;
scanf("%d%d",&u,&v);
G[u][v] = 1;
ff.eb( mp( u , v ) );
}
rep( i , 1 , n ) scanf("%d",c + i);
rep( i , 1 , n ) rep( j , 1 , n ) if( G[i][j] ) {
if( c[i] != c[j] ) {
if( c[i] < c[j] ) G[i][j] = 0 , G[j][i] = 1;
} else {
g[i].pb( j ) , g[j].pb( i );
G[i][j] = 0;
}
}
rep( i , 1 , n ) if( !vis[i] ) dfs( i , i );
for( auto t : ff ) {
int u = t.fi , v = t.se;
if( c[u] != c[v] ) {
if( G[u][v] ) puts( "->" );
else puts( "<-" );
} else {
if( S.count( mp( u , v ) ) ) puts("<-");
else puts("->");
}
}
}
signed main() {
// int T;cin >> T;while( T-- ) solve();
solve();
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define rep1(i,n) for(ll i=1;i<=(ll)(n);i++)
#define LOCAL 1;
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl
#else
#define dbg(x) true
#endif
template<typename T>
ostream& operator<< (ostream& out, const vector<T>& v) {
out << "[";
size_t last = v.size() - 1;
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
if (i != last)
out << ", ";
}
out << "]";
return out;
}
template<typename F, typename S>
ostream& operator<< (ostream& out, const pair<F,S>& p) {
out << "[" << p.first << ", " << p.second << "]";
return out;
}
vector<int> c;
vector<pair<int,int>> c_idx;
vector<set<int>> g;
set<pair<int,int>> ed;
//0-indexed
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) { }
//木の根なら-(size of tree) それ以外は木の根のindexが入っている。
bool unite(int x, int y) {
x = root(x); y = root(y);
if (x != y) {//xの方がでかい
if (data[y] < data[x]) swap(x, y);
data[x] += data[y]; data[y] = x;
}
return x != y;
}
bool same(int x, int y) {
return root(x) == root(y);
}
int root(int x) {
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) {
return -data[root(x)];
}
};
map<pair<int,int>,string> ans;
void dfs(int cv, UnionFind &uf, set<int> &cver, vector<bool> &used, map<int,int> &mp){
// cout << cv << endl;
used[mp[cv]] = true;
for(auto nv:g[cv]){
if(cver.count(nv) && !used[mp[nv]]){
ans[{cv,nv}] = "->";
used[mp[nv]]=true;
dfs(nv,uf,cver,used,mp);
}
if(ans.count({cv,nv})==0 && ans.count({nv,cv})==0){
ans[{cv,nv}] = "->";
}
}
}
void solve(vector<int> &cver){
UnionFind uf(((int)cver.size()));
map<int,int> mp;
set<int> st;
rep(i,cver.size()){
st.insert(cver[i]);
}
rep(i,cver.size()){
mp[cver[i]] = i;
}
for(auto i:cver){
for(auto j:cver){
if(i>=j) continue;
if(ed.count({i,j})){
uf.unite(mp[i],mp[j]);
}
}
}
vector<bool> used(cver.size(),false);
rep(i,cver.size()){
if(uf.root(i)==i){
// dbg(i);
dfs(cver[i],uf,st,used,mp);
}
}
rep(i,cver.size()){
for(auto nv:g[cver[i]]){
if(st.count(nv)==0) ans[{cver[i],nv}] = "->";
g[nv].erase(cver[i]);
}
g[cver[i]].clear();
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,m;
cin >> n >> m;
c.resize(n);
c_idx.resize(n);
g.resize(n,set<int>());
vector<pair<int,int>> inp;
rep(i,m){
int a,b;
cin >> a >> b;
--a;--b;
g[a].insert(b);
g[b].insert(a);
ed.insert({min(a,b),max(a,b)});
inp.push_back({a,b});
}
rep(i,n) cin >> c[i];
rep(i,n) c_idx[i] = {c[i],i};
sort(c_idx.rbegin(),c_idx.rend());
// rep(i,n)dbg(c_idx[i]);
rep(i,n){
vector<int> cver = {c_idx[i].second};
int ni = i+1;
while(ni<n && c_idx[ni].first==c_idx[i].first){
// dbg(c_idx[ni].second);
cver.push_back(c_idx[ni].second);
ni++;
}
// dbg(cver);
i=ni-1;
solve(cver);
}
rep(i,inp.size()){
if(ans.count(inp[i])) cout << ans[inp[i]] << endl;
else{
if(ans.count({inp[i].second,inp[i].first})){
cout << "<-" << endl;
}
// else{
// cout <<"->" << endl;
// }
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A;
cin >> A;
int B;
cin >> B;
int W;
cin >> W;
int i = 0;
int a = 0;
int c, d;
int w = W * 1000;
while (true) {
i++;
if (a == 0) {
if (A * i <= w && B * i >= w) {
a = 1;
c = i;
}
}
else if (a == 1) {
if (A * i > w) {
a = 2;
d = i - 1;
break;
}
}
if (a == 0 && i >= 1000000) {
break;
}
}
if (a == 2) {
cout << c << " " << d << endl;
}
if (a == 0) {
cout << "UNSATISFIABLE" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;//三年竞赛一场空，不开long long见祖宗
//typedef __int128 lll;
#define print(i) cout << "debug: " << i << endl
#define close() ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define mem(a, b) memset(a, b, sizeof(a))
#define pb(a) push_back(a)
#define x first
#define y second
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int maxn = 4e5 + 10;
const int inf = 0x3f3f3f3f;
double a[maxn], b[maxn];
const double eps=1e-6;
int vis[maxn];
int n, m, k;
inline int sgn(double x)
{
if(x>-eps && x<eps)
return 0;
if(x>0) return 1;
else return -1;
}
int main()
{
cin >> n >> m >> k;
for(int i = 1; i <= k; i++)
{
int x; cin >> x; vis[x] = 1;
}
double suma = 0, sumb = 0;
for(int i = n - 1; i >= 0; i--)
{
if(vis[i])
{
a[i] = 1, b[i] = 0;
}
else
{
a[i] = suma / m, b[i] = sumb / m + 1;
}
suma += a[i], suma -= a[i + m];
sumb += b[i], sumb -= b[i + m];
}
//cout << a[1] << " " << b[1] << endl;
if(sgn(a[0] - 1) == 0) cout << -1 << endl;
else
{
double res = b[0] / (1 - a[0]);
printf("%.4f\n", res);
}
}
|
#include<bits/stdc++.h>
#define f first
#define int long long
#define s second
using namespace std;
const int N=2e5+5,mod=998244353;
int t,n,a[N];
string s;
main(){
cin>>n;
// t=1;
int ans=0,cur=0;
for(int i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+n+1);
for(int i=1;i<=n;i++){
ans += a[i]*((cur+a[i])%mod)%mod;
ans%=mod;
cur=(cur*2+a[i])%mod;
}
cout<<ans;
}
| #define _CRT_SECURE_NO_WARNINGS
#define fast ios::sync_with_stdio(false); cin.tie(0)
#define foru(i, k, n) for (ll i = k; i < n; i++)
#define ford(i, k, n) for (ll i = k; i >= n; i--)
#define pb push_back
#define ff first
#define ss second
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <list>
#include <queue>
#include <bitset>
#include <map>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef pair<ll, ll> pll;
const ll mod = 998244353;
void imult(ll& lhs, const ll& rhs) {
lhs = ((lhs % mod) * (rhs % mod)) % mod;
}
void iadd(ll& lhs, const ll& rhs) {
lhs = ((lhs%mod) + (rhs%mod)) % mod;
}
void isubt(ll& lhs, const ll& rhs) {
ll ret = (lhs - rhs) % mod;
lhs = ret + (ret < 0 ? mod : 0);
}
ll bpw(const ll& lhs, const ll& rhs) {
if (rhs == 0)return 1;
ll ret = bpw(lhs, rhs >> 1);
imult(ret, ret);
if (rhs & 1) imult(ret, lhs);
return ret;
}
ll inv(const ll& x) {
return bpw(x, mod - 2);
}
ll mult(const ll& lhs, const ll& rhs) {
return ((lhs % mod) * (rhs % mod)) % mod;
}
ll add(const ll& lhs, const ll& rhs) {
return ((lhs%mod) + (rhs%mod)) % mod;
}
ll subt(const ll& lhs, const ll& rhs) {
ll ret = (lhs - rhs) % mod;
return ret + (ret < 0 ? mod : 0);
}
ll div(const ll& lhs, const ll& rhs) {
return mult(lhs, inv(rhs));
}
const int sz = 5e5;
int n;
int a[sz];
int main() {
fast;
cin >> n;
ll sum = 0;
foru(i, 0, n)
cin >> a[i], iadd(sum, mult(a[i], a[i]));
sort(a, a + n);
ll poly = a[0];
foru(i, 1, n) {
iadd(sum, mult(poly, a[i]));
imult(poly, 2);
iadd(poly, a[i]);
}
cout << sum << '\n';
return 0;
} |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define debug(var) do{cout << #var << " : "; view(var);}while(0)
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
template<class T> void view(T e) {cout << e << endl;}
template<class T> void view(const vector<T> &v) {for(const auto &e : v){cout << e << " ";} cout << endl;}
template<class T> void view(const vector<vector<T>> &vv) {for(const auto &v : vv){view(v);}}
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int,int>;
const int inf = 1<<30;
const ll inf_l = 1LL<<61;
const int MAX = 1e5;
const int mod = 1e9 + 7;
struct mint {
ll x;
mint (ll x = 0) : x((x % mod + mod) % mod) {}
mint operator -() const {return mint(-x);}
mint& operator +=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator -=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator *=(const mint a) {(x *= a.x) %= mod; return *this;}
mint operator +(const mint a) const {return mint(*this) += a;}
mint operator -(const mint a) const {return mint(*this) -= a;}
mint operator *(const mint a) const {return mint(*this) *= a;}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const {return pow(mod - 2);}
mint operator /=(const mint a) {return *this *= a.inv();}
mint operator /(const mint a) {return mint(*this) /= a;}
};
istream& operator >>(istream &is, mint &a) {return is >> a.x;}
ostream& operator <<(ostream &os, const mint &a) {return os << a.x;}
mint dp[2005][2005];
mint sum_v[2005][2005];
mint sum_h[2005][2005];
mint sum_d[2005][2005];
int main() {
int h, w; cin >> h >> w;
vector<string> field(h);
rep(i,h) cin >> field[i];
sum_v[1][1] = 1;
sum_h[1][1] = 1;
sum_d[1][1] = 1;
dp[1][1] = 1;
REP(i,h+1)REP(j,w+1) {
if (field[i - 1][j - 1] == '#') continue;
if (i == 1 && j == 1) continue;
dp[i][j] = sum_v[i - 1][j] + sum_h[i][j - 1] + sum_d[i - 1][j - 1];
sum_v[i][j] = sum_v[i - 1][j] + dp[i][j];
sum_h[i][j] = sum_h[i][j - 1] + dp[i][j];
sum_d[i][j] = sum_d[i - 1][j - 1] + dp[i][j];
}
cout << dp[h][w] << endl;
} | #include <bits/stdc++.h>
#define endl '\n'
#define INF 0x3f3f3f3f
#define Inf 1000000000000000000LL
#define int long long
#define pb push_back
#define mp make_pair
#define F first
#define S second
using namespace std;
typedef pair<int,int>pii;
int n,m;
char a[510][510];
int cntr,cntb;
signed main(){
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>(a[i]+1);
for(int i=1;i<=m;i++){
bool flgr=0,flgb=0;
for(int x=1,y=i;x<=n&&y>=1;x++,y--){
if(a[x][y]=='R')flgr=1;
if(a[x][y]=='B')flgb=1;
}
if(flgr==1&&flgb==1)return puts("0"),0;
if(flgr==1)cntr++;
if(flgb==1)cntb++;
}
for(int i=2;i<=n;i++){
bool flgr=0,flgb=0;
for(int x=i,y=m;x<=n&&y>=1;x++,y--){
if(a[x][y]=='R')flgr=1;
if(a[x][y]=='B')flgb=1;
}
if(flgr==1&&flgb==1)return puts("0"),0;
if(flgr==1)cntr++;
if(flgb==1)cntb++;
}
int t=n+m-1LL-cntr-cntb;
// cout<<t<<endl;
int ans=1LL;
for(int i=1;i<=t;i++)ans=ans*2LL%998244353LL;
cout<<ans<<endl;
return 0;
}
/*
rrb
rbr
brr
r.r
.br
...
#####
#####
#####
*/
|
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
// Use g++ compiler for this include to work.
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
// Constants
#define INF 2e18
#define EPS 1e-9
#define MOD 1000000007
// // for using in pairs
#define F first
#define S second
// Macros
#define all(x) begin(x), end(x)
#define allr(x) rbegin(x), rend(x)
// aliases
using ll = long long;
using ull = unsigned long long;
using ui = unsigned int;
using ld = long double;
template<typename T>
using oset = tree<T, null_type, less <T>, rb_tree_tag, tree_order_statistics_node_update>;
// Temporary macro.
#define int long long
// Operator overloads.
/**
* Both types in the pair should have overload for << operator with ostream.
*/
template<typename T1, typename T2>
ostream& operator<<(ostream &ostream, pair<T1, T2>& p)
{
ostream << p.first << " " << p.second;
return ostream;
}
/**
* The type of element in the vector should have overload for << operator with ostream.
*/
template<typename T>
ostream& operator<<(ostream &stream, vector<T>& v)
{
for (const auto &it : v)
stream << it << " ";
return stream;
}
template<typename T1, typename T2>
istream& operator>>(istream &istream, pair<T1, T2>& p)
{
istream >> p.first >> p.second;
return istream;
}
template<typename T>
istream& operator>>(istream &istream, vector<T>& a)
{
for (auto &it : a)
istream >> it;
return istream;
}
// Utility functions.
template<typename T>
T MIN(T first) { return first; }
template<typename T, typename... Args>
T MIN(T first, Args... args) { return min(first, MIN(args...)); }
template<typename T>
T MAX(T first) { return first; }
template<typename T, typename... Args>
T MAX(T first, Args... args) { return max(first, MAX(args...)); }
template <typename T>
void DEBUG(T&& t) {cout << t << "\n";}
template <typename T, typename... Args>
void DEBUG(T&& t, Args&&... args)
{
cout << t << " ";
DEBUG(forward<Args>(args)...);
}
template<typename T>
int32_t size_i(T& container) { return static_cast<int32_t>(container.size()); }
// Mathematical functions.
int GCD(int a, int b)
{
if (!b)
return a;
return GCD(b, a % b);
}
int LCM(int a, int b)
{
return (a * b) / GCD(a, b);
}
int modpow(int x, int n, int m = INF)
{
if (n == 0) return 1 % m;
long long u = modpow(x, n / 2, m);
u = (u * u) % m;
if (n % 2 == 1)
u = (u * x) % m;
return u;
}
/**
* m should be prime
*/
int modinv(int x, int m = MOD)
{
return modpow(x, m - 2, m);
}
//////////////////// START CODE HERE ///////////////////////////
void preSolve()
{
}
struct comp
{
int l, t, lt, val;
comp()
{
l = 0;
t = 0;
lt = 0;
val = 0;
}
comp(int l, int t, int lt, int val)
: l(l), t(t), lt(lt), val(val) {}
int sum() { return l + lt + t; }
};
void solve(int tc)
{
int n, m;
cin >> n >> m;
char a[n + 1][m + 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> a[i][j];
comp dp[n + 1][m + 1];
for (int i = 0; i <= n; i++)
{
for (int j = 0; j <= m; j++)
{
if (!i || !j)
continue;
if (a[i][j] == '#')
{
dp[i][j] = comp();
continue;
}
if (i == 1 && j == 1)
{
dp[1][1] = comp(0, 0, 0, 1);
continue;
}
dp[i][j] = comp();
dp[i][j].l += (dp[i][j - 1].val + dp[i][j - 1].l) % MOD;
dp[i][j].t += (dp[i - 1][j].val + dp[i - 1][j].t) % MOD;
dp[i][j].lt += (dp[i - 1][j - 1].val + dp[i - 1][j - 1].lt) % MOD;
dp[i][j].val = (dp[i][j].sum()) % MOD;
}
}
cout << dp[n][m].val;
}
int32_t main()
{
#ifdef LOCAL_PROJECT
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
preSolve();
int t = 1;
// cin >> t;
for (int i = 1; i <= t; i++)
{
solve(i);
}
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pi;
const int mod=1000000007;
inline int add(int x,int y)
{
return ((ll)x+y)%mod;
}
bool g[2005][2005];
int dp[2005][2005],lr[2005][2005],tb[2005][2005],di[2005][2005];
int h,w;
int main()
{
cin.tie(0);cout.tie(0);
cin>>h>>w;
for(int i=0;i<h;i++)
{
for(int j=0;j<w;j++)
{
char c;
cin>>c;
if(c=='.') g[i][j]=1;
}
}
dp[0][0]=1;
lr[0][0]=1;
tb[0][0]=1;
di[0][0]=1;
for(int i=1;i<w;i++)
if(g[0][i])
{
dp[0][i]=lr[0][i-1];
lr[0][i]=add(dp[0][i],lr[0][i-1]);
tb[0][i]=dp[0][i];
di[0][i]=dp[0][i];
}
int la;
for(int i=1;i<h;i++)
{
if(g[i][0])
{
dp[i][0]=tb[i-1][0];
tb[i][0]=add(tb[i-1][0],dp[i][0]);
lr[i][0]=dp[i][0];
di[i][0]=dp[i][0];
}
for(int j=1;j<w;j++)
if(g[i][j])
{
dp[i][j]=add(add(tb[i-1][j],lr[i][j-1]),di[i-1][j-1]);
tb[i][j]=add(tb[i-1][j],dp[i][j]);
lr[i][j]=add(lr[i][j-1],dp[i][j]);
di[i][j]=add(di[i-1][j-1],dp[i][j]);
}
}
cout<<dp[h-1][w-1]<<endl;
return 0;
} |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <time.h>
#include <random>
#include <string>
#include <cassert>
#include <vector>
#include <ostream>
#include <istream>
#include <stack>
#include <deque>
#include <queue>
#include <functional>
#include <chrono>
#include <stack>
using namespace std;
#define int long long
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define pii pair<int, int>
#define ld long double
ostream& operator<< (ostream &out, const vector<int> &b) {
for (auto k : b) out << k << " ";
return out;
}
istream& operator>> (istream& in, pii& b) {
in >> b.first >> b.second;
return in;
}
ostream& operator<< (ostream& out, const pii& b) {
out << "{" << b.first << ", " << b.second << "}";
return out;
}
template <typename T1, typename T2> inline bool chkmin(T1 &x, const T2 &y) {if (x > y) {x = y; return 1;} return 0;}
template <typename T1, typename T2> inline bool chkmax(T1 &x, const T2 &y) {if (x < y) {x = y; return 1;} return 0;}
#ifdef LOCAL
#define dbg(x) cout << #x << " : " << (x) << "\n";
const int INF = 1e18;
// const int mod = 2600000069;
// const int p = 10;
#else
#define dbg(x) 57
const int INF = 1e18;
// const int mod = 2600000069;
// const int p = 179;
#endif
const ld PI = acos(-1);
#define time clock() / (double) CLOCKS_PER_SEC
// #pragma GCC optimize("Ofast,no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,sse3,sse4")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC optimize("fast-math")
// #pragma GCC target("avx2")
// #pragma GCC optimize("section-anchors")
// #pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
// #pragma GCC optimize("vpt")
// #pragma GCC optimize("rename-registers")
// #pragma GCC optimize("move-loop-invariants")
// #pragma GCC optimize("unswitch-loops")
// #pragma GCC optimize("function-sections")
// #pragma GCC optimize("data-sections")
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
const int MAXN = 110;
const int S = 150000;
int n, k, m;
int dp[MAXN][S];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> m;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
int val = min(i, n - i - 1);
int up = val * (val + 1) / 2 * k;
for (int sum = 0; sum <= up; sum++) {
for (int t = 0, tt = 0; t <= sum && tt <= k; t += i, tt++) {
dp[i][sum] += dp[i - 1][sum - t];
if (dp[i][sum] >= m) dp[i][sum] -= m;
}
}
}
for (int x = 1; x <= n; x++) {
int ans = 0;
int val = min(x - 1, n - x);
int up = val * (val + 1) / 2 * k;
for (int sum = 1; sum <= up; sum++) {
ans += dp[x - 1][sum] * dp[n - x][sum] % m * (k + 1) % m;
if (ans >= m) ans -= m;
}
ans += k;
if (ans >= m) ans -= m;
cout << ans << "\n";
}
}
/*
*/
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int MOD;
class mint{
int x;
public:
mint():x(0){}
mint(long long y){ x=y%MOD; if(x<0) x+=MOD; }
mint& operator+=(const mint& m){ x+=m.x; if(x>=MOD) x-=MOD; return *this; }
mint& operator-=(const mint& m){ x-=m.x; if(x< 0) x+=MOD; return *this; }
mint& operator*=(const mint& m){ x=1LL*x*m.x%MOD; return *this; }
mint& operator/=(const mint& m){ return *this*=inverse(m); }
mint operator+(const mint& m)const{ return mint(*this)+=m; }
mint operator-(const mint& m)const{ return mint(*this)-=m; }
mint operator*(const mint& m)const{ return mint(*this)*=m; }
mint operator/(const mint& m)const{ return mint(*this)/=m; }
mint operator-()const{ return mint(-x); }
friend mint inverse(const mint& m){
int a=m.x,b=MOD,u=1,v=0;
while(b>0){ int t=a/b; a-=t*b; swap(a,b); u-=t*v; swap(u,v); }
return u;
}
friend istream& operator>>(istream& is,mint& m){ long long t; is>>t; m=mint(t); return is; }
friend ostream& operator<<(ostream& os,const mint& m){ return os<<m.x; }
int to_int()const{ return x; }
};
mint operator+(long long x,const mint& m){ return mint(x)+m; }
mint operator-(long long x,const mint& m){ return mint(x)-m; }
mint operator*(long long x,const mint& m){ return mint(x)*m; }
mint operator/(long long x,const mint& m){ return mint(x)/m; }
int main(){
int n,k; scanf("%d%d%d",&n,&k,&MOD);
int m=n*(n+1)/2*k;
static mint buf[3000000];
mint* a=&buf[1500000];
a[0]=1;
for(int i=1;i<n;i++){
// * (1-X^{(k+1)*i})
for(int j=m;j>=-m+(k+1)*i;j--) a[j]-=a[j-(k+1)*i];
// / (1-X^i)
for(int j=-m;j<=m-i;j++) a[j+i]+=a[j];
}
// * (k+1)
for(int j=-m;j<=m;j++) a[j]*=k+1;
cout<<a[0]-1<<'\n';
for(int x=2;x<=n;x++){
// * (1-X^{n+1-x})
for(int j=m;j>=-m+n+1-x;j--) a[j]-=a[j-(n+1-x)];
// / (1-X^{(k+1)*(n+1-x)})
for(int j=-m;j<=m-(k+1)*(n+1-x);j++) a[j+(k+1)*(n+1-x)]+=a[j];
// * X^{-k*(x-1)}
for(int j=-m;j<=m-k*(x-1);j++) a[j]=a[j+k*(x-1)];
// * (1-X^{(k+1)*(x-1)})
for(int j=m;j>=-m+(k+1)*(x-1);j--) a[j]-=a[j-(k+1)*(x-1)];
// / (1-X^(x-1))
for(int j=-m;j<=m-(x-1);j++) a[j+(x-1)]+=a[j];
cout<<a[0]-1<<'\n';
}
return 0;
}
|
#include<bits/stdc++.h>
#include <iterator>
#include <iostream>
#include <numeric>
#include <math.h>
#define ll long long
#define ull long
#define mpa make_pair
#define pb push_back
#define ff first
#define pii pair<ll,ll>
#define dd double
#define trace(x) cerr << #x << " : " << x << endl
#define ss second
#define boost ios_base::sync_with_stdio(0)
#define forp(i,a,b) for(ll i=a;i<=b;i++)
#define rep(i,n) for(ll i=0;i<n;++i)
#define ren(i,n) for(ll i=n-1;i>=0;i--)
#define forn(i,a,b) for(ll i=a;i>=b;i--)
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(typeof((c).begin()) i = (c).begin(); i != (c).end();
#define sc(x) scanf("%lld",&x)
#define clr(x,val) memset(x,val,sizeof(x))
#define pr(x) printf("%lld\n",x)
#define pdd pair<dd,dd>
#define read_arr(a,n) for(ll i=1;i<=n;i++)cin>>a[i];
#define init_arr(a,n) for(ll i=1;i<=n;i++)a[i]=n-i+1;
#define prec(x) cout<<fixed<<setprecision(x)
#define fre freopen("input.txt","r",stdin),freopen("output.txt","w",stdout)
#define arr array
using namespace std;
ll a[200005];
int main(){
ll n,x;
cin>>n>>x;
ll tot=0;
ll sol=-1;
for(ll i=1;i<=n;i++){
ll v,p;
cin>>v>>p;
tot+=v*p;
if(tot>x*100 and sol==-1){
sol=i;
}
}
cout<<sol;
}
| #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int N;
ll X;
cin >> N >> X;
vector<ll> V(N);
vector<ll> P(N);
for (int i = 0; i < N; ++i) {
cin >> V.at(i) >> P.at(i);
}
ll total = 0;
for (int i = 0; i < N; ++i) {
total += P.at(i) * V.at(i);
if(total > X * 100){
cout << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
} |
#include <bits/stdc++.h>
int main() {
using namespace std;
cin.tie(nullptr)->sync_with_stdio(false);
int64_t a, b, c, d;
cin >> a >> b >> c >> d;
if (d * c - b > 0)
cout << (a + d * c - b - 1) / (d * c - b) << '\n';
else
cout << "-1\n";
}
| /**
* author: velengel
* created: 24.04.2021 21:04:04
**/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; (i) < (int)(n); ++ (i))
using namespace std;
using ll = long long;
using P = pair<int, int>;
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int a,b,c;
cin>>a>>b>>c;
cout<<((a*a+b*b<c*c)?"Yes":"No")<<endl;
return 0;
} |
#include <iostream>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a==b && b!=c){
cout<<c;
}
if(a==c && c!=b){
cout<<b;
}
if(b==c && c!=a){
cout<<a;
}
if(a==b && b==c){
cout<<a;
}
if(a!=b && b!=c && c!=a){
cout<<0;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef pair<ll,ll> pi;
#define forn(i,x,n) for(long long int i = x; i < n; ++i)
# define pb push_back
# define mp make_pair
struct node
{
char c;
ll v;
};
vector<ll> variable_list(10);
ll find_num(string a, ll count, node* my_struct){
ll i=0,m=1,j;
ll val=0;
for (i = a.length() - 1; i >= 0; i--)
{
char ch = a[i];
for (j = 0; j < count; j++)
if (my_struct[j].c == ch)
break;
val += m * my_struct[j].v;
m *= 10;
}
return val;
}
ll sum_check(node* my_struct, const ll count, string s1, string s2, string s3){
ll val1 = find_num(s1, count, my_struct);
ll val2 = find_num(s2, count, my_struct);
ll val3 = find_num(s3, count, my_struct);
if (val3 == (val1 + val2)) return 1;
return 0;
}
bool permute_string(const ll count, node* my_struct, ll n, string s1, string s2, string s3)
{
if (n == count - 1) {
forn(i,0,10) {
if (variable_list[i] == 0) {
if(i==0 && (my_struct[n].c == s1[0] || my_struct[n].c == s2[0] || my_struct[n].c == s3[0] )){continue;}
my_struct[n].v = i;
if (sum_check(my_struct, count, s1, s2, s3) == 1)
{
map <char,ll> m;
for (ll j = 0; j < count; j++){
m[my_struct[j].c] = my_struct[j].v;
}
forn(i,0,s1.length()) cout<< m[s1[i]];
cout<<endl;
forn(i,0,s2.length()) cout<< m[s2[i]];
cout<<endl;
forn(i,0,s3.length()) cout<< m[s3[i]];
cout<<endl;
return true;
}
}
}
return false;
}
forn(i,0,10)
{
if (variable_list[i] == 0)
{
if(i==0 && (my_struct[n].c == s1[0] || my_struct[n].c == s2[0] || my_struct[n].c == s3[0] )){continue;}
my_struct[n].v = i;
variable_list[i] = 1;
if (permute_string(count, my_struct, n + 1, s1, s2, s3))
return true;
variable_list[i] = 0;
}
}
return false;
}
bool alphametic(string s1, string s2, string s3)
{
vector<ll> freq(26);
ll count = 0;
ll l1 = s1.length();
ll l2 = s2.length();
ll l3 = s3.length();
forn(i,0,s1.length()) freq[s1[i] - 'a']++;
forn(i,0,s2.length()) freq[s2[i] - 'a']++;
forn(i,0,s3.length()) freq[s3[i] - 'a']++;
forn(i,0,26) if (freq[i] > 0) count++;
if (count > 10) return 0;
node my_struct[count];
ll j=0;
forn(i,0,26) {
if (freq[i] > 0) {
my_struct[j].c = char(i + 'a'); j++;
}
}
return permute_string(count, my_struct, 0, s1, s2, s3);
}
int main(){
string a,b,c;
cin>>a>>b>>c;
if (!alphametic(a, b, c))
cout << "UNSOLVABLE"<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long N, p, q;
cin >> N;
p = 0;
q = N * (N - 1) * 0.5;
vector<int> A(N);
rep(i, N){
cin >> A.at(i);
}
sort(A.begin(), A.end());
rep(i, N - 1){
if(A.at(i) == A.at(i + 1)){
p++;
}
else{
q = q - p * (p + 1) * 0.5;
p = 0;
}
}
q = q - p * (p + 1) * 0.5;
cout << q << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(x, a, b) for (int x = a; x <= b; x++)
#define FOD(x, a, b) for (int x = a; x >= b; x--)
#define REP(x, a, b) for (int x = a; x < b; x++)
#define RED(x, a, b) for (int x = a; x > b; x--)
void solve() {
int n, res = 0;
cin >> n;
vector<int> x(n), y(n);
REP(i, 0, n) cin >> x[i] >> y[i];
REP(i, 0, n - 1) {
REP(j, i + 1, n) {
if (abs(1.0 * (y[j] - y[i]) / (x[j] - x[i])) <= 1) {
res ++;
}
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
// cin >> tests;
// while (tests--) {
// solve();
// }
solve();
}
|
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
template<class S, class T> inline S min_L(S a,T b){
return a<=b?a:b;
}
inline int my_getchar_unlocked(){
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if(s == e && e == 1048576){
e = fread_unlocked(buf, 1, 1048576, stdin);
s = 0;
}
if(s == e){
return EOF;
}
return buf[s++];
}
inline void rd(long long &x){
int k;
int m=0;
x=0;
for(;;){
k = my_getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = my_getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
struct MY_WRITER{
char buf[1048576];
int s;
int e;
MY_WRITER(){
s = 0;
e = 1048576;
}
~MY_WRITER(){
if(s){
fwrite_unlocked(buf, 1, s, stdout);
}
}
}
;
MY_WRITER MY_WRITER_VAR;
void my_putchar_unlocked(int a){
if(MY_WRITER_VAR.s == MY_WRITER_VAR.e){
fwrite_unlocked(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a){
my_putchar_unlocked(a);
}
inline void wt_L(long long x){
int s=0;
int m=0;
char f[20];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
my_putchar_unlocked('-');
}
while(s--){
my_putchar_unlocked(f[s]+'0');
}
}
int main(){
long long N;
rd(N);
long long res = 0;
long long x = 1;
long long y;
long long c = 0;
for(;;){
y =min_L(x * 1000, N+1);
if(x >= y){
break;
}
res += c * (y - x);
c++;
x *= 1000;
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay version 20210227-1
// --- original code ---
// {
// ll @N, res = 0, x = 1, y, c = 0;
// for(;;){
// y = min(x * 1000, N+1);
// if(x >= y) break;
// res += c * (y - x);
// c++;
// x *= 1000;
// }
// wt(res);
// }
| #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
//#pragma GCC optimize ("-O3")
using namespace std;
void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i @hamayanhamayan0
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
ll N;
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N; N++;
int comma = 0;
ll ans = 0;
ll L = 1, R = 10;
rep(i, 0, 16) {
ll lft = max(1LL, L);
ll rht = min(N, R);
if (lft < rht) ans += (rht - lft) * comma;
L *= 10;
R *= 10;
if (i % 3 == 2) comma++;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >>a>>b;
vector<vector<char>> vec(a,vector<char>(b));
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
cin >>vec[i][j];
}
}
vector<int> x={-1,1,0,0};
vector<int> y={0,0,1,-1};
int ans=0;
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
if(vec[i][j]=='.'){
vec[i][j]='#';
for(int k=0;k<4;k++){
if(i+x[k]<0||j+y[k]<0||i+x[k]>=a||j+y[k]>=b){
continue;
}
if(vec[i+x[k]][j+y[k]]=='.'){
ans++;
}
}
}
}
}
cout << ans <<endl;
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e9 + 7;
const int N = 2e3;
ll fastexpo(ll a, ll b) {
ll ret = 1;
while(b) {
if(b & 1) { ret = ret * a % MOD; }
a = a * a % MOD;
b >>= 1;
}
return ret;
}
int h, w, k;
string st[N + 5];
int hr[N + 5][N + 5][2], vr[N + 5][N + 5][2];
void solve() {
cin >> h >> w;
for(int i = 0; i < h; i++) {
cin >> st[i];
for(int j = 0; j < w; j++) {
k += (st[i][j] == '.');
}
}
for(int i = 0; i < h; i++) {
int ed;
ed = 0;
for(int j = 0; j < w; j++) {
if(st[i][j] == '#') ed = j + 1;
else {
hr[i][j][0] = ed;
}
}
ed = w + 1;
for(int j = w - 1; j >= 0; j--) {
if(st[i][j] == '#') ed = j + 1;
else {
hr[i][j][1] = ed;
}
}
}
for(int i = 0; i < w; i++) {
int ed;
ed = 0;
for(int j = 0; j < h; j++) {
if(st[j][i] == '#') ed = j + 1;
else {
vr[j][i][0] = ed;
}
}
ed = h + 1;
for(int j = h - 1; j >= 0; j--) {
if(st[j][i] == '#') ed = j + 1;
else {
vr[j][i][1] = ed;
}
}
}
ll ans = 0;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
if(st[i][j] == '#') continue;
int ni = i + 1, nj = j + 1;
int tot_hr = hr[i][j][1] - hr[i][j][0] - 1;
int tot_vr = vr[i][j][1] - vr[i][j][0] - 1;
// cerr << i << ' ' << j << ' ' << tot_hr << ' ' << tot_vr << '\n';
// for(int x = 0; x < 2; x++) {
// cerr << hr[i][j][x] << ' ' << vr[i][j][x] << '\n';
// }
int tot = tot_hr + tot_vr - 1;
ll temp = (fastexpo(2, k) - fastexpo(2, k - tot));
ans = (ans + temp) % MOD;
}
}
if(ans < 0) ans += MOD;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int TC = 1;
for(int i = 1; i <= TC; i++) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define FAST_IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define show(x) cerr << #x << " = " << x << '\n'
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
const double EPS = 1e-10; // epsilon
const double PI = acos(-1);
const ll MOD = (ll)1e9 + 7;
const int N = 2e5 + 5;
int t = 1;
string s;
int main()
{
FAST_IO
//scanf("%d", &t);
while (t--)
{
cin >> s;
for (auto& c : s)
{
if (c == '.')
break;
cout << c;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
string x;
cin>>x;
int pos;
if(x.find(".")!=string::npos)
{
pos=x.find(".");
cout<<x.substr(0,pos);
}
else
cout<<x;
return 0;
} |
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
inline void wt_L(char a){
putchar_unlocked(a);
}
inline void wt_L(int x){
int s=0;
int m=0;
char f[10];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
putchar_unlocked('-');
}
while(s--){
putchar_unlocked(f[s]+'0');
}
}
int N;
int K;
int M;
int A[100];
int main(){
int res;
rd(N);
rd(K);
rd(M);
{
int Lj4PdHRW;
for(Lj4PdHRW=(0);Lj4PdHRW<(N-1);Lj4PdHRW++){
rd(A[Lj4PdHRW]);
}
}
{
int e98WHCEY;
int cTE1_r3A;
if(N-1==0){
cTE1_r3A = 0;
}
else{
cTE1_r3A = A[0];
for(e98WHCEY=(1);e98WHCEY<(N-1);e98WHCEY++){
cTE1_r3A += A[e98WHCEY];
}
}
res = N*M-cTE1_r3A;
}
if(res < 0){
res = 0;
}
if(res > K){
res = -1;
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay varsion 20200112-1
// --- original code ---
// int N, K, M, A[100];
// {
// int res;
// rd(N,K,M,A(N-1));
// res = N*M-sum(A(N-1));
// if(res < 0) res = 0;
// if(res > K) res = -1;
// wt(res);
// }
| #include <bits/stdc++.h>
using namespace std;
const long long mod1 = 1000000007;
using ll = long long;
using graph = vector<vector<int>>;
vector<ll> dx = {0,-1,0,1};
vector<ll> dy = {-1,0,1,0};
long long pow(long x,long n){
long long ans = 1;
while(n != 0){
long long a = x;
long long z = 1;
while(z*2 <= n){
a *=a;
a=a%mod1;
z*=2;
}
ans*=a;
ans=ans%mod1;
n-=z;
}
return ans;
}//累乗 x^n
template<typename T>
void input_vec(vector<T> &A,long long N){
for(int i = 0; i < N; i++){
cin >> A.at(i);
}
return;
}//入力を配列で受け取る
template<typename T>
void output_vec(vector<T> &A,long long N){
for(int i = 0; i < N; i++){
if(i != 0){
cout << " ";
}
cout << A.at(i);
}
cout << endl;
return;
}//配列を出力
template<typename T>
long long count_vec(vector<T> &A,T x){
long long counter = 0;
for(int i = 0; i < (int)A.size(); i++){
if(A.at(i) == x){
counter++;
}
}
return counter;
}//配列内のxの個数をreturn
vector<char> change_vec(string s,int n){
vector<char> ans(n);
for(int i = 0; i < n; i++){
ans.at(i) = s.at(i);
}
return ans;
}//長さがnの文字列を配列に変換
vector<ll> change_vec2(ll x){
vector<ll> ans;
while(x != 0){
ans.push_back(x%10);
x/=10;
}
return ans;
}//数列を配列に変換
ll sort_big(ll x){
vector<ll> vec = change_vec2(x);
sort(vec.begin(),vec.end());
ll ans = 0;
for(int i = (int)vec.size()-1; i >= 0 ; i--){
ans += vec.at(i);
if(i != 0) ans*=10;
}
return ans;
}//桁ごとに大きい順に並べ替え
ll sort_small(ll x){
vector<ll> vec = change_vec2(x);
sort(vec.begin(),vec.end());
ll ans = 0;
for(int i = 0; i < (int)vec.size();i++){
ans += vec.at(i);
if(i+1 != (int)vec.size()) ans*= 10;
}
return ans;
}//桁ごとに小さい順に並べ替え
int main(){
string C; cin >> C;
bool ans = false;
if(C.at(0) == C.at(1) && C.at(0) == C.at(2)) ans = true;
if(ans) cout << "Won" << endl;
else cout << "Lost" << endl;
} |
#include <bits/stdc++.h>
// clang-format off
using namespace std; using ll=long long; using ull=unsigned long long; using pll=pair<ll,ll>; const ll INF=4e18;
void print0(){}; template<typename H,typename... T> void print0(H h,T... t){cout<<h;print0(t...);}
void print(){print0("\n");}; template<typename H,typename... T>void print(H h,T... t){print0(h);if(sizeof...(T)>0)print0(" ");print(t...);}
void perr0(){}; template<typename H,typename... T> void perr0(H h,T... t){cerr<<h;perr0(t...);}
void perr(){perr0("\n");}; template<typename H,typename... T>void perr(H h,T... t){perr0(h);if(sizeof...(T)>0)perr0(" ");perr(t...);}
void ioinit() { cout << fixed << setprecision(15); cerr<<fixed<<setprecision(6); ios_base::sync_with_stdio(0); cin.tie(0); }
// clang-format on
vector<ll> makedivprimes(ll n) {
vector<ll> divprimes(n + 1, -1);
vector<bool> isprime(n + 1, true);
isprime[0] = false;
isprime[1] = false;
for (ll i = 2; i <= n; i++) {
if (isprime[i]) {
divprimes[i] = i;
for (ll j = 2 * i; j <= n; j += i) {
divprimes[j] = i; // その数をふるい落とした素数を記録
isprime[j] = false;
}
}
}
return divprimes;
}
map<ll, ll> prime_factor_fast(ll n, vector<ll>& divprimes) {
map<ll, ll> result;
ll ni = n;
while (ni >= 2) {
ll p = divprimes[ni];
if (!result.count(p)) {
result[p] = 0;
}
result[p]++;
ni = ni / p;
}
return result;
}
int main() {
ioinit();
ll l, r;
cin >> l >> r;
auto divprimes = makedivprimes(1000009);
ll gans = 0;
for (ll x = l; x < r; x++) {
if (x == 1 || divprimes[x] == x) continue;
ll ans = 0;
auto pfs = prime_factor_fast(x, divprimes);
vector<ll> primes;
for (auto pf : pfs) {
primes.push_back(pf.first);
}
ll m = primes.size();
for (ll i = 0; i < (1ULL << m); i++) {
ll usepr = 0;
ll v = 1;
for (ll j = 0; j < m; j++) {
if ((i >> j) & 1) {
v *= primes[j];
usepr++;
}
}
if (usepr == 0) {
continue;
}
ll sign = 1;
if (usepr % 2 == 0) { // 包除原理？
sign = -1;
}
// x+kv<=r;
// k<=(r-x)/v
ll k = (r - x) / v;
for (ll kk = k - 1; kk <= k + 1; kk++) {
if (x + kk * v <= r) k = kk;
}
if (k >= 1) {
ans += sign * k;
}
//perr(x, ans);
}
// 最後にxの倍数を除去
{
ll k = (r - x) / x;
for (ll kk = k - 1; kk <= k + 1; kk++) {
if (x + kk * x <= r) k = kk;
}
if (k >= 1) {
ans -= k;
}
//perr(x, ans);
}
//perr(x, ans);
gans += ans;
}
print(gans * 2);
}
| #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < (int)(n); i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
using ll = long long;
int main() {
int L, R; cin >> L >> R;
vector<ll> cnt(R + 1, 0);
for (int i = R; i >= 2; i--) {
cnt[i] = R / i - (L - 1) / i;
cnt[i] *= cnt[i];
for (int j = i + i; j <= R; j += i) cnt[i] -= cnt[j];
}
ll ans = accumulate(ALL(cnt), 0LL);
REP(i, max(L, 2), R + 1) {
ans -= 2LL * (R / i - (L - 1) / i);
ans++;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DD double
#define Pb push_back
#define Bp pop_back
#define Pf push_front
#define Fp pop_front
#define Ub upper_bound
#define Lb lower_bound
#define Bs binary_search
#define In insert
#define Mp make_pair
#define All(x) x.begin(), x.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define fast ios_base::sync_with_stdio(0);cin.tie(0)
#define X first
#define Y second
const int mx1 = 35;
const int mx2 = 105;
const int mx3 = 2005;
const int mx4 = 10005;
const int mx5 = 200005;
const int mx6 = 1000005;
typedef vector<int> Vi;
typedef vector<DD> Vd;
typedef vector<bool> Vb;
typedef vector<Vi> VVi;
typedef pair<int, int> Pii;
typedef pair<DD, DD> Pdd;
typedef vector<Pii> Vpi;
typedef vector<Pdd> Vpd;
typedef queue<int> Qi;
typedef stack<int> Si;
typedef deque<int> Di;
int _toggle(int N, int pos) {return N = N ^ (1 << pos);}
int _set(int N, int pos) {return N = N | (1 << pos);}
int _reset(int N, int pos) {return N = N & ~(1 << pos);}
bool _check(int N, int pos) {return (bool)(N & (1 << pos));}
bool _upper(char a) {return a >= 'A' && a <= 'Z';}
bool _lower(char a) {return a >= 'a' && a <= 'z';}
bool _digit(char a) {return a >= '0' && a <= '9';}
int dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
///******************************************************///
const int inf = 1e9;
int n, m, a[mx3][mx3], self[mx3], dist[mx3][mx3];
Vpi g[mx3];
void dijkstra(int sr)
{
priority_queue<Pii, vector<Pii>, greater<Pii>> Q;
for(int i = 1; i <= n; i++){
dist[sr][i] = a[sr][i];
if(a[sr][i] < inf){
Q.push({a[sr][i], i});
}
}
while(!Q.empty()){
int v = Q.top().Y;
int d_v = Q.top().X;
Q.pop();
if(d_v != dist[sr][v]){
continue;
}
for(auto i: g[v]){
int to = i.X;
int len = i.Y;
if(dist[sr][v] + len < dist[sr][to]){
dist[sr][to] = dist[sr][v] + len;
Q.push({dist[sr][to], to});
}
}
}
}
void solve()
{
cin >> n >> m;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
a[i][j] = inf;
}
self[i] = inf;
}
for(int i = 1; i <= m; i++){
int u, v, w;
cin >> u >> v >> w;
if(u == v){
self[u] = min(self[u], w);
}
else{
a[u][v] = min(a[u][v], w);
}
}
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
if(a[i][j] < inf){
g[i].Pb({j, a[i][j]});
}
}
}
for(int i = 1; i <= n; i++){
dijkstra(i);
int ans = min(dist[i][i], self[i]);
if(ans == inf){
ans = -1;
}
cout << ans << '\n';
}
}
int main()
{
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
fast;
int tc = 1;
//cin >> tc;
while(tc--){
solve();
}
}
| #include <bits/stdc++.h>
/* #include <atcoder/all> */
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
/* using namespace atcoder; */
using ll = long long;
using P = pair<int, int>;
const ll INF = 1 << 30;
template<class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct Data {
int to;
ll cost;
};
int main() {
int n, m;
cin >> n >> m;
vector<ll> dist(n, INF);
vector<vector<ll>> G2(n, vector<ll>(n, INF));
vector<vector<Data>> G(n, vector<Data>());
rep(i, m) {
int a, b;
ll c;
cin >> a >> b >> c;
a--;
b--;
if (a == b) {
chmin(dist.at(a), c);
} else {
// chmin(G2.at(a).at(b), c);
Data d = {b, c};
G.at(a).push_back(d);
}
}
// vector<vector<Data>> G(n, vector<Data>());
// rep(i, n) {
// rep(j, n) {
// if (i == j) continue;
// Data d = {j, G2.at(i).at(j)};
// G.at(i).push_back(d);
// }
// }
vector<vector<ll>> dist2(n, vector<ll>(n, INF));
rep(i, n) {
vector<ll> dist3(n, INF);
dist3.at(i) = 0;
priority_queue<pair<ll, int>, vector<pair<ll, int>>,
greater<pair<ll, int>>> que;
que.push(make_pair(dist3.at(i), i));
while (!que.empty()) {
int v = que.top().second;
ll d = que.top().first;
que.pop();
if (d > dist3.at(v)) continue;
for (auto e : G.at(v)) {
if (e.to == i) {
continue;
}
if (chmin(dist3.at(e.to), dist3.at(v) + e.cost)) {
que.push(make_pair(dist3.at(e.to), e.to));
}
}
}
rep(j, n) {
// cerr << dist3.at(j) << " ";
dist2.at(i).at(j) = dist3.at(j);
}
// cerr << endl;
}
rep(i, n) {
rep(j, n) {
if (i == j) continue;
dist.at(i) = min(dist.at(i), dist2.at(i).at(j) + dist2.at(j).at(i));
}
}
rep(i, n) {
cout << ((dist.at(i) == INF) ? -1 : dist.at(i)) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INFint = 1e9+1;
const ll INFll = (ll)1e18+1;
const int MOD=1e9+7;
template <typename T>
struct SegmentTree {
int n;
vector<T> node;
using FX = function<T(T, T)>; // T•T -> T となる関数の型
FX fx;
const T ex; // 単位元(RMQの時はex=INFint)
// 元配列 v をセグメント木で表現する
SegmentTree(vector<T> v, FX fx_, T ex_): fx(fx_), ex(ex_) {
int sz = v.size();
n = 1; while(n < sz) n *= 2; // 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 -> これを n とおく
node.resize(2 * n - 1, ex); // セグメント木全体で必要なノード数は 2n-1 個である
for(int i = 0; i < sz; i++) node[i + n - 1] = v[i]; // 配列そのままが入るのはindex n-1から
for(int i = n - 2; i >= 0; i--) node[i] = fx(node[2 * i + 1], node[2 * i + 2]); // 下の段から順に初期値を計算していく(根はnode[0])
}
void update(int x, T val) {
x += n - 1; // 最下段のノードにアクセスする
node[x] = val;
while(x > 0) {
x = (x - 1) / 2; // 自分の親ノードに行く
node[x] = fx(node[2 * x + 1], node[2 * x + 2]);
}
}
T query(int a, int b) { return query_sub(a, b, 0, 0, n); }
T query_sub(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return ex;
if (a <= l && r <= b) return node[k];
T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return fx(vl, vr);
}
T get(int x) { // もとの配列のx番目(0-indexed)の値を返す
return node[x + n - 1];
}
void print(){ // 最下段[n-1,2n-1)のn個を出力する
for(int i(0); i < n; i++) cout << node[i + n - 1] << " ";
cout << endl;
}
void printall(){ // 全てのノードの値を出力する
for(int i(0); i<2 * n; i++) cout << node[i] << " ";
cout << endl;
}
};
int main(){
int N, Q;
cin>>N>>Q;
vector<int> A(N);
for(int i(0);i<N;i++) cin>>A[i];
SegmentTree<int> stree(A, [](int x, int y){return (x ^ y);}, 0);
for(int i(0);i<Q;i++){
int t, x, y;
cin>>t>>x>>y;
x--;
if (t == 1){
stree.update(x, stree.get(x) ^ y);
} else {
cout << stree.query(x, y) << endl;
}
}
return 0;
}
| // C++ program to show Segment Tree - XOR of range
#include<bits/stdc++.h>
using namespace std;
#define w(x) int x; cin>>x; while(x--)
#define nl "\n"
#define fr(i,t) for(int i=0;i<t;i++)
#define fr1(i,a,b) for(int i = a; i<b; i++)
#define frr(i,n) for(int i = n; i>=0; i--)
#define frr1(i,a,b) for(int i = a; i>=b; i--)
#define dbug(x) cout<<#x<<"="<<x<<endl;
#define debug(v, n) fr(i,n){cout<<v[i]<<" ";if(i == n-1)cout<<nl;}
#define debug1(v, a, b) cout<<#v<<nl;fr1(i,a,b){cout<<v[i]<<" ";if(i == b)cout<<nl;}
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define pb push_back
#define ff first
#define ss second
#define pii pair<int, int>
#define ll long long int
// int -10**9 to 10**9 4 byte -2**31 to +2**31 -2147483647 to +2147483648
// long long int -10**19 to 10**19 8 byte -2**63 to +2**63
// unsigned long long int -0 to 10**20 8 byte 0 to +2**64
// log(10 ** 5) 16.60
// log(10 ** 6) 19.93
// log(10 ** 9) 29.89
// INT_MAX 0x7fffffff 2147483647
const int M1 = 1000000007;
const int M2 = 998244353;
const int N = 300005;
int BIT[N];
int arr[N];
void update(int idx, int val, int n){
while(idx<=n){
BIT[idx] ^= val;
idx += idx & (-idx);
}
}
void build (int n){
fr1(i,1,n+1){
update(i,arr[i-1],n);
}
}
ll getxor(int idx){
ll sum = 0;
while(idx){
sum ^= BIT[idx];
idx -= idx & (-idx);
}
return sum;
}
void showBIT(int n){
cout<<"BIT content : "<<nl;
fr1(i,1,n+1){
cout<<BIT[i]<<" ";
}
}
int main()
{
int n,q,type,a,b;
cin>>n>>q;
fr(i,n){
cin>>arr[i];
}
build(n);
fr(i,q){
cin>>type>>a>>b;
if(type == 1){
update(a, b, n);
}
else{
cout<<(getxor(b) ^ getxor(a-1))<<nl;
}
}
} |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rep2(i,s,n) for (int i = (s); i < (int)(n); i++)
#define ALL(a) (a).begin(),(a).end()
#define PI 3.14159265358979
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1e9+7LL;
vector<ll> IntegerToVector(ll bit, ll N) {
vector<ll> S;
for (int i = 0; i < N; ++i) {
if (bit & (1 << i)) {
S.push_back(i);
}
}
return S;
}
int gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ll N; cin >> N;
vector<ll> X(N);
rep(i, N){
cin >> X[i];
}
ll ans = 1e18;
vector<ll> pr = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
rep2(i,1,1<<15){
vector<ll> S = IntegerToVector(i,15);
ll s = S.size();
ll res = 1;
bool flag = true;
rep(j, s) res *= pr[S[j]];
rep(j, N){
if(gcd(res,X[j])==1) flag = false;
}
if(flag&&res<ans) ans = res;
}
cout << ans << endl;
} | /*
__
/\ \
_ __ ___ ___\ \ \/'\ ___ __ ___ ___ __
/\`'__\/ __`\ /'___\ \ , < / __`\ /'__`\ /' _ `\ /' _ `\ /'__`\
\ \ \//\ \L\ \/\ \__/\ \ \\`\ /\ \L\ \/\ \L\.\_/\ \/\ \/\ \/\ \/\ \L\.\_
\ \_\\ \____/\ \____\\ \_\ \_\ \____/\ \__/.\_\ \_\ \_\ \_\ \_\ \__/.\_\
\/_/ \/___/ \/____/ \/_/\/_/\/___/ \/__/\/_/\/_/\/_/\/_/\/_/\/__/\/_/
*/
#ifndef __AHA__HEADER
#define __AHA__HEADER
#include <bits/stdc++.h>
using namespace std;
#define g0 get<0>
#define g1 get<1>
#define g2 get<2>
#define ft first
#define sd second
#define sz(x) (i6) x.size()
#define psb(x) push_back(x)
#define ppb() pop_back()
#define bg(x) x.begin()
#define ed(x) x.end()
#define col(x) x.begin(), x.end()
#define srt(x) sort(x.begin(), x.end())
#define vec vector
#define deq deque
#define hmap unordered_map
#define pq priority_queue
#define fn function
#ifdef LOCAL
#define git stauDBG_MACRO_NO_WARNING
#include <dbg.h>
#define dbgt dbg(dbg::time())
#else
#define dbg(...)
#define dbgt
#endif
typedef string str;
typedef int32_t i3;
typedef int64_t i6;
typedef int64_t i64;
typedef uint32_t u3;
typedef uint64_t u6;
typedef long double d6;
typedef pair<i6, i6> p6;
typedef vec<i6> vi6;
typedef vec<p6> vp6;
typedef vec<bool> vb;
typedef vec<vi6> vv;
typedef deq<p6> dp6;
typedef deq<i6> di6;
typedef map<i6, i6> mi6;
typedef map<p6, i6> mp6;
typedef set<i6> si6;
typedef hmap<i6, i6> hi6;
typedef vv graph;
typedef vv matrix;
const i6 INF = INT64_MAX / 4;
const i6 NINF = -INF;
const i6 ZERO = 0;
const i6 ONE = 1;
#endif
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef LOCAL
ifstream cin{"input.txt"};
ofstream cout{"output.txt"};
#endif
i64 n;
cin >> n;
d6 res = 0;
for (i64 i = 1; i < n; i++) {
res += n / (double)(n - i);
}
cout << std::setprecision(11);
cout << fixed;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int a, b;
cin >> a >> b;
cout << 2*a + 100 - b;
}
| #include <bits/stdc++.h>
#define endl "\n"
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define rrep(i, n) for(ll i = n - 1; i > -1; i--)
#define all(v) v.begin(), v.end()
#define pb push_back
#define fi first
#define se second
template <class X> void print(X x) { cout << x << endl; }
void print(vl x) {
for(ll i : x) {
cout << i << " ";
}
cout << endl;
}
const ll INF = (1LL << 61) - 1;
const ll MOD = 1000000007 /*998244353*/;
const ll MAX_N = 500010;
ll a, b, c, d, e, f, h, x, y, z, p, q, n, t, r, k, w, l, ans, i, j, u, v, m;
ll codeforces = 1;
string S, T;
vector<vl> g(MAX_N);
vl A, B;
void input() { cin >> x >> y; }
void solve() { print(x * 2 + 100 - y); }
int main() {
// cout<<fixed<<setprecision(15);
cin.tie(0);
ios::sync_with_stdio(false);
input();
while(codeforces--) {
solve();
}
} |
/*
* ## ##### #### #### # # ####
* # # # # # # # # # # # #
* # # ##### # # # # # # #
* ###### # # # # # # ## # # #
* # # # # # # # # ## ## # #
* # # ##### #### #### # # ####
*/
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair <int, int>
#define X first
#define Y second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define info() cerr << __PRETTY_FUNCTION__ << ": " << __LINE__ << endl
void abc() {cerr << endl;}
template <typename T, typename ...U> void abc(T a, U ...b) {
cerr << a << ' ', abc(b...);
}
template <typename T> void printv(T l, T r) {
while (l != r) cout << *l << " \n"[++l == r];
}
template <typename A, typename B> istream& operator >> (istream& o, pair<A, B> &a) {
return o >> a.X >> a.Y;
}
template <typename A, typename B> ostream& operator << (ostream& o, pair<A, B> a) {
return o << '(' << a.X << ", " << a.Y << ')';
}
template <typename T> ostream& operator << (ostream& o, vector<T> a) {
bool is = false;
for (T i : a) {o << (is ? ' ' : '{'), is = true, o << i;}
return o << '}';
}
template <typename T> struct vv : vector <vector <T>> {
vv(int n, int m, T v) : vector <vector <T>> (n, vector <T>(m, v)) {}
vv() {}
};
template <typename T> struct vvv : vector <vv <T>> {
vvv(int n, int m, int k, T v) : vector <vv <T>> (n, vv <T>(m, k, v)) {}
vvv() {}
};
#ifdef Doludu
#define test(args...) info(), abc("[" + string(#args) + "]", args)
#define owo void(0)
#else
#define test(args...) void(0)
#define owo ios::sync_with_stdio(false); cin.tie(0)
#endif
const int mod = 1e9 + 7, N = 400001, logC = 30, logN = 19, K = 111, M = 4e6;
vector <int> adj[N];
bool vis[N];
int edge, pt;
void dfs(int v) {
edge += adj[v].size();
vis[v] = true;
pt++;
for (int u : adj[v]) if (!vis[u]) {
dfs(u);
}
}
int main () {
owo;
int n;
cin >> n;
for (int i = 0, u, v; i < n; ++i) {
cin >> u >> v, --u, --v;
adj[u].pb(v);
adj[v].pb(u);
}
int ans = 0;
for (int i = 0; i < N; ++i) if (!vis[i]) {
dfs(i);
edge >>= 1;
if (edge >= pt) ans += pt;
else ans += pt - 1;
edge = pt = 0;
}
cout << ans << endl;
} | #include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <numeric>
#include <list>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#include <deque>
#include <complex>
#include <bitset>
#include <functional>
#include <cassert>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using ld = long double;
using vld = vector<ld>;
using vb = vector<bool>;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl
#else
#define dbg(x) true
#endif
template <class T> void chmin(T& a, T b) { a = min(a, b);}
template <class T> void chmax(T& a, T b) { a = max(a, b);}
template <class T> ostream& operator<<(ostream& s, const vector<T>& a) { for(auto i : a) s << i << ' '; return s; }
constexpr ll INFL = 1LL << 60;
constexpr ld EPS = 1e-12;
ld PI = acos(-1.0);
vvll g;
vll c;
ll cc;
void dfs(ll now, ll cc) {
c[now] = cc;
for(ll nxt : g[now]) {
if(c[nxt] != -1) continue;
dfs(nxt, cc);
}
}
void solve() {
ll n;
cin >> n;
const int maxn = 400000;
g.assign(maxn+1, vll(0));
rep(i, n) {
ll a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
c.assign(maxn, -1);
cc = 0;
rep(i, maxn) {
if(c[i] != -1) continue;
dfs(i, cc);
++cc;
}
assert(cc > 0);
vll v(cc), e(cc);
rep(i, maxn) {
assert(c[i] < cc);
++v[c[i]];
e[c[i]] += g[i].size();
}
rep(i, cc) e[i] /= 2;
ll ans = 0;
rep(i, cc) {
if(e[i] == v[i] - 1) ans += v[i] - 1;
else ans += v[i];
}
cout << ans << endl;
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define itn int
#define rep2(i,a,n) for(int i = (a);i < (n);i++)
#define rep(i,n) rep2(i,0,n)
int main(void){
string s,t;
cin >> s >> t;
if(s == "Y"){
if(t == "a")cout << "A";
else if(t == "b")cout << "B";
else cout << "C";
} else cout << t;
} | #include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#define int long long
#define ll long long
using namespace std;
int n;ll k,s3[3000010],s2[3000010],f2[3000010],s[1000010];
void solve1(int sum,int fir,ll k)
{
ll sec=max(1ll,sum-fir-n)+k-1;
printf("%lld %lld %lld",fir,sec,sum-fir-sec);
exit(0);
}
void solve(int sum,ll k)
{
for(int i=1;i<=n;i++)
{
s[i]=s[i-1]+f2[sum-i];
if(s[i]>=k)
solve1(sum,i,k-s[i-1]);
}
}
signed main()
{
scanf("%lld %lld",&n,&k);
for(int i=2;i<=2*n;i++)
{
f2[i]=n-abs(i-(n+1));
s2[i]=s2[i-1]+f2[i];
}
for(int i=2*n+1;i<=3*n;i++)
s2[i]=s2[i-1];
for(int i=3;i<=3*n;i++)
s3[i]=s3[i-1]+s2[i-1]-s2[max(0ll,i-n-1)];
for(int i=3;i<=3*n;i++)
if(s3[i]>=k)
solve(i,k-s3[i-1]);
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int i = (s); i < (n); ++i)
#define rem(i, s, n) for (int i = (s); i >= (n); --i)
using ll = long long;
const int MOD = 1e9 + 7;
int main(){
int n, k, m; cin >> n >> k >> m;
vector<int> a(n); rep(i, 0, n) cin >> a[i];
int sum = accumulate(a.begin(), a.end(), 0);
int g = n * m;
if (g - sum > k) cout << -1 << endl;
else cout << max((g - sum), 0) << endl;
return 0;
} | #include<iostream>
using namespace std;
int main(){
int n, k, m;
cin >> n >> k >> m;
int sum = 0;
for (int i = 0; i < n-1; i++)
{
int ai;
cin >> ai;
sum += ai;
}
int ans = n * m - sum;
if (ans <= k)
{
if(ans<0)
ans = 0;
cout << ans << endl;
return 0;
}
cout << "-1" << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
void solve()
{
ll r, x, y;
cin >> r >> x >> y;
double d = sqrt(x * x + y * y);
ll k = ceil(d / r);
if (d == r)
cout << "1";
else if (d <= 2 * r)
cout << "2";
else
cout << k;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
// cin>>t;
while (t--)
{
solve();
cout << endl;
}
return 0;
} | #include<bits/stdc++.h>
#pragma GCC optimize ("-O2")
using namespace std;
#define el "\n"
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define fo(a,n) for(int i=a;i<n;i++)
#define rep(i,a,b) for (int i = a; i < b; i++)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x <<" "; _print(x); cerr << endl;
#else
#define debug(x)
#endif
void _print(int t) {cerr << t;}
void _print(string t) {cerr << t;}
void _print(char t) {cerr << t;}
void _print(double t) {cerr << t;}
template <class T, class V> void _print(pair <T, V> p);
template <class T> void _print(vector <T> v);
template <class T> void _print(set <T> v);
template <class T, class V> void _print(map <T, V> v);
template <class T> void _print(multiset <T> v);
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.ff); cerr << ","; _print(p.ss); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((int)result * base) % mod;
base = ((int)base * base) % mod;
exp >>= 1;
}
return result;
}
void c_p_c()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int32_t main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
//c_p_c();
int a, b, c;
cin >> a >> b >> c;
if (!(c & 1)) {
a = abs(a);
b = abs(b);
}
if (a < b) cout << "<";
else if (a == b) cout << "=";
else cout << ">";
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <stdint.h>
#include <string.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <deque>
#include <string>
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
#include <random>
#define sqr(x) (x) * (x)
typedef int i64;
using namespace std;
using namespace std::chrono;
const i64 mod = 1'000'000'000ll + 7;
//const i64 mod = 998'244'353ll;
const i64 inf = 1'000'000'000'000'000'000ll;
const long double eps = 1e-8;
struct TCalcSegTree {
using Type = i64;
const Type Zero = 0;
inline Type Combine(Type a, Type b) {
return a ^ b;
}
i64 N = 0;
vector<Type> St;
TCalcSegTree() {}
TCalcSegTree(i64 size) {
Init(size);
}
void Init(i64 size) {
N = 1;
while (N < size) {
N *= 2;
}
St.assign(N * 2, Zero);
}
void Set(i64 i, Type v, i64 x, i64 lx, i64 rx) {
if (rx - lx == 1) {
St[x] = Combine(St[x], v);
return;
}
i64 m = (lx + rx) / 2;
if (i < m) {
Set(i, v, x * 2 + 1, lx, m);
}
else {
Set(i, v, x * 2 + 2, m, rx);
}
St[x] = Combine(St[x * 2 + 1], St[x * 2 + 2]);
}
void Set(i64 i, Type v) {
Set(i, v, 0, 0, N);
}
Type Calc(i64 l, i64 r, i64 x, i64 lx, i64 rx) {
if (lx >= r || l >= rx) {
return Zero;
}
if (l <= lx && rx <= r) {
return St[x];
}
i64 m = (lx + rx) / 2;
Type v1 = Calc(l, r, x * 2 + 1, lx, m);
Type v2 = Calc(l, r, x * 2 + 2, m, rx);
return Combine(v1, v2);
}
Type Calc(i64 l, i64 r) {
return Calc(l, r, 0, 0, N);
}
};
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout.precision(15); cout.setf(ios::fixed); cerr.precision(15); cerr.setf(ios::fixed);
if (sizeof(i64) != sizeof(long long int)) {
cerr << "i64 != long long int" << endl;
}
i64 n, m;
cin >> n >> m;
vector<i64> a(n);
for (i64 i = 0; i < n; i++) {
cin >> a[i];
}
TCalcSegTree st(n);
for (i64 i = 0; i < n; i++) {
st.Set(i, a[i]);
}
stringstream ss;
for (i64 i = 0; i < m; i++) {
i64 t, x, y;
cin >> t >> x >> y;
if (t == 1) {
st.Set(x - 1, y);
}
else {
i64 R = st.Calc(x - 1, y);
ss << R << endl;
}
}
cout << ss.str();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define rrep(i, a, b) for (ll i = b - 1; a <= i; i--)
ll MOD = 1000000007;
ll N, M, Q, X[200010], Y[200010], op[200010][2], A[200010], B[200010];
ll c[200010][2], sign[200010][2];
bool swap_xy[200010];
int main () {
cin >> N;
rep (i, 0, N) cin >> X[i] >> Y[i];
cin >> M;
rep (i, 0, M) {
cin >> op[i][0];
if (op[i][0] > 2) cin >> op[i][1];
}
cin >> Q;
rep (i, 0, Q) {
cin >> A[i] >> B[i];
B[i]--;
}
sign[0][0] = sign[0][1] = 1;
rep (i, 0, M) {
ll p = op[i][1];
if (op[i][0] == 1) {
c[i+1][0] = c[i][1];
c[i+1][1] = -c[i][0];
sign[i+1][0] = sign[i][1];
sign[i+1][1] = -sign[i][0];
swap_xy[i+1] = !swap_xy[i];
} else if (op[i][0] == 2) {
c[i+1][0] = -c[i][1];
c[i+1][1] = c[i][0];
sign[i+1][0] = -sign[i][1];
sign[i+1][1] = sign[i][0];
swap_xy[i+1] = !swap_xy[i];
} else if (op[i][0] == 3) {
c[i+1][0] = 2 * p - c[i][0];
c[i+1][1] = c[i][1];
sign[i+1][0] = -sign[i][0];
sign[i+1][1] = sign[i][1];
swap_xy[i+1] = swap_xy[i];
} else {
c[i+1][0] = c[i][0];
c[i+1][1] = 2 * p - c[i][1];
sign[i+1][0] = sign[i][0];
sign[i+1][1] = -sign[i][1];
swap_xy[i+1] = swap_xy[i];
}
}
rep (i, 0, Q) {
ll x = X[B[i]], y = Y[B[i]];
if (swap_xy[A[i]]) swap(x, y);
x = c[A[i]][0] + sign[A[i]][0] * x;
y = c[A[i]][1] + sign[A[i]][1] * y;
cout << x << " " << y << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <functional>
#include <cassert>
#include <stack>
#include <numeric>
#include <iomanip>
#include <limits>
#include <random>
#include <unordered_map>
typedef int64_t ll;
typedef std::pair<int, int> Pii;
typedef std::pair<ll, ll> Pll;
typedef std::pair<double, double> Pdd;
#define rip(_i, _n, _s) for (int _i = (_s); _i < (int)(_n); _i++)
#define all(_l) _l.begin(), _l.end()
#define rall(_l) _l.rbegin(), _l.rend()
#define MM << " " <<
template<typename _T>
using MaxHeap = std::priority_queue<_T>;
template<typename _T>
using MinHeap = std::priority_queue<_T, std::vector<_T>, std::greater<_T>>;
template<typename _T>
inline bool chmax(_T &_l, const _T _b) {
if (_l < _b) {
_l = _b;
return true;
}
return false;
}
template<typename _T>
inline bool chmin(_T &_l, const _T _b) {
if (_l > _b) {
_l = _b;
return true;
}
return false;
}
template<typename _T>
void vdeb(const std::vector<_T> &bb) {
for (unsigned int i = 0;i < bb.size();i++) {
if (i == bb.size() - 1) std::cout << bb[i];
else std::cout << bb[i] << ' ';
}
std::cout << '\n';
}
template<typename _T>
void vdeb(const std::vector<std::vector<_T>> &bb) {
for (unsigned int i = 0;i < bb.size();i++) {
std::cout << i << ' ';
vdeb(bb[i]);
}
std::cout << '\n';
}
using namespace std;
int main() {
int a, b; cin >> a >> b;
a += b;
if(a >= 15 && b >= 8) cout << 1 << endl;
else if(a >= 10 && b >= 3) cout << 2 << endl;
else if(a >= 3) cout << 3 << endl;
else cout << 4 << endl;
} | #include <iostream>
#include <cstring>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <map>
#include <queue>
#include <deque>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <utility>
#include <set>
const long long INF = 1LL<<60;
using ll = long long;
using namespace std;
int main() {
ll t,N;cin>>t>>N;
vector<ll> T(100);
map<ll,ll> m;
ll msize = 0;
for (int i = 0; i < 100; i++)
{
T[i] = (i*t)%100;
// cout << T[i];
if(i>0&&T[i]<T[i-1]){
m[msize] = i-1;
// cout << " " <<msize << " " <<i-1;
msize++;
}
// cout << endl;
}
m[msize] = 99;
msize++;
m[-1] = -1;
// cout << msize << endl;
ll id = N%msize;
ll id1 = (N-id)/msize;
// cout << id << id1 << endl;
ll A = id1*100 + m[id-1];
// cout << A << endl;
double b = A*(100+t)/100;
cout << (ll)(floor(b)+0.5)+1<<endl;
} |
#include <bits/stdc++.h>
//#include <iostream>
//#include <vector>
//#include <string>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const ll M = 998244353;
ll sum(ll mn, ll mx) {
return (mx - mn + 1)*(mn + mx) / 2;
}
int main() {
int t, l, r;
cin >> t;
rep(i, t) {
cin >> l >> r;
int mx;
mx = r - l - l + 1;
mx = max(mx, 0);
cout << sum(1, mx) << endl;
}
} | /*
author : Aryan Agarwal, IIT KGP
created : 10-January-2021 18:43:37 IST
*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int mxn = 2e5;
const long long INF = 2e18;
const int32_t M = 1000000007; /*more than 1e9 */ /*7 + 1e9*/
// const int32_t M = 998244353; /*less than 1e9 */ /*1 + 7*17*(1<<23) */
const long double pie = acos(-1);
#define X first
#define Y second
#define pb push_back
#define sz(a) ((int)(a).size())
#define all(a) (a).begin(), (a).end()
#define F(i, a, b) for (int i = a; i <= b; i++)
#define RF(i, a, b) for (int i = a; i >= b; i--)
#define dbg(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
vector <int> mx(mxn,-INF);
vector <int> a(mxn);
vector< vector<int> > adj(mxn);
vector <bool> vis(mxn);
// vector <bool> ans(mxn,-INF);
int ans=-INF;
int n,m;
void dfs(int u){
vis[u]=true;
for(int to : adj[u])
{
if(!vis[to])dfs(to);
}
for(int to : adj[u])
{
mx[u]=max(mx[to],mx[u]);
mx[u]=max(a[to],mx[u]);
}
ans=max(ans,-a[u]+mx[u]);
// dbg(u,a[u],mx[u]);
}
void solve_LOG()
{
cin>>n>>m;
F(i,0,n-1)cin>>a[i];
F(i,0,m-1)
{
int u,v;
cin>>u>>v;
--u;--v;
adj[u].pb(v);
}
F(i,0,n-1)
{
if(!vis[i])
dfs(i);
}
cout<<ans;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
#ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
#endif
#ifdef ARYAN_SIEVE
// defualt mxn_sieve = 1e5
sieve();
#endif
#ifdef ARYAN_SEG_SIEVE
// default [L,R] = [1,1e5]
segmented_sieve();
#endif
#ifdef ARYAN_FACT
// default mxn_fact = 1e5
fact_init();
#endif
// cout<<fixed<<setprecision(10);
int _t=1;
// cin>>_t;
for (int i=1;i<=_t;i++)
{
// cout<<"Case #"<<i<<": ";
solve_LOG();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define SPEED ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define READ freopen("out.txt","r",stdin)
#define WRITE freopen("out.txt","w",stdout);
#define pb push_back
#define mem(arr,val) memset(arr,val,sizeof(arr))
#define sf(x) scanf("%d",&x)
#define sf2(x,y) scanf("%d %d",&x,&y)
#define sf3(x,y,z) scanf("%d %d %d",&x,&y,&z)
#define sl(x) scanf("%lld",&x)
#define sl2(x,y) scanf("%lld %lld",&x,&y)
#define sl3(x,y,z) scanf("%lld %lld %lld",&x,&y,&z)
#define sd(x) scanf("%lf",&x);
#define pii pair<int,int>
#define pLL pair<long long,long long>
#define pDB pair<double,double>
#define ff first
#define sn second
#define PRINT_CASE printf("Case %d: ",tc++)
#define PRINT_CASENL printf("Case %d:\n",tc++)
#define lnd tree[ind<<1]
#define rnd tree[(ind<<1)+1]
#define cnd tree[ind]
#define lndp b,(b+e)>>1,(ind<<1)
#define rndp ((b+e)>>1)+1,e,(ind<<1)+1
#define IN(a,x,y) (a>=x && a<=y)
#define popcountL __builtin_popcountll
#define popcount __builtin_popcount
/// int other=mask^((1<<n)-1);
typedef long long ll;
typedef long long int lln;
typedef unsigned long long int ull;
ll INF=1<<28;
//typedef long long lld;
//const double pi=acos(-1.0);
int fx[]={1,-1,0,0}; //direction array
int fy[]={0,0,1,-1};
int dir[4][2]={1,0,-1,0,0,-1,0,1};
//int X[8]={0,0,1,-1,-1,1,1,-1};
int Y[8]={1,-1,0,0,-1,-1,1,1};
int knight[8][2]={1,2,1,-2,2,1,2,-1,-1,2,-1,-2,-2,1,-2,-1};
const long double EPS=1e-16;
//#define INF 10000
ll lcm(ll a,ll b)
{
return ((a*b)/__gcd(a,b));
}
struct compare
{
bool operator()(const pii& l, const pii& r)
{
if(l.ff==r.ff)
{
return l.sn>r.sn;
}
return l.ff<r.ff;
}
};
const int mx=301050;
//const int mod=998244353;
const int mod=1e9+7;
// Including Policy Based DS
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//
//////cout<<*X.find_by_order(1)<<endl;
////cout<<X.order_of_key(-5)<<endl;
//4352348930241
//const int mod=11092019;
int arr[mx];
int tree[4*mx];
void update(int b,int e,int ind,int st,int en)
{
if(st>e || en<b)
return;
if(st<=b && e<=en)
{
cnd=1;
return;
}
update(lndp,st,en);
update(rndp,st,en);
cnd=lnd+rnd;
}
int query(int b,int e,int ind,int st,int en)
{
if(st>e || en<b)
{
return 0;
}
if(st<=b && e<=en)
return cnd;
return query(lndp,st,en)+query(rndp,st,en);
}
int main()
{
int t=1,tc=1;
// sf(t);
while(t--)
{
int n;
sf(n);
for(int i=0;i<n;i++)
{
sf(arr[i]);
}
ll ans=0;
for(int i=n-1;i>=0;i--)
{
ans+=query(0,n-1,1,0,arr[i]-1);
update(0,n-1,1,arr[i],arr[i]);
}
printf("%lld\n",ans);
vector<ll>v;
for(int i=n-1;i>=1;i--)
{
ans-=(n-1-arr[i]);
ans+=(arr[i]);
v.pb(ans);
}
reverse(v.begin(),v.end());
for(int i=0;i<v.size();i++)
{
printf("%lld\n",v[i]);
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define FOR(i, j, k, in) for (ll i = j; i < k; i += in)
#define RFOR(i, j, k, in) for (ll i = j; i >= k; i -= in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
void add(vector<ll> &fw, ll index) {
index++;
while (index <= fw.size()) {
fw[index - 1]++;
index += index & -index;
}
}
ll prefix(const vector<ll> &fw, ll index) {
ll ret = 0;
while (index > 0) {
ret += fw[index - 1];
index -= index & -index;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<ll> perm(n);
REP(i, n)
cin >> perm[i];
vector<ll> forward(n), backward(n);
// set<int> elems;
vector<ll> fw(n + 2, 0);
REP(i, n) {
// int dist = distance(elems.begin(), elems.upper_bound(perm[i]));
ll dist = prefix(fw, perm[i] + 1);
// forward[i] = elems.size() - dist;
forward[i] = i - dist;
if (i != 0) forward[i] += forward[i - 1];
// elems.insert(perm[i]);
add(fw, perm[i] + 1);
}
// cout << "forward:";
// for (const auto el : forward) cout << ' ' << el;
// cout << endl;
fw.clear();
fw.resize(n + 2, 0);
// cout << "fw:";
// for (const auto el : fw) cout << ' ' << el;
// cout << endl;
RFOR(i, n - 1, 0, 1) {
// int dist = distance(elems.begin(), elems.upper_bound(perm[i]));
ll dist = prefix(fw, perm[i] + 1);
backward[i] = dist;
if (i != n - 1) backward[i] += backward[i + 1];
// elems.insert(perm[i]);
add(fw, perm[i] + 1);
}
// cout << "backward:";
// for (const auto el : backward) cout << ' ' << el;
// cout << endl;
ll total = forward[n - 1];
cout << total << endl;
// cout << endl;
FOR(i, 0, n - 1, 1) {
ll possible = (i + 1) * (n - 1 - i);
// cout << "i: " << i << endl;
// cout << "possible: " << possible << endl;
ll current = total - forward[i] - backward[i + 1];
// cout << "current: " << current << endl;
cout << possible - current + forward[i] + backward[i + 1] << endl;
// cout << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = std::int_fast64_t;
using std::cout;
using std::cerr;
using std::endl;
using std::cin;
#if defined(DONLINE_JUDGE)
#define NDEBUG
#elif defined(ONLINE_JUDGE)
#define NDEBUG
#endif
template<typename T> std::vector<T> make_v(size_t a){return std::vector<T>(a);}
template<typename T, typename... Ts> auto make_v(size_t a, Ts... ts){
return std::vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
int main() {
int n; i64 x; scanf("%d%lld", &n, &x);
std::vector<int> a(n); for(auto& v: a) scanf("%d", &v);
i64 ans = 1LL << 60;
for(int k = 1; k <= n; k++) {
auto dp = make_v<int>(k + 1, k + 1); // dp[i][j] := sum (i 個使って sum % k = j)
for(int i = 0; i < dp.size(); i++) for(int j = 0; j < dp[i].size(); j++) dp[i][j] = -1;
dp[0][0] = 0;
for(auto v: a) {
for(int i = k - 1; i >= 0; i--) {
for(int j = 0; j < k; j++) {
if(dp[i][j] == -1) continue;
int sum = dp[i][j] + v;
int to = sum % k;
if(dp[i + 1][to] == -1) dp[i + 1][to] = sum;
dp[i + 1][to] = std::max(dp[i + 1][to], sum);
}
}
}
int r = x % k;
if(dp[k][r] == -1) continue;
ans = std::min(ans, (x - dp[k][r]) / k);
#ifndef NDEBUG
cout << k << ": " << dp[k][r] << endl;
#endif
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fr(i,n) for(int i = 0; i<n; i++)
#define sz(v) (int)(v.size())
#define prin(a) cout << #a << " = " << a << endl
#define all(v) (v).begin(),(v).end()
#define rmax(a,b) a = max<ll>(a,b)
#define rmin(a,b) a = min<ll>(a,b)
typedef long long ll;
const int N = 110;
ll dp[N][N][N];
ll v[N];
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
ll n, targ; cin >> n >> targ;
ll soma = 0;
fr(i,n) cin >> v[i], soma+=v[i];
if(soma==targ){
cout << 0 << "\n";
return 0;
}
ll ans = LLONG_MAX;
for(ll t = 1; t<=n; t++){
fr(i,n+1) fr(j,n+1) fr(k,n+1) dp[k][i][j] = INT_MIN;
dp[0][0][0] = 0;
fr(i,n){
fr(t_sofar,n+1) fr(p,n){
ll r = (p+v[i])%t;
rmax(dp[i+1][t_sofar][p],
dp[i][t_sofar][p]);
if(t_sofar==n) continue;
rmax(dp[i+1][t_sofar+1][r],
dp[i][t_sofar][p]+v[i]);
}
}
ll need_r = targ%t;
if(dp[n][t][need_r]>0){
assert(dp[n][t][need_r]<=targ);
//prin(t);
//prin(dp[n][t][need_r]);
assert((targ-dp[n][t][need_r])%t==0);
rmin(ans, (targ-dp[n][t][need_r])/t);
}
}
cout << ans << "\n";
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define _GLIBCXX_DEBUG
ll gcd(ll x,ll y){
if(x<y)swap(x,y);
if(y==0)return x;
return gcd(y,x%y);
}
ll lcm(ll a,ll b){
return a*b/gcd(a,b);
}
int main() {
ll t,N;
cin>>t>>N;
int Q[200]={0};
for(int i=1;i<101;i++){
for(int j=1;j<=100+t;j++){
if(i+(t*i)/100==j){
Q[j]=1;
}
}
}
ll count=0;
ll R[200];
for(int i=1;i<=100+t;i++){
if(Q[i]==0){
count++;
R[count]=i;
}
}
ll L=0;
if(N%count==0)L=N/count-1;
else L=N/count;
ll M=N%count;
ll ans=0;
if(M==0){
ans=L*(100+t)+R[count];
}
else{
ans=L*(100+t)+R[M];
}
cout<<ans<<endl;
} | #include<cstdio>
#define ll long long
ll t, n, ans;
int main(){
scanf("%lld%lld", &t, &n);
ans = 100*n/t;
if(100*n % t != 0) ans++;
ans = ans + ans*t/100;
printf("%lld", ans-1);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define LL long long
#define READ(x) freopen(x,"r",stdin)
#define WRITE(x) freopen(x,"w",stdout)
#define BOOST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define pb push_back
#define mem(x,y) memset(x,y,sizeof x )
#define ch printf("Came Here!!!!!!!!!!!!!!!\n")
#define deb(x) cerr<<#x<<" :: "<<x<<" "
#define dnl cerr<<endl;
#define FOR(i,n) for(int i=0;i<n;i++)
#define cnd tree[idx]
#define lc tree[idx*2]
#define rc tree[idx*2+1]
#define lnd (2*idx),(b),( (b+e) /2 )
#define rnd ((2*idx)+1),(((b+e)/2)+1),(e)
#define popcount __builtin_popcount
//const LL INF = 1LL<<59;
const double PI = 2.0 * acos(0.0);
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
typedef vector<int> vi;
typedef vector<LL> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
//// Including Policy Based DS
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
/////cout<<*X.find_by_order(1)<<endl;
/////cout<<X.order_of_key(-5)<<endl;
//typedef tree<
//pll,
//null_type,
//less< pll >,
//rb_tree_tag,
//tree_order_statistics_node_update>
//ordered_set;
// Grid direction array [4]
int X[4]={0,0,-1,1};
int Y[4]={1,-1,0,0};
// Grid direction array [8]
int X8[8]={0,0,1,-1,-1,1,1,-1};
int Y8[8]={1,-1,0,0,-1,-1,1,1};
// Bishop direction array [8]
int BX[8]={0,0,1,-1,-1,1,1,-1};
int BY[8]={1,-1,0,0,-1,-1,1,1};
// Knight Direction Array
int KX[8] = {1,1,2,2,-1,-1,-2,-2};
int KY[8] = {2,-2,1,-1,2,-2,1,-1};
inline LL modMul(LL a, LL b,LL mod){
LL ans = 0;
a = a % mod;
while (b > 0){
if ( b % 2 )ans = (ans%mod+ a%mod) % mod;
a = (a%mod * 2%mod) % mod;
b /= 2;
}
return ans % mod;
}
inline LL power(LL a,LL b,LL mod){
if(b==0)return 1LL%mod;
LL x=power( a,b/2,mod );
x = (x*x) % mod;
if( b%2==1 )x = (x*a)%mod;
return x%mod;
}
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
const int mx = 234567;
void solve(int cs){
int n,m;
LL a,b,c;
cin>>a>>b>>c;
if( c%2==0 ){
if( abs(a)==abs(b) )cout<<"=";
else if( abs(a)<abs(b) )cout<<"<";
else cout<<">";
}
else{
if(a == b)cout<<"=";
else if( a<b )cout<<"<";
else cout<<">";
}
}
int main(){
BOOST;
#ifdef MujahidPC
double start = clock();
// READ("in.txt");
// WRITE("out.txt");
#endif
int t;
t = 1;
// cin>>t;
FOR(cs,t)solve(cs+1);
#ifdef MujahidPC
double tim = (clock() - start)/CLOCKS_PER_SEC;
cerr<<"Running Time : "<<tim<<" \n";
#endif
return 0;
} |
#include<iostream>
using namespace std;
// {{{{{{{{{{{{{{{ SOLVER : SANGAM KUMAR }}}}}}}}}}}}}}}
#include<math.h>
#include<stdio.h>
#include <cstdlib>
#include <ctime>
#include<cmath>
#include<string.h>
#include<stdlib.h>
#include<bits/stdc++.h>
#define ll long long int
#define start ll _; cin>>_; while(_--){ runtest();}
#define loop(j,n) for(ll h=j;h<n;h++)
#define var ll n,m,x,y,z,c,j,h,k;
#define array ll a[200004],b[200004];
#define ci cin
#define co cout
#define yes cout<<"YES\n";
#define no cout<<"NO\n";
#define nan cout<<"-1\n";
#define line cout<<"\n";
#define getarray cin>>n; ll a[200005]; loop(0,n){ ci>>a[h];}
#define putarray loop(0,n){ co<<a[h]<<" "; }
// predefined functions
ll lcm(ll a, ll b)
{
ll k=(a*b)/(__gcd(a,b));
return k;
}
bool isprime(ll n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
ll fact(ll n)
{
return (n == 1 || n == 0) ? 1 : n * fact(n - 1);
}
void runtest()
{
var;
}
int main()
{
// start
ll a,b,c;
ci>>a>>b>>c;
ll x=(ll)pow(a,c);
ll y=(ll)pow(b,c);
if(c%2==0)
{
if(abs(a)==abs(b))
{
co<<"=";
}
else if(abs(a)>abs(b))
{
co<<">";
}
else co<<"<";
}
else
{
if(a>b)
{
co<<">";
}
else if(a<b)
{
co<<"<";
}
else co<<"=";
}
return 0;
} |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define bg begin()
#define en end()
#define endl "\n"
#define vvl(n,m) vector<vector<ll> > a( n , vector<ll> (m))
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define mod 1000000007
using namespace std;
ll gcd(ll a,ll b){
if(a==0)
return b;
else return gcd(b%a,a);
}
ll power(ll x, ll y, ll m)
{
if (y == 0)
return 1;
ll p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
ll modInverse(ll a, ll m)
{
return power(a, m - 2, m);
}
ll ncr(ll n, ll k)
{
ll res = 1;
if (k > n - k)
k = n - k;
for (ll i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
void permute(string str)
{
set<string> s;
sort(str.begin(), str.end());
do {
if(s.count(str)==0)
cout << str << endl;
s.insert(str);
} while (next_permutation(str.begin(), str.end()));
}
void solve()
{
ll n,i,j;
cin>>n;
ll x[n],y[n];
for(i=0;i<n;i++){
cin>>x[i]>>y[i];
}
ll ans=0;
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(abs(x[j]-x[i])>=abs(y[j]-y[i]))
ans++;
}
}
cout<<ans;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fast
solve();
#ifndef ONLINE_JUDGE
cout << "\nTime Elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " sec\n";
#endif
return 0;
} | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <deque>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <functional>
#include <iomanip>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(int i=0;i<n;i++)
#define rep3(i,a,b) for(int i=a;i>=b;i--)
#define REP(e,v) for(auto e:v)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mp make_pair
#define mt make_tuple
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define vec vector<int>
#define vecvec vector<vec>
#define vecll vector<ll>
#define vecpii vector<pii>
#define vecpll vector<pll>
#define vecbl vector<bool>
#define endl "\n"
#define ALL(c) (c).begin(),(c).end()
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
string stin(){string s;cin>>s;return s;}
/*
string x="atcoder";
int func(string s){
if(s.length()>x.length()){
bool flag=true;
rep(i,x.length())if(s[i]!=x[i])flag=false;
if(flag)return 0;
}
rep(i,s.length())if(s[i]!='a')return i;
return -1;
}
int main(){
int n=in();
rep(i,n)cout<<func(stin())<<endl;
}
*/
int main(){
int n=in();
ll ans=0;
vecll a(n),b(n);
rep(i,n)a[i]=in();
rep(i,n)b[i]=in();
vecll odd,even;
rep(i,n){
ans += a[i];
if(i%2==0){
even.pb(b[i]-a[i]);
}else{
odd.pb(b[i]-a[i]);
}
}
sort(ALL(odd),greater<ll>());
sort(ALL(even),greater<ll>());
vecll sumO(n/2+1),sumE(n/2+1);
rep(i,n/2){
sumO[i+1]=sumO[i]+odd[i];
sumE[i+1]=sumE[i]+even[i];
}
ll tmp=LONG_MIN;
rep(i,n/2+1)tmp=max(tmp,sumO[i]+sumE[i]);
cout<<ans+tmp<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for(int i=0; i<n; i++)
#define REPi(i, a, b) for(int i=int(a); i<int(b); i++)
#define MEMS(a,b) memset(a,b,sizeof(a))
#define mp make_pair
#define MOD(a, m) ((a % m + m) % m)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll MOD = 1e9+7;
// 負の数にも対応した mod
// 例えば -17 を 5 で割った余りは本当は 3 (-17 ≡ 3 (mod. 5))
// しかし単に -17 % 5 では -2 になってしまう
inline long long mod(long long a, long long m) {
return (a % m + m) % m;
}
// 拡張 Euclid の互除法
// ap + bq = gcd(a, b) となる (p, q) を求め、d = gcd(a, b) をリターンします
//
// ## ax + by = Aを満たす一般解(x, y)を求める
// auto d = extGcd(a, b, p, q);
// if(A % d != 0) continue;
// p *= A/d, q *= A/d;
// (x, y) = (p + k * (b/d), q + k * (a/d));
long long extGcd(long long a, long long b, long long &p, long long &q) {
if (b == 0) { p = 1; q = 0; return a; }
long long d = extGcd(b, a%b, q, p);
q -= a/b * p;
return d;
}
// 中国剰余定理
// x % m1 == b1 && x % m2 == b2であるxを計算.
// リターン値を (r, m) とすると解は x ≡ r (mod. m)
// 解なしの場合は (0, -1) をリターン
pair<long long, long long> ChineseRem(long long b1, long long m1, long long b2, long long m2) {
long long p, q;
long long d = extGcd(m1, m2, p, q); // p is inv of m1/d (mod. m2/d)
if ((b2 - b1) % d != 0) return make_pair(0, -1);
long long m = m1 * (m2/d); // lcm of (m1, m2)
long long tmp = (b2 - b1) / d * p % (m2/d);
long long r = mod(b1 + m1 * tmp, m);
return make_pair(r, m);
}
int main(){
ll T;
cin >> T;
while(T--){
ll X, Y, P, Q;
cin >> X >> Y >> P >> Q;
ll T_train = 2*X + 2*Y;
ll T_player = P + Q;
const ll INF = LLONG_MAX;
ll ans = INF;
for(ll t1 = X; t1 < X+Y; t1++){
for(ll t2 = P; t2 < P+Q; t2++){
auto [r, m] = ChineseRem(t1, T_train, t2, T_player);
if(m == -1) continue;
chmin(ans, r);
}
}
if(ans == INF){
cout << "infinity" << endl;
}
else{
cout << ans << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, nn ) for(int i = 0 ; i < (int) nn; i++)
#define REPS(i, ss, nn ) for(int i = ss ; i < (int) nn; i++)
#define REV(i, ss, nn ) for(int i = ss ; i >= nn; i--)
#define deb(x) std::cout << #x << " " << x << endl;
#define debl(x) std::cout << #x << " " << x << " ";
#define all(x) x.begin(), x.end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
namespace std{
template<class Fun>
class y_combinator_result{
Fun fun_;
public:
template<class T>
explicit y_combinator_result(T &&fun) : fun_(std::forward<T>(fun)){}
template<class ...Args>
decltype(auto) operator()(Args&&...args){
return fun_(std::ref(*this), std::forward<Args>(args)...);
}
};
template<class Fun>
decltype(auto) y_combinator(Fun && fun){
return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}
};
template<typename T>
bool umax(T& a, T b){
bool ret = a < b;
if(ret) a = b;
return ret;
}
template<typename T>
bool umin(T& a, T b){
bool ret = a > b;
if(ret) a = b;
return ret;
}
struct edge{
int to; ll cost;
int from;
edge(){ edge(0,0);}
edge(int to_, ll cost_) : to(to_), cost(cost_){}
edge(int to_, int from_, ll cost_) : to(to_), cost(cost_), from(from_){}
};
template<typename... T>
void read(T& ... a){
((cin >> a),...);
}
template<typename... T>
void write(T... a){
((cout << a),...);
}
template<typename T>
vector<T> read_array(int sz){
vector<T> ret(sz);
for(auto & x : ret) cin >> x;
return ret;
}
long long gcd(long long a, long long b){
if( a < b) std::swap(a, b);
if( b == 0) return a;
return gcd(b, a%b);
}
void ext_gcd(long long a, long long b, long long& x, long long& y){
if(b == 0){
x = 1;
y = 0;
return;
}
if( a < b){
ext_gcd(b, a, y, x);
}else{
long long tmpx, tmpy;
ext_gcd(b, a % b, tmpx, tmpy);
// g = b * x + y *( a - a / b * b)
// g = y +( x - a / b * y);
x = tmpy;
y = tmpx - a / b * tmpy;
}
}
//to be verified
long long mod_inverse(long long a, long long m){
//return such that b * a = 1(mod m)
long long x, y;
ext_gcd(a, m, x, y);
assert( a * x + m * y == 1);
return ( m + x % m) % m;
}
void solve(){
ll x, y, p, q;
read(x,y, p, q);
ll T1 = 2 * (x + y) ;
ll T2 = (p + q);
ll mxT = T1 * T2;
ll ans = mxT;
ll g = gcd(T1, T2);
ll t1 = T1 / g;
ll t2 = T2 / g;
REP(i, y){
//find smallest n such that T1 * n + x + i = p (mod T2)
// T1 * n = (p - x -i) (mod T2)
if( ( p - x -i) % g != 0){
continue;
}
ll rhs = ( p - x - i) / g;
// deb(rhs)
rhs = (rhs % t2 + t2) % t2;
// deb(rhs)
ll n = mod_inverse(t1, t2);
// deb(n)
n = (n * rhs) % t2;
// deb(n)
ll res = T1 * n + x + i;
// debl(i) deb(res)
umin(ans, res);
}
REP(i, q){
//find smallest n such that T2 * n + p + i = x (mod T1)
// T2 * n = (x - p - i) (mod T1)
if( (x - p - i) % g != 0){
continue;
}
ll rhs = (x - p - i) / g;
// deb(rhs)
rhs = (rhs % t1 + t1) % t1;
// deb(rhs)
ll n = mod_inverse(t2, t1);
n = (n * rhs) % t1;
// deb(n)
ll res = T2 * n + p + i;
// debl(i) deb(res)
umin(ans, res);
}
if(ans < mxT){
write(ans, "\n");
}else{
write("infinity\n");
}
}
int main()
{
//making data IO Fast
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
/****************************/
int T = 1;
cin >> T;
while(T--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(){
int n, m;
cin>>n>>m;
vector<pair<int, int>> cond(m);
for(auto& [a, b] : cond)cin>>a>>b;
int k;
cin>>k;
vector<pair<int, int>> choice(k);
for(auto& [c , d] : choice) cin>>c>>d;
int ans = 0;
for(int bit=0;bit< 1 << k;bit++){
vector<bool> ball(n);
for(int i=0;i<k;i++){
const auto [c, d] = choice[i];
ball[bit & 1 << i ? c : d] = 1;
}
int cnt = 0;
for(auto [a, b] : cond) if(ball[b] && ball[a]) cnt++;
if(ans < cnt) ans = cnt;
}
cout<<ans;
}
int main(){
solve();
} | #include <bits/stdc++.h>
using namespace std;
// clang-format off
/* accelration */
// 高速バイナリ生成
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
// cin cout の結びつけ解除, stdioと同期しない(入出力非同期化)
// cとstdの入出力を混在させるとバグるので注意
struct Fast {Fast() {std::cin.tie(0); ios::sync_with_stdio(false);}} fast;
/* alias */
using ull = unsigned long long;
using ll = long long;
using vi = vector<int>;
using vl = vector<long>;
using vll = vector<long long>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using vvll = vector<vll>;
using vs = vector<string>;
using pii = pair<int, int>;
/* define short */
#define pb push_back
#define mp make_pair
#define all(obj) (obj).begin(), (obj).end()
#define YESNO(bool) if(bool){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;}
#define yesno(bool) if(bool){cout<<"yes"<<endl;}else{cout<<"no"<<endl;}
#define YesNo(bool) if(bool){cout<<"Yes"<<endl;}else{cout<<"No"<<endl;}
/* REP macro */
#define reps(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define rep(i, n) reps(i, 0, n)
#define rrep(i, n) reps(i, 1, n + 1)
#define repd(i,n) for(ll i=n-1;i>=0;i--)
#define rrepd(i,n) for(ll i=n;i>=1;i--)
/* debug */
// 標準エラー出力を含む提出はrejectされる場合もあるので注意
#define debug(x) cerr << "\033[33m(line:" << __LINE__ << ") " << #x << ": " << x << "\033[m" << endl;
/* func */
inline int in_int() {int x; cin >> x; return x;}
inline ll in_ll() {ll x; cin >> x; return x;}
inline string in_str() {string x; cin >> x; return x;}
// search_length: 走査するベクトル長の上限(先頭から何要素目までを検索対象とするか、1始まりで)
template <typename T> inline bool vector_finder(std::vector<T> vec, T element, unsigned int search_length) {
auto itr = std::find(vec.begin(), vec.end(), element);
size_t index = std::distance( vec.begin(), itr );
if (index == vec.size() || index >= search_length) {return false;} else {return true;}
}
template <typename T> inline void print(const vector<T>& v, string s = " ")
{rep(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");}
template <typename T, typename S> inline void print(const pair<T, S>& p)
{cout << p.first << " " << p.second << endl;}
template <typename T> inline void print(const T& x) {cout << x << "\n";}
template <typename T, typename S> inline void print(const vector<pair<T, S>>& v)
{for (auto&& p : v) print(p);}
// 第一引数と第二引数を比較し、第一引数(a)をより大きい/小さい値に上書き
template <typename T> inline bool chmin(T& a, const T& b) {bool compare = a > b; if (a > b) a = b; return compare;}
template <typename T> inline bool chmax(T& a, const T& b) {bool compare = a < b; if (a < b) a = b; return compare;}
int main(){
int a, b, c;
cin >> a >> b >> c;
if(a == b) {cout << c << endl;return 0;}
if(b == c) {cout << a << endl;return 0;}
if(a == c) {cout << b << endl;return 0;}
if(a != b && b != c){cout << 0 << endl; return 0;}
} |
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)
#define uid(a, b) uniform_int_distribution<int>(a, b)(rng)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 1100001; //check the limits, dummy
template<int SZ> struct DSU {
int parent[SZ], size[SZ];
DSU() {
F0R(i, SZ) parent[i] = i, size[i] = 0;
}
int get(int x) {
if (parent[x] != x) parent[x] = get(parent[x]);
return parent[x];
}
void unify(int x, int y) {
x = get(x); y = get(y);
if (x == y) return;
if (size[x] < size[y]) swap(x, y);
if (size[x] == size[y]) size[x]++;
parent[y] = x;
}
};
void solve() {
int N, M; cin >> N >> M;
DSU<MX> dsu;
bool A[N][M];
F0R(i, N) {
F0R(j, M) {
char C; cin >> C; A[i][j] = C == '#';
}
}
bool fr[N], fc[M];
F0R(i, N) fr[i] = false;
F0R(i, M) fc[i] = false;
F0R(i, N) {
F0R(j, M) {
if (A[i][j]) {
fr[i] = true; fc[j] = true;
dsu.unify(i*M+j, N*M+i);
dsu.unify(i*M+j, N*M+N+j);
if (i == 0 || i == N-1 || j == 0 || j == M-1) {
dsu.unify(i*M+j, N*M+N+M);
}
}
}
}
set<int> comps;
FOR(i, 1, N-1) {
FOR(j, 1, M-1) {
if (A[i][j]) comps.ins(dsu.get(i*M+j));
}
}
int ed = 0;
if (sz(comps)) {
ed = 1;
F0R(i, N) {
if (comps.count(dsu.get(i*M)) || comps.count(dsu.get(i*M+M-1))) ed = 0;
}
F0R(i, M) {
if (comps.count(dsu.get(i)) || comps.count(dsu.get((N-1)*M+i))) ed = 0;
}
}
int a1 = 0, a2 = 0;
FOR(i, 1, N-1) if (!fr[i]) a1++;
FOR(i, 1, M-1) if (!fc[i]) a2++;
cout << max(0, sz(comps)-1) + min(a1, a2) + ed << nl;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int T = 1;
// cin >> T;
while(T--) {
solve();
}
return 0;
}
// read the question correctly (ll vs int)
// template by bqi343
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1e3 + 5;
const int MAXM = 1e3 + 5;
int fa[MAXN + MAXM];
inline void init(int n){ for(int i=1; i<=n; ++i) fa[i] = i;}
int find(int u){ return fa[u] == u? u: fa[u] = find(fa[u]);}
inline void connect(int u,int v){ fa[find(u)] = find(v);}
char s[MAXN][MAXM];
int main(void)
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=1; i<=n; ++i) scanf("%s",s[i]+1);
s[1][1] = s[1][m] = s[n][1] = s[n][m] = '#';
init(n+m);
for(int i=1; i<=n; ++i)
for(int j=1; j<=m; ++j) if(s[i][j] == '#')
connect(i, j+n);
static int vis[MAXN + MAXM];
int ans1 = 0, ans2 = 0;
for(int i=1; i<=n; ++i)
if(vis[find(i)] != 1)
vis[find(i)] = 1, ++ans1;
for(int i=1; i<=m; ++i)
if(vis[find(i+n)] != 2)
vis[find(i+n)] = 2, ++ans2;
printf("%d",min(ans1, ans2) - 1);
return 0;
} |
#include<bits/stdc++.h>
using ll = int_fast64_t;
using P = std::pair<ll,ll>;
using PP = std::pair<ll,P>;
#define REP(i,b,e) for(int i=b; i<e; i++)
#define PRINT(vec) {printf("[ ");for(auto &i:vec)printf("%ld ",i);puts("]");}
#define fi first
#define se second
const int MOD = 1e9+7;
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
int main(){
int n, k;
scanf("%d %d", &n, &k);
int a[n];
REP(i, 0, n) scanf("%d", &a[i]);
ll cnt[n] = {};
REP(i, 0, n) cnt[a[i]]++;
ll ans = 0, ct = k;
REP(i, 0, n){
ans += std::max(0l, ct-cnt[i]) * i;
ct = std::min(ct, cnt[i]);
}
printf("%ld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ll long long int
#define sd(x) scanf("%lld",&x)
#define sdi(x) scanf("%d",&x)
#define sdc(c) scanf("%c",&c)
#define inf 1000000000000000000ll
#define pll pair<ll,ll>
#define pii pair<int,int>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define bits(x) __builtin_popcountll(x)
#define ld long double
#define test() ll test; cin>>test; while(test--)
#define fi first
#define se second
#define all(x) x.begin(),x.end()
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
clock_t time_p = clock();
void time_taken()
{
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
inline ll GCD(ll x, ll y) {
if(x<y) swap(x,y);
if(x==0) return y;
if(y==0) return x;
return GCD(x%y,y);
}
ll phi(ll n) {
ll result = n;
for (ll i = 2; i * i <= n; i++) {
if(n % i == 0) {
while(n % i == 0)
n /= i;
result -= result / i;
}
}
if(n > 1)
result -= result / n;
return result;
}
ll power(ll x, ll n, ll mod) {
ll res = 1;
x %= mod;
while(n) {
if(n&1) {
res = ((res*x)%mod+mod)%mod;
}
x = ((x*x)%mod+mod)%mod;
n>>=1;
}
return res;
}
const int MOD = 1e9+7;
inline ll add(ll x, ll y, ll MOD) {
x %= MOD;
y %= MOD;
ll ans = (x+y)%MOD;
return ans;
}
inline ll mul(ll x,ll y, ll MOD) {
x %= MOD;
y %= MOD;
ll ans = ((x*y)%MOD+MOD)%MOD;
return ans;
}
int main() {
fastio;
ll N,K;
cin>>N>>K;
vector<ll> cnt(N+1,0);
ll x;
for(int i=0;i<N;i++) {
cin>>x;
cnt[x]++;
}
ll ans = 0;
ll kitne = K;
for(int i=0;i<N;i++) {
kitne = min(kitne,cnt[i]);
ans += kitne;
}
cout<<ans<<endl;
time_taken();
}
|
#include <iostream>
#include <climits>
using namespace std;
int main()
{
int N;
cin >> N;
int A[100];
int A_max = 0;
for (int i = 0; i < N; ++i) {
cin >> A[i];
A_max = max(A[i], A_max);
}
int max = 0;
int ans;
for (int k = 2; k <= A_max; ++k) {
int count = 0;
for (int i = 0; i < N; ++i) {
if (A[i] % k == 0)++count;
}
if (count > max) {
ans = k;
max = count;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll N;
cin >> N;
ll p[N];
for(ll i = 0; i < N; i++){
cin >> p[i];
}
ll ans = 0;
ll t[210000];
for(ll i = 0; i < N; i++){
t[p[i]]++;
while (t[ans])
{
ans++;
}
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
using Pll = pair<ll,ll>;
const ll INF = 1001001001;
void chmin(ll& a,ll b){if(a>b)a = b;}
int main(){
int n;
cin >> n;
vector<string> S(n);
set<string> sset;
rep(i,n){
cin >> S[i];
sset.insert(S[i]);
}
rep(i,n){
if(sset.count('!'+S[i])){
cout << S[i] << endl;
return 0;
}
}
cout << "satisfiable" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// template {{{
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
#define range(i, l, r) for (i64 i = (i64)(l); i < (i64)(r); (i) += 1)
#define rrange(i, l, r) for (i64 i = (i64)(r) - 1; i >= (i64)(l); (i) -= 1)
#define whole(f, x, ...) ([&](decltype((x)) container) { return (f)( begin(container), end(container), ## __VA_ARGS__); })(x)
#define rwhole(f, x, ...) ([&](decltype((x)) container) { return (f)( rbegin(container), rend(container), ## __VA_ARGS__); })(x)
#define debug(x) cerr << "(" << __LINE__ << ")" << #x << ": " << (x) << endl
constexpr i32 inf = 1001001001;
constexpr i64 infll = 1001001001001001001ll;
constexpr i32 dx[] = {0, -1, 1, 0, -1, 1, -1, 1};
constexpr i32 dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
struct IoSetup { IoSetup(i32 x = 15){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(x); cerr << fixed << setprecision(x); } } iosetup;
template <typename T = i64> T input() { T x; cin >> x; return x; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { range(i, 0, v.size()) { os << v[i] << (i + 1 != (int)v.size() ? " " : ""); } return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }
template <typename T> vector<T> make_vector(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_vector(size_t a, Ts... ts) { return vector<decltype(make_vector(ts...))>(a, make_vector(ts...)); }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// }}}
pair<int, int> diam_dfs(int v, int p, int dep, const vector<vector<int>> &G, vector<pair<int, int>> &ds) {
pair<int, int> res(dep, v);
for (auto &u : G[v]) {
if (u == p) continue;
chmax(res, diam_dfs(u, v, dep + 1, G, ds));
}
ds[v] = res;
return res;
}
void dfs(int v, int p, int &e, const vector<vector<int>> &G, const vector<pair<int, int>> &ds, vector< int > &ans) {
ans[v] = e;
vector< pair<int, int> > us;
for (auto &u : G[v]) {
if (u == p) continue;
us.emplace_back(ds[u].first, u);
}
whole(sort, us);
for (auto &[d, u] : us) {
e++;
dfs(u, v, e, G, ds, ans);
e++;
}
}
void solve() {
int n = input();
vector< vector< int > > G(n);
range(i, 1, n) {
int a = input() - 1, b = input() - 1;
G[a].emplace_back(b);
G[b].emplace_back(a);
}
vector< pair<int, int> > ds(n);
auto [d0, v0] = diam_dfs(0, -1, 0, G, ds);
diam_dfs(v0, -1, 0, G, ds);
int e = 1;
vector< int > ans(n);
dfs(v0, -1, e, G, ds, ans);
cout << ans << endl;
}
signed main() {
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
struct s{
int value;
int idx;
}a[65538];
int main()
{
int n;
cin>>n;
n=pow(2,n);
for (int i=1;i<=n;i++)
{
cin>>a[i].value;
a[i].idx=i;
}
while(n>2)
{
for (int i=1;i<=n;i+=2)
{
if (a[i].value<a[i+1].value){
a[i/2+1].value=a[i+1].value;
a[i/2+1].idx=a[i+1].idx;
}
else
{
a[i/2+1].value=a[i].value;
a[i/2+1].idx=a[i].idx;
}
}
n/=2;
}
if (a[1].value>a[2].value) cout<<a[2].idx<<endl;
else cout<<a[1].idx<<endl;
return 0;
} | //nik
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#define reg register
#define FOR(a, b, c) for (a = b; a <=c; a++)
#define rFOR(a, b, c) for (a = b;a >= c; a--)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SORT(x) sort(all(x))
#define all(x) x.begin(), x.end()
#define newl "\n"
#define alls(x) x.begin(), x.end(), x.begin()
#define umap(v, t1, t2) unordered_map<t1, t2> v
#define uset(v,t1) unordered_set<t1> v
#define IOF ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
using UL = unsigned long int;
using UI = unsigned int;
using ULL = unsigned long long int;
using LI = long int;
using LL = long long;
using LF = double;
using LLF = long double;
const int MOD1 = 1000000007;
/*const int MOD2 = */
/* Combinatorics Start */
int binoMax = 10000;
vector<LL> numInv(binoMax + 1), factNumInv(binoMax + 1), fact(binoMax + 1);
inline void generate_ncrp(LL p)
{ int i;numInv[0] = numInv[1] = 1;
FOR(i, 2, binoMax)
{ numInv[i] = numInv[p % i] * (p - p / i) % p;
} factNumInv[0] = factNumInv[1] = 1;
FOR(i, 2, binoMax)
{ factNumInv[i] = (numInv[i] * factNumInv[i - 1]) % p;
}
fact[0] = 1;
FOR(i, 1, binoMax)
{ fact[i] = (fact[i - 1] * i) % p;
}
}
LL ncrmodp(LL n, LL r, LL p)
{ LL ans = ((fact[n] * factNumInv[r]) % p * factNumInv[n - r]) % p;
return ans;
}
/* Combinatorics End */
LL expmodp(LL x, LL y, LL p)
{ LL res = 1;
while (y > 0)
{ if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}return res;
}
/* Matrix Operations Start */
struct Matrix{
int row,col;
vector<vector<LL> > a;
Matrix(int r,int c){
row=r;col=c;
a.resize(row,vector<LL>(col,0));
; }
static Matrix IDM(LL n){
Matrix res(n,n);
for(int i=0;i<n;i++)res.a[i][i]=1;
return res;
}
};
Matrix Matmult(Matrix A,Matrix B){
Matrix res(A.row,B.col);
LL i,j,k;
FOR(i,0,A.row-1){
FOR(j,0,B.col-1){
FOR(k,0,A.col-1){
res.a[i][j]=(res.a[i][j]+A.a[i][k]*B.a[k][j])%MOD1;
}
}
}
return res;
}
Matrix BinExp(Matrix X,LL n){
Matrix res=Matrix::IDM(X.row);
while(n>0){
if(n&1){
res=Matmult(X,res);
}
X=Matmult(X,X);
n>>=1;
}
return res;
}
/* Matrix Operations End */
bool check(int x){
int noct = x,z;
int ndec = x;
while(ndec>0){
z = ndec%10;
ndec/=10;
if(z==7)return false;
}
while(noct>0){
z = noct%8;
noct/=8;
if(z==7)return false;
}
return true;
}
int main()
{
IOF
int N,i,j,k,tp1,tp2;
cin>>N;
LL A[(1<<N)];
FOR(i,0,(1<<N)-1){
cin>>A[i];
}
vector<int> temp,temp1;
FOR(i,0,(1<<N)-1){
temp.push_back(i);
}
FOR(i,1,N-1){
FOR(j,0,(1<<(N-i))-1){
if(A[temp[2*j]]<A[temp[2*j+1]])temp1.push_back(temp[2*j+1]);
else temp1.push_back(temp[2*j]);
}
temp.clear();
temp.assign(all(temp1));
temp1.clear();
}
if(A[temp[0]]<A[temp[1]])cout<<temp[0]+1;
else cout<<temp[1]+1;
} |
#include <iostream>
#include <iomanip>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <cstdio>
#include <utility>
#include <string>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <numeric>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI=3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for(int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y) - 1) / (y))
#define MOD 1000000007ULL
#define IN(l, r, x) ((l) <= (x) && (x) < (r))
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
vs64 w(n), v(n);
rep (i, n)
{
cin >> w[i] >> v[i];
}
vs64 x(m);
rep (i, m) cin >> x[i];
rep (i, q)
{
int l, r;
cin >> l >> r;
--l;
vs64 y;
rep (j, m)
{
if (IN(l, r, j)) continue;
y.emplace_back(x[j]);
}
sort(y.begin(), y.end());
s64 ans = 0;
vector< bool > used(n, false);
for (const auto& X : y)
{
int idx = -1;
rep (j, n)
{
if (used[j]) continue;
if (w[j] <= X && !used[j])
{
if (idx < 0)
{
idx = j;
}
else if (v[idx] < v[j] || (v[idx] == v[j] && w[idx] < w[j]))
{
idx = j;
}
}
}
if (idx >= 0)
{
ans += v[idx];
used[idx] = true;
}
}
cout << ans << "\n";
}
return 0;
}
| #include<iostream>
#include<algorithm>
#include<ctime>
#include<vector>
#include<string>
#include<cmath>
#include<map>
#include<iomanip>
#include<numeric>
#include<queue>
#include<deque>
#include<cfloat>
#include<functional>
#include<tuple>
#include<math.h>
#include<bitset>
#include<stack>
#include<set>
#include<random>
#include<stdlib.h>
#define rip(i,n) for(int i=0;i<n;i++)
#define Rip(i,n) for(int i=1;i<=n;i++)
#define RIP(i,a,b) for(int i=a;i<b;i++)
#define all(V) V.begin(),V.end()
#define sec setprecision;
#define _CRT_SECURE_NO_WARNINGS
#pragma target("avx")
#pragma optimize("O3")
#pragma optimize("unroll-loops");
constexpr double eps = 1e-9;
constexpr double pi = 3.141592653589793238462643383279;
using namespace std;
using ll = long long;
using ld = long double;
using Pa = pair<ll,ll>;
const ll MOD = 998244353;
ll gcd(ll a, ll b)
{
if (a % b == 0) return(b);
else return(gcd(b, a % b));
}
ll lcm(ll a, ll b)
{
return a * b / gcd(a, b);
}
ll modpow(ll x, ll n, ll mod) {
x %= mod;
if (n == 0)
return 1;
if (n % 2 == 0)
return (modpow((x * x) % mod, n / 2, mod) % mod);
else
return (x * modpow(x, n - 1, mod)) % mod;
}
bool is_prime(int n) {//素数判定
bool ans = true;
for (int i = 2; i <= sqrt(n); i++)if (n % i == 0)ans = false;
return ans;
}
void solveA() {
int n; cin >> n;
vector<ll>a(n);
vector<ll>b(n);
rip(i, n)cin >> a[i];
rip(i, n)cin >> b[i];
vector<Pa>bmax(n);
vector<ll>amax(n);
ll bmaxx = 0;
rip(i, n) {
bmaxx = max(bmaxx, b[i]);
bmax[i].first = bmaxx;
if (bmaxx == b[i]) {
bmax[i].second = i;
}
}
ll amaxx = 0;
rip(i, n) {
amaxx = max(amaxx, a[i]);
amax[i] = amaxx;
}
vector<ll>ans(n);
ans[0] = a[0] * b[0];
for (int i = 1; i < n; i++) {
ll maxx = 0;
maxx = b[i] * amax[i];
ans[i] = max(ans[i - 1], maxx);
}
rip(i, n)cout << ans[i] << endl;
}
void solveB() {
int N, K;
cin >> N >> K;
vector<ll>a(N);
rip(i, N)cin >> a[i];
sort(all(a));
}
void solveC() {
}
int main() {
solveA();
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b;
cin >> a >> b;
cout << max(0, (2 * (a) + 100) - b) << '\n';
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int a, b, c, mn;
cin >> a >> b >> c;
mn = min({a,b,c});
cout << a+b+c-mn << endl;
}
|
#include<bits/stdc++.h>
// #include<iostream>
// #include<algorithm>
// #include<vector>
// #include<set>
// #include<queue>
// #include<map>
using namespace std;
#define ll long long
#define ld long double
#define For(n) for(ll i=0;i<n;i++)
#define Forr(a,b) for(ll i=a;i<b;i++)
#define sortt(x) sort(x.begin(),x.end())
#define rsortt(x) sort(x.rbegin(),x.rend())
#define condsortt(x) sort(x.begin(),x.end(),sortBy)
#define MOD 1000000007
#define en "\n"
#define F first
#define S second
#define input(x,n) for(ll i=0;i<n;i++) cin>>x[i]
#define v(A,n) vector<ll> A(n)
#define vi(x) vector<ll> x
#define pb(x) push_back(x)
#define MP make_pair
#define PI 3.14159265
void print(vector<ll> vec)
{
for(auto itr:vec)
cout<<itr<<" ";
cout<<en;
}
void solve()
{
ll a,b,c;
cin>>a>>b>>c;
if(a==b)
cout<<c;
else if(b==c)
cout<<a;
else if(a==c)
cout<<b;
else
cout<<0;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t=1;
// cin>>t;
for(ll i=1;i<=t;i++)
{
// cout<<"Case #"<<i<<": ";
solve();
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
using namespace std::chrono;
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repn(i,a,b) for(int i=a;i>=b;i--)
#define ff first
#define ss second
#define lb lower_bound
#define ub upper_bound
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define vvi vector<vector<int>>
#define mi map<int,int>
#define mii map<pii,int>
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define sz(x) (int)x.size()
#define all(v) (v).begin(), (v).end()
#define ret(x) return cout<<x,0;
#define rety return cout<<"YES",0;
#define retn return cout<<"NO",0;
#define fl fflush(stdout)
#define hell 1000000007
#define hell2 998244353
#define pi 3.14159265358979323846
int fexp(int a, int b,int m){int ans = 1;while(b){if(b&1)ans=ans*a%m; b/=2;a=a*a%m;}return ans;}
int inverse(int a, int p){return fexp(a, p-2,p);}
int fac[300005]; //fac[0]=0;fac[1]=1;rep(i,2,300005)fac[i]=(fac[i-1]+fac[i-2])%hell;
int ncr(int n, int r,int p) {
if (r==0) return 1;
return (fac[n]*inverse(fac[r],p)%p*inverse(fac[n-r],p)%p)%p;
}
void code_hunter(){
int n,m;cin>>n>>m;
if((min(n,m)+3)>max(n,m))
cout<<"Yes";
else
cout<<"No";
}
signed main(){
IOS;
int t=1;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r" , stdin);
freopen("output.txt", "w", stdout);
#endif
// cin>>t;
while(t--){
code_hunter();
// cout<<"\n";
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
int ans[N];
vector <int> g[N];
struct node{
int step;
int num;
}p;
int a[N];
int b[N];
int main()
{
int x,y,z;
cin>>x>>y>>z;
if(x==y)cout<<z;
else if(x==z) cout<<y;
else if(y==z) cout<<x;
else cout<<0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
char S, T; cin >> S >> T;
if(S == 'Y'){
char t = toupper(T);
cout << t << endl;
} else {
cout << T << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
char s[maxn];
int n,sum[maxn][30];
long long ans;
int book;
char ch;
int main() {
scanf("%s",s+1);
n=strlen(s+1);
book=n+1; ch='a'-1;
for(int i=1;i<=n;i++) {
for(int j=1;j<=26;j++) sum[i][j]=sum[i-1][j];
sum[i][(s[i]-'a'+1)]++;
}
for(int i=n-2;i>=1;i--) {
if(s[i]==s[i+1] && s[i+1]!=s[i+2]) {
if(ch==s[i]) ans+=(book-1)-(i+1);
else ans+=n-(i+1);
ans-=sum[(book-1)][(s[i]-'a'+1)]-sum[i+1][(s[i]-'a'+1)];
book=i,ch=s[i];
}
}
printf("%lld",ans);
return 0;
} | #include <bits/stdc++.h>
#include <variant>
#define rep2(i,k,n) for(i64 i=(i64)(k);i<(i64)(n);i++)
#define rep(i,n) rep2(i,0,n)
#define all(x) begin(x),end(x)
#ifdef ENV_LOCAL
#define dump if (1) cerr
#else
#define dump if (0) cerr
#endif
using namespace std;
using namespace std::string_literals;
using i32 = int32_t;
using i64 = int64_t;
using f64 = double;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
pair<i32,bool> solve(const vector<vi32>& g, i32 i) {
bool flip = true;
vector<pair<i32,bool>> children;
for (auto&& to : g[i]) {
auto [sc, fl] = solve(g, to);
if (fl) flip = !flip;
children.emplace_back(-sc, fl);
}
dump<<i<<endl;
sort(all(children), [](auto&& lhs, auto&& rhs) {
auto [ls, lf] = lhs;
auto [rs, rf] = rhs;
if (ls >= 0 && rs < 0) return true;
else if (ls < 0 && rs >= 0) return false;
if (ls >= 0) {
if (lf == rf) {
return ls > rs;
} else {
return rf;
}
} else {
if (lf == rf) {
return ls > rs;
} else {
return lf;
}
}
});
i32 score = 1;
bool current = false;
for (auto&& [sc, fl] : children) {
dump<<sc<<" "<<fl<<endl;
if (current) {
score += sc;
} else {
score -= sc;
}
if (fl) current = !current;
}
return make_pair(score, flip);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
i32 n;
cin>>n;
vector<vi32> g(n);
rep2(i,1,n) {
i32 p;
cin>>p;
--p;
g[p].push_back(i);
}
auto [score, flip] = solve(g, 0);
auto ans = (n + score) / 2;
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 998244353;//1000000007;
constexpr long long INF = 1000000000 + 100;
constexpr long long LINF = 1000000000000000000 + 100;
constexpr double EPS = 1e-9;
#define all(v) v.begin(), v.end()
#define rep(i, n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
#define rrep(i, n) for(int i=(n); i>=0; i--)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
//dp[i][j]:=i番目まで見て、j=1ならtrue, 0ならfalseの数
ll dp[66][2];
int main(){
int N; cin >> N;
vector<string> S(N); rep(i, N)cin >> S[i];
dp[0][0] = dp[0][1] = 1;
rep(i, N){
rep(j, 2){
if(S[i]=="AND"){
rep(k, 2){
dp[i+1][j and k] += dp[i][j];
}
}
else{
rep(k, 2){
dp[i+1][j or k] += dp[i][j];
}
}
}
}
cout << dp[N][1] << ln;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define FastIO cin.sync_with_stdio(false), cin.tie(nullptr)
#define pb push_back
#define fs first
#define sc second
#define mkp make_pair
#define endl '\n'
// IO
#define multitest signed __T; cin >> __T; while(__T--)
template<typename T>
void _read(T& t);
template<typename T>
void _read(vector<T>& v);
template<typename T1, typename T2>
void _read(pair<T1, T2>& p);
template<typename T>
void _read(T& t) { cin >> t; }
template<typename T>
void _read(vector<T>& v) { for (unsigned _i = 0; _i < v.size(); _i++)_read(v[_i]); }
template<typename T1, typename T2>
void _read(pair<T1, T2>& p) { _read(p.first); _read(p.second); }
void _masterread() {}
template<typename T, typename... V>
void _masterread(T& t, V& ... v) { _read(t); _masterread(v...); }
#define re(...)_masterread(__VA_ARGS__)
template<typename T>
void _print(T t);
template<typename T>
void _print(vector<T>& v);
template<typename T1, typename T2>
void _print(pair<T1, T2>& p);
template<typename T>
void _print(T t) { cout << t; }
template<typename T>
void _print(vector<T>& v) { for (unsigned _i = 0; _i < v.size(); _i++)_print(v[_i]), cout << (_i == v.size() - 1 ? "" : " "); }
template<typename T1, typename T2>
void _print(pair<T1, T2>& p) { _print(p.first); cout << " "; _print(p.second); }
void _masterprint() { cout << endl; }
template<typename T, typename... V>
void _masterprint(T t, V... v) { _print(t); if (sizeof...(v))cout << " "; _masterprint(v...); }
#define pr(...)_masterprint(__VA_ARGS__)
// DEBUG
// colored output???
template <typename T> // start forward declaration
void _debug(T t);
template<typename T1, typename T2>
void _debug(pair<T1, T2> p);
template<typename T>
void _debug(vector<T>v);
template <typename T> // end forward declaration
void _debug(T t) { cerr << t; }
template<typename T1, typename T2>
void _debug(pair<T1, T2> p) { cerr << "{"; _debug(p.first); cerr << ", "; _debug(p.second); cerr << "}"; }
template<typename T>
void _debug(vector<T>v) { cerr << "("; for (unsigned _i = 0; _i < v.size(); _i++)_debug(v[_i]), cerr << (_i == v.size() - 1 ? "" : ", "); cerr << ")"; }
void _masterdebug() { cerr << "]\n"; }
template<typename T, typename... V>
void _masterdebug(T t, V... v) { _debug(t); if (sizeof...(v))cerr << ", "; _masterdebug(v...); }
#define debug(...) cerr<<"["<<#__VA_ARGS__<<"] = [";_masterdebug(__VA_ARGS__)
#define int long long
void solve() {
string s;
cin >> s;
char c1 = s[0], c2 = s[1], c3 = s[2];
if (c1 == c2 && c2 == c3) {
pr("Won");
}
else
pr("Lost");
}
signed main() {
FastIO;
/*int t;
cin >> t;
while (t--)*/
solve();
} |
#include<bits/stdc++.h>
typedef long long LL;
typedef long double dl;
#define opt operator
#define pb push_back
#define pii std::pair<LL,LL>
const LL maxn=1e6+9,mod=998244353,inf=1e18;
LL Read(){
LL x(0),f(1); char c=getchar();
while(c<'0' || c>'9'){
if(c=='-') f=-1; c=getchar();
}
while(c>='0' && c<='9'){
x=(x<<3ll)+(x<<1ll)+c-'0'; c=getchar();
}return x*f;
}
void Chkmin(LL &x,LL y){
if(y<x) x=y;
}
void Chkmax(LL &x,LL y){
if(y>x) x=y;
}
LL add(LL x,LL y){
return x+=y,x>=mod?x-mod:x;
}
LL dec(LL x,LL y){
return x-=y,x<0?x+mod:x;
}
LL mul(LL x,LL y){
return 1ll*x*y%mod;
}
LL Pow(LL base,LL b){
LL ret(1); while(b){
if(b&1) ret=mul(ret,base); base=mul(base,base); b>>=1;
}return ret;
}
LL n;
dl a[maxn],suf[maxn];
int main(){
n=Read();
for(LL i=1;i<=n;++i){
a[i]=Read();
}
std::sort(a+1,a+1+n);
dl ret(1000000000000000000.0);
// printf("%.10Lf\n",ret);
for(LL i=n;i>=1;--i) suf[i]=suf[i+1]+a[i];
for(LL i=1;i<=n;++i){
dl x(1.0*a[i]/2.0);
dl sum(1.0*i*x+suf[i+1]-1.0*(n-i)*x);
ret=std::min(ret,sum);
}
ret/=1.0*n;
printf("%.10Lf\n",ret);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main() {
long n,k,a;
cin>>n;
vector<long> vec(n);
for(long i=0; i<n; i++){
cin>>vec.at(i);
}
sort(vec.begin(),vec.end());
k=n/2;
a=vec.at(k);
double ans=0;
double b=a;
for(long i=0; i<n; i++){
ans+=vec.at(i)-min(vec.at(i),a);
}
ans=ans/n;
ans=ans+b/2;
cout << fixed << setprecision(10);
cout<<ans;
} |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define N 10100
#define MOD 998244353
#define ll long long
#define rep(i, n) for(int i = 0; i < n; ++i)
#define rep2(i, a, b) for(int i = a; i <= b; ++i)
#define rep3(i, a, b) for(int i = a; i >= b; --i)
#define eb emplace_back
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define vi vector<int>
#define pii pair<int,int>
#define pll pair<ll,ll>
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
}
} setup_io;
int main() {
int n;
int x, s;
int a[100];
ll dp[101][N];
ll k[110];
ll y, z;
cin >> n;
rep(i, n)cin >> a[i];
rep(i, n + 1) {
rep(j, N)dp[i][j] = 0;
}
s = 0;
dp[0][0] = 1;
rep(i, n) {
s += a[i];
rep3(ii, i, 0) {
rep3(j, 100*(i+1), a[i])dp[ii + 1][j] = (dp[ii + 1][j] + dp[ii][j - a[i]]) % MOD;
}
}
if (s % 2 == 1) {
cout << 0 << endl;
return 0;
}
s /= 2;
k[0] = 1;
rep2(i, 1, 100) {
y = (ll)i;
k[i] = (k[i - 1] * y) % MOD;
}
ll ans = 0;
rep(i, n + 1) {
y = dp[i][s];
y = (y*k[i]) % MOD;
y = (y*k[n - i]) % MOD;
ans = (ans + y) % MOD;
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
#define int long long
using namespace std;
const int mo=998244353;
int n,sum,ans;
int a[110],dp[110][110][10010],p[110];
signed main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
sum+=a[i];
}
dp[0][0][0]=1;
for(int i=0;i<=n;i++)
for(int j=0;j<=i;j++)
for(int k=0;k<=n*100;k++){
dp[i+1][j][k]=(dp[i+1][j][k]+dp[i][j][k])%mo;
dp[i+1][j+1][k+a[i+1]]=(dp[i+1][j+1][k+a[i+1]]+dp[i][j][k])%mo;
}
p[0]=1;
for(int i=1;i<=n;i++)
p[i]=p[i-1]*i%mo;
for(int i=0;i<=n;i++)
ans=(ans+dp[n][i][sum/2]*p[i]%mo*p[n-i])%mo;
cout<<(sum%2 ? 0:ans)<<endl;
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <string>
#include <map>
#include <set>
#include <stack>
#include <tuple>
#include <deque>
#include <array>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cassert>
#include <chrono>
#include <random>
#include <limits>
#include <iterator>
#include <functional>
#include <sstream>
#include <fstream>
#include <complex>
#include <cstring>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using ll = long long;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template<class T>
inline bool chmax(T& x, T y){
if(x < y){
x = y;
return true;
}
return false;
}
template<class T>
inline bool chmin(T& x, T y){
if(x > y){
x = y;
return true;
}
return false;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M, A;
cin >> N >> M;
vector<vector<int>> pos(N + 1);
for(int i = 0; i <= N; ++i) pos[i].emplace_back(-1);
for(int i = 0; i < N; ++i){
cin >> A;
pos[A].emplace_back(i);
}
for(int i = 0; i <= N; ++i) pos[i].emplace_back(N);
for(int i = 0; i <= N; ++i){
for(int j = 0; j + 1 < (int)pos[i].size(); ++j){
if(pos[i][j + 1] - pos[i][j] > M){
cout << i << '\n';
return 0;
}
}
}
return 0;
} | #include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
using ll = long long;
map<ll, ll> freq;
set<ll> mex;
int n, m;
int main(){
ios::sync_with_stdio(0); cin.tie(0);
cin >> n >> m;
for(ll i = 0; i <= n; ++i)
mex.insert(i);
vector<ll> vec(n);
for(auto & el: vec)
cin >> el;
for(int i = 0; i < m; ++i){
freq[vec[i]]++;
mex.erase(vec[i]);
}
ll res = *mex.begin();
for(int i = m; i < n; ++i){
freq[vec[i - m]]--;
if(freq[vec[i - m]] == 0 ){
mex.insert(vec[i - m]);
freq.erase(vec[i - m]);
}
freq[vec[i]]++;
if(freq[vec[i]] == 1)
mex.erase(vec[i]);
res = min(res, * mex.begin());
}
cout << res;
}
|
#include <iostream>
#include <vector>
#include <array>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <string>
#include <sstream>
#include <algorithm>
#include <random>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <cassert>
#include <climits>
#include <bitset>
#include <functional>
#include <iomanip>
#include <random>
#define FOR_LT(i, beg, end) for (decltype(end) i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (decltype(end) i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (decltype(beg) i = beg; end <= i; i--)
#define REP(n) for (decltype(n) repeat_index = 0; repeat_index < n; repeat_index++)
using namespace std;
template<int64_t M = 1000000007>
class ModInt {
public:
ModInt() : val_(0) {};
ModInt(int64_t val) {
this->val_ = val;
this->val_ %= M;
while (this->val_ >= M) this->val_ -= M;
while (this->val_ < 0) this->val_ += M;
}
operator int64_t() const {
return this->val_;
}
ModInt& operator += (int64_t val) {
this->val_ += val;
this->val_ %= M;
while (this->val_ >= M) this->val_ -= M;
while (this->val_ < 0) this->val_ += M;
return *this;
}
ModInt& operator -= (int64_t val) {
this->val_ -= val;
this->val_ %= M;
while (this->val_ >= M) this->val_ -= M;
while (this->val_ < 0) this->val_ += M;
return *this;
}
ModInt& operator *= (int64_t val) {
this->val_ *= val;
this->val_ %= M;
return *this;
}
ModInt& operator /= (int64_t val) {
ModInt v = ModInt::pow(val, M - 2);
*this *= v;
return *this;
}
ModInt operator + (int64_t v) const {
ModInt ret = *this;
return (ret += v);
}
ModInt operator - (int64_t v) const {
ModInt ret = *this;
return (ret -= v);
}
ModInt operator * (int64_t v) const {
ModInt ret = *this;
return (ret *= v);
}
ModInt operator / (int64_t v) const {
ModInt ret = *this;
return (ret /= v);
}
static ModInt pow(ModInt n, int64_t m) {
if (m == 0) {
ModInt ret(1);
return ret;
}
if (m == 1) {
return n;
}
ModInt v = pow(n, m / 2);
ModInt ret = v * v;
if (m & 1) {
ret *= n;
}
return ret;
}
ostream& operator << (ostream& out) {
out << this->val_;
return out;
}
private:
int64_t val_;
};
bool gmap[2001][2001];
int nmap[2001][2001];
ModInt <> val(int n, int m)
{
ModInt<> s = 2;
auto a = ModInt<>::pow(2, n);
auto d = ModInt<>::pow(2, n - m);
//cout << n << " " << m << endl;
return a - d;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(20);
int h, w; cin >> h >> w;
int g = 0;
FOR_LT(i, 0, h) {
string s; cin >> s;
FOR_LT(j, 0, w) {
if (s[j] == '#') {
gmap[i][j] = true;
g++;
}
else {
nmap[i][j] = 1;
}
}
}
FOR_LT(i, 0, h) {
int j = 0;
int s = -1;
while (j < w) {
while (j < w && gmap[i][j]) j++;
s = j;
while (j < w && !gmap[i][j]) j++;
if (s != -1) {
int c = (j - s);
//cout << c << endl;
FOR_LT(k, s, j) {
nmap[i][k] += c - 1;
//cout << i << " " << k << " " << nmap[i][k] << endl;
}
}
s = -1;
}
}
FOR_LT(j, 0, w) {
int i = 0;
int s = -1;
while (i < h) {
while (i < h && gmap[i][j]) i++;
s = i;
while (i < h && !gmap[i][j]) i++;
if (s != -1) {
int c = (i - s);
FOR_LT(k, s, i) {
nmap[k][j] += c - 1;
}
}
s = -1;
}
}
ModInt<> ans = 0;
FOR_LT(i, 0, h) {
FOR_LT(j, 0, w) {
ans += val(h * w - g, nmap[i][j]);
}
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod ll(1e9+7)
#define inv ll(500000004)
ll exp(ll a,ll b)
{
if(b==0)
return 1;
if(b%2==0){
return exp(a*a%mod,b/2);
}
return a*exp(a*a%mod,(b-1)/2)%mod;
}
int main()
{
int h,w;
cin>>h>>w;
int cnt=0;
vector<string>arr(h);
for(int i=0; i<h; i++)
cin>>arr[i];
vector<vector<int> >mtr1(h,vector<int>(w)),mtr2(h,vector<int>(w));
for(int i=0; i<h; i++){
int len=0;
for(int j=0; j<w; j++){
if(arr[i][j]=='#'){
len=0;
}
else{
len++;
cnt++;
mtr1[i][j]=len;
}
}
}
for(int i=0; i<h; i++){
int num=0;
for(int j=w-1; j>=0; j--){
if(mtr1[i][j]>0){
num=max(num,mtr1[i][j]);
mtr1[i][j]=num;
}
else
num=0;
}
}
for(int i=0; i<w; i++){
int len=0;
for(int j=0; j<h; j++){
if(arr[j][i]=='#')
len=0;
else{
len++;
mtr2[j][i]=len;
}
}
}
for(int i=0; i<w; i++){
int num=0;
for(int j=h-1; j>=0; j--){
if(mtr2[j][i]>0){
num=max(num,mtr2[j][i]);
mtr2[j][i]=num;
}
else
num=0;
}
}
ll ans=0;
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
if(arr[i][j]=='.'){
ll num1=mtr1[i][j]+mtr2[i][j]-1;
ll num2=cnt-num1;
ans=(ans+(exp(2,num1)-1+mod)*exp(2,num2)%mod)%mod;
}
}
}
cout<<ans;
return 0;
} |
/*
_/_/_/_/ _/_/_/_/_/ _/_/_/
_/ _/ _/ _/ _/
_/ _/ _/ _/ _/
_/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/_/
_/_/_/_/ _/_/ _/_/_/_/_/
_/_/_/_/ _/ _/ _/ _/
_/ _/ _/ _/ _/_/ _/_/
_/ _/ _/_/ _/ _/_/ _/
_/ _/ _/ _/ _/ _/
_/ _/ _/_/ _/ _/
_/ _/ _/ _/ _/ _/
_/_/_/_/ _/ _/ _/ _/
_/_/_/_/_/ _/_/_/_/_/ _/_/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/ _/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/_/_/_/_/ _/_/_/_/_/
_/_/_/_/_/ _/_/_/_/_/ _/_/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/ _/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/_/_/_/_/ _/_/_/_/_/
*/
#include <cassert>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>
#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <iomanip>
#include <limits>
#include <numeric>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template<class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v)
is >> x;
return is;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i)
os << ' ' << v[i];
}
return os;
}
const int P = 998244353;
int norm(int x) { return x >= P ? (x - P) : x; }
void add(int &x, int y) { if ((x += y) >= P) x -= P; }
void sub(int &x, int y) { if ((x -= y) < 0) x += P; }
void exGcd(int a, int b, int &x, int &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exGcd(b, a % b, y, x);
y -= a / b * x;
}
int inv(int a) {
int x, y;
exGcd(a, P, x, y);
return norm(x + P);
}
const int N = 3010, L = 15;
int A[L], B[L];
int f[L][N];
int q[N];
int main() {
#ifdef ELEGIA
freopen("test.in", "r", stdin);
int nol_cl = clock();
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
n -= k;
for (int i = 1; i != L; ++i) {
B[i] = (1 << i) - 1;
A[i] = A[i - 1] + B[i];
}
{
q[0] = 1;
int C = 0;
for (int i = 0; C <= n; ++i, C = A[i] + k * ((1 << i) - 1)) {
if (i)
for (int j = B[i]; j <= n - C; ++j) add(q[j], q[j - B[i]]);
if (i & 1)
for (int j = C; j <= n; ++j) sub(f[0][j], q[j - C]);
else for (int j = C; j <= n; ++j) add(f[0][j], q[j - C]);
}
}
for (int i = 0; i <= n; ++i) {
for (int j = 1; A[j] <= i; ++j)
sub(f[0][i], f[j][i - A[j]]);
int j;
for (j = 1; B[j] <= i; ++j)
f[j][i] = norm(P - f[j - 1][i] + f[j][i - B[j]]);
for (; B[j] <= n; ++j)
f[j][i] = norm(P - f[j - 1][i]);
}
cout << f[0][n] << '\n';
#ifdef ELEGIA
LOG("Time: %dms\n", int ((clock()
-nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
return 0;
}
| //#include<cstdio>
//#include<cassert>
//#include<iostream>
//#include<cstring>
//#include<algorithm>
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define MAX ((int)2e9 + 5)
#define MAXP ((int)2e5)
#define MAXL ((ll)1e18 + 5)
#define MAX_X ((ll)1e5 + 2)
#define pi acos(-1)
#define M ((int)1e6 + 7)
#define MOD ((int)998244353 + 0)
//#define MOD1 ((int)998244353 + 0)
#define BAS ((int)1e6 + 3)
#define BAS1 ((int)2e5 + 3)
#define NN ((int)1e5 + 5)
#define N ((int)3e3 + 5)
#define eps (1e-8)
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define logn 10
#define endl "\n"
#define mp make_pair
#define BUCK 105
#define LEF (idx<<1)
#define RIG ((idx<<1)|1)
//#define int ll
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
/*fast io
ios_base::sync_with_stdio(false);
cin.tie(NULL);
*/
typedef tree < int, null_type, less < int >, rb_tree_tag, tree_order_statistics_node_update > o_set;
typedef tree < pair < int, int >, null_type, less < pair < int, int > >, rb_tree_tag, tree_order_statistics_node_update > o_setp;
/// o_set s;
/// s.order_of_key(k) : Number of items strictly smaller than k .
/// *(s.find_by_order(k)) : K-th element in a set (counting from zero).
int dpp[N][N] , sum[N][N];
int call(int last , int rem);
int fun(int last , int rem)
{
last = min(last , rem);
if(rem < 0) return 0;
if(sum[last][rem] != -1) return sum[last][rem];
int ans = call(last,rem) + fun(last + 2 , rem-1);
if(ans >= MOD) ans -= MOD;
return sum[last][rem] = ans;
}
int call(int last , int rem)
{
last = min(last , rem);
if(rem < 0) return 0;
if(rem == 0) return 1;
if(dpp[last][rem] != -1) return dpp[last][rem];
int ans = fun(2,rem-1) - fun(last+last+2,rem-last-1);
if(ans < 0) ans += MOD;
return dpp[last][rem] = ans;
}
int main()
{
fastio;
int n , k;
cin>>n>>k;
memset(dpp,-1,sizeof dpp);
memset(sum,-1,sizeof sum);
cout<<call(k,n-k)<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long int
#define mod 1000000007
#define string_mod 2549536629329_base_255
#define pb push_back
#define F first
#define S second
#define ff first
#define endl "\n"
#define ss second
#define all(v) v.begin(), v.end()
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int power(int x, unsigned int y, int p)
{
int res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res % p;
}
int lcm(int a, int b)
{
return a / __gcd(a, b) * b;
}
void solve()
{
int n, k;
cin >> n >> k;
int a[n];
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
int ans = 0;
int f = 0;
for (int i = 0; i < n; i++) {
if (k <= 0)
break;
if (mp[i] / k == 0) {
ans += (k - mp[i]) * i;
k -= (k - mp[i]);
}
}
cout << ans << endl;
}
int32_t main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc;
tc = 1;
#ifndef ONLINE_JUDGE
freopen("inputf.txt", "r", stdin);
freopen("outputf.txt", "w", stdout);
#endif
// cin >> tc;
while (tc--)
{
solve();
}
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, m, n) for (ll i = m; i < (n); i++)
#define RFOR(i, m, n) for (ll i = (m - 1); i >= 0; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, n, 0)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
//#define print(ele) cout << (ele) << "\n"
#define print10(ele) cout << fixed << setprecision(10) << (ele) << "\n"
using namespace std;
typedef long long ll;
typedef vector<int> ivec;
typedef vector<string> svec;
typedef vector<ll> lvec;
const int mod = 1e9 + 7;
const ll INF = 1000000000000000000LL;
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
cout << head;
if (sizeof...(tail) != 0) cout << " ";
print(forward<Tail>(tail)...);
}
int main() {
int n, k;
cin >> n >> k;
ll ans = n;
REP(i, k) {
if (ans % 200) {
string tmp = to_string(ans) + "200";
ans = stoll(tmp);
} else {
ans /= 200;
}
}
print(ans);
return 0;
} |
/*
Bismillahir rahmanir rahim
Name : Mir Rifat
Bsmrstu.
*/
#include <bits/stdc++.h>
using namespace std ;
typedef long long ll;
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define T int t,q; cin >> t; for(q=1;q<=t;q++)
#define Forn(i,n) for(int i=0;i<n;i++)
#define ForN(i,n) int i;for(i=n-1;n>=0;i--)
#define Sort(s) sort(s.begin(),s.end())
#define ff first
#define ss second
#define pb push_back
#define mem(a) memset(a,0,sizeof a)
#define memn(a) memset(a,-1,sizeof a)
#define pi acos(-1
#define PI 3.1415926535
#define Int(f) cin>>f;
#define Pnt(k) cout<<k<<endl;
#define yy() cout<< "YES"<<endl;
#define nn() cout<< "NO"<<endl;
void solve(){
string s;cin>>s;
cin>>s;
ll ans=0;
for(int i=0;i<9;i++){
if(s[i]=='Z' && s[i+1]=='O' && s[i+2]=='N' && s[i+3]=='e'){
ans++;
}
}
cout<<ans<<endl;
}
int main(){
//int t;cin>>t;while(t--)
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define clr(a) memset(a, 0, sizeof(a))
#define full(a) memset(a, 0x3f, sizeof(a))
#define mset(a, b) memset(a, b, sizeof(a))
#define cpy(a,b) memcpy(a, b, sizeof(a))
#define fornext(x, i) for(signed i = hd[x], y = ver[i]; i; i = nxt[i], y = ver[i])
#define Rep(i, a, b) for(signed i = (signed)(a); i <= (signed)(b); ++i)
#define dRep(i, a, b) for(signed i = (signed)(a); i >= (signed)(b); --i)
#define IOset(a) freopen(a".in", "r", stdin), freopen(a".out", "w", stdout);
#define pb push_back
#define It iterator
#define endl '\n'
#define un unsigned
#define int ll
#define ll long long
#define db double
#define rept cerr<<1.0*clock()/CLOCKS_PER_SEC<<endl;
#define dbg cout<<"c "
#define dbug(x) cerr << #x " = " << (x) << endl
template<typename _T> inline void _prt(_T _d) { cerr << _d << ' '; }
template <typename _T, typename ...Args> inline void _prt(_T _d, Args ..._a) { _prt(_d), _prt(_a...); }
template <typename _T, typename ...Args> inline void prt(_T _d, Args ..._a) { _prt(_d), _prt(_a...), cerr<<endl; }
template <typename _T, typename ...Args> inline void prt(_T _d) { cerr << _d <<endl; }
template<typename _T> inline void rd(_T &_d) {
signed _f; char _c; _f = 1,_d = 0; while (_c = getchar(), !isdigit(_c)) if(_c=='-') _f=-1;
while (isdigit(_c)) _d = _d * 10 + _c - '0', _c = getchar();
_d=_f*_d;
}
template <typename _T, typename ...Args> inline void rd(_T &_d, Args &..._a) { rd(_d); rd(_a...); }
// const int N=
signed main() {
int n;
rd(n);
--n;
printf("1155 ");
Rep(i,1,5000) {
if(!n) break;
if(i%3==0||i%5==0||i%7==0||i%11==0) --n,printf("%d ",i*2);
}
return 0;
}
|
//*
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
//*/
#include <bits/stdc++.h>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
#define DEBUG(x) cerr<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cerr<<#v<<":";for(int i=0;i<v.size();i++) cerr<<" "<<v[i]; cerr<<endl;
#define DEBUG_MAT(v) cerr<<#v<<endl;for(int i=0;i<v.size();i++){for(int j=0;j<v[i].size();j++) {cerr<<v[i][j]<<" ";}cerr<<endl;}
typedef long long ll;
// #define int ll
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
template<class S, class T> pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first + t.first, s.second + t.second); }
template<class S, class T> pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first - t.first, s.second - t.second); }
template<class S, class T> ostream& operator<<(ostream& os, pair<S, T> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
#define X first
#define Y second
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(int)(n);i>0;i--)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(),c.end()
void YES(bool t=true) {cout<<(t?"YES":"NO")<<endl;}
void Yes(bool t=true) {cout<<(t?"Yes":"No")<<endl;}
void yes(bool t=true) {cout<<(t?"yes":"no")<<endl;}
void NO(bool t=true) {cout<<(t?"NO":"YES")<<endl;}
void No(bool t=true) {cout<<(t?"No":"Yes")<<endl;}
void no(bool t=true) {cout<<(t?"no":"yes")<<endl;}
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a = b; return 1; } return 0; }
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = (ll)1e18 + 1;
const long double pi = 3.1415926535897932384626433832795028841971L;
int popcount(ll t) { return __builtin_popcountll(t); }
// int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
// int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
vi dx = {0, 1, 0, -1}, dy = {-1, 0, 1, 0};
// vi dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(25);
}
} setup_io;
// const ll MOD = 1000000007;
const ll MOD = 998244353;
// #define mp make_pair
//#define endl '\n'
signed main() {
int n;
cin >> n;
vector<double> dp(n + 1);
dp[n] = 0;
for (int i = n - 1; i >= 0; i--) {
dp[i] = 1 + (n - i) * dp[i + 1] / (double)n;
dp[i] *= n / (double)(n - i);
}
cout << dp[1] << endl;
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define reps(i, j, n) for (ll i = j; i < (n); ++i)
#define ALL(s) ((s).begin(), (s).end())
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
using namespace std;
typedef long long ll;
constexpr ll INF = 3e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n, ans = INF;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
rep(bit, 1 << n) {
vector<ll> res;
ll t = 0;
rep(i, n) {
if (bit >> i & 1)
res.push_back(t), t = a[i];
else
t |= a[i];
}
res.push_back(t);
t = 0;
for (ll tt : res) t ^= tt;
ans = min(ans, t);
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define MOD (int)(1e9+7)
#define MOD1 998244353
#define ceil(x, y) ((x)%(y))==0? ((x)/(y)) : ((x)/(y)+1)
#define FOR(i, N) for(int i = 0; i < N; ++i)
#define FOR1(i, N) for(int i = 1; i <= N; ++i)
#define vi vector <int>
#define pii pair <int, int>
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define mset(a, v) memset(a, v, sizeof(a))
#define all(v) (v).begin(), (v).end()
#define INF 2e9
#define EPS 1e-9
#define int long long
/*#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
typedef cc_hash_table<int, int, hash<int>> ht; // while using, comment #define int long long */
void __print(int x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define dbg(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define dbg(x...)
#endif
using namespace std;
int power(int x, int y, int m){
if(y == 0) return 1;
if(y & 1) return x * power(x, y-1, m) % m;
else{
int p = power(x, y / 2, m);
return p * p % m;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("in7.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
int T=1;
// cin >> T;
FOR1(tt, T){
// cout << "Case #" << tt << ": ";
int n, m; cin >> n >> m;
/*Observe X % M == (X - kM) % M */
cout << (power(10, n, m*m) / m) % m;
cout << '\n';
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int M, mod;
long long N;
int mul (int x, int y) {return 1LL * x * y % mod;}
int power (int a, long long b)
{
int p = 1;
for (int i=0; (1LL<<i) <= b; i++)
{
if (b & (1LL << i)) p = mul (p, a);
a = mul (a, a);
}
return p;
}
int main ()
{
//freopen ("input", "r", stdin);
//freopen ("output", "w", stdout);
scanf ("%lld %d", &N, &M);
mod = M * M;
printf ("%d\n", power (10, N) / M);
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define boost ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
typedef long long ll;
typedef unsigned long long ull;
typedef string str;
typedef double db;
typedef long double ld;
typedef pair<int, int> pi;
#define fi first
#define se second
typedef vector<int> vi;
typedef vector<pi> vpi;
typedef vector<str> vs;
typedef vector<ld> vd;
#define pb push_back
#define eb emplace_back
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define endl "\n"
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
const int MOD = 1e9 + 7; //998244353
const ll INF = 1e18;
const int MX = 1e6 + 10;
const int nx[8] = {0, 0, 1, -1, -1, 1, 1, -1}, ny[8] = {1, -1, 0, 0, 1, -1, 1, -1}; //right left down up
template<class T> using V = vector<T>;
template<class T> bool ckmin(T& a, const T& b) { return a > b ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); } // divide a by b rounded up
//constexpr int log2(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
//mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
ll random(ll a, ll b){
return a + rng() % (b - a + 1);
}
#ifndef LOCAL
#define cerr if(false) cerr
#endif
#define dbg(x) cerr << #x << " : " << x << endl;
#define dbgs(x,y) cerr << #x << " : " << x << " / " << #y << " : " << y << endl;
#define dbgv(v) cerr << #v << " : " << "[ "; for(auto it : v) cerr << it << ' '; cerr << ']' << endl;
#define here() cerr << "here" << endl;
void IO() {
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
//Geometry
typedef long long C;
typedef complex<C> P;
#define X real()
#define Y imag()
#define pi 3.14159265359
int main()
{
boost;
IO();
str n;
cin >> n;
if(n=="0")
{
cout << "Yes" << endl;
return 0;
}
int len = (int)n.length();
int j = len-1;
while(n[j]=='0'&&j>=0)
{
n = '0' + n;
}
len = (int)n.length();
bool flag = true;
FOR(i, 0, len/2)
{
if(n[i]!=n[len-i-1])
{
flag = false;
break;
}
}
if(flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
bool palind(string nb){
int i = 0;
int j = nb.size() - 1;
bool palind = true;
while (i <= j & palind == true){
if (nb[i] == nb[j]){
i += 1;
j -= 1;
}
else{
palind = false;
}
}
return palind;
}
int numberOfZeros(string nb){
int i = nb.size() - 1;
int nbOfZero = 0;
while (i >= 0 & nb[i] == '0'){
nbOfZero += 1;
i--;
}
return nbOfZero;
}
int main(){
int number;
cin >> number;
string numberInString = to_string(number);
string nbAfterAdd;
if (palind(numberInString)){
cout << "Yes";
}
else if (numberOfZeros(numberInString) != 0){
for (int i = 0; i < numberOfZeros(numberInString); i++){
nbAfterAdd += '0';
}
nbAfterAdd += numberInString;
if (palind(nbAfterAdd)){
cout << "Yes";
}
else{
cout << "No";
}
}
else{
cout << "No";
}
} |
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
//#include <fstream>
#include <string>
#include <math.h>
#include <set>
#include <string>
#include <bitset>
//#include <fstream>
//#include <stack>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
//typedef pair<ll, P> T;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n) - 1; i >= 0; i--)
#define f first
#define s second
#define pb push_back
ll mod = 1000000007;
const ll INF = 100000000000010000;
//const ull B = 998244353;
//ll kai[3010];
//void pres(double A, ll x = 20) { printf("%.20f\n", x); }
vector<ll> dx = { 0, 1, 0, -1, 1, -1, 1, -1, 0};
vector<ll> dy = { 1, 0, -1, 0, 1, 1, -1, -1, 0};
void chmin(ll& x, ll y) {
x = min(x, y);
}
void chmax(ll& x, ll y) {
x = max(x, y);
}
ll pow_long(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y % 2 == 1) res *= x;
x *= x;
y /= 2;
}
return res;
}
void test() {
cout << "888888888888888888888888" << endl;
}
ll gcd(ll x, ll y) {
if (y == 0) return x;
return gcd(y, x % y);
}
ll pow_mod(ll x, ll k) {
x %= mod;
ll res = 1;
while (k > 0) {
if (k % 2) {
res *= x; res %= mod;
}
x *= x; x %= mod;
k /= 2;
}
return res;
}
ll div_mod(ll x) {
return pow_mod(x, mod - 2);
}
//コンビネーション
const int MAXcomb = 1000010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAXcomb; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod%i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll comb(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * finv[k] % mod * finv[n - k] % mod;
}
ll N, X;
vector<ll> vec;
void solve() {
cin >> N >> X;
rep(i, N) {
int a;
cin >> a;
if (a == X) continue;
vec.push_back(a);
}
//sort(vec.begin(), vec.end());
rep(i, vec.size()) {
cout << vec[i] << ' ';
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll T = 1;
//cin >> T;
rep(i, T) solve();
}
| // YATIN KWATRA
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define ar array
#define sz(v) (int)(v.size())
#define inf 1e18
#define int ll
#define FIO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ld long double
#define ull unsigned long long
#define endl "\n"
#define fo(i,a,b) for(int i = a; i<=b ; i++)
#define rfo(i,a,b) for(int i = a; i>=b ; i--)
#define vii vector<int>
#define pq priority_queue
#define uomii unordered_map<int,int,best_hash>
#define all(v) v.begin(),v.end()
#define mp make_pair
#define pb push_back
#define pob pop_back
#define ff first
#define ss second
#define pii pair<int,int>
#define mii map<int,int>
#define vvii vector<vii>
#define mod 1000000007
#define MIN -1e9
#define pi 3.1415926535897932384626433832795
#define cz(x) 63 - __builtin_clzll(x)
using namespace std;
using namespace __gnu_pbds;
template<class T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct best_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void INPUT()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
/*
----------------------------------------------------------------
-> Check For Overflows
-> Out of Bounds
-> Initialisations of global arrays and variables
----------------------------------------------------------------
*/
// so we will run all possible ways, as only two directions are allowed
// dp[turn][i][j] -> turn == 0 means tak turn and 1 means aoki turn
// we always the score difference between tak and aoki
// we maintain the score difference
// aoki tries to minimise
// tak tries to maximise
const int N = 2005;
int v[N][N];
int dp[2][N][N];
int n, m;
int khelo(int turn, int i, int j) {
if (i == n - 1 and j == m - 1) return 0; // khel laye boht, chalo vapis
int &ans = dp[turn][i][j];
if (ans != -1e18) return ans;
ans = -1e9;
if (j + 1 < m) ans = max(ans, v[i][j + 1] - khelo(!turn, i, j + 1));
if (i + 1 < n) ans = max(ans, v[i + 1][j] - khelo(!turn, i + 1, j));
return ans;
}
void solve()
{
cin >> n >> m;
fo(i, 0, n - 1) {
fo(j, 0, m - 1) {
char ch;
cin >> ch;
if (ch == '+') v[i][j] = 1;
else v[i][j] = -1;
dp[0][i][j] = dp[1][i][j] = -1e18;
}
}
int score = khelo(0, 0, 0);
if (score > 0) cout << "Takahashi\n";
else if (score < 0) cout << "Aoki\n";
else cout << "Draw\n";
}
signed main() {
FIO
INPUT();
int t;
t = 1;
//cin >> t;
fo(i, 0, t - 1) {
solve();
}
return 0;
}
|
#include<bits/stdc++.h>
#include<algorithm>
#include<string.h>
#include<numeric>
#include<vector>
#include<math.h>
#include<map>
using namespace std;
#define dude ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define mesc(number,character) char f[number];memset(f,character,number);
#define mesi(number,value) int f[number];memset(f,value,number);
#define specio ifstream cin("input.txt");ofstream cout("output.txt");
#define fr(i,start,end) for(i=start;i<=end;i++)
#define rf(i,start,end) for(i=start;i>=end;i--)
#define st(vect) sort(v.begin(),v.end())
#define tst int t;cin>>t;while(t--)
#define ai ll n,j,i;cin>>n;ll a[n+1];
#define pi 3.14159265358979323846
#define ll long long int
#define acc accumulate
#define ld long double
#define pb push_back
#define r0 return 0;
#define pp pop_back
#define vec vector
#define sec second
#define S string
#define D double
#define len length
#define br break;
#define wh while
#define fs first
#define F float
#define gcd __gcd
#define sz size
#define endl "\n"
#define sp " "
ll tim(S s) {
ll val=0;
val+=(s[0]-48)*600;
val+=(s[1]-48)*60;
val+=(s[3]-48)*10;
val+=(s[4]-48);
return val;
}
void sagnik(){
ai
ll b[n];
ll ans=INT_MAX;
fr(i,0,n-1) {
cin>>a[i]>>b[i];
}
fr(i,0,n-1) {
fr(j,0,n-1) {
if(i!=j) {
ans=min(ans,max(a[i],b[j]));
}
else {
ans=min(ans,(a[i]+b[i]));
}
}
}
cout<<ans<<endl;
}
int main(){
// dude
// tst {
sagnik();
// }
r0;
} | #include<bits/stdc++.h>
using namespace std;
const int maxn = 5010;
const int mod = 998244353;
int add (int x, int y) {return x + y >= mod ? x + y - mod : x + y;}
int sub (int x, int y) {return x - y < 0 ? x - y + mod : x - y;}
int mul (int x, int y) {return 1LL * x * y % mod;}
int qpm (int x, int y)
{
int r = 1;
while (y)
{
if (y & 1) r = mul (r, x);
x = mul (x, x);
y >>= 1;
}
return r;
}
int n, m;
int s[maxn][maxn], dp[maxn][maxn], ans = 0, _m[maxn];
int main()
{
scanf ("%d %d", &n, &m);
_m[0] = 1;
for (int i = 1; i <= n; i++) _m[i] = mul (_m[i - 1], m);
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
int temp = _m[i - 1];
dp[i][j] = s[i - 1][j];
s[i][j] = add (mul (s[i - 1][j], m - j), temp);
}
}
for (int i = 1; i <= n; i++)
{
int temp = 0;
for (int j = 1; j <= m; j++)
temp = add (temp, dp[i][j]);
ans = add (mul(sub (_m[i], temp), _m[n - i]), ans);
}
printf ("%d\n", ans);
return 0;
}
|
//#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#include <bits/stdc++.h>
#include<set>
#include <array>
using namespace std;
#define ll long long
#define endl '\n'
#define mod 998244353
#define pb push_back
#define ff first
#define ss second
#define con continue
#define ub upper_bound
#define lb lower_bound
#define si(x) int(x.size())
#define sum_all(a) ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
const double pi = 2 * acos(0.0);
const int dx[] = { -1, 0, 1, 0 };
const int dy[] = { 0, -1, 0, 1 };
const int dx8[] = { -1, 0, 1, 0,1,1,-1,-1 };
const int dy8[] = { 0, -1, 0, 1,1,-1,1,-1 };
ll min(ll a,ll b)
{
if(a<b)return a;
return b;
}
ll max(ll a,ll b)
{
if(a>b)return a;
return b;
}
ll ceil1(ll a,ll b)
{
return(a+b-1)/b;
}
void read(vector<ll> & arr)
{
for(ll i=0;i<si(arr);i++)
cin >> arr[i];
}
void read_graph(vector<vector<ll>>& g, ll m)
{
while(m--)
{
ll x,y; cin >> x>> y ;
x--,y--;
g[x].pb(y);
g[y].pb(x);
}
}
ll modmul(ll x, ll y, ll m=mod)
{
if (y==0) return 0;
ll a = modmul(x, y / 2, m) % m;
a = (a + a) % m;
if (y % 2 != 0)
{
a = (a + x) % m;
}
return a;
}
ll power(ll a, ll b, ll m)
{
if (b == 1) return a;
ll x = power(a, b / 2, m);
x *= x;
x %= m;
if (b % 2 == 1)
{
x *= a;
x %= m;
}
return x;
}
void solve()
{
int n;
cin >> n ;
vector<ll> arr(n);
for(int i=0;i<n;i++)
cin >> arr[i];
sort(arr.begin(),arr.end());
// for(ll i=0;i<n;i++) cout << arr[i] << " " ;
// cout << endl ;
vector<ll> suff(n);
vector<ll> pw(n+1);
pw[0]=1;
for(ll i=1;i<=n;i++)
{
pw[i]=pw[i-1]*2;
pw[i]%=mod;
}
for(ll i=0;i<n;i++)
{
suff[i]= modmul(arr[i],pw[i],mod);
suff[i]%=mod;
}
for(ll i=n-2;i>=0;i--)
{
suff[i] +=suff[i+1];
suff[i]%=mod;
}
ll inv_2= power(2,mod-2,mod);
ll base=inv_2;
// ll k =853983 *853983 ;
ll ans=0 ;
for(ll i=0;i<n;i++)
{
ans+=(modmul(arr[i],arr[i]))%mod;
ans%=mod;
}
for(ll i=0;i<n-1;i++)
{
ll x ;
x= modmul(suff[i+1],inv_2);
x=modmul(arr[i],x);
ans+=x;
ans%=mod;
inv_2= modmul(inv_2,base);
}
cout << ans <<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
// int t; cin >> t; while (t--)
solve();
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define ALL(a) (a).begin(),(a).end()
#define sz(x) int(x.size())
using namespace std;
using ll = long long;
using P = pair<int,int>;
using T = tuple<int,int,int>;
using Graph = vector<vector<int>>;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
constexpr ll TEN(int n){ return (n == 0) ? 1 : 10 * TEN(n - 1); }
ll MOD = 998244353;
int main(){
int n; cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
sort(ALL(a));
vector<ll> dp(n,0); //答え
vector<ll> sum(n);
sum[0] = a[0];
rep(i,n-1) {
sum[i+1] = (sum[i]*2+a[i+1]) % MOD;
}
(dp[0] = a[0]*a[0]) %= MOD;
for(int i = 1; i < n;++i){
dp[i] += dp[i-1];
(dp[i] += (a[i]*a[i])%MOD) %= MOD;
(dp[i] += (sum[i-1]*a[i])%MOD) %= MOD;
}
cout << dp[n-1] << endl;
} |
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<functional>
#include <random>
#include<iostream>
#include<iomanip>
using namespace std;
int main() {
int N, M;
int state[1000];
cin >> N >> M;
for (int i = 0; i < 1000;i++) {
state[i] = 0;
}
for (int i = 0; i < N; i++) {
int A;
cin >> A;
state[A - 1] += 1;
}
for (int i = 0; i < M; i++) {
int B;
cin >> B;
state[B - 1] += 1;
}
for (int i = 0; i < 1000; i++) {
if (state[i] == 1) {
cout << i + 1 << " ";
}
}
} | #include<bits/stdc++.h>
#include<iostream>
#include<set>
#include<map>
#include<iterator>
#define ll long long
#define lli long long int
#define pb push_back
#define mp make_pair
#define RIP(i,n) for(ll i=0; i<n; i++)
#define F(i,a,b) for(int i=a; i<b; i++)
#define RIP1(i,n) for(int i=(n-1); i>=0; i--)
#define FOR(i,a,b) for(int i=a;i<(b); i++)
#define FOR1(i,a,b) for(int i=a; i>=(b); i--)
#define sc(a) scanf("%lld",&a)
#define SC(a) scanf("%d",&a)
#define cin(a) cin >> a
#define cout(a) cout << a
#define pi acos(-1)
#define pr(a) printf("%lld\n",a)
#define PR(a) printf("%lld ",a)
#define s(a,b) sort(a,b)
#define sz(x) (int)(x).size()
#define nl '\n'
#define Max 10000
#define mod 1e9+7
using namespace std;
void F_I_O()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
ll gcd(ll a,ll b)
{
if(b==0)
{
return a;
}
else
{
return gcd(b,a%b);
}
}
int main()
{
ll n,m;
cin >> n >> m;
vector<ll>a(n),b(m);
vector<ll>cnt_a(Max,0),cnt_b(Max,0);
vector<ll>ans;
RIP(i,n)
{
cin >> a[i];
cnt_a[a[i]]++;
}
RIP(i,m)
{
cin >> b[i];
cnt_a[b[i]]++;
}
RIP(i,n)
{
if(cnt_a[a[i]]==1)
{
ans.pb(a[i]);
}
}
RIP(i,m)
{
if(cnt_a[b[i]]==1)
{
ans.pb(b[i]);
}
}
sort(ans.begin(),ans.end());
RIP(i,ans.size())
{
cout << ans[i] << ' ';
}
cout << nl;
/* ll a,b,c;
cin >> a >> b >> c;
double p = (b*c)/a*1.0;
ll r = p;
if(b%a==0 || c%a==0)
{
p--;
}
cout << max(p,0LL) << nl;*/
/* ll a,b;
cin >> a >> b;
ll ans=1;
for(ll i=2; i<=a; i++)
{
ll r = a/i + !(a%i==0);
ll p = r*i;
ll q = (r+1)*i;
if(p<b && q<=b)
{
ans = max(ans,i);
}
}
cout << ans << nl;*/
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(f,c,...) (([&](decltype((c)) cccc) { return (f)(std::begin(cccc), std::end(cccc), ## __VA_ARGS__); })(c))
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void solve(long long N, std::vector<long long> x){
i64 ans1 = 0, ans3 = 0;
double ans2 = 0;
REP (i, N) {
i64 x_abs = abs(x.at(i));
ans1 += x_abs;
ans2 += x_abs * x_abs;
ans3 = max(abs(ans3), x_abs);
}
cout << ans1 << endl;
ans2 = sqrt(ans2);
cout << fixed << setprecision(15) << ans2 << endl;
cout << ans3 << endl;
}
int main(){
long long N;
scanf("%lld",&N);
std::vector<long long> x(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&x[i]);
}
solve(N, std::move(x));
return 0;
}
| #include<iostream>
#include<cstring>
#include<cassert>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<vector>
#include<time.h>
#include<bitset>
#include<cstdio>
#include<algorithm>
using namespace std;
#define REP(i,x,y) for(int i=x;i<=y;i++)
#define rep(i,n) REP(i,1,n)
#define rep0(i,n) REP(i,0,n-1)
#define repG(i,x) for(int i=pos[x];~i;i=e[i].next)
#define ll long long
#define db double
const int N=4e5+7;
const int INF=1e9+7;
int n;
vector<int>E[N];
bool vis[N];
int sz[N];
bool dfs(int x,int f){
bool d=0;
vis[x]=1;
sz[x]=1;
for(int i=0;i<E[x].size();i++){
if(vis[E[x][i]]){
if(E[x][i]!=f)d=1;
}
else{
d|=dfs(E[x][i],x);
sz[x]+=sz[E[x][i]];
}
}
return d;
}
int main(){
scanf("%d",&n);
rep(i,n){
int x,y; scanf("%d%d",&x,&y);
E[x].push_back(y);
E[y].push_back(x);
}
int ans=0;
rep(i,400000){
if(vis[i])continue;
if(!E[i].size())continue;
bool q=dfs(i,0);
ans+=(sz[i]-(!q));
}
printf("%d\n",ans);
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
// 定義
typedef long long ll;
typedef pair<ll, ll> P;
#define ALL(x) (x).begin(),(x).end()
#define REP(i, n) for(ll i = 0 ; i < (ll)n ; ++i)
#define REPN(i, m, n) for(ll i = m ; i < (ll)n ; ++i)
#define VL vector<ll>
#define VVL vector<vector<ll>>
#define VVVL vector<vector<vector<ll>>>
#define INF (ll)2e9
#define INF_LL 1LL<<60
//#define MOD 998244353
#define MOD 1000000007
ll Ceil(ll val, ll div) { return (val + div - 1) / div; }
ll CeilN(ll val, ll div) { return Ceil(val, div) * div; }
ll FloorN(ll x, ll n) { return (x - x % n); }
bool IsOdd(ll x) { return ((x & 1) == 1); }
bool IsEven(ll x) { return ((x & 1) == 0); }
#define POS_MAX ((ll)2e5 + 5)
ll N, M;
VVL G(POS_MAX * 2);
VVL isUsed(POS_MAX * 2);
void dfs(ll x, ll y, ll cIdx)
{
VL &posC = G[y];
isUsed[y][cIdx] = true;
ll xEnd;
if (cIdx < posC.size() - 1) {
xEnd = posC[cIdx + 1];
} else {
xEnd = N * 2 + 5;
}
auto execOne = [&](ll yNext) {
VL &xNext = G[yNext];
VL &isUsedOne = isUsed[yNext];
ll i = upper_bound(ALL(xNext), x) - xNext.begin();
for (; i < xNext.size(); i++) {
if (!isUsedOne[i]) {
if (x < xNext[i] && xNext[i] <= xEnd) {
dfs(xNext[i], yNext, i);
} else {
break;
}
}
}
};
execOne(y - 1);
execOne(y + 1);
}
// 処理
void Solve()
{
cin >> N >> M;
REP(i, M) {
ll x, y;
cin >> x >> y;
y -= N;
if (-POS_MAX < y && y < POS_MAX) {
y += POS_MAX;
G[y].emplace_back(x);
isUsed[y].emplace_back(false);
}
}
isUsed[POS_MAX].emplace_back(false);
G[POS_MAX].emplace_back(0);
for (auto &g : G) {
if (g.size()) {
sort(ALL(g));
}
}
dfs(0, POS_MAX, 0);
ll ans = 0;
for (auto u : isUsed) {
if (u.size()) {
if (u.back()) {
ans++;
}
}
}
cout << ans << endl;
}
// メイン
int main()
{
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Solve();
return 0;
}
| #include<cstdio>
#include<functional>
#include<utility>
#include<algorithm>
#include<set>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main(){
int N, M;
scanf("%d %d", &N, &M);
pair<int, int> pawn[M];
for (unsigned i = 0; i < M; i++) scanf("%d %d", &pawn[i].first, &pawn[i].second);
set<int> valid_y;
valid_y.insert(N);
sort(pawn, pawn + M);
bool pawn_exists_in_front = false, pawn_exists_in_left;
for(unsigned i = 0;i < M;i++){
pawn_exists_in_left = pawn_exists_in_front;
pawn_exists_in_front = (valid_y.find(pawn[i].second) != valid_y.end()) && i < M-1 && pawn[i+1] == make_pair(pawn[i].first, pawn[i].second + 1);
if(((i && pawn[i-1] == make_pair(pawn[i].first, pawn[i].second - 1)) ? pawn_exists_in_left : (valid_y.find(pawn[i].second - 1) != valid_y.end())) || (valid_y.find(pawn[i].second + 1) != valid_y.end())) valid_y.insert(pawn[i].second);
else valid_y.erase(pawn[i].second);
}
printf("%u\n", valid_y.size());
return 0;
} |
#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
using namespace std;
using Graph = vector<vector<int>>;
using vst= vector<string>;
using vin= vector<int>;
using ll=long long;
using ull=unsigned long long;
using vll= vector<ll>;
using P=pair<int ,int>;
//const long double pi=acos(-1);
#define ft first
#define sd second
#define fn front
#define pb push_back
#define eb emplace_back
#define it insert
#define vvi vector<vector<int>>
#define si(v) int((v).size())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rell(i,n) for (ll i=0; i< (ll)(n); i++)
#define sot(x) sort(x.begin(), x.end())
#define rese(x) reverse(x.begin(), x.end())
#define gsot(x) sort(x.begin(), x.end(), greater<ll>());
#define vnn(x,y,s,name) vector<vector<int>> name(x, vector<int>(y,s))
#define mse(x) memset(x, 0, sizeof(x)
#define all(x) (x).begin(),(x).end()
#define mii(x,y,z) min(x,min(y,z))
#define maa(x,y,z) max(x,max(y,z))
#define cps CLOCKS_PER_SEC
#define yes cout<<"Yes"<<"\n"
#define no cout<<"No"<<"\n"
#define cset(x) cout<<fixed<<setprecision(x)
//const int INF=1001001001;
//998244353 1000000007
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n,m;
cin>>n>>m;
vector<P> a(m);
rep(i,m){
cin>>a[i].ft>>a[i].sd;
a[i].ft--; a[i].sd--;
}
int k;
cin>>k;
vector<P> c(k);
rep(i,k){
cin>>c[i].ft>>c[i].sd;
c[i].ft--; c[i].sd--;
}
int ans=0;
int l=(1<<17);
rep(i,l){
bitset<17> s(i);
vector<bool> d(n,0);
rep(j,k){
if(s[j]) d[c[j].ft]=true;
else d[c[j].sd]=true;
}
int cnt=0;
rep(j,m){
if(d[a[j].ft]&&d[a[j].sd]) cnt++;
}
if(cnt>ans) ans=cnt;
}
//cout<<l<<endl;
cout<<ans<<endl;
}
| #include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<string>
#include<set>
#define ll long long
using namespace std;
int main(){
int n,m;
cin>>n>>m;
vector<int> a(m),b(m);
for(int i=0;i<m;i++){
cin>>a[i]>>b[i];
}
int k;
cin>>k;
vector<int> c(k),d(k);
for(int i=0;i<k;i++){
cin>>c[i]>>d[i];
}
int ans=0;
for(int bit=0;bit<(1<<k);bit++){
vector<bool> v(n,false);
for(int i=0;i<k;i++){
if(bit & (1<<i)){
v[c[i]]=true;
}else{
v[d[i]]=true;
}
}
int cnt=0;
for(int i=0;i<m;i++){
if(v[a[i]]==true && v[b[i]]==true) cnt++;
}
ans=max(ans,cnt);
}
cout<<ans<<endl;
return 0;
} |
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, s, n) for (int i = (s); i < (n); ++i)
#define all(a) a.begin(), a.end()
#define len(x) (int)(x).size()
#define dup(x, y) (((x) + (y)-1) / (y))
#define pb push_back
#define Field(T) vector<vector<T>>
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
long N;
cin >> N;
for (long i = 1, a = 3; a < N; i++, a *= 3) {
for (long j = 1, b = 5; b < N; j++, b *= 5) {
if (a + b == N) return cout << i << " " << j << "\n", 0;
}
}
cout << -1 << endl;
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
} | #include<bits/stdc++.h>
#define ll long long int
#define dd double
using namespace std;
const ll MOD = 1e9 + 7;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin>>n;
ll sum=0;
ll i=0;
for(i=1;i<=n;i++){
sum=sum+i;
// cout<<sum<<endl;
if(sum>=n){
break;
}
}
cout<<i<<endl;
return 0;
}
|
//#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#include <bits/stdc++.h>
#include<set>
using namespace std;
#define ll long long
#define endl '\n'
#define pb push_back
#define ff first
#define ss second
#define si(x) int(x.size())
#define sum_all(a) ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) ( max_element((a).begin(), (a).end()) - (a).begin())
void solve()
{
ll n ;
cin >>n ;
if(n==1)
{
cout << 1<< endl << 1 << endl; return ;
}
if(n==2)
{
cout << 2 << endl << 1<< endl << 1 << endl; return ;
}
vector<ll> f;
f={1,1};
while(f.back()<1e18)
{
f.pb(f[si(f)-1]+f[si(f)-2]);
}
// for(ll i=0;i<5;i++) cout << f[i] << " ";
// cout << endl;
vector<ll> ans;
vector<ll> temp;
while(n>0)
{
ll x=0;
for(ll i=0;i<si(f);i++)
{
if(n>=f[i]) x=i;
}
ans.pb(x+1);
n-=f[x];
}
vector<ll> res;
// for(ll i=0;i<si(ans);i++) cout << ans[i]<< endl;
if(ans[0]%2==0)
{
res.pb(2);
for(ll i=1;i<ans[0];i++)
{
if(i%2==1) res.pb(3); else res.pb(4);
}
vector<ll> fin;
ll j=si(ans)-1;
for(ll i=si(res)-1;i>=0;i--)
{
fin.pb(res[i]);
if(j>=1 and ans[0]-ans[j]==i)
{
if(fin.back()==3)
fin.pb(1);
else fin.pb(2);
j--;
}
}
reverse(fin.begin(),fin.end());
cout << si(fin) << endl;
for(ll i=0;i<si(fin);i++)
{
cout <<fin[i] << endl ;
}
}
else
{
res.pb(1);
for(ll i=1;i<ans[0];i++)
{
if(i%2==1) res.pb(4); else res.pb(3);
}
vector<ll> fin;
ll j=si(ans)-1;
for(ll i=si(res)-1;i>=0;i--)
{
fin.pb(res[i]);
if(j>=1 and ans[0]-ans[j]==i)
{
if(fin.back()==3)
fin.pb(1);
else fin.pb(2);
j--;
}
}
reverse(fin.begin(),fin.end());
cout << si(fin) << endl;
for(ll i=0;i<si(fin);i++)
{
cout <<fin[i] << endl ;
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
//int t; cin >> t; while (t--)
solve();
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
# define M_PI 3.14159265358979323846
const int M=1e9+7;
long long mod(long long x){
return ((x%M + M)%M);
}
long long add(long long a, long long b){
return mod(mod(a)+mod(b));
}
long long mul(long long a, long long b){
return mod(mod(a)*mod(b));
}
long long gcd(long long int a, long long int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
// Function to return LCM of two numbers
long long lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
ll modPow(ll a, ll b){
if(b==0)
return 1LL;
if(b==1)
return a%M;
ll res=1;
while(b){
if(b%2==1)
res=mul(res,a);
a=mul(a,a);
b=b/2;
}
return res;
}
void solve()
{
int n;
cin>>n;
vector<int>v;
for(int i=0;i<pow(2,n);i++)
{
int k;
cin>>k;
v.push_back(k);
}
int i1=0;
int ml=0;
int mr=0;
int i2=0;
for(int i=0;i<pow(2,n-1);i++)
{
ml=max(ml,v[i]);
if(ml==v[i])
{
i1=i;
}
}
for(int i=pow(2,n-1);i<pow(2,n);i++)
{
mr=max(mr,v[i]);
if(mr==v[i])
{
i2=i;
}
}
if(ml<mr)
cout<<i1+1<<endl;
else
cout<<i2+1<<endl;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed;
cout<<setprecision(10);
int t=1;
// cin>>t;
for(int i=1;i<=t;i++){
// cout<<"Case #"<<i<<": ";
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<int> ps;
DSU(int n): ps(n) {
iota(ps.begin(), ps.end(), 0);
}
int find(int i) {
if (ps[i] == i) {
return i;
}
return ps[i] = find(ps[i]);
}
bool merge(int i, int j) {
i = find(i);
j = find(j);
if (i == j) {
return false;
}
ps[i] = j;
return true;
}
};
void solve() {
int h, w;
cin >> h >> w;
DSU dsu(h + w);
for (auto [i, j] : vector<pair<int, int>>{{0, w}, {0, w+h-1}, {w-1, w}, {w-1, w+h-1}}) {
dsu.merge(i, j);
}
for (int i = 0; i < h; ++i) {
string s;
cin >> s;
for (int j = 0; j < w; ++j) {
if (s[j] == '#') {
dsu.merge(w + i, j);
}
}
}
set<int> a, b;
for (int i = 0; i < w; ++i) {
a.insert(dsu.find(i));
}
for (int i = 0; i < h; ++i) {
b.insert(dsu.find(w + i));
}
int answer = min(a.size(), b.size()) - 1;
cout << answer << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | #include <bits/stdc++.h>
#define Ri register int
#define ll long long
#define db double
#define FOR(i, j, k) for(Ri i = j; i <= k; i++)
#define DEC(i, j, k) for(Ri i = j; i >= k; i--)
using namespace std;
const int maxn = 2e5 + 100;
int n;
vector<int> g[maxn];
int mx, xm;
int d[maxn];
inline void dfs(int u, int fa) {
d[u] = d[fa] + 1;
if(d[u] > mx) mx = d[u], xm = u;
for(Ri i = 0; i < g[u].size(); i++) {
if(g[u][i] == fa) continue;
dfs(g[u][i], u);
}
}
bool f[maxn];
void tagi(int u) {
if(!u) return;
f[u] = 1;
for(Ri i = 0; i < g[u].size(); i++) {
if(d[g[u][i]] < d[u]) {
tagi(g[u][i]);
break;
}
}
}
int out[maxn];
int sol(int u, int fa, int w) {
out[u] = ++w;
int h = 0;
for(Ri i = 0; i < g[u].size(); i++) {
if(g[u][i] == fa) continue;
if(f[g[u][i]]) {h = g[u][i]; continue;}
w = sol(g[u][i], u, w) + 1;
}
if(h) w = sol(h, u, w);
return w;
}
int main() {
scanf("%d", &n);
FOR(i, 2, n) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
mx = 0, xm = 0;
dfs(1, 0);
int w = xm;
mx = 0, xm = 0;
dfs(w, 0);
tagi(xm);
sol(w, 0, 0);
FOR(i, 1, n) printf("%d ", out[i]);
return 0;
}
|
#include <stdio.h>
#include <algorithm>
#include <map>
#include <vector>
struct segTree{
int value[800010];
void setValue(int ind ,int val, int l=1, int r=200000, int v=1)
{
if(l==r) value[v] = val;
else
{
int h = (l+r)/2;
if(ind<=h) setValue(ind,val,l,h,2*v);
else setValue(ind,val,h+1,r,2*v+1);
value[v] = value[2*v]+value[2*v+1];
}
}
int getSum(int L, int R, int l=1, int r=200000, int v=1)
{
if(L>R) return 0;
if(L<=l&&r<=R) return value[v];
else if(r<L) return 0;
else if(R<l) return 0;
else
{
int h = (l+r)/2;
int s1 = getSum(L,R,l,h,2*v);
int s2 = getSum(L,R,h+1,r,2*v+1);
return s1+s2;
}
}
}T;
std::vector<int> index;
std::map<int,int> hash;
std::vector<int> V[200010];
int x[200010],y[200010];
int main()
{
int a;
scanf("%d",&a);
for(int i=1;i<=a;i++) scanf("%d",&x[i]);
for(int i=1;i<=a;i++) scanf("%d",&y[i]);
for(int i=1;i<=a;i++) x[i] += i;
for(int i=1;i<=a;i++) y[i] += i;
for(int i=1;i<=a;i++) index.push_back(x[i]);
std::sort(index.begin(),index.end());
index.erase(std::unique(index.begin(),index.end()),index.end());
for(int i=0;i<index.size();i++) hash[index[i]] = i+1;
for(int i=a;i>=1;i--) V[hash[x[i]]].push_back(i);
for(int i=1;i<=a;i++) T.setValue(i,1);
long long int ans = 0;
for(int i=1;i<=a;i++)
{
if(hash.find(y[i])==hash.end())
{
printf("-1");
return 0;
}
if(V[hash[y[i]]].size()==0)
{
printf("-1");
return 0;
}
int t = V[hash[y[i]]].back();
V[hash[y[i]]].pop_back();
ans += T.getSum(1,t-1);
T.setValue(t,0);
}
printf("%lld",ans);
} | #include <iostream>
#include <vector>
#include <deque>
#include <iomanip>
using namespace std;
using ll = int64_t;
using ld = double;
int main() {
ll n;
cin >> n;
vector<vector<ll>> E(n, vector<ll>{});
for(ll i=0; i<n; i++) {
string S;
cin >> S;
for(ll j=0; j<n; j++) {
if(S[j]=='1') {
E[i].push_back(j);
}
}
}
// R[i] is the set of vertices reachable from i
vector<vector<ll>> R(n, vector<ll>{});
for(ll i=0; i<n; i++) {
vector<int> SEEN(n, false);
deque<ll> Q;
Q.push_back(i);
while(!Q.empty()) {
ll x = Q.front(); Q.pop_front();
if(SEEN[x]) { continue; }
SEEN[x] = true;
R[i].push_back(x);
for(ll y : E[x]) {
Q.push_back(y);
}
}
}
// P[i] is the set of vertices that can reach i
vector<vector<ll>> P(n, vector<ll>{});
for(ll i=0; i<n; i++) {
for(ll j : R[i]) {
P[j].push_back(i);
}
}
ld ans = 0.0;
for(ll i=0; i<n; i++) {
ans += 1.0/static_cast<ld>(P[i].size());
}
cout << setprecision(16) << ans << endl;
}
|
/**
* author: Taichicchi
* created: 17.04.2021 11:31:39
**/
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
long double R, X, Y;
cin >> R >> X >> Y;
long double D;
D = sqrtl(pow(X, 2) + pow(Y, 2));
if (R == D) {
cout << 1 << endl;
return 0;
}
if (R > D) {
cout << 2 << endl;
return 0;
}
cout << ceill(D / R) << endl;
return 0;
} | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <utility>
#include <string>
#include <fstream>
#include <map>
#include <set>
#include <queue>
#include <memory.h>
using namespace std;
typedef vector<int> VI;
typedef pair<long long, long long> PI;
typedef vector<PI> VPI;
#define FOR(i,a,n) for (int i = (a); i < (n); ++i)
#define FORE(i,a,n) for (int i = (a); i <= (n); ++i)
#define FORD(i,a,b) for (int i = (a); i >= (b); --i)
#define REP(i,n) FOR(i,0,n)
#define REPE(i,n) FORE(i,0,n)
#define LL long long
#define FIR(n) REP(i,n)
#define FJR(n) REP(j,n)
#define ALL(v) v.begin(), v.end()
#define FI FIR(n)
#define FJ FJR(n)
#define FR(i,a) FOR(i,a,n)
#define REPN(i) REP(i,n)
#define GI(n) scanf("%d", &n)
#define GI2(n,m) scanf("%d %d", &n, &m)
typedef pair<double, double> PDD;
int main() {
#ifdef LOCALF
freopen("input.txt", "rt", stdin);
#endif
ios::sync_with_stdio(false); cin.tie(0);
int n, M, K; cin >> n >> M >> K;
vector<PDD> f(n + 1 + M);
vector<int> reachable(n + 1 + M, 1);
double s = 0, t = 0;
vector<int> ok(n + 1 + M, 1);
int q = 0;
REP(k, K) {
cin >> q;
ok[q] = 0;
}
FORD(i, n - 1, 0) {
int last = i + M;
reachable[i] = false;
if (ok[i]) FJR(M) if (reachable[i + 1 + j]) {
reachable[i] = true;
break;
}
bool isb = false;
if (!ok[i]) {
f[i] = { 0, 1 };
}
else {
f[i] = { 1 + s / M, t / M };
}
s -= f[last].first;
t -= f[last].second;
s += f[i].first;
t += f[i].second;
}
if (!reachable[0]) {
cout << "-1" << endl;
return 0;
}
double res = f[0].first / (1 - f[0].second);
cout.precision(10);
cout << res << endl;
}
|
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
int main() {
int n;
string s;
cin >> n >> s;
int ans = -1;
if (s[0] != s[n - 1]) ans = 1;
else {
for (int i = 1; i < n - 1; i++) {
if (s[0] != s[i] && s[i + 1] != s[n - 1]) ans = 2;
break;
}
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
//#include <atcoder/modint>
//using namespace atcoder;
//using mint = modint998244353;
//using mint = modint1000000007;
#pragma region template
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
#define overload4(_1,_2,_3,_4,name,...) name
#define overload3(_1,_2,_3,name,...) name
#define rep1(n) for(ll i=0;i<n;++i)
#define rep2(i,n) for(ll i=0;i<n;++i)
#define rep3(i,a,b) for(ll i=a;i<b;++i)
#define rep4(i,a,b,c) for(ll i=a;i<b;i+=c)
#define rep(...) overload4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define rrep1(n) for(ll i=n;i--;)
#define rrep2(i,n) for(ll i=n;i--;)
#define rrep3(i,a,b) for(ll i=b;i-->(a);)
#define rrep(...) overload3(__VA_ARGS__,rrep3,rrep2,rrep1)(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define debug(var) do{std::cerr << #var << " : ";view(var);}while(0)
template<typename T> void view(T e){std::cerr << e << std::endl;}
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cerr << e << " "; } std::cerr << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){cerr << endl;int cnt = 0;for(const auto& v : vv){cerr << cnt << "th : "; view(v); cnt++;} cerr << endl;}
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
template<class T, class K>bool chmax(T &a, const K b) { if (a<b) { a=b; return 1; } return 0; }
template<class T, class K>bool chmin(T &a, const K b) { if (b<a) { a=b; return 1; } return 0; }
const int inf = 1001001001;
const ll INF = 1001001001001001001ll;
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
ll rddiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // -20 / 3 == -7
ll power(ll a, ll p){ll ret = 1; while(p){if(p & 1){ret = ret * a;} a = a * a; p >>= 1;} return ret;}
ll modpow(ll a, ll p, ll mod){ll ret = 1; while(p){if(p & 1){ret = ret * a % mod;} a = a * a % mod; p >>= 1;} return ret;}
ll rudiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // 20 / 3 == 7
#pragma endregion
//const double pi = acos(-1);
//const ll mod = 998244353;
const ll mod = 1000000007;
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
//cout << fixed << setprecision(20);
int n; cin >> n;
string s; cin >> s;
if(s[0] == s.back()){
char c = s[0];
rep(i,n - 1){
if(s[i] != c && s[i + 1] != c) cout << 2 << endl, exit(0);
}
cout << -1 << endl;
}
else cout << 1 << endl;
} |
#include <bits/stdc++.h>
using namespace std;
// clang-format off
/* accelration */
// 高速バイナリ生成
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
// cin cout の結びつけ解除, stdioと同期しない(入出力非同期化)
// cとstdの入出力を混在させるとバグるので注意
struct Fast {Fast() {std::cin.tie(0); ios::sync_with_stdio(false);}} fast;
/* alias */
using ull = unsigned long long;
using ll = long long;
using vi = vector<int>;
using vl = vector<long>;
using vll = vector<long long>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using vvll = vector<vll>;
using vs = vector<string>;
using pii = pair<int, int>;
/* define short */
#define pb push_back
#define mp make_pair
#define all(obj) (obj).begin(), (obj).end()
#define YESNO(bool) if(bool){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;}
#define yesno(bool) if(bool){cout<<"yes"<<endl;}else{cout<<"no"<<endl;}
#define YesNo(bool) if(bool){cout<<"Yes"<<endl;}else{cout<<"No"<<endl;}
/* REP macro */
#define reps(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define rep(i, n) reps(i, 0, n)
#define rrep(i, n) reps(i, 1, n + 1)
#define repd(i,n) for(ll i=n-1;i>=0;i--)
#define rrepd(i,n) for(ll i=n;i>=1;i--)
/* debug */
// 標準エラー出力を含む提出はrejectされる場合もあるので注意
#define debug(x) cerr << "\033[33m(line:" << __LINE__ << ") " << #x << ": " << x << "\033[m" << endl;
/* func */
inline int in_int() {int x; cin >> x; return x;}
inline ll in_ll() {ll x; cin >> x; return x;}
inline string in_str() {string x; cin >> x; return x;}
// search_length: 走査するベクトル長の上限(先頭から何要素目までを検索対象とするか、1始まりで)
template <typename T> inline bool vector_finder(std::vector<T> vec, T element, unsigned int search_length) {
auto itr = std::find(vec.begin(), vec.end(), element);
size_t index = std::distance( vec.begin(), itr );
if (index == vec.size() || index >= search_length) {return false;} else {return true;}
}
template <typename T> inline void print(const vector<T>& v, string s = " ")
{rep(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");}
template <typename T, typename S> inline void print(const pair<T, S>& p)
{cout << p.first << " " << p.second << endl;}
template <typename T> inline void print(const T& x) {cout << x << "\n";}
template <typename T, typename S> inline void print(const vector<pair<T, S>>& v)
{for (auto&& p : v) print(p);}
// 第一引数と第二引数を比較し、第一引数(a)をより大きい/小さい値に上書き
template <typename T> inline bool chmin(T& a, const T& b) {bool compare = a > b; if (a > b) a = b; return compare;}
template <typename T> inline bool chmax(T& a, const T& b) {bool compare = a < b; if (a < b) a = b; return compare;}
// gcd lcm
// C++17からは標準実装
// template <typename T> T gcd(T a, T b) {if (b == 0)return a; else return gcd(b, a % b);}
// template <typename T> inline T lcm(T a, T b) {return (a * b) / gcd(a, b);}
// clang-format on
struct P {
double x, y;
};
int main() {
int N;
P p0, pp;
cin >> N >> p0.x >> p0.y >> pp.x >> pp.y;
P c_;
c_.x = 0.5 * (p0.x + pp.x);
c_.y = 0.5 * (p0.y + pp.y);
P cx;
cx.x = (-c_.x + p0.x);
cx.y = (-c_.y + p0.y);
double pi = -3.1415926535;
double c = cos(pi / N);
double s = sin(pi / N);
P e;
e.x = c_.x + c * (c * cx.x + s * cx.y);
e.y = c_.y + c * (-s * cx.x + c * cx.y);
cout << 2 * e.x - p0.x << "\t" << 2 * e.y - p0.y;
return 0;
}
| #include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(void)
{
int n=0;
int a[200000] = {};
// int counter[200000] = {};
long long count=0,temp_count=1;
int i=0,j=0;
cin >> n;
for (i=0;i<n;i++){
cin >> a[i];
}
for(i=0;i<n;i++){
a[i] %= 200;
}
sort(a,a+n,greater<int>());
for(i=0;i<n-1;i++){
for (j=i+1;j<n;j++){
if(a[i]!= a[j] ) {
count += (temp_count*(temp_count-1))/2;
temp_count=1;
i=j-1;
break;
}
else temp_count++;
if(j == n-1) {
count += (temp_count*(temp_count-1))/2;
temp_count=1;
i=j-1;
break;
}
}
}
// cout << count << endl;
printf("%ld",count);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
int main(){
ull n,c=0;
cin >> n;
for(ull i=1;i<1000000;i++){
string s = to_string(i) + to_string(i);
if(stoull(s)<=n){
c++;
}
else{
break;
}
}
cout << c << endl;
return 0;
} | /*
* @Author: Luisvacson
* @LastEditors: Luisvacson
* @Descriptions: None
* @Date: 2021-03-20 20:06:05
* @LastEditTime: 2021-03-20 20:40:54
* @FilePath: \C++\Practice\ABC196C.cpp
*/
#include <bits/stdc++.h>
#define int long long
using namespace std;
int a[15], b[15];
string s;
signed main() {
cin >> s;
int n = s.size(), m, t = 1, ans = 0;
if (n & 1)
m = n >> 1;
else
m = (n >> 1) - 1;
for (int i = 1; i <= m; i++) {
ans += t * 9;
t *= 10;
}
if (!(n & 1)) {
ans = 0;
int x = n / 2, cnt = 1;
for (int i = 0; i < x; i++) a[i] = (s[i] - '0');
for (int i = x; i < n; i++) b[i - x] = (s[i] - '0');
bool flag = false;
for (int i = 0; i < x; i++) {
if (a[i] > b[i]) {
flag = true;
break;
} else if (a[i] < b[i])
break;
}
for (int i = 1; i < x; i++) {
cnt *= 10;
}
for (int i = 0; i < x; i++) {
ans += a[i] * cnt;
cnt /= 10;
}
if (flag) ans--;
}
cout << ans << endl;
return 0;
} |
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<iomanip>
using namespace std;
int main(){
long double N,D,H,mini = 100000000,ans;
vector<long double> d,h;
cin >> N >> D >> H;
d.resize(N);
h.resize(N);
for(long long i = 0;i<N;i++){
cin >> d[i] >> h[i];
mini = min(mini,(H-h[i])/(D-d[i]));
}
ans=H-mini*D;
if(ans < 0){
ans = 0;
}
cout << fixed << setprecision(15) << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define for_(i, a, b) for(int i = (a);i < (b);++i)
#define ford_(i, a, b) for(int i = (b)-1;i >= (a);--i)
#define rep(i, n) for_(i, 0, n)
#define repd(i, n) rfor_(i, 0, n)
int main(){
int n;
double d,h;
cin >> n >> d >> h;
vector<double> a(n);
vector<double> b(n);
vector<double> m(n);
rep(i,n){
cin >> a.at(i) >> b.at(i);
m.at(i) = (h - b.at(i)) / (d - a.at(i));
}
double ma = *min_element(m.begin(),m.end());
double sepp = h - (d * ma);
if(sepp < 0)cout << "0.0" << endl;
else cout << sepp << endl;
return 0;
}
|
//بسم الله الرحمن الرحيم
// -----> Author : N A Y E M
// -----> [ CSE-19 , CU ]
#include<bits/stdc++.h>
using namespace std ;
typedef long long ll;
typedef unsigned long long ull ;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int,int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef double dl;
//using u128 = __uint128_t;
#define el << '\n'
#define sz(v) ((int)(v).size())
#define PI 3.141592653589793238
#define _test_ int _ ; cin >> _ ; while( _-- )
#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define file() freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout)
ll gcd ( ll a, ll b ) { return __gcd ( a, b ) ; }
ll lcm ( ll a, ll b ) { return a * ( b / gcd ( a, b ) ) ; }
ll big_mod(ll base , ll power , ll mod){
ll ret=1;base%=mod;while(power){if(power&1)ret=ret*base%mod;base=base*base%mod;power>>=1;}return ret;}
ll mod_inverse(ll a , ll mod ){ return big_mod(a,mod-2,mod);}
ull POW(ll a , ll b){if(b==0) return 1;ull ret=1;while(b--)ret*=a;return ret;}
int dx[]={0,0,+1,-1,+1,-1,-1,+1} ;
int dy[]={+1,-1,0,0,+1,-1,+1,-1} ;
// ------------------>
const ll infLL = 1e15;
const int inf = 1e9;
const ll mod = 1e9+7;
const ll mX = 3e5+123;
// ------------------>
ll N,C,sum,total;
void _case_()
{
cin >> N >> C ;
vll v;
for(int i=0;i<N;i++)
{
ll a,b,c;
cin >> a >> b >> c;
sum+=(b-a+1)*c;
v.push_back({a,c});
v.push_back({b+1,-c});
}
sort(v.begin(),v.end());
for(int i=0;i<2*N;i++)
{
total += v[i].second ;
if(total>C)
sum -= (total-C)*(v[i+1].first-v[i].first);
}
cout << sum el;
}
int main( )
{
optimize() ;
//_test_
_case_() ;
return 0 ;
} | #pragma region header
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n)for(int i=0;i<(n);i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define int ll
#define each(i, a) for (auto &&i : (a))
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
using vvs = vector<vs>;
using vd = vector<ld>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using P = pair<int, int>;
using vp = vector<P>;
using int128 = __int128_t;//cin coutはできない
template <class T>
using greater_queue = priority_queue<T, vector<T>, greater<T>>;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int lcm(int a,int b){return a / gcd(a, b) * b;};
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
template <class T>
void CVEC(const T &v) {
int c = v.size() - 1;
for (int i = 0; i < c; i++) cout << v[i] << ' ';
if (c > -1) cout << v[c];
cout << '\n';
}
#pragma endregion header
signed main(){
int N, C; cin >> N >> C;
vector<pair<int, int>> ma;
rep(i,N) {
int a, b, c; cin >> a >> b >> c;
a--;
ma.emplace_back(a, c);
ma.emplace_back(b, -c);
}
sort(ALL(ma));
int ans = 0;
int now = 0;
int today = 0;
for(auto [x, y] : ma){
if(x != today){
ans += min(C, now) * (x - today);
today = x;
}
now += y;
}
cout << ans << endl;
} |
#define DEBUG 0
#include <bits/stdc++.h>
#define all(v) (v).begin(), (v).end()
#define pb push_back
#define eb emplace_back
#define rep(i,n) for(int i=0; i<(n); i++)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define REP(i, begin, end) for(int i = int(begin); i < int(end); i++)
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end())
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class T>using numr=std::numeric_limits<T>;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const int INF = 1e9;
const ll LLINF = 1e16;
const int mod = 1000000007;
const int mod2 = 998244353;
void debug_impl() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) { std::cerr << " " << head; debug_impl(tail...); }
#if DEBUG
#define debug(...)\
do {\
std::cerr << std::boolalpha << "[" << #__VA_ARGS__ << "]:";\
debug_impl(__VA_ARGS__);\
std::cerr << std::noboolalpha;\
} while (false)
#else
#define debug(...) {}
#endif
template < typename Container, typename Value = typename Container::value_type, std::enable_if_t<!std::is_same< Container, std::string >::value, std::nullptr_t> = nullptr>
std::istream& operator>> (std::istream& is, Container& v)
{ for (auto & x : v) { is >> x; } return is; }
template < typename Container, typename Value = typename Container::value_type, std::enable_if_t<!std::is_same< Container, std::string >::value, std::nullptr_t> = nullptr >
std::ostream& operator<< (std::ostream& os, Container const& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); it++)
{os << (it != v.begin() ? "," : "") << *it;}
return os << "}";
}
// make_v -> auto a = make_v<int>(n,m)
template< typename T = int64_t >
vector< T > make_v(size_t a) {
return vector< T >(a);
}
template< typename T, typename... Ts >
auto make_v(size_t a, Ts... ts) {
return vector< decltype(make_v< T >(ts...)) >(a, make_v< T >(ts...));
}
//ジェネッリックラムダ
template< typename F >
struct FixPoint : F {
FixPoint(F &&f) : F(forward< F >(f)) {}
template< typename... Args >
decltype(auto) operator()(Args &&... args) const {
return F::operator()(*this, forward< Args >(args)...);
}
};
template< typename F >
inline decltype(auto) MFP(F &&f) {
return FixPoint< F >{forward< F >(f)};
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
ll n;
cin >> n;
ll ans = 0;
ll a = 11,b=101,c=1001,d=10001,e=100001,f=1000001;
for(ll i = 1;i<=9;i++){
ll res = a*i;
if(n>=res) ans++;
}
for(ll i = 10;i<=99;i++){
ll res = b*i;
if(n>=res) ans++;
}
for(ll i = 100;i<=999;i++){
ll res = c*i;
if(n>=res) ans++;
}
for(ll i = 1000;i<=9999;i++){
ll res = d*i;
if(n>=res) ans++;
}
for(ll i = 10000;i<=99999;i++){
ll res = e*i;
if(n>=res) ans++;
}
for(ll i = 100000;i<=999999;i++){
ll res = f*i;
if(n>=res) ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T,class U> using P = pair<T,U>;
template<class T> using vec = vector<T>;
template<class T> using vvec = vector<vec<T>>;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
int main(){
ll n; cin >> n;
for(int i = 1; i <= 1e6; i++){
int dig = 0;
ll num = i;
while(!num==0) {
num /= 10;
dig++;
}
ll tmp = i + i * pow(10, dig);
// cout << tmp << endl;
if (n < tmp) {
cout << i - 1 << endl;
return 0;
}
}
} |
#include<ctime>
#include<queue>
#include<cstdio>
#include<cctype>
#include<cstring>
#define ll long long
const ll N=2e5+10;
using namespace std;
ll read() {
char c;
ll x=0,f=1;
while(!isdigit(c=getchar()))
f-=2*(c=='-');
while (isdigit(c)){
x=x*10+(c-48)*f;
c=getchar();
}
return x;
}
struct edge{
ll to,t,k,nxt;
edge(ll a=0,ll b=0,ll c=0,ll d=0){
to=a;
t=b;
k=c;
nxt=d;
}
};
edge e[N];
ll n,m,x,y,u,v,t,k;
ll tot,head[N],dis[N],vis[N];
void add(ll u,ll v,ll t,ll k){
e[++tot]=edge(v,t,k,head[u]);
head[u]=tot;
}
ll SPFA(){
queue<ll>q;
memset(dis,63,sizeof(dis));
dis[x]=0;
vis[x]=1;
q.push(x);
while(!q.empty()){
ll u=q.front();
q.pop();
vis[u]=0;
for(ll i=head[u];i;i=e[i].nxt){
ll v=e[i].to;
ll t=e[i].t;
ll k=e[i].k;
ll d=(dis[u]+k-1)/k*k;
if(dis[v]>d+t){
dis[v]=d+t;
if(!vis[v]){
vis[v]=1;
q.push(v);
}
}
}
}
if(dis[y]==dis[0])
return -1;
return dis[y];
}
int main() {
#ifndef ONLINE_JUDGE
freopen("E.in","r",stdin);
freopen("E.out","w",stdout);
#endif
clock_t t1=clock();
//--------
n=read();
m=read();
x=read();
y=read();
for(ll i=1;i<=m;++i){
u=read();
v=read();
t=read();
k=read();
add(u,v,t,k);
add(v,u,t,k);
}
printf("%lld",SPFA());
//--------
clock_t t2=clock();
fprintf(stderr,"time:%0.3lfs",1.0*(t2-t1)/CLOCKS_PER_SEC);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
void DFS(int u, vector<set<int>>& edges, vector<set<int>>& to) {
while (!edges[u].empty()) {
int v = *(edges[u].begin());
// u -> v
edges[u].erase(v);
edges[v].erase(u);
to[u].insert(v);
DFS(v, edges, to);
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<int> a(M), b(M);
for (int i = 0; i < M; ++i) {
cin >> a[i] >> b[i];
--a[i];
--b[i];
}
vector<int> c(N);
for (int i = 0; i < N; ++i) {
cin >> c[i];
}
vector<int> ans(M, 0); // 0 : <-, 1 : ->
vector<set<int>> edges(N);
for (int i = 0; i < M; ++i) {
if (c[a[i]] < c[b[i]]) {
ans[i] = 0;
} else if (c[a[i]] > c[b[i]]) {
ans[i] = 1;
} else {
edges[a[i]].insert(b[i]);
edges[b[i]].insert(a[i]);
}
}
vector<set<int>> to(N);
for (int i = 0; i < N; ++i) {
DFS(i, edges, to);
}
for (int i = 0; i < M; ++i) {
if (to[a[i]].count(b[i])) {
ans[i] = 1;
}
}
for (int i = 0; i < M; ++i) {
if (ans[i] == 0) {
cout << "<-\n";
} else {
cout << "->\n";
}
}
return 0;
} |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using std::cout;
using std::cin;
using std::endl;
using ll=long long;
using ld=long double;
ll I=1167167167167167167;
ll Q=1e9+7;
#define rep(i,a) for (ll i=0;i<a;i++)
template<class T> using _pq = priority_queue<T, vector<T>, greater<T>>;
template<class T> ll LB(vector<T> &v,T a){return lower_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> ll UB(vector<T> &v,T a){return upper_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> bool chmin(T &a,const T &b){if(a>b){a=b;return 1;}else return 0;}
template<class T> bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}else return 0;}
template<class T> void So(vector<T> &v) {sort(v.begin(),v.end());}
template<class T> void Sore(vector<T> &v) {sort(v.begin(),v.end(),[](T x,T y){return x>y;});}
template<class T> void print_tate(vector<T> &v) {rep(i,v.size()) cout<<v[i]<<"\n";}
void yneos(bool a){if(a) cout<<"Yes"<<"\n"; else cout<<"No"<<"\n";}
//おちこんだりもしたけれど、私はげんきです。
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin>>N;
ll cen[4];
rep(i,4) cen[i]=0;
vector<ll> A(N),B(N),C(N),D(N);
rep(i,N){
cin>>A[i]>>B[i];
A[i]*=N;
B[i]*=N;
cen[0]+=A[i];
cen[1]+=B[i];
}
rep(i,N){
cin>>C[i]>>D[i];
C[i]*=N;
D[i]*=N;
cen[2]+=C[i];
cen[3]+=D[i];
}
rep(i,4) cen[i]/=N;
rep(i,N){
A[i]-=cen[0];
B[i]-=cen[1];
C[i]-=cen[2];
D[i]-=cen[3];
}
if(A[0]*A[0]+B[0]*B[0]==0){
swap(A[0],A[1]);
swap(B[0],B[1]);
}
set<pair<int,int>> s;
ll L=A[0]*A[0]+B[0]*B[0];
rep(i,N) s.insert({C[i]*L,D[i]*L});
bool T=false;
vector<vector<ll>> q=
{
{A[0],B[0]},
{B[0]*-1,A[0]}
};
//rep(i,N) cout<<A[i]<<" "<<B[i]<<" "<<C[i]<<" "<<D[i]<<endl;
rep(i,N){
if(L!=C[i]*C[i]+D[i]*D[i]) continue;
bool U=true;
vector<vector<ll>> p(2,vector<ll>(2));
vector<vector<ll>> r=
{
{C[i],D[i]*-1},
{D[i],C[i]}
};
rep(a,2) rep(b,2) rep(c,2){
p[a][b]+=q[a][c]*r[c][b];
}
/*rep(i,2){
rep(j,2) cout<<p[i][j]<<" ";
cout<<endl;
}*/
rep(j,N){
ll X=0,Y=0;
X=A[j]*p[0][0]+B[j]*p[0][1];
Y=A[j]*p[1][0]+B[j]*p[1][1];
if( !s.count({X,Y}) ){
U=false;
break;
}
}
T|=U;
}
yneos(T);
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(),(x).end()
#define COUT(x) cout<<(x)<<"\n"
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define REP(i,n) for(int i=0;i<n;i++)
#define YES(x) cout<<(x?"YES":"NO")<<"\n"
#define Yes(x) cout<<(x?"Yes":"No")<<"\n"
#define dump(x) cout<<#x<<" = "<<(x)<<"\n"
#define endl "\n"
using G = vector<vector<int>>;
using M = map<int,int>;
using P = pair<int,int>;
using PQ = priority_queue<int>;
using PQG = priority_queue<int,vector<int>,greater<int>>;
using V = vector<int>;
using ll = long long;
using edge = struct { int to; int cost; };
template<class T>bool chmax(T &a,const T &b) {if(a<b){a=b; return 1;} return 0;}
template<class T>bool chmin(T &a,const T &b) {if(b<a){a=b; return 1;} return 0;}
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int main() {
IOS;
int h,w; cin >> h >> w;
int a[h][w];
int mina = INF;
REP(i,h) REP(j,w){
cin >> a[i][j];
chmin(mina,a[i][j]);
}
int ans = 0;
REP(i,h) REP(j,w){
ans += a[i][j] - mina;
}
COUT(ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c; cin >> c;
cout << (c-1) / 100 + 1 << endl;
} | /*
ID: anonymo14
TASK: wormhole
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pair<int,int>> vpii;
typedef vector<pair<ll,ll>> vpll;
int solve() {//267
int num;
cin>>num;
int rem = num%100;
num/=100;
if(rem)num++;
return num;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t=1;
// cin>>t;
// prefill();
while(t--) {
// cout<<(solve()?"Yes":"No")<<endl;
// printf("%.6lf\n",solve());
cout<<solve()<<endl;
// solve();
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+5;
char s[maxn],t[2][maxn],st[maxn],k[maxn];
int n,C,tot,p[maxn],sum[maxn],top,K,cnt[2];
int main(){
scanf("%s",s+1);
n=strlen(s+1);
for(int i=1;i<=n;i++){
if(s[i]=='R')tot^=1,++C;
else{
t[tot][++cnt[tot]]=s[i];
}
}
if(C%2==0){
for(int i=cnt[1];i;i--)k[++K]=t[1][i];
for(int i=1;i<=cnt[0];i++)k[++K]=t[0][i];
}
else{
for(int i=cnt[0];i;i--)k[++K]=t[0][i];
for(int i=1;i<=cnt[1];i++)k[++K]=t[1][i];
}
for(int i=1;i<=K;i++){
st[++top]=k[i];
while(top>=2&&st[top]==st[top-1])top-=2;
}
for(int i=1;i<=top;i++)putchar(st[i]);
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <string>
#include <stdlib.h>
#include <cmath>
#include <algorithm>
#include <numeric>
#include <climits>
#include <iomanip>
#include <deque>
#include <limits>
#include <map>
#include <set>
#include <functional>
using namespace std;
int main()
{
uint64_t X, Y, A, B;
cin >> X >> Y >> A >> B;
uint64_t exp = 0;
while (true) {
if (X > (B / (A - 1))) break;
X *= A;
if (X >= Y) {
cout << exp << endl;
return 0;
}
exp++;
}
if ((Y - X) % B == 0) {
cout << exp + (Y - X) / B - 1 << endl;
}
else {
cout << exp + (Y - X) / B << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long long ll;
const int N = 100;
const int S = N * N;
const int P = 998244353;
inline int norm(int x) {if (x >= P) x -= P; return x;}
inline int reduce(int x) {if (x < 0) x += P; return x;}
inline void add(int &x, int y) {if ((x += y) >= P) x -= P;}
inline void sub(int &x, int y) {if ((x -= y) < 0) x += P;}
int mpow(int b, int p) {
int r = 1;
for (; p; p >>= 1, b = (ll)b * b % P)
if (p & 1) r = (ll)r * b % P;
return r;
}
int fct[N + 5];
int f[N + 5][N + 5][2*S + 5], w[N + 5], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &w[i]);
fct[0] = 1; for (int i = 1; i <= n; i++) fct[i] = (ll)fct[i - 1] * i % P;
f[0][0][S] = 1;
for (int i = 0; i < n; i++) for (int j = 0; i + j < n; j++) {
int p = w[i + j + 1];
for (int k = p; k <= (S << 1); k++) add(f[i + 1][j][k], f[i][j][k - p]);
for (int k = (S << 1) - p; k >= 0; k--) add(f[i][j + 1][k], f[i][j][k + p]);
}
int ans = 0;
for (int i = 0; i <= n; i++) ans = (ans + (ll)fct[i] * fct[n - i] % P * f[i][n - i][S]) % P;
printf("%d\n", ans);
} | #include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <cmath>
#include <numeric>
#include <functional>
#include <cassert>
#define debug_value(x) cerr << "line" << __LINE__ << ":<" << __func__ << ">:" << #x << "=" << x << endl;
#define debug(x) cerr << "line" << __LINE__ << ":<" << __func__ << ">:" << x << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
class ModInt{
public:
ll v;
ModInt(ll _v = 0){
if(_v < 0) _v = (v%MOD)+MOD;
if(_v >= MOD) _v %= MOD;
v = _v;
}
ModInt operator+(ll n){
return ModInt((v+n)%MOD);
}
ModInt operator-(ll n){
return ModInt((v-n+MOD)%MOD);
}
ModInt operator*(ll n){
if(n >= MOD) n %= MOD;
return ModInt((v*n)%MOD);
}
ModInt operator/(ll n){
return ModInt((ModInt(n).inv()*v).v%MOD);
}
void operator+=(ll n){
v = (v+n)%MOD;
}
void operator-=(ll n){
v = (v-n+MOD)%MOD;
}
void operator*=(ll n){
v = (v*n+MOD)%MOD;
}
ModInt operator+(ModInt n){
return ModInt((v+n.v)%MOD);
}
ModInt operator-(ModInt n){
return ModInt((v-n.v+MOD)%MOD);
}
ModInt operator*(ModInt n){
return ModInt((v*n.v)%MOD);
}
ModInt operator/(ModInt n){
return ModInt((n.inv()*v).v%MOD);
}
void operator+=(ModInt n){
v = (v+n.v)%MOD;
}
void operator-=(ModInt n){
v = (v-n.v+MOD)%MOD;
}
void operator*=(ModInt n){
v = (v*n.v)%MOD;
}
void operator=(ModInt n){
v = n.v;
}
bool operator==(ModInt n){
return v == n.v;
}
bool operator!=(ModInt n){
return v != n.v;
}
void operator=(ll n){
v = n%MOD;
}
ModInt inv(){
if(v == 1) return ModInt(1);
else return ModInt(MOD-ModInt(MOD%v).inv().v*(MOD/v)%MOD);
}
};
ostream& operator<<(ostream& os, const ModInt& m){
os << m.v;
return os;
}
istream & operator >> (istream &in, ModInt &m){
in >> m.v;
return in;
}
ModInt pow(ModInt a, ll n) {
assert(n >= 0);
ModInt ans = 1;
ModInt tmp = a;
for (int i = 0; i <= 60; i++) {
ll m = (ll)1 << i;
if (m & n) {
ans *= tmp;
}
tmp *= tmp;
}
return ans;
}
#define N_MAX 200002
ModInt inv[N_MAX],fac[N_MAX],finv[N_MAX];
void init(){
fac[0]=1;fac[1]=1;
finv[0]=1;finv[1]=1;
inv[1]=1;
for(int i=2;i<N_MAX;i++){
inv[i]=ModInt(MOD)-inv[MOD%i]*(MOD/i);
fac[i]=fac[i-1]*(ll) i;
finv[i]=finv[i-1]*inv[i];
}
}
using mint = ModInt;
mint dp[105][105][10005];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(10) << fixed;
init();
int n; cin >> n;
vector<int> w(n);
for(int i = 0; i < n; i++) cin >> w[i];
int sum = accumulate(w.begin(), w.end(), 0);
dp[0][0][0] = 1;
for(int i = 0; i < n; i++){
for(int j = 0; j <= i; j++){
for(int k = 0; k <= sum; k++){
if(dp[i][j][k].v == 0) continue;
dp[i+1][j][k] += dp[i][j][k];
dp[i+1][j+1][k+w[i]] += dp[i][j][k];
}
}
}
if(sum%2 != 0){
cout << 0 << endl;
return 0;
}
mint ans = 0;
for(int i = 0; i <= n; i++){
ans += dp[n][i][sum/2]*fac[i]*fac[n-i];
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long R,x,y;
cin>>R>>x>>y;
float D = sqrt(x*x+y*y);
if(D==R)
{
cout<<1<<endl;
}
else if(D<=R+R)
{
cout<<2<<endl;
}
else cout<<ceil(D/R)<<endl;
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
#define ALL(l) (l).begin(),(l).end()
#define rep(i,n) for(ll (i)=0;(i)<(n);(i)++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
using namespace std;
//const ll mod = 998244353;
//const ll maxn = 1000000000;
//const ll mod = 1000000007;
//---------------------------------------------------------------------------------------------------
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vll = vector<ll>; // intの1次元の型に vi という別名をつける
using vvll = vector<vll>; // intの2次元の型に vvi という別名をつける
using vs = vector<string>; // stringの1次元の型に vs という別名をつける
using pll = pair<ll, ll>; // これ以降 pii という型名はpair<ll, ll> と同じ意味で使える
//---------------------------------------------------------------------------------------------------
template <typename T>
void chmax(T &a, const T& b) {
if (a < b) {
a = b; // aをbで更新
}
}
template <typename T>
void chmin(T &a, const T& b) {
if (a > b) {
a = b; // aをbで更新
}
}
int main() {
//cout << fixed << setprecision(10);
ll r;
cin>>r;
double x,y;
cin>>x>>y;
double rxy=sqrt(x*x+y*y);
//cout<<rxy<<endl;
if(r==rxy)cout<<1<<endl;
else if(r>rxy)cout<<2<<endl;
else{
ll dis=0;
rep(i,100000000){
if(dis>=rxy){
cout<<i<<endl;
return 0;
}
dis+=r;
}
}
} |
/*
author : TAPAN SAVANI
codeforces : savanitapan2001
codechef : savanitapan17
*/
/*
------------------------------------------------------------------------
░██╗░░░░░░░██╗░█████╗░██████╗░██╗░░██╗ ██╗░░██╗░█████╗░██████╗░██████╗░
░██║░░██╗░░██║██╔══██╗██╔══██╗██║░██╔╝ ██║░░██║██╔══██╗██╔══██╗██╔══██╗
░╚██╗████╗██╔╝██║░░██║██████╔╝█████═╝░ ███████║███████║██████╔╝██║░░██║
░░████╔═████║░██║░░██║██╔══██╗██╔═██╗░ ██╔══██║██╔══██║██╔══██╗██║░░██║
░░╚██╔╝░╚██╔╝░╚█████╔╝██║░░██║██║░╚██╗ ██║░░██║██║░░██║██║░░██║██████╔╝
░░░╚═╝░░░╚═╝░░░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝ ╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝╚═════╝░
------------------------------------------------------------------------
*/
#include <bits/stdc++.h>
using namespace std;
#define HAPPY_CODING \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define mp make_pair
#define Debug(x) cout << #x " = " << (x) << endl
#define SORT(a) sort(a.begin(), a.end())
#define SORTR(a) sort(a.rbegin(), a.rend())
#define mod 1000000007
#define pi 3.141592653589793238
#define ll long long int
#define ull unsigned long long
#define be begin()
#define en end()
#define FOR(i, a, b) for (long long int i = a; i < b; i++)
#define FORI(i, a, b) for (int i = a; i >= b; i--)
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;
typedef vector<PI> VPI;
int main()
{
HAPPY_CODING;
int A, B;
cin >> A >> B;
for (int c = B;; c--)
if ((A + c - 1) / c < B / c)
{
cout << c << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
template <class c, class cmp = less<c> > using ordered_set = tree<c, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
template<class T> ostream& operator<<(ostream &os, vector<T> V) {os << "[ "; for(auto v : V) os << v << " "; return os << "]";}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {return os << "(" << P.first << "," << P.second << ")";}
template <typename T,typename U>pair<T,U> operator+(const pair<T,U> & l,const std::pair<T,U> & r) { return {l.first+r.first,l.second+r.second};}
typedef long long int ll;
const ll mod = 1e9 + 7;
const ll maxn = 5e6 + 5;
#define endl '\n'
#define ld long double
#define int ll
#define all(x) (x).begin(),(x).end()
const ll md = (ll) 1e9 + 7;
inline ll add(ll a, ll b) {
a += b;
if (a >= md) a -= md;
return a;
}
inline ll sub(ll a, ll b) {
a -= b;
if (a < 0) a += md;
return a;
}
inline ll mul(ll a, ll b) {
return (ll) ((long long)((a%md) * (b%md)) % md);
}
inline ll power(ll a, long long b) {
ll res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline ll inv(ll a) {
a %= md;
if (a < 0) a += md;
ll b = md, u = 0, v = 1;
while (a) {
ll t = b / a;
b -= t * a; swap(a, b);
u -= t * v; swap(u, v);
}
assert(b == 1);
if (u < 0) u += md;
return u;
}
vector<int> fact(maxn+5);
void init (int n)
{
fact[0] = 1;
for(int i = 1;i<=n;i++)
{
fact[i] = mul(i,fact[i-1]);
}
}
int nck(int n,int k)
{
return mul(fact[n],mul(inv(fact[k]),inv(fact[n-k])));
}
int32_t main(){
IOS
init(5000000);
int n, m;
cin >> n >> m;
vector<int> a(n);
int k = 1;
for(int i = 0;i<n;i++){
cin >> a[i];
m -= a[i];
k += a[i] + 1;
}
if(m < 0){
cout << 0 << endl;
return 0;
}
int num = k - 1 + m;
int den = k - 1;
int ans = 1;
for(int i = 0;i<den;i++){
ans = mul(ans, num - i);
}
ans = mul(ans, inv(fact[den]));
cout << ans << endl;
} |
#include "bits/stdc++.h"
#define int long
#define MOD 1000000007
#define PI 3.14159265359
#define fi first
#define se second
#define pb push_back
#define se second
#define vi vector<int>
#define vvi vector<vi>
#define len(x) (int)x.size()
#define pi pair<int,int>
#define vpi vector<pi>
#define maxheap priority_queue<int>
#define minheap priority_queue<int,vi,greater<int>>
#define bits(x) __builtin_popcount(x)
#define fixed(x) cout<<fixed<<setprecision(x);
using namespace std;
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {return os << "(" << P.first << "," << P.second << ")";}
template<class T> ostream& operator<<(ostream &os, vector<T> V) {for(auto v : V) os << v << " ";return os<<"";}
template<class T> ostream& operator<<(ostream &os, set<T> S){os << "{ ";for(auto s:S) os<<s<<" ";return os<<"}";}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){os << "{ ";for(auto s:S) os<<s<<" ";return os<<"}";}
template<class T> ostream& operator<<(ostream &os, multiset<T> S){os << "{ ";for(auto s:S) os<<s<<" ";return os<<"}";}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {os << "{ ";for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";return os<<"}";}
template<class L, class R> ostream& operator<<(ostream &os, unordered_map<L,R> M) {os << "{ ";for(auto m:M) os<<"("<<m.fi<<":"<<m.se<<") ";return os<<"}";}
template<typename T> istream& operator>>(istream& in,vector<T> &a){for(int i=0;i<len(a);i++)in>>a[i];return in;}
template<typename T1, typename T2> istream& operator>>(istream& in,pair<T1,T2>&p){in>>p.fi>>p.se;return in;}
template<typename T>
void print(T t){cout<<(t);cout<<'\n';}
template<typename T, typename... Args>
void print(T t, Args... args){cout << (t) <<' ';print(args...);}
inline int mul(int a,int b){return (1LL*a*b)%MOD;}
inline void add(int &x,int b){x += b;if(x>=MOD)x-=MOD;}
inline int bpow(int a,int b){int rt=1;while(b>0){if(b&1)rt=mul(rt,a);a=mul(a,a);b>>=1;}return rt;}
int gcd(int a,int b){if(a==0)return b;return gcd(b%a,a);}
const int N = 2e5+1;
int n,q,c[N],tp,a,b,par[N],sz[N];
map<int,map<int,int>>d;
int find(int x){
if(par[x]==x)return x;
return find(par[x]);
}
void unite(int x,int y){
int p1=find(x),p2=find(y);
if(p1==p2)return;
if(sz[p1]>sz[p2]){
sz[p1] += sz[p2];
par[p2] = p1;
// d[p1][c[y]]++;
for(auto p:d[p2]){
d[p1][p.fi]+=p.se;
}
}else{
sz[p2] += sz[p1];
par[p1] = p2;
// d[p2][c[x]]++;
for(auto p:d[p1]){
d[p2][p.fi]+=p.se;
}
}
}
int32_t main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin>>n>>q;
for (int i = 1; i <= n; ++i)
{
cin>>c[i];
par[i] = i,sz[i] = 1;
d[i][c[i]]++;
}
for(int i=0;i<q;i++){
cin>>tp>>a>>b;
if(tp==1){
unite(a,b);
// print(d);
}else{
print(d[find(a)][b]);
}
}
return 0;
} | #include <iostream>
#include <map>
#include <vector>
class disjoint_set {
std::vector<int> parent;
public:
std::vector<std::map<int,int>> mp;
disjoint_set(int n): parent(n,-1), mp(n) {};
int find(int x) {
if (parent[x] < 0) return x;
return parent[x] = find(parent[x]);
}
void fusion(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (parent[x] > parent[y]) std::swap(x, y);
for (auto c: mp[y]) {
mp[x][c.first] += c.second;
}
parent[x] += parent[y];
parent[y] = x;
}
};
int main() {
int n, q;
std::cin >> n >> q;
disjoint_set d(n);
for (int i {0}; i<n; ++i) {
int c;
std::cin >> c;
d.mp[i][c] = 1;
}
for (int i {0}; i<q; ++i) {
int type;
std::cin >> type;
if (type == 1) {
int a, b;
std::cin >> a >> b;
--a;
--b;
d.fusion(a, b);
} else {
int x, y;
std::cin >> x >> y;
--x;
x = d.find(x);
std::cout << d.mp[x][y] << std::endl;
}
}
}
|
#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#define endl '\n';
#define sz(s) int(s.size())
#define all(v) ((v).begin()),((v).end())
#define allr(v) ((v).rbegin()), ((v).rend())
#define mem(x,y) memset(x,y,sizeof(x))
#define Ceil(x,y) ((x+y-1)/y)
typedef long long ll;
typedef double dl;
using namespace std;
void Selim()
{
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
/***************************************************/
vector<vector<int>>adjList;
vector<int>color, dis, ok;
bool vis[int(1e5 + 10)];
set<int>st;
void DFS(int node){
vis[node] = 1;
if (!ok[color[node]]){
st.insert(node);
}
ok[color[node]]++;
for (auto child : adjList[node]){
if (vis[child])continue;
DFS(child);
}
ok[color[node]]--;
}
void solve(){
int n;
cin >> n;
adjList.resize(1e5 + 5);
color.resize(1e5 + 5);
dis.resize(n + 1, 1e9);
ok.resize(1e5 + 5, 0);
dis[1] = 0;
for (int i = 1; i <= n; i++){
cin >> color[i];
}
for (int i = 1; i < n; i++){
int u, v;
cin >> u >> v;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
DFS(1);
st.insert(1);
for (auto it : st){
cout << it << endl;
}
}
int main()
{
Selim();
int t = 1;
//cin >> t;
while (t--)
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (ll i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
using ll = long long;
using ld=long double;
using vin=vector<int>;
using vvin=vector<vin>;
using vll=vector<ll>;
using vvll=vector<vll>;
using vst=vector<string>;
using P = pair<ll,ll>;
using vp=vector<P>;
using vvp=vector<vp>;
const int inf=1e9+7;
const ll INF=9e18/2;
const long double PI = acosl(-1.0);
const long double EPS=1e-10;
template <typename T> bool chmin(T &a, const T& b){if(a > b){a = b;return true;}return false;}
template <typename T> bool chmax(T &a, const T& b){if(a < b){a = b;return true;}return false;}
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
const int dx[8] = {0,0,1,-1,1,1,-1,-1};
const int dy[8] = {1,-1,0,0,1,-1,1,-1};
template<typename T>void vecout(const vector<T> &a){int n=a.size();rep(i,0,n)cout<<a[i]<<(i==n-1 ? "":" ");cout<<endl;}
int f(vin &a,int x){
int ret=0;
auto it=upper_bound(all(a),x);
ret=it-a.begin();
return ret;
}
vvin cdp;//positive
vvin cdn;//negative
vin c;
vector<vector<int>> g;
vector<int> in,out;
int counter;
void euler_tour(int now,int par=-1){
cdp[c[now]].pb(counter);
in[now]=counter++;
for(int to:g[now])if(to!=par)euler_tour(to,now);
cdn[c[now]].pb(counter);
out[now]=counter++;
}
int main(){//cout<<fixed<<setprecision(20);
cdp.resize(110000);
cdn.resize(110000);
int n;
cin>>n;
c.resize(n);
rep(i,0,n)cin>>c[i];
g.resize(n);
in.resize(n);
out.resize(n);
rep(i,0,n-1){
int a,b;
cin>>a>>b;
a--;b--;
g[a].pb(b);
g[b].pb(a);
}
euler_tour(0);
rep(i,0,n){
int pc=f(cdp[c[i]],in[i]);
int nc=f(cdn[c[i]],in[i]);
if(pc-nc==1)cout<<i+1<<endl;
}
} |
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#include<random>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (int)(Y);++(X))
#define reps(X,S,Y) for (int (X) = (int)(S);(X) < (int)(Y);++(X))
#define rrep(X,Y) for (int (X) = (int)(Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (int)(Y)-1;(X) >= (int)(S);--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl
#define NL <<"\n"
#define cauto const auto
using namespace std;
using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
template<class T> using vv=vector<vector<T>>;
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
//#undef NUIP
#ifdef NUIP
#include "benri.h"
#else
#define out(args...)
#endif
void ouT(ll x,int d=3){auto re=to_string(x);if((int)re.size()>d) re=x>0?"oo":"-oo";cout<<string(d-re.size(),' ')<<re<<",";}
#ifdef __cpp_init_captures
template<typename T>vector<T> table(int n, T v){ return vector<T>(n, v);}
template <class... Args> auto table(int n, Args... args){auto val = table(args...); return vector<decltype(val)>(n, move(val));}
#endif
template<class A,class B> pair<A,B> operator+(const pair<A,B> &p,const pair<A,B> &q){ return {p.X+q.X,p.Y+q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator+=(pair<A,B> &p,const pair<C,D> &q){ p.X+=q.X; p.Y+=q.Y; return p;}
template<class A,class B> pair<A,B> operator-(const pair<A,B> &p,const pair<A,B> &q){ return {p.X-q.X,p.Y-q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator-=(pair<A,B> &p,const pair<C,D> &q){ p.X-=q.X; p.Y-=q.Y; return p;}
template<class A,class B> istream& operator>>(istream &is, pair<A,B> &p){ is>>p.X>>p.Y; return is;}
template<class T=ll> T read(){ T re; cin>>re; return move(re);}
template<class T=ll> T read(const T &dec){ T re; cin>>re; return re-dec;}
template<class T=ll> vector<T> readV(const int sz){ vector<T> re(sz); for(auto &x:re) x=read<T>(); return move(re);}
template<class T=ll> vector<T> readV(const int sz, const T &dec){ vector<T> re(sz); for(auto &x:re) x=read<T>(dec); return move(re);}
vv<int> readG(const int &n,const int &m){ vv<int> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); g[a].pb(b); g[b].pb(a);} return move(g);}
vv<int> readG(const int &n){ return readG(n,n-1);}
#define TT cauto TTT=read();rep(_,TTT)
const ll MOD=1e9+7; //998244353;
int main(){
ios_base::sync_with_stdio(false); cin.tie(0);
cout<<fixed<<setprecision(0);
cauto a=read();
cauto b=read();
cauto c=read();
cout<<(a*a+b*b<c*c?"Yes":"No") NL;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// Compile with "(g++) -std=c++11 -Wall -Wextra -Wconversion -Wshadow -Dcychien"
#ifdef cychien
#define debug(...) do {\
fprintf(stderr, "%s - %d : (%s) = ", __PRETTY_FUNCTION__, __LINE__, #__VA_ARGS__);\
_DO(__VA_ARGS__);\
}while(0)
template<typename I> void _DO(I&&x) {cerr << x << '\n';}
template<typename I, typename ...T> void _DO(I&&x,T&&...tail) {cerr << x << ", "; _DO(tail...);}
#define IOS
#else
#define debug(...)
#define IOS ios_base::sync_with_stdio(0);cin.tie(0)
#endif
#define FOR(i, n) for(int i = 0; i < n; i++)
#define FOR1(i, n) for(int i = 1; i <= n; i++)
#define pb push_back
#define mp make_pair
#define X first
#define Y second
#define SZ(x) (ll)x.size()
#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort(ALL(x))
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
const int NF = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const ll MOD = 1e9 + 7;
const ld PI = 3.14159265358979323846264338327950288;
#define int ll
ll ext_gcd(ll a, ll b, ll &x, ll &y) {
if(b == 0) {
x = 1; y = 0;
return a;
}
int ret = ext_gcd(b, a%b, y, x);
y -= x*(a / b);
return ret;
}
class ChineseRemainderTheorem {
typedef long long vlong;
typedef pair<vlong,vlong> pll;
/** CRT Equations stored as pairs of vector. See addEqation()*/
vector<pll> equations;
public:
void clear() {
equations.clear();
}
/** Add equation of the form x = r (mod m)*/
void addEquation( vlong r, vlong m ) {
equations.push_back({r, m});
}
pll solve() {
if (equations.size() == 0) return {-1,-1}; /// No equations to solve
vlong a1 = equations[0].first;
vlong m1 = equations[0].second;
a1 %= m1;
/** Initially x = a_0 (mod m_0)*/
/** Merge the solution with remaining equations */
for ( int i = 1; i < equations.size(); i++ ) {
vlong a2 = equations[i].first;
vlong m2 = equations[i].second;
vlong g = __gcd(m1, m2);
if ( a1 % g != a2 % g ) return {-1,-1}; /// Conflict in equations
/** Merge the two equations*/
ll p, q;
ext_gcd(m1/g, m2/g, p, q);
vlong mod = m1 / g * m2;
vlong x = ( (__int128)a1 * (m2/g) % mod *q % mod + (__int128)a2 * (m1/g) % mod * p % mod ) % mod;
/** Merged equation*/
a1 = x;
if ( a1 < 0 ) a1 += mod;
m1 = mod;
}
return {a1, m1};
}
};
main() {
IOS;
int t;
cin >> t;
ChineseRemainderTheorem crt;
while (t--){
ll res = -1;
ll x, y, p, q;
cin >> x >> y >> p >> q;
for (ll i = 0; i < y; i++){
for (ll j = 0; j < q; j++){
crt.clear();
crt.addEquation(x + i, 2 * x + 2 * y);
crt.addEquation(p + j, p + q);
pll ans = crt.solve();
if (ans.X != -1){
if (res == -1)
res = ans.X;
else
res = min(res, ans.X);
}
}
}
if (res == -1){
cout << "infinity\n";
}
else {
cout << res << '\n';
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
// using namespace __gnu_pbds;
#pragma GCC optimize("O3")
#ifdef LOCAL
#include "/Users/lbjlc/Desktop/coding/debug_utils.h"
#else
#define print(...) ;
#define printn(...) ;
#define printg(...) ;
#define fprint(...) ;
#define fprintn(...) ;
#endif
#define rep(i, a, b) for(auto i = (a); i < (b); i++)
#define rrep(i, a, b) for(auto i = (a); i > (b); i--)
#define all(v) (v).begin(), (v).end()
#define pb push_back
// #define mp make_pair
#define fi first
#define se second
#define maxi(x, y) x = max(x, y)
#define mini(x, y) x = min(x, y)
// long long fact(long long n) { if(!n) return 1; return n*fact(n-1); }
// #define endl '\n'
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int get_random() {
static uniform_int_distribution<int> dist(0, 1e9 + 6);
return dist(rng);
}
#define solve_testcase int T;cin>>T;for(int t=1;t<=T;t++){solve(t);}
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pdd> vpdd;
typedef vector<long long> vll;
#define bd(type,op,val) bind(op<type>(), std::placeholders::_1, val)
template<class T>
void make_unique(T & v) {
sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());
}
int geti() { int x; cin >> x; return x; }
long long getll() { long long x; cin >> x; return x; }
double getd() { double x; cin >> x; return x; }
// pair<int, int> a(geti(), geti()) does not work
// pair<int, int> a({geti(), geti()}) works, since it uses initializer.
const int MAXN = 3e5 + 100;
void solve(int tt) {
// cout<<"Case #"<<tt<<": ";
}
int main(int argc, char * argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
// solve_testcase;
int n;
cin>>n;
string s;
cin>>s;
const string s110="110";
ll tot=1e10;
if(n==1) {
if(s[0]=='0') cout<<tot<<endl;
else cout<<2*tot<<endl;
return 0;
}
if(s[0]=='0') s = "11"+s;
else if(s[1]=='0') s = "1"+s;
n=s.size();
if(s[n-1]=='1') {
if(s[n-2]=='1') s+='0';
else s += "10";
}
print(s);
if(s.size()%3) {
cout<<0<<endl;
return 0;
}
int ok=1;
rep(i,0,n) {
if(s[i]!=(i%3==2?'0':'1'))
ok=0;
}
if(!ok) {
cout<<0<<endl;
return 0;
}
cout<<tot-ll(s.size())/3+1<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
// #define LOCAL
typedef long long ll;
#ifdef LOCAL
constexpr int DEBUG = 1;
#else
constexpr int DEBUG = 0;
#endif
const int N = 505;
const int MOD = 998244353;
char s[N][N], t[N + N];
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i)
scanf("%s", s[i] + 1);
for(int i = 1; i <= n; ++i){
for(int j = 1; j <= m; ++j){
if(s[i][j] == 'B'){
if(t[i + j] == 'R'){
cout << 0 << endl; return;
}
t[i + j] = 'B';
}
if(s[i][j] == 'R'){
if(t[i + j] == 'B'){
cout << 0 << endl; return;
}
t[i + j] = 'R';
}
}
}
ll ans = 1;
for(int i = 2; i <= n + m; ++i){
if(t[i] == 0) ans = ans * 2 % MOD;
}
cout << ans << endl;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
cout << "start Debug" << endl;
#endif
int _ = 1;
// cin >> _;
for(int i = 1; i <= _; ++i) solve();
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef double lf;
#define Rl(x) scanf ("%lld", &x)
#define Ri(x) scanf ("%d", &x)
#define Rf(x) scanf ("%lf", &x)
const int maxn = 2e5 + 5, mod = 998244353;
int n, m; LL a[maxn], tmp[maxn], ans[maxn];
inline void D(LL *a, LL *b) {
memset(tmp, 0, sizeof tmp);
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= m / i; ++j)
tmp[i * j] = (tmp[i * j] + a[i] * b[j] % mod) % mod;
}
memcpy(a, tmp, sizeof tmp);
}
void work() {
for (int i = 1; i <= m; ++i) a[i] = 1;
ans[1] = 1;
while (n) {
if (n & 1) D(ans, a);
D(a, a);
n >>= 1;
}
for (int i = 1; i <= m; ++i) ans[i] = (ans[i - 1] + ans[i]) % mod;
}
int main() {
Ri(n); Ri(m);
work();
cout << ans[m] << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
namespace IO
{
const int buf_size=1<<20;
char buf[buf_size],*S,*T;
inline char read_char()
{
if(S==T)
T=(S=buf)+fread(buf,1,buf_size,stdin);
return S!=T?*(S++):EOF;
}
bool flag_EOF;
inline int read_int()
{
char c=read_char();
bool neg=false;
while(c<'0'||c>'9')
{
if(c==EOF)
{
flag_EOF=true;
return 0;
}
neg=(c=='-');
c=read_char();
}
int x=0;
while(c>='0'&&c<='9')
{
x=x*10+(c^48);
c=read_char();
}
return neg?-x:x;
}
inline void read_string(char *s)
{
char c=read_char();
while(c<'a'||c>'z')
{
if(c==EOF)
{
flag_EOF=true;
return;
}
c=read_char();
}
while(c>='a'&&c<='z')
{
*(s++)=c;
c=read_char();
}
*s='\0';
}
inline double read_double()
{
char c=read_char();
bool neg=false;
while(c<'0'||c>'9')
{
if(c==EOF)
{
flag_EOF=true;
return 0;
}
neg=(c=='-');
c=read_char();
}
double x=0;
while(c>='0'&&c<='9')
{
x=x*10+(c^48);
c=read_char();
}
if(c=='.')
{
c=read_char();
double eps=1;
while(c>='0'&&c<='9')
{
eps*=0.1;
x+=eps*(c^48);
c=read_char();
}
}
return neg?-x:x;
}
char fw[buf_size];
int pw;
inline void flush()
{
fwrite(fw,1,pw,stdout);
pw=0;
}
inline void write_char(char x)
{
if(pw==buf_size)
flush();
fw[pw++]=x;
}
char st[26];
int top;
inline void write_int(int x)
{
if(!x)
{
write_char('0');
return;
}
if(x<0)
{
write_char('-');
x=-x;
}
while(x)
{
st[++top]=x%10^48;
x/=10;
}
while(top>0)
write_char(st[top--]);
}
inline void write_string(const char *s)
{
for(int i=0;s[i];++i)
write_char(s[i]);
}
inline void write_double(double x,int cnt_digits,bool mark=true)
{
if(x<0)
{
write_char('-');
x=-x;
}
if(mark)
x+=5*pow(0.1,cnt_digits+1);
write_int(int(x));
if(cnt_digits>0)
{
write_char('.');
for(int i=1;i<=cnt_digits;++i)
{
x-=int(x),x*=10;
write_char(int(x)^48);
}
}
}
}
const int mod=998244353;
const int max_n=4e5+5;
int fac[max_n],inv[max_n],inv_fac[max_n];
inline void init(int n=4e5)
{
fac[0]=inv_fac[0]=1;
fac[1]=inv[1]=inv_fac[1]=1;
for(int i=2;i<=n;++i)
{
fac[i]=1ll*fac[i-1]*i%mod;
inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;
inv_fac[i]=1ll*inv_fac[i-1]*inv[i]%mod;
}
}
inline int C(int n,int m)
{
if(n<0||m<0||n<m)
return 0;
return 1ll*fac[n]*inv_fac[m]%mod*inv_fac[n-m]%mod;
}
int ans;
vector<int> cnt;
int N,M;
inline void solve(int x)
{
cnt.clear();
for(int i=2;1ll*i*i<=x;++i)
{
if(x%i==0)
{
int c=0;
while(x%i==0)
x/=i,++c;
cnt.push_back(c);
}
}
if(x!=1)
cnt.push_back(1);
int res=1;
for(int i=0;i<int(cnt.size());++i)
{
int x=cnt[i];
res=1ll*res*C(N+x-1,N-1)%mod;
}
ans=(ans+res)%mod;
}
int main()
{
init();
scanf("%d%d",&N,&M);
for(int i=1;i<=M;++i)
solve(i);
printf("%d\n",ans);
IO::flush();
return 0;
}
|
#include <bits/stdc++.h>
/* #include <atcoder/lazysegtree> */
using namespace std;
/* using namespace atcoder; */
using pint = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
using vint = vector<int>;
using vll = vector<long long>;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (long long i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (long long i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define VREP(s, ite) for (auto ite = s.begin(); ite != s.end(); ++ite)
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define endl "\n"
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
constexpr ll INF = 1e15 + 7LL;
constexpr ll MOD = 1e9 + 7LL;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
is >> v[i];
}
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (v.size() == 0) return os;
for (int i = 0; i < v.size() - 1; ++i) {
os << v[i] << " ";
}
os << v[v.size() - 1];
return os;
}
template <typename... T>
void In(T&&... args) {
(std::cin >> ... >> args);
}
template <typename T, typename ...Tail>
void Out(T head, Tail... tail) {
std::cout << head;
if constexpr(sizeof...(tail) > 0) {
std::cout << ' ';
Out(tail...);
} else {
std::cout << '\n';
}
}
template <typename T>
T& chmin(T& val, T val2) {
return val = min(val, val2);
}
template <typename T>
T& chmax(T& val, T val2) {
return val = max(val, val2);
}
void solve() {
int n; In(n);
ll yh=2e15,yl=-2e15, acm = 0;
REP(i,n) {
ll a, t; In(a,t);
if (t == 1) {
acm += a;
yh += a;
yl += a;
} else if (t == 2) {
if (a > yl) {
yl = a;
if (yl > yh) yh = yl;
}
} else {
if (a < yh) {
yh = a;
if (yl > yh) yl = yh;
}
}
}
ll xh = yh - acm, xl = yl - acm;
int q; In(q);
vll x(q); In(x);
REP(i,q) {
if (yl == yh) {
Out(yl);
} else if (x[i] <= xl) {
Out(yl);
} else if (x[i] >= xh) {
Out(yh);
} else {
Out(x[i]+acm);
}
}
}
int main() {
solve();
char tmp;
while (cin >> tmp) {
cin.putback(tmp);
solve();
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n), t(n);
for (int i = 0; i < n; i++) cin >> a[i] >> t[i];
vector<long long> pref(n);
pref[0] = (t[0] == 1) * a[0];
for (int i = 1; i < n; i++) {
pref[i] = (t[i] == 1) * a[i] + pref[i - 1];
}
vector<int> p(n);
iota(p.begin(), p.end(), 0);
set<pair<long long, int>> mx, mn;
for (int i = n - 1; i >= 0; i--) {
if (t[i] == 1) {
} else {
long long bound = a[i] - pref[i];
auto it1 = mx.lower_bound(make_pair(bound, 0));
auto it2 = mn.lower_bound(make_pair(bound + 1, 0));
it2 = it2 != mn.begin() ? prev(it2) : mn.end();
int pos1 = it1 != mx.end() ? it1->second : n, pos2 = it2 != mn.end() ? it2->second : n;
int pos = min(pos1, pos2);
if (pos != n) {
p[i] = p[pos];
}
if (t[i] == 2) {
auto ub = mx.lower_bound(make_pair(bound + 1, 0));
for (auto it = mx.begin(); it != ub;) {
it = mx.erase(it);
}
mx.emplace(bound, i);
} else {
auto lb = mn.lower_bound(make_pair(bound, 0));
for (auto it = lb; it != mn.end();) {
it = mn.erase(it);
}
mn.emplace(bound, i);
}
}
}
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
auto it1 = mx.lower_bound(make_pair(x, 0));
auto it2 = mn.upper_bound(make_pair(x, 0));
it2 = it2 != mn.begin() ? prev(it2) : mn.end();
int pos1 = it1 != mx.end() ? it1->second : n, pos2 = it2 != mn.end() ? it2->second : n;
int pos = min(pos1, pos2);
if (pos != n) {
cout << a[p[pos]] + pref.back() - pref[p[pos]] << '\n';
} else {
cout << x + pref.back() << '\n';
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define ALL(a) (a).begin(),(a).end()
const int INF = 1 << 30;
const int MOD = 1e9 + 7;
const long long LINF = 1LL << 60;
const double PI = 3.141592653589793;
const int NIL = -1;
const int MAX = 1100000;
const int LARGE = 10000;
double X, Y, R;
ll XX, YY, RR;
bool inside(ll x, ll y) {
x *= LARGE; y *= LARGE;
return (x - XX) * (x - XX) + (y - YY) * (y - YY) <= RR * RR;
}
ll calc_lower(ll x) {
ll ok = floor(Y);
ll er = ok - floor(R) - 10;
if (!inside(x, ok)) return 0;
while(abs(ok - er) > 1) {
ll mid = (ok + er) / 2;
if (inside(x, mid)) ok = mid;
else er = mid;
}
return floor(Y) - er;
}
ll calc_upper(ll x) {
ll ok = floor(Y) + 1;
ll er = ok + floor(R) + 10;
if (!inside(x, ok)) return 0;
while(abs(ok - er) > 1) {
ll mid = (ok + er) / 2;
if (inside(x, mid)) ok = mid;
else er = mid;
}
return er - (floor(Y) + 1);
}
int main() {
cin >> X >> Y >> R;
XX = (ll) round(X * LARGE);
YY = (ll) round(Y * LARGE);
RR = (ll) round(R * LARGE);
ll ans = 0;
for (ll x = floor(X - R - 10); x < floor(X + R + 10); x++) {
ans += calc_upper(x) + calc_lower(x);
}
cout << ans << endl;
}
| #include <cstdio>
#include <climits>
#include <cmath>
#include <iostream>
#include <cstdio>
#include <climits>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdio>
#include <climits>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <utility>
#include <queue>
#include <cstring>
#include <set>
#include <map>
#include <complex>
#include <tuple>
#define rep(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
long long MOD = 1000000007;
long long INF = 1000000000000000000; //10^18
typedef long long ll;
typedef unsigned long long ull;
/*ll powMod(ll x, ll n, ll mod) {
if (n == 0) return 1;
ll t = powMod(x, n/2, mod);
t = t * t % mod;
if (n & 1) return t * x % mod;
return t;
}
ll gcd(ll a, ll b) {
if (a == 0 || b == 0) return a + b;
if (b > a) return gcd(b, a);
return gcd(b, a % b);
}*/
int main(void) {
ll n, a[100100];
cin >> n;
rep(i, n) cin >> a[i];
ll x[100100][3], y[100100][3];
if (n == 1) {
cout << a[0] << endl;
return 0;
}
x[1][1] = (a[0] + a[1]) % MOD;
x[1][0] = (a[0] - a[1] + MOD) % MOD;
y[1][1] = 1;
y[1][0] = 1;
for (int i = 2; i < n; i++) {
y[i][1] = (y[i-1][1] + y[i-1][0])%MOD;
y[i][0] = y[i-1][1];
x[i][1] = (x[i-1][1] + a[i]*y[i-1][1]%MOD)%MOD;
x[i][1] += (x[i-1][0] + a[i]*y[i-1][0]%MOD)%MOD;
x[i][1] %= MOD;
x[i][0] = (x[i-1][1] - a[i]*y[i-1][1]%MOD + MOD)%MOD;
}
//cout << y[n-2][0] << " " << y[n-2][1] << endl;
cout << (x[n-1][0] + x[n-1][1])%MOD << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define int ll
#define pb push_back
#define N 2003
#define f1 first
#define s2 second
#define PII pair<int,int>
using namespace std;
double dp[105][105][105];
int a,b,c,d,t;
string s;
double dpf(int a,int b,int c){
if(a==100 || b==100 ||c==100 )
return 0;
if(dp[a][b][c]!=-1){
return dp[a][b][c] ;
}
// cout<<((double)a/(double)(a+b+c)) <<endl;
dp[a][b][c]=(dpf(a+1,b,c)+1)*((double)a/(double)(a+b+c));
dp[a][b][c]+=(dpf(a,b+1,c)+1)*((double)b/(double)(a+b+c));
dp[a][b][c]+=(dpf(a,b,c+1)+1)*((double)c/(double)(a+b+c));
return dp[a][b][c];
}
int32_t main(){
// freopen("a.gir","r",stdin);
// freopen("a.cik","w",stdout);
// scanf("%lld",&t);
t=1;
while(t--){
for(int i=0;i<101;i++)
for(int j=0;j<101;j++)
for(int k=0;k<101;k++)
dp[i][j][k]=-1;
scanf("%lld %lld %lld",&a,&b,&c);
printf("%.10lf\n",dpf(a,b,c) ); ;
}
}
| #include<bits/stdc++.h>
using namespace std;
int H, W, A, B;
bool used[16][16];
int dfs(int x, int y, int a) {
if (H == y) return a == 0;
if (W == x) return dfs(0, y + 1, a);
if (used[y][x]) return dfs(x + 1, y, a);
int res = 0;
if (y + 1 < H && !used[y+1][x] && 0 < a) {
used[y][x] = true;
used[y+1][x] = true;
res += dfs(x+1, y, a-1);
used[y][x] = used[y+1][x] = false;
}
if (x + 1 < W && !used[y][x+1] && 0 < a) {
used[y][x] = true;
used[y][x+1] = true;
res += dfs(x+1, y, a-1);
used[y][x] = false;
used[y][x+1] = false;
}
res += dfs(x+1, y, a);
return res;
}
int main() {
cin >> H >> W >> A >> B;
cout << dfs(0, 0, A) << endl;
} |
#include <algorithm>
#include <array>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define ll long long
#define INF 1LL << 33
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define SHOW(p) \
if (test) \
cout << #p " : " << p << endl;
//bool test = true;
bool test = false;
int H, W;
vector<string> s;
vector<pair<int, int>> gs, gs2;
vector<bool> col, row, col2, row2;
bool update()
{
bool update_onece = false;
bool update = true;
while (update) {
update = false;
for (auto it = gs.begin(); it != gs.end();) {
if (row.at(it->first)) {
if (!col.at(it->second)) {
update = col.at(it->second) = true;
it = gs.erase(it);
} else {
it++;
}
} else if (col.at(it->second)) {
if (!row.at(it->first)) {
update = row.at(it->first) = true;
it = gs.erase(it);
} else {
it++;
}
} else {
it++;
}
if (test) {
cout << it->first << ":" << it->second << endl;
}
}
if (update) {
update_onece = true;
}
}
return update_onece;
}
bool update2()
{
bool update_onece = false;
bool update = true;
while (update) {
update = false;
for (auto it = gs2.begin(); it != gs2.end();) {
if (row2.at(it->first)) {
if (!col2.at(it->second)) {
update = col2.at(it->second) = true;
it = gs2.erase(it);
} else {
it++;
}
} else if (col2.at(it->second)) {
if (!row2.at(it->first)) {
update = row2.at(it->first) = true;
it = gs2.erase(it);
} else {
it++;
}
} else {
it++;
}
if (test) {
cout << it->first << ":" << it->second << endl;
}
}
if (update) {
update_onece = true;
}
}
return update_onece;
}
signed main()
{
cin >> H >> W;
s.resize(H);
col.resize(W, false);
row.resize(H, false);
row.at(0) = row.at(H - 1) = col.at(0) = col.at(W - 1) = true;
REP(i, H)
{
cin >> s.at(i);
REP(j, W)
{
if (s.at(i).at(j) == '#') {
gs.push_back({i, j});
}
}
}
update();
row2 = row;
col2 = col;
gs2 = gs;
//cols
int ans_c = 0;
for (int x = 0; x < H; x++) {
if (row.at(x)) {
continue;
}
ans_c++;
row.at(x) = true;
update();
}
//cols
int ans_r = 0;
for (int x = 0; x < W; x++) {
if (col2.at(x)) {
continue;
}
ans_r++;
col2.at(x) = true;
update2();
}
if (ans_r > ans_c) {
cout << ans_c << endl;
} else {
cout << ans_r << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define maxn 2086
using namespace std;
int n, m;
char s[maxn][maxn];
int fa[maxn], siz[maxn];
int find(int x){
return x == fa[x] ? x : fa[x] = find(fa[x]);
}
set<int> st[2];
int main(){
scanf("%d%d", &n, &m);
for(int i = 1;i <= n;i++) scanf("%s", s[i] + 1);
for(int i = 1;i <= n + m;i++) fa[i] = i, siz[i] = 1;
s[1][1] = s[n][1] = s[1][m] = s[n][m] = '#';
for(int i = 1;i <= n;i++){
for(int j = 1;j <= m;j++){
if(s[i][j] == '#'){
int x = find(i), y = find(j + n);
if(x == y) continue;
if(siz[x] > siz[y]) swap(x, y);
fa[x] = y, siz[y] += siz[x];
}
}
}
for(int i = 1;i <= n;i++) st[0].insert(find(i));
for(int i = 1;i <= m;i++) st[1].insert(find(i + n));
printf("%d", min(st[0].size(), st[1].size()) - 1);
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> x(N), y(N);
for (int i = 0; i < N; i++) {
cin >> x.at(i) >> y.at(i);
}
double a;
for (int i = 0; i < N - 1; i++) {
set<double> c;
for (int j = i + 1; j < N; j++) {
if (x.at(j) == x.at(i)) {
a = 1000000;
}
else {
a = (y.at(j) - y.at(i)) / (x.at(j) - x.at(i));
}
if (c.count(a)) {
cout << "Yes" << endl;
return 0;
}
c.insert(a);
}
}
cout << "No" << endl;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define out(x) cout << x << '\n'
#define lli long long int
#define uli unsigned long long int
#define rep(i, m, n) for (lli i = m; i < (n); i++)
#define repe(i, m, n) for (lli i = m; i <= (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((lli)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define _GLIBCXX_DEBUG
const lli INF = 2147483647;
const lli MINF = -2147483648;
const lli LINF = 9223372036854775807;
const lli MOD = 1000000007; //10^9+7
const double PI = acos(-1);
#define SORT(n) sort(n.begin(), n.end())
#define SORTR(n) sort(n.begin(), n.end(), greater<int>())
#define REV(n) reverse(n.begin(), n.end())
#define pb push_back
#define eb emplace_back
#define mp make_pair
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vlli = vector<lli>;
using vvli = vector<vlli>;
using vs = vector<string>;
using vvs = vector<vs>;
using vb = vector<bool>;
using vvb = vector<vb>;
using ll = long long;
//---------------------------------------------------------------------------------------------------
// vector入力
template <typename T>
istream &operator>>(istream &is, vector<T> &vec)
{
for (T &x : vec)
is >> x;
return is;
}
// vector出力
template <typename T>
ostream &operator<<(ostream &os, vector<T> &vec)
{
// os << '{';
for (int i = 0; i < vec.size(); i++)
{
os << vec[i] << (i + 1 == vec.size() ? "" : "");
}
// os << '}';
return os;
}
// aよりもbが大きいならばaをbで更新する(更新されたならばtrueを返す)
template <typename T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b; // aをbで更新
return true;
}
return false;
}
// aよりもbが小さいならばaをbで更新する(更新されたならばtrueを返す)
template <typename T>
bool chmin(T &a, const T &b)
{
if (a > b)
{
a = b; // aをbで更新
return true;
}
return false;
}
//---------------------------------------------------------------------------------------------------
lli gcd(lli a, lli b)
{
while (b)
{
lli c = b;
b = a % b;
a = c;
}
return a;
}
//---------------------------------------------------------------------------------------------------
void solve()
{
}
//---------------------------------------------------------------------------------------------------
signed main()
{
lli a = 0, b = 0, c = 0, h = 0, n = 0, w = 0, ans = 0, count = 0;
string s = "", t = "";
vector<pair<lli, lli>> pr;
pair<lli, lli> A, B, C;
map<lli, lli> ma;
map<lli, lli> ma2;
set<lli> st;
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
lli x, y;
double X[n];
double Y[n];
bool ff = false;
rep(i, 0, n)
{
cin >> X[i] >> Y[i];
// ma[x]++;
// ma2[y]++;
// pr.eb(mp(x, y));
// d[i].pb(x);
// d[i].pb(y);
// X.pb(x);
// Y.pb(y);
}
// for (auto z : ma)
// {
// if (z.second >= 3)
// {
// out("Yes");
// return 0;
// }
// }
// for (auto z : ma2)
// {
// if (z.second >= 3)
// {
// out("Yes");
// return 0;
// }
// }
rep(i, 0, n - 2)
{
rep(j, i + 1, n - 1)
{
rep(k, j + 1, n)
{
if ((Y[j] - Y[i]) * (X[k] - X[j]) == (Y[k] - Y[j]) * (X[j] - X[i]))
{
out("Yes");
return 0;
}
}
}
}
out("No");
} |
#include<algorithm>
#include<cstdio>
#define ll long long
#define MaxN 200500
using namespace std;
const int mod=1000000007;
int n,a[MaxN];
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++)scanf("%d",&a[i]);
sort(a+1,a+n+1);
ll ans=1;
for (int i=1;i<=n;i++)
ans=(ans*(a[i]-a[i-1]+1))%mod;
printf("%lld",ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
#define per(i, x, y) for (int i = x; i >= y; i--)
#define vi vector<int>
#define Go(i, x, v) for (int i = 0, x = (i == v.size() ? 0 : v[i]); i < v.size(); i++, x = (i == v.size() ? 0 : v[i]))
#define pb push_back
#define mkp make_pair
#define fi first
#define se second
#define gc getchar
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
template <class T> void rd(T &x) {
x = 0; char ch = gc(); int f = 1;
for (; !isdigit(ch); ch = gc()) if (ch == '-') f = -1;
for (; isdigit(ch); ch = gc()) x = (x << 1) + (x << 3) + ch - '0';
x *= f;
}
template <class T> void cmin(T &x, T y) { x = min(x, y); }
template <class T> void cmax(T &x, T y) { x = max(x, y); }
const int mod = 1e9 + 7;
void Add(int &x, int y) { x += y; if (x >= mod) x -= mod; }
void Sub(int &x, int y) { x += mod - y; if (x >= mod) x -= mod; }
void Mul(int &x, int y) { x = (ll)x * y % mod; }
int add(int x, int y) { x += y; if (x >= mod) x -= mod; return x; }
int sub(int x, int y) { x += mod - y; if (x >= mod) x -= mod; return x; }
int mul(int x, int y) { return (ll)x * y % mod; }
int qpow(int a, int b) { int ret = 1; for (; b; b >>= 1, Mul(a, a)) if (b & 1) Mul(ret, a); return ret; }
/* ============ Header Template ============ */
const int N = 1e5 + 10;
int n, a[N], b[N], tot;
int main() {
rd(n);
rep(i, 1, n) {
rd(a[i]);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
tot = unique(b + 1, b + n + 1) - b - 1;
int ans = 1;
rep(i, 1, tot) {
Mul(ans, max(1, b[i] - b[i - 1] + 1));
}
printf("%d\n", ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
/* alias */
using ull = unsigned long long;
using ll = long long;
/* define short */
#define all(obj) (obj).begin(), (obj).end()
#define YESNO(bool) if(bool){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;}
#define yesno(bool) if(bool){cout<<"yes"<<endl;}else{cout<<"no"<<endl;}
#define YesNo(bool) if(bool){cout<<"Yes"<<endl;}else{cout<<"No"<<endl;}
/* REP macro */
#define reps(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define rep(i, n) reps(i, 0, n)
#define rrep(i, n) reps(i, 1, n + 1)
#define repd(i,n) for(ll i=n-1;i>=0;i--)
#define rrepd(i,n) for(ll i=n;i>=1;i--)
int main() {
ll a,b,c;
bool even;
cin>>a>>b>>c;
if(c%2==0){
even = true;
}else{
even = false;
}
if(even){
if(abs(a)<abs(b)){
cout<<"<"<<endl;
}else if(abs(a)==abs(b)){
cout<<"="<<endl;
}else{
cout<<">"<<endl;
}
return 0;
}
if(a<b){
cout<<"<"<<endl;
}else if(a==b){
cout<<"="<<endl;
}else{
cout<<">"<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long a, b, c;
int main() {
cin >> a >> b >> c;
c = c % 2 ? 1 : 2;
if (c == 1) {
if (a > b)
cout << '>';
if (a < b)
cout << '<';
if (a == b)
cout << '=';
}
else {
a *= a;
b *= b;
if (a > b)
cout << '>';
if (a < b)
cout << '<';
if (a == b)
cout << '=';
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vecll = vector<ll>;
using matll = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < ll(n); i++)
#define repitr(id, itr) for (auto& id : itr)
#define repr(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define reprs(i, a, b, s) for (ll i = ll(a); i < ll(b); i += s)
#define reprms(i, a, b, s) for (ll i = ll(a); i > ll(b); i += s)
#define repdic(key, val, dic) for (const auto& [key, val] : dic)
#define sort_all(v) sort(v.begin(), v.end())
#define min_val(v) *min_element(v.begin(), v.end())
#define max_val(v) *max_element(v.begin(), v.end())
#define max_idx(v) distance(v.begin(), max_element(v.begin(), v.end()))
#define sum(v) accumulate(v.begin(), v.end(), 0LL)
#define all(v) v.begin(), v.end()
#define deg_to_rad(deg) (((deg) / 360) * 2 * M_PI)
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
#define coutdeci cout << fixed << setprecision(15)
ll smallcmb(ll n, ll r) {
if (r < 0 || n < r) return 0;
r = min(r, n - r);
ll res = 1;
rep(i, r) {
res *= n - r + 1 + i;
res /= i + 1;
}
return res;
}
string S;
int main() {
cin >> S;
ll o = count(all(S), 'o'), x = count(all(S), 'x');
ll ox = count(all(S), '?');
ll ans = 0;
rep(i, ox + 1) {
ll cnt = i + o;
if (cnt == 0 || cnt > 4)
continue;
else if (cnt == 1)
ans += smallcmb(ox, i);
else if (cnt == 2)
ans += 14 * smallcmb(ox, i);
else if (cnt == 3)
ans += 36 * smallcmb(ox, i);
else if (cnt == 4)
ans += 24 * smallcmb(ox, i);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fast_io cin.tie(0);ios_base::sync_with_stdio(0);
string to_string(string s) { return '"' + s + '"';}
string to_string(char s) { return string(1, s);}
string to_string(const char* s) { return to_string((string) s);}
string to_string(bool b) { return (b ? "true" : "false");}
template <typename A> string to_string(A);
template <typename A, typename B>string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A> string to_string(A v) {bool f = 1; string r = "{"; for (const auto &x : v) {if (!f)r += ", "; f = 0; r += to_string(x);} return r + "}";}
void debug_out() { cout << endl; }
void show() { cout << endl; }
void pret() { cout << endl; exit(0);}
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {cout << " " << to_string(H); debug_out(T...);}
template <typename Head, typename... Tail> void show(Head H, Tail... T) {cout <<H<<" "; show(T...);}
template <typename Head, typename... Tail> void pret(Head H, Tail... T) {cout <<H<<" "; pret(T...);}
#define pr(...) cout << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
typedef long long ll;
#define int ll
typedef long double ld;
typedef vector<int> vi;
#define disp(x) cout<<x<<" ";
#define rep(i,a,b) for(int i=a;i<(int)b;i++)
#define fo(i,a,b) for(int i=a;i<=(int)b;i++)
#define rf(i,a,b) for(int i=a;i>=(int)b;i--)
#define mp make_pair
#define pb emplace_back
#define F first
#define S second
#define endl '\n'
//cout.setf(ios::fixed);cout.precision(18)
const int MOD = 1e9+7;
const int maxn = 300000+10;
int lcm(int x, int y){
int g = __gcd(x, y);
return (x * y) / g;
}
int32_t main(){
fast_io;
int n;
cin >> n;
int ans = 1;
fo(i, 2, n) ans = lcm(i, ans);
ans++;
show(ans);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int pt[n][2];
for(int i=0; i<n; i++) {
cin>>pt[i][0]>>pt[i][1];
}
int x1, y1, x2, y2, x3, y3;
for(int i=0; i<=n-3; i++) {
x1 = pt[i][0];
y1 = pt[i][1];
for(int j=i+1; j<=n-2; j++) {
x2 = pt[j][0];
y2 = pt[j][1];
for(int k=j+1; k<=n-1; k++) {
x3 = pt[k][0];
y3 = pt[k][1];
if(x3*(y1-y2) + x1*(y2-y3) + x2*(y3-y1) == 0) {
cout<<"Yes";
return 0;
}
}
}
}
cout<<"No";
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#ifdef ENABLE_DEBUG
#define dump(a) cerr<<#a<<"="<<a<<endl
#define dumparr(a,n) cerr<<#a<<"["<<n<<"]="<<a[n]<<endl
#else
#define dump(a)
#define dumparr(a,n)
#endif
#define FOR(i, a, b) for(ll i = (ll)a;i < (ll)b;i++)
#define For(i, a) FOR(i, 0, a)
#define REV(i, a, b) for(ll i = (ll)b-1LL;i >= (ll)a;i--)
#define Rev(i, a) REV(i, 0, a)
#define REP(a) For(i, a)
#define SIGN(a) (a==0?0:(a>0?1:-1))
typedef long long int ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<ll, ll> pll;
typedef pair<ll,pll> ppll;
typedef vector<ll> vll;
typedef long double ld;
typedef pair<ld,ld> pdd;
pll operator+(pll a,pll b){
return pll(a.first+b.first,a.second+b.second);
}
pll operator-(pll a,pll b){
return pll(a.first-b.first,a.second-b.second);
}
pll operator*(ll a,pll b){
return pll(b.first*a,b.second*a);
}
const ll INF=(1LL<<60);
#if __cplusplus<201700L
ll gcd(ll a, ll b) {
a=abs(a);
b=abs(b);
if(a==0)return b;
if(b==0)return a;
if(a < b) return gcd(b, a);
ll r;
while ((r=a%b)) {
a = b;
b = r;
}
return b;
}
#endif
template<class T>
bool chmax(T& a,const T& b){
if(a<b){
a=b;
return true;
}
return false;
}
template<class T>
bool chmin(T& a,const T& b){
if(a>b){
a=b;
return true;
}
return false;
}
template<class S,class T>
std::ostream& operator<<(std::ostream& os,pair<S,T> a){
os << "(" << a.first << "," << a.second << ")";
return os;
}
template<class T>
std::ostream& operator<<(std::ostream& os,vector<T> a){
os << "[ ";
REP(a.size()){
os<< a[i] << " ";
}
os<< " ]";
return os;
}
template<typename T>
int sgn(T val){
return (T(0)<val)-(val<T(0));
}
tuple<long long,long long,long long> egcd(long long a,long long b){
// (val,da,db) val==gcd(a,b) da*a+db*b=val
if(a==0||b==0)return std::make_tuple(0LL,0LL,0LL);
long long sa=sgn(a),sb=sgn(b);
a=std::abs(a);b=std::abs(b);
long long p=1,q=0,r=0,s=1;
while(b>0){
long long c=a/b;
long long d;
d=a;a=b;b=d%b;
d=p;p=q;q=d-c*q;
d=r;r=s;s=d-c*s;
}
return std::make_tuple(a,p*sa,r*sb);
}
long long inverse(long long a,long long m){
using namespace std;
assert(abs(gcd(a,m))==1LL);
assert(a!=0);
auto [val,da,dm]=egcd(a,m);
return (da%m+m)%m;
}
int main(){
cout<<setprecision(1000);
ll T;
cin>>T;
For(times,T){
ll X,Y,P,Q;
cin>>X>>Y>>P>>Q;
ll mod=P+Q;
ll l=X%mod,r=(X+Y)%mod;
ll s=2*(X+Y);
ll g=gcd(s,mod);
ll ans=LLONG_MAX;
FOR(i,P,P+Q){
For(jj,Y){
ll j=(jj+X)%mod;
if(s%mod==0&&j!=i)continue;
if(s%mod==0&&j==i){
chmin(ans,jj+X);
continue;
}
ll k=(i-j+mod)%mod;
if(k%g!=0){
continue;
}
ll nmod=mod/g;
ll ns=s/g%nmod;
ll nk=k/g;
ll tmpans=inverse(ns,nmod)*nk%nmod*s+X+jj;
chmin(ans,tmpans);
}
}
if(ans==LLONG_MAX){
cout<<"infinity"<<endl;
}else{
cout<<ans<<endl;
}
}
return 0;
}
|
#define MOD 1000000007
#pragma GCC target("popcnt")
#include <bits/stdc++.h>
#include <numeric>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t n;
cin>>n;
array < int64_t , 86 > fib;
vector < int64_t > decomp,fin,ans;
fib[0]=fib[1]=1;
for(int i=2; i<fib.size(); ++i){
fib[i]=fib[i-1]+fib[i-2];
}
for(int i=fib.size()-1; i>=0; --i){
while(n>=fib[i]){
n-=fib[i];
decomp.push_back(i);
}
}
reverse(decomp.begin(),decomp.end());
ans.resize(decomp.back()+1);
for(auto &i:decomp){
++ans[ans.size()-1-i];
}
if(decomp.back()&1){
for(int i=0; i<ans.size(); ++i){
while(ans[i]--){
fin.push_back(1+!(i&1));
}
fin.push_back(3+(i&1));
}
}
else{
for(int i=0; i<ans.size(); ++i){
while(ans[i]--){
fin.push_back(1+(i&1));
}
fin.push_back(3+!(i&1));
}
}
fin.pop_back();
cout<<fin.size()<<'\n';;
for(int i=0; i<fin.size(); ++i){
cout<<fin[i]<<'\n';
}
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
long long i,j,k,l,m,n,t,r,g,b1;
long long a[200010],b[200010],c[200010];
char ch;
cin>>n;
r=g=b1=0;
for(i=0;i<2*n;i++) {
cin>>k;
getchar();
ch=getchar();
if (ch=='R') {
a[r++]=k;
}
else if (ch=='G') {
b[g++]=k;
}
else if (ch=='B') {
c[b1++]=k;
}
}
sort(a,a+r);
sort(b,b+g);
sort(c,c+b1);
if (r%2==0&&g%2==0&&b1%2==0) {
cout<<0;
}
else {
i=j=0;
m=1e16;
while(i<g&&j<b1) {
if (m>abs(b[i]-c[j])) m=abs(b[i]-c[j]);
if (b[i]<c[j]) i++;
else j++;
}
i=j=0;
l=1e16;
while(i<r&&j<b1) {
if (l>abs(a[i]-c[j])) l=abs(a[i]-c[j]);
if (a[i]<c[j]) i++;
else j++;
}
i=j=0;
k=1e16;
while(i<r&&j<g) {
if (k>abs(a[i]-b[j])) k=abs(a[i]-b[j]);
if (a[i]<b[j]) i++;
else j++;
}
if (r%2==0) {
if (m>l+k) cout<<l+k;
else cout<<m;
}
else if (g%2==0) {
if (l>m+k) cout<<m+k;
else cout<<l;
}
else {
if (k>m+l) cout<<m+l;
else cout<<k;
}
}
return 0;
} |
#include <iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<math.h>
#include<iomanip>
#include<string>
#include <cassert>
#include <complex>
#include<math.h>
#include<bits/stdc++.h>
#define rep(s,i,n) for(int i = s;i < n;i++)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef __int128_t lll;
typedef pair<ll, ll> pll;
const int dx[] = { 0,1,0,-1 };
const int dy[] = { 1,0,-1,0 };
const ll LongINF = 1e13 + 7;
const int INF = 1e9 + 7;
const ll LL_MAX = 9223372036854775807;
const ll LL_MIN = -9223372036854775807;
//エッジが保持する情報
struct E{
int y;
int d;
int c;
E(int y,int d,int c) : y(y) , d(d), c(c) {}
} ;
//ノード一つが取り扱う情報
struct S{
double time;
int sp,city,prev;
//コンストラクタ
S(double time,int sp, int city, int prev) : time(time),sp(sp),city(city),prev(prev) {}
bool operator > (const S & s) const{
return time > s.time;
}
};
int dsp[3] = {-1,0,1};
int keta(ll i){
int keta = 0;
do{
keta++;
}while(i /= 10);
return keta;
}
//素因数分解 O(√n)
vector<pair<ll,ll>> pfactor(ll n){
vector<pair<ll,ll>> factor;
ll ex; //指数
for(ll a = 2; a * a <= n; a++){
if(n % a != 0)continue;
ll ex = 0;
while(n % a == 0){
n /= a;
ex++;
}
factor.push_back({a,ex});
}
if(n != 1) factor.push_back({n,1});
return factor;
}
int charCheck(char c){
int f;
if(c >= 'a' && c <= 'z')f = 1;
else if(c >= 'A' && c <= 'Z') f = 0;
return f;
}
int main(void){
string s;
cin >> s;
rep(1,i,s.size() + 1){
if(i%2 != charCheck(s[i-1]))
{
cout << "No" ;
return 0;
}
}
cout << "Yes";
return 0;
} | #include <bits/stdc++.h>
#include<sstream>
#include<string>
#include<vector>
#include <set>
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define pb push_back
#define mp make_pair
#define ll long long
#define lb lower_bound
#define ub upper_bound
#define endl "\n"
#define ff first
#define ss second
#define decimal(ans,w) cout<<fixed<<setprecision(w)<<ans
long long M=1000000007;
using namespace std;
ll fact[10000];
ll power(ll x, unsigned ll y, unsigned ll m)
{
if (y == 0)
return 1;
ll p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
unsigned long long modInverse(unsigned long long n,
ll p)
{
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n,
ll r, ll p)
{
// If n<r, then nCr should return 0
if (n < r)
return 0;
// Base case
if (r == 0)
return 1;
return (fact[n] * modInverse(fact[r], p) % p
* modInverse(fact[n - r], p) % p)
% p;
}
int32_t main()
{
IOS
string s;
cin>>s;
ll n=s.length(),x=0;
deque<char>t;
for(ll i=0;i<n;i++)
{
if(s[i]=='R')
{
x^=1;
}
else if(x)t.push_front(s[i]);
else t.push_back(s[i]);
}
if(x)reverse(t.begin(),t.end());
string s1;
for(auto it:t)
{
if(s1.length()>0 && s1.back()==it)
{
s1.pop_back();
}
else s1.push_back(it);
}
cout<<s1;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long ll;
const int N = 15;
string s1, s2, s3;
string as;
int mp[128];
void get(string& s, ll& x) {
x = 0;
for (int i = 0; i < s.size(); ++i) x = x * 10 + mp[s[i]];
}
bool check() {
static ll x, y, z;
if (!(mp[s1[0]] && mp[s2[0]] && mp[s3[0]])) return false;
get(s1, x), get(s2, y), get(s3, z);
if (!x || !y || !z) return false;
if (x + y == z) {
printf("%lld\n%lld\n%lld", x, y, z);
return true;
} else {
return false;
}
}
bool st[N];
bool dfs(int u = 0) {
if (u == as.size()) {
if (check()) return true;
return false;
}
for (int i = 0; i < 10; ++i) {
if (!st[i]) {
st[i] = true;
mp[as[u]] = i;
if (dfs(u + 1)) return true;
mp[as[u]] = 0;
st[i] = false;
}
}
return false;
}
int main() {
cin >> s1 >> s2 >> s3;
as = s1 + s2 + s3;
sort(as.begin(), as.end());
as.erase(unique(as.begin(), as.end()), as.end());
if (!dfs()) puts("UNSOLVABLE");
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < (t); ++i)
#define dsrep(i,t,s) for(int i = (t)-1; i >= (s); --i)
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define isin(x,l,r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define snuke srand((unsigned)clock()+(unsigned)time(NULL));
#define show(x) cerr<<#x<<" = "<<x<<endl;
#define bn(x) ((1<<(x))-1)
#define newline puts("")
using namespace std;
template<typename T> using vc = vector<T>;
template<typename T> using vv = vc<vc<T>>;
template<typename T> using PQ = priority_queue<T,vc<T>,greater<T> >;
using ll = long long;
using uint = unsigned;
using ull = unsigned long long;
using P = pair<int,int>;
using T3 = tuple<int,int,int>;
using vi = vc<int>;
using vvi = vv<int>;
using vl = vc<ll>;
using vp = vc<P>;
using vt = vc<T3>;
int getInt(){int x;scanf("%d",&x);return x;}
vi pm(int n, int s=0) { vi a(n); iota(rng(a),s); return a;}
template<typename T>istream& operator>>(istream&i,vc<T>&v){rep(j,sz(v))i>>v[j];return i;}
template<typename T>string join(const vc<T>&v,const string& d=""){stringstream s;rep(i,sz(v))(i?s<<d:s)<<v[i];return s.str();}
template<typename T>ostream& operator<<(ostream&o,const vc<T>&v){if(sz(v))o<<join(v," ");return o;}
template<typename T1,typename T2>istream& operator>>(istream&i,pair<T1,T2>&v){return i>>v.fi>>v.se;}
template<typename T1,typename T2>ostream& operator<<(ostream&o,const pair<T1,T2>&v){return o<<v.fi<<","<<v.se;}
vc<string> split(const string& s,char d=' '){vc<string> r(1);for(char c:s)if(c==d)r.pb("");else r.back()+=c;return r;}
string operator*(const string& s,int t){return join(vc<string>(t,s));}
template<typename T>bool mins(T& x,const T&y){if(x>y){x=y;return true;}else return false;}
template<typename T>bool maxs(T& x,const T&y){if(x<y){x=y;return true;}else return false;}
template<typename T>T dup(T x, T y){return (x+y-1)/y;}
template<typename T>ll suma(const vc<T>&a){ll res(0);for(auto&&x:a)res+=x;return res;}
// template<typename T>void uni(vc<T>& a){sort(rng(a));a.erase(unique(rng(a)),a.end());}
template<typename T>void uni(T& a){sort(rng(a));a.erase(unique(rng(a)),a.end());}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame { puts("UNSOLVABLE"); return;}
#define yn {puts("Yes");}else{puts("No");}
const int MX = 200005;
using vs = vc<string>;
struct Solver {
void solve() {
vs s(3);
cin>>s;
string cs;
rep(i,3) cs += s[i];
uni(cs);
if (sz(cs) > 10) dame;
vi p = pm(10);
vi mp(256);
do {
rep(i,sz(cs)) mp[cs[i]] = p[i];
vl t(3);
bool ok = true;
rep(i,3) {
if (mp[s[i][0]] == 0) ok = false;
for (char c : s[i]) t[i] = t[i]*10+mp[c];
}
if (t[0]+t[1] != t[2]) ok = false;
if (!ok) continue;
cout<<t<<endl;
return;
} while (next_permutation(rng(p)));
dame;
}
};
int main() {
int ts = 1;
// scanf("%d",&ts);
rrep(ti,ts) {
Solver solver;
solver.solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#define endl '\n'
#define inf 0x3f3f3f3f
using namespace std;
using ll = long long int;
int main(){
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << min({a, b, c, d}) << endl;
}
// Author: bitbeast
// Practice more! | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef int64_t ll;
typedef uint64_t ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
uint64_t g = gcd(m,n);
if(m%g==0) return (m/g)*n;
if(n%g==0) return (n/g)*m;
return (m*n)/gcd(m,n);
}
// vector<vector<uint64_t> > v(n+1, vector<uint64_t>(n+1, 0))
// v[n][k]に組み合わせ数が入る。
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
// 掛け算オーバーフロー判定
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
//素因数分解
void primeFactorization(uint64_t a, list<uint64_t> &factors){ //素因数分解を出力するプログラム
long i,sq;
if(a%2==0){ //偶数の場合
factors.push_back(2);
primeFactorization(a/2,factors); //2で割った値で再帰
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){ //3以上√a以下の奇数の場合
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors); //割れた値で再帰
return;
}
}
//偶数でも3以上√a以下の奇数の場合でも割り切れない場合
if(a!=1){ //aが1でないなら、a自身は素数
factors.push_back(a);
}
}
// フェルマーの小定理
// mod. m での a の逆元 a^{-1} を計算する
// (a/b)%m = a*movinv(b,m)%m
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
/*
//エラトステネスのふるい
int maxNum = 100000;
char isNotPrime[maxNum+1] = {};
isNotPrime[0]=isNotPrime[1]=1;
for(int i=2;i<maxNum;i++){
if(isNotPrime[i]==1) continue;
int num = i+i;
while(num<=maxNum){
isNotPrime[num]=1;
num += i;
}
}
*/
// 円周率
// M_PI
// #include <iomanip> // setprecisionを使用するのに必要
// cout << std::fixed << std::setprecision(15) << y << endl;
// 昇順
// priority_queue<int, vector<int>, greater<int> > queue;
// 降順ソート vector<int> v;
// sort(v.begin(),v.end(),greater<int>());
signed main() {
ll n = 0;
ll m = 1000;
for(int i=0;i<4;i++){
cin >> n;
m = min(m,n);
}
cout << m << endl;
return 0;
}
|
Subsets and Splits