code1
stringlengths 54
12k
| code2
stringlengths 71
12k
| similar
int64 0
1
| __index_level_0__
int64 0
101M
|
|---|---|---|---|
#include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <unordered_map>
#include <vector>
const int mod = 1e9 + 7;
const int kmax = 510000;
const int last_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
long long fact[kmax], fact_inv[kmax], inv[kmax];
void init_comb()
{
fact[0] = fact[1] = 1;
fact_inv[0] = fact_inv[1] = 1;
inv[1] = 1;
for (int i = 2; i < kmax; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fact_inv[i] = fact_inv[i - 1] * inv[i] % mod;
}
}
long long comb(int n, int r)
{
if (n < r) {
return 0;
}
if (n < 0 || r < 0) {
return 0;
}
return fact[n] * (fact_inv[r] * fact_inv[n - r] % mod) % mod;
}
template <typename T, T N>
class UnionFind {
T parent_[N];
T rank_[N];
T size_[N];
public:
UnionFind();
T Root(T idx);
bool IsSame(T x, T y);
void Unite(T x, T y);
T GetSize(T idx);
};
template <typename T, T N>
UnionFind<T, N>::UnionFind()
{
for (T i = 0; i < N; i++) {
parent_[i] = i;
rank_[i] = 0;
size_[i] = 1;
}
}
template <typename T, T N>
T UnionFind<T, N>::Root(T idx)
{
return parent_[idx] == idx ? idx : parent_[idx] = Root(parent_[idx]);
}
template <typename T, T N>
bool UnionFind<T, N>::IsSame(T x, T y)
{
return Root(x) == Root(y);
}
template <typename T, T N>
void UnionFind<T, N>::Unite(T x, T y)
{
x = Root(x);
y = Root(y);
if (x == y) {
return;
}
if (rank_[x] < rank_[y]) {
parent_[x] = y;
size_[y] += size_[x];
} else {
parent_[y] = x;
size_[x] += size_[y];
if (rank_[x] == rank_[y]) {
rank_[x]++;
}
}
}
template <typename T, T N>
T UnionFind<T, N>::GetSize(T idx)
{
return size_[Root(idx)];
}
template <typename T>
T pow_mod(T n, T p, T m)
{
if (p == 0) {
return 1;
}
if (p % 2 == 0) {
T t = pow_mod(n, p / 2, m);
return t * t % m;
}
return n * pow_mod(n, p - 1, m) % mod;
}
template <typename T>
T nCr_mod(T n, T r)
{
T x = 1;
for (T i = n - r + 1; i <= n; i++) {
x *= i;
x %= mod;
}
T a = 1;
for (T i = 1; i <= r; i++) {
a *= i;
a %= mod;
}
T y = pow_mod(a, mod - 2) % mod;
return x * y % mod;
}
template <typename T>
bool is_prime(T n)
{
if (n == 1) {
return false;
}
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
template <typename T>
bool is_leap(T y)
{
return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
template <typename T>
void next_day(T& y, T& m, T& d)
{
d++;
if (d > last_days[m - 1] + (m == 2 && is_leap(y) ? 1 : 0)) {
d = 1;
m++;
}
if (m > 12) {
y++;
m = 1;
}
}
template <typename T>
T fib(T n)
{
T a = 0, b = 1;
for (T i = 0; i < n; i++) {
T t = a;
a = b;
b = a + t;
}
return a;
}
template <typename T>
std::vector<size_t> calculate_ranks(const std::vector<T>& v)
{
std::vector<T> sorted = v;
std::sort(sorted.begin(), sorted.end());
std::map<T, long long> m;
for (auto i = 0LU; i < v.size(); i++) {
m.insert(std::make_pair(sorted[i], i));
}
std::vector<size_t> rank(v.size());
for (auto i = 0LU; i < v.size(); i++) {
rank[i] = m.find(v[i])->second + 1;
}
return rank;
}
template <typename T>
std::map<T, T> prime_factors_and_num(T n)
{
std::map<T, T> m;
for (T i = 2; i <= n; i++) {
while (n % i == 0) {
m[i]++;
n /= i;
}
}
return m;
}
inline long long calculate_sum(const std::vector<long long>& v)
{
return std::accumulate(v.begin(), v.end(), 0LL);
}
template <typename T, T N>
class Graph {
std::vector<std::vector<T>> weights_;
std::vector<T> predecessors_;
std::vector<T> shortest_path_estimate_;
std::vector<std::vector<T>> edges_;
void InitializeSingleSource(T start);
void Relax(T v, T u);
public:
Graph(std::vector<std::vector<T>> weights, std::vector<std::vector<T>> edges);
Graph(std::vector<std::vector<T>> weights, T inf);
T BellmanFord(T start, T end);
T Dijkstra(T start, T end);
};
template <typename T, T N>
Graph<T, N>::Graph(std::vector<std::vector<T>> weights, std::vector<std::vector<T>> edges)
{
weights_ = weights;
predecessors_ = std::vector<T>(N, -1);
shortest_path_estimate_ = std::vector<T>(N, mod);
edges_ = edges;
}
template <typename T, T N>
Graph<T, N>::Graph(std::vector<std::vector<T>> weights, T inf)
{
weights_ = weights;
predecessors_ = std::vector<T>(N, -1);
shortest_path_estimate_ = std::vector<T>(N, inf);
edges_ = std::vector<std::vector<T>>(N, std::vector<T>());
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (weights_[i][j] != inf) {
edges_[i].push_back(j);
}
}
}
}
template <typename T, T N>
void Graph<T, N>::InitializeSingleSource(T start)
{
for (int i = 0; i < N; i++) {
shortest_path_estimate_[i] = mod;
predecessors_[i] = -1;
}
shortest_path_estimate_[start] = 0;
}
template <typename T, T N>
void Graph<T, N>::Relax(T u, T v)
{
if (shortest_path_estimate_[v] > shortest_path_estimate_[u] + weights_[u][v]) {
shortest_path_estimate_[v] = shortest_path_estimate_[u] + weights_[u][v];
predecessors_[v] = u;
}
}
template <typename T, T N>
T Graph<T, N>::BellmanFord(T start, T end)
{
InitializeSingleSource(start);
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < N; j++) {
for (auto edge : edges_[j]) {
Relax(j, edge);
}
}
}
for (int i = 0; i < N; i++) {
for (auto edge : edges_[i]) {
if (shortest_path_estimate_[edge] > shortest_path_estimate_[i] + weights_[i][edge]) {
fprintf(stderr, "Graph contains negative circle!\n");
exit(1);
}
}
}
return shortest_path_estimate_[end];
}
template <typename T, T N>
T Graph<T, N>::Dijkstra(T start, T end)
{
InitializeSingleSource(start);
std::set<T> s;
auto compare_d = [=](const T& x, const T& y) {
return shortest_path_estimate_[x] > shortest_path_estimate_[y];
};
std::priority_queue<T, std::vector<T>, decltype(compare_d)> q(compare_d);
for (int i = 0; i < N; i++) {
q.push(i);
}
while (q.size()) {
T u = q.top();
q.pop();
s.insert(u);
for (auto v : edges_[u]) {
Relax(u, v);
}
}
return shortest_path_estimate_[end];
}
template <typename T>
std::vector<T> Divisor(T n)
{
std::vector<T> ans;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
ans.push_back(i);
if (i * i != n) {
ans.push_back(n / i);
}
}
}
return ans;
}
int main()
{
long long k;
std::cin >> k;
std::queue<long long> q;
for (int i = 1; i < 10; i++) {
q.push(i);
}
for (int i = 0; i < k - 1; i++) {
auto t = q.front();
q.pop();
if (t % 10 != 0) {
q.push(t * 10 + t % 10 - 1);
}
q.push(t * 10 + t % 10);
if (t % 10 != 9) {
q.push(t * 10 + t % 10 + 1);
}
}
std::cout << q.front() << std::endl;
}
|
#include<iostream>
using namespace std;
int main() {
int n, k, x, y;
cin >> n >> k >> x >> y;
int fee ;
if (n > k) {
fee = (k * x) + ((n - k) * y);
}
else {
fee = (n * x);
}
cout << fee;
}
| 0
| 12,124,927
|
#include "bits/stdc++.h"
using namespace std;
int main()
{
int n,d,ans;
ans=0;
cin>>n>>d;
vector<vector<int>> x(n,vector<int>(d));
for(int i=0;i<n;i++)
{
for(int j=0;j<d;j++)
{
cin>>x.at(i).at(j);
}
}
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
int disdis=0;
int han;
double dis;
for(int k=0;k<d;k++)
{
disdis+=(x.at(i).at(k)-x.at(j).at(k))*(x.at(i).at(k)-x.at(j).at(k));
}
dis=sqrt(disdis);
han=dis;
if(dis==han)
ans++;
}
}
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define T() long long t;cin>>t;for(long long i=1;i<=t;i++)
#define INF (int)MAX_INT
#define INFS (int)MIN_INT
#define mod 1000000007
#define FOR(a, b, n) for(int a = b; a < n; a++)
#define REP(a,c, b) for(int a = c; a < b; a++)
#define FORD(a, b, c) for(int a = b; a >= c; a--)
#define REPD(a, c,b) for(int a = b-1; a >= c; a--)
#ifdef HOHOHO
#define DEBUG(x) cerr << #x << " : " << x << '\n'
#define DEBUGV(x) cerr << #x << " : { "; REP(_it, x.size()) cerr << x[_it] << ' '; cerr << "}" << '\n'
#define DEBUGA(x, y) cerr << #x << " : { "; REP(_it, y) cerr << x[_it] << ' '; cerr << "}" << '\n'
#define PRINTF(...) fprintf(stderr,__VA_ARGS__)
#define CHECKPOINT cerr << "OK LINE #" << __LINE__ << '\n'
#else
#define DEBUG(x) {}
#define DEBUGV(x) {}
#define DEBUGA(x, y) {}
#define PRINTF(...) {}
#define CHECKPOINT {}
#endif
#define RESET(a, b) memset(a, b, sizeof a)
#define EPS 1e-9
#define m_p make_pair
#define pb push_back
#define fi first
#define se second
#define RALL(x) x.rbegin(), x.rend()
#define all(x) x.begin(), x.end()
#define ALL(x, y) x, x+y
#define SZ(x) ((int)x.size())
#define pi(a) pair<a, a>
#define vi(a) vector<a>
#define vii(a) vector<pi(a)>
#define vs vector<string>
template<class T> T sqr(T x){ return x*x; }
template<class T> T binPow(T p, int q, int MOD) {
if(q == 1) return p % MOD;
if(q & 1) return p*(binPow(p, q-1, MOD) % MOD) % MOD;
else return sqr(binPow(p, q/2, MOD) % MOD) % MOD;
}
ll nxt() {
ll temporaryVariable;
cin >> temporaryVariable;
return temporaryVariable;
}
const double PI = acos(-1.0);
#define MAXN 100001
const int G = 2e5 + 5;
int main(){
ios::sync_with_stdio(false);
ll n=nxt(),ans=n-1;
REP(i,2,n){
if(n%i==0){
ans+=(n/i)-1;
}
else{
ans+=n/i;
}
}
cout<<ans<<endl;
#ifdef HOHOHO
fprintf(stderr, "%.3lf\n", clock() / (double) CLOCKS_PER_SEC );
#endif
}
| 0
| 89,666,444
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(itr,mp) for(auto itr=mp.begin();itr!=mp.end();itr++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
ll Gcd(ll a,ll b){
if(a < b)swap(a, b);
if(a%b == 0)return(b);
else return(Gcd(b, a%b));
}
int main(){
ll n;
cin >> n;
ll ans;
rep(i, n){
ll a;
cin >> a;
if(i == 0)ans = a;
else ans = Gcd(ans, a);
}
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <math.h>
#include <algorithm>
#include <set>
#include <iomanip>
#include <stdio.h>
#include <sstream>
#include <bits/stdc++.h>
using namespace std;
vector<long long int> c;
vector<vector<long long int>> hoge;
vector<long long int> ans;
void saiki(long long int now,long long int bef){
if(now!=0&&hoge.at(now).size()==1){
ans.at(now)=c.at(now)+ans.at(bef);
return;
}
ans.at(now)=c.at(now);
if(now!=0) ans.at(now)+=ans.at(bef);
for(long long int i=0; i<hoge.at(now).size(); i++){
if(hoge.at(now).at(i)!=bef){
saiki(hoge.at(now).at(i),now);
}
}
}
int main(void){
long long int n,q;
cin>>n>>q;
hoge=vector<vector<long long int>>(n,vector<long long int>(0));
c.resize(n);
ans.resize(n);
for(long long int i=0; i<n-1; i++){
long long int a,b;
cin>>a>>b;
a--;
b--;
hoge.at(a).push_back(b);
hoge.at(b).push_back(a);
}
vector<long long int> p(q);
vector<long long int> x(q);
for(long long int i=0; i<q; i++){
cin>>p.at(i)>>x.at(i);
}
for(long long int i=0; i<q; i++){
c.at(p.at(i)-1)+=x.at(i);
}
saiki(0,-1);
for(long long int i=0; i<n; i++){
cout<<ans.at(i);
if(i!=n-1){
cout<<" ";
}else{
cout<<endl;
}
}
}
| 0
| 89,695,858
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define prec(n) fixed << setprecision(n)
#define maxpq priority_queue<ll>
#define minpq priority_queue<int, vector<int>, greater<int>>
#define PI 3.14159265
#define pb push_back
#define bits(n) __builtin_popcount(n)
void solve()
{
int n;
cin>>n;
set<int> a;
for(int i=0;i<n;i++)
{
int temp;
cin>>temp;
a.insert(temp);
}
if(a.size()==n)
cout<<"YES";
else
{
cout<<"NO";
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
int t=1;
while(t--)
{
solve();
}
return 0;
}
|
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<math.h>
#include <bits/stdc++.h>
#include<cstring>
using namespace std;
int main()
{
int a[100005];
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
int l=a[n-1];
cout<<l<<" ";
if(l%2)
{
for(int i=0;i<n;i++)
{
if(a[i]==l/2||a[i]==(l+1)/2)
{
cout<<a[i]<<endl;
return 0;
}
if(a[i]>(l+1)/2)
{
if(l-a[i]>a[i-1])
cout<<a[i];
else
cout<<a[i-1];
cout<<endl;
return 0;
}
}
}
else
{
for(int i=0;i<n;i++)
{
if(a[i]==l/2)
{
cout<<a[i]<<endl;
return 0;
}
if(a[i]>l/2)
{
if(l-a[i]>a[i-1])
cout<<a[i];
else
cout<<a[i-1];
cout<<endl;
return 0;
}
}
}
cout<<a[n-2]<<endl;
return 0;
}
| 0
| 59,126,623
|
#include <bits/stdc++.h>
#include <string>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <bitset>
typedef long long ll;
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
const int MAX = 510000;
const int MOD = 1000000007;
const int MAX_N = 200000;
int ctoi(const char c){
switch(c){
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
default : return -1;
}
}
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
int main(int argc, const char * argv[]) {
ll N; cin >> N ;
vector< bitset<61> > A;
for(ll i=0;i<N;i++){
ll temp; cin >> temp;
bitset<61> B(temp);
A.push_back(B);
}
ll ans = 0;
for(ll i=0; i<61; i++){
ll one_num = 0;
for(ll j=0; j<N;j++){
if(A[j][i]) one_num++;
}
ans = ( ans + ((one_num * (N - one_num)) % MOD ) * modpow(2,i) ) % MOD;
}
cout << ans % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1'000'000'007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define rep(i, n) for(ll i=0; i<(ll)(n); i++)
#define repd(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=a-1; (ll)(b)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define rALL(x) x.rbegin(), x.rend()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main(){
string s; cin >> s;
ll n; cin >> n;
vector<ll> v;
ll cnt=0;
FOR(i, 1, s.size()){
if(s[i-1]==s[i]) cnt += 1;
else{
v.push_back(cnt+1);
cnt = 0;
}
}
if(0<cnt) v.push_back(cnt+1);
ll res = n/2;
if(1<v.size()){
res = 0;
if(s[0]!=s.back()){
rep(i, v.size()) res += v[i]/2*n;
}else{
res = *v.begin()/2+v.back()/2 + (*v.begin()+v.back())/2*(n-1);
FOR(i, 1, v.size()-1) res += v[i]/2*n;
}
}else if(0<v.size()) res = v.back()*n/2;
cout << res << endl;
}
| 0
| 77,721,084
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char a;
cin >> a;
a++;
cout << a << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;
cin>>N;
vector<int> money(N);
vector<string> NString(N);
for(int i=0;i<N;i++){
cin>>NString.at(i);
}
cin>>M;
vector<string> MString(M);
for(int i=0;i<M;i++){
cin>>MString.at(i);
}
int n1=0,n2=0;
string re1,re2;
for(int i=0;i<N;i++){
re1=NString.at(i);
for(int j=0;j<N;j++){
re2=NString.at(j);
if(re1==re2)
money.at(i)++;
}
for(int j=0;j<M;j++){
re2=MString.at(j);
if(re1==re2)
money.at(i)--;
}
}
int most=0;
for(int i=0;i<N;i++){
if(most<money.at(i))
most=money.at(i);
}
if(most<0)
most=0;
cout<<most<<endl;
}
| 0
| 92,300,953
|
#include<math.h>
#include <bits/stdc++.h>
#include <algorithm>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define ll long long int
#define py printf("Yes\n")
#define pn printf("No\n")
#define in cin>>
using namespace std;
int INF = 1001001001;
int main()
{
string s,t;
in s>>t;
sort(s.begin(), s.end());
sort(t.begin(), t.end(), greater<int>());
if(s<t)py;
else pn;
}
|
#include<iostream>
using namespace std;
int main() {
int a[100];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int sum;
int min = 100000000;
for (int i = -100; i <= 100; i++) {
sum = 0;
for (int j = 0; j < n; j++) {
sum = sum + (i - a[j]) * (i - a[j]);
}
if (sum < min)min = sum;
}
cout << min << endl;
return 0;
}
| 0
| 13,367,539
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define f(a, b) for (ll i = a; i <= b; i++)
#define pb push_back
#define pf push_front
#define mp make_pair
using namespace std;
#define N 200005
const ll INF = 1000000000000000001;
const ll MOD = 1000000000;
void solve(){
ll n; cin >> n;
ll ans =0;
ll a[n] ;
f(0, n-1) cin >> a[i];
f(1, n-1){
if(a[i] < a[i-1]) ans += a[i-1]-a[i], a[i] += (a[i-1]-a[i]);
}
cout << ans << "\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("out.txt","w",stdout);
#endif
solve();
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define INIT \
cin.tie(0); \
ios::sync_with_stdio(false);
template <class T>
inline bool chmax(T& a, T b) {
return a = (a < b) ? b : a;
}
template <class T>
inline bool chmin(T& a, T b) {
return a = (a > b) ? b : a;
}
ll const INF = 1LL << 60;
ll const MOD = 1000000007;
int main() {
INIT;
ll H, W;
cin >> H >> W;
vector<string> S(H);
rep(i, H) cin >> S[i];
vector<vector<ll>> cntX(H, vector<ll>(W, 0));
vector<vector<ll>> cntY(H, vector<ll>(W, 0));
rep(i, H) {
ll cnt = 0;
rep(j, W) {
if (S[i][j] == '#')
cnt = 0;
else
cnt++;
cntX[i][j] = cnt;
}
}
repr(i, H - 1) {
ll max_cnt = 0;
repr(j, W - 1) {
if (S[i][j] == '#')
max_cnt = 0;
else
chmax(max_cnt, cntX[i][j]);
cntX[i][j] = max_cnt;
}
}
rep(i, W) {
ll cnt = 0;
rep(j, H) {
if (S[j][i] == '#')
cnt = 0;
else
cnt++;
cntY[j][i] = cnt;
}
}
repr(i, W - 1) {
ll max_cnt = 0;
repr(j, H - 1) {
if (S[j][i] == '#')
max_cnt = 0;
else
chmax(max_cnt, cntY[j][i]);
cntY[j][i] = max_cnt;
}
}
ll ans = 0;
rep(i, H) {
rep(j, W) { chmax(ans, cntX[i][j] + cntY[i][j] - 1); }
}
cout << ans << endl;
return 0;
}
| 0
| 69,088,611
|
#include <bits/stdc++.h>
#include <vector>
#include <iostream>
#include<algorithm>
#include<string>
#include <map>
#include <queue>
#include <stack>
#include<set>
#include<tuple>
#define DIV 998244353
using namespace std;
using ll = long long;
using ldb = long double;
int main() {
ll N, K; cin >> N >> K;
vector<pair<ll, ll>> num(N);
for (int i = 0; i < N; i++) {
cin >> num[i].first >> num[i].second;
}
ll ans = 0;
for (int i = -1; i < 32; i++) {
if ((i != -1) && !(K & (1 << i)))continue;
ll temp = 0;
for (int j = 0; j < N; j++) {
for (int k = i; k < 32; k++) {
if (k == i) if (num[j].first & (1 << k))break;
if ((!(K & (1 << k))) && (num[j].first & (1 << k))) {
break;
}
else if (k == 31) {
temp += num[j].second;
}
}
}
ans = max(ans, temp);
}
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <math.h>
using namespace std;
#define rep(i,n) for(int i = 1; i < (int)(n); i++)
#define invrep(i,n) for(int i = (int)(n); i > 0; i++)
using ll = long long;
int main() {
ll a, b, c, k;
cin >> a >> b >> c >> k;
if (a >= k) {
cout << k << endl;
return 0;
}
int tmp = k - a;
rep(i, b + 1) {
--tmp;
if (tmp == 0) {
cout << a << endl;
return 0;
}
}
rep(i, c + 1) {
--tmp;
if (tmp == 0) {
cout << a - i << endl;
return 0;
}
}
}
| 0
| 34,729,622
|
#include <stdio.h>
#include <stdlib.h>
long long intSum(int *num, int size);
int intMax(int *num, int size);
int intMin(int *num, int size);
int main(int argc, const char * argv[]) {
int *num;
int size;
long long sum;
int max;
int min;
int i;
scanf("%d", &size);
num = (int *)malloc(sizeof(int) * size);
if (num == NULL) {
printf("?????¢???????¢??????§????????????\n");
exit(1);
}
for (i=0; i<size; i++) {
scanf("%d", &num[i]);
}
sum = intSum(num, size);
max = intMax(num, size);
min = intMin(num, size);
printf("%d %d %lld\n", min, max, sum);
free(num);
return 0;
}
long long intSum(int *num, int size){
int i;
long long sum = 0;
for(i=0; i<size; i++){
sum += num[i];
}
return sum;
}
int intMax(int *num, int size){
int i;
int max = num[0];
for (i=0; i<size; i++) {
if (max < num[i]) {
max = num[i];
}
}
return max;
}
int intMin(int *num, int size){
int i;
int min = num[0];
for (i=0; i<size; i++) {
if (num[i] < min) {
min = num[i];
}
}
return min;
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
#define rep2(i,a,b) for(int i=(a);i<(b);++i)
template<class T> inline void chmin(T& a, T b) {if (a > b) a = b;}
template<class T> inline void chmax(T& a, T b) {if (a < b) a = b;}
template <class T>ostream &operator<<(ostream &o,const vector<T>&v){
o<<"{";
for(int i=0;i<(int)v.size();i++) o << (i>0?", ":"") << v[i];
o<<"}";
return o;
}
int main() {
int H,W;
cin >> H >> W;
vector<string> A(H);
vector<vector<int>> grid(H,vector<int>(W,-1));
queue<vector<int>> q;
rep(i,H) {
cin >> A[i];
rep(j,W) if (A[i][j]=='#') {
grid[i][j]=0;
q.push({i,j,0});
}
}
int res = 0;
while (!q.empty()) {
auto t = q.front();
int y = t[0],x = t[1];
q.pop();
if (x>0) if (grid[y][x-1]==-1) {
grid[y][x-1] = t[2]+1;
q.push({y,x-1,t[2]+1});
}
if (y>0) if (grid[y-1][x]==-1) {
grid[y-1][x] = t[2]+1;
q.push({y-1,x,t[2]+1});
}
if (x<W-1) if (grid[y][x+1]==-1) {
grid[y][x+1] = t[2] + 1;
q.push({y,x+1,t[2]+1});
}
if (y<H-1) if (grid[y+1][x]==-1) {
grid[y+1][x] = t[2] + 1;
q.push({y+1,x,t[2]+1});
}
chmax(res,t[2]);
}
cout << res << endl;
}
| 0
| 33,882,504
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
char s;
cin >> s;
cout << char(s + 1) <<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int dx[] = {-1, 1, 0, 0};
int dy[] = { 0, 0, 1, -1};
int main(){
int h, w, d;
cin >> h >> w >> d;
vector<P> a(h*w);
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
int b;
cin >> b;
b--;
a[b] = make_pair(i, j);
}
}
vector<int> s(h*w);
for(int i=0; i<d; i++){
s[i] = 0;
}
for(int i=d; i<h*w; i++){
int dx = abs(a[i].first - a[i-d].first );
int dy = abs(a[i].second - a[i-d].second);
s[i] = s[i-d] + dx + dy;
}
int q; cin >> q;
for(int i=0; i<q; i++){
int l, r;
cin >> l >> r;
l--; r--;
cout << s[r] - s[l] << endl;
}
return 0;
}
| 0
| 34,935,911
|
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
int main() {
string S; cin >> S;
if (S[0] != 'A') {
cout << "WA" << endl;
return 0;
}
for (char c : S) {
if (c == 'A' || c == 'C') continue;
if (isupper(c)) {
cout << "WA" << endl;
return 0;
}
}
int cnt = 0;
for (int i = 2; i < S.size() - 1; ++i) {
if (S[i] == 'C') ++cnt;
}
if (cnt == 1) cout << "AC" << endl;
else cout << "WA" << endl;
return 0;
}
|
#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() {
string N; int K; cin >> N >> K;
ll dp[N.size() + 1][K + 2][2] = {};
dp[0][0][0] = 1;
REP(i, 0, N.size()) {
int n = N[i] - '0';
REP(j, 0, K + 1) {
REP(k, 0, 2) {
if (k == 0) {
REP(l, 0, n + 1) {
dp[i + 1][j + (l != 0)][l < n] += dp[i][j][k];
}
} else {
REP(l, 0, 10) {
dp[i + 1][j + (l != 0)][k] += dp[i][j][k];
}
}
}
}
}
cout << dp[N.size()][K][0] + dp[N.size()][K][1] << endl;
return 0;
}
| 0
| 17,484,553
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
const int INF = 1 << 30;
const ll LINF = 1LL << 61;
const int NIL = -1;
const int MAX = 10000;
const int MOD = 1000000007;
const double pi = 3.141592653589;
int main() {
int a, b;
cin >> a >> b;
if (a > 8 || b > 8) cout << ":(" << endl;
else cout << "Yay!" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define pb push_back
#define pii pair<ll, ll>
#define nyan "(=^･ω･^=)"
#define read_input freopen("in.txt","r", stdin)
#define print_output freopen("out.txt","w", stdout)
typedef long long ll;
typedef long double ld;
using namespace std;
const ll maxn = 4e3+10;
ll pre[4][maxn], a[maxn];
ll other(ll a, ll b) {
if(a > b) swap(a, b);
if(a == 1 && b == 2) return 3;
if(a == 1 && b == 3) return 2;
if(a == 2 && b == 3) return 1;
}
int main()
{
ll n; string s;
cin >> n >> s;
for(ll i = 1; i <= n; i++) {
if(s[i-1] == 'R') pre[1][i]++, a[i] = 1;
if(s[i-1] == 'G') pre[2][i]++, a[i] = 2;
if(s[i-1] == 'B') pre[3][i]++, a[i] = 3;
}
for(ll i = 1; i <= n; i++) {
for(ll j = 1; j <= 3; j++)
pre[j][i] += pre[j][i-1];
}
ll ans = 0;
for(ll i = 1; i <= n; i++) {
for(ll j = i+1; j <= n; j++) {
if(a[i] == a[j]) continue;
ll c = other(a[i], a[j]);
ans += pre[c][i-1];
if(2*i-j >= 1 && 2*i-j <= n) ans -= a[2*i-j] == c;
}
}
cout << ans << endl;
return 0;
}
| 0
| 53,838,328
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define DEBUG(x) cout << '>' << #x << ':' << x << endl;
#define REP(i,n) for(ll i=0;i<(n);i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define FORC(i,a,b,c) for(ll i=(a);i<(b);i+=(c))
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define ff first
#define ss second
#define dd long double
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a,b,c,k;
cin>>a>>b>>c>>k;
ll ans=min(k,a);
k-=min(k,a);
k-=min(k,b);
ans-=min(k,c);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <math.h>
#include <sstream>
#include <numeric>
#include <cctype>
#include <bitset>
#include <cassert>
#include<algorithm>
#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 rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define SIZE 100005
#define INF 1e18
#define all(x) x.begin(),x.end()
#define fi first
#define se second
#define vec vector
using pint = pair<int,int>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
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; }
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const double pi = acos(-1);
int main() {
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
ll n;cin>>n;
vll a(n+2);
for(int i=1;i<=n;i++){
cin>>a[i];
}
a[0]=0;
a[n+1]=0;
ll ans=0;
rep(i,n+1){
ans+=abs(a[i+1]-a[i]);
}
for(int i=1;i<=n;i++){
ll sum=ans;
sum=sum+abs(a[i-1]-a[i+1])-abs(a[i-1]-a[i])-abs(a[i+1]-a[i]);
cout<<sum<<endl;
}
}
| 0
| 19,624,579
|
#include<iostream>
using namespace std;
int main()
{
long int i,n,a;
while(cin>>n)
{
a=1;
for(i=n;i>=1;i--)
{
a=a*i;
}
cout<<a<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
#define rep(i,n) for(ll i = 0;i < (ll)n;i++)
#define ALL(x) (x).begin(),(x).end()
#define MOD 1000000007
int main(){
int n;
cin >> n;
vector<int> p,ne;
vector<P> res;
rep(i,n){
int x;cin >> x;
if(x >= 0)p.push_back(x);
else ne.push_back(x);
}
if(p.size() >= 2 && ne.size() >= 1){
int o = ne[0];
for(int i = 0;i < p.size()-1;i++){
res.push_back(make_pair(o,p[i]));
o = o-p[i];
}
res.push_back(make_pair(p.back(),o));
o = p.back()-o;
for(int j = 1;j < ne.size();j++){
res.push_back(make_pair(o,ne[j]));
o = o-ne[j];
}
cout << o << endl;
for(P k : res)cout << k.first << " " << k.second << endl;
}else if(p.size() == 1){
int o = p[0];
for(auto au : ne){
res.push_back(make_pair(o,au));
o = o-au;
}
cout << o << endl;
for(P k : res)cout << k.first << " " << k.second << endl;
}else if(p.size() >= 2 && ne.size() == 0){
sort(ALL(p));
int o = p[0];
for(int i = 1;i < p.size()-1;i++){
res.push_back(make_pair(o,p[i]));
o = o-p[i];
}
res.push_back(make_pair(p.back(),o));
o = p.back()-o;
cout << o << endl;
for(P k : res)cout << k.first << " " << k.second << endl;
}else if(p.size() == 0){
sort(ALL(ne),greater<int>());
int o = ne[0];
for(int i = 1;i < ne.size();i++){
res.push_back(make_pair(o,ne[i]));
o = o-ne[i];
}
cout << o << endl;
for(P k : res)cout << k.first << " " << k.second << endl;
}
return 0;
}
| 0
| 52,133,784
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin>>N;
vector<int64_t> p(N);
for(int i=0;i<N;i++){
cin>>p.at(i);
}
sort(p.begin(),p.end());
vector<int64_t> WA(N);
WA.at(0)=p.at(0);
for(int i=1;i<N;i++){
WA.at(i)=p.at(i)+WA.at(i-1);
}
int A=1;
for(int i=N-2;i>=0;i--){
if(WA.at(i)*2>=p.at(i+1)){
A++;
}
else{
break;
}
}
cout<<A<<endl;
}
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>
#include <cmath>
#include <complex>
using namespace std;
#define MOD 1000000007
#define ll long long
#define ld long double
#define FOR(i,a,b) for(ll i=(ll)a;i<(ll)b;i++)
#define rep(i,n) FOR(i,0,n)
#define pb push_back
#define mp make_pair
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define rmsame(a) sort(all(a)),a.erase(unique(all(a)), a.end())
#define rmvector(a,b) rep(i,a.size())rep(j,b.size())if(a[i]==b[j]){a.erase(a.begin()+i);i--;break;}
#define pq_pair_tB priority_queue <pair<ll,ll>, vector<pair<ll,ll> > , greater<pair<ll,ll> > >
#define pq_pair_ts priority_queue <pair<ll,ll> >
template<typename X> bool exist(vector<X> vec, X item){return find(all(vec), item)!=vec.end();}
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b,a%b);}
ll lcm(ll a, ll b){return a/gcd(a,b)*b;}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N ;
cin >> N;
ld k = (-1.0 + sqrt(1.0 + 8.0*N))/2.0;
ll siz = k;
if((siz * (siz+1)) != (2*N)){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
cout << siz+1<< endl;
vector< vector<ll> > ans;
ll till = 0;
rep(i, siz+1){
vector<ll> ret;
ll now = ans.size();
if(now >0){
rep(i, now){
ret.pb(ans[i][now-1]);
}
}
now = siz - ret.size();
rep(i, now){
till++;
ret.pb(till);
}
ans.pb(ret);
}
rep(i,ans.size()){
cout << siz << " ";
rep(j, ans[i].size()){
cout << ans[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 0
| 85,254,509
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> P;
typedef pair<int,int> Pi;
#define rep(i,n) for(ll i=0;i<n;i++)
#define FOR(i,a,b) for(ll i=a;i<b;i++)
#define fi first
#define se second
#define endl "\n"
template<typename T> inline bool chmax(T &a, T b){if(a<b){a=b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if(a>b){a=b;return true;}return false;}
template<typename T> ostream& operator<<(ostream& s,const complex<T>& d) {return s<<"("<<d.real()<<", "<<d.imag()<< ")";}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const pair<T1,T2>& d) {return s<<"("<<d.first<<", "<<d.second<<")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& d){int len=d.size();rep(i,len){s<<d[i];if(i<len-1) s<<" ";}return s;}
template<typename T> ostream& operator<<(ostream& s,const vector<vector<T>>& d){int len=d.size();rep(i,len){s<<d[i]<<endl;}return s;}
template<typename T> ostream& operator<<(ostream& s,const set<T>& v){s<<"{ ";for(auto itr=v.begin();itr!=v.end();++itr) {if (itr!=v.begin()) {s<< ", ";}s<<(*itr);}s<<" }";return s;}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const map<T1,T2>& m){s<<"{"<<endl;for(auto itr=m.begin();itr!=m.end();++itr){s<<" "<<(*itr).first<<" : "<<(*itr).second<<endl;}s<<"}"<<endl;return s;}
const ll mod=1e9+7;
const ll inf=1e17;
const int INF=1e9;
const double PI=acos(-1);
const double EPS=1e-10;
int main(){
cin.tie(0);ios::sync_with_stdio(false);
ll n,x;
cin>>n>>x;
vector<ll> a(n+1),b(n+1);
a[0]=1;
b[0]=1;
FOR(i,1,n+1){
a[i]=2*a[i-1]+3;
b[i]=2*b[i-1]+1;
}
auto dfs=[&](auto &dfs,int level,ll d)->ll{
if(level==0){
return 1ll;
}
if(d==a[level]){
return b[level];
}
level--;
if(d==1){
return 0;
}
if(1<d && d<=1+a[level]){
return dfs(dfs,level,d-1);
}
if(d==2+a[level]){
return 1+b[level];
}
return b[level]+1+dfs(dfs,level,d-2-a[level]);
};
cout<<dfs(dfs,n,x)<<endl;
}
|
#include <iostream>
using namespace std;
int main(){
int n,b,f,r,v;
cin>>n;
int array[4][3][10]={0};
for(;n>0;n--){
cin>>b>>f>>r>>v;
if(v>=0){
array[b-1][f-1][r-1]+=v;
}else if(v<0){
array[b-1][f-1][r-1]-=v*(-1);
}
}
for(b=0;b<=3;b++){
for(f=0;f<=2;f++){
for(r=0;r<=9;r++){
cout<<" "<<array[b][f][r];
}
cout<<endl;
}
if(b!=3){
cout<<"####################"<<endl;
}
}
return 0;
}
| 0
| 78,037,665
|
#include <iostream>
#include <iomanip>
#include <utility>
#include <cmath>
#include <random>
#include <vector>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <algorithm>
using namespace std;
#define rep(i,n) for(int i = 0; i<n; ++i)
#define REP(i,n) for(int i = 1; i<=n; ++i)
#define all(x) begin(x),end(x)
typedef long long ll;
typedef pair<int,int> ip;
typedef pair<ll,ll> lp;
const int inf = 1001001000;
const ll INF = 1LL<<60;
const int MOD = (int)1e9 + 7;
int main(){
ll N,X;
cin>>N>>X;
vector<lp> table (N+1);
table[0].first = 1;
table[0].second = 1;
REP(i,N){
table[i].first = table[i-1].first*2 + 3LL;
table[i].second = table[i-1].second*2 + 1LL;
}
ll ans = -1LL;
++X;
while(X>0){
++ans;
--X;
for(int i = N; i>=0; --i){
if(table[i].first <= X){
ans += table[i].second;
X -= table[i].first;
N = i;
break;
}
--X;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
std::cin >> a >> b >> c >> d;
int left = a + b, right = c + d;
if (left > right){
std::cout << "Left" << std::endl;
}
else if(left == right){
std::cout << "Balanced" << std::endl;
}
else{
std::cout << "Right" << std::endl;
}
}
| 0
| 54,922,446
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string str;
string s, p, buf;
cin >> s;
cin >> p;
buf = s + s;
if(buf.find(p)!=string::npos){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
return 0;
}
|
#include <stdio.h>
main()
{
int ai,am,as,ae,bi,bm,bs,be,s,t;
scanf("%d %d %d %d %d %d %d %d",&ai,&am,&as,&ae,&bi,&bm,&bs,&be);
s = ai+am+as+ae;
t = bi+bm+bs+be;
if (s>t) printf("%d\n",s);
else printf("%d\n",t);
}
| 0
| 32,689,703
|
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define REP(i, n) for(size_t i = 0; i < (n); ++i)
int main()
{
int D, T, S;
cin >> D >> T >> S;
if (T * S >= D)
{
cout << "Yes\n";
return 0;
}
cout << "No\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define LLINF 2000000000000000000ll
#define fi first
#define sec second
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define dmp(x) cerr << #x << ": " << x << endl;
template <class T>
void chmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
vector<T> vect(int len, T elem) {
return vector<T>(len, elem);
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.fi << ',' << p.sec;
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.fi >> p.sec;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
os << vec[i];
if (i + 1 < vec.size()) os << ' ';
}
return os;
}
template <class T>
istream &operator>>(istream &is, vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) is >> vec[i];
return is;
}
void fastio() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
#define endl "\n"
void solve() {
int N, K;
cin >> N >> K;
vector<ll> a(N);
cin >> a;
ll ans = LLINF;
for (int i = 0; i < (1 << N); i++) {
int popcnt = 0;
for (int j = 0; j < N; j++) {
if ((i >> j) & 1) popcnt++;
}
if (popcnt < K) continue;
ll res = 0ll;
ll pre = -1;
for (int j = 0; j < N; j++) {
if ((i >> j) & 1) {
if (pre >= a[j]) {
res += pre + 1 - a[j];
pre = pre + 1;
} else {
pre = a[j];
}
} else {
chmax(pre, a[j]);
}
}
chmin(ans, res);
}
cout << ans << endl;
return;
}
signed main() {
fastio();
solve();
return 0;
}
| 0
| 58,902,766
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<long long> vll;
typedef vector<int> vi;
#define io ios_base::sync_with_stdio(false)
#define pb push_back
#define eb emplace_back
#define mod 1000000007
#define PI 2*acos(0.0)
#define all(r)(r).begin(),(r).end()
#define dbg(a) cout<<#a<<" ->->->-> "<<a<<"\n"
#define inf 1000000000000000000
#define N 20000
int dirx[] = {1, -1,0, 0}, diry[] = {0, 0, 1, -1};
ll dp[10005][1005];
int h, n;
vi a, b;
ll rec(int ht, int pos)
{
if(ht <= 0)
return 0;
if(pos >= n)
return INT_MAX;
if(dp[ht][pos] != -1)
return dp[ht][pos];
ll c = 0, d = 0, f = 0;
c = rec(ht, pos + 1);
d = rec(ht-a[pos], pos + 1) + b[pos];
f = rec(ht-a[pos], pos) + b[pos];
return dp[ht][pos] = min(c, min(d, f));
}
int32_t main()
{
io;
cin>>h>>n;
for(int i = 0;i < n; i++)
{
int x, y;
cin>>x>>y;
a.push_back(x);
b.push_back(y);
}
memset(dp, -1, sizeof(dp));
cout<<rec(h, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
void bubble_sort(vector<string>& v)
{
int n = v.size();
for (int i = 0; i < n; ++i) {
for (int j = n - 1; j > i; --j) {
if (v[j - 1][1] > v[j][1]) {
swap(v[j - 1], v[j]);
}
}
}
}
void selection_sort(vector<string>& v)
{
int n = v.size();
for (int i = 0; i < n; ++i) {
int ix = i;
for (int j = i; j < n; ++j) {
if (v[j][1] < v[ix][1]) {
ix = j;
}
}
swap(v[i], v[ix]);
}
}
bool cmp(const string& s1, const string& s2)
{
return s1[1] < s2[1];
}
void print(vector<string> v)
{
int n = v.size();
for (int i = 0; i < n; ++i) {
if (i) { fprintf(stdout, " "); }
fprintf(stdout, "%s", v[i].c_str());
}
fprintf(stdout, "\n");
}
int main()
{
int n = 0;
cin >> n;
vector<string> cards(n);
for (int i = 0; i < n; ++i) {
cin >> cards[i];
}
vector<string> bubble = cards, sel = cards;
stable_sort(cards.begin(), cards.end(), cmp);
bubble_sort(bubble);
selection_sort(sel);
print(bubble);
fprintf(stdout, "%s\n", cards == bubble ? "Stable" : "Not stable");
print(sel);
fprintf(stdout, "%s\n", cards == sel ? "Stable" : "Not stable");
return 0;
}
| 0
| 36,335,264
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL<<62
#define inf 10000000007
int main() {
ll n;
cin>>n;
ll ans=0;
ll ch[52];
for(ll i=0;i<n;i++){
cin>>ch[i];
}
for(ll i=0;i<n;i++){
for(ll j=i+1;j<n;j++){
ans+=ch[i]*ch[j];
}
}
cout <<ans;
return 0;
}
|
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)((x).size())
#define jonathan ios_base::sync_with_stdio(0)
#define livingston cin.tie(0)
using namespace std;
void yes() {cout << "Yes" << endl;}
void no() {cout << "No" << endl;}
int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const int INF = 1e9 + 9;
const long long LINF = 1e18 + 8;
const double EPS = 1e-9;
const long long MOD = 1e9 + 7;
const double PI = acos(-1);
void solve() {
int n; cin >> n;
long long res = 0;
long long last = 0;
for (int i = 0; i < n; i++) {
long long x; cin >> x;
x--;
long long d = x / (last + 1);
res += d;
if (d > 0) last = max(last, 1ll);
else last = max(last, x + 1);
}
cout << res << endl;
}
int main() {
jonathan;
livingston;
solve();
return 0;
}
| 0
| 40,499,637
|
#include <bits/stdc++.h>
using namespace std;
#define Hello ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl '\n'
#define ll long long
int getFirst10(int n){
int numb = 0;
while(numb < n){
numb += 10;
}
return numb;
}
int main(){
Hello
int a[5], ans = 1e9;
for(int i = 0; i < 5; i++)
cin >> a[i];
sort(a, a + 5);
do{
int lst = 0;
for(int i = 0; i < 5; i++){
if(i == 4) lst = lst + a[i];
else lst = getFirst10(lst + a[i]);
}
ans = min(ans, lst);
}
while(next_permutation(a, a + 5));
cout << ans;
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<iomanip>
#include<map>
#include<set>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;
#define DEBUG(x) cout<<#x<<"="<<x<<endl
#define DEBUG2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<endl
typedef long long ll;
class Solver{
public:
static const int MAXN=50;
char grid[2*MAXN][2*MAXN+1];
void output(){
for(int u=0;u<2*MAXN;u++){
cout<<grid[u]<<'\n';
}
}
void solve(){
int w,b;
cin>>w>>b;
w--;b--;
for(int u=0;u<MAXN;u++){
for(int v=0;v<2*MAXN;v++){
grid[u][v]='#';
}
if(u%2==0&&w){
for(int v=0;v<2*MAXN&&w;v+=2){
grid[u][v]='.';
w--;
}
}
}
for(int u=2*MAXN-1;u>=MAXN;u--){
for(int v=0;v<2*MAXN;v++){
grid[u][v]='.';
}
if(u%2==1&&b){
for(int v=0;v<2*MAXN&&b;v+=2){
grid[u][v]='#';
b--;
}
}
}
cout<<100<<" "<<100<<'\n';
output();
}
};
int main()
{
(new Solver())->solve();
}
| 0
| 23,265,202
|
#include <iostream>
using namespace std;
int main(){
int x,y=1;
while(cin >> x,x){
cout << "Case "<< y << ": " << x << endl;
y++;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s,s2;
long long k,n,i,j,p,p2;
cin >> s >> k;
n=s.size();
p=0;
p2=0;
j=0;
int a=1;
for(i=0;i<n-1;i++){
if(s.at(i)!=s.at(i+1)){
a=0;
}
}
if(a==1){
cout << n*k/2 << endl;
}else{
s2=s+s;
for(i=0;i<n;i++){
if(i==n-1){
p=p+(j+1)/2;
j=0;
}else if(s.at(i)!=s.at(i+1)){
p=p+(j+1)/2;
j=0;
}else{
j++;
}
}
for(i=0;i<n*2;i++){
if(i==n*2-1){
p2=p2+(j+1)/2;
j=0;
}else if(s2.at(i)!=s2.at(i+1)){
p2=p2+(j+1)/2;
j=0;
}else{
j++;
}
}
cout << (k-1)*p2-(k-2)*p << endl;
}
}
| 0
| 79,527,561
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cmath>
using namespace std;
typedef long long ll;
ll MOD = 1e9+7;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
char a, b;
cin >> a >> b;
if ( a == 'H' && b == 'H' || a == 'D' && b == 'D' ) cout << 'H' << endl;
else cout << 'D' << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define repl(i, l, r) for (int i = l; i < r; ++i)
#define rep(i, n) repl(i, 0, n)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using G = vector<vector<int>>;
const int MOD = 998244353;
const int INF = 1001001001;
const int dy[] = {-1, 0, 1, 0};
const int dx[] = {0, -1, 0, 1};
int main()
{
int n;
cin >> n;
vector<ll> d(n);
rep(i, n) {
cin >> d[i];
if(i == 0 && d[i] != 0) {
cout << 0 << endl;
return 0;
}
else if(i != 0 && d[i] == 0) {
cout << 0 << endl;
return 0;
}
}
map<ll,ll> mp;
rep(i, n) {
++mp[d[i]];
}
ll ans = 1;
repl(i, 1, n) {
ans *= mp[d[i]-1];
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 0
| 97,988,787
|
#include <cstdio>
#include <vector>
using namespace std;
int n,m,x,ans=0x7fffffff;
int c[15],a[15][15];
int main(){
scanf("%d%d%d",&n,&m,&x);
for(int i=1;i<=n;++i){
scanf("%d",c+i);
for(int j=1;j<=m;++j){
scanf("%d",a[i]+j);
}
}
for(int i=0;i<(1<<n);++i){
int t=i,sum=0;
vector<int>v(m+1,0);
for(int j=0;j<n;++j){
if(t&1){
for(int k=1;k<=m;++k){
v[k]+=a[j+1][k];
}
sum+=c[j+1];
}
t>>=1;
}
int j;
for(j=1;j<=m;++j){
if(v[j]<x)break;
}
if(j>m){
ans=(sum<ans?sum:ans);
}
}
if(ans==0x7fffffff)printf("-1\n");
else printf("%d\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll H, W;
int main() {
cin >> H >> W;
ll ans = INF;
if (H % 3 == 0) {
cout << 0 << endl;
return 0;
}
ll pat1_max = ((H / 3) + 1) * W;
ll pat1_min = ((H / 3)) * W;
ll pat1_area = pat1_max - pat1_min;
ans = min(ans, pat1_area);
ll pat2_max = ((W / 3) + 1) * H;
ll pat2_min = ((W / 3)) * H;
ll pat2_area = pat2_max - pat2_min;
ans = min(ans, pat2_area);
ll w1 = (W / 2);
ll w2 = ceil(W / 2.0);
for (int h = 1; h <= H - 1; h++) {
ll a1 = h * W;
ll a2 = (H - h) * w1;
ll a3 = (H - h) * w2;
vector<ll> v1 = {a1, a2, a3};
sort(v1.begin(), v1.end());
ll pat3_area = v1[2] - v1[0];
ans = min(ans, pat3_area);
}
ll h1 = H / 2;
ll h2 = ceil(H / 2.0);
for (int w = 1; w <= W - 1; w++) {
ll a1 = w * H;
ll a2 = (W - w) * h1;
ll a3 = (W - w) * h2;
vector<ll> v1 = {a1, a2, a3};
sort(v1.begin(), v1.end());
ll pat4_area = v1[2] - v1[0];
ans = min(ans, pat4_area);
}
cout << ans << endl;
}
| 0
| 98,809,074
|
#include <cstdio>
#include <algorithm>
#include <climits>
typedef long long ll;
const int max_t = 20;
ll dist[max_t][max_t];
int main() {
while (1) {
int n, t = 0;
scanf("%d", &n);
if (n == 0) break;
for (int i = 0; i < max_t; i++) {
std::fill(dist[i], dist[i] + max_t, INT_MAX);
}
for (int i = 0; i < n; i++) {
int from, to;
ll d;
scanf("%d%d%lld", &from, &to, &d);
t = std::max(t, from);
t = std::max(t, to);
dist[from][to] = d;
dist[to][from] = d;
}
for (int i = 0; i <= t; i++) {
dist[i][i] = 0;
}
for (int k = 0; k <= t; k++) {
for (int i = 0; i <= t; i++) {
for (int j = 0; j <= t; j++) {
if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX)
dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
ll min_len = INT_MAX;
int start = -1;
for (int i = 0; i <= t; i++) {
ll len = 0;
for (int j = 0; j <= t; j++) {
if (j == i) continue;
len += dist[i][j];
}
if (len < min_len) {
min_len = len;
start = i;
}
}
printf("%d %lld\n", start, min_len);
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <iomanip>
#include <math.h>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
unsigned long gcd(unsigned long a, unsigned long b)
{
if (a%b == 0)
{
return(b);
}
else
{
return(gcd(b, a%b));
}
}
unsigned long lcm(unsigned long a, unsigned long b)
{
return a * b / gcd(a, b);
}
int main(){
unsigned long A,B,C,D;
cin>>A>>B>>C>>D;
unsigned long c,d,cc,dd,E,e,ee;
if(A%C==0)c=A/C-1;
else c=A/C;
if(A%D==0)d=A/D-1;
else d=A/D;
E=lcm(C,D);
if(A%E==0)e=A/E-1;
else e=A/E;
cc=B/C;
dd=B/D;
ee=B/E;
cout<<-cc+c-dd+d+ee-e+B-A+1;
return 0;
}
| 0
| 15,750,735
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
for(int i=0;i<S.size();i++){
if(S.at(i) == 'a' ||
S.at(i) == 'i' ||
S.at(i) == 'u' ||
S.at(i) == 'e' ||
S.at(i) == 'o'){
cout << "vowel" << endl;
}else{
cout << "consonant" << endl;
}
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<ll>;
using vvi = vector<vi>;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
int main() {
int n, m;
cin >> n >> m;
vi x(n), y(n), z(n);
rep(i, n) {
cin >> x[i] >> y[i] >> z[i];
}
vi dp;
int kirei[2] = {1, -1};
int oisisa[2] = {1, -1};
int ninkido[2] = {1, -1};
ll ans = -LINF;
rep(i, 2) {
rep(j, 2) {
rep(k, 2) {
dp.assign(m+1, -LINF);
dp[0] = 0;
rep(q, n) {
for(int l = m; l>0; --l) {
if(dp[l-1] == -LINF) continue;
dp[l] = max(dp[l], dp[l-1] + x[q]*kirei[i] + y[q]*oisisa[j] + z[q]*ninkido[k]);
}
}
ans = max(ans, dp[m]);
}
}
}
cout << ans << endl;
}
| 0
| 7,740,523
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const LL N = 1000000007;
LL ec = 0,hed[200005] = {0},nxt[400005],to[400005];
void add_edge(LL f,LL t){
++ ec; to[ec] = t; nxt[ec] = hed[f]; hed[f] = ec;
}
LL n,flg,a[200005];
LL deg[200005] = {0},siz[200005],mx[200005];
void dfs(LL u,LL f){
for(LL i = hed[u];i;i = nxt[i]){
LL v = to[i];
if(v == f) continue;
dfs(v,u);
mx[u] = max(mx[u],mx[v]);
siz[u] += siz[v];
}
if(deg[u] == 1){
siz[u] = a[u];
mx[u] = a[u];
}
else{
LL del = siz[u] - a[u],mxd;
mxd = (mx[u] * 2 > siz[u] ? siz[u] - mx[u] : (siz[u] >> 1));
if(del < 0 || del > mxd) flg = 0;
siz[u] -= (del << 1); mx[u] = siz[u];
}
}
int main(){
ios::sync_with_stdio(false);
LL u,v;
cin >> n;
for(LL i = 1;i <= n;i ++) cin >> a[i];
for(LL i = 1;i < n;i ++){
cin >> u >> v;
add_edge(u,v); add_edge(v,u);
deg[u] ++; deg[v] ++;
}
if(n == 2){
if(a[1] == a[2]) cout << "YES" << endl;
else cout << "NO" << endl;
return 0;
}
LL rt = 1; for(LL i = 1;i <= n;i ++) if(deg[i] != 1) rt = i;
add_edge(n + 1,rt); a[n + 1] = 0;
flg = 1; dfs(n + 1,0);
cout << (flg ? "YES" : "NO") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<vector<int>, long long> mp;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vector<int> abc(27);
for (char c : s) abc[c-'a']++;
mp[abc]++;
}
long long ans = 0;
for (auto m: mp) {
ans += m.second * (m.second - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 0
| 31,372,234
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<ll,ll>;
const ll mod = 1e9+7;
#define ALL(x) (x).begin(),(x).end()
#define pow(x,y) modpow(x,y)
#define REP(i,n) for(ll (i)=0;(i)<(n);(i)++)
template <class T = int>T in(){
T x;
cin >> x;
return (x);
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
cout << in() - in() + 1 << "\n";
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n;
vector<int> box(3);
cin >> box.at(0) >> box.at(1) >> box.at(2) >> n;
int ans = 0;
for(int i = 0; box.at(0) * i <= n; i++) {
int x = n - box.at(0) * i;
for(int j = 0; j * box.at(1) <= x; j++) {
int y = x - box.at(1) * j;
if(y % box.at(2) == 0) ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 83,114,087
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<ll, ll> PLL;
#define chmax(x, y) do { x = max(x, y); } while(0)
#define chmin(x, y) do { x = min(x, y); } while(0)
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) \
for (ll i = static_cast<ll>(a); i < static_cast<ll>(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, ) (__VA_ARGS__)
template<typename T>
using reversed_priority_queue = std::priority_queue<T, std::vector<T>, std::greater<T> >;
signed main() {
ll M, n = 0, s = 0;
cin >> M;
rep(i, M) {
ll d, c;
cin >> d >> c;
n += c;
s += d * c;
}
ll C = (n-1) * 9 + (s-1);
cout << C/9 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <numeric>
#define rep(i,n) for (int i = 0; i < n; ++i)
#define reps(i,s,n) for (int i = s; i < n; ++i)
#define rep1(i,n) for (int i = 1; i <= n; ++i)
#define per(i,n) for (int i = n - 1; i >= 0; --i)
#define per1(i,n) for (int i = n; i >= 1; --i)
#define all(c) begin(c),end(c)
template<typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> inline T intceil(T a, T b) { return (a + (b - 1)) / b; }
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
const long long MOD = 1e9+7;
#define precout() cout << std::fixed << std::setprecision(20);
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
const int dy[4] = { 0, 1, 0, -1 };
const int dx[4] = { 1, 0, -1, 0 };
static const long double pi = acos(-1.0);
typedef complex<ld> cd;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
vector<ll> T(N), A(N);
bool ng = 0;
cin >> T[0];
rep1(i, N-1) {
cin >> T[i];
if(T[i] < T[i - 1]) {
ng = 1;
}
}
cin >> A[0];
rep1(i, N-1) {
cin >> A[i];
if(A[i] > A[i - 1]) {
ng = 1;
}
}
if(T.back() != A.front()) {
ng = 1;
}
if(ng) {
cout << 0 << endl;
return 0;
}
ll ans = 1;
rep1(i, N-2) {
if(T[i] != T[i-1] && A[i] != A[i+1] && A[i] != T[i]) {
cout << 0 << endl;
return 0;
}
if(T[i] != T[i-1] && T[i] > A[i]) {
cout << 0 << endl;
return 0;
}
if(A[i] != A[i+1] && A[i] > T[i]) {
cout << 0 << endl;
return 0;
}
if(T[i] != T[i-1] || A[i] != A[i+1]) continue;
ans *= min(T[i], A[i]);
ans %= MOD;
}
cout << ans << endl;
}
| 0
| 76,756,489
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
char op;
cin >> A >> op >> B;
cout << ((op == '+') ? A + B : A - B) << "\n";
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#define ll long long int
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define phi 3.1415926535
#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl '\n'
using namespace std;
const ll mod = 1000000007;
ll tc, cnt = 0, number, many, total = 0, query;
int rmove[8] = {-1, 0, 1, 0, -1, 1, -1, 1};
int cmove[8] = {0, 1, 0, -1, 1, -1, -1, 1};
ll power(ll x, ll y, ll mod)
{
if(y == 0)
return 1;
else if(y % 2 == 0)
return (power(x, y / 2, mod) % mod * power(x, y / 2, mod) % mod) % mod;
else
return x * (power(x, y / 2, mod) % mod * power(x, y / 2, mod) % mod) % mod;
}
int main()
{
fastio();
cin >> many >> number;
int arr[many];
for(int i = 0; i < many; i++)
cin >> arr[i];
int dp[many];
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for(int i = 0; i < many; i++)
{
for(int j = i + 1; j <= i + number && j < many; j++)
{
if(dp[j] == -1)
dp[j] = dp[i] + abs(arr[j] - arr[i]);
else
dp[j] = min(dp[i] + abs(arr[j] - arr[i]), dp[j]);
}
}
cout << dp[many - 1] << endl;
return 0;
}
| 0
| 58,213,028
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1000000007;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REP2(i, x, n) for (ll i = x; i < (n); i++)
#define PR(x) cout << (x) << "\n"
#define PS(x) cout << (x) << " "
const long long INF = numeric_limits<long long>::max();
int main() {
ll N;
cin >> N;
map<ll, ll> values;
REP(i, N) {
ll n;
cin >> n;
values[n]++;
}
bool isOk = true;
for (const auto& v : values) {
isOk &= v.second == 1;
}
PR(isOk ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define DEBUG
#define PI 3.141592653589793238462643383279
#define _GLIBCXX_DEBUG
#ifdef DEBUG
#define s(...) show(__VA_ARGS__);
#define sl(...) show(__VA_ARGS__);cout<<endl;
#else
#define s(...)
#define sl(...)
#endif
void show() {}
template <class Head,class... Args>void show(Head t,Args... args){std::cout<<t<<" ";show(args...);}
#define REP(i, n) for(ll i = 0; i < n; i++)
#define REPR(i, n) for(ll i = n; i >= 0; i--)
#define FOR(i, m, n) for(ll i = m; i < n; i++)
#define REP1(i, n) for(ll i = 1; i <= n; i++)
#define REPR1(i, n) for(ll i = n; i >= 1; i--)
#define FOR1(i, m, n) for(ll i = m; i <= n; i++)
const ld INF = 1e9+123;
#define VEC(type,A,N) vector<type> A(N)
#define VECi(type,A,N,i) vector<type> A(N,i)
#define VEC2(type,A,N,M) vector<vector<type>> A(N,vector<type>(M))
#define VEC2i(type,A,N,M,i) vector<vector<type>> A(N,vector<type>(M,i))
#define ALL(v) v.begin(), v.end()
ll frac(ll k){
int s = 1;
for (ll i=1; i<=k; ++i)s *= i;
return s;
}
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 antidiv(ll N,ll C,ll D){
return N-floor(N/C)-floor(N/D)+floor(N/lcm(C,D));
}
vector<ll> yakusuu(ll N){
vector<ll> ret;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
ret.push_back(i);
if (i * i != N) ret.push_back(N / i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
int main(){
int N;
cin>>N;
VEC(string,v,0);
string bef="";
REP(i,N){
string s;
cin>>s;
auto t=find(ALL(v),s);
if(i>0&&(s[0] != bef[0] || t != v.end())){
cout<<"No";return 0;
}
v.push_back(s);
bef=s[s.length()-1];
}
cout<<"Yes";
cout<<endl;
return 0;
}
| 0
| 74,951,467
|
#include <iostream>
#include <algorithm>
#include <map>
#include <utility>
using namespace std;
int n, m, a[100005];
map<int, int> mp;
int main()
{
cin >> n >> m;
long long rj = 0, s = 0;
for (int i = 0; i < n; ++i)
{
cin >> a[i];
s = (s + a[i]) % m;
if (s == 0)
++rj;
if (mp.find(s) != mp.end())
rj += mp[s];
++mp[s];
}
cout << rj << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main()
{
int N; cin >> N;
vector<Int> A(N); for (auto& a : A) cin >> a;
Int cnt = 0;
Int minimum = *min_element(begin(A), end(A));
for (auto& a : A) {
a -= minimum;
cnt += a / (N+1);
a %= N+1;
}
for (auto& a : A) a += minimum + cnt;
sort(rbegin(A), rend(A));
vector<Int> B(N);
for (int i = 0; i < N; i++) {
B[i] = A[i]+i;
if (B[i] <= N-1) {
cout << cnt + i << endl;
return 0;
}
}
int t = min_element(begin(B), end(B)) - begin(B);
while (t--) {
*max_element(begin(A), end(A)) -= N + 1;
for (auto& a : A) a += 1;
cnt++;
}
Int maximum = *max_element(begin(A), end(A));
cout << cnt + (maximum - N + 1) * N << '\n';
return 0;
}
| 0
| 69,011,614
|
#include <bits/stdc++.h>
using namespace std;
#define BE(x) (x).begin(), (x).end()
int main() {
int n, m, a, b;
cin >> n >> m;
vector<vector<int>> v(n+1);
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int s = v[1].size();
for (int i = 0; i < s; i++) {
int x = v[1][i];
if (*max_element(BE(v[x])) == n) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
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; }
const int mod=1000000007;
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int K,N;
cin>>K>>N;
vector<int>A(N);
for(int i=0;i<N;i++){
cin>>A[i];
}
int r,l;
int MIN=INF;
for(int i=0;i<N;i++){
if(i==0){l=A[0]+(K-A[N-1]);}
else {l=A[i]-A[i-1];}
if(i==N-1){r=K-A[N-1]+A[0];}
else{r=A[i+1]-A[i];}
int m=min(K-r,K-l);
chmin(MIN,m);
}
cout<<MIN<<endl;
return 0;
}
| 0
| 4,247,208
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define int ll
#define _GLIBCXX_DEBUG
#define REP(i,n) for (int i = 0; i < (n); ++i)
#define REPD(i,n) for (int i = (n-1); i >= 0; --i)
#define FORE(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define debug(x) cerr << #x << ": " << x << '\n'
#define hyphen() cerr << "--\n"
#define ALL(vec) (vec).begin(), (vec).end()
#define REVALL(vec) (vec).rbegin(), (vec).rend()
#define fst first
#define snd second
#define pb push_back
const int MOD = (int)1e9 + 7;
const int INF = numeric_limits<int>::max();
double log5(double x) {
return log(x) / log(5);
}
signed main() {
int N;
cin >> N;
if (N < 2 || N % 2 == 1) {
cout << 0 << endl;
return 0;
}
int digits = log5(N);
int ans = 0;
FORE(i, 1, digits) {
int a = pow(5, i);
int b = pow(5, i+1);
int num = (N / a) / 2 - (N / b) / 2;
debug(i);
debug(num);
ans += num * i;
}
cout << ans << endl;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
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;}
ll maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
ll digsz(ll x){if(x==0) return 1;else{ll ans=0;while(x){x/=10;ans++;}return ans;}}
ll digsum(ll x){ll sum=0;while(x){sum+=x%10;x/=10;}return sum;}
vector<ll> pw2(62,1);vector<ll> pw10(19,1);
ll dx[8]={0,0,-1,1,-1,1,-1,1};
ll dy[8]={1,-1,0,0,1,1,-1,-1};
vector<vector<ll> > c(10,vector<ll>(10,0));
int main(){
{rep1(i,61) pw2[i]=2*pw2[i-1];}
{rep1(i,18) pw10[i]=10*pw10[i-1];}
vector<ll> X(26,INF);
string s,t; cin>>s>>t;
rep(i,sz(s)){
ll tmp1=s[i]-'a';
ll tmp2=t[i]-'a';
if(X[tmp1]==INF){
X[tmp1]=tmp2;
}
else if(X[tmp1]!=tmp2){
cout<<"No"<<endl;
return 0;
}
}
ll cnt=0;
set<ll> se;
rep(i,26){
if(X[i]!=INF){
cnt++;
se.insert(X[i]);
}
}
if(sz(se)!=cnt){
cout<<"No"<<endl;
return 0;
}
cout<<"Yes"<<endl;
return 0;
}
| 0
| 61,525,343
|
#include<iostream>
using namespace std;
int main()
{
char c;
while (cin >> c)
{
if (c == '1') cout << '9';
else cout << '1';
}
return 0;
}
|
#include <bits/stdc++.h>
typedef int64_t int64;
typedef uint32_t uint;
typedef uint64_t uint64;
using namespace std;
template <typename T>
inline void print(const T& rhs){ std::cout<<" = "<<rhs<<std::endl; }
template <typename T>
inline void print(const std::vector<T>& rhs){
std::cout<<" = [ ";
for(uint i=0; i<rhs.size(); ++i){ std::cout<<rhs[i]<<' '; }
std::cout<<"]"<<std::endl;
}
template <typename T>
inline void print(const std::vector<std::vector<T>>& rhs){
std::cout<<" = "<<std::endl;
std::cout<<"[[ ";
for(uint p=0; p<rhs.size(); ++p){
if(p!=0){ std::cout<<" [ "; }
for(uint q=0; q<rhs[p].size(); ++q){
std::cout<<rhs[p][q]<<' ';
}
if(p!=rhs.size()-1){ std::cout<<"]"<<std::endl; }
}
std::cout<<"]]"<<std::endl;
}
template <typename TL, typename TR>
inline void print(const std::vector<std::pair<TR,TL>>& rhs){
std::cout<<" = [";
uint i=0;
for(; i<rhs.size()-1; ++i){ std::cout<<"[f: "<<rhs[i].first<<", s: "<<rhs[i].second<<"], "; }
std::cout<<"[f: "<<rhs[i].first<<", s: "<<rhs[i].second<<"]]" << endl;
}
#define printn(var) {printf("%s", #var);print(var);}
#define printn_all(var) {printf("%s(%d): ", __func__, __LINE__);printf("%s", #var);print(var);}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64 N, M; cin >> N >> M;
if (N==1 && M==1){ cout << 1 << endl;
}else if(N==1 && M>=2){ cout << (M-2) << endl;
}else if(N>=2 && M==1){ cout << (N-2) << endl;
}else if(N>=2 && M>=2){ cout << (N-2)*(M-2) << endl; }
return 0;
}
| 0
| 65,641,198
|
#include<bits/stdc++.h>
using namespace std;
#define inf 1e9 + 5
int main() {
int n, k;
cin >> n >> k;
vector< int > height(n);
for (int& i: height) cin >> i;
vector< int > dp (n, inf);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= i + k; j++) {
if (j < n) dp[j] = min (dp[j], dp[i] + abs(height[i] - height[j]));
}
}
cout << dp[n - 1];
}
|
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
string S,T;
cin>>S>>T;
vector<int>a1;
vector<int>b1;
long long int f,g,i,j,t=0;
map<char,int>a;
for(i=0;S[i];i++)
{f=a[S[i]];
a[S[i]]++;
a1.push_back(f+1);}
sort(a1.begin(),a1.end());
map<char,int>b;
for(i=0;T[i];i++)
{g=b[T[i]];
b[T[i]]++;
b1.push_back(g+1);}
sort(b1.begin(),b1.end());
for(j=0;j<i;j++)
{
if(a1[j]!=b1[j])
{t=1;
break;}
}
if(t==1)
cout<<"No";
else
cout<<"Yes";
}
| 0
| 14,303,970
|
#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 (int i = (s); i < (int)(n); i++)
using namespace std;
using vi = vector<int>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
int nyakusu(int x){
int ans=1;
rep2(i,2,x+1){
int j=0;
while(1){
if(x%i!=0)break;
x/=i;
j++;
}ans*=(j+1);
}
return ans;
}
int main() {
vi a(201,0);
int n;
cin>>n;
rep2(i,1,201){
if(i%2==1&&nyakusu(i)==8)a.at(i)++;
}
rep2(i,2,201)a.at(i)+=a.at(i-1);
cout<<a.at(n)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >>S;
vector<long long>aaa(S.size()+1,0);
long long answer=0;
for(long long i=0;i<S.size();i++){
if(S.at(i)=='<'){
aaa.at(i+1)=aaa.at(i)+1;
}
}
for(long long i=S.size()-1;0<=i;i--){
if(S.at(i)=='>'){
if(aaa.at(i+1)>=aaa.at(i)){
aaa.at(i)=aaa.at(i+1)+1;
}
}
}
for(int i=0;i<=S.size();i++){
answer+=aaa.at(i);
}
cout<<answer<<endl;
}
| 0
| 98,152,685
|
#include <bits/stdc++.h>
#include<algorithm>
#define int long long
using namespace std;
typedef pair<int,int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 1000000000000
int MOD=1000000007;
struct edge {
int to, cost;
};
int modpow(int a,int x){
if(a<0)a+=MOD;
int ans=1;
while(x>0){
if(x&1) ans=ans*a%MOD;
a=a*a%MOD;
x>>=1;
}
return ans;
}
int gyaku(int n){
return modpow(n,MOD-2);
}
auto factor(int n){
map<int,int>res;
for(int i=2;i*i<=n;i++){
for(; n%i==0;n/=i) res[i]++;
}
if(n>1)res[n]++;
return res;
}
signed main() {
int n;
cin>>n;
int c[n],s[n],f[n];
rep(i,n-1)cin>>c[i]>>s[i]>>f[i];
rep(i,n-1){
int x=s[i]+c[i];
for(int j=i+1;j<n-1;j++){
if(x-s[j]<0)x=s[j]+c[j];
else if((x-s[j])%f[j]==0)x+=c[j];
else x=f[j]-(x-s[j])%f[j]+x+c[j];
}
cout<<x<<endl;
}
cout<<0<<endl;
}
|
#include <bits/stdc++.h>
typedef long long LL;
#define FOR(i,a,b) for(LL i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
LL p = 1000000007ll;
int main(void)
{
LL n;
cin >> n;
vector<int> a(n);
for(auto &x:a) cin >> x;
LL l = 0;
LL r = n;
while(r-l>1) {
LL piv = (l+r+1) / 2;
vector<pair<int,int>> str;
bool lpiv = false;
for(auto x:a) {
bool more = false;
while(!str.empty() && str.back().first > x) {
more = true;
str.pop_back();
}
if(more && piv == 1) {
lpiv = true;
break;
}
if(str.empty() || str.back().first < x) {
if(more) str.emplace_back(x,2);
else str.emplace_back(x,1);
} else {
LL updatePos = x;
while(!str.empty() && str.back().first == updatePos && str.back().second == piv) {
--updatePos;
str.pop_back();
}
if(updatePos == 0) {
lpiv = true;
break;
}
if(!str.empty() && str.back().first == updatePos) {
++str.back().second;
} else {
str.emplace_back(updatePos,2);
}
if(updatePos != x) str.emplace_back(x,1);
}
}
if(lpiv) l = piv;
else r = piv;
}
cout << r << endl;
return 0;
}
| 0
| 60,627,697
|
#pragma GCC optimize ("O3")
#pragma GCC target ("avx")
#include<bits/stdc++.h>
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 hist[300002];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
rep(i, N) {
int a;
cin >> a;
hist[a]++;
}
sort(hist + 1, hist + N + 1);
int k = N + 1;
int ruiseki = N;
int mae = 0;
for (int i = N; i >= 1; i--) {
while (hist[k - 1] >= i) {
ruiseki -= hist[--k];
}
int ijou = N - k + 1;
int kei = ijou + ruiseki / i;
for (int j = mae + 1; j <= kei; j++) co(i);
mae = kei;
}
for (int j = mae + 1; j <= N; j++) co(0);
Would you please return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
bool diff = false;
long long ans = 0;
int big = 1E9 + 6;
for (int i = 0; i < n; i++)
{
int a, b;
cin >> a >> b;
ans += a;
if (a > b && b < big)
big = b;
diff = diff || (a != b);
}
ans -= big;
if (!diff)
ans = 0;
cout << ans << endl;
return 0;
}
| 0
| 10,715,740
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long int
int main(){
int D;
cin>>D;
if(D==25)
cout<<"Christmas";
else if(D==24)
cout<<"Christmas Eve";
else if(D==23)
cout<<"Christmas Eve Eve";
else
cout<<"Christmas Eve Eve Eve";
return 0;
}
|
#include<bits/stdc++.h>
#include<ctype.h>
# define pb push_back
#define fst first
#define sec second
#define For(i,a,b) for(int i=a;i<b;i++)
#define ll long long int
#define ull unsigned long long int
#define mod 1000000007
#define fo(i,n) for(ll i=0;i<n;i++)
#define endl "\n"
#define rev(i,n) for(ll i=n-1;i>=0;i--)
#define fo1(i,n) for(ll i=1;i<=n;i++)
#define boolsize 1000001
#define pi pair<ll,ll>
#define vi vector<ll>
#define vii vector<pi>
using namespace std;
template<typename T>
void showvector(vector <T> v)
{
for(T x:v)
cout<<x<<" ";
cout<<endl;
}
template<typename T>
void showvector1(vector <T> v)
{
ll n=v.size();
fo1(i,n-1)
cout<<v[i]<<endl;
}
template<typename T>
void showset(set <T> s)
{
for(T x: s)
cout<<x<<" ";
cout<<endl;
}
template<class T>
void showvectorpair(vector<T> v)
{
for(auto it=v.begin();it!=v.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T,typename P>
void showmap(map <T,P> m)
{
for(auto it=m.begin();it!=m.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T>
bool comp(T a,T b)
{
return (a>b);
}
template<class T>
bool comppair(T a,T b)
{
if(a.first==b.first)
return(a.second>b.second);
return (a.first>b.first);
}
bool sameparity(ll a,ll b)
{
return (a%2==b%2);
}
bool difparity(ll a,ll b)
{
return !(a%2==b%2);
}
bool isprime(ll x)
{ if(x<=1)
return false;
for(ll i=2;i<=sqrt(x);i++)
{
if(x%i==0)
return false;
}
return true;
}
bool iseven(ll x)
{
return !(x%2);
}
bool isodd(ll x)
{
return (x%2);
}
void vfun()
{
ll n,k;
cin>>n;
vector <ll> v(n);
fo(i,n)
cin>>v[i];
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("inputh.txt", "r", stdin);
freopen("outputh.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
ll test=1;
while(test--)
{
ll n,k,start=0,ans=0;;
cin>>n>>k;
vector <ll> v(n);
fo(i,n)
cin>>v[i];
fo(i,n)
{
if(i==n-1)
{
ans+=v[i]-v[start]+k;
break;
}
if(v[i]+k < v[i+1])
{
ans+=v[i]+k-v[start];
start=i+1;
}
}
cout<<ans;
}
}
| 0
| 38,094,265
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <cmath>
#include <map>
#include <climits>
#include <cassert>
#include <algorithm>
#include <utility>
using namespace std;
using Int = long long int;
using UInt = unsigned long long int;
using VI = vector<long long int>;
using VVI = vector<vector<long long int> >;
int main(void) {
Int n, m;
cin >> n >> m;
cout << (n * (n - 1) + m * (m - 1)) / 2 << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define cinsc ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(0);
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOR(i,k,n) for(int64 i=k;i<(int64)n;i++)
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define FOREACHr(it, l) for (auto it = l.rbegin(); it != l.rend(); it++)
#define IN(A, B, C) assert( B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
#define SQ(x) ((x)*(x))
const double pi=acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int,int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
int64 powr(int64 x,int64 y,int64 p)
{
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0){
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
void in_o(){
#ifndef LOCAL
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
cinsc;
}
int main(){
int n;
cin>>n;
deque <int> q;
FOR(i,0,n){
int x;
cin>>x;
if(i%2)
q.push_front(x);
else
q.push_back(x);
}
if(!(n%2))
FOREACH(it,q){
cout<<*it<<" ";
}
else
FOREACHr(it,q){
cout<<*it<<" ";
}
return 0;
}
| 0
| 24,912,899
|
#include <bits/stdc++.h>
using namespace std;
#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 INF 10000000000
#define MOD 1000000007
using ll = long long;
using Graph = vector<vector<int>>;
int N;
ll D, A;
vector<ll> X, H;
ll solve()
{
vector<int> idx(N);
rep(i, N) idx[i] = i;
sort(idx.begin(), idx.end(), [](int i, int j) { return X[i] < X[j]; });
vector<ll> NX(N), NH(N);
rep(i, N) NX[i] = X[idx[i]], NH[i] = H[idx[i]];
X = NX, H = NH;
vector<ll> IMOS(N + 1, 0);
ll res = 0;
rep(i, N)
{
if (IMOS[i] < H[i])
{
ll need = (H[i] - IMOS[i] - 1) / A + 1;
ll right = X[i] + 2 * D;
int r_id = upper_bound(X.begin(), X.end(), right) - X.begin();
IMOS[i] += need * A;
IMOS[r_id] -= need * A;
res += need;
}
IMOS[i + 1] += IMOS[i];
}
return res;
}
int main()
{
cin >> N >> D >> A;
X.resize(N);
H.resize(N);
rep(i, N) cin >> X[i] >> H[i];
cout << solve() << endl;
}
|
#include<bits/stdc++.h>
const double pi=acos(-1.0);
using namespace std;
#define endl '\n'
#define sl(n) scanf("%lld",&n)
#define mp make_pair
#define pb push_back
#define ppb pop_back
#define fi first
#define se second
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define f(i,a,b) for(ll i = (ll)(a); i < (ll)(b); i++)
#define rf(i,a,b) for(ll i = (ll)(a); i > (ll)(b); i--)
#define ms(a,b) memset((a),(b),sizeof(a))
#define abs(x) ((x<0)?(-(x)):(x))
#define MAX 1000005
#define inf LLONG_MAX
#define ninf LLONG_MIN
#define MIN INT_MIN
#define yeet return 0;
#define fast_io ios_base::sync_with_stdio (false) ; cin.tie(0) ; cout.tie(0) ;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
inline long long MAX2(long long a, long long b){return (a)>(b)?(a):(b);}
inline long long MAX3(long long a, long long b,long long c){return (a)>(b)?((a)>(c)?(a):(c)):((b)>(c)?(b):(c));}
inline long long MIN2(long long a, long long b){return (a)<(b)?(a):(b);}
inline long long MIN3(long long a, long long b,long long c){return (a)<(b)?((a)<(c)?(a):(c)):((b)<(c)?(b):(c));}
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
int mod = 1e9 +7 ;
int64_t extGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {if (!a) {x = 0;y = 1;return b;}int64_t x1, y1;int64_t d = extGcd(b % a, a, x1, y1);x = y1 - (b / a) * x1;y = x1;return d;}
inline int addMod(int a, int b, int m = mod) {return ((int64_t)a + b) % m;}
inline int mulMod(int a, int b, int m = mod) { return ((int64_t)a * b) % m;}
inline int divMod(int a, int b, int m = mod) {int64_t x, y;int64_t g = extGcd(b, m, x, y);if (g != 1) {cerr << "Bad gcd!" << endl;for (;;);}x = (x % m + m) % m;return mulMod(a, x, m);}
int dx[]={1,1,0,-1,-1,-1, 0, 1};
int dy[]={0,1,1, 1, 0,-1,-1,-1};
inline ll exp(ll a,ll b){if(a==0)return 0ll;ll r=1LL;while(b>0){if(b&1){r=r*(a%mod);r=(r+mod)%mod;}b/=2;a=(a%mod)*(a%mod);a=(a+mod)%mod;}return (r+mod)%mod;}
ll gcd(ll a,ll b){if(b==0)return a;if(a==0)return b;return gcd(b,a%b);}
uint32 setbits(ll n){uint32 count=0;while (n){n&=(n-1);count++;}return count; }
int main(){
int n;
cin>>n;
map<ll,ll>m1;
for(int i=2;i<=n;i++){
int num=i;
for(int j=2;j*j<=num;j++){
while(num%j==0){
m1[j]++;
num=num/j;
}
}
if(num>1)m1[ num]++;
}
ll cnt3=0;
ll cnt5=0;
ll cnt25=0;
ll cnt15=0;
ll cnt75=0;
for(int i=2;i<=n;i++){
if(m1[i]>=74)cnt75++;
if(m1[i]>=24)cnt25++;
if(m1[i]>=14)cnt15++;
if(m1[i]>=2)cnt3++;
if(m1[i]>=4)cnt5++;
}
ll ans=0;
ans+= cnt75+(cnt25* (cnt3-1))+(((cnt5*(cnt5-1))/2) *(cnt3-2) )+(cnt15*(cnt5-1));
cout<<ans<<endl;
}
| 0
| 99,423,652
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); ++i)
#define cout(x) cout<<(x)<<endl
using namespace std;
using ll = long long;
using P = pair<int,int>;
const ll inf=1e18;
const int N=2e5+10;
ll factorial(ll x){
if(x==0||x==1) return 1;
return x*factorial(x-1);
}
ll gcd(ll a ,ll b){return b ? gcd(b,a%b) : a;}
ll lcm(ll a, ll b){return a/gcd(a,b)*b;}
int num_digit(ll a){
int num_dig = 0;
while(a!=0){
a /= 10;
++num_dig;
}
return num_dig;
}
vector<ll> digit(ll a){
vector<ll> dig(num_digit(a));
for(int i=num_digit(a)-1; i>=0; --i){
dig[i] = a%10;
a /= 10;
}
return dig;
}
int main(){
int a,b,k;
cin >> a >> b >> k;
int n = min(a,b);
vector<int> div;
for(int i=1; i<=n; ++i){
if(a%i==0&&b%i==0){
div.push_back(i);
}
}
cout(div.at((int)div.size() -1 -(k-1)));
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
using vll=vector<ll>;
using vvll=vector<vll>;
using vi=vector<int>;
using vvi=vector<vector<int>>;
using vb=vector<bool>;
using pii=pair<int,int>;
using vpii=vector<pair<int,int>>;
using plli=pair<ll,int>;
using vplli=vector<pair<ll,int>>;
using pllll=pair<ll,ll>;
using vpllll=vector<pair<ll,ll>>;
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;}
template<class T> ll llpow(ll x,T n){ll ans=1;if(x==0)ans=0;while(n){if(n&1)ans*=x;x*=x;n>>=1;}return ans;}
long long modpow(long long a, long long n, long long mod) {long long res = 1;while (n > 0) {if (n & 1) res = res * a % mod;a = a * a % mod;n >>= 1;}return res;}
template<class T> inline T gcd(T x,T y){if(y==0)return x; else {return gcd(y,x%y);}}
template<class T> inline T lcm(T x,T y){return x/gcd(x,y)*y;}
long long modinv(long long a, long long m) {long long b = m, u = 1, v = 0;while (b) {long long t = a / b;a -= t * b; swap(a, b);u -= t * v; swap(u, v);}u %= m;if (u < 0) u += m;return u;}
#define rep(i, begin_i, end_i) for (ll i = (ll)begin_i; i < (ll)end_i; i++)
#define irep(i, end_i, begin_i) for (ll i = (ll)begin_i-1; i >= (ll)end_i; i--)
long long INF = 1LL<<60;
int main( ){
int n,m;
cin>>n>>m;
set<int> rest;
rep(i,1,m+1)rest.insert(i);
vpii payday;
rep(i,0,n){
int a,b;
cin>>a>>b;
pii e;
e.first=b;
e.second=a;
payday.push_back(e);
}
sort(payday.rbegin(),payday.rend());
ll ans=0;
rep(i,0,n){
int pay=payday[i].first;
int day=payday[i].second;
auto pos=rest.lower_bound(day);
if(pos!=rest.end()){
rest.erase(pos);
ans+=pay;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 40,963,158
|
#include <bits/stdc++.h>
int main() {
int n, x;
int ans = 0;
for(;;) {
std::cin >> n >> x;
if( n == 0 && x == 0 ) {
break;
}
ans = 0;
for(int i = 1; i <= n; ++i) {
for(int j = i+1; j <= n; ++j) {
for(int k = j+1; k <= n; ++k) {
if( i + j + k == x ) {
ans += 1;
}
}
}
}
std::cout << ans << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
map<long, long> a;
long tmp;
for (long i = 0; i < n; i++) {
cin >> tmp;
a[tmp]++;
}
long counter = 0;
auto itr = a.begin();
do {
while (itr->second > 2) {
itr->second -= 2;
counter++;
counter++;
}
itr = next(itr, 1);
} while (itr != a.end());
itr = a.begin();
long count2 = 0;
vector<long> c2;
do {
if (itr->second == 2) {
c2.push_back(itr->first);
}
itr = next(itr, 1);
} while (itr != a.end());
if (c2.size() % 2 == 0 ) {
counter += c2.size();
}
else {
counter += c2.size()+1;
}
cout << n-counter << endl;
return 0;
}
| 0
| 30,170,320
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin >> N;
long long minC=N+1;
for(int i=1;i<=sqrt(N);i++){
if(N%i==0){
long long C=i+N/i;
minC=min(minC,C);
}
}
cout << minC-2 << endl;
}
|
#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>;
int main(){
int n;
cin >> n;
vector<ll> a(n+1), cnt(n+1), c(n+1);
ll sum = 0;
for(int i=1; i<=n; ++i){
int A;
cin >> A;
a[i] = A;
cnt[A]++;
}
for(int i=1; i<=n; ++i){
c[i] = cnt[i]*(cnt[i]-1)/2;
sum += c[i];
}
for(int i=1; i<=n; ++i){
ll ans = sum - (cnt[a[i]] - 1);
cout << ans << endl;
}
return 0;
}
| 0
| 37,083,335
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using Graph = vector<vector<int>>;
using P = pair<int,int>;
#define MOD 1000000007
int main()
{
int H,W;cin>>H>>W;
char S[2020][2020];
for (int i=1;i<=H;i++)
{
for (int j=1;j<=W;j++)
cin>>S[i][j];
}
int L[2020][2020];
int R[2020][2020];
int T[2020][2020];
int D[2020][2020];
for (int i=1;i<=H;i++)
{
for (int j=1;j<=W;j++)
{
if (S[i][j]=='#') L[i][j]=0;
else
{
if (j==1) L[i][j]=1;
else L[i][j]=L[i][j-1]+1;
}
}
}
for (int i=1;i<=H;i++)
{
for (int j=W;j>=1;j--)
{
if (S[i][j]=='#') R[i][j]=0;
else
{
if (j==W) R[i][j]=1;
else R[i][j]=R[i][j+1]+1;
}
}
}
for (int i=1;i<=H;i++)
{
for (int j=1;j<=W;j++)
{
if (S[i][j]=='#') T[i][j]=0;
else
{
if (i==1) T[i][j]=1;
else T[i][j]=T[i-1][j]+1;
}
}
}
for (int i=H;i>=1;i--)
{
for (int j=1;j<=W;j++)
{
if (S[i][j]=='#') D[i][j]=0;
else
{
if (i==H) D[i][j]=1;
else D[i][j]=D[i+1][j]+1;
}
}
}
int mx=0;
int light;
for (int i=1;i<=H;i++)
{
for (int j=1;j<=W;j++)
{
light = L[i][j]+R[i][j]+T[i][j]+D[i][j];
mx = max(mx,light);
}
}
cout<<mx-3<<endl;
}
|
#include<bits/stdc++.h>
#include<iomanip>
using namespace std;
typedef long long ll;
typedef long l;
typedef pair<int,int> P;
#define rep(i,n) for(int i=0;i<n;i++)
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
const double PI=3.141592653589;
const int INF=1000000007;
const ll LMAX=1000000000000001;
int gcd(int a,int b){if(a<b)swap(a,b);int c=a%b;while(c!=0){a=b;b=c;c=a%b;}return b;}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int a, b, c, n;
vector<int> L(10);
int ans = INF;
void dfs(int id, int alen, int blen, int clen, int cos){
if(id == n){
if(!(alen == 0 || blen == 0 || clen == 0))
ans = min(ans, cos + abs(a - alen) + abs(b - blen) + abs(c - clen));
}else{
dfs(id + 1, alen, blen, clen, cos);
if(alen == 0)
dfs(id + 1, alen + L[id], blen, clen, cos);
else
dfs(id + 1, alen + L[id], blen, clen, cos + 10);
if(blen == 0)
dfs(id + 1, alen, blen + L[id], clen, cos);
else
dfs(id + 1, alen, blen + L[id], clen, cos + 10);
if(clen == 0)
dfs(id + 1, alen, blen, clen + L[id], cos);
else
dfs(id + 1, alen, blen, clen + L[id], cos + 10);
}
}
int main(){
cin >> n >> a >> b >> c;
rep(i, n) cin >> L[i];
dfs(0, 0, 0, 0, 0);
cout << ans << endl;
return 0;
}
| 0
| 90,088,158
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
using ll = long long;
using ld = long double;
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define rep3(i, n) for (ll i = 1; i < (ll)(n+1); i++)
#define rep4(i, s, n) for (ll i = (s); i < (ll)(n+1); i++)
#define repr(i,n) for (ll i = (n-1); i>=0;i--)
#define repr3(i,n) for(ll i = (n);i>0;i--)
#define repr4(i,s,n) for(ll i = (n);i>=(s);i--)
#define stlen(s) ll s.size()-1
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define cout(n) cout<<std::fixed<<std::setprecision(n)
using Graph = vector<vector<int>>;
using Graphw = vector<vector<pair<ll,ll>>>;
#define INF1 INT_MAX;
#define INF2 LLONG_MAX;
#define PI 3.14159265358979323846;
#define MOD 1000000007;
const int mod = 1000000007;
int main(){
string S;
cin>>S;
map<char,int>num;
if(S.size()!=26){
rep(i,S.size()){
num[S[i]]++;
}
rep(i,26){
if(num[(char)(i+'a')]==0){
S+=string(1,(char)(i+'a'));
break;
}
}
}
else{
if(S[0]=='z'){
cout<<-1<<endl;
return 0;
}
else{
int p=S.size()-1;
repr(i,S.size()-1){
if(S[i]<S[i+1]){
p=i;
break;
}
}
char c='z'+1;
rep2(i,p+1,26){
if((S[p]<S[i])&&(c>S[i])){
c=S[i];
}
}
S=S.substr(0,p)+string(1,c);
}
}
cout<<S<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#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 PI 3.14159265
#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 pw(b,p) pow(b,p) + 0.1
#define __ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repb(i,a,b) for(int i=a;i>=b;i--)
#define endl "\n"
#define m(a) memset(a,0,sizeof(a))
#define all(x) begin(x), end(x)
void file(){
#ifndef ONLINE_JUDGE
freopen("in.txt" , "r" , stdin);
freopen("out.txt" , "w" , stdout);
#endif
}
int bs(int a[] , int s , int e, int x){
if(s<=e){
int m = (s+e)/2;
if(a[m]==x)
return m;
else if(a[m] > x)
return bs(a,s,m-1,x);
else return bs(a,m+1,e,x);
}
return -1;
}
#define tr(x) cout<<x<<endl;
#define tr2(x,y) cout<<x<<" "<<y<<endl;
#define tr3(x,y,z) cout<<x<<" "<<y<<" "<<z<<endl;
#define tr4(w,x,y,z) cout<<w<<" "<<x<<" "<<y<<" "<<z<<endl;
#define tr5(v,w,x,y,z) cout<<v<<" "<<w<<" "<<x<<" "<<y<<" "<<z<<endl;
#define tr6(u,v,w,x,y,z) cout<<u<<" "<<v<<" "<<w<<" "<<x<<" "<<y<<" "<<z<<endl;
#define deb(x) cout<<#x<<"="<<x<<endl
#define deb2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<endl
#define deb3(x,y,z) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<","<<#z<<"="<<z<<endl
#define deba(a) for(auto &x:a) cout<<x<<" ";
#define sd(x) cin >> x;
#define sd2(x,y) cin >> x >> y;
#define sd3(x,y,z) cin >> x >> y >> z;
#define sd4(w,x,y,z) cin >> w >> x >> y >> z;
bool is_pal(string s) {return equal(all(s), s.rbegin());}
int fxp(int a, int b ,int p){
int res = 1;
while (b > 0) {
if (b & 1)
res = (res * a)%p;
a = (a * a)%p;
b >>= 1;
}
return (res%p);
}
void solveFrogOne(){
int n; cin >> n;
int a[n]; for(int i=0 ; i<n ; ++i) cin >> a[i];
int dp[n];
dp[0]=0;
dp[1] = abs(a[1]-a[0]) + dp[0];
for(int i=2 ; i<n ; ++i){
dp[i] = min(dp[i-1] + abs(a[i]-a[i-1]) , dp[i-2] + abs(a[i]-a[i-2]));
}
cout << dp[n-1] << endl;
}
void solveFrogTwo(){
int n,k; cin >> n >> k;
int a[n]; for(int i=0 ; i<n ; ++i) cin >> a[i];
int dp[n];
fill(dp , dp+n , inf);
dp[0]=0;
dp[1] = abs(a[1]-a[0]);
for(int i=2 ; i<n ; ++i){
for(int j=1 ; j<min(k,i)+1 ; ++j){
dp[i] = min(dp[i-j]+abs(a[i]-a[i-j]) , dp[i]);
}
}
cout << dp[n-1] << endl;
}
int32_t main(){
__;
file();
solveFrogTwo();
return 0;
}
| 0
| 16,082,394
|
#include <bits/stdc++.h>
#define SPEED ios_base::sync_with_stdio(false); cin.tie(NULL)
#define REP(i,a,b) for(int i=a,_b=b;i<=_b;i++)
#define rep(i,n) REP(i,0,n-1)
#define FORD(i,b,a) for(int i=b,_a=a;i>=_a;i--)
#define ford(i,n) FORD(i,n-1,0)
#define sqr(x) ((x)*(x))
#define ll long long
#define pi pair<int,int>
#define vi vector<int>
#define vpi vector<pi>
#define vll vector<ll>
#define fi first
#define se second
#define all(a) a.begin(),a.end()
#define add push_back
#define len(arr) arr.size()
#define print(x) cout<<(x)<<'\n'
using namespace std;
const int N = 4e5 + 1;
int main() {
SPEED;
int a, b; cin >> a >> b;
if(a + b == 15) print('+');
else if(a * b == 15) print('*');
else print('x');
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<class T> using oset=tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define pb push_back
#define N 200001
#define ll long long
#define int ll
#define pi pair<int , int>
#define pip pair<pair ,int>
#define mp make_pair
#define f first
#define s second
#define mod 998244353
ll Mod(ll x, ll y, int p)
{ll res = 1; x = x % p;
while (y > 0)
{if(y & 1) res = (res*x) % p;
y = y>>1;x = (x*x) % p;
}return res;
}
int* getlps(string pattern){
int len = pattern.length();
int * lps = new int[len];
lps[0] = 0;
int i = 1 , j = 0;
while(i < len){
if(pattern[i] == pattern[j]){
lps[i] = j+1;
i++;
j++;
}
else{
if(j != 0){
j = lps[j-1];
}
else{
lps[i] = 0;
i++;
}
}
}
return lps;
}
class Triplet{
public:
int x ;
int y ;
int gcd;
};
Triplet extendedEuclid(int a , int b){
if(b == 0){Triplet ans; ans.gcd = a;ans.x = 1;ans.y = 0;return ans;}
Triplet smallAns = extendedEuclid(b , a%b);
Triplet ans;
ans.gcd = smallAns.gcd;
ans.x = smallAns.y;
ans.y = smallAns.x - (a/b)*smallAns.y;
return ans;
}
int mmInverse(int a , int m){
Triplet ans = extendedEuclid(a , m);
return (ans.x+m)%m;
}
int fact[N];
void calfac(int n ){
fact[0] = 1;
for(int i = 1 ; i <= n+2; i++){
fact[i] = (((fact[i-1]%mod)*(i%mod))%mod + mod)%mod;
}
}
int calc(int n , int r){
if(r > n)return 0;
if(r == n)return 1;
int ans = 1;
ans = ((ans%mod)*(fact[n])%mod + mod)%mod;
ans = ((ans%mod)*(mmInverse(fact[n-r] , mod)%mod) + mod)%mod;
ans = ((ans%mod)*(mmInverse(fact[r] , mod)%mod) + mod)%mod;
return (ans+mod)%mod;
}
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, upto;
cin>>n>>upto;
int arr[n];
for(int i = 0 ; i < n;i++){
cin>>arr[i];
arr[i] = arr[i]/2;
}
int dp[n];
for(int i = 0 ; i < n;i++){
int val = arr[i];
int cnt = 0;
while(val%2 == 0){
val=val/2;
cnt++;
if(val == 0)break;
}
dp[i] = cnt;
}
map<int , int> m;
int odd = 0;
for(int i = 0 ; i < n ;i++){
if(dp[i] > 0){
m[dp[i]]++;
}
else{
odd++;
}
}
if(odd == 0 && (int)m.size() == 1){
int lcm = arr[0];
for(int i = 1 ; i < n; i++){
lcm = lcm*arr[i]/(__gcd(lcm , arr[i]));
}
cout<<((upto/lcm) + 1)/2<<endl;
return 0;
}
if(m.size()){
cout<<0<<endl;
return 0;
}
int lcm = arr[0];
for(int i = 1 ; i < n; i++){
lcm = lcm*arr[i]/(__gcd(lcm , arr[i]));
}
cout<<((upto/lcm) + 1)/2<<endl;
return 0;
}
| 0
| 41,054,419
|
#include <iostream>
using namespace std;
int main(){
int d,t,s;
cin>>d>>t>>s;
if(s*t>=d){
cout<<"Yes";
return 0;
}
cout<<"No";
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
#define f first
#define s second
#define fio ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define mp make_pair
#define int long long
using namespace std;
const int INF = 1e9;
const int MAX = 1e5+3;
int MOD = 1e9+7;
int n, m, v, p;
int arr[MAX];
bool is_pos(int mid)
{
int temp_arr[MAX];
memcpy(temp_arr, arr, n*sizeof(int));
int ind = mid, tot = v*m;
while(tot > 0 && ind >= 0)
{
temp_arr[ind] += m;
tot -= m;
ind--;
}
int to_be_equal = temp_arr[mid];
ind = mid+1;
while(tot > 0 && ind < n)
{
if(temp_arr[ind] >= to_be_equal)
break;
tot -= (to_be_equal-temp_arr[ind]);
temp_arr[ind] = to_be_equal;
ind++;
}
int last_ind = ind;
if(tot > 0)
{
ind = n-1;
while(tot > 0 && ind >= 0)
{
int to_add = min(m-(temp_arr[ind]-arr[ind]), tot);
temp_arr[ind] += to_add;
tot = tot - to_add;
ind--;
}
}
vector<pair<pair<int, int>, int> > dis;
dis.pb({{-temp_arr[mid], -10}, mid});
int curr_prior = 1;
for(int i=0;i<n;i++)
{
if(i != mid){
dis.pb({{-temp_arr[i], curr_prior}, i});
curr_prior++;
}
}
sort(dis.begin(), dis.end());
for(int i=0;i<p;i++)
{
if(dis[i].s == mid)
return true;
}
return false;
}
int32_t main()
{
cin>>n>>m>>v>>p;
for(int i=0;i<n;i++)
cin>>arr[i];
sort(arr, arr+n);
int ans = n, mid, low = 0, hi = n-1;
while(low <= hi)
{
mid = (low+hi)/2;
bool curr_pos = is_pos(mid);
if(curr_pos)
{
ans = mid;
hi = mid-1;
}
else
low = mid+1;
}
cout<<n-ans;
}
| 0
| 24,390,932
|
#include <bits/stdc++.h>
#define LL long long
using namespace std;
int main(){
LL N;
cin >> N;
int f = 10;
for(LL A=1; A*A<=N; A++){
if(N%A != 0) continue;
LL a = A;
LL b = N/A;
int B_d = 0;
int A_d = 0;
while(a>0){
a /= 10;
A_d++;
}
while(b>0){
b /= 10;
B_d++;
}
f = min(f,max(A_d,B_d));
}
cout << f << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main (){
int H, W, M;
cin >> H >> W >> M;
map<pair<int, int>, bool> m;
pair<int, int> temppair;
vector<int> hx(H,0);
vector<int> wy(W,0);
int h, w;
for(int i = 0; i < M; i++) {
cin >> h >> w;
temppair = make_pair(h - 1,w - 1);
m[temppair] = 1;
hx.at(h - 1)++;
wy.at(w - 1)++;
}
int hh = 0;
int ww = 0;
hh = *max_element(hx.begin(), hx.end());
ww = *max_element(wy.begin(), wy.end());
vector<int> hl;
int hln = 0;
vector<int> wl;
int wln = 0;
for(int i = 0; i < H; i++) {
if(hh == hx.at(i)) {
hl.push_back(i);
}
}
for(int i = 0; i < W; i++) {
if(ww == wy.at(i)) {
wl.push_back(i);
}
}
int ans = hh + ww;
hln = hl.size();
wln = wl.size();
for(int h = 0; h < hln; h++) {
for(int w = 0; w < wln; w++) {
temppair = make_pair(hl.at(h),wl.at(w));
if(!m.count(temppair)) {
cout << ans << endl;
return 0;
}
}
}
cout << ans - 1 << endl;
}
| 0
| 60,598,196
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using ll = long long;
using namespace std;
using P = pair<int,int>;
int main(){
int a,b;
cin >> a >> b;
if(a == 1) a += 13;
if(b == 1) b += 13;
if(a > b) cout << "Alice" << endl;
else if(b > a) cout << "Bob" << endl;
else cout << "Draw" << endl;
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 rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define maxs(x,y) (x = max(x,y))
#define mins(x,y) (x = min(x,y))
#define limit(x,l,r) max(l,min(x,r))
#define lims(x,l,r) (x = max(l,min(x,r)))
#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 uni(x) x.erase(unique(rng(x)),x.end())
#define snuke srand((unsigned)clock()+(unsigned)time(NULL));
#define show(x) cout<<#x<<" = "<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define bn(x) ((1<<x)-1)
#define dup(x,y) (((x)+(y)-1)/(y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef tuple<int,int,int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
inline int in() { int x; scanf("%d",&x); return x;}
template<typename T>inline istream& operator>>(istream&i,v(T)&v)
{rep(j,sz(v))i>>v[j];return i;}
template<typename T>string join(const v(T)&v)
{stringstream s;rep(i,sz(v))s<<' '<<v[i];return s.str().substr(1);}
template<typename T>inline ostream& operator<<(ostream&o,const v(T)&v)
{if(sz(v))o<<join(v);return o;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v)
{return i>>v.fi>>v.se;}
template<typename T1,typename T2>inline ostream& operator<<(ostream&o,const pair<T1,T2>&v)
{return o<<v.fi<<","<<v.se;}
template<typename T>inline ll suma(const v(T)& a) { ll res(0); for (auto&& x : a) res += x; return res;}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame { puts("-1"); return 0;}
#define yn {puts("Yes");}else{puts("No");}
const int MX = 305;
typedef v(vl) vvl;
struct X {
typedef int T;
vector<T> d;
X() {}
X(vector<T>& a): d(a) {
d.pb(0);
init();
for (T& na : a) na = (*this)(na);
}
void add(const T& x) { d.pb(x);}
void init() {
sort(rng(d));
d.erase(unique(rng(d)), d.end());
}
int size() const { return sz(d);}
T operator[](int i) const { return d[i];}
int operator()(const T& x) const { return upper_bound(rng(d),x)-d.begin()-1;}
} xs;
ll f(int a, int b) {
a = xs[a];
b = xs[b];
return max(0,b-a);
}
int main() {
int n,t;
scanf("%d%d",&n,&t);
vi a(n);
cin>>a;
xs = X(a);
int m = sz(xs);
vvl dp(1,vl(m,LINF));
dp[0][0] = 0;
rep(i,n) {
vvl p(i+2,vl(m,LINF)); swap(dp,p);
rep(j,i+1)rep(k,m) {
ll now = p[j][k];
if (now == LINF) continue;
mins(dp[j][a[i]], now+f(k,a[i]));
mins(dp[j+1][k], now);
}
}
ll ans = LINF;
rep(i,t+1)rep(j,m) mins(ans,dp[i][j]);
cout<<ans<<endl;
return 0;
}
| 0
| 7,171,014
|
#include <bits/stdc++.h>
int main() {
uint64_t N, T;
std::cin >> N >> T;
uint64_t prev = 0, total = 0, t;
for (size_t i = 0; i < N; ++i) {
std::cin >> t;
if (i == 0 || (prev + T) <= t) {
total += T;
prev = t;
} else {
total += (T - (prev + T - t));
prev = t;
}
}
std::cout << total << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define rep(i,n) for(int i = 0; i < ((int)(n)); i++)
int main() {
ll N,K; cin >> N >> K;
vector<ll> A(N);
rep(i,N) cin >> A.at(i);
ll MOD = 1000000007;
ll cnt = 0;
rep(i,N) {
rep(j,N) {
if (i == j) continue;
if (A[i] > A[j]) {
if (i > j) {
cnt += (K - 1) * K / 2;
cnt %= MOD;
} else {
cnt += K * (K + 1) / 2;
cnt %= MOD;
}
}
}
}
cout << cnt << endl;
}
| 0
| 664,757
|
#include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9+7)
#define inf (int)(3e18+7)
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define P pair<int,int>
#define PiP pair<int,pair<int,int>>
#define all(v) v.begin(),v.end()
#define mkp make_pair
#define mkt make_tuple
#define prique(T) priority_queue<T,vector<T>,greater<T>>
#define vecunique(vec) sort(vec.begin(), vec.end());decltype(vec)::iterator result = std::unique(vec.begin(), vec.end());vec.erase(result, vec.end())
using namespace std;
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)return false;
}
return x > 1;
}
int gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x % y);
}
int lcm(int x, int y) {
return x / gcd(x, y) * y;
}
int kai(int x) {
if (x == 0)return 1;
return kai(x - 1) * x % mod;
}
int mod_pow(int x, int y, int mod_) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % mod_;
}
x = x * x % mod_;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)return 0;
return kai(x)* mod_pow(kai(x - y), mod - 2, mod) % mod * mod_pow(kai(y), mod - 2, mod) % mod;
}
int n, k;
int positive[114514], sum[114514];
signed main() {
cin >> n >> k;
rep(i, n) {
int a; cin >> a;
if (i) {
positive[i] += positive[i - 1];
sum[i] += sum[i - 1];
}
if (a > 0)positive[i] += a;
sum[i] += a;
}
int ans = 0;
rep(i, n - k + 1) {
int cnt = 0;
if (i) {
cnt += positive[i - 1];
cnt += max(0ll, sum[i + k - 1] - sum[i - 1]);
}
else {
cnt += max(0ll, sum[i + k - 1]);
}
cnt += positive[n - 1] - positive[i + k - 1];
ans = max(ans, cnt);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
setprecision(18);
int n,k;
cin>>n>>k;
double ans=0.0;
for(int i=1;i<=min(n,k-1);i++)
{
int cur=i;
int cnt=0;
while(cur<k)
{
cur=cur*2;
cnt++;
}
double curAns=(1.0/(1.0*n));
for(int j=0;j<cnt;j++)
{
curAns=curAns*(0.5);
}
ans+=curAns;
}
for(int i=min(n,k-1)+1;i<=n;i++)
{
double curAns=(1.0/(1.0*n));
ans+=curAns;
}
cout<<setprecision(18)<<ans<<"\n";
return 0;
}
| 0
| 44,991,184
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s,p;
cin>>s>>p;
p=p+s;
cout<<p;
return 0;
}
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll
#define flagcount __builtin_popcount
#define flag(x) (1ll << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1ll << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) (distance(v.begin(), low2way(v, x)))
#define idx_upper(v, x) (distance(v.begin(), high2way(v, x)))
#define idx_lower2(v, x) (v.size() - idx_lower(v, x))
#define idx_upper2(v, x) (v.size() - idx_upper(v, x))
#define putout(a) cout << a << endl
#define Sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c)
{
if (c >= '0' && c <= '9')
{
return c - '0';
}
return -1;
}
template <typename T>
T lcm(T x, T y)
{
T z = gcd(x, y);
return x * y / z;
}
template <typename T>
bool primejudge(T n)
{
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
double sqrtn = sqrt(n);
for (T i = 3; i < sqrtn + 1; i++)
{
if (n % i == 0)
{
return false;
}
i++;
}
return true;
}
template <typename T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, const T &b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int main()
{
cout << fixed << setprecision(30);
ll N, L;
cin >> N >> L;
vec a(N);
loop(i, N) cin >> a[i];
string I = "Impossible", P = "Possible";
ll maxx = 0;
loop(i, N - 1) maxx = max(maxx, a[i] + a[i + 1]);
if (maxx < L)
{
putout(I);
return 0;
}
putout(P);
ll x, y;
loop(i, N - 1)
{
ll check = a[i] + a[i + 1];
if (check == maxx)
{
x = i + 1;
y = i + 2;
break;
}
}
loop(i, x - 1) putout(1 + i);
loop(i, N - 2 - (x - 1)) putout(N - 1 - i);
putout(x);
return 0;
}
| 0
| 84,093,862
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll N;
cin >> N;
vector<ll> delt(N);
ll c = 0;
ll dec = 0;
for (ll &e : delt) cin >> e;
for (ll i = 0; i < N; i++) {
ll x;
cin >> x;
delt[i] -= x;
if (delt[i] < 0) {
dec += delt[i];
c += 1;
}
}
sort(delt.begin(), delt.end(), greater<ll>());
for (int i = 0; i < N; i++) {
if (delt[i] <= 0) {
cout << -1 << endl;
return 0;
}
c += 1;
dec += delt[i];
if (dec >= 0) {
if (c == 1) c--;
cout << c << endl;
return 0;
}
}
}
|
#include<bits/stdc++.h>
#define fast ios::sync_with_stdio(false), cin.tie(0);
#define ll long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define endl '\n'
const int INF = 1e6;
using namespace std;
int n,a,b,c;
int l[10];
int solve (int at, int bt, int ct, int cur)
{
if (cur==n)
{
if (min({at,bt,ct})>0)
return abs(a-at)+abs(b-bt)+abs(c-ct)-30;
else
return INF;
}
int r1=solve(at,bt,ct,cur+1);
int r2=solve(at+l[cur],bt,ct,cur+1)+10;
int r3=solve(at,bt+l[cur],ct,cur+1)+10;
int r4=solve(at,bt,ct+l[cur],cur+1)+10;
return min({r1,r2,r3,r4});
}
main()
{
fast;
int i;
cin>>n>>a>>b>>c;
for (i=0;i<n;i++)
cin>>l[i];
int ans=solve(0,0,0,0);
cout<<ans<<endl;
}
| 0
| 98,766,282
|
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,l,r) for(long long i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define int long long
const int MOD=1e9+7;
const int INF=1e15;
signed main(){
int N;cin>>N;
map<string,int>memo;
REP(i,N){
string d;cin>>d;
memo[d]++;
}
int M;cin>>M;
REP(i,M){
string d;cin>>d;
memo[d]--;
}
int ans=0;
for(auto it=memo.begin();it!=memo.end();it++){
ans=max(ans,it->second);
}
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int h,w;
cin >> h >> w;
vector<vector<int>> wall_y(h);
vector<vector<int>> wall_t(w);
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
char c;
cin >> c;
if(c == '#'){
wall_y.at(i).push_back(j);
wall_t.at(j).push_back(i);
}
}
}
vector<vector<int>> yoko(h, vector<int>(w,0));
vector<vector<int>> tate(h, vector<int>(w,0));
for(int i=0; i<h; i++){
if(wall_y.at(i).size() == 0){
for(int j=0; j<w; j++){
yoko.at(i).at(j) = w;
}
}
else if(wall_y.at(i).size() == 1){
int k = wall_y.at(i).at(0);
for(int j=0; j<w; j++){
if(j < k) yoko.at(i).at(j) = k;
else if(j==k) yoko.at(i).at(j) = 0;
else yoko.at(i).at(j) = w-k-1;
}
}
else{
int s = wall_y.at(i).size();
int first,end;
first = wall_y.at(i).at(0);
end = wall_y.at(i).at(s-1);
for(int j=0; j<first; j++){
yoko.at(i).at(j) = first;
}
for(int j=end+1; j<w; j++){
yoko.at(i).at(j) = w-end-1;
}
for(int j=0; j<=s-2;j++){
int p,q;
p = wall_y.at(i).at(j);
q = wall_y.at(i).at(j+1);
for(int l=p+1; l<q; l++){
yoko.at(i).at(l) = q-p-1;
}
}
}
}
for(int i=0; i<w; i++){
if(wall_t.at(i).size() == 0){
for(int j=0; j<h; j++){
tate.at(j).at(i) = h;
}
}
else if(wall_t.at(i).size() == 1){
int k = wall_t.at(i).at(0);
for(int j=0; j<h; j++){
if(j < k) tate.at(j).at(i) = k;
else if(j==k) tate.at(j).at(i) = 0;
else tate.at(j).at(i) = h-k-1;
}
}
else{
int s = wall_t.at(i).size();
int first,end;
first = wall_t.at(i).at(0);
end = wall_t.at(i).at(s-1);
for(int j=0; j<first; j++){
tate.at(j).at(i) = first;
}
for(int j=end+1; j<h; j++){
tate.at(j).at(i) = h-end-1;
}
for(int j=0; j<=s-2;j++){
int p,q;
p = wall_t.at(i).at(j);
q = wall_t.at(i).at(j+1);
for(int l=p+1; l<q; l++){
tate.at(l).at(i) = q-p-1;
}
}
}
}
ll ans=0;
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
ll light = tate.at(i).at(j) + yoko.at(i).at(j) -1;
ans = max(ans, light);
}
}
cout << ans << endl;
}
| 0
| 68,911,346
|
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
int main() {
int n;
string s;
cin >> n >> s;
ll ret = 1;
ll fin_count = 0;
ll calc_count = 0;
for (int i = 2 * n - 1; i >= 0; i--) {
if ((i % 2 == 0) == (s[i] == 'W'))fin_count++;
else {
ret *= fin_count;
ret %= mod;
fin_count--;
calc_count++;
}
}
for (ll i = 1; i <= n; i++) {
ret *= i;
ret %= mod;
}
cout << (calc_count == n ? ret : 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ld long double
const int INF = 1e15 + 7;
const int MAX = 1e5 + 7;
const int MOD = 1e9 + 7;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
typedef vector<bool> vb;
#define pq priority_queue
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(), (c).end()
#define ordered_set tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vii a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i].ff, a[i].ss = i;
sort(all(a));
map<int, int> m;
int j = n;
for (int i = n; i > 0; i--)
{
j = min(j, a[i].ss);
m[j] += (a[i].ff - a[i - 1].ff) * (n - i + 1);
}
for (int i = 1; i <= n; i++)
cout << m[i] << endl;
return 0;
}
| 0
| 100,772,949
|
#include <bits/stdc++.h>
#define rep(i, n) for (lli i = 0; i < (n); i++)
#define rrep(i, n) for (lli i = (n)-1; i >= 0; i--)
using namespace std;
using lli = long long int;
void YESNO(bool), YesNo(bool);
template <class T1, class T2>
bool chmin(T1 &l, const T2 &r);
template <class T1, class T2>
bool chmax(T1 &l, const T2 &r);
int cnt[300005] = {};
int cnt2[300005] = {};
int cnt3[300005] = {};
void solve(long long N, std::vector<long long> A)
{
rep(i, N) cnt[A[i]]++;
vector<int> a;
vector<int> hist;
rep(i, 300005)
{
if (cnt[i])
{
cnt2[cnt[i]]++;
}
}
map<lli, lli> m;
lli sum = 0;
lli used = 0;
rep(i, 300005) used += cnt2[i];
rep(i, 300005)
{
sum += cnt2[i] * i;
used -= cnt2[i];
if (i)
cnt3[i] = (sum + i * used) / i;
}
lli cur = N;
for (int k = 1; k <= N; k++)
{
while (cur >= 0 && cnt3[cur] < k)
cur--;
cout << (cur > 0 ? cur : 0) << endl;
}
}
signed main()
{
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
for (int i = 0; i < N; i++)
{
scanf("%lld", &A[i]);
}
solve(N, std::move(A));
return 0;
}
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
template <class T1, class T2>
bool chmin(T1 &l, const T2 &r)
{
return (l > r) ? (l = r, true) : false;
}
template <class T1, class T2>
bool chmax(T1 &l, const T2 &r)
{
return (l < r) ? (l = r, true) : false;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll solve() {
ll MAX = pow(10, 18);
int n; cin >> n;
vector<ll> nums;
ll a;
for (int i = 0; i < n; ++i) {
cin >> a;
if (a == 0) {
return 0;
}
nums.push_back(a);
}
ll res = 1;
for (ll num : nums) {
if (MAX / res >= num)
res *= num;
else
return -1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << solve() << endl;
}
| 0
| 48,301,761
|
#include <iostream>
using namespace std;
using LL = long long;
int main() {
int n;
cin >> n;
LL ans = 1;
for (int i = n; i > 1; i--) {
ans *= i;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define print(x) cout << x << endl;
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<pair<int, int>> ab, cd;
int x, y;
rep(i, N) {
cin >> x >> y;
ab.push_back(pair<int, int>(x, y));
}
rep(i, N) {
cin >> x >> y;
cd.push_back(pair<int, int>(x, y));
}
sort(cd.begin(), cd.end(), [](const pair<int, int> x, const pair<int, int> y){return x.first < y.first;});
int done[N] = {};
int sum = 0;
rep(i, N) {
int max_y = -1;
int max_ind = -1;
rep(j, N) {
if (ab.at(j).first < cd.at(i).first && ab.at(j).second < cd.at(i).second) {
if (ab.at(j).second > max_y && done[j] == 0) {
max_ind = j;
max_y = ab.at(j).second;
}
}
}
if (max_ind == -1) continue;
else {
done[max_ind] += 1;
sum++;
}
}
cout << sum << endl;
return 0;
}
| 0
| 39,039,733
|
#include <algorithm>
#include<iostream>
#include<vector>
#include<deque>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<string>
#include <sstream>
#include<bitset>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<limits.h>
const int INF = 0x7fffffff;
using lll = long long;
using ull = unsigned long long;
using namespace std;
int main(){
lll ii,jj,kk;
vector<int> ret;
int n;
string s;
lll cnt = 0;
lll k;
cin >> n;
cin >> s;
lll rgb[3];
memset(rgb,0,sizeof(rgb));
for(ii=0;ii<n;ii++){
if(s[ii] == 'R'){rgb[0]++;}
if(s[ii] == 'G'){rgb[1]++;}
if(s[ii] == 'B'){rgb[2]++;}
}
lll ans;
ans = rgb[0] * rgb[1] * rgb[2];
for(jj=0;jj<n;jj++){
for(ii=0;ii<n;ii++){
if(jj > ii){
k = 2*jj - ii;
if(k < n){
if(s[ii] == s[jj]){continue;}
if(s[ii] == s[k]) {continue;}
if(s[jj] == s[k]) {continue;}
cnt++;
}
}
}
}
cout << ans - cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char * argv[]) {
int n, k; cin>>n>>k;
double ans=0;
for(int i=1; i<=n; i++){
double sc = 1.0/n;
int reg=i;
while(reg<k){
sc/=2;
reg*=2;
}
ans+=sc;
}
printf("%.9f\n", ans);
return 0;
}
| 0
| 72,315,805
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int s;
double x;
cin>>s;
for(int i=s;i>=1;i--){
x=log(i)/log(2);
if(x-int(x)==0){
cout<<i;
break;
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(ll i=0;i<(ll)n;++i)
int main() {
string s,t;cin >> s >> t;
ll id = -1;
for(ll i=0;i<=(ll)s.size()-(ll)t.size();++i){
for(ll j=0;j<(ll)t.size();++j){
if( s.at(i+j) == '?' || s.at(i+j) == t.at(j) ){
if( j == (ll)t.size() - 1 ) id = i;
}else{
break;
}
}
}
if( id == -1 ){
cout << "UNRESTORABLE" << endl;
return 0;
}
for(ll i=0;i<(ll)s.size();++i){
if( i == id ){
cout << t;
i += t.size()-1;
continue;
}
if( s.at(i) == '?' ) cout << 'a';
else cout << s.at(i);
}
cout << endl;
return 0;
}
| 0
| 18,039,176
|
#include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
#define INF 1.1e9
#define LINF 1.1e18
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) for(int i=0;i<=(n);++i)
#define ALL(v) (v).begin(),(v).end()
typedef long long ll;
typedef pair<ll, int> P;
int h,w,d;
char s[4]={'R','Y','G','B'};
char c[500][500];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin>>h>>w>>d;
REP(i,h) {
REP(j,w) {
int y=i+j;
int x=i-j+h+w;
int color=y/d%2*2 + x/d%2;
c[i][j]=s[color];
}
}
REP(i,h) {
REP(j,w) {
cout<<c[i][j];
}
cout<<endl;
}
return 0;
}
|
#include<cstdio>
#include<iostream>
#include<cstdlib>
using namespace std;
long long cur;
int w;
long long p[18],po[18];
int bs(int x)
{
int l=-1,r=10;
if(x==1)l=0;
while(l+1<r)
{
int m=(l+r)/2;
printf("? %lld\n",(cur*10LL+m)*po[11-x]+p[11-x]);
char op;
cin>>op;
if(op=='N')l=m;else r=m;
}
return l;
}
int main()
{
po[0]=1LL;
for(int i=1;i<=17;i++)p[i]=p[i-1]*10LL+9,po[i]=po[i-1]*10LL;
w=1;
while(1)
{
if(w>10)
{
long long t=cur;
long long cj=1LL;
while(t%10==0)
{
t/=10LL;
cj*=10LL;
}
t/=10LL;
cj*=10LL;
char op;
do
{
t=t*10LL+9;
cj/=10LL;
printf("? %lld\n",t);
cin>>op;
}
while(op=='N');
long long res=cur/cj;
printf("! %lld",res);
return 0;
}
int k=bs(w);
cur=cur*10LL+k+1;
w++;
}
return 0;
}
| 0
| 14,558,266
|
#include <bits/stdc++.h>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i,n) for (ll i=0; i < (ll)(n); i++)
int main(void){
ll n;
cin>>n;
ll ans=0;
for(ll i=1;i<=n;i++){
ll p=n/i;
ans+=i*(1+p)*p/2;
}
cout<<ans<<endl;
}
|
#pragma GCC optimize ("O3")
#include <iostream>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
#include <bitset>
#include <utility>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <ctime>
#include <cctype>
#include <cstdlib>
#include <numeric>
#define IINF 1000000000
#define INF 3223372036854775807
#define MOD 1000000007
#define mod 1000000007
#define INT_MAX_ 2147483647
#define EPS (1e-10)
#define REP(i, a, n) fo-r (ll i = a; i < (ll)(n); i++)
#define REPE(i, a, n) for (ll i = a; i <= (ll)(n); i++)
#define rep(i,l,r)for(ll i=(l);i<(r);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define Endl endl
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define mmax(x,y)(x>y?x:y)
#define mmin(x,y)(x<y?x:y)
#define chmax(x,y) x=mmax(x,y)
#define chmin(x,y) x=mmin(x,y)
#define all(x) (x).begin(),(x).end()
#define siz(x) (ll)(x).size()
#define PI acos(-1.0)
#define me memset
#define bit(n,k) ((n>>k)&1)
#define lg length()
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<int,int>Pin;
typedef pair<ll,ll>Pll;
template<class T> using V=vector<T>;
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T> >;
long long GCD(long long a, long long b) {return b?GCD(b,a%b):a;}
long long LCM(long long a, long long b) {return a/GCD(a,b)*b;}
ll pom(ll a,ll n,int m){ll x=1;for(a%=m;n;n/=2)n&1?x=x*a%m:0,a=a*a%m;return x;}
#define invp(a,p)pom(a,p-2,p)
int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
int ddx[8]={-1,0,1,0,1,1,-1,-1};
int ddy[8]={0,-1,0,1,1,-1,1,-1};
ll cmp1(pair<Pll,ll> a,pair<Pll,ll> b){
return a.fi.se>b.fi.se;
}
ll cmp2(pair<ll,min_priority_queue<ll>> a,pair<ll,min_priority_queue<ll>> b){
return a.fi > b.fi;
}
int main(int argc, char * argv[]){
cin.tie(0);
ios::sync_with_stdio(false);
string s;cin>>s;
string t = "";
for(ll i=0;i<s.lg;i++){
if(s[i]!='x')t+=s[i];
}
ll l=0,r=t.lg-1;
while(l<r){
if(t[l]==t[r]){
l++;
r--;
}
else{
cout<<-1<<endl;
return 0;
}
}
ll ans=0;
l=0;r=s.lg-1;
while(l<r){
if(s[l]=='x'&&s[r]=='x'){
l++;
r--;
}
else if(s[l]!='x'&&s[r]!='x'){
l++;
r--;
}
else if(s[l]=='x'){
ans++;
l++;
}
else if(s[r]=='x'){
ans++;
r--;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 93,986,590
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s;
string answer ="";
for (int i = 0; i < s.size(); i+= 2) answer += s.at(i);
cout << answer << endl;
}
|
#pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T>
using pqrev = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for (ll i = 0, i##_end = (n); i < i##_end; i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for (ll i = (a), i##_end = (b); i < i##_end; i++)
#define reprb(i, a, b) for (ll i = (b)-1, i##_end = (a); i >= i##_end; i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
constexpr ll MOD = 1e9 + 7;
/*/
constexpr ll MOD = 998244353;
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
constexpr ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
constexpr ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
template <typename S, typename T>
constexpr bool chmax(S &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename S, typename T>
constexpr bool chmin(S &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif
template <typename T>
bool print_(const T &a) {
cout << a;
return true;
}
template <typename T>
bool print_(const vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) {
cout << " ";
}
}
return false;
}
template <typename T>
bool print_(const vector<vector<T>> &vv) {
for (auto &v : vv) {
for (auto &a : v) {
cout << a;
if (&a != &v.back()) {
cout << " ";
}
}
if (&v != &vv.back()) {
cout << "\n";
}
}
return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&... tail) {
bool f = print_(head);
if (sizeof...(tail) != 0) {
cout << (f ? " " : "\n");
}
print(forward<Tail>(tail)...);
}
#pragma endregion
void Pr(bool f){
cout << (f ? "Yes" : "No") << "\n";
exit(0);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n;
cin >> n;
vll a(n);
rep(i, n){
cin >> a[i];
}
vll idx_max, v_max, cnt_max, res_max;
ll ma = 0;
rep(i, n){
if(chmax(ma, a[i])){
idx_max.emplace_back(i);
v_max.emplace_back(a[i]);
cnt_max.emplace_back(1);
res_max.emplace_back(0);
}else if(binary_search(ALL(v_max), a[i])){
ll id = lower_bound(ALL(v_max), a[i]) - v_max.begin();
cnt_max[id]++;
}else{
ll id = upper_bound(ALL(v_max), a[i]) - v_max.begin();
if(id){
cnt_max[id-1]++;
res_max[id] += a[i]-v_max[id-1];
}else{
res_max[0] += a[i];
}
}
}
dump(cnt_max);
dump(res_max);
reprb(i, 1, SZ(v_max)){
v_max[i] -= v_max[i-1];
cnt_max[i-1] += cnt_max[i];
}
dump(cnt_max);
dump(res_max);
dump(v_max);
ll c = 0;
rep(i, n){
if(c < SZ(idx_max) && idx_max[c] == i){
print(cnt_max[c]*v_max[c] + res_max[c]);
c++;
}else{
print(0);
}
}
}
| 0
| 85,582,255
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
int ans = 1;
while(1){
if(ans * 2 <= N){
ans *= 2;
}
else{
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <complex>
#include <valarray>
#include <unordered_map>
#include <array>
#include <fstream>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <random>
#include <numeric>
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int w=0; w<n; ++w){MACRO_VEC_ROW_Scan(w, __VA_ARGS__);}
template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }
template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& R:c)for(auto& w:R)std::cin>>w;
#define OUT(dist) std::cout<<(dist);
#define FOUT(n, dist) std::cout<<std::fixed<<std::setprecision(n)<<(dist);
#define SOUT(n, c, dist) std::cout<<std::setw(n)<<std::setfill(c)<<(dist);
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
#define SHOW(dist) {std::cerr << #dist << "\t:" << (dist) << "\n";}
#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}
#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}
#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}
#define ALL(a) (a).begin(),(a).end()
#define FOR(w, a, n) for(int w=(a);w<(n);++w)
#define RFOR(w, a, n) for(int w=(n)-1;w>=(a);--w)
#define REP(w, n) for(int w=0;w<int(n);++w)
#define RREP(w, n) for(int w=int(n)-1;w>=0;--w)
#define FORLL(w, a, n) for(ll w=ll(a);w<ll(n);++w)
#define RFORLL(w, a, n) for(ll w=ll(n)-1;w>=ll(a);--w)
#define REPLL(w, n) for(ll w=0;w<ll(n);++w)
#define RREPLL(w, n) for(ll w=ll(n)-1;w>=0;--w)
#define IN(a, x, b) (a<=x && x<b)
template<class T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}
template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template<typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")"; return os;
}
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30;
constexpr int INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-10;
constexpr int MOD = 998244353;
constexpr double PI = 3.141592653589793238462643383279;
template<class T, size_t N> void FILL(T(&a)[N], const T& val) { for (auto& x : a) x = val; }
template<class ARY, size_t N, size_t M, class T> void FILL(ARY(&a)[N][M], const T& val) { for (auto& b : a) FILL(b, val); }
template<class T> void FILL(std::vector<T>& a, const T& val) { for (auto& x : a) x = val; }
template<class ARY, class T> void FILL(std::vector<std::vector<ARY>>& a, const T& val) { for (auto& b : a) FILL(b, val); }
void NO() {
OUT("No")BR;
exit(0);
}
signed main() {
INIT;
VAR(int, n);
int t = std::round(std::sqrt(1 + 8 * n));
if (t * t != 1 + 8 * n) NO();
int k = (1 + t) / 2;
std::vector<std::vector<int>> s(k);
int p = 0;
REP(i, k) FOR(j, i + 1, k) {
s[i].emplace_back(p);
s[j].emplace_back(p);
++p;
}
OUT("Yes")BR;
OUT(k)BR;
REP(i, k) {
OUT(s[i].size())SP;
REP(j, s[i].size()) {
OUT(s[i][j] + 1)SPBR(j, s[i].size());
}
}
return 0;
}
| 0
| 88,166,349
|
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll q,h,s,d,n;
cin >> q >> h >> s >> d >> n;
h = min(2*q,h);
s = min(2*h,s);
ll ca = d*(n/2) + s*(n%2);
ll cb = s*n;
ll ans =min(ca, cb);
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<map>
#include<vector>
#include<cmath>
#include<string>
#include<cstring>
#include<algorithm>
#include<climits>
#include<stack>
#include<queue>
#include<set>
#include<cctype>
#include<bitset>
#include<type_traits>
#include<numeric>
#include<array>
using namespace std;
# define REP(i,n) for (int i=0;i<(n);++i)
# define rep(i,a,b) for(int i=a;i<(b);++i)
# define p(s) std::cout << s ;
# define pl(s) std::cout << s << endl;
# define printIf(j,s1,s2) cout << (j ? s1 : s2) << endl;
# define YES(j) cout << (j ? "YES" : "NO") << endl;
# define Yes(j) std::cout << (j ? "Yes" : "No") << endl;
# define yes(j) std::cout << (j ? "yes" : "no") << endl;
# define all(v) v.begin(),v.end()
# define showVector(v) REP(i,v.size()){p(v[i]);p(" ")} pl("")
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;}
typedef long long int ll;
typedef pair<int,int> P_ii;
typedef pair<double,double> P_dd;
template<class T>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template<typename T,typename V>
typename enable_if<is_class<T>::value==0>::type
fill_v(T &t,const V &v){t=v;}
template<typename T,typename V>
typename enable_if<is_class<T>::value!=0>::type
fill_v(T &t,const V &v){
for(auto &e:t) fill_v(e,v);
}
const int mod = 1000000007;
const int MOD = 1000000007;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
void addM(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
void mulM(long long &a, long long b) {
a = ((a%MOD)*(b%MOD))%MOD ;
}
long myPow(long a,long b,int M) {
long ret = 1;
long tmp = a;
while(b>0) {
if((b&1)==1) ret = (ret * tmp) % M;
tmp = (tmp * tmp) % M;
b = b>>1;
}
return ret;
}
int nCk(int n,int k,int M) {
long ret = 1;
int mi = min(k, n-k);
for(int i=1;i<=mi;i++) {
ret = (ret * myPow(i,M-2,M)) % M;
}
for(int i=n-mi+1;i<=n;i++) {
ret = (ret * i) % M;
}
return (int)ret;
}
int main(){
int N;cin >> N;
pl((N-2)*180)
return 0;
}
| 0
| 16,211,905
|
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
using lint = long long int;
int H, W, N;
vector<P> p;
int count(int x, int y)
{
if (x <= 0 || y <= 0 || x >= H-1 || y >= W-1) return 0;
int ans = 0;
for (int i=-1; i<=1; i++)
{
for (int j=-1; j<=1; j++)
{
ans += binary_search(p.begin(), p.end(), P(x+i, y+j));
}
}
return ans;
}
int main()
{
cin >> H >> W >> N;
for (int i=0; i<N; i++)
{
int a, b;
cin >> a >> b;
a--;
b--;
p.push_back(P(a, b));
}
sort(p.begin(), p.end());
vector<set<P>> ans(9);
for (int i=0; i<N; i++)
{
for (int x=-1; x<=1; x++)
{
for (int y=-1; y<=1; y++)
{
int n = count(p[i].first+x, p[i].second+y);
if (n) ans[n-1].insert(P(p[i].first+x, p[i].second+y));
}
}
}
lint ans0 = (lint)(H-2) * (W-2);
for (auto v : ans) ans0 -= v.size();
cout << ans0 << endl;
for (auto v : ans) cout << v.size() << endl;
}
|
#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <stdlib.h>
using namespace std;
class Heap{
public:
Heap(){
array = new int[2000000];
n = 0;
}
void insert(int data){
array[n] = data;
int tmp = n;
while(tmp != 0 && array[tmp] > array[(tmp-1)/2]){
std::swap(array[tmp], array[(tmp-1)/2]);
tmp = (tmp-1)/2;
}
n++;
}
void max_heapify(int* array, int start, int end)
{
int dad = start;
int son = dad * 2 + 1;
while (son <= end)
{
if (array[son] < array[son+1] && son+1 <= end)
son++;
if (array[dad] > array[son])
return;
else
{
swap(array[son], array[dad]);
dad = son;
son = dad * 2 + 1;
}
}
}
int heap_sort(int* array, int len)
{
int i;
swap(array[0],array[len-1]);
max_heapify(array,0,len-2);
return array[len-1];
}
int extract(){
int ret = heap_sort(array,n);
n--;
return ret;
}
private:
int* array;
int n;
};
int main(){
int insert_data;
char buf[22];
Heap heap;
while(true){
fgets(buf,22,stdin);
if(buf[2] == 'd') break;
if(buf[0] == 'i'){
insert_data = atoi(buf+7);
heap.insert(insert_data);
}else{
printf("%d\n",heap.extract());
}
}
}
| 0
| 32,322,837
|
#include <stdio.h>
#include <algorithm>
using namespace std;
int N, D, A; pair<int, int> M[200200];
int cnt = 1, coord[400400];
long long sum[400400];
void push(int x, long long p)
{
x = lower_bound(coord + 1, coord + cnt, x) - coord;
while (x < cnt){
sum[x] += p;
x += x & (-x);
}
}
long long pop(int x)
{
long long r = 0;
x = lower_bound(coord + 1, coord + cnt, x) - coord;
while (x){
r += sum[x];
x -= x & (-x);
}
return r;
}
int main()
{
scanf ("%d %d %d", &N, &D, &A);
for (int i = 0, x, h; i < N; i++){
scanf ("%d %d", &x, &h); x -= D;
M[i] = { x, h };
coord[cnt++] = x;
coord[cnt++] = x + 2 * D + 1;
}
sort(coord + 1, coord + cnt);
sort(M, M + N);
long long drop = 0;
for (int i = 0; i < N; i++){
long long nh = M[i].second - pop(M[i].first);
if (nh > 0){
long long d = (nh + A - 1) / A;
push(M[i].first, d * A);
push(M[i].first + 2 * D + 1, -d * A);
drop += d;
}
}
printf ("%lld\n", drop);
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
#define ll long long
typedef pair<int,int> P;
const int inf=1000000007;
const int MOD=1000000007;
signed main(){
string s;cin>>s;
int n=s.size();
vector<vector<int>> dp(2,vector<int>(n,0));
dp[0][0]=1;dp[1][0]=2;
rep1(i,n-1){
if(s[i]=='0'){
dp[0][i]=dp[0][i-1]*3;
dp[1][i]=dp[1][i-1];
}
else{
dp[0][i]=dp[0][i-1]*3+dp[1][i-1];
dp[1][i]=dp[1][i-1]*2;
}
dp[0][i]%=MOD;
dp[1][i]%=MOD;
}
cout<<(dp[0][n-1]+dp[1][n-1])%MOD<<"\n";
return 0;
}
| 0
| 51,445,922
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while(cin>>n,n){
string str;
bool right=0,left=0;
int ans=0;
for(int i=0,now=1;i<n;i++){
cin>>str;
if(str=="lu")left=1;
if(str=="ru")right=1;
if(str=="ld")left=0;
if(str=="rd")right=0;
if(now==right&&right==left){
ans++;
now=(now+1)%2;
}
}
cout<<ans<<endl;
}
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
long long n, m;
cin >> n >> m;
vector<pair<long long, long long> > v;
for(long long i = 0; i < n; i++){
long long a, b;
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
long long sum = 0;
long long cost = 0;
long long i = 0;
while(1){
if(sum + v[i].second < m){
sum += v[i].second;
cost += v[i].first*v[i].second;
i++;
}
else if(sum + v[i].second >= m){
cost += (m - sum)*v[i].first;
sum = m;
break;
}
}
cout << cost << endl;
return 0;
}
| 0
| 61,026,023
|
#include <iostream>
using namespace std;
struct TCoordinate
{
double x;
double y;
};
bool JudgeSameSide(TCoordinate T1, TCoordinate T2, TCoordinate L1, TCoordinate L2)
{
if(L1.x == L2.x){
if((T1.x - L1.x) * (T2.x - L2.x) > 0){
return true;
}else{
return false;
}
}else{
if(((L2.x - L1.x) * (T1.y - L1.y) - (L2.y - L1.y) * (T1.x - L1.x)) * ((L2.x - L1.x) * (T2.y - L1.y) - (L2.y - L1.y) * (T2.x - L1.x)) > 0){
return true;
}else{
return false;
}
}
}
int main()
{
bool SameSideFlagA1A2, SameSideFlagA2A3, SameSideFlagA3A1;
while(true){
TCoordinate A1, A2, A3, Ap;
cin >> A1.x >> A1.y >> A2.x >> A2.y >> A3.x >> A3.y >> Ap.x >> Ap.y;
if(cin.eof() == true) break;
SameSideFlagA1A2 = JudgeSameSide(A3, Ap, A1, A2);
SameSideFlagA2A3 = JudgeSameSide(A1, Ap, A2, A3);
SameSideFlagA3A1 = JudgeSameSide(A2, Ap, A3, A1);
if(SameSideFlagA1A2 == true && SameSideFlagA2A3 == true && SameSideFlagA3A1 == true){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
}
return 0;
}
|
#ifdef _DEBUG
#include "MyLib.h"
#else
#define main_D main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i,s,e) for (int i = int(s); i < int(e); ++i)
#define REP(i,e) FOR(i,0,e)
#define INF (INT_MAX/2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX/2)
const int MGN = 8;
const int ARY_SZ_MAX = 10000000;
using namespace std;
using ll = long long; using ull = unsigned long long;
using vi = vector<int>; using vvi = vector<vi>; using vvvi = vector<vvi>;
using vb = vector<bool>; using vvb = vector<vb>; using vvvb = vector<vvb>;
using vl = vector<ll>; using vvl = vector<vl>;
using vd = vector<double>; using vs = vector<string>;
using pii = pair<int, int>; using pll = pair<ll, ll>;
using psi = pair<string, int>;
#endif
int main_D() {
cin.tie(0);
ios::sync_with_stdio(false);
int A, B; cin >> A >> B;
int W = 100, H = 100;
vs s(H);
REP(i, H / 2) s[i] = string(W, '.');
FOR(i, H / 2, H) s[i] = string(W, '#');
int cnt = 1;
bool ok = false;
for(int i= 0; i<H/2; i+=2) {
for(int j=0; j<W; j+=2){
if (cnt >= B) {
ok = true;
break;
}
s[i][j] = '#';
cnt++;
}
if (ok) break;
}
cnt = 1;
ok = false;
for(int i= H/2+1; i<H; i+=2) {
for(int j=0; j<W; j+=2){
if (cnt >= A) {
ok = true;
break;
}
s[i][j] = '.';
cnt++;
}
if (ok) break;
}
cout << H << " " << W << endl;
REP(i,H) {
cout << s[i] << endl;
}
return 0;
}
| 0
| 100,658,834
|
#include <cstdio>
#include <cmath>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pi = acos(-1);
const int maxn = 2e6 + 10;
const double eps = 1e-8;
const ll mod = 1e9 + 7;
const ull base = 131;
const ull mod1 = 1e9 + 9;
const ull mod2 = 1610612741;
set<int> s;
int main()
{
for (int i = 1; i < 4; ++i)
{
int x;
scanf("%d", &x);
s.insert(x);
}
printf("%d\n", s.size());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rem(i, m, n) for (int i = m; i < (n); i++)
#define eps (1e-7)
#define inf (1e9)
#define pi (acos(-1))
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<double> vd;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
string a, b;
cin >> a >> b;
if (a.size() > b.size())
cout << "GREATER"
<< "\n";
else if (a.size() < b.size())
cout << "LESS"
<< "\n";
else
{
rep(i, a.size())
{
if (strcmp(&a[i], &b[i]) > 0)
{
cout << "GREATER"
<< "\n";
return 0;
}
else if (strcmp(&a[i], &b[i]) < 0)
{
cout << "LESS"
<< "\n";
return 0;
}
}
cout << "EQUAL"
<< "\n";
}
return 0;
}
| 0
| 73,483,865
|
#include<cstdio>
#include<string>
#include<cstring>
#include<utility>
#include<cmath>
#include<map>
#include<queue>
#include<set>
#include<algorithm>
#include<vector>
#include<iostream>
#define ll long long
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define inf 0x7fffffff
using namespace std;
string s[2010];
int a[2010][2010],b[2010][2010];
int numa[2010*2010],numb[2010*2010];
int main()
{
int i,j,k,n,m,x,y,h=0;
scanf("%d%d",&n,&m);
for(i=0;i<n;i++)
{
cin>>s[i];
}
for(i=0;i<n;i++)
{
x=0;
for(j=0;j<m;j++)
{
if(s[i][j]=='#')
{
if(x>0)
{
numa[h]=x;
x=0;
h++;
}
}
else
{
a[i][j]=h;
x++;
}
}
if(x>0)
{
numa[h]=x;
h++;
}
}
h=0;
for(i=0;i<m;i++)
{
x=0;
for(j=0;j<n;j++)
{
if(s[j][i]=='#')
{
if(x>0)
{
numb[h]=x;
x=0;
h++;
}
}
else
{
b[j][i]=h;
x++;
}
}
if(x>0)
{
numb[h]=x;
h++;
}
}
int ma=0;
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
ma=max(ma,numa[a[i][j]]+numb[b[i][j]]-1);
}
}
printf("%d",ma);
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <limits>
#include <queue>
#include <unordered_map>
#include <list>
#include <set>
#include <numeric>
using namespace std;
using ll = long long;
#define rep_init(i, init, n) for(int i = (init); i < (n); ++i)
#define rep(i, n) rep_init(i, 0, n)
using CC = pair<ll, ll>;
template<typename T>
constexpr T divide_floor(T a, T b)
{
T remainder = a % b;
return (a - remainder) / b;
}
int main()
{
int N, M;
cin >> N >> M;
vector<CC> P(N);
rep(i, N)
{
ll A, B;
cin >> A >> B;
P[i] = pair<ll, ll>(A, B);
}
sort(P.begin(), P.end(), [](CC a, CC b) { return a.first < b.first; });
ll ans = 0;
rep(i, N)
{
if (P[i].second >= M)
{
ans += P[i].first * M;
break;
}
else
{
ans += P[i].first * P[i].second;
M -= P[i].second;
}
}
cout << ans << endl;
return 0;
}
| 0
| 82,713,825
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
for (int a = 1; a < n; a++) {
count += (n - 1) / a;
}
cout << count;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define MOD 1000000007
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a), q(b), r(c);
for (int i = 0; i < a; ++i) {
cin >> p[i];
}
for (int i = 0; i < b; ++i) {
cin >> q[i];
}
for (int i = 0; i < c; ++i) {
cin >> r[i];
}
sort(p.rbegin(), p.rend());
sort(q.rbegin(), q.rend());
vector<int> all;
for (int i = 0; i < x; ++i) {
all.push_back(p[i]);
}
for (int i = 0; i < y; ++i) {
all.push_back(q[i]);
}
for (int i = 0; i < c; ++i) {
all.push_back(r[i]);
}
sort(all.rbegin(), all.rend());
ll ans = 0;
for (int i = 0; i < x + y; ++i) {
ans += all[i];
}
cout << ans << endl;
return 0;
}
| 0
| 37,491,585
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> h(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
vector<int> cost(N + 1, 0);
for (int i = 2; i <= N; i++) {
int minimum = INT_MAX;
for(int j = 1; j <= K; j++) {
if (i - j <= 0) continue;
minimum = min(minimum, cost[i - j] + abs(h[i]- h[i-j]));
}
cost[i] = minimum;
}
cout << cost[N] << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int N, Y;
cin >> N >> Y;
int x, y, z;
int ansx=0, ansy=0, ansz=0;
for(x = 0; x <= N; x++){
for(y = 0; y <= N-x; y++){
z = N-x-y;
if((10000*x + 5000*y + 1000*z) == Y){
ansx = x;
ansy = y;
ansz = z;
break;
}
}
}
if(ansx == 0 && ansy == 0 && ansz == 0){
ansx = -1;
ansy = -1;
ansz = -1;
}
cout << ansx << " " << ansy << " " << ansz << " " << endl;
}
| 0
| 29,905,349
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define all(x) (x).begin(),(x).end()
#define V vector
typedef V<int> vi;
typedef V<vi> vvi;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
constexpr auto INF = INT_MAX >> 1;
constexpr auto LINF = 5000000000000000;
constexpr auto MOD = 1000000007;
int main() {
int n;
cin >> n;
V<T> dish(n);
rep(i, n) {
int a, b;
cin >> a >> b;
dish[i] = make_tuple(a + b, a, b);
}
sort(all(dish), greater<T>());
ll taka = 0, aoki = 0;
rep(i, n) {
if (i & 1) aoki += get<2>(dish[i]);
else taka += get<1>(dish[i]);
}
cout << taka - aoki << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind
{
vector<int> par;
UnionFind(int N) : par(N)
{
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x)
{
if(par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y)
{
int rx = root(x);
int ry = root(y);
if(rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y)
{
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main()
{
int N, M, x, y;
cin >> N >> M;
vector<int> p(N);
int total = 0;
UnionFind tree(N);
for(int i = 0; i < N; i++){cin >> p.at(i);}
for(int i = 0; i < M; i++)
{
cin >> x >> y;
x--;
y--;
tree.unite(x, y);
}
for(int i = 0; i < N; i++)
{
if(tree.same(i, p.at(i) - 1)) total++;
}
cout << total << endl;
}
| 0
| 49,264,057
|
#include<iostream>
using namespace std;
int main()
{
int s, a[10000];
cin >> s;
a[0] = s;
for(int i = 1; i < 10000; i++)
{
if(s % 2 == 0)
{
s = s / 2;
a[i] = s;
}
else
{
s = 3 * s + 1;
a[i] = s;
}
for(int j = 0; j < i; j++)
{
if(i != j && a[i] == a[j])
{
cout << i + 1;
return 0;
}
}
}
}
|
#include<iostream>
using namespace std;
int main()
{
int h, w;
cin >> h >> w;
while(true)
{
if (h == 0 && w == 0) break;
for (int i = 0; i < h; i++)
{
if (i == 0 || i == h-1)
{
for (int j = 0; j < w; j++)
{
cout << "#";
}
cout << endl;
}
else
{
for (int j = 0; j < w; j++)
{
if (j == 0 || j == w-1)
{
cout << "#";
}
else
{
cout << ".";
}
}
cout << endl;
}
}
cout << endl;
cin >> h >> w;
}
return 0;
}
| 0
| 68,068,124
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double r(0.0), g(0.0);
cin >> r;
cin >> g;
const double goal = g * 2.0;
cout << goal - r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> l_l;
typedef pair<int , int> i_i;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<char> vec;
typedef vector<bool> veb;
typedef vector<string> ves;
typedef vector<vector<ll>> vvl;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvec;
typedef vector<vector<bool>> vveb;
typedef vector<vector<string>> vves;
#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 rep2(i,n) for(int i=2;i<(int)(n);i++)
#define repk(i,k,n) for(int i=k;i<(int)(n);i++)
#define fs first
#define sc second
#define pb push_back
#define pp pop_back
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define maxel(a) *max_element(all(a))
#define minel(a) *min_element(all(a))
#define acc accumulate
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define mod (1000000007)
typedef long long int64;
#define dame { puts("-1"); return 0;}
#define YES { cout << "YES" << endl; return 0; }
#define NO { cout << "NO" << endl; return 0; }
#define Yes { cout << "Yes" << endl; return 0; }
#define No { cout << "No" << endl; return 0; }
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; }
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,k;
cin >> n >> k;
if(n%k==0)cout << 0 << endl;
else cout << 1 << endl;
return 0;
}
| 0
| 93,784,666
|
#include<iostream>
#include<vector>
#define lli long long int
#include<climits>
#include<unordered_map>
#include<algorithm>
#include<bitset>
#include<map>
#include<cmath>
#include<queue>
#define pb push_back
#define N (int)(1e5)
using namespace std;
using namespace std;
int main()
{
int h,n;
int i,j;
cin>>h>>n;
vector<vector<lli>>dp(n,vector<lli>(h+1));
vector<int>att(n);
vector<int>pt(n);
for(i=0;i<n;i++){ cin>>att[i];cin>>pt[i];}
for(i=0,j=0;i<n;i++) dp[i][j] = 0;
vector<lli>mins(h+1);
mins[0] = 0;
for(j=1;j<=h;j++)
{
mins[j] = LLONG_MAX;
for(i=0;i<n;i++)
{
if(j-att[i]>=0) dp[i][j] = pt[i] + mins[j-att[i]];
else dp[i][j] = pt[i];
if(dp[i][j]<mins[j]) mins[j] = dp[i][j];
}
}
cout<<mins[h]<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n,m,x;
cin>>n>>m>>x;
int ans=10101010;
int a[12][12];
vector<int>c(n);
rep(i,n){
cin>>c.at(i);
rep(j,m) cin>>a[i][j];
}
rep(s,1<<n){
int cost=0;
vector<int>d(m,0);
rep(i,n){
if(s>>i &1){
cost+=c.at(i);
rep(j,m) d.at(j)+=a[i][j];
}
}
bool ok=true;
rep(j,m) if(d.at(j) <x) ok=false;
if(ok) ans=min(ans,cost);
}
if(ans==10101010) cout<<-1<<endl;
else cout<<ans<<endl;
}
| 0
| 94,515,295
|
#include<bits/stdc++.h>
using namespace std;
#define cinsc ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(0);
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOR(i,k,n) for(int64 i=k;i<(int64)n;i++)
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define IN(A, B, C) assert( B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
#define SQ(x) ((x)*(x))
const double pi=acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int,int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
int64 powr(int64 x,int64 y,int64 p)
{
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0){
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
void in_o(){
#ifndef LOCAL
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
cinsc;
}
int main(){
int n,p;
cin>>n>>p;
int r0=0,r1=0;
FOR(i,0,n){
int x;
cin>>x;
if(x%2)
r1++;
else
r0++;
}
int64 ans=0;
if(!r1)
ans=1LL<<n;
else
ans=1LL<<(n-1);
if(p)
ans=(1LL<<n)-ans;
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <queue>
#define rep(i,n) for(int i=0; i<(n); ++i)
#define outl(x) cout<< (x) << '\n'
using namespace std;
using let = const int;
int V, E;
bool vis[10005];
vector <int> G[10005];
vector <int> out;
void bfs(let s, int *indeg)
{
queue <int> que; que.emplace(s);
while (!que.empty()) {
let u = que.front(); que.pop();
out.emplace_back(u);
for(let x : G[u]) if( --indeg[x] == 0 && !vis[x]++ ) que.emplace(x);
}
}
void topologial_sort()
{
static int indeg[10005] = {};
rep(i, V)
for(let x: G[i]) ++indeg[x];
rep(i, V)
if (indeg[i] == 0 && !vis[i]++) bfs(i, indeg);
for_each(out.cbegin(), out.cend(), [](let x) { outl( x ); });
}
signed main()
{
cin.tie(0), ios::sync_with_stdio(false);
cin >> V >> E;
while(E--) {
int s, t;
cin >> s >> t;
G[s].emplace_back(t);
}
topologial_sort();
}
| 0
| 93,414,887
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=1<<17,INF=1<<30;
int main(){
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
while(1){
int N;cin>>N;
while(N--){
string S;cin>>S;
string T;
int now=0,cnt=0;
while(now<S.size()){
if(S[now]=='0'){
now++;
continue;
}
cnt=0;
while(S[now]==S[now+cnt]) cnt++;
int rcnt=cnt;
if(S[now]-'0'==1){
cnt%=5;
if(cnt==1) T+='.';
if(cnt==2) T+=',';
if(cnt==3) T+='!';
if(cnt==4) T+='?';
if(cnt==0) T+=' ';
}
if(S[now]-'0'==2){
cnt%=3;
if(cnt==1) T+='a';
if(cnt==2) T+='b';
if(cnt==0) T+='c';
}
if(S[now]-'0'==3){
cnt%=3;
if(cnt==1) T+='d';
if(cnt==2) T+='e';
if(cnt==0) T+='f';
}
if(S[now]-'0'==4){
cnt%=3;
if(cnt==1) T+='g';
if(cnt==2) T+='h';
if(cnt==0) T+='i';
}
if(S[now]-'0'==5){
cnt%=3;
if(cnt==1) T+='j';
if(cnt==2) T+='k';
if(cnt==0) T+='l';
}
if(S[now]-'0'==6){
cnt%=3;
if(cnt==1) T+='m';
if(cnt==2) T+='n';
if(cnt==0) T+='o';
}
if(S[now]-'0'==7){
cnt%=4;
if(cnt==1) T+='p';
if(cnt==2) T+='q';
if(cnt==3) T+='r';
if(cnt==0) T+='s';
}
if(S[now]-'0'==8){
cnt%=3;
if(cnt==1) T+='t';
if(cnt==2) T+='u';
if(cnt==0) T+='v';
}
if(S[now]-'0'==9){
cnt%=4;
if(cnt==1) T+='w';
if(cnt==2) T+='x';
if(cnt==3) T+='y';
if(cnt==0) T+='z';
}
now=now+rcnt+1;
}
cout<<T<<endl;
}
break;
}
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond&& mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T>
T round_up(const T& a, const T& b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2>& p) {
os << p.first << p.second;
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T>
T clamp(T& n, T a, T b) {
if (n < a) n = a;
if (n > b) n = b;
return n;
}
template <typename T>
static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T>
static T LCM(T u, T v) {
return u / GCD(u, v) * v;
}
template <typename T>
std::vector<T> enum_div(T n) {
std::vector<T> ret;
for (T i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) { ret.push_back(n / i); }
}
}
return ret;
}
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;
}
struct ToUpper {
char operator()(char c) {
return toupper(c);
}
};
struct ToLower {
char operator()(char c) {
return tolower(c);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, K;
cin >> N >> K;
map<int, vector<int>> m;
REP(i, N) {
int t, d;
cin >> t >> d;
m[t - 1].push_back(d);
}
for (auto&& a : m) { RSORT(a.second); }
vector<pair<int, int>> S;
S.reserve(N);
for (auto&& a : m) {
S.push_back({ a.second[0], 1 });
FOR(i, 1, a.second.size()) {
S.push_back({ a.second[i], 0 });
}
}
RSORT(S);
ll x = 0, y = 0;
priority_queue<int, vector<int>, greater<int>> q;
REP(i, K) {
x += S[i].first;
y += S[i].second;
if (S[i].second == 0) { q.push(S[i].first); }
}
ll ans = x + y * y;
FOR(i, K, N) {
if (q.empty()) break;
if (S[i].second == 1) {
x -= q.top();
q.pop();
x += S[i].first;
y += 1;
chmax(ans, x + y * y);
}
}
cout << ans << endl;
return 0;
}
| 0
| 49,726,206
|
#include <bits/stdc++.h>
#include <set>
#define ll long long
#include <string>
#define pb push_back
#define mp make_pair
# define pi 3.14159265358979323846
#define mod 1000000007
#define rep(i,n) for(i=0;i<n;i++)
using namespace std;
void fastio()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
ll int multiply(ll int a,ll int b)
{
ll int ans=(a%mod*b%mod)%mod;
return ans;
}
ll int add(ll int a, ll int b)
{
ll int ans=(a%mod+b%mod)% mod;
return ans;
}
void solve()
{
ll int n;
cin>>n;
ll int a[n+1],i;
for(i=1;i<=n;i++)
{
cin>>a[i];
}
ll int dp[n+1];
dp[0]=0;
dp[1]=0;
for(i=2;i<=n;i++)
{
ll int op1=abs(a[i]-a[i-1])+dp[i-1];
ll int op2=(i>2)? abs(a[i]-a[i-2])+dp[i-2]:1e18;
dp[i]=min(op1,op2);
}
cout<<dp[n]<<endl;
}
int main()
{
fastio();
ll int t;
t=1;
while(t--)
{
solve();
}
}
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
using ll = long long;
using graph = std::vector<std::vector<ll>>;
using namespace std;
int main() {
ll N,M,V,P;
cin >> N >> M >> V >> P;
vector<ll> A(N);
vector<ll> B(N + 1);
B[0] = 0;
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
sort(A.begin(),A.end(),greater<ll>());
for(int i = 0; i < N; i++){
B[i + 1] = B[i] + A[i];
}
ll count = 0;
ll thr = A[P - 1];
for (int i = 0; i < N; ++i) {
if(i < P){
count++;
continue;
}
if(A[P - 1] > A[i] + M){
continue;
}
ll votable = 0;
votable += (P - 1) * M;
votable += (N - i) * M;
votable += (i - P + 1) * (A[i] + M) - (B[i]-B[P - 1]);
if(votable >= M * V){
count++;
}
}
cout << count << endl;
}
| 0
| 28,678,844
|
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <stack>
#include <numeric>
#include <algorithm>
#include <tuple>
#include <stdio.h>
#include <bitset>
#include <limits.h>
#include <complex>
#include <deque>
#include <iomanip>
#include <list>
#include <cstring>
using namespace std;
#define pi pair<int,int>
#define pl pair<long long,long long>
#define chmax(a,b) (a<b ? a=b:0)
#define chmin(a,b) (a>b ? a=b:0)
#define en cout << endl
const int MM = 1e9;
const int MOD = MM+7;
const long double PI = acos(-1);
const long long INF = 1e15;
int dx[8] = {-1,0,1,0,-1,-1,1,1};
int dy[8] = {0,-1,0,1,-1,1,1,-1};
template<typename T>
T GCD(T u,T v){
return v ? GCD(v,u%v) : u;
}
template<typename T>
T LCM(T x,T y){
T gc = GCD(x,y);
return x*y/gc;
}
struct edge {
int time, x, y;
};
int main(){
long long N,K; cin >> N >> K;
vector<long long> t(N),d(N);
vector<pair<long long,long long> > p(N);
for (int i = 0; i < N; i++){
cin >> t[i] >> d[i];
p[i] = {d[i],t[i]};
}
sort(p.begin(),p.end());
reverse(p.begin(),p.end());
map<long long,long long> vari;
long long sum = 0;
priority_queue<pair<long long,long long>,vector<pair<long long,long long> >,greater<pair<long long,long long> > > pq;
for (int i = 0; i < K; i++){
vari[p[i].second]++;
sum += p[i].first;
pq.push(p[i]);
}
sum += vari.size()*vari.size();
long long total = sum;
for (int i = K; i < N; i++){
if (vari[p[i].second] != 0) continue;
while (!pq.empty()){
pair<long long,long long> se = pq.top();
pq.pop();
if (vari[se.second] > 1){
long long n = vari.size();
total = total + p[i].first - se.first + n*n - (n-1)*(n-1);
vari[se.second]--;
vari[p[i].second]++;
sum = max(sum,total);
break;
}
}
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
using ll = long long;
const int INF = (1<<30)-1;
const long long LINF = (1LL<<62)-1;
const int dx[] = {1, 0};
const int dy[] = {0, 1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
using P = pair<int, int>;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
deque<P> deq;
vector<vector<int>> grid(h, vector<int>(w, INF));
grid[0][0] = (s[0][0] == '#');
deq.push_front({0, 0});
while (!deq.empty()) {
int x, y;
tie(x, y) = deq.front();
deq.pop_front();
rep(i, 2) {
if (x+dx[i] < 0 || y+dy[i] < 0 || x+dx[i] >= h || y+dy[i] >= w)
continue;
if (s[x+dx[i]][y+dy[i]] == '.' || s[x+dx[i]][y+dy[i]] == s[x][y]) {
if (chmin(grid[x+dx[i]][y+dy[i]], grid[x][y]))
deq.push_front({x+dx[i], y+dy[i]});
} else {
if (chmin(grid[x+dx[i]][y+dy[i]], grid[x][y]+1))
deq.push_back({x+dx[i], y+dy[i]});
}
}
}
cout << grid[h-1][w-1] << endl;
return 0;
}
| 0
| 87,286,639
|
#include <bits/stdc++.h>
#define pb push_back
#define ll long long
#define mp make_pair
#define inf 1000000007
using namespace std;
set<double> lms[40009];
void setadd(int lef, int rig, int lim, int n,int sum){
double dlef = 1.0 * lef;
double drig = 1.0 * rig;
for(int i=0;i<=2*sum;i++){
double ct = 0.5 * i;
if(ct < dlef){
lms[i].insert(lim+(dlef-ct));
}
else if(drig<ct){
lms[i].insert(lim+(ct-drig));
}
else{
lms[i].insert(lim);
}
}
}
signed main(){
int n;
cin>>n;
vector<int> t,x;
int sum = 0;
for(int i=0;i<n;i++){
int tt;
cin>>tt;
t.pb(tt);
sum+=tt;
}
for(int i=0;i<n;i++){
int tx;
cin>>tx;
x.pb(tx);
}
int cur = 0;
setadd(0,0,0,n,sum);
for(int i=0;i<n;i++){
setadd(cur,cur+t[i],x[i],n,sum);
cur += t[i];
}
setadd(cur,cur,0,n,sum);
vector<double> flim;
for(int i=0;i<=2*sum;i++){
flim.pb( *(lms[i].upper_bound(-1)) );
}
double ans=0;
for(int i=0;i<2*sum;i++){
ans += 0.25*(flim[i]+flim[i+1]);
}
cout<<setprecision(12)<<ans<<endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
long long R = 0;
long long G = 0;
long long B = 0;
for (int n = 0; n < S.size(); ++n) {
if ('R' == S[n]) {
++R;
}
else if('G'==S[n]){
++G;
}
else {
++B;
}
}
long long ans = R * G * B;
for (int i = 0;i<N;++i) {
for (int j = i+1;j<N;++j) {
int k = 2 * j - i;
if (k >= N) {
continue;
}
if (S[i]==S[j]) {
continue;
}
if (S[i]==S[k]) {
continue;
}
if (S[j]==S[k]) {
continue;
}
--ans;
}
}
cout << ans <<endl;
return 0;
}
| 0
| 44,767,010
|
bool DBG = false;
#include<bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using ll = long long;
using ld = long double;
using bint = boost::multiprecision::cpp_int;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define IFOR(i,a,b) for(int i=((b)-1);i>=(a);--i)
#define RPT(i,a,b) for(int i=(a);i<((a)+(b));++i)
#define IRPT(i,a,b) for(int i=((a)+(b)-1);i>=(a);--i)
#define ALL(x) x.begin(),x.end()
#define RALL(x) x.rbegin(),x.rend()
#define fs first
#define sd second
#define couts(x) cout << (x) << (" ")
#define coutn(x) cout << (x) << ("\n")
#define ncouts(x) numout(x),outst[outst_N++] = ' '
#define ncoutn(x) numout(x),outst[outst_N++] = '\n'
#define scouts(x) strout(x),outst[outst_N++] = ' '
#define scoutn(x) strout(x),outst[outst_N++] = '\n'
#define dcouts(x) if(DBG) couts(x)
#define dcoutn(x) if(DBG) coutn(x)
#define endl "\n"
#define psb push_back
#define ppb pop_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define LBIT(x,a) (((x)>>(a))&1LL)
#define IBIT(x,a) (((x)>>(a))&1)
#define BCOUNT(x) (__builtin_popcount(x))
template<typename T> std::istream &operator>>(std::istream &is, std::vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T1, typename T2> std::istream &operator>>(std::istream &is, std::pair<T1,T2> &p){is >> p.first >> p.second; return is; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::deque<T> &vec){ os << "deque["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> std::ostream &operator<<(std::ostream &os, const std::unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> std::ostream &operator<<(std::ostream &os, const std::map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> std::ostream &operator<<(std::ostream &os, const std::unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<class T> using V = vector<T>;
template<class T> using V2 = V<V<T>>;
template<class T> using V3 = V<V2<T>>;
template<class T> using V4 = V<V3<T>>;
char outst[20'000'000]; int outst_N = 0;
char outst_tmp[200];
template<class NUM >
void numout(NUM n){
if(n<0) { n*=-1; outst[outst_N++] = '-';}
if(n==0){ outst[outst_N++] = '0'; return;}
int cnt = 0;
while(n>0){
outst_tmp[cnt++] = '0' + (n % 10);
n /= 10;
}
IFOR(i,0,cnt){
outst[outst_N++] = outst_tmp[i];
}
}
void strout(std::string s){
for(auto x: s){
outst[outst_N++] = x;
}
}
constexpr ll LINF = 1LL << 60;
constexpr int IINF = 1 << 28;
constexpr ll mod = 1'000'000'007;
struct food{
ll x, y, z;
food(ll x=0, ll y=0, ll z=0) : x(x), y(y), z(z) {}
};
std::ostream &operator<<(std::ostream &os, const food &vec){ os << "[" << vec.x << "," << vec.y << "," << vec.z << "]"; return os; }
void solve(){
int n, m; cin >> n >> m;
V<food> foods(n);
FOR(i,0,n) cin >> foods[i].x >> foods[i].y >> foods[i].z;
ll ret = 0;
FOR(i,0,8){
sort(RALL(foods), [&](food x, food y){
ll fx = x.x*(2*( (i>>0)&1 )-1) + x.y*(2*( (i>>1)&1 )-1) + x.z*(2*( (i>>2)&1 )-1);
ll fy = y.x*(2*( (i>>0)&1 )-1) + y.y*(2*( (i>>1)&1 )-1) + y.z*(2*( (i>>2)&1 )-1);
return (fx<fy);
});
ll tmp = 0;
FOR(j,0,m){
auto x = foods[j];
ll fx = x.x*(2*( (i>>0)&1 )-1) + x.y*(2*( (i>>1)&1 )-1) + x.z*(2*( (i>>2)&1 )-1);
tmp += fx;
}
ret = max<ll>(ret, tmp);
}
cout << ret;
}
int main(void){
cin.tie(0);
solve();
return 0;
}
|
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <functional>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
typedef long long ll;
#define N 100000
int n;
vector<vector<int> > e(N);
vector<int> a(N) , p(N) , d(N);
void dfs(int now, int from, int depth){
p[now] = from;
d[now] = depth;
if (e[now].size()==0){
a[now] = 2;
}
REP(k,e[now].size()){
dfs(e[now][k],now,depth+1);
}
}
int main(void) {
cin >> n;
REP(i,n){
int id , k;
cin >> id >> k;
REP(i,k){
int c;
cin >> c;
e[id].push_back(c);
a[c]=1;
}
}
REP(i,n){
if (a[i]==0){
p[i]=-1;
d[i]=0;
REP(k,e[i].size()){
dfs(e[i][k],i,1);
}
}
}
REP(i,n){
printf("node %d: parent = %d, depth = %d, ",i,p[i],d[i]);
if (a[i]==0)
cout << "root";
if (a[i]==1)
cout << "internal node";
if (a[i]==2)
cout << "leaf";
printf(", [");
REP(k,e[i].size()){
printf("%d",e[i][k]);
if (k<e[i].size()-1){
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
}
| 0
| 76,138,275
|
#include<stdio.h>
int main(){
int H1, M1, H2, M2, K;
scanf("%d %d %d %d %d", &H1, &M1, &H2, &M2, &K);
int x;
x = ((H2 - H1) * 60) + (M2 - M1) - K;
printf("%d", x);
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <ctype.h>
using namespace std;
using ll = long long;
using PAIR = pair<int, int>;
using PAIRLL = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
#define TR ","
#define fi first
#define se second
#define rep(i,N) for(ll i=0;i<(ll)N;++i)
#define repe(i,a,b) for(ll i=a;i<(ll)b;++i)
#define all(v) v.begin(), v.end()
#define IO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define INF 100000000
ll gcd(ll a, ll b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y) {
return x / gcd(x, y) * y;
}
ll waz = 76543217;
ll inv(ll x) {
if (x == 1) { return 1; }
if (x == 0) { return 0; }
else {
ll a = (waz - inv(waz % x) * (waz / x)) % waz;
if (a >= 0) { return a; }
else { return waz + a; }
}
}
void printVector(const vector<int>& vec) {
for (int value : vec) {
cout << value << " ";
}
cout << endl;
}
vector<ll> p;
ll phi(ll x) {
ll a = x;
ll b = x;
for (ll k = 0; k != p.size(); ++k) {
if (a % p[k] == 0) {
while (a % p[k] == 0) {
a /= p[k];
}
b = b / p[k] * (p[k] - 1);
}
if (a == 1) { break; }
}
return b;
}
bool my_compare(pair<string, int> a, pair<string, int> b) {
if (a.first != b.first) {
return a.first < b.first;
}
if (a.second != b.second) {
return a.second > b.second;
}
else {
return true;
}
}
int main()
{
IO;
ll N, M; cin >> N >> M;
vector<pair<ll, ll> > pa(M);
ll p, y;
map<ll, pair<ll, ll> > ma;
map<pair<ll, ll>, string> ma2;
rep(i, M) {
cin >> p >> y;
pa[i] = make_pair(p, y);
ma[i] = pa[i];
}
sort(all(pa));
ll jj = 0;
rep(i, M) {
++jj;
string a=to_string(pa[i].first);
if (a.size() == 1) { a = "00000"+a; }
else if (a.size() == 2) { a = "0000" + a; }
else if (a.size() == 3) { a = "000" + a; }
else if (a.size() == 4) { a = "00" + a; }
else if (a.size() == 5) { a = "0" + a; }
string b = to_string(jj);
if (b.size() == 1) { b = "00000" + b; }
else if (b.size() == 2) { b = "0000" + b; }
else if (b.size() == 3) { b = "000" + b; }
else if (b.size() == 4) { b = "00" + b; }
else if (b.size() == 5) { b = "0" + b; }
ma2[pa[i]]=a + b;
if (i < pa.size() - 1 && pa[i].first != pa[i + 1].first) jj = 0;
}
rep(i, M) {
cout << ma2[ma[i]] << endl;
}
}
| 0
| 96,768,452
|
#include <iostream>
#include <complex>
using namespace std;
typedef complex<double> P;
#define EPS (1e-10)
double cross(P a, P b){
return (a.real() * b.imag() - a.imag() * b.real());
}
int is_intersect(P a1, P a2, P b1, P b2){
return (cross(a2-a1, b1-a1) * cross(a2-a1, b2-a1) < EPS) &&
(cross(b2-b1, a1-b1) * cross(b2-b1, a2-b1) < EPS);
}
int main(void){
double x,y;
P p[4],o;
while(1){
for(int i=0;i<4;i++){
if(!(cin>>x>>y)) return 0;
p[i] = P(x,y);
}
o = P((p[0].real() + p[1].real() + p[2].real()) / 3,
(p[0].imag() + p[1].imag() + p[2].imag()) / 3);
if(is_intersect(p[0],p[1],p[3],o) ||
is_intersect(p[1],p[2],p[3],o) ||
is_intersect(p[2],p[0],p[3],o)){
cout<<"NO\n";
}
else{
cout<<"YES\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout<<setprecision(32);
int n; ll m;
cin>>n>>m;
set<int> st;
ll lcm = 1;
for(int i = 0; i < n; i++){
ll x; cin>>x;
int cnt = 0;
while(x%2 == 0){
x >>= 1;
cnt++;
}
cnt--;
st.insert(1<<cnt);
lcm = lcm*(x/__gcd(x, lcm));
if(lcm > m){
cout<<0<<endl;
exit(0);
}
}
if(st.size() != 1){
cout<<0<<endl;
exit(0);
}
m /= (*st.begin());
ll mul = m/lcm;
cout<<(mul + 1)/2<<endl;
return 0;
}
| 0
| 34,969,217
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
string x;
cin >> x;
int sum = 0;
for (int i = 0; i < x.length(); ++i){
sum += x[i]-'0';
}
if(sum%9 == 0){cout << "Yes" << endl;}
else{std::cout << "No" << std::endl;}
return 0;
}
|
#include <bits/stdc++.h>
#define debug(x) cerr << #x << ": " << x << endl
#define debugArray(x, n) \
for (long long hoge = 0; (hoge) < (n); ++(hoge)) \
cerr << #x << "[" << hoge << "]: " << x[hoge] << endl
using namespace std;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
string N;
cin >> N;
int n = N.length();
int K;
cin >> K;
long long dp[n + 1][K + 1];
int cnt = 0;
fill(dp[0], dp[0] + K + 1, 0);
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = 1;
for (int k = 1; k <= K; k++) {
dp[i][k] = dp[i - 1][k];
if (cnt == k - 1) {
dp[i][k] += 9 * (dp[i - 1][k - 1] - 1) + (N[i - 1] - '0');
} else {
dp[i][k] += 9 * dp[i - 1][k - 1];
}
}
cnt += N[i - 1] > '0';
}
cout << dp[n][K] << endl;
return 0;
}
| 0
| 44,539,208
|
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <complex>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
typedef vector<int> vi;
#define de(x) cout << #x << "=" << x << endl
#define rep(i,a,b) for(int i=a;i<(b);++i)
#define per(i,a,b) for(int i=(b)-1;i>=(a);--i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
int main(){
ll x , y;
cin >> x >> y;
puts(abs(x - y) <= 1 ? "Brown" : "Alice");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(),(x).end()
using ll = long long;
using ld = long double;
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
using pll = pair<long long,long long>;
#define cY cout<<"Yes"<<endl
#define cN cout<<"No"<<endl
const long long INF = 1LL << 60;
const long long MOD = 1000000007;
const long double pi = (acos(-1));
#define pb push_back
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;
}
vector<long long> divisor(long long n) {
vector<long long> ret;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
ll nCr(ll n, ll r) {
ll ans = 1;
for (ll i = n; i > n - r; --i) {
ans = ans*i;
}
for (ll i = 1 ; i < r + 1; ++i) {
ans = ans / i;
}
return ans;
}
map< ll, ll > prime_factor(ll n) {
map< ll, ll > ret;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
int main(){
ll N;
cin>>N;
vl even(N/2);
vl A(N);
rep(i,N){
cin>>A[i];
if(i%2==1){
even[i/2]=A[i];
}
}
sort(all(even));
sort(all(A));
even.pb(-1);
ll E=0;
ll Ans=0;
rep(i,N){
if(A[i]==even[E]){
E++;
if(i%2==0){
Ans++;
}
}
}
cout<<Ans<<endl;
}
| 0
| 28,889,742
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(0);cin.tie(0);
set<int> s;
for(int i=0;i<3;++i){
int x;
cin>>x;
s.insert(x);
}
cout<<int(s.size())<<'\n';
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll n, m;
cin >> n >> m;
vector<vector<ll>> S(n, vector<ll>(2));
vector<vector<ll>> P(m, vector<ll>(2));
for (int i = 0; i < n; i++)
{
ll a, b;
cin >> a >> b;
S.at(i).at(0) = a;
S.at(i).at(1) = b;
}
for (int i = 0; i < m; i++)
{
ll c, d;
cin >> c >> d;
P.at(i).at(0) = c;
P.at(i).at(1) = d;
}
for (int i = 0; i < n; i++)
{
ll man = 200000000;
ll ans = m;
for (int j = 0; j < m; j++)
{
ll d = abs(S.at(i).at(0) - P.at(j).at(0)) + abs(S.at(i).at(1) - P.at(j).at(1));
if (man > d)
{
ans = j + 1;
}
man = min(man, d);
}
cout << ans << endl;
}
}
| 0
| 23,599,735
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()
#define LL long long
using namespace std;
int N;
int A[100000];
vector<int> edge[100000];
bool used[100000];
LL DFS(int v){
used[v]=true;
if(edge[v].size()==1)return A[v];
vector<LL> lift;
REP(i,edge[v].size())if(!used[edge[v][i]])lift.push_back(DFS(edge[v][i]));
REP(i,lift.size())if(lift[i]==-1)return -1;
LL sum = 0;
REP(i,lift.size())sum+=lift[i];
LL maxl = *max_element(ALL(lift));
LL lower = (maxl*2 > sum ? maxl : (sum+1)/2);
if(A[v]<lower||A[v]>sum)return -1;
return 2*A[v]-sum;
}
int main(){
cin>>N;
REP(i,N)cin>>A[i];
REP(i,N-1){
int a,b;cin>>a>>b;
edge[--a].push_back(--b);
edge[b].push_back(a);
}
fill_n(used,N,false);
REP(i,N){
if(edge[i].size()>1){
if(DFS(i)==0)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
return 0;
}
}
if(A[0]==A[1])cout<<"YES"<<endl;
else cout<<"NO"<<endl;
return 0;
}
|
#include<cstdio>
#include<iostream>
#define MAX_N 10000000;
using namespace std;
long long int dp[20][20];
int w,h;
int main(){
while(1){
for(int i=0;i<20;i++){
for(int j=0;j<20;++j){
dp[i][j]=0;
}
}
dp[1][1]=1;
cin>>w>>h;
int n,x,y;
if(w==0&&h==0)break;
cin>>n;
for(int i=0;i<n;i++){
cin>>x>>y;
dp[x][y]=-1;
}
for(int i=1;i<=w;++i){
for(int j=1;j<=h;++j){
if(dp[i][j]!=-1){
if(dp[i+1][j]!=-1)
dp[i+1][j]+=dp[i][j];
if(dp[i][j+1]!=-1)
dp[i][j+1]+=dp[i][j];
}
}
}
cout<<dp[w][h]<<endl;
}
return 0;
}
| 0
| 91,644,089
|
#include <iostream>
#include <string>
int main() {
std::string str;
std::cin >> str;
int n;
std::cin >> n;
std::string command;
int a, b;
for(int i = 0; i < n; ++i) {
std::cin >> command >> a >> b;
if(command == "replace") {
std::string rep;
std::cin >> rep;
str.replace(a, b - a + 1, rep);
}
else if(command == "reverse") {
std::string rev(str.substr(a, b - a + 1));
for(int j = 0; j < b - a + 1; ++j) {
str[a + j] = rev[b - a - j];
}
}
else if(command == "print") {
std::cout << str.substr(a, b - a + 1) << std::endl;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
int ans=1,p=a[0];
for(int i=1;i<n;i++)
{
if(a[i]<=p)
{
ans++;
p=a[i];
}
}
cout<<ans<<endl;
}
| 0
| 14,580,573
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <utility>
#include <set>
#include <stack>
#include <climits>
#include <cmath>
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define rep1(i,n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
#define reps(i,s,n) for(int i=s, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
#define MOD 1000000007
using namespace std;
int main(void){
ll N;
string S;
ll kosu[26];
cin>>N>>S;
MEMSET(kosu, 0);
rep(i, N){
kosu[S[i]-'a']++;
kosu[S[i]-'a']%=MOD;
}
ll count=1;
rep(i, 26){
count*=((kosu[i]+1)%MOD);
count%=MOD;
}
cout<<(count-1+MOD)%MOD<<endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#define mp make_pair
#define mt make_tuple
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
template <class T>
using max_priority_queue = priority_queue<T>;
template <class T>
using min_priority_queue = priority_queue<T, std::vector<T>, std::greater<T>>;
const int INF = 1 << 29;
const ll LL_INF = 1LL << 60;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
int N;
vector<int> A, B;
int main()
{
cin >> N;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; i++)
{
cin >> A[i] >> B[i];
}
if (A == B)
{
cout << 0 << endl;
return 0;
}
ll sum_a = accumulate(A.begin(), A.end(), 0LL);
ll res = LL_INF;
for (int i = 0; i < N; i++)
{
cin >> A[i] >> B[i];
if (A[i] > B[i])
{
res = min(res, (ll)B[i]);
}
}
cout << sum_a - res << endl;
return 0;
}
| 0
| 35,397,271
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<string>
#include<cstring>
#include<functional>
#include<bitset>
using namespace std;
typedef long long int ll;
bool color[100001];
int d[100001];
int f[100001];
int t = 0;
vector< pair<int, int> > g[100001];
int x[100001];
bool dfs(int u){
color[u] = 1;
d[u] = ++t;
for(int i = 0; i < g[u].size(); i++){
if(x[g[u][i].first] == 2000000001){
x[g[u][i].first] = x[u] + g[u][i].second;
}
else if(x[g[u][i].first] != x[u] + g[u][i].second){
return 0;
}
if(color[g[u][i].first] == 0){
if(dfs(g[u][i].first) == 0) return 0;
}
}
f[u] = ++t;
return 1;
}
int main(){
int n, m, l, r, d;
cin >> n >> m;
for(int i = 0; i < m; i++){
cin >> l >> r >> d;
g[l].push_back(make_pair(r,d));
g[r].push_back(make_pair(l, -d));
}
memset(color, 0, sizeof(color));
for(int i = 1; i <= n; i++){
x[i] = 2000000001;
}
for(int i = 1; i <= n; i++){
if(!color[i]){
x[i] = 0;
bool res = dfs(i);
if(!res){
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
using namespace std;
int static fast = [](){
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0); return 0;
}();
int main() {
int n;
cin >> n;
vector<ll> arr(n, 0);
for(auto& val: arr)
cin >> val;
sort(arr.begin(), arr.end());
vector<ll> acc(n, 0);
acc[0] = arr[0];
for(int i = 1; i < n; i++) {
acc[i] = acc[i-1] + arr[i];
}
int ans = 1;
for(int i = arr.size()-2; i >= 0; i--) {
if (acc[i]*2 >= arr[i+1])
ans += 1;
else
break;
}
cout << ans << endl;
return 0;
}
| 0
| 88,121,883
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define N 100000
#define ff first
#define ss second
#define si size()
#define mod 1000000007
#define large 10000000000000001
#define FAST ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);srand(time(NULL));
int main()
{
FAST;
ll n;
cin>>n;
cout<<(n-2)*180;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
#define rrep(i, m, n) for(int (i)=(m); (i)<(n); (i)++)
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
#define rev(i, n) for(int (i)=(n)-1; (i)>=0; (i)--)
#define vrep(i, c) for(__typeof((c).begin())i=(c).begin(); i!=(c).end(); i++)
#define ALL(v) (v).begin(), (v).end()
#define mp make_pair
#define pb push_back
template<class T1, class T2> inline void minup(T1& m, T2 x){ if(m>x) m=static_cast<T2>(x); }
template<class T1, class T2> inline void maxup(T1& m, T2 x){ if(m<x) m=static_cast<T2>(x); }
#define INF 1000000000
#define MOD 1000000009
#define EPS 1E-9
const int n = 10;
int h[n];
int main()
{
rep(i, n) cin >> h[i];
sort(h, h+n, greater<int>());
cout << h[0] << endl << h[1] << endl << h[2] << endl;
return 0;
}
| 0
| 34,176,323
|
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=50000+10,maxm=20+10;
int n,m;
int d[maxm],f[maxn];
int main(){
cin>>n>>m;
for(int i=1;i<=m;i++)
cin>>d[i];
memset(f,0x3f,sizeof(f));
f[0]=0,f[1]=1;
for(int i=1;i<=m;i++)
for(int j=0;j<=n;j++)
if(j-d[i]>=0)
f[j]=min(f[j],f[j-d[i]]+1);
cout<<f[n]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,l;
bool f=false;
cin >> n >> l;
int k=1,j=0;
vector<int> a(n);
vector<int> co(n-1);
cin >> a.at(0);
for(int i=1;i<n;i++){
cin >> a.at(i);
if(a.at(i-1)+a.at(i)>=l){
f=true;
k=i;
}
}
if(f){
for(int i=1;i<k;i++){
co.at(i-1)=i;
j=i;
}
for(int i=n-1;i>=k;i--,j++){
co.at(j)=i;
}
cout << "Possible" << endl;
for(int i=0;i<n-1;i++){
cout << co.at(i) << endl;
}
}else{
cout << "Impossible" << endl;
}
}
| 0
| 50,730,039
|
#include<bits/stdc++.h>
using namespace std;
#define OUT(x) cout<<x<<endl
int main(){
int n,ud,ans;
bool o;
string ins;
while(cin>>n&&n){
o = false;
ud = ans = 0;
for(int i=0;i<n;i++){
cin >> ins;
if(ins == "lu" || ins == "ru")ud++;
else ud--;
if(!o&&ud==2){
ans++;
o = true;
}
else if(o&&!ud){
ans++;
o = false;
}
}
OUT(ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb insert
#define eb emplace_back
#define ff first
#define ss second
typedef long long int ll;
typedef long double ld;
#define all(a) a.begin(), a.end()
#define show(x) cerr << #x << " is " << x << "\n"
#define show2(x, y) cerr << #x << " " << #y << " " << x << " " << y << "\n"
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> pp;
typedef vector<pp> vp;
typedef map<pp, ll> ipi;
typedef map<pp, char> ipc;
typedef map<ll, ll> ii;
typedef set<ll> sl;
typedef multiset<ll> msl;
typedef map<char, ll> ci;
typedef set<pair<ll, ll>> sp;
const ll mod = 1e9 + 7;
const ll N = 2e6 + 1;
void solve()
{
ll a,b;cin>>a>>b;
vl cnt(a+1,0);
ii m;
for(int i=0;i<b;i++){
ll k;cin>>k;
m[k]=1;
}
cnt[0]=1;
if(!m[1])
cnt[1]=1;
for(int i=2;i<=a;i++){
if(!m[i])
cnt[i]=(cnt[i-1]+cnt[i-2])%mod;
}
cout<<cnt[a]<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t;
t=1;
while(t--){
solve();
}
return 0;
}
| 0
| 12,563,326
|
#include <iostream>
using namespace std;
int main(){
int n,gold;
int res10000=-1,res5000=-1,res1000=-1;
cin >> n >> gold;
for(int x = 0;x <= n;x++){
for(int y = 0;x+y <= n;y++){
int z = n - x - y;
int total = 10000*x + 5000*y + 1000*z;
if(total == gold){
res10000 = x;
res5000 = y;
res1000 = z;
}
}
}
cout << res10000 << " " << res5000 << " " << res1000 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef long long ll;
typedef long double ld;
int main(){
int t=1;
while(t--){
int s;
cin>>s;
vector<int> a(1000001);
a.at(s)++;
for(int i=2;i<=1000000;i++){
int n;
if(s%2==0){
n=s/2;
}
else{
n=(3*s)+1;
}
if(a.at(n)==1){
cout<<i;
return 0;
}
else{
a.at(n)++;
s=n;
}
}
cout<<1000000;
}
return 0;
}
| 0
| 56,364,954
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for (ll i = 0; i < (n); ++i)
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n-1);
rep(i,n-1) cin >> b[i];
a[0] = b[0];
rep(i,n-2){
a[i+1] = min(b[i],b[i+1]);
}
a[n-1] = b[n-2];
ll ans=0;
rep(i,n) ans += a[i];
cout << ans << endl;
return(0);
}
|
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
#ifdef HOME
#define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
#define DEBUG(...)
#endif
int MOD = 1e9+7;
void ADD(LL& x,LL v){x=(x+v)%MOD;if(x<0)x+=MOD;}
const int SIZE = 1e6+10;
int u[SIZE];
PII AA[SIZE];
int main(){
int N,K;
R(N,K);
REP(i,N)R(AA[i].S,AA[i].F);
sort(AA,AA+N,greater<PII>());
int cnt=0;
LL v=0;
REP(i,K){
u[AA[i].S]++;
if(u[AA[i].S]==1)cnt++;
v+=AA[i].F;
}
int it=K-1;
LL an=v+(LL)cnt*cnt;
REPP(i,K,N){
if(!u[AA[i].S]){
while(it>=0&&u[AA[it].S]==1)it--;
if(it<0)break;
u[AA[it].S]--;
v-=AA[it].F;
it--;
u[AA[i].S]++;
v+=AA[i].F;
cnt++;
an=max(an,v+cnt*(LL)cnt);
}
}
W(an);
return 0;
}
| 0
| 69,575,286
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.