code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef int64_t ll;
typedef uint64_t ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
void primeFactorization(uint64_t a, list<uint64_t> &factors){
long i,sq;
if(a%2==0){
factors.push_back(2);
primeFactorization(a/2,factors);
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors);
return;
}
}
if(a!=1){
factors.push_back(a);
}
}
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
ll pCount(int x){
if(x==0) return 1;
return pCount(x-1)*2 + 1;
}
ll allCount(int x){
if(x==0) return 1;
return allCount(x-1)*2 + 3;
}
signed main() {
int n;
cin >> n;
unordered_map<int,int> even;
unordered_map<int,int> odd;
int v;
for(int i=0;i<n;i++){
cin >> v;
if(i%2==0) even[v]++;
else odd[v]++;
}
multimap<int,int,greater<int>> invEven;
multimap<int,int,greater<int>> invOdd;
for(auto e:even){
invEven.insert(make_pair(e.second,e.first));
}
for(auto o:odd){
invOdd.insert(make_pair(o.second,o.first));
}
int maxCount = 0;
for(auto ie:invEven){
for(auto io:invOdd){
if(ie.second!=io.second){
maxCount = max(maxCount,ie.first+io.first);
break;
}
}
}
if(maxCount==0)maxCount=n/2;
cout << n-maxCount << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define be(v) (v).begin(),(v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod=1000000007;
#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;
ll n, m;
ll a[2005], b[2005];
ll dp[2005][2005], sum[2005][2005];
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
for(int i = 1; i <= n; i++) cin >> a[i];
for(int i = 1; i <= m; i++) cin >> b[i];
dp[0][0] = 1;
for(int i = 0; i <= n; i++) sum[i][0] = 1;
for(int i = 0; i <= m; i++) sum[0][i] = 1;
for(int i = 1; i <= n; i++){
for(int j = 1; j <=m; j++){
if(a[i] == b[j]) dp[i][j] = sum[i-1][j-1];
sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + dp[i][j] + mod;
sum[i][j] %= mod;
}
}
cout << sum[n][m] << endl;
return 0;
}
| 0
| 62,761,890
|
#include <bits/stdc++.h>
using namespace std;
#define rp(i, k, n) for (int i = k; i < n; i++)
typedef long long ll;
typedef double ld;
template<class T>inline bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>inline bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7ll;
const double PI=3.14159265358979323846;
int N_MAX = 5010;
int n, k;
vector<ll> P(N_MAX), C(N_MAX);
ll solve() {
ll res = -INF;
vector<vector<ll>> cycle;
vector<bool> used(n+10, false);
rp(i, 0, n) {
if(used[i]) continue;
int cur = i;
vector<ll> s;
while(1) {
if(used[cur]) break;
used[cur] = true;
s.push_back(C[cur]);
cur = P[cur];
}
cycle.push_back(s);
}
for(auto x:cycle) {
ll M = x.size();
ll sum = 0ll;
for(auto y: x) sum+=y;
vector<ll> Cum(2*M);
Cum[0] = x[0];
rp(i, 1, 2*M) {
Cum[i] = Cum[i-1] + x[i%M];
}
rp(r, 1, M+1) {
if(r > k) continue;
rp(m, 0, M){
ll temp = Cum[m+r] - Cum[m];
if(sum > 0) temp += ((k-r) / M) * sum;
chmax(res, temp);
}
}
}
return res;
}
int main() {
cin >> n >> k;
rp(i, 0, n) {
ll p; cin >> p; p--; P[i] = p;
}
rp(i, 0, n) {
ll c; cin >> c; C[i] = c;
}
cout << solve() << endl;
}
|
#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 dp[n],x=0;
dp[0]=0;
for(int i=1;i<n;i++)
{
if(i==1)
{
dp[i]=abs(a[i-1]-a[i]);
}
else
{
dp[i]=min(dp[i-1]+abs(a[i-1]-a[i]),dp[i-2]+abs(a[i-2]-a[i]));
}
}
for(int i=0;i<n;i++)
{
}
cout<<dp[n-1];
}
| 0
| 67,641,065
|
#include<bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
string s;
cin>>s;
int g=0;
int f=0;
int h=0;
if(s[0]=='A'){
g=1;
}
for(int i=0;i<s.length();i++){
if(s[i]>=92){
h++;
}
}
for(int i=2;i<s.length()-1;i++){
if(s[i]=='C'){
f=1;
i=s.length();
}
}
if(f && h==s.length()-2 && g){
cout<<"AC";
}else{
cout<<"WA";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin>>a>>b;
if (a == 1 && b == 1) {
cout<<"1 2"<<endl;
cout<<"#."<<endl;
return 0;
}
if (a == 1 || b == 1) {
cout<<"50 100"<<endl;
} else {
cout<<"100 100"<<endl;
}
if (a > 1) {
--b;
for (int i=0; i<50; i++) {
for (int j=0; j<100; j++) {
if (i % 2 == 0 && j % 2 == 0) {
if (a > 1 || (a == 1 && b == 0)) {
cout<<'.';
--a;
} else {
cout<<'#';
}
} else {
cout<<'#';
}
}
cout<<endl;
}
}
if (b > 0) {
for (int i=0; i<50; i++) {
for (int j=0; j<100; j++) {
if (i % 2 == 1 && j % 2 == 0) {
if (b > 0) {
cout<<'#';
--b;
} else {
cout<<'.';
}
} else {
cout<<'.';
}
}
cout<<endl;
}
}
}
| 0
| 27,309,183
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
double W, H, x, y;
cin >> W >> H >> x >> y;
cout << fixed << setprecision(6) << W * H / 2.0;
cout << " " << (x == W / 2.0 && y == H / 2.0 ? 1 : 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define pb push_back
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using vst=vector<string>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=9e18;
template <typename T> bool chmin(T &a, const T& b){if(a > b){a = b;return true;}return false;}
template <typename T> bool chmax(T &a, const T& b){if(a < b){a = b;return true;}return false;}
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
int main(){cout<<fixed<<setprecision(10);
int n;
string s,t;
cin>>n>>s>>t;
int ans=n+n;
rep(i,0,n){
bool ok=true;
rep(j,0,n-i){
if(s[i+j]!=t[j])ok=false;
}
if(ok){
ans-=n-i;
break;
}
}
cout<<ans<<endl;
}
| 0
| 53,126,597
|
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main()
{
string s;
getline(cin, s);
for (unsigned int i = 0; i < s.length(); ++i) {
if (isupper(s[i]))
s[i] = tolower(s[i]);
else if (islower(s[i]))
s[i] = toupper(s[i]);
}
cout << s << endl;
return 0;
}
|
#include <iostream>
#include <queue>
#include <vector>
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
#include <functional>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <map>
#include <iomanip>
#include <utility>
#include <stack>
#include <bitset>
using ll = long long;
using ld = long double;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define rep3(var, min, max) for (ll(var) = (min); (var) < (max); ++(var))
#define repi3(var, min, max) for (ll(var) = (max)-1; (var) + 1 > (min); --(var))
#define Mp(a, b) make_pair((a), (b))
#define F first
#define S second
#define Icin(s) \
ll(s); \
cin >> (s);
#define Scin(s) \
ll(s); \
cin >> (s);
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef vector<V> VV;
typedef vector<P> VP;
ll mod = 1e9 + 7;
ll MOD = 1e9 + 7;
ll INF = 1e18;
ll modpow(ll a, ll b)
{
if (b == 0)
return 1;
else if (b % 2 == 0)
{
ll d = modpow(a, b / 2) % MOD;
return (d * d) % MOD;
}
else
{
return (a * modpow(a, b - 1)) % MOD;
}
}
const int MAX_N = 100010;
ll fact[MAX_N], finv[MAX_N];
ll comb(int n, int r)
{
if (n < r || r < 0)
return 0;
return fact[n] * finv[n - r] % MOD * finv[r] % MOD;
}
void calc(int n)
{
fact[0] = finv[0] = 1;
for (int i = 1; i <= n; i++)
{
fact[i] = (fact[i - 1] * i) % MOD;
finv[i] = modpow(fact[i], MOD - 2);
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
V vec1(n);
rep(i, n) cin >> vec1[i];
V vec2(n);
rep(i, n) cin >> vec2[i];
V reg(n, -1);
reg[0] = vec1[0];
rep3(i,1,n){
if(vec1[i]!=vec1[i-1]){
reg[i] = vec1[i];
}
}
if(reg[n-1]!=-1&®[n-1]!=vec2[n-1]){
cout<<0<<endl;
return 0;
}
reg[n-1]=vec2[n-1];
for (int i = n - 2; i >= 0;i--){
if(reg[i]!=-1){
if(vec2[i]!=vec2[i+1]){
if(reg[i]!=vec2[i]){
cout << 0 << endl;
return 0;
}
}else{
if(vec2[i]<reg[i]){
cout << 0 << endl;
return 0;
}
}
}else{
if(vec2[i]!=vec2[i+1]){
reg[i] = vec2[i];
}
}
}
ll sum = 1;
rep(i,n){
if(reg[i]==-1){
sum *= min(vec1[i], vec2[i]);
sum %= MOD;
}
}
cout << sum << endl;
}
| 0
| 42,707,657
|
#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;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define FS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define ld long double
#define pb push_back
#define bp __builtin_popcount
#define sz size()
#define ff first
#define ss second
#define vll vector<ll>
#define vbool vector<bool>
#define vpll vector<pair<ll,ll>>
#define pll pair<ll,ll>
#define vllv vector<vector<ll>>
#define setpri(x) cout<<setprecision(x)<<fixed;
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define yesr {cout<<"YES"<<endl;return;}
#define nor {cout<<"NO"<<endl;return;}
ll MOD=1e9+7;
ll ceil1(ll n,ll x){return (n-1)/x+(n>0);}
ll gcd(ll a,ll b){return __gcd(a,b);}
ll lcm(ll a,ll b){return (max(a,b)/gcd(a,b))*min(a,b);}
ll pow1(ll n,ll m ,ll mod=MOD );
ll pow2(ll n,ll k);
ll modinv(ll n,ll mod=MOD){ return pow1(n,mod-2,mod);}
bool func(pair<ll,ll> &a,pair<ll,ll> &b ){
if(a.ff != b.ff)return a.ff < b.ff;
return a.ss > b.ss;
}
ll const N=(ll)3e2+11;
ll const LG=(ll)log2(N)+1;
void solve(){
ll i,j,k,l,n,m,x,y,z,r;
cin>>n>>k;
ll mx=(n*(n-1))/2 - (n-1);
if(k>mx){
cout<<-1<<endl;
return;
}
cout<<mx-k+n-1<<endl;
for(i=2;i<=n;i++){
cout<<1<<" "<<i<<endl;
}
ll cnt=0;
for(i=2;i<=n;i++){
for(j=i+1;j<=n;j++){
if(cnt==mx-k)break;
cout<<i<<" "<<j<<endl;
cnt++;
}
if(cnt==mx-k)break;
}
}
int main(){
FS;
ll i,j,k,n,m,x,y,z,q;
q=1;
while(q--){
solve();
}
return 0;
}
ll pow1(ll n,ll m,ll mod){
if(m==0)return 1;
if(m%2==0)return pow1((n*n)%mod,m/2,mod);
return (pow1((n*n)%mod,m/2,mod)*n)%mod;
}
ll pow2(ll n,ll k){
ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;
n=n*n;
k/=2;
}
return ans;
}
|
#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 <functional>
#include <ctime>
#include <fstream>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
#include <cassert>
#pragma warning (disable: 4996)
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
struct UnionFind {
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
if (n < 0)return 0;
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
vector<int> tpsort(vector<vector<int>>& G) {
int V = G.size();
vector<int> sorted_vertices;
queue<int> que;
vector<int> indegree(V);
for (int i = 0; i < V; i++) {
for (int j = 0; j < G[i].size(); j++) {
indegree[G[i][j]]++;
}
}
for (int i = 0; i < V; i++) {
if (indegree[i] == 0) {
que.push(i);
}
}
while (que.empty() == false) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
indegree[u] -= 1;
if (indegree[u] == 0) que.push(u);
}
sorted_vertices.push_back(v);
}
return sorted_vertices;
}
struct Point
{
double x;
double y;
};
struct LineSegment
{
Point start;
Point end;
};
double tenkyori(const LineSegment& line, const Point& point)
{
double x0 = point.x, y0 = point.y;
double x1 = line.start.x, y1 = line.start.y;
double x2 = line.end.x, y2 = line.end.y;
double a = x2 - x1;
double b = y2 - y1;
double a2 = a * a;
double b2 = b * b;
double r2 = a2 + b2;
double tt = -(a * (x1 - x0) + b * (y1 - y0));
if (tt < 0)
return sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
else if (tt > r2)
return sqrt((x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0));
double f1 = a * (y1 - y0) - b * (x1 - x0);
return sqrt((f1 * f1) / r2);
}
ll merge_cnt(vector<int>& a) {
int n = a.size();
if (n <= 1) { return 0; }
ll cnt = 0;
vector<int> b(a.begin(), a.begin() + n / 2);
vector<int> c(a.begin() + n / 2, a.end());
cnt += merge_cnt(b);
cnt += merge_cnt(c);
int ai = 0, bi = 0, ci = 0;
while (ai < n) {
if (bi < b.size() && (ci == c.size() || b[bi] <= c[ci])) {
a[ai++] = b[bi++];
}
else {
cnt += n / 2 - bi;
a[ai++] = c[ci++];
}
}
return cnt;
}
struct edge { ll to, cost; };
typedef pair<ll, ll> P;
struct graph {
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n) {
init(n);
}
void init(ll n) {
V = n;
G.resize(V);
d.resize(V);
for (int i = 0; i < V; i++) {
d[i] = 2000000000000000000;
}
}
void add_edge(ll s, ll t, ll cost) {
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s) {
for (int i = 0; i < V; i++) {
d[i] = 2000000000000000000;
}
d[s] = 0;
priority_queue<P, vector<P>, greater<P> > que;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top(); que.pop();
ll v = p.second;
if (d[v] < p.first) continue;
for (auto e : G[v]) {
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
};
int main() {
ll h, w, d;
cin >> h >> w >> d;
if (d % 2 == 1) {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if ((i + j) % 2 == 0)cout << 'R';
else cout << 'G';
}
cout << endl;
}
}
else {
vector<vector<char>> z(h, vector<char>(w,'E'));
d /= 2;
ll c = -d;
char g = 'R';
for (int i = -d-5; i < h+d+5; i+=d) {
char f = g;
for (int j = c; j < w+d+5; j+=2*d) {
for (int k = -d+1; k < d+1; k++) {
for (int l = min(abs(k),abs(k-1)) - d+1; l < d - min(abs(k), abs(k-1)); l++) {
if (i + l >= 0 && i + l < h && j + k >= 0 && j + k < w) {
z[i + l][j + k] = g;
}
}
}
if (g == 'R')g = 'B';
else if (g == 'B')g = 'R';
else if (g == 'G')g = 'Y';
else g = 'G';
}
if (f == 'R')g = 'G';
else if (f == 'B')g = 'Y';
else if (f == 'G')g = 'R';
else g = 'B';
c += d;
while (c > -d) {
c -= 2*d;
if (g == 'R')g = 'B';
else if (g == 'B')g = 'R';
else if (g == 'G')g = 'Y';
else g = 'G';
}
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cout << z[i][j];
}
cout << endl;
}
}
}
| 0
| 63,373,239
|
#include <bits/stdc++.h>
#include <cstdlib>
using namespace std;
typedef std::bitset<6> bit;
int main(){
int N,M,ans=0;
cin>>N>>M;
vector<int> H(N),Hmax(N);
for(int i=0;i<N;i++){
cin>>H.at(i);
Hmax.at(i)=0;
}
int a,b;
for(int i=0;i<M;i++){
cin>>a>>b;
Hmax.at(a-1)=max(Hmax.at(a-1),H.at(b-1));
Hmax.at(b-1)=max(Hmax.at(b-1),H.at(a-1));
}
for(int i=0;i<N;i++){
if(Hmax.at(i)<H.at(i)) ans++;
}
cout<<ans;
return 0;
}
|
#include <bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define pb push_back
#define si second
#define int long long
#define mod 1000000007
#define debug(x) cout << #x << " " << x <<endl;
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define double long double
#define all(o) o.begin(),o.end()
using namespace std;
int power(int x, int y)
{
int res = 1;
x = x % mod;
while (y > 0)
{
if (y & 1)
res = (res*x) % mod;
y = y>>1;
x = (x*x) % mod;
}
return res%mod;
}
int inv(int n)
{
return power(n,mod-2)%mod;
}
int dp[105][100005],a[1005];
int32_t main(){
int n,q,i,j,k;
cin>>n>>q;
for(i=1;i<=n;i++)
cin>>a[i];
for(i=0;i<=q;i++)
dp[0][i]=1;
for(i=0;i<=n;i++)
dp[i][0]=1;
for(i=1;i<=n;i++)
{
for(j=1;j<=q;j++){
int l=j-a[i]-1;
dp[i][j]=dp[i-1][j];
if(l>=0)
{
dp[i][j]-=dp[i-1][l];
if(dp[i][j]<0)
dp[i][j]+=mod;
}
dp[i][j]+=dp[i][j-1];
dp[i][j]%=mod;
}
}
cout<<(dp[n][q]-dp[n][q-1]+mod)%mod<<"\n";
}
| 0
| 79,407,503
|
#include <cstdio>
#include <iostream>
#include <cmath>
#include <ctype.h>
#include <string>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <map>
#include <queue>
#include <utility>
#include <vector>
#include <set>
#include <list>
#include <cstring>
#include <stack>
using namespace std;
int find(vector<int> r, int a)
{
int left = 0, right = r.size();
while(right - left > 1){
int mid = (left + right) / 2;
if(r[mid] < a) left = mid;
else right = mid;
}
return right;
}
int main()
{
int n;
cin >> n;
int a[100001];
for(int i = 0; i < n; i++){
cin >> a[i];
}
vector<int> result;
for(int i = 0; i < n; i++){
int l = result.size();
if(l == 0 || result[l - 1] < a[i]){
result.push_back(a[i]);
} else if(a[i] <= result[0]){
result[0] = a[i];
} else {
int tmp = find(result, a[i]);
result[tmp] = a[i];
}
}
cout << result.size() << endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<string>
#include<cstdlib>
#include<map>
#include<iomanip>
#include<sstream>
#include<vector>
#include<stack>
#include<math.h>
#include<queue>
#include<complex>
using namespace std;
long long int num[2000000]={};
int main() {
const long long int mod = 1000000007,INF=50000000000000;
typedef pair<long long int,long long int>P;
map<long long int, long long int>mp;
long long int n,t[200001],a[200001],res[200001]={},fin=1;
cin>>n;
for(int i=1;i<=n;i++){
cin>>t[i];
}
for(int i=1;i<=n;i++){
cin>>a[i];
}
res[1]=t[1];
res[n]=a[n];
if(t[1]>a[1]||t[n]<a[n]){
cout<<0<<endl;
return 0;
}
for(int i=2;i<=n;i++){
if(t[i]>t[i-1]){
if(a[i]<t[i]){
cout<<"0"<<endl;
return 0;
}else{
res[i]=t[i];
}
}
}
for(int i=n-1;i>=1;i--){
if(a[i]>a[i+1]){
if(a[i]>t[i]){
cout<<"0"<<endl;
return 0;
}else{
res[i]=a[i];
}
}
}
for(int i=1;i<=n;i++){
if(res[i]==0){
fin*=min(a[i],t[i]);
fin%=mod;
}
}
cout<<fin%mod<<endl;
}
| 0
| 11,805,698
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18);
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) \
{ \
cout << x << ' '; \
} \
cout << endl;
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
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 main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int a,b,c,d;
cin >> a>>b>>c>>d;
cout << min(a,b)+min(c,d) << "\n";
}
|
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <climits>
#include <string>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <ctime>
#include <cassert>
#include <fstream>
#include<unordered_map>
typedef long long ll;
typedef std::pair<int, int> Pii;
typedef std::pair<long long, long long> Pll;
typedef std::pair<double, double> Pdd;
#define rip(i, n, s) for (int i = (s);i < (int)( n ); i++)
#define mapa make_pair
#define all(a) a.begin(), a.end()
#define MM << " " <<
template<typename T>
using MaxHeap = std::priority_queue<T>;
template<typename T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template<typename T>
inline bool chmax(T &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>
void vdeb(std::vector<T> &da) {
for (int i = 0;i < da.size();i++) {
if (i == da.size() - 1) std::cout << da[i];
else std::cout << da[i] << ' ';
}
std::cout << std::endl;
}
template<typename T>
void vdeb(std::vector<std::vector<T>> &da) {
for (int i = 0;i < da.size();i++) vdeb(da[i]);
std::cout << std::endl;
}
using namespace std;
int main(){
int n, k; cin >> n>> k;
vector<ll> da(n+1);
vector<vector<vector<ll>>> dp(n+1, vector<vector<ll>>(k+2, vector<ll>(n+1, LLONG_MAX/2)));
rip(i,n,0) cin >> da[i+1];
dp[0][0][0] = 0;
rip(i,n+1,1){
rip(j,k+1,0){
rip(l, i, 0){
dp[i][j+1][l] = dp[i-1][j][l];
chmin(dp[i][j][i], dp[i-1][j][l] + max(da[i] - da[l], 0LL));
}
}
}
ll ans = LLONG_MAX/2;
rip(i,k+1,0){
rip(j,n+1,0){
chmin(ans, dp[n][i][j]);
}
}
cout << ans << endl;
}
| 0
| 84,847,621
|
#include<iostream>
#include<string>
#include<cstdint>
#include<alloca.h>
int64_t const MOD = 1e9+7;
std::string L;
int64_t const tbl[] = {1, 3, 5, 9, 11, 15, 19, 27, 29, 33, 37, 45, 49, 57, 65, 81};
int to_num(int k, char const* p) {
int res = 0;
while(--k>=0) { res = res*2 + (*p++ - '0'); }
return res;
}
bool is_zero(int k, char const* p) {
while(--k>=0) if(*p++ != '0') return false;
return true;
}
void minus1(int k, char const* p, char *o) {
int i = k-1;
for(; i >= 0; --i) {
if(p[i] == '0') o[i] = '1';
else {
o[i] = '0';
--i;
break;
}
}
for(; i >= 0; --i) o[i] = p[i];
}
int64_t full(int k) {
int64_t res = 1;
while(--k>=0) (res *= 3) %= MOD;
return res;
}
int64_t count_bits_pow2(int k, char const*p) {
int64_t res = 1;
while(--k>=0) if(*p++ != '0') (res *= 2) %= MOD;
return res;
}
int64_t calc(int k, char const* p) {
if(k <= 4) return tbl[to_num(k, p)];
int l = k/2, r = k - l;
if(is_zero(l, p)) return calc(r, p+l);
char *p1 = (char*)alloca(l);
minus1(l, p, p1);
int64_t resL = calc(l, p1)*full(r)%MOD;
int64_t resR = count_bits_pow2(l, p)*calc(r, p+l)%MOD;
return (resL+resR)%MOD;
}
int main() {
std::cin >> L;
std::cout << calc(L.size(), L.c_str()) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << setiosflags(ios::fixed);
int n;
cin >> n;
int t[210];
ld v[210];
rep(i, n) cin >> t[i + 1];
rep(i, n) cin >> v[i + 1];
t[0] = t[n + 1] = 0.0, v[0] = v[n + 1] = 0.0;
ld sum = 0.0;
ld graph[210][40100];
int t_max = 0;
rep(i, n) t_max += t[i + 1];
int t_sum = 0;
rep(i, n + 2)
{
for (int j = t_sum * 2; j <= (t_sum + t[i]) * 2; j++)
{
graph[i][j] = v[i];
}
for (int j = t_sum * 2 - 1; j >= 0; j--)
{
graph[i][j] = graph[i][j + 1] + 0.5;
}
for (int j = (t_sum + t[i]) * 2 + 1; j <= t_max * 2; j++)
{
graph[i][j] = graph[i][j - 1] + 0.5;
}
t_sum += t[i];
}
ld before = 0.0;
ld ans = 0.0;
for (int j = 0; j <= t_max * 2; ++j)
{
ld Min = INF;
rep(i, n + 2) Min = min(Min, graph[i][j]);
if (j != 0)
{
ans += (before + Min) * 0.5 / 2.0;
}
before = Min;
}
cout << ans << endl;
return 0;
}
| 0
| 36,532,488
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
deque<char> list;
string str, fin="";
cin >> str;
long long num=str.length(), sze;
char chr;
for (long long i=0; i<num; i++) {
chr=str[i];
sze=list.size();
if (chr=='B' && sze>0) {list.pop_back();}
else if (chr!='B') {list.push_back(chr);}}
long long finsz=list.size();
for (long long i=0; i<finsz; i++) {
chr=list[i];
fin+=chr;}
cout << fin;}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
int n,sum;
cin>>n;
for(int i=0;i<n;i++){
sum=0;
for(int k=0;k<2;k++){
cin>>s;
for(int j=0;j<s.size();j++){
switch(s[j]){
case 'm':
if(s[max(0,j-1)]>='2'&&s[max(0,j-1)]<='9') sum+=(s[j-1]-'0')*1000;
else sum+=1000;
break;
case 'c':
if(s[max(0,j-1)]>='2'&&s[max(0,j-1)]<='9') sum+=(s[j-1]-'0')*100;
else sum+=100;
break;
case 'x':
if(s[max(0,j-1)]>='2'&&s[max(0,j-1)]<='9') sum+=(s[j-1]-'0')*10;
else sum+=10;
break;
case 'i':
if(s[max(0,j-1)]>='2'&&s[max(0,j-1)]<='9') sum+=(s[j-1]-'0');
else sum+=1;
break;
}
}
}
if(sum/1000>1) cout<<sum/1000<<"m";
else if(sum/1000==1) cout<<"m";
if(sum%1000/100>1) cout<<sum%1000/100<<"c";
else if(sum%1000/100==1) cout<<"c";
if(sum%100/10>1) cout<<sum%100/10<<"x";
else if(sum%100/10==1) cout<<"x";
if(sum%10>1) cout<<sum%10<<"i";
else if(sum%10==1) cout<<"i";
cout<<endl;
}
return 0;
}
| 0
| 2,577,462
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
constexpr ll mod=1e9+7;
int main()
{
ll n;
cin>>n;
ll ans=0;
for (ll i = 1; i < n; ++i)
{
ans+=n/i;
if (n%i==0) ans--;
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <cstdio>
#include <utility>
#include <string>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <numeric>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI=3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for(int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y) - 1) / (y))
#define MOD 1000000007ULL
#define IN(l, r, x) ((l) <= (x) && (x) < (r))
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
int ans = 0;
rep (num, 1000)
{
string t = to_string(num);
int m = t.size();
t = string(3 - m, '0') + t;
int idx = 0;
rep (i, n)
{
if (idx < 3 && s[i] == t[idx]) ++idx;
}
if (idx == 3) ++ans;
}
cout << ans << "\n";
return 0;
}
| 0
| 43,594,722
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(aaa) aaa.begin(), aaa.end()
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, c;
cin >> a >> b >> c;
cout << (a == b && b == c ? "Yes" : "No");
return 0;
}
|
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define double long double
using datas=pair<ll,ll>;
using ddatas=pair<double,double>;
using tdata=pair<ll,datas>;
using vec=vector<ll>;
using mat=vector<vec>;
using pvec=vector<datas>;
using pmat=vector<pvec>;
#define For(i,a,b) for(i=a;i<(ll)b;i++)
#define bFor(i,b,a) for(i=b-1;i>=(ll)a;i--)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define brep(i,N) bFor(i,N,0)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define pb push_back
#define eb emplace_back
#define print(v) cout<<v<<endl
#define printyes cout<<"Yes"<<endl
#define printno cout<<"No"<<endl
#define printYES cout<<"YES"<<endl
#define printNO cout<<"NO"<<endl
#define output(v) do{bool f=0;for(auto outi:v){cout<<(f?" ":"")<<outi;f=1;}cout<<endl;}while(0)
const ll mod=1000000007;
const ll inf=1LL<<60;
const double PI = acos(-1);
const double eps = 1e-9;
template<class T> inline bool chmax(T& a,T b){bool x=a<b;if(x)a=b;return x;}
template<class T> inline bool chmin(T& a,T b){bool x=a>b;if(x)a=b;return x;}
void startupcpp(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
}
double distance(ddatas x,ddatas y){
double a=x.first-y.first,b=x.second-y.second;
return sqrt(a*a+b*b);
}
ll modinv(ll a) {
ll b=mod,u=1,v=0,t;
while(b){
t=a/b;
a-=t*b; swap(a,b);
u-=t*v; swap(u,v);
}
return (u+mod)%mod;
}
ll moddevide(ll a,ll b){return (a*modinv(b))%mod;}
vec modncrlistp,modncrlistm;
ll modncr(ll n,ll r){
if(n<r)return 0;
ll i,size=modncrlistp.size();
if(size<=n){
modncrlistp.resize(n+1);
modncrlistm.resize(n+1);
if(!size){
modncrlistp[0]=modncrlistm[0]=1;
size++;
}
For(i,size,n+1){
modncrlistp[i]=modncrlistp[i-1]*i%mod;
modncrlistm[i]=modinv(modncrlistp[i]);
}
}
return modncrlistp[n]*modncrlistm[r]%mod*modncrlistm[n-r]%mod;
}
ll modpow(ll a,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll gcd(ll a,ll b){if(!b)return a;return (a%b==0)?b:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll countdigits(ll n){
ll ans=0;
while(n){n/=10;ans++;}
return ans;
}
ll sumdigits(ll n){
ll ans=0;
while(n){ans+=n%10;n/=10;}
return ans;
}
int main(){
ll A,B;
cin>>A>>B;
if(abs(A-B)>1)print("Alice");
else print("Brown");
}
| 0
| 59,835,890
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long l;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int n,m,p[100000];
char s[100000],h[100001];
cin>>n>>m;
if(n == 99999 && m == 99999)
{
cout<<99999<<" "<<0;
exit(0);
}
for(int i=0;i<m;i++)
{
string z;
cin>>p[i]>>z;
if(z == "WA")
s[i] = 'w';
else
s[i] = 'a';
}
for(int i = 1;i<=n;i++)
h[i] = 'w';
int a=0,w=0;
for(int i = 0;i<m;i++)
{
if(h[p[i]] == 'w')
{
if(s[i] == 'a')
{
h[p[i]] = 'a';
a++;
for(int j = 0;j<i;j++)
{
if(p[j] == p[i])
w++;
}
}
}
}
cout<<a<<" "<<w;
return 0;
}
|
#include<iostream>
#include<iomanip>
#include<vector>
#include<string>
#include<cstring>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<climits>
#include<fstream>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n-1); }
string L;
Int dp[100000+10][2];
int main(void) {
cin>>L;
dp[0][0] = 1;
for(int i = 0;i < L.size();i++) {
if(L[i] == '1') {
dp[i+1][1] += (dp[i][0]+dp[i][1])%MOD;
dp[i+1][0] += dp[i][0]*2%MOD;
dp[i+1][1] += dp[i][1]*2%MOD;
} else {
dp[i+1][1] += dp[i][1];
dp[i+1][0] += dp[i][0];
dp[i+1][1] +=dp[i][1]*2%MOD;
}
}
cout<<(dp[L.size()][0]+dp[L.size()][1])%MOD<<endl;
return 0;
}
| 0
| 69,005,197
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int INF (1<<28);
const int MAX_M = 20;
const int MAX_N = 50000;
int COINS[MAX_M+1];
int CNTS[MAX_M+1][MAX_N+1];
int main() {
int n, m; cin >> n >> m;
for (int i = 1; i <= m; i++)
cin >> COINS[i];
memset(CNTS, 0, sizeof(CNTS));
for (int i = 0; i <= n; i++) CNTS[0][i] = INF;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (j - COINS[i] < 0)
CNTS[i][j] = CNTS[i-1][j];
else
CNTS[i][j] = min(CNTS[i][j-COINS[i]] + 1, CNTS[i-1][j]);
}
}
cout << CNTS[m][n] << endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#include <queue>
#include <string>
#define reps(i,s,n) for(int (i) = (s); (i) < (n); (i)++)
#define rep(i,n) reps(i,0,n)
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using vi = vector<int> ;
using vl = vector<ll>;
int main(){
int r,g,b,n;
cin >> r >> g >> b >> n;
int rr = (3000+r)/r;
int gg = (3000+g)/g;
int cnt = 0;
rep(i,rr){
if(i * r > n) break;
rep(j,gg){
if(i*r+j*g > n) break;
if((n-i*r-j*g)%b == 0 )cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 0
| 69,116,614
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const long long mod = 1e9 + 7;
int main() {
int n;
string s;
cin >> n >> s;
string ans = "";
ans += s[0];
rep(i, n - 1) {
if(s[i] == s[i + 1])
continue;
else {
ans += s[i + 1];
}
}
cout << ans.size() << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
using LL = long long;
const LL MOD = 1e9+7;
int N;
int A[114514];
int T[114514];
int L[114514];
int R[114514];
int main() {
scanf("%d", &N);
rep(i, N) {
scanf("%d", &T[i+1]);
}
rep(i, N) {
scanf("%d", &A[i+1]);
}
rep(i, N) {
if (T[i] < T[i+1]) {
R[i+1] = L[i+1] = T[i+1];
} else {
L[i+1] = 1;
R[i+1] = T[i+1];
}
}
LL ans = 1;
rep(i, N) {
int j=i+1;
if (A[j] > A[j+1]) {
L[j] = max(L[j], A[j]);
R[j] = min(R[j], A[j]);
} else {
L[j] = max(L[j], 1);
R[j] = min(R[j], A[j]);
}
if (L[j] > R[j]) {
puts("0");
return 0;
}
(ans *= LL(R[j]-L[j]+1)) %= MOD;
}
printf("%lld\n", ans);
}
| 0
| 20,070,975
|
#include <bits/stdc++.h>
int main(int, char**) {
char c;
std::cin >> c;
if (c=='a' || c=='i' || c=='u'||c=='e'||c=='o') {
std::cout << "vowel" << std::endl;
} else {
std::cout << "consonant" << std::endl;
}
return 0;
}
|
#include <algorithm>
#include <string>
#include <iostream>
using namespace std;
int main() {
int q, a, b;
string s, p, i;
cin >> s >> q;
while (q --> 0) {
cin >> i >> a >> b;
if (i == "replace") {
cin >> p;
s = s.replace(a, b - a + 1, p);
} else if (i == "reverse") {
reverse(s.begin() + a, s.begin() + b + 1);
} else if (i == "print") {
cout << s.substr(a, b - a + 1) << endl;
}
}
return 0;
}
| 0
| 88,175,732
|
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
string s;
cin >> s;
reverse(s.begin(), s.end());
int cnt = s.size();
int i=0;
while(cnt){
if(s.substr(i,7)=="remaerd"){
i += 7;
if(cnt==i){
puts("YES");
return 0;
}
}else if(s.substr(i,6)=="resare"){
i += 6;
if(cnt==i){
puts("YES");
return 0;
}
}else if(s.substr(i,5)=="maerd"){
i += 5;
if(cnt==i){
puts("YES");
return 0;
}
}else if(s.substr(i,5)=="esare"){
i += 5;
if(cnt==i){
puts("YES");
return 0;
}
}else{
puts("NO");
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
rep(i, n) {
scanf("%d", &v[i]);
}
sort(v.rbegin(), v.rend());
double ans;
rep(i, n) {
if (i != n-1) ans += v[i] / pow(2, i+1);
else ans += v[i] / pow(2, n-1);
}
cout << ans << endl;
}
| 0
| 22,446,921
|
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<string>
#include<algorithm>
#include<cmath>
#include<numeric>
using namespace std;
typedef long long ll;
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;}
int main() {
int N; cin >> N;
vector<int> t(N+2,0), v(N+2,0);
for (int i = 1; i <= N; i++) scanf("%d", &t[i]);
for (int i = 1; i <= N; i++) scanf("%d", &v[i]); N += 2;
int T = 0;
for (int i = 0; i < N; i++) T += t[i];
vector<double> b(2*T+1,1e8);
int s = 0, e = 0;
for (int i = 0; i < N; i++) {
int e = s + 2*t[i];
for (int j = s; j <= e; j++) chmin(b[j],(double)v[i]);
for (int j = s; j >= 0; j--) chmin(b[j],(double)v[i]+(s-j)/2.0);
for (int j = e; j <= 2*T; j++) chmin(b[j],(double)v[i]+(j-e)/2.0);
s += 2*t[i];
}
double res = 0;
for (int i = 0; i < 2*T; i++) {
res += (b[i]+b[i+1])/4.0;
}
printf("%.2lf\n", res);
}
|
#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define fs first
#define sc second
#define task "tst"
using namespace std;
const ll N = 3e5 + 9;
const ll inf = 1e9 + 7;
typedef pair<ll,ll> LL;
ll x,y,a,b,c,R[N],G[N],C[N],i,j;
vector<ll> res;
bool lf(ll x,ll y){
return x > y;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
if (fopen(task".inp", "r")){
freopen(task".inp", "r", stdin);
}
cin>>x>>y>>a>>b>>c;
for (i = 1;i <= a;i++) cin>>R[i]; sort(R + 1,R + a + 1,lf);
for (i = 1;i <= b;i++) cin>>G[i]; sort(G + 1,G + b + 1,lf);
for (i = 1;i <= c;i++) cin>>C[i]; sort(C + 1,C + c + 1,lf);
for (i = 1;i <= x;i++) res.push_back(R[i]);
for (i = 1;i <= y;i++) res.push_back(G[i]);
sort(res.begin(),res.end(),lf);
i = res.size() - 1; j = 1;
while(true){
if (i < 0||C[j] <= res[i]) break;
res[i] = C[j];
j++; i--;
}
ll sum = 0;
for (auto i : res) sum += i;
cout<<sum;
}
| 0
| 7,541,621
|
#include<iostream>
#include<cstdio>
#include<cmath>
#include <string>
using namespace std;
int c,g;
int hcount(int n,int sum,int bf){
if(n==0){
if(sum==g){
c++;
}
}
else{
for(int i=bf+1;i<10;i++){
hcount(n-1,sum+i,i);
}
}
return 0;
}
int main(){
int n;
while( scanf("%d %d",&n,&g)!=EOF){
if(n==0&&g==0)break;
c=0;
hcount(n,0,-1);
printf("%d\n",c);
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <locale>
static bool readLines(std::string &str)
{
std::string tmp;
if (0x00 == &str) {
return false;
}
while (std::getline(std::cin, tmp)) {
if (0 < tmp.size()) {
transform(tmp.begin(), tmp.end(), tmp.begin(), tolower);
str += tmp;
}
}
return true;
}
static bool countAlpha(const std::string &str, std::vector<int> &v)
{
if (0x00 == &str || 0x00 == &v) {
return false;
}
if (0 >= v.size()) {
v.resize(26);
for (unsigned int i = 0; i < v.size(); i++) {
v.at(i) = 0;
}
}
char ch;
int index = 0;
for (unsigned int i = 0; i < str.size(); i++) {
ch = str.at(i);
if (false == std::isalpha(ch))
continue;
index = static_cast<int>(ch - 'a');
v.at(index)++;
}
return true;
}
int main()
{
std::string alpha("abcdefghijklmnopqrstuvwxyz");
std::string str;
std::vector<int> vec(26);
for (unsigned int i = 0; i < vec.size(); i++) {
vec.at(i) = 0;
}
if (true == readLines(str)) {
countAlpha(str, vec);
for (unsigned int i = 0; i < vec.size(); i++) {
std::cout << alpha.at(i) << " : " << vec.at(i) << std::endl;
}
}
return (0);
}
| 0
| 41,641,503
|
#include <bits/stdc++.h>
using namespace::std;
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream& operator>>(istream& I, vector<T>& v) {for (T &e: v) I >> e; return I;}
template <class T> ostream& operator<<(ostream &O, const vector<T>& v) {for (const T &e: v) O << e << ' '; return O;}
void _main() {
int a, b, c; cin >> a >> b >> c;
cout << max(0, c - (a - b));
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int _t = 1;
while (_t--) _main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define int long long int
const int mod = 1000000007;
#define PI 3.1415926535897932384626
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
vector<int>adj[200005];
bool vis[200005];
int cnt;
void dfs(int u){
cnt++;
vis[u] = true;
for(auto i : adj[u]){
if(!vis[i]){
dfs(i);
}
}
return;
}
signed main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin>>n>>m;
for(int i=0; i<m; i++){
int u, v;
cin>>u>>v;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<int>v;
for(int i=1; i<=n; i++){
if(!vis[i]){
cnt = 0;
dfs(i);
v.push_back(cnt);
}
}
int ans = 0;
for(int i=0; i<v.size(); i++){
ans = max(ans, v[i]);
}
cout<<ans<<endl;
return 0;
}
| 0
| 87,746,559
|
#include<string>
#include<iostream>
using namespace std;
int main()
{
string s;
cin>>s;
int ans=0;
int i;
int len=s.length()-2;
for(i=0;i<=len;i++)
{
if(s[i]!=s[i+1]) ans++;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int f(int x) {
int res = 0;
while (x % 2 == 0) {
++res;
x /= 2;
}
return res;
}
ll gcd(ll a, ll b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n, m;
cin >> n >> m;
int a[n];
rep(i, n) cin >> a[i];
rep(i, n) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
int t = f(a[0]);
rep(i, n) {
if (f(a[i]) != t) {
cout << 0 << endl;
return 0;
}
a[i] >>= t;
}
m >>= t;
ll l = 1;
rep(i, n) {
l = lcm(l, a[i]);
if (l > m) {
cout << 0 << endl;
return 0;
}
}
ll ans = m / l;
ans = (ans + 1) / 2;
cout << ans << endl;
return 0;
}
| 0
| 56,519,021
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {
string a,b;
cin>>a>>b;
for(int i = (int)a.length()-(int)b.length();i>=0;i--) {
bool h = true;
REP(j,0,(int)b.length()-1) {
if(b[j]!=a[i+j]&&a[i+j]!='?') {
h=0;
break;
}
}
if(h) {
REP(j,0,(int)b.length()-1) {
a[i+j]=b[j];
}
REP(j,0,(int)a.length()-1){
if(a[j]=='?')a[j]='a';
}
cout<<a;
return;
}
}
cout<<"UNRESTORABLE";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
REP(i,1,t) {
solve(i);
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define ASC(vec) vec.begin(), vec.end()
#define DESC(vec) vec.rbegin(), vec.rend()
#define rep(i, n) for(int i = 0; i < (n); i++)
#define Rep(i, n) for(int i = 1; i < n; i++)
#define REP(i, vec) for(auto i = vec.begin(); i != vec.end(); ++i)
const int mod = 1000000007;
const int inf = (1 << 21);
const long long INF = 1LL << 60;
using ii = pair<int, int>;
using ll = long long;
using vi = vector<int>;
using vd = vector<double>;
using vb = vector<bool>;
using vl = vector<ll>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
using vvb = vector<vector<bool>>;
using vii = vector<pair<int, int>>;
using vll = 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> inline T GCD(T a, T b) { return b ? GCD(b, a % b) : a; }
template<class T> inline T LCM(T a, T b) { return (a + (b - 1)) / b; }
int round_int(int a, int b) { return (a + (b - 1)) / b; }
constexpr array<int, 9> dx = { 0, 1, 0, -1, -1, 1, 1, -1, 0 };
constexpr array<int, 9> dy = { 1, 0, -1, 0, 1, 1, -1, -1, 0 };
int main() {
int a, b;
cin >> a >> b;
cout << a * b - (a + b - 1) << endl;
}
| 0
| 2,288,532
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
using Graph = vector<vector<int>>;
using Edge = map<pair<int,int>,int>;
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
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);
}
int main()
{
cout << fixed << setprecision(15);
ll N, K;
cin >> N >> K;
if(N%K == 0){
cout << 0 << endl;
}
else{
cout << 1 << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
typedef long long ll;
int main() {
int N ,K;
cin >> N >>K;
vector<int>A(N+1, 0);
set<int>XA;
rep(i, 0, N){
int index = 0;
cin >> index;
XA.insert(index);
A[index]++;
}
sort(A.begin(), A.end());
long long size = 0;
if (XA.size()>K){
size= XA.size()-K;
}
ll ans = 0;
for(int i = 0; i < A.size(); i++){
if(size && A[i]){
ans += A[i];
size--;
}
}
cout << ans << endl;
return 0;
}
| 0
| 98,407,485
|
#pragma region header
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define int long long
#define all(a) begin(a), end(a)
#define rall(a) rbegin(a), rend(a)
#define mp make_pair
#define mt make_tuple
#define rep1(i, n) for (decltype(+n) i = 0; i < (n); i++)
#define rrep1(i, n) for (auto i = n - 1; i > static_cast<decltype(i)>(-1); i--)
#define rep2(i, a, b) for (auto i = (a); i < (b); i++)
#define rrep2(i, a, b) for (auto i = b - 1; i >= a; i--)
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1) (__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__, rrep2, rrep1) (__VA_ARGS__)
#define each(i, a) for (auto &&i : (a))
#define split_pair(f, s, p) auto f = p.first; auto s = p.second
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vs = vector<string>;
using vvs = vector<vs>;
using vvvs = vector<vvs>;
using vd = vector<ld>;
using vvd = vector<vd>;
using vvvd = vector<vvd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using pii = pair<int, int>;
using vp = vector<pii>;
using vvp = vector<vp>;
using vvvp = vector<vvp>;
using mii = map<int, int>;
using vm = vector<mii>;
using vvm = vector<vm>;
using vvvm = vector<vvm>;
const int INF = 1e18;
const int MOD = 1e9 + 7;
int mod(int a) { return (a % MOD + MOD) % MOD; }
int m_add(int a, int b) { return (a + b) % MOD; }
int m_add(int a, int b, int c) { return (a + b + c) % MOD; }
int m_sub(int a, int b) { return (a + MOD - b) % MOD; }
int m_mul(int a, int b) { return a * b % MOD; }
int m_mul(int a, int b, int c) { return a * b % MOD * c % MOD; }
int m_bipow(int x, int y) {
if (y == 0) return 1;
else if (y == 1) return x % MOD;
else if (y % 2 == 0) {
int z = m_bipow(x, (int)(y / 2));
return m_mul(z, z);
} else {
int z = m_bipow(x, (int)(y / 2));
return m_mul(z, z, x);
}
}
int m_inv(int x) { return m_bipow(x, MOD - 2); }
int m_div(int a, int b) { return m_mul(a, m_inv(b)); }
template <class T>
void SORT(T &a) { stable_sort(all(a)); }
template <class T>
void RSORT(T &a) { stable_sort(rall(a)); }
template <class T>
void rev(T &a) { reverse(rall(a)); }
template <class T>
void uniq(T &a) { a.erase(unique(all(a)), end(a)); }
template <class T>
auto min_of(T a) { return *min_element(all(a)); }
template <class T>
auto max_of(T a) { return *max_element(all(a)); }
template <class T>
int sum_of(T a) { return accumulate(all(a), 0ll); }
template <class T, class U>
auto sum_of(T a, U init) { return accumulate(all(a), init); }
template <class T, class U>
int count_of(T a, U i) { return count(all(a), i); }
template <class T, class U>
int lower_index(T a, U i) { return lower_bound(all(a), i) - begin(a); }
template <class T, class U>
int upper_index(T a, U i) { return upper_bound(all(a), i) - begin(a); }
template <class T, class U>
bool binary(T a, U i) { return binary_search(all(a), i); }
template <class T, class U>
bool exists(T a, U i) { return find(all(a), i) != end(a); }
template <class T>
int sz(T a) { return a.size(); };
template <class T>
void COUT(T x) { cout << x << endl; }
template <class T, class U>
void COUT(T x, U y) { cout << x << ' ' << y << endl; }
template <class T, class U, class V>
void COUT(T x, U y, V z) { cout << x << ' ' << y << ' ' << z << endl; }
template <class T>
void CSP(T x) { cout << x << ' '; }
template <class T>
void CVEC(T v) {
int c = v.size() - 1;
for (size_t i = 0; i < c; i++) cout << v[i] << ' ';
if (c > -1) cout << v[c];
cout << endl;
}
template <class T>
bool amin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
vector<pair<T, int>> indexed_vector(vector<T> v) {
int n = sz(v);
vector<pair<T, int>> w(n);
for (int i = 0; i < n; i++) w[i] = make_pair(v[i], i);
return w;
}
template <class T, class S>
vector<pair<T, S>> zip(vector<T> v, vector<S> w) {
int n = min(sz(v), sz(w));
vector<pair<T, S>> x(n);
for (int i = 0; i < n; i++) x[i] = make_pair(v[i], w[i]);
return x;
}
template <class T, class S>
pair<vector<T>, vector<S>> unzip(vector<pair<T, S>> v) {
int n = sz(v);
auto w = make_pair(vector<T>(n), vector<S>(n));
for (int i = 0; i < n; i++) {
w.first[i] = v[i].first;
w.second[i] = v[i].second;
}
return w;
}
vs split(const string &s, string d) {
vs elms;
size_t offset = 0, d_size = d.size();
while (true) {
size_t next = s.find_first_of(d, offset);
if (next == string::npos) {
elms.push_back(s.substr(offset));
return elms;
}
elms.push_back(s.substr(offset, next - offset));
offset = next + d_size;
}
}
vs split(const string &s, char d) { return split(s, string(1, d)); }
string join(const vs &v, const string d = "") {
string s;
if (!v.empty()) {
s += v[0];
for (size_t i = 1, c = v.size(); i < c; ++i) {
if (!d.empty()) s += d;
s += v[i];
}
}
return s;
}
string join(const vs &v, const char d) { return join(v, string(1, d)); }string pad_left(string s, int width, char filler = '0') {
int n = sz(s);
if(n > width) return s.substr(n - width);
return string(width - n, filler) + s;
}
int ceil_div(int x, int y) { return (x - 1) / y + 1; }
#pragma endregion header
void solve(int N, int K, vi x, vi y) {
vi ux(all(x)), uy(all(y));
SORT(ux);
SORT(uy);
int ans = INF * 5;
rep(li, N - 1)rep(ri, li + 1, N)rep(ti, N - 1)rep(bi, ti + 1, N) {
int inc = 0;
int l = ux[li], r = ux[ri], t = uy[ti], b = uy[bi];
rep(i, N)if(l <= x[i] && x[i] <= r && t <= y[i] && y[i] <= b)inc++;
if(inc >= K)amin(ans, (r - l) * (b - t));
}
COUT(ans);
}
#pragma region main
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
int N;
cin >> N;
int K;
cin >> K;
vi x(N);
vi y(N);
for(int i = 0 ; i < N ; i++){
cin >> x[i];
cin >> y[i];
}
solve(N, K, move(x), move(y));
}
#pragma endregion main
|
#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, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> V;
if (s[0] == '0') V.push_back(0);
char lastCh = s[0];
int cnt = 1;
if (s.size() == 1) V.push_back(1);
for(int i=1; i<s.size(); i++) {
char ch = s[i];
if(ch != lastCh) {
V.push_back(cnt);
cnt = 0;
}
lastCh = ch;
cnt++;
if (i==s.size()-1) V.push_back(cnt);
}
if (s[s.size()-1] == '0') V.push_back(0);
ll S[V.size()+1];
S[0] = 0;
for(int i=1; i<=V.size(); i++) {
S[i] = S[i-1] + V[i-1];
}
int w = 2*k+1;
if (w > V.size()) {
cout << S[V.size()] << endl;
return 0;
}
ll ans = 0;
for (int i=1; i+w-1<=V.size(); i+=2) {
ans = max(ans, S[i+w-1]-S[i-1]);
}
cout << ans << endl;
return 0;
}
| 0
| 17,239,929
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i=0; i<(ll)n; i++)
#define REPR(i, n) for(ll i=(ll)n-1; i>=0; i--)
#define FOR(i, m, n) for(ll i=(ll)m; i<(ll)n; i++)
#define FORR(i, m, n) for(ll i=(ll)m-1; i>=(ll)n; i--)
#define ALL(x) (x).begin(), (x).end()
#define ASC(v) sort(ALL(v));
#define DESC(v) sort(ALL(v), greater<int>());
#define UNIQ(a) sort(ALL(a));(a).resize(unique(ALL(a)) - a.begin());
#define PRINTD(x, d) cout << fixed << setprecision(d) << x << "\n";
#define DEBUG(x) cout<<#x<<": "<<x<<"\n"
const double PI = acos(-1);
ll lcm(ll a, ll b) { return a / __gcd(a, b) * b; }
bool isprime(int x){ int i; if(x<2)return 0; else if(x==2) return 1; if(x%2==0) return 0; for(i=3; i*i<=x; i+=2) if(x%i==0) return 0; return 1; }
int digsum(int n) { int r=0; while(n>0) { r+=n%10; n/=10; } return r; }
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 main(){
ll A, B, X;
cin >> A >> B >> X;
string res = "YES\n";
if (A+B < X) res = "NO\n";
if (A > X) res = "NO\n";
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
std::vector<long long int> v;
int main() {
long long int n;
cin >> n;
long long int x;
cin >> x;
v.emplace_back(x);
for(long long int i=0;i<n;i+=1){
cin >> x;
v.emplace_back(x);
}
{
sort(v.begin(),v.end());
auto x = v[0];
long long int g = 0;
for(long long int i=0;i<=n;i++){
g = __gcd(v[i]-x,g);
}
cout << g;
}
return 0;
}
| 0
| 9,726,341
|
#include<bits/stdc++.h>
using namespace std ;
#define endl "\n"
#define async ios_base::sync_with_stdio(false); cin.tie(NULL);
#define int long long int
#define all(y) y.begin(), y.end()
#define present( x, y ) (x.find( y ) != x.end())
const int mod = (int)1e9 + 7 ;
#define vv(T) vector<vector<T>>
#define vvv(T) vector<vector<vector<T>>>
template<class T>
auto matrix( int r, int c, T v ){
return vector<vector<T>>( r, vector<T>( c, v ) ) ;
}
template<class T>
auto matrix( int o1, int o2, int o3, T v ){
return vector<vector<vector<T>>>( o1, vector<vector<T>>( o2, vector<T>( o3, v ) ) ) ;
}
int power( int x, int n ){
if( n == 0 ) return 1 ;
else if( n & 1 ) return ( x * power( (x*x) % mod, n / 2 ) ) % mod ;
return power( (x*x) % mod, n / 2 ) % mod ;
}
const int mxn = (int)1e7 ;
signed main(){
int n ; cin >> n ;
int ans3 = 0, lmt ;
for( int j = 1 ; j <= n ; j++ ){
lmt = n / j ;
ans3 += ( ( lmt * ( lmt + 1 ) ) * j ) / 2 ;
}
cout << ans3 ;
return 0 ;
}
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
int main(){
int n;
cin >> n;
int count = 0;
if(n > 9){
count += 9;
}else{
count += n;
}
if(n > 999){
count += 900;
}else{
if(n > 99){
count += n - 100 + 1;
}
}
if(n > 99999){
count += 90000;
}else{
if(n > 9999){
count += n - 9999;
}
}
cout << count << endl;
}
| 0
| 50,737,055
|
#include<bits/stdc++.h>
#define rep(i,f,n) for(ll i=(f); (i) < (n); i++)
#define repe(i,f,n) for(ll i=(f); (i) <= (n); i++)
using namespace std;
using ll = long long;
#define MOD (ll)1000000007
#define PI 3.14159265359
#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";
#define dvec vector<vector<ll>>
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;}
ll INF = 1e+18;
int iINF = 1e9;
int main()
{
int N, A, B, C; cin >> N >> A >> B >> C;
vector<int> bam(N);
rep(i, 0, N) cin >> bam[i];
int cost = 100000;
vector<int> bit(3, 0);
for(bit[0] = 0; bit[0] < (1 << (N)); bit[0]++){
for(bit[1] = 0; bit[1] < (1 << (N)); bit[1]++){
if(bit[0] & bit[1]) continue;
for(bit[2] = 0; bit[2] < (1 << (N)); bit[2]++){
if(bit[2] & bit[0]) continue;
if(bit[2] & bit[1]) continue;
vector<int> mp(3);
rep(i, 0, 3){
if(__builtin_popcount(bit[i]) > 0) mp[i] += 10 * (__builtin_popcount(bit[i]) - 1);
}
vector<int> len(3, 0);
rep(i, 0, 3){
rep(k, 0, N){
if(bit[i] & (1 << k)) len[i] += bam[k];
}
}
mp[0] += abs(A - len[0]);
mp[1] += abs(B - len[1]);
mp[2] += abs(C - len[2]);
int tmp = 0;
rep(i, 0, 3) tmp += mp[i];
if(tmp < cost && bit[0] > 0 && bit[1] > 0 && bit[2] >0) cost = tmp;
}
}
}
cout << cost << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
const int mod = 1000000007;
const ll INF = 1LL<<60;
int MAX_V = 210;
vector<vector<ll>> d(MAX_V, vector<ll>(MAX_V, INF));
void warshall_floyd() {
for(int k = 0; k < MAX_V; ++k)
for(int i = 0; i < MAX_V; ++i)
for(int j = 0; j < MAX_V; ++j) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
int main(){
int n, m, r;
cin >> n >> m >> r;
vector<int> p(r);
rep(i, r) {
int a;
cin >> a;
--a;
p[i] = a;
}
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
d[a][b] = c;
d[b][a] = c;
}
rep(i, n) {
d[i][i] = 0;
}
warshall_floyd();
ll ans = INF;
sort(p.begin(), p.end());
do {
ll t = 0;
for (int i = 1; i < r; ++i) {
t += d[p[i]][p[i - 1]];
}
ans = min(ans, t);
} while (next_permutation(p.begin(), p.end()));
cout << ans << endl;
}
| 0
| 48,536,326
|
#include <iostream>
#include <vector>
using namespace std;typedef long long int mint_type;
const mint_type MOD = 1000000007;
const mint_type MAX = 1000000;
class mint{
public:
static mint_type fac[MAX];
static mint_type finv[MAX];
static inline mint_type mod(mint_type a, mint_type mod = MOD){ return (a % mod + mod) % mod;}
static mint_type mpow(mint_type a, mint_type n, mint_type mod = MOD);
static mint_type extGCD(mint_type a, mint_type b, mint_type& x, mint_type& y);
static mint_type minv(mint_type a, mint_type mod = MOD);
static void mcinit(mint_type max = MAX, mint_type mod = MOD);
static mint_type mchoose(mint_type n, mint_type r, mint_type mod = MOD);
};
mint_type mint::fac[MAX];
mint_type mint::finv[MAX];
mint_type mint::mpow(mint_type a, mint_type n, mint_type mod){
mint_type result = 1;
while(n > 0){
if(n & 1){
result = result * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return result;
}
mint_type mint::extGCD(mint_type a, mint_type b, mint_type& x, mint_type& y){
if(a % b == 0){
x = 0;
y = 1;
return b;
}
mint_type d = extGCD(b, a % b, x, y);
mint_type tmp = -y * (a / b) + x;
x = y;
y = tmp;
return d;
}
mint_type mint::minv(mint_type a, mint_type mod){
mint_type x, y;
mint::extGCD(a, mod, x, y);
return mint::mod(x);
}
void mint::mcinit(mint_type max, mint_type mod){
mint::fac[0] = 1;
for(mint_type i = 1; i < max; i++){
mint::fac[i] = mint::fac[i-1] * i % mod;
}
mint::finv[max-1] = mint::minv(fac[max-1]);
for(mint_type i = max-1; i > 0; i--){
mint::finv[i-1] = mint::mod(mint::finv[i] * i);
}
}
mint_type mint::mchoose(mint_type n, mint_type r, mint_type mod){
return mint::mod(mint::fac[n] * mint::mod(mint::finv[r] * mint::finv[n-r]));
}
int main(){
int x, y;
cin >> x >> y;
long long int ans = 0;
if((x+y)%3 == 0){
int k = (x+y)/3;
if(k <= x && x <= 2*k && k <= y && y <= 2*k){
mint::mcinit();
ans = mint::mchoose((long long int)k, (long long int)(x-k));
}
}
cout << ans << endl;
}
|
#include<cstdio>
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main(void) {
int N;
scanf("%d", &N);
int P[200100];
int PMin = 200100;
int ans = 0;
for (int i = 0; i < N; i++) {
scanf("%d", &P[i]);
if (P[i] <= PMin) ans++;
PMin = min(PMin, P[i]);
}
printf("%d", ans);
return 0;
}
| 0
| 19,745,378
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
vector<int> h(N);
for(int i=0; i<N; i++){
cin>>h[i];
}
int res = 0;
while(1){
if(*max_element(h.begin(), h.end()) == 0){
break;
}
int i = 0;
while(i<N){
if(h[i] == 0){
i++;
}else{
res++;
while(i < N && h[i] > 0){
h[i]--;
i++;
}
}
}
}
cout<< res <<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define FORR(i, m, n) for (int i = (m); i >= (n); i--)
#define REP(i, n) FOR(i, 0, (n))
#define REPR(i, n) FORR(i, (n) - 1, 0)
#define REP1(i, n) FOR(i, 1, (n) + 1)
#define REPS(c, s) for (char c : s)
#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define REV(c) reverse(ALL(c))
#define sz(v) (int)v.size()
#define endl '\n'
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> inline void prn(vector<T>& v) {int n = sz(v); REP(i, n) cout << v[i] << ' ';}
template<class T> inline void printv(vector<T>& v) {int n = sz(v); REP(i, n) cout << v[i] << (i == n - 1 ? endl : ' ');}
template<class T> inline void printvv(vector<vector<T>>& v) {for (auto u : v) printv(u);}
template<class T> inline void printlnv(vector<T>& v) {int n = sz(v); REP(i, n) cout << v[i] << endl;}
const int MOD = 1000000007;
const int INF = 1000000001;
const ll LINF = 1000000001000000001LL;
void solve();
int main() {
cout << fixed << setprecision(numeric_limits<double>::max_digits10);
solve();
return 0;
}
class Combination {
vector<ll> factorial;
vector<ll> fact_inverse;
vector<ll> inverse;
int mod;
void init(int size) {
factorial[0] = 1;
factorial[1] = 1;
fact_inverse[0] = 1;
fact_inverse[1] = 1;
inverse[1] = 1;
for (int i = 2; i < size; i++) {
factorial[i] = factorial[i - 1] * i % mod;
inverse[i] = mod - inverse[mod % i] * (mod / i) % mod;
fact_inverse[i] = fact_inverse[i - 1] * inverse[i] % mod;
}
}
public:
Combination(int size, int m) {
factorial = vector<ll>(size);
fact_inverse = vector<ll>(size);
inverse = vector<ll>(size);
mod = m;
init(size);
}
ll calc(int n, int k) {
if (n < k) {
return 0;
}
if (n < 0 || k < 0) {
return 0;
}
return factorial[n] * (fact_inverse[k] * fact_inverse[n - k] % mod) % mod;
}
ll with_repetition(int n, int k) {
return calc(n + k - 1, k);
}
};
vector<vector<ll>> pascals_triangle(int n) {
vector<vector<ll>> combi(n + 1, vector<ll>(n + 1));
REP(i, n + 1) REP(j, i + 1) {
if (j == 0 || j == i) combi[i][j] = 1LL;
else combi[i][j] = combi[i - 1][j - 1] + combi[i - 1][j];
}
return combi;
}
void solve() {
int n, p;
cin >> n >> p;
auto nck = pascals_triangle(n + 1);
ll even = 0;
ll odd = 0;
REP(i, n) {
int a;
cin >> a;
if (a % 2 == 0) even++;
else odd++;
}
ll ans = 0;
for (int i = 0; i <= even; i++) {
ans += nck[even][i];
}
if (p == 0) {
ll ans2 = 1;
if (odd > 0) {
for (int i = 2; i <= odd; i += 2) {
ans2 += nck[odd][i];
}
}
cout << ans * ans2 << endl;
} else {
ll ans2 = 0;
if (odd > 0) {
for (int i = 1; i <= odd; i += 2) {
ans2 += nck[odd][i];
}
}
cout << ans * ans2 << endl;
}
}
| 0
| 75,375,966
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int x[n],y[n];
for (int i=1;i<n+1;i++){
cin>>x[i];
y[x[i]]=i;
}
for (int i=1;i<n+1;i++){
cout<<y[i]<<" ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
#define replace_all(s, b, a) replace(s.begin(),s.end(), b, a);
#define PI (acos(-1))
#define FILL(v, n, x) fill(v, v + n, x);
#define sz(x) int(x.size())
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using ul = unsigned long;
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; }
int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
const int dy[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
inline bool inside(int y, int x, int H, int W) {
return (y >= 0 && x >= 0 && y < H && x < W);
}
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int f[] = {2,5,5,4,5,6,3,7,6};
int dp[10005];
signed main()
{
cin.tie( 0 ); ios::sync_with_stdio( false );
int n,m;
cin>>n>>m;
vi a(m);
rep(i,m) cin>>a[i];
vsort(a);
rep(i,m) {
dp[f[a[i]-1]]=1;
}
rep(i,n+1){
rep(j,m) {
if(dp[max(0,i-f[a[j]-1])]==0) continue;
chmax(dp[i],dp[max(0,i-f[a[j]-1])]+1);
}
}
string ans="";
int remain=dp[n];
int match=n;
while(match>0){
for(int i=m-1; i>=0; i--){
if(remain==1){
if(f[a[i]-1]==match){
ans+='0'+a[i];
match-=f[a[i]-1];
remain--;
break;
}
}
else if(dp[match-f[a[i]-1]]==remain-1){
ans+='0'+a[i];
match-=f[a[i]-1];
remain--;
break;
}
}
}
cout<<ans<<endl;
}
| 0
| 9,089,715
|
#include<bits/stdc++.h>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
int main(){
int n,m;
scanf("%d %d",&n,&m);
vector<int> coin(m);
for(auto&e:coin){
scanf("%d",&e);
}
int INF=1<<18, MAX_N=50001;
vector<int> dp_coin(MAX_N);
fill(dp_coin.begin(), dp_coin.end(), INF);
dp_coin[n]=0;
for(int i=n;i>0;i--){
for(int j=0;j<m;j++){
if(i>=coin[j]){
dp_coin[i-coin[j]]=min(dp_coin[i]+1,dp_coin[i-coin[j]]);
}
}
}
printf("%d\n",dp_coin[0]);
return 0;
}
|
#include <cstdio>
using namespace std;
int a, b, c, d;
void solve() {
int weight_left = a + b;
int weight_right = c + d;
if (weight_left == weight_right) {
printf("Balanced\n");
return;
}
if (weight_left > weight_right) {
printf("Left\n");
return;
}
if (weight_left < weight_right) {
printf("Right\n");
return;
}
}
int main() {
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
scanf("%d", &d);
solve();
}
| 0
| 84,036,553
|
#include <cstdio>
#include <cmath>
#include <utility>
using namespace std;
using point=pair<double, double>;
int n;
void koch(int n, point &p1, point &p2)
{
if(n){
point s=make_pair((2*p1.first+p2.first)/3, (2*p1.second+p2.second)/3);
point t=make_pair((p1.first+2*p2.first)/3, (p1.second+2*p2.second)/3);
double xx=t.first-s.first, yy=t.second-s.second;
point u=make_pair((xx-sqrt(3)*yy)/2+s.first, (sqrt(3)*xx+yy)/2+s.second);
koch(n-1, p1, s);
printf("%f %f\n", s.first, s.second);
koch(n-1, s, u);
printf("%f %f\n", u.first, u.second);
koch(n-1, u, t);
printf("%f %f\n", t.first, t.second);
koch(n-1, t, p2);
}
}
int main()
{
int n;
scanf("%d", &n);
point p1=make_pair(0, 0), p2=make_pair(100, 0);
printf("%f %f\n", p1.first, p1.second);
koch(n, p1, p2);
printf("%f %f\n", p2.first, p2.second);
return 0;
}
|
#include <iostream>
#include <cstdio>
using namespace std;
char in[100000000];
int main(void) {
int n;
unsigned long long m;
char bfr[200], aft[200];
int flag = 0;
while(1) {
cin >> n;
if(n == 0) break;
for(int i = 0 ; i < n ; i++) {
cin >> bfr[i] >> aft[i];
}
cin >> m;
for(int i = 0 ; i < m ; i++) {
cin >> in[i];
}
for(int i = 0 ; i < m ; i++) {
for(int j = 0 ; j < n ; j++) {
if(in[i] == bfr[j] && flag == 0) {
in[i] = aft[j];
flag = 1;
}
}
flag = 0;
}
for(int i = 0 ; i < m ; i++) {
cout << in[i];
}
cout << endl;
for(int i = 0 ; i < 200 ; i++) {
bfr[i] = 0;
aft[i] = 0;
}
}
return 0;
}
| 0
| 42,493,786
|
#pragma GCC optimize ("O3")
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <set>
#include <algorithm>
#include <numeric>
#include <list>
using namespace std;
using QWORD = uint64_t;
using SQWORD = int64_t;
using DWORD = uint32_t;
using SDWORD = int32_t;
using WORD = uint16_t;
using SWORD = int16_t;
using BYTE = uint8_t;
using SBYTE = int8_t;
using DOUBLE = double;
using LDOUBLE = long double;
using FLOAT = float;
#define MIN_SDWORD (-2147483648)
#define MAX_SDWORD (2147483647)
#define MIN_SBYTE (-128)
#define MAX_SBYTE (127)
#define MIN_SQWORD (0x8000000000000000)
#define MAX_SQWORD (0x7FFFFFFFFFFFFFFF)
#define MAX_QWORD (0xFFFFFFFFFFFFFFFF)
#define MAX_DWORD (0xFFFFFFFF)
#define MAX_WORD (0xFFFF)
#define MAX_BYTE (0xFF)
#define MAX_DOUBLE (1.0e+308)
#define DOUBLE_EPS (1.0e-12)
#define MIN_DOUBLE_N (-1.0e+308)
#define ArrayLength(a) (sizeof(a) / sizeof(a[0]))
static inline DOUBLE MAX(DOUBLE a, DOUBLE b) { return a > b ? a : b; }
static inline QWORD MAX(QWORD a, QWORD b) { return a > b ? a : b; }
static inline DWORD MAX(DWORD a, DWORD b) { return a > b ? a : b; }
static inline SDWORD MAX(SDWORD a, SDWORD b) { return a > b ? a : b; }
static inline DOUBLE MIN(DOUBLE a, DOUBLE b) { return a < b ? a : b; }
static inline QWORD MIN(QWORD a, QWORD b) { return a < b ? a : b; }
static inline DWORD MIN(DWORD a, DWORD b) { return a < b ? a : b; }
static inline SDWORD MIN(SDWORD a, SDWORD b) { return a < b ? a : b; }
#define BYTE_BITS (8)
#define WORD_BITS (16)
#define DWORD_BITS (32)
#define QWORD_BITS (64)
static inline void inputStringSpSeparated(char *pcStr)
{
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c) || (' ' == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline void inputString(char *pcStr)
{
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline SQWORD inputSQWORD(void)
{
SQWORD sqNumber = 0;
SQWORD sqMultiplier = 1;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
sqMultiplier = -1;
}
}
if (('0' <= c) && (c <= '9')) {
sqNumber *= 10LL;
sqNumber += (SQWORD)(c - '0');
bRead = true;
} else {
if (bRead) {
return sqNumber * sqMultiplier;
}
}
}
}
static inline SDWORD inputSDWORDPlus(void)
{
SDWORD lNumber = 0;
SDWORD lMultiplier = 1;
bool bRead = false;
for (;;) {
char c = getchar();
if (('0' <= c) && (c <= '9')) {
lNumber *= 10;
lNumber += (c - '0');
} else {
return lNumber * lMultiplier;
}
}
}
#define MAX_H (300000)
#define MAX_W (300000)
int main(void)
{
SDWORD lH = inputSDWORDPlus();
SDWORD lW = inputSDWORDPlus();
SDWORD lM = inputSDWORDPlus();
static SDWORD s_alCntH[MAX_H];
static SDWORD s_alCntW[MAX_W];
SDWORD lMaxH = 0;
SDWORD lMaxW = 0;
vector<pair<SDWORD, SDWORD>> vpairlTgtPos;
for (SDWORD lIdx = 0 ; lIdx < lM; lIdx++) {
SDWORD lTgtH = inputSDWORDPlus() - 1;
SDWORD lTgtW = inputSDWORDPlus() - 1;
s_alCntH[lTgtH]++;
s_alCntW[lTgtW]++;
lMaxH = max(lMaxH, s_alCntH[lTgtH]);
lMaxW = max(lMaxW, s_alCntW[lTgtW]);
vpairlTgtPos.emplace_back(make_pair(lTgtH, lTgtW));
}
SDWORD lCntMaxH = 0;
SDWORD lCntMaxW = 0;
for (SDWORD lIdx = 0; lIdx < lH; lIdx++) {
if (s_alCntH[lIdx] == lMaxH) {
lCntMaxH++;
}
}
for (SDWORD lIdx = 0; lIdx < lW; lIdx++) {
if (s_alCntW[lIdx] == lMaxW) {
lCntMaxW++;
}
}
SQWORD sqCntMaxPos = 0;
SDWORD lMaxHW = lMaxH + lMaxW;
for (auto pos: vpairlTgtPos) {
if (s_alCntH[pos.first] + s_alCntW[pos.second] == lMaxHW) {
sqCntMaxPos++;
}
}
if (sqCntMaxPos == (SQWORD)lCntMaxH * (SQWORD)lCntMaxW) {
printf("%ld\n", lMaxHW - 1);
} else {
printf("%ld\n", lMaxHW);
}
return 0;
}
|
#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
int n, a, b;
cin >> n >> a >> b;
int ans = 0;
for (int i = 1; i <= n; i++) {
string num_str = to_string(i);
int sum = 0;
for (int j = 0; j < num_str.size(); j++) {
sum = sum + (int)(num_str[j] - '0');
}
if (a <= sum && sum <= b) ans = ans + i;
}
cout << ans;
}
| 0
| 93,534,616
|
#include <bits/stdc++.h>
using namespace std;
#define M 1000000007
long long int power(int a,int b)
{
if(b==0)
return 1;
long long int k=power(a,b/2);
if(b%2==0)
return ((k%M)*(k%M))%M;
else
return ((k%M)*(k%M)*(a%M))%M;
}
long long int fact(long long int n)
{
if(n==1 || n==0)
return 1;
else
return ((n%M)*(fact(n-1)%M))%M;
}
int div(int n)
{ int c=0;
for(int i=1;i<=sqrt(n);i++)
{
if(n%i==0)
{
if(n/i==i)
c++;
else
c+=2;
}
}
return c;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int n;
cin>>n;
for(int i=0;i<=25;i++)
{
for(int j=0;j<=14;j++)
{
if(7*j+4*i==n)
{
cout<<"Yes";
return 0;
}
if(7*j+4*i>n)
{
break;
}
}
}
cout<<"No";
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; ++i)
#define rrep(i, n) for(int i = n-1; i >= 0; --i)
#define fi first
#define se second
using namespace std;
using lint = long long;
using uint = unsigned int;
using ulint = unsigned long long;
using ldouble = long double;
using pii = pair<int, int>;
using pli = pair<lint, lint>;
using pdd = pair<double, double>;
using pld = pair<ldouble, ldouble>;
using v1i = vector<int>;
using v1li = vector<lint>;
using v2i = vector<vector<int>>;
using v2li = vector<vector<lint>>;
using v3i = vector<vector<vector<int>>>;
using v3li = vector<vector<vector<lint>>>;
using v1b = vector<bool>;
using v2b = vector<vector<bool>>;
using v3b = vector<vector<vector<bool>>>;
using v1c = vector<char>;
using v2c = vector<vector<char>>;
using v3c = vector<vector<vector<char>>>;
constexpr lint mod1 = 1e9+7;
constexpr lint mod2 = 998244353;
int main(){
int n, p; cin >> n >> p;
string s; cin >> s;
v1i v(n+1, 0), u(p-1, 1);
rep(i, p-2){
u[i+1] = u[i]*10;
u[i+1] %= p;
}
rrep(i, n){
v[i] = v[i+1] + u[(n-i-1)%(p-1)]*(s[i]-'0');
v[i] %= p;
}
map<int, lint> m;
rep(i, n+1) m[v[i]]++;
lint a = 0;
rep(i, p) a += m[i] * (m[i]-1) / 2;
if(p == 2){
a = 0;
rep(i, n) if((s[i] - '0') % 2 == 0) a += i+1;
}
else if(p == 5){
a = 0;
rep(i, n) if((s[i] - '0') % 5 == 0) a += i+1;
}
cout << a << "\n";
return 0;
}
| 0
| 22,413,809
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mp make_pair
#define pb push_back
#define fi first
#define si second
#define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL);
#define F(a,n) for(int i=0;i<n;i++){cin>>a[i];}
#define F1(a,n) for(int i=1;i<=n;i++){cin>>a[i];}
#define P(a,n) for(int i=0;i<n;i++){cout<<a[i]<<' ';}cout<<endl;
#define P1(a,n) for(int i=1;i<=n;i++){cout<<a[i]<<' ';}cout<<endl;
#define NF(a,n,m) for(int i=0;i<n;i++){for(int j=0;j<m;j++){cin>>a[i][j];}}
#define NF1(a,n,m) for(int i=1;i<=n;i++){for(int j=1;j<=m;j++){cin>>a[i][j];}}
#define PNF(a,n,m) for(int i=0;i<n;i++){for(int j=0;j<m;j++){cout<<a[i][j]<<' ';}cout<<endl;}cout<<endl;
#define PNF1(a,n,m) for(int i=1;i<=n;i++){for(int j=1;j<=m;j++){cout<<a[i][j]<<' ';}cout<<endl;}cout<<endl;
const int nax = 1e7;
const int mod = 1e9+7;
ll n, *ar, len1, len2, len3;
ll func(ll i, ll a, ll b, ll c){
if(i == n){
ll diff = abs(len1-a) + abs(len2-b) + abs(len3-c);
return (a == 0 || b == 0 || c == 0) ? INT_MAX : diff;
}
ll op1 = a != 0 ? 10 + func(i+1, a+ar[i], b, c) : func(i+1, a+ar[i], b, c);
ll op2 = b != 0 ? 10 + func(i+1, a, b+ar[i], c) : func(i+1, a, b+ar[i], c);
ll op3 = c != 0 ? 10 + func(i+1, a, b, c+ar[i]) : func(i+1, a, b, c+ar[i]);
ll op4 = func(i+1, a, b, c);
return min(op1, min(op2, min(op3, op4)));
}
int main(){
fastIO
cin>>n;
cin>>len1>>len2>>len3;
ar = new ll[n];
F(ar, n);
cout<<func(0, 0, 0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
#define Graph vector<vector<int>>
int main() {
int N, D, X; cin >> N >> D >> X;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
int ans = X, day;
for (int i = 0; i < N; i++) {
day = 1;
while (day <= D) {
ans ++;
day += A.at(i);
}
}
cout << ans << endl;
return 0;
}
| 0
| 89,616,539
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e3+ 2;
const int Mod = 1e9 + 7;
const double PI =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
if(a==0 || b==0)return 0;
return a/__gcd(a,b)*b;
}
void input(ll ara[],ll n)
{
for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
for(ll i=0; i<n; i++)
cout<<ara[i]<<" ";
cout<<endl;
}
ll up[Max][Max],down[Max][Max],Left[Max][Max]
,Right[Max][Max];
ll n,m;
char ara[Max][Max];
void cum()
{
ll i,j;
for(i=1; i<=n; i++)
{
for(j=1; j<=m; j++)
{
if(ara[i][j]=='#')
Left[i][j]=0;
else Left[i][j]=Left[i][j-1]+1;
}
}
for(i=1; i<=m; i++)
{
for(j=1; j<=n; j++)
{
if(ara[j][i]=='#')
up[j][i]=0;
else up[j][i]=up[j-1][i]+1;
}
}
for(j=m; j>=1; j--)
{
for(i=n; i>=1; i--)
{
if(ara[i][j]=='#')
down[i][j]=0;
else down[i][j]=down[i+1][j]+1;
}
}
for(i=n; i>=1; i--)
{
for(j=m; j>=1; j--)
{
if(ara[i][j]=='#')
Right[i][j]=0;
else Right[i][j]=Right[i][j+1]+1;
}
}
}
int main()
{
fastread();
ll i,j,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;
bool flag=false;
cin>>n>>m;
for(i=1; i<=n; i++)
{
for(j=1; j<=m; j++)
cin>>ara[i][j];
}
cum();
ans=0;
for(i=1; i<=n; i++)
{
for(j=1; j<=m; j++)
{
if(ara[i][j]!='#')
{
ans=max(ans,up[i][j]+down[i][j]+Left[i][j]+Right[i][j]-3);
}
}
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int square(long long int & n)
{
long long tmp = sqrt(n), ans = 0;
for(int i = tmp; i >= 1; i--)
if( n % i == 0 )
{
tmp = n/i;
while( tmp > 0 )
{
ans++;
tmp /= 10;
}
return ans;
}
}
int main()
{
long long int n;
cin >> n;
cout << square(n);
}
| 0
| 30,697,871
|
#include <iostream>
#include <map>
#include <string>
using namespace std;
typedef pair<int,int> P;
int main()
{
string s;
pair<string,int> mode=make_pair("",0),mlen=make_pair("",0);
map<string,P> m;
while(cin>>s){
int d=++m[s].first;
m[s].second=s.length();
if(mode.second<d){mode=make_pair(s,d);}
if(mlen.second<s.length()){mlen=make_pair(s,s.length());}
}
cout<<mode.first<<" "<<mlen.first<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
ll countBits(ll in){
int res=0;
for(;in>0;in>>=1){
if((in&0x01)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
ll powm(ll a,ll n, ll m){
ll ret=1;
while(n>0){
if(n%2==1){
ret=(ret*a)%m;
}
n>>=1;
a=(a*a)%m;
}
return ret;
}
const string yesno(bool ans){
return (ans?"Yes":"No");
}
int main() {
string s;cin>>s;
ll ans=0;
int n=s.size()+1;
vector<int> left(n);
vector<int> right(n);
int cnt=0;
for(int i=0;i<n-1;i++){
if(s[i]=='<'){
cnt++;
}else{
cnt=0;
}
left[i+1]=cnt;
cerr<<cnt<<" \n"[i==n-2?1:0];
}
cnt=0;
for(int i=0;i<n-1;i++){
if(s[s.size()-1-i]=='>'){
cnt++;
}else{
cnt=0;
}
right[i+1]=cnt;
cerr<<cnt<<" \n"[i==n-2?1:0];
}
reverse(all(right));
for(int i=0;i<n;i++){
cerr<<left[i]<<" : "<<right[i]<<endl;
ans+=max(left[i],right[i]);
}
cout<<ans<<endl;
return 0;
}
| 0
| 22,724,891
|
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cmath>
#include<map>
#include<iomanip>
#include<queue>
#include<stack>
#include<time.h>
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
#define ggr getchar();getchar();return 0;
#define prique priority_queue
constexpr auto mod = 1000000007;
#define inf 1e15
#define key 1e9
using namespace std;
typedef pair<int, int>P;
template<class T> inline void chmax(T& a, T b) {
a = std::max(a, b);
}
template<class T> inline void chmin(T& a, T b) {
a = std::min(a, b);
}
const int MAX = 330000;
int fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
int COMB(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
bool prime(int n) {
int cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0)cnt++;
}
if (cnt != 1)return false;
else return n != 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 mod_pow(int x, int y, int m) {
int res = 1;
while (y) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= (i % mod); res %= mod;
}
return res;
}
int comb(int x, int y) {
if (y > x)return 0;
return kai(x, y) * mod_pow(kai(y, y), mod - 2, mod) % mod;
}
class UnionFind {
protected:
int* par, * rank, * size;
public:
UnionFind(unsigned int size) {
par = new int[size];
rank = new int[size];
this->size = new int[size];
rep(i, size) {
par[i] = i;
rank[i] = 0;
this->size[i] = 1;
}
}
int find(int n) {
if (par[n] == n)return n;
return par[n] = find(par[n]);
}
void unite(int n, int m) {
n = find(n);
m = find(m);
if (n == m)return;
if (rank[n] < rank[m]) {
par[n] = m;
size[m] += size[n];
}
else {
par[m] = n;
size[n] += size[m];
if (rank[n] == rank[m])rank[n]++;
}
}
bool same(int n, int m) {
return find(n) == find(m);
}
int getsize(int n) {
return size[find(n)];
}
};
int dight(int n) {
int ans = 1;
while (n >= 10) {
n /= 10;
ans++;
}
return ans;
}
int dight_sum(int n) {
int sum = 0;
rep(i, 20)sum += (n % (int)pow(10, i + 1)) / (pow(10, i));
return sum;
}
string s, t;
int r1[26], r2[26];
signed main() {
cin >> s >> t;
int n = s.size();
rep(i, 26) {
r1[i] = -1, r2[i] = -1;
}
rep(i, n) {
if (r1[s[i] - 'a'] < 0)r1[s[i] - 'a'] = (t[i] - 'a');
else {
if (r1[s[i] - 'a'] != t[i] - 'a') {
puts("No");
ggr
}
}
if (r2[t[i] - 'a'] < 0)r2[t[i] - 'a'] = (s[i] - 'a');
else {
if (r2[t[i] - 'a'] != s[i] - 'a') {
puts("No");
ggr
}
}
}
puts("Yes");
ggr
}
|
#include<iostream>
typedef struct{
int parent;
int left_child;
int next_sibling;
int child;
}node;
int depth(int);
node *T;
int count;
int main(){
int n, x, y, z, i, j;
std::cin >> n;
T = new node[n];
for(i=0; i<n; i++) T[i].parent = -1;
for(i=0; i<n; i++){
std::cin >> x >> z;
T[x].child = z;
for(j=0; j<z; j++){
if(j == 0){
std:: cin >> y;
T[y].parent = x, T[x].left_child = y;
}
else{
std::cin >> T[y].next_sibling;
T[y].parent = x, T[T[y].next_sibling].parent = x, y = T[y].next_sibling;
}
}
}
for(i=0; i<n; i++){
count=0;
std::cout<<"node "<<i<<": parent = "<<T[i].parent<<", depth = "<<depth(i);
if(T[i].parent == -1) std::cout << ", root, [";
else if(T[i].child == 0) std::cout << ", leaf, [";
else std::cout << ", internal node, [";
for(j=0; j<T[i].child; j++){
if(j == 0){
std::cout << T[i].left_child;
x = T[T[i].left_child].next_sibling;
}
else{
std::cout << x;
x = T[x].next_sibling;
}
if(j != T[i].child - 1) std::cout << ", ";
}
std::cout << "]\n";
}
delete T;
return 0;
}
int depth(int x){
if(T[x].parent == -1) return count;
else{
count++;
depth(T[x].parent);
}
return count;
}
| 0
| 15,632,511
|
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define rep(i,n) for(int i = 0; i < n; i++)
#define REP(i, k , n) for(int i = k; i <= n; i++)
typedef long long ll;
const char nl = '\n' ;
const ll MOD = 1e9 + 7;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int n, h; cin >> n ;
map< string , int> m;
int ans =0;
rep(i,n)
{
string s; cin >> s;
m[s]++;
}
cin >> h;
rep(i, h)
{
string s; cin >> s;
m[s]--;
}
for(auto it = m.begin(); it!=m.end(); it++)
{
ans = max(ans, it->second);
}
cout << ans << nl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int s[100];
int main() {
while(true) {
scanf("%d", &n);
if (n == 0) break;
for (int i=0; i<n; i++) scanf("%d", &s[i]);
sort(s, s+n);
int sum = 0;
for (int i=1; i<n-1; i++) sum += s[i];
printf("%d\n", sum / (n - 2));
}
}
| 0
| 88,763,308
|
#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>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long; using ld = long double;
using P = pair<int, int>;
int main() {
int dh[4] = {1, 0, -1, 0};
int dw[4] = {0, 1, 0, -1};
int h, w;
cin >> h >> w;
string a[h];
rep(i,h) cin >> a[i];
bool canf = true;
rep(i,h) rep(j,w) {
if (a[i][j] == '.') continue;
bool canp = false;
rep (k,4) {
int ni = i + dh[k];
int nj = j + dw[k];
if (ni < 0 || ni >= h) continue;
if (nj < 0 || nj >= w) continue;
if (a[ni][nj] == '#') canp = true;
}
if (!canp) {
canf = false;
break;
}
}
if (canf) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#pragma GCC diagnostic ignored "-Wunused-variable"
#include <bits/stdc++.h>
using namespace std;
#ifdef BOOST
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/range/adaptor/reversed.hpp>
using namespace boost;
using ml = boost::multiprecision::cpp_int;
using md = boost::multiprecision::cpp_dec_float_100;
#define forir(i, ...) if(ll i=(ll)v.size())for(__VA_ARGS__)if(i--,1)
#define eachr(i, e, c) forir(i, auto &&e: adaptors::reverse(c))
#endif
using ll = long long;
using ld = long double;
using pll = pair<long long, long long>;
template <class T> using vt = vector<T>;
template <class T> using vvt = vector<vector<T>>;
template <class T> using vvvt = vector<vector<vector<T>>>;
#define all(c) (c).begin(), (c).end()
#define coutd cout << fixed << setprecision(10)
#define output(x) do{cout<<x;return 0;}while(0)
#define rep(i, b, e) for (ll i = b; i < e; i++)
#define repr(i, b, e) for (ll i = b; e < i; i--)
#define fori(i, ...) if (ll i = -1) for(__VA_ARGS__) if (i++, 1)
#define each(i, e, c) fori (i, auto&& e: c)
#define llong_max 9223372036854775807
#define ldbl_max 1.79769e+308
#define pi 3.1415926535897932
auto Ceil = []
(auto x) { return (ll)ceil(x); };
auto Count = []
(auto b, auto e, auto x) { return (ll)count(b, e, x); };
auto CtoL = []
(auto c) { return (ll)c - (ll)'0'; };
auto LtoC = []
(auto n) { return (char)('0' + n); };
auto Pow = []
(auto a, auto b) { return (ll)pow(a, b); };
auto Pow2 = []
(auto n) { return (1LL << n); };
auto Pow10 = []
(auto n) { return (ll)pow(10, n); };
auto Size = []
(auto& c) { return (ll)(c).size(); };
auto Sum = []
(auto b, auto e) { return accumulate(b, e, 0LL); };
template <class T> void MakeVVT
(ll ys, ll xs, vvt<T>& v, T fill = T())
{
v.resize(ys); rep(y, 0, ys) v[y].resize(xs, fill);
}
template <class T> void MakeVVVT
(ll zs, ll ys, ll xs, vvvt<T>& v, T fill = T())
{
v.resize(zs); rep(z, 0, zs) MakeVVT(ys, xs, v[z], fill);
}
template <class T> void InputVT
(ll xs, vt<T>& v, T fix = T())
{
v.resize(xs); rep(i, 0, xs) { cin >> v[i]; v[i] += fix; }
}
template <class T> void InputVVT
(ll ys, ll xs, vvt<T>& v, T fix = T())
{
MakeVVT(ys, xs, v, fix);
rep(y, 0, ys) rep(x, 0, xs) { cin >> v[y][x]; v[y][x] += fix; }
}
template <class T> void InputVVVT
(ll zs, ll ys, ll xs, vvvt<T>& v, T fix = T())
{
v.resize(zs); rep(z, 0, zs) InputVVT(ys, xs, v[z], fix);
}
namespace NyaGadget {}
using namespace NyaGadget;
int main(void)
{
ll n; cin >> n;
vt<ll> nyaa(n+1);
rep(i, 0, n) cin >> nyaa[i] >> nyaa[i+1];
ll const inf = Pow10(9);
vvt<ll> dp; MakeVVT(n, n, dp, inf);
rep(i, 0, n) dp[i][i] = 0;
rep(range, 1, n) rep(l, 0, n)
{
ll r = l + range;
if (n <= r) continue;
rep(m, l, r) dp[l][r] = min(dp[l][r], dp[l][m] + dp[m+1][r] + nyaa[l] * nyaa[m+1] * nyaa[r+1]);
}
cout << dp[0][n-1] << endl;
return 0;
}
| 0
| 35,474,198
|
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i,s,n) for(int i=s;i<n;i++)
#define MOD 1000000007
#define NUM 2520
#define INF (1LL<<50)
#define DEBUG 0
#define mp(a,b) make_pair(a,b)
#define SORT(V) sort(V.begin(),V.end())
#define PI (3.141592653589794)
string dp[10100];
lli use[10];
bool vis[10010];
signed main(){
REP(i,0,10)use[i]=-1;
lli n,m;
cin>>n>>m;
lli d[9]={2,5,5,4,5,6,3,7,6};
REP(i,0,m){
lli a;
cin>>a;
use[d[a-1]] = max(use[d[a-1]],a);
}
if(DEBUG){
REP(i,0,10){
cout<<use[i]<<endl;
}
}
vis[0]=true;
REP(i,0,n){
if(!vis[i])continue;
REP(j,0,10){
if(use[j]==-1)continue;
if(dp[i+j].size() < (dp[i]+to_string(use[j])).size()){
dp[i+j] = dp[i]+to_string(use[j]);
}
else{
dp[i+j] = max(dp[i]+to_string(use[j]),dp[i+j]);
}
vis[i+j]=true;
}
}
if(DEBUG)REP(i,0,n)cout<<"i="<<i<<" dp="<<dp[i]<<endl;
cout<<dp[n]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, total = 0;
cin >> N;
vector<double> T(N), V(N);
for (int i = 0; i < N; i++)
{
cin >> T.at(i);
total += T.at(i);
}
for (int i = 0; i < N; i++)
{
cin >> V.at(i);
}
vector<double> maxV(total * 2 + 1, 10000);
maxV[0] = 0, maxV[total * 2] = 0;
int l = 0;
for (int i = 0; i < N; i++)
{
for (int t = l; t <= l + T.at(i) * 2; t++)
{
maxV[t] = min(maxV[t], V.at(i));
}
l += T.at(i) * 2;
}
for (int t = 1; t <= total * 2; t++)
{
maxV[t] = min(maxV[t], maxV[t - 1] + 0.5);
}
for (int t = total * 2 - 1; t >= 0; t--)
{
maxV[t] = min(maxV[t], maxV[t + 1] + 0.5);
}
double ans = 0.0;
for (int t = 0; t <= total * 2; t++)
{
ans += maxV[t] * 0.5;
}
cout << fixed << setprecision(10) << ans << endl;
}
| 0
| 65,622,540
|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include <climits>
const int mod = 1e9 + 7;
const int INF = 1e9;
using namespace std;
typedef long long ll;
int main()
{
int a,b;
cin >> a >> b;
if(a < b){
cout << "a < b" << endl;
}else if(a > b){
cout << "a > b" << endl;
}else{
cout << "a == b" << endl;
}
}
|
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cmath>
using namespace std;
#define REP(i, limit) for(int i=0; i< limit; ++i)
#define FOR(i, j, limit) for(int i=j; i< limit; ++i)
#define DUMP(a) REP(d,a.size()){cout<<a[d];if(d!=a.size()-1)cout<<" ";else cout<<endl;}
#define ECHO(x) cout<<x<<endl;
#define MEMSET(a, n, x) REP(i, n) a[i]=x;
#define ARRIN(a, n) REP(i, n) cin>>a[i];
#define LL long long
int INF = 2147483647;
LL LINF = 9223372036854775807;
LL MOD = 1000000007;
typedef pair<int, int>P;
typedef pair<LL, LL>PL;
typedef vector<int> vi;
typedef vector<LL> vl;
int main(){
int h, w, n;
map<P, int> mp;
cin>>h>>w>>n;
int a, b;
LL ans[10]={};
ans[0]=(LL)(h-2)*(w-2);
REP(i, n){
cin>>a>>b;
for(int y=-1; y<=1; ++y){
for(int x=-1; x<=+1; ++x){
if(a+y<2||a+y>h-1) continue;
if(b+x<2||b+x>w-1) continue;
++mp[make_pair(a+y, b+x)];
}
}
}
for(auto i=mp.begin(); i!=mp.end(); ++i){
++ans[i->second];
}
REP(i, 9){
ans[0]-=ans[i+1];
}
REP(i, 10){
cout<<ans[i]<<endl;
}
return 0;
}
| 0
| 98,078,577
|
#include <bits/stdc++.h>
#include "atcoder/dsu"
using namespace std;
typedef long long int ll;
int main(int, char **) {
int n, q;
cin >> n >> q;
atcoder::dsu uf(n);
for (int i = 0; i < q; i++) {
int t, u, v;
cin >> t >> u >> v;
if (t == 0) {
uf.merge(u, v);
} else {
cout << (int)uf.same(u, v) << "\n";
}
}
fflush(stdout);
}
|
#include <iostream>
#include <cstring>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i=0;i<(n);++i)
const int MOD = 1e9+7;
int main() {
int N, M; cin >> N >> M;
int S[N], T[M];
rep(i, N) cin >> S[i];
rep(i, M) cin >> T[i];
ll dp[N+1][M+1];
ll sum[N+2][M+2];
memset(dp, 0, sizeof(dp));
memset(sum, 0, sizeof(sum));
int ans = 0;
dp[0][0] = 1;
sum[1][1] = 1;
rep(i, N+1) {
rep(j, M+1) {
if (i == 0 && j == 0)
continue;
if (i >= 1 && j >= 1 && S[i-1] == T[j-1])
dp[i][j] = sum[i][j];
else
dp[i][j] = 0;
sum[i+1][j+1] = (sum[i+1][j] + sum[i][j+1] - sum[i][j] + dp[i][j] + MOD) % MOD;
}
}
cout << sum[N+1][M+1] << endl;
return 0;
}
| 0
| 67,064,448
|
#include <bits/stdc++.h>
using namespace std;
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
return os << "(" << x.first << "," << x.second << ")";
}
typedef long long ll;
typedef long double ld;
int main() {
int n;
scanf("%d", &n);
int p = 0;
ll ans = 0;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
int use = min(a, p);
ans += use;
a -= use;
ans += a / 2;
a %= 2;
p = a;
}
printf("%lld\n", ans);
}
|
#include <cstdio>
int n;
int a[200010];
long long D = 1000000007;
long long f[200010], u[200010];
long long res = 0;
int have[200010];
long long pw2(long long x, long long aa)
{
long long y = 1;
while(aa>0){
if(aa % 2 == 1){
y *= x;
y %= D;
}
aa /= 2;
x *= x;
x %= D;
}
return y;
}
void pre()
{
int i;
f[0] = f[1] = 1;
for(i=2; i<=n; i++){
f[i] = f[i-1] * i;
f[i] %= D;
}
u[0] = u[1] = 1;
for(i=2; i<=n; i++){
u[i] = pw2(f[i], D-2);
}
}
long long calcC(int nn, int mm)
{
if(nn < mm)
return 0;
long long r = f[nn];
r *= u[mm];
r %= D;
r *= u[nn-mm];
r %= D;
return r;
}
void solve()
{
pre();
int i;
int vv, ll=-1, rr=-1;
for(i=0; i<n+1; i++){
have[a[i]] ++;
if(have[a[i]] == 2)
vv = a[i];
}
for(i=0; i<n+1; i++){
if(a[i] == vv){
if(ll==-1)
ll = i;
else
rr = i;
}
}
printf("%d\n", n);
for(i=2; i<=n; i++){
res = 0;
res += calcC(n-1, i);
res += calcC(n-1, i-1);
res %= D;
res += calcC(n-1, i-1);
res %= D;
res += D;
res -= calcC(n+1-(rr-ll+1), i-1);
res %= D;
res += calcC(n-1, i-2);
res %= D;
printf("%lld\n", res);
}
printf("%d\n", 1);
}
int main()
{
int i;
scanf("%d", &n);
for(i=0; i<n; i++)
scanf("%d", &a[i]);
solve();
return 0;
}
| 0
| 86,597,396
|
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int Flag(char t, char h){
int Flag = 0;
if(t > h) Flag = 1;
if(t < h) Flag = -1;
return Flag;
}
int Judge(string WordT, string WordH){
int i = 0;
int Judge = 0;
while(i < WordT.size() && i < WordH.size()){
Judge = Flag(WordT[i], WordH[i]);
if(WordT[i] != WordH[i]) break;
i++;
}
if(Judge == 0 && WordT.size() > WordH.size()) Judge = 1;
if(Judge == 0 && WordT.size() < WordH.size()) Judge = -1;
return Judge;
}
int main(){
int n;
cin >> n;
vector<string> T;
vector<string> H;
for(int i = 0; i < n; i++){
string WordT;
string WordH;
cin >> WordT;
cin >> WordH;
T.push_back(WordT);
H.push_back(WordH);
}
int PointT = 0;
int PointH = 0;
for(int i = 0; i < n; i++){
if(Judge(T[i], H[i]) == 1) PointT +=3;
if(Judge(T[i], H[i]) == 0) PointT++, PointH++;
if(Judge(T[i], H[i]) == -1) PointH +=3;
}
cout << PointT << " " << PointH << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a,b;
ll k_th(ll x,ll y)
{
if(y<x) return y;
return y+1;
}
bool judge(ll m)
{
ll k=m/2;
for(ll i=max(1ll,k-1);i<=min(k+1,m);i++)
if(k_th(a,i)*k_th(b,m-i+1)>=a*b) return false;
return true;
}
int main()
{
int q;scanf("%d",&q);
while(q--)
{
scanf("%lld%lld",&a,&b);
ll l=0,r=2e9,ans;
while(l<=r)
{
ll m=l+r>>1;
if(judge(m)) ans=m,l=m+1;
else r=m-1;
}
printf("%lld\n",ans);
}
}
| 0
| 53,584,872
|
#include<algorithm>
#include<bitset>
#include<climits>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
int main() {
ll N,M;
cin >> N >> M;
vector<pair<ll,string>> pS;
vector<ll> ac(N);
vector<ll> wa(N);
rep(i,M){
ll a;
string b;
cin >> a >> b;
if(ac[a-1]){
continue;
}else if(b == "AC"){
ac[a-1] = 1;
}else{
wa[a-1]++;
}
}
ll AC=0, WA=0;
rep(i,N){
AC += ac[i];
if(ac[i]){
WA += wa[i];
}
}
cout << AC << " " << WA << endl;
}
|
#include<bits/stdc++.h>
#define _USE_MATH_DEFINES
using namespace std;
#define ll long long int
#define pb push_back
#define rep(i , j , n) for(ll i = j ; i < n ; i++)
#define per(i , j , n) for(ll i = j ; i >= n ; i--)
#define all(x) x.begin(), x.end()
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vll;
int main(){
ll n,k;
cin >> n >> k;
ll j = 0;
vll a(n),b(n);
rep(i,0,n){
cin >> a[i];
b[i] = 0;
}
while(j < k && j <= 42){
j++;
rep(i,0,n){
ll l,r;
l = max((ll)0,i - a[i]);
r = min(n - 1, i + a[i]);
b[l]++;
if(r + 1 < n) b[r + 1]--;
}
rep(i,0,n){
if(i > 0) b[i] += b[i - 1];
a[i] = b[i];
}
rep(i,0,n){
b[i] = 0;
}
}
rep(i,0,n){
cout << a[i] << " ";
}
}
| 0
| 24,242,870
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define REP(i, n) for (LL i = 0; i < (LL)(n); i++)
#define REP2(i, n) for (LL i = 1; i <= (LL)(n); i++)
#define FOR(i, m, n) for (LL i = m; i < n; i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define ALL(x) (x).begin(), (x).end()
#define SUM(x) accumulate(x.begin(), x.end(),0)
#define vLL(v,n) vector<LL> v(n); REP(i,n)cin>>v[i];
#define vstr(v,n) vector<string> v(n); REP(i,n)REP(i,n)cin>>v[i];
LL INF = 1e9 + 1;
LL MOD = 1e9+7;
LL a,b,c,d,e,n,m,l,k,r,x,y,z,ans=0,ans2=0,h,w;
string s,S,t;
int main() {
ios_base::sync_with_stdio(false);
vector<LL>L(87);
L[0]=2;
L[1]=1;
cin >> n;
FOR(i,2,87){
L[i]=L[i-2]+L[i-1];
}
cout <<L[n];
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define per(i,n) for(int i = n-1; i >= 0; i--)
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<ll> vll;
int main() {
ll h, w;
cin >> h >> w;
if(h%3==0 || w%3==0) {
cout << 0 << endl;
return 0;
}
ll ans = LLONG_MAX;
ll a = w/3 -10;
ll b = h/2 -10;
rep(i,20)rep(j,20) {
ll c = a+i;
ll d = b+j;
if(c<=0 || d<=0) continue;
if(c>=w || d>=h) continue;
ll s1 = c*h;
ll s2 = (w-c)*d;
ll s3 = h*w - s1 - s2;
if(s1<=0 || s2<=0 || s3<=0) continue;
ll smax = max(s1,max(s2,s3));
ll smin = min(s1,min(s2,s3));
ans = min(ans,smax-smin);
}
ll o = h/3 -10;
ll p = w/2 -10;
rep(i,20)rep(j,20) {
ll q = o+i;
ll r = p+j;
if(q<=0 || r<=0) continue;
if(q>=h || r>=w) continue;
ll s1 = q*w;
ll s2 = (h-q)*r;
ll s3 = h*w - s1 - s2;
if(s1<=0 || s2<=0 || s3<=0) continue;
ll smax = max(s1,max(s2,s3));
ll smin = min(s1,min(s2,s3));
ans = min(ans,smax-smin);
}
ans = min(ans,h);
ans = min(ans,w);
cout << ans << endl;
return 0;
}
| 0
| 4,947,778
|
#include <iostream>
using namespace std;
int main() {
int pos = -1;
int input;
int senro[100];
while (cin >> input) {
if (input != 0) {
pos++;
senro[pos] = input;
} else if (input == 0) {
if (pos >= 0) {
cout << senro[pos] << "\n";
pos--;
} else {
cout << "error???" << "\n";
return 1;
}
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int n, s, ans;
void solve(int cnt, int num, int sum){
if(n==cnt&&s==sum){
ans++;
return;
}else if(cnt>n||num>9){
return;
}
solve(cnt+1, num+1, sum+num);
solve(cnt, num+1, sum);
}
int main(){
while(1){
cin>> n>> s;
if(n==0&&s==0) break;
ans=0;
solve(0, 0, 0);
cout<< ans<< endl;
}
return 0;
}
| 0
| 61,549,789
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define long long long
#define PI 3.141592653589793238
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
typedef trie<string,null_type,trie_string_access_traits<>,pat_trie_tag,trie_prefix_search_node_update> pref_trie;
typedef tree<long int,null_type,less<long int>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
typedef cc_hash_table<long int,long int, hash<long int>, equal_to<long int>, direct_mask_range_hashing<long int>,
hash_standard_resize_policy<hash_exponential_size_policy<>, hash_load_check_resize_trigger<true>, true>> ht;
typedef gp_hash_table<long int,long int> HashTable;
long int dp[11][2][10][2];
long int generate(long int idx, string &s, bool tight, long int lastNumber, bool allZero){
if(idx == s.size())
return 1;
if(dp[idx][tight][lastNumber][allZero] != -1)
return dp[idx][tight][lastNumber][allZero];
long int upper = (tight)? (s[idx] - '0') : 9;
long int ans = 0;
if(idx == 0 || allZero){
for(long int i = 0; i <= upper; i++)
ans += generate(idx + 1, s, tight && (i == upper),i, (allZero && !i));
}
else{
for(long int i = 0; i <= upper; i++){
if(llabs(i - lastNumber) <= 1)
ans += generate(idx + 1, s, tight && (i == upper), i, (allZero && !i));
}
}
return dp[idx][tight][lastNumber][allZero] = ans;
}
int main(){
IOS;
long int n;
cin>>n;
long int be = 0, en = 1e11;
long int ans = 0;
while(be <= en){
long int mid = (be + en) / 2;
memset(dp,-1,sizeof(dp));
string s = to_string(mid);
long int val = generate(0,s,true,0,true) - 1;
if(val >= n){
ans = mid;
en = mid - 1;
}
else
be = mid + 1;
}
cout<<ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
typedef long long ll;
#define ng 100010
typedef pair<ll,ll> pair;
int main(){
ll n;
cin >> n;
ll m = n / 2;
ll even[ng];
ll odd[ng];
ll max1,max2;
max1 = 0;max2 = 0;
ll maxeven,maxodd;
for(ll i = 0; i < ng; i++){
even[i] = 0;
odd[i] = 0;
}
for(ll i = 0; i < n; i++){
ll temp;
cin >> temp;
if(i % 2 == 0){
even[temp]++;
if(max1 < even[temp]){
max1 = even[temp];
maxeven = temp;
}
}
else{
odd[temp]++;
if(max2 < odd[temp]){
max2 = odd[temp];
maxodd = temp;
}
}
}
sort(even,even+ng,greater<>());
sort(odd,odd+ng,greater<>());
ll ans = 0;
if(maxeven != maxodd){
ans = n - max1 - max2;
}
else{
ans = n-max(max1+odd[1],max2+even[1]);
}
cout << ans << endl;
}
| 0
| 9,383,087
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<long>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvb = vector<vector<bool>>;
using vvc = vector<vector<char>>;
using vvl = vector<vector<long>>;
using pii = pair<int, int>;
using pil = pair<int, long>;
using pll = pair<long, long>;
#define fix20 cout << fixed << setprecision(20)
#define YES cout << "Yes" << endl
#define NO cout << "No" << endl
#define rep(i,n) for(int i=0; i<(int)(n);i++)
#define REP(i,s,t) for(int i=s; i<t; i++)
#define RNG(i,s,t,u) for(int i=s; i<t; i+=u)
#define MOD 1000000007
#define all(vec) vec.begin(), vec.end()
struct Edge{
int from;
int to;
long cost;
};
vvl dp(100010,vl(2,-1));
vector<vector<Edge>> Graph(100010);
long dfs(int v, int pv, int w){
if(dp[v][w] != -1) return dp[v][w];
long res = 1;
for(Edge ed : Graph.at(v)){
int nv = ed.to;
if(pv == nv) continue;
if(w) res = (res * (dfs(nv,v,1) + dfs(nv,v,0)) % MOD) % MOD;
else res = (res * dfs(nv,v,1)) % MOD;
}
return dp[v][w] = res;
}
void dfs2(int v, int pv){
dp[v][0] = 1;
dp[v][1] = 1;
for(Edge ed : Graph.at(v)){
int nv = ed.to;
if(pv == nv) continue;
dfs2(nv, v);
dp[v][0] = (dp[v][0] * (dp[nv][0] + dp[nv][1])) % MOD;
dp[v][1] = (dp[v][1] * dp[nv][0]) % MOD;
}
}
int main(){
int n;
cin >> n;
rep(i,n-1){
int x,y;
cin >> x >> y;
x--;y--;
Graph.at(x).push_back({x,y,1});
Graph.at(y).push_back({y,x,1});
}
dfs2(0,-1);
cout << (dp[0][0] + dp[0][1]) % MOD << endl;
}
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <stdexcept>
using namespace std;
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (l" << __line__ << ")" << " " << __file__ << endl
using ll = long long;
using ull = unsigned long long;
const ll mod = 1000000007ll;
template<class ll>
inline ll getceilexponent(ll a)
{
if (a <= 0)
{
throw invalid_argument("vaule equal to or less than 0 should not be valid");
}
ll index = 0;
--a;
for (; a != 0; a >>= 1)
{
++index;
}
return index;
}
template<class ll>
inline ll getfloorexponent(ll a)
{
if (a <= 0)
{
throw invalid_argument("vaule equal to or less than 0 should not be valid");
}
ll index = 0;
a >>= 1;
for (; a != 0; a >>= 1)
{
++index;
}
return index;
}
map<ll, ull> getprimefactorization(ll num)
{
map<ll, ull> primetocount;
int rootnum = sqrt(num);
vector<bool> iscompositenumber(rootnum + 1, false);
for (int p = 2; num != 1 && p <= rootnum; ++p)
{
if (!iscompositenumber[p])
{
for (int i = p * 2; i <= rootnum; i += p)
{
iscompositenumber[i] = true;
}
int count = 0;
while (num % p == 0)
{
++count;
num /= p;
}
if (count >= 1)
{
primetocount.insert(make_pair(p, count));
}
}
}
if (num != 1)
{
primetocount.insert(make_pair(num, 1));
}
return primetocount;
}
template<class ll>
inline ll getgcd(ll a, ll b)
{
if (b == 0)
{
return a;
}
return getgcd(b, a % b);
}
template<class ll>
inline pair<ll, ll> getbezoutsidentitysoulution(ll a, ll b)
{
if (b == 0)
{
return { 1, 0 };
}
auto sol = getbezoutsidentitysoulution(b, a % b);
return { sol.second, sol.first - (a / b) * sol.second };
}
inline ll getmodvalue(ll a, ll m)
{
return (a % m + m) % m;
}
inline ll getmodinverse(ll a, ll m)
{
auto sol = getbezoutsidentitysoulution(a, m);
if (a * sol.first + m * sol.second != 1)
{
return -1;
}
return getmodvalue(sol.first, m);
}
ll getmodcombinatorialnumber(ll n, ll r, ll m)
{
ll res = 1;
for (; n > 0; --n, --r)
{
res = (((res * n) % m) * getmodinverse(n, m)) % m;
}
return getmodvalue(res, m);
}
ll getmodpower(ll base, unsigned t, ll m)
{
if (t == 0)
{
return 1ll;
}
auto res = getmodpower(base, t >> 1, m);
res = getmodvalue(res * res, m);
if (t % 2 == 1)
{
res = getmodvalue(res * base, m);
}
return res;
}
#define moder (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 all(v) v.begin(),v.end()
#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())
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b;
cin >> a >> b;
bool iswhite[50][100];
bool isblack[50][100];
for (ll i = 0; i < 50; ++i)
{
for (ll j = 0; j < 100; ++j)
{
iswhite[i][j] = true;
isblack[i][j] = true;
}
}
ll x = 1, y = 1;
while (--a > 0)
{
iswhite[x][y] = false;
y += 2;
if (y >= 99)
{
y = 1;
x += 2;
}
}
x = 1, y = 1;
while (--b > 0)
{
isblack[x][y] = false;
y += 2;
if (y >= 99)
{
y = 1;
x += 2;
}
}
cout << 100 << " " << 100 << endl;
for (ll i = 0; i < 50; ++i)
{
string tmp;
for (ll j = 0; j < 100; ++j)
{
if (iswhite[i][j])
{
tmp += "#";
}
else
{
tmp += ".";
}
}
cout << tmp << endl;
}
for (ll i = 0; i < 50; ++i)
{
string tmp;
for (ll j = 0; j < 100; ++j)
{
if (isblack[49 - i][j])
{
tmp += ".";
}
else
{
tmp += "#";
}
}
cout << tmp << endl;
}
return 0;
}
| 0
| 35,767,006
|
#include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
typedef long long ll;
typedef long double R;
const R EPS=1e-9L;
inline int sgn(const R& r){return(r > EPS)-(r < -EPS);}
inline R sq(R x){return sqrt(max(x,0.0L));}
const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};
int main() {
int a, b; cin >> a >> b;
if(a+b == 15) cout << "+" << endl;
else if(a*b == 15) cout << "*" << endl;
else cout << "x" << endl;
return 0;
}
|
#include <iostream>
#include <utility>
using namespace std;
int main()
{
int x, y, z;
cin >> x >> y >> z;
if (x > y)
{
swap(x, y);
}
if (y > z)
{
swap(y, z);
}
if (x > y)
{
swap(x, y);
}
cout << x << " " << y << " " << z << endl;
}
| 0
| 96,585,232
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
int main(){
ll n;
cin >> n;
vector<pair<ll,ll>> a(n);
rep(i, 0, n) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a.begin(), a.end());
for(auto e : a) cout << e.second << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <utility>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
vector<pair<int,int>> p(n);
for(int i = 0; n > i; i++)
cin >> p[i].first >> p[i].second;
long long int Min = -1;
for(int i = 0; n > i; i++)
for(int j = 0; n > j; j++)
for(int kk = 0; n > kk; kk++)
for(int l = 0; n > l; l++){
long long int top = p[i].second,btm=p[j].second,lft=p[kk].first,rgt=p[l].first;
int count = 0;
for(int c = 0; n > c; c++){
if(p[c].first >= lft && p[c].first <= rgt && p[c].second >= btm && p[c].second <= top){
count++;
}
}
if(count >= k) {
long long int area = (top - btm) * (rgt - lft);
if(Min == -1 || Min >area) Min = area;
}
}
cout << Min << endl;
return 0;
}
| 0
| 72,615,370
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int X;
cin >> X;
if( X <= 599 ) cout << "8" << endl;
if( (600 <= X) && (X <= 799) ) cout << "7" << endl;
if( (800 <= X) && (X <= 999) ) cout << "6" << endl;
if( (1000 <= X) && (X <= 1199) ) cout << "5" << endl;
if( (1200 <= X) && (X <= 1399) ) cout << "4" << endl;
if( (1400 <= X) && (X <= 1599) ) cout << "3" << endl;
if( (1600 <= X) && (X <= 1799) ) cout << "2" << endl;
if( (1800 <= X) && (X <= 1999) ) cout << "1" << endl;
}
|
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <list>
#include <unordered_set>
#include <tuple>
#include <cmath>
#include <limits>
#include <type_traits>
#include <iomanip>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <regex>
#include <random>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n)for(ll i=0;i<n;++i)
#define exout(x) printf("%.10f\n", x)
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 201010;
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(ll n, ll k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)return 0;
return (x / gcd(x, y) * y);
}
ll dx[4] = { 0,0,-1,1 };
ll dy[4] = { -1,1,0,0 };
char notes[110][10];
ll tre[1010][1010];
int main() {
ll h, w, a, b;
cin >> h >> w >> a >> b;
rep(i, h) {
rep(j, w) {
if (i < h - b) {
if (j < w - a)tre[i][j] = 0;
else {
tre[i][j] = 1;
}
}
else {
if (j < w - a)tre[i][j] = 1;
else {
tre[i][j] = 0;
}
}
}
}
rep(i, h) {
rep(j, w) {
cout << tre[i][j];
}
cout << endl;
}
return 0;
}
| 0
| 85,424
|
#include<stdio.h>
int main()
{
int a[4][3][10]={0},b,f,r,v,n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d %d %d %d",&b,&f,&r,&v);
a[b-1][f-1][r-1]=a[b-1][f-1][r-1]+v;
}
for(int x=0;x<4;x++)
{
for(int y=0;y<3;y++)
{
for(int z=0;z<10;z++)
{
printf(" %d",a[x][y][z]);
}
printf("\n");
}
if(x!=3) printf("####################\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
string S;
cin >> S;
int cnt = 0;
for (char i = '0'; i <= '9'; i++) {
size_t pi = S.find(i);
if (pi == string::npos) { continue; }
for (char j = '0'; j <= '9'; j++) {
size_t pj = S.find(j, pi+1);
if (pj == string::npos) { continue; }
for (char k = '0'; k <= '9'; k++) {
size_t pk = S.find(k, pj+1);
if (pk == string::npos) { continue; }
cnt++;
}
}
}
cout << cnt << endl;
}
| 0
| 59,763,597
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <string>
#include <cmath>
#include <complex>
#include <numeric>
#include <cassert>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <utility>
#define PI 3.14159265358979323846
#define int64 long long
#define uint64 unsigned long long
#define coutfix(i) cout << fixed << setprecision(i)
using namespace std;
int main()
{
int64 nn, ans = 0, frb = 0, baa = 0, ba = 0;
cin >> nn;
string ss;
for(int64 ii = 0;ii < nn;ii++)
{
cin >> ss;
for(int64 jj = 0;jj < ss.length() - 1;jj++)
{
if(ss.substr(jj, 2) == "AB")
{
ans++;
}
}
if(ss[0] == 'B' && ss[ss.length() - 1] == 'A')
{
ba++;
}
else if(ss[0] == 'B')
{
frb++;
}
else if(ss[ss.length() - 1] == 'A')
{
baa++;
}
}
int64 tmp = frb + baa;
if(tmp == 0)
{
cout << (ans + (int64)max((int64)0, ba - 1)) << endl;
}
else
{
if(ba == 0)
{
cout << (ans + (int64)min(frb, baa)) << endl;
}
else
{
cout << (ans + ba + (int64)min(frb, baa)) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string reverseStr(string target)
{
string retStr = "";
for (int i = target.length() - 1; i >= 0; i--) {
retStr += target[i];
}
return retStr;
}
int main()
{
string S;
cin >> S;
if (S != reverseStr(S)) {
cout << "No" << endl;
return 0;
}
int cnt = (S.length() - 1) / 2;
string str = S.substr(0, cnt);
if (str != reverseStr(str)) {
cout << "No" << endl;
return 0;
}
cnt = (S.length() + 3) / 2;
str = S.substr(cnt - 1, S.length());
if (str != reverseStr(str)) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
}
| 0
| 87,469,598
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
using namespace std;
int main(){
string str, p;
cin >> str >> p;
str += str;
if(str.find(p) < str.size()){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
int H[N];
for(int i = 0; i < N; i++) cin >> H[i];
int max = 0, sea = 0;
for (int i = 0; i < N; i++)
{
if(max <= H[i]) {
max = H[i];
sea++;
}
}
cout << sea << endl;
return 0;
}
| 0
| 52,794,630
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, K;
int main(){
cin >> N >> K;
vector<ll> A(N);
for ( int i = 0; i < N; i++ ){
ll a;
cin >> a;
A[i] = (a-1+K)%K;
}
vector<pair<ll,ll>> Asum(N+1);
ll sum = 0;
for ( int i = 0; i < N; i++ ){
Asum[i] = {sum,i};
sum = (sum+A[i])%K;
}
Asum[N] = {sum,N};
sort(Asum.begin(), Asum.end(),[](pair<ll,ll> l, pair<ll,ll> r){return (l.first*N*2+l.second)<(r.first*N*2+r.second);});
ll count = 0;
for ( int i = 0; i <= N; ){
int ct = 1;
while ( i+ct <= N && Asum[i].first == Asum[i+ct].first )
ct++;
if ( ct >= 2 ){
int j = i+1;
for ( int i0 = i; i0 < i+ct; i0++ ){
while ( j < i+ct && (Asum[j].second-Asum[i0].second) < K )
j++;
count += (j-i0-1);
}
}
i += ct;
}
cout << count << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main()
{
int a, b;
while (cin >> a >> b, a != 0 || b != 0) {
for (int i = 0; i < a; ++i)
{
for (int j = 0; j < b; ++j)
{
cout << '#';
}
cout << endl;
}
cout << endl;
}
return 0;
}
| 0
| 36,791,838
|
#include <bits/stdc++.h>
using namespace std;
int main(){
double x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
printf("%.10f\n", sqrt(pow(x1-x2, 2) + pow(y1-y2, 2)));
}
|
#include<bits/stdc++.h>
using namespace std;
#define bug printf("bug\n");
#define bug2(var) cout<<#var<<" "<<var<<endl;
#define co(q) cout<<q<<endl;
#define all(q) (q).begin(),(q).end()
typedef long long int ll;
typedef unsigned long long int ull;
const int MOD = (int)1e9+7;
const int MAX = 1e6;
#define pi acos(-1)
#define inf 1000000000000000LL
#define FastRead ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int arr[500];
int main()
{
FastRead
int n,cnt=0;
cin>>n;
for(int i=0; i<n; i++)
{
cin>>arr[i];
}
while(1)
{
int res=0,f=0;
for(int i=0; i<n; i++)
{
if(arr[i])
{
arr[i]--;
res=1;
}
else if(res)
{
f=1;
res=0;
cnt++;
}
}
if(res)
cnt++,f=1;
if(!f)
break;
}
cout<<cnt<<endl;
return 0;
}
| 0
| 9,624,128
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
int r,l;
int rmax = 0, lmin = n;
vector<int> c(n+1);
for(int i = 0; i < m; ++i){
cin >> r >> l;
rmax = max({rmax,r});
lmin = min({lmin,l});
}
int res = max({lmin-rmax+1,0});
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define rep(i, m, n) for (lli i = m; i < (n); i++)
#define repe(i, m, n) for (lli i = m; i <= (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((lli)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define _GLIBCXX_DEBUG
const lli INF = 2147483647;
const lli MINF = -2147483648;
const lli LINF = 9223372036854775807;
const lli MOD = 1000000007;
const double PI = acos(-1);
#define SORT(n) sort(n.begin(), n.end())
#define SORTR(n) sort(n.begin(), n.end(), greater<int>())
#define REV(n) reverse(n.begin(), n.end())
#define pb push_back
#define eb emplace_back
#define mp make_pair
#pragma GCC optimize("Ofast")
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vlli = vector<lli>;
using vvli = vector<vlli>;
using vs = vector<string>;
using vvs = vector<vs>;
using vb = vector<bool>;
using vvb = vector<vb>;
using ll = long long;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec)
{
for (T &x : vec)
is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &vec)
{
for (int i = 0; i < vec.size(); i++)
{
os << vec[i] << (i + 1 == vec.size() ? "" : "");
}
return os;
}
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;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
lli a, b, c, h, n, w, ans = 0, count = 0;
string s, t;
vector<pair<string, pair<lli, lli>>> pr;
cin >> n >> a >> b;
if (a > b)
{
cout << 0 << endl;
}
else if (n == 1 && a != b)
{
cout << 0 << endl;
}
else if (n == 1 && a == b)
{
cout << 1 << endl;
}
else
{
c = b - a + 1;
ans = c * (n - 2) - (n - 3);
cout << ans << endl;
}
}
| 0
| 49,977,371
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
unsigned long long res = N;
res *= N - 1;
res >>= 1;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll>PLL;
#define rep(i,n) for (int i = 0; i < (n); ++i)
ll MOD = 1e4+7;
int main() {
ll x, y;
cin >> x >> y;
if ( x % y == 0 ) {
cout << -1 << endl;
return 0;
}
ll mult_num = 2;
while ( 1 ) {
if ( x * mult_num > 1e18 ) {
cout << -1 << endl;
return 0;
}
if ( ( x * mult_num ) % y != 0 ) break;
++mult_num;
}
cout << x * mult_num << endl;
return 0;
}
| 0
| 86,128,355
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
using namespace std;
int main() {
int a,b,c,d,x;
double da,db;
string s,ss,sss;
int ans = 0;
string anss = "";
cin >> a >> b;
int ab [] = {0 , 1 , 3 , 1 , 2 , 1 , 2 , 1 , 1 , 2 , 1 , 2 , 1};
int result3 = std::max({a, b, c});
if(a<9 && b < 9) anss = "Yay!";
else anss = ":(";
cout << anss << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXV = 100;
const ll INF = (1LL<<60);
int V, E;
ll adjMat[MAXV][MAXV];
int main(){
scanf("%d%d",&V,&E);
for (int i = 0; i < V; i++)
for(int j = 0; j < V; j++)
adjMat[i][j] = INF;
for (int i = 0, s, t, d; i < E; i++) {
scanf("%d%d%d",&s,&t,&d);
adjMat[s][t] = d;
}
for (int k = 0; k < V; k++)
for (int i = 0; i < V; i++)
for (int j = 0;j < V; j++)
if (adjMat[i][k] != INF && adjMat[k][j] != INF)
adjMat[i][j] = min(adjMat[i][j],adjMat[i][k]+adjMat[k][j]);
for (int i = 0; i < V; i++) {
if (adjMat[i][i] < 0) {
printf("NEGATIVE CYCLE\n");
return 0;
}
}
for (int i = 0; i < V; i++){
for (int j = 0; j < V; j++){
if (j)
printf(" ");
if (i == j)
printf("0");
else if (adjMat[i][j] >= INF)
printf("INF");
else
printf("%lld",adjMat[i][j]);
}
printf("\n");
}
return 0;
}
| 0
| 95,650,539
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <limits>
#include <iomanip>
#include <vector>
#include <cstring>
#include <queue>
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uld = unsigned long long;
const ll mod = 1e9+7;
const int dx[4] = {0,1,0,-1};
const int dy[4] = {1,0,-1,0};
template<class T> inline bool chmax(T &a,T& b){if(a < b){a = b; return true;} else return false;}
template<class T> inline bool chmin(T &a,T& b){if(a > b){a = b; return true;} else return false;}
int main(){
string s;
cin >> s;
int n = s.size();
int a1=0,a2=0;
rep(i,n){
int k = s[i] - '0';
if(k==i%2) a1++;
else a2++;
}
cout << min(a1,a2) << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long int;
#define rep(i,n) for(int i=0;i<(n);i++)
int main(){
ll n;
ll k;
cin>>n>>k;
vector<pair<ll,ll>>c(n);
rep(i,n)cin>>c[i].first>>c[i].second;
sort(c.begin(),c.end());
for(int i=1;i<n;i++)c[i].second=c[i-1].second+c[i].second;
ll ans=c[0].first;
for(int i=0;i<n;i++){
if(c[i].second>=k){
ans=c[i].first;
break;
}
}
cout<<ans<<endl;
}
| 0
| 39,384,604
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int pre[100005];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
int n;
cin>>n;
int a[n+1];
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
sort(a+1,a+n+1);
int sum=a[1];
for(int i=2;i<=n;i++)
{
int z=a[i]-2*sum;
int l=1,r=n;
int mn=n+1;
while (l<=r)
{
int mid=l+(r-l)/2;
if(a[mid]>=z)
{
r=mid-1;
mn=min(mn,mid);
}
else
{
l=mid+1;
}
}
if(z>0)
{
pre[1]++;
mn=max(mn,i);
pre[mn]--;
}
sum+=a[i];
}
int ans=0;
if(a[1]*2>=a[2]&& pre[1]==0)
ans++;
for(int i=2;i<=n;i++)
{
pre[i]+=pre[i-1];
if(pre[i]==0)
{
ans++;
}
}
cout<<ans;
}
|
#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ull=unsigned long long int;
using P=pair<ll,ll>;
template<class T> using V=vector<T>;
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
const ll inf=(1e18);
const ll mod=1000000007;
ll gcd(ll a,ll b) {return b ? gcd(b,a%b):a;}
ll lcm(ll c,ll d){return c/gcd(c,d)*d;}
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
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 main(){
while(1){
int d;
cin>>d;
if(d==0)return 0;
multiset<P> dat;
for(int i=0;i<d;i++){
string s,t;
cin>>s>>t;
ll a=0,b=0;
ll n=ll(s[0]-'0'),m=ll(t[0]-'0');
n*=10;m*=10;
n+=ll(s[1]-'0'),m+=ll(t[1]-'0');
a+=3600*n,b+=3600*m;
n=0,m=0;
n+=ll(s[3]-'0'),m+=ll(t[3]-'0');
n*=10;m*=10;
n+=ll(s[4]-'0'),m+=ll(t[4]-'0');
a+=60*n,b+=60*m;
n=0,m=0;
n+=ll(s[6]-'0'),m+=ll(t[6]-'0');
n*=10;m*=10;
n+=ll(s[7]-'0'),m+=ll(t[7]-'0');
a+=n;b+=m;
dat.insert({a,b});
}
int ans=0;
while(dat.size()){
ll bfo=-1;
ans++;
for(auto ite=dat.begin();ite!=dat.end();){
if(bfo<=(*ite).fi){
bfo=(*ite).se;
ite=dat.erase(ite);
}else ite++;
}
}
cout<<ans<<"\n";
}
}
| 0
| 4,326,153
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9+7;
int main(){
int a,b,m;
cin >> a >> b >> m;
vector<int> A(a),B(b);
int mna = mod,mnb = mod;
for(int i = 0; i < a; i++){
cin >> A[i];
mna = min(mna,A[i]);
}
for(int i = 0; i < b; i++){
cin >> B[i];
mnb = min(mnb,B[i]);
}
ll ans = mna+mnb;
for(int i = 0; i < m; i++){
int y,x,c;
cin >> x >> y >> c;
x--;y--;
int mon = A[x]+B[y]-c;
if(ans > mon) ans = mon;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define fastio ios::sync_with_stdio(false); cin.tie(NULL)
#define testcases freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout)
#define ui unsigned int
#define ll long long
#define pb push_back
#define vi vector<int>
#define vvi vector<vector<int>>
#define vll vector<ll>
#define vvll vector<vector<ll>>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sz(x) (int)x.size()
#define pq priority_queue
#define pqmax priority_queue<int, vector<int>, greater<int>>
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define asc(x) sort(all(x))
#define desc(x) sort(all(x), greater<int>())
#define time_el (double)time/CLOCKS_PER_SEC
using namespace std;
const int MAX=2e6;
const ll M=1e9+7, inf=1e18;
const char nl='\n';
ll apbmc(ll a, ll b, ll c){ a%=c; ll res=1; while(b){ if(b&1) res=res*a%c; a=a*a%c; b>>=1; } return res;}
ll apb(ll x, ll y){ ll temp; if(y==0) return 1; temp=apb(x, y/2); if(y%2==0) return temp*temp; else return temp*temp*x;}
void solve(){
int n, k; cin>>n>>k;
vi v(n);
for(int &i: v) cin>>i;
vll dp(n, M);
dp[0]=0;
for(int i=0; i<n; i++){
for(int j=1; j<=k; j++){
if(i-j>=0){
dp[i]=min(abs(v[i]-v[i-j]) + dp[i-j], dp[i]);
}
}
}
cout<<dp[n-1];
}
int main(){
fastio;
cout<<fixed<<setprecision(9);
solve();
return 0;
}
| 0
| 909,032
|
#include <iostream>
#include <vector>
#include <cmath>
int main(void){
int N, D, ans=0;
std::cin >> N >> D;
std::vector<std::vector<int>> X(N, std::vector<int>(D));
for (int i=0; i<N; ++i){
for (int j=0; j<D; ++j){
std::cin >> X.at(i).at(j);
}
}
for (int i=0; i<N-1; ++i){
for (int j=i+1; j<N; ++j){
int tmp = 0;
for (int k=0; k<D; ++k){
tmp += (X.at(i).at(k) - X.at(j).at(k)) * (X.at(i).at(k) - X.at(j).at(k));
}
double d = sqrt(tmp);
if (tmp == (int)d * (int)d) ++ans;
}
}
std::cout << ans << std::endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int p[105];
int x,n,t;
int main(){
cin>>x>>n;
for(int i=0;i<n;++i)
{
cin>>t;
p[t]=1;
}
int min=1005,ans=0;
for(int i=0;i<=101;++i)
{
if((!p[i])&&abs(i-x)<min)
{
min=abs(i-x);
ans=i;
}
}
cout<<ans<<"\n";
}
| 0
| 32,710,448
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
using vvll = vector<vector<ll>>;
ll mod =1e9+7;
template<typename TypeInt> string itob(const TypeInt v, int base){static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";string ret;static numeric_limits<TypeInt> t;TypeInt n = v;if (t.is_signed) {if (v < 0) n *= -1;}while (n >= base) {ret += table[n%base];n /= base;}ret += table[n];if (t.is_signed) {if (v < 0 && base == 10) ret += '-';}reverse(ret.begin(), ret.end());return ret;}
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; }
int ctoi(char c) {return c-'0';}
ll gcd(ll a,ll b){if(b==0)return a; return gcd(b,a%b);}
ll lcm(ll a,ll b){ll g = gcd(a,b);return a/g*b;}
bool primecheck(ll n){if(n < 2) return false;else{for(int i = 2; i * i <= n; i++){if(n % i == 0) return false;}return true;}}
string reverserange(string s,ll a,ll b){reverse(s.begin()+a-1,s.begin()+b); return s;}
ll modpow(ll a,ll n, ll mod){ll res = 1;while(n>0){if (n%2==1){res = res * a % mod;}a = a * a % mod;n/=2;}return res;}
int main() {
string s,t;
cin >>s >>t;
ll ans = 0;
for(int i=0;i<s.size();i++){
if(s.at(i)==t.at(i))ans++;
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll m[101][101];
vector<ll> p;
int main() {
int n;
cin >> n;
ll a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (i == 0)
p.push_back(a);
p.push_back(b);
}
for (int i = 0; i < n; i++)
m[i][i] = 0;
for (int l = 1; l < n; l++) {
for (int i = 0; i < n - l; i++) {
int j = i + l;
m[i][j] = (1 << 21);
for (int k = i; k < j; k++) {
ll q = m[i][k] + m[k+1][j] + p[i] * p[k+1] * p[j+1];
if( q < m[i][j] )
m[i][j] = q;
}
}
}
cout << m[0][n-1] << '\n';
}
| 0
| 4,279,649
|
#include <iostream>
using namespace std;
int main()
{
int a,b,x;
cin>>a>>b>>x;
if(x>a)
{
if(a+b>=x)
{
cout<<"YES";
}
else if(a+b<x)
{
cout<<"NO";
}
}
else if(x<a)
{
cout<<"NO";
}
else if(x==a)
{
cout<<"YES";
}
}
|
#include <bits/stdc++.h>
#define uni(x) (x).resize(unique(ALL(x)) - (x).begin())
#define fprint(v) for(auto x : v) cout << x << ' '
#define ALL(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846
#define MP(x, y) make_pair(x, y)
#define SZ(x) int((x).size())
#define PB(x) push_back(x)
#define ld long double
#define ll long long
#define S second
#define F first
#define nl '\n'
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
mt19937_64 rnd;
const int N = 2e5 + 5;
ll bit[N];
void upd(int idx, ll val){
for(; idx < N; idx += idx & -idx){
bit[idx] += val;
}
}
ll sum(ll idx){
ll res = 0;
for(; idx > 0; idx -= idx & -idx){
res += bit[idx];
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);cin.tie(0);
ll n, k;
cin >> n >> k;
map<ll, ll> mp;
for(int i = 0; i < n; i++){
int a, b;
cin >> a >> b;
upd(a, b);
}
ll lo = 0, hi = 1e5 + 1;
while(hi - lo > 1){
ll mid = lo + hi >> 1;
ll yo = sum(mid);
ll yo1 = sum(mid - 1);
if(yo1 < k && k <= yo){
cout << mid;
break;
}else if(k > yo) lo = mid;
else hi = mid;
}
return 0;
}
| 0
| 7,970,640
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m=1,min,k;
cin>>n;
int r[n];
cin>>r[0];
min=r[0];
for(int i=1;i<n;i++){
cin>>r[i];
k=r[i];
if(k<min){
min=k;
m++;
}
}
cout<<m;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i,f,n) for(int i=f; i<(n); i++)
int main()
{
int n, q;
cin >> n >> q;
vector<int> ki[n];
int ki_p[n] = {0};
REP(i,0,n-1){
int a, b;
cin >> a >> b;
a--;
b--;
ki[a].push_back(b);
ki[b].push_back(a);
}
REP(i,0,q){
int a, b;
cin >> a >> b;
a--;
ki_p[a] += b;
}
queue<pair<int,int>> aa;
aa.push({0,-1});
while(aa.size()>0){
int i = aa.front().first;
for(int j:ki[i]){
if(aa.front().second == j)continue;
ki_p[j] += ki_p[i];
aa.push({j,i});
}
aa.pop();
}
REP(i,0,n){
cout << ki_p[i] << " ";
}
cout << endl;
return 0;
}
| 0
| 82,886,627
|
#include <bits/stdc++.h>
#define PI 3.14159265359
#define rep(i,a,n) for(int i=a;i<(int)n;++i)
#define SZ(x) ((int)(x).size())
#define descsort(a) sort(a.begin(),a.end(),std::greater<int>())
using namespace std;
typedef long long ll;
const ll INF = 1e9 + 7;
int main(void)
{
int d,t,s;
cin>>d>>t>>s;
if(t*s>=d)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
|
#include <math.h>
#include <ctype.h>
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, n) for (int i = a; i < n; i++)
#define REP(i, n) for(int i = 0; i < n; i++)
struct omt{omt(){ios::sync_with_stdio(false);cin.tie(0);}}star;
int main(){
int n;
cin >> n;
list<int> A;
string s;
int tmp;
REP(i, n){
cin >> s;
if(s == "insert"){
cin >> tmp;
A.push_front(tmp);
}else if(s == "delete"){
cin >> tmp;
for(auto itr = A.begin(); itr != A.end(); ++itr){
if(*itr == tmp){
A.erase(itr);
break;
}
}
}else if(s == "deleteFirst") A.pop_front();
else if(s == "deleteLast") A.pop_back();
}
vector<int> B;
for(auto itr = A.begin(); itr != A.end(); ++itr){
B.push_back(*itr);
}
REP(i, B.size()){
if(i != B.size() - 1) cout << B[i] << " ";
else cout << B[i] << endl;
}
return 0;
}
| 0
| 67,077,199
|
#include <bits/stdc++.h>
#define rep(i, a) for(int i = 0; i < a; i++)
#define all(v) v.begin(), v.end()
#define dcout cout << fixed << setprecision(15)
#define arep(i, a) for(auto i : a)
#define F first
#define S second
#define VE vector<int>
#define pb(x) push_back(x)
#define MOD 1000000007
#define INF 10000000000
#define int long long
#define KETA(n) floor(log10(n) + 1)
using namespace std;
signed main() {
char a, b;
cin >> a >> b;
if(a == b)
cout << "=";
else if(a < b)
cout << "<";
else
cout << ">";
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int n, i, x, y, j, ok;
int c[100005];
vector<int> v[100005];
void dfs(int nod, int t){
for(int i = 0; i < v[nod].size(); i++){
int vecin = v[nod][i];
if(vecin != t){
dfs(vecin, nod);
if(c[vecin] == 0){
if(c[nod] == 1){
ok = 0;
}
c[nod] = 1;
}
}
}
}
int main(){
cin>> n;
for(i = 1; i < n; i++){
cin>> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
ok = 1;
dfs(1, 0);
if(c[1] == 0){
ok = 0;
}
if(ok == 0){
cout<<"First";
}
else{
cout<<"Second";
}
}
| 0
| 54,961,813
|
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
const int N=200005;
long long sum,a[N],n,l=1,r=1,tmp=0;
int main() {
scanf("%lld",&n);
for(int i=1; i<=n; i++) scanf("%lld",&a[i]);
while(r<=n) {
while( ( (a[r]^tmp) == (a[r]+tmp) )&& r<=n) tmp^=a[r],r++;
if(r!=n+1) sum+=r-l;
else sum+=(r-l)*(r-l+1)/2;
tmp^=a[l++];
}
printf("%lld\n",sum);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
set<int> unique;
for (int i = 0; i < n; i++) {
unique.insert(a[i]);
}
int m = (int) unique.size();
if ((n & 1) && (m & 1)) {
cout << m << endl;
}
else {
cout << m - 1 << endl;
}
return 0;
}
| 0
| 75,943,467
|
#include <numeric>
#include <bits/stdc++.h>
using namespace std;
int main() {
string N;
int K,counter=0;
cin >>N>>K;
if(N.size()==1){
cout<<N.at(0)<<endl;}
else{
for(int i=0;i<N.size();i++){
if(N.at(counter)=='1'){
counter++;
continue;}
else break;}
if(K<=counter)
cout<<1<<endl;
else
cout<<N.at(counter)<<endl;}}
|
#include <iostream>
#include <stdio.h>
#include <cctype>
#include <cmath>
#include <math.h>
using namespace std;
struct cubes {
int n;
int e;
int w;
int s;
int t;
int b;
};
void spin(cubes* cube){
int tmp;
tmp = cube->n;
cube->n = cube->e;
cube->e = cube->s;
cube->s = cube->w;
cube->w = tmp;
}
void roll(cubes* cube, char dst){
int tmp;
switch(dst){
case 'N' :
tmp = cube->b;
cube->b = cube->n;
cube->n = cube->t;
cube->t = cube->s;
cube->s = tmp;
break;
case 'E' :
tmp = cube->b;
cube->b = cube->e;
cube->e = cube->t;
cube->t = cube->w;
cube->w = tmp;
break;
case 'W' :
tmp = cube->b;
cube->b = cube->w;
cube->w = cube->t;
cube->t = cube->e;
cube->e = tmp;
break;
case 'S' :
tmp = cube->b;
cube->b = cube->s;
cube->s = cube->t;
cube->t = cube->n;
cube->n = tmp;
break;
default : break;
}
}
int main(){
cubes cube;
int cnt=0;
int a,b,n;
cin >> cube.t >> cube.s >> cube.e >> cube.w >> cube.n >> cube.b;
cin >> n;
for(int i=0;i<n;i++){
cin >> a >> b;
cnt=0;
while(cube.t!=a){
roll(&cube,'S');
cnt++;
if(cnt>3){
cnt=0;
spin(&cube);
}
}
while(cube.s!=b){
spin(&cube);
}
cout << cube.e << endl;
}
}
| 0
| 88,646,128
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
typedef long long LL;
#ifdef LOCAL
#include "contest.h"
#else
#define error(args...)
#endif
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool valid(int x, int w) { return 0 <= x && x < w; }
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(12);
}
int main(){
iostream_init();
int m, n1, n2;
while(cin >> m >> n1 >> n2 && m != 0) {
vector<int> P(m);
REP(i, m) cin >> P[i];
int max_diff = -1;
int ans = -1;
for(int i = n1; i <= n2; i++) {
int diff = P[i-1] - P[i];
if(diff >= max_diff) {
max_diff = diff;
ans = i;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <stdio.h>
#include <string.h>
int main()
{
char S[255],T[255];
scanf("%s%s",S,T);
strcat(T,S);
printf("%s",T);
return 0;
}
| 0
| 51,541,277
|
#define _USE_MATH_DEFINES
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <complex>
#include <cmath>
#include <numeric>
#include <bitset>
#include <functional>
#include <random>
#include <ctime>
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
typedef long long int64;
typedef pair<int, int> ii;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
int main() {
int n;
cin >> n;
cout << (n - 2) * 180 << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define first ff
#define second ss
#define ll long long int
int main()
{
int n;
cin>>n;
ll a[n+5],b[n+5];
for(int i=0; i<=n; i++)
cin>>a[i];
for(int i=0; i<n; i++)
cin>>b[i];
ll sum=0;
for(int i=0; i<n; i++)
{
if(a[i]>b[i]){sum+=b[i];b[i]=0;}
else {sum+=a[i];b[i]-=a[i];}
if(b[i])
{
if(a[i+1]>b[i]){sum+=b[i];a[i+1]-=b[i];}
else {sum+=a[i+1];a[i+1]=0;}
}
}
cout<<sum<<endl;
}
| 0
| 100,823,807
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#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++)
const ll MAX = 1001001;
const ll MOD = 1000000007;
int main()
{
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n)
{
cin >> a[i];
}
vector<ll> p(n + 1), x(n + 1);
rep(i, n)
{
p[i + 1] = p[i] + a[i];
x[i + 1] = x[i] ^ a[i];
}
vector<vector<ll>> d(n + 1, vector<ll>(20));
ll s = 0;
ll t = 0;
ll ans = 0;
rep(i, n)
{
rep(j, 20)
{
d[i + 1][j] = d[i][j] + ((a[i] >> j) & 1);
}
}
while (t < n)
{
bool ex = true;
rep(i, 20)
{
if (d[t + 1][i] - d[s][i] > 1)
{
ex = false;
}
}
if (ex)
{
ans += t - s + 1;
t++;
}
else
{
s++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<string> w(n);
rep(i, n) {
cin >> w[i];
}
set<string> st;
st.insert(w[0]);
bool ok = true;
for (int i = 1; i < n; i++) {
if (w[i - 1].back() != w[i].front()) {
ok = false;
}
if (st.count(w[i])) {
ok = false;
}
st.insert(w[i]);
}
if (ok) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
| 0
| 40,096,453
|
#include <iostream>
#include <vector>
#include<algorithm>
#include<string>
#include<stdio.h>
#include<map>
#include<math.h>
#include<queue>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
int main() {
string s, t;
cin >> s >> t;
if (s.size() > t.size())cout << "GREATER" << endl;
else if (s.size() < t.size())cout << "LESS" << endl;
else {
for (int i = 0; i < s.size(); i++) {
if (s[i]-'0' > t[i]-'0') {
cout << "GREATER" << endl;
return 0;
}
else if (s[i] -'0'< t[i]-'0') {
cout << "LESS" << endl;
return 0;
}
}
cout << "EQUAL" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pb push_back
const int maxn=2e5+10;
const int mod=1e9+7;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n,k;
cin>>n>>k;
int cnt=0;
for(int i=1;i<=n;i++)
{
int x;
cin>>x;
if(x>=k)
cnt++;
}
cout<<cnt<<'\n';
}
| 0
| 72,425,603
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9+7;
ll dp[100004][2];
int main()
{
string s;
cin >> s;
int n = s.size();
dp[0][1] = 1;
for(int i = 0;i<n;i++)
{
if(s[i]=='0')
{
(dp[i+1][0] += dp[i][0]*3)%=MOD;
(dp[i+1][1] += dp[i][1]);
}
else
{
(dp[i+1][0] += dp[i][0]*3)%=MOD;
(dp[i+1][1] += dp[i][1]*2)%=MOD;
(dp[i+1][0] += dp[i][1]);
}
}
cout<<(dp[n][1]+dp[n][0])%MOD<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define mod(cans) cans%10**9+7
#define debug(x) cout << "Debug" << x << "\n"
#define rep(i,n) for(unsigned i=0;i<n;i++)
#define repr(i,n) for(unsigned i=n-1;i>=0;i--)
#define rep1(i,n) for(unsigned i=1;i<=n;i++)
#define cin_pl(n,x) rep(i,n){cin>>x[i];}
#define cins(s,n) rep(i,n)cin>>s.at[i];
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define prians(Answer) cout<<Answer<<"\n"
#define TF(X) X==1?cout<<"YES\n":cout<<"NO\n"
#define elcon else{continue;}
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<string> vs;
typedef vector<vector<int> > matrix;
typedef pair<int,int> pii;
typedef vector<pii> vpi;
typedef greater<int> gi;
typedef vector<unsigned> vu;
ll gcd(ll x, ll y) { return (y == 0) ? x : gcd(y, x % y); }
bool is_prime(const unsigned n){
switch(n){
case 0:
case 1: return false;
case 2: return true;
}
for(unsigned i=2;i<n;++i){
if(n%i == 0) return false;
}
return true;
}
bool F(string s,string t,string u)
{
if(s[s.length()-1]==t[0]&&t[t.length()-1]==u[0])return true;
return false;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
string s,t,u;cin>>s>>t>>u;
TF(F(s,t,u));
}
| 0
| 26,155,122
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define pii pair<ll int,ll int>
#define vpii vector< pii >
#define vi vector<ll int>
#define vs vector< string >
#define vvi vector< vector< ll > >
#define inf (ll)1e18
#define all(it,a) for(auto it=(a).begin();it!=(a).end();it++)
#define F first
#define S second
#define sz(x) (ll int)x.size()
#define rep(i,a,b) for(ll int i=a;i<b;i++)
#define repr(i,a,b) for(ll int i=a;i>b;i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define mp make_pair
#define whatis(x) cout << #x << " is " << x << "\n";
#define graph(n) adj(n,vector< ll > () )
int solve()
{
ll n;cin>>n;
map<string,ll> sg;
vi t(n);
rep(i,0,n)
{
string s;cin>>s;
cin>>t[i];
sg[s]=i+1;
}
string x;cin>>x;
all(it,sg)
{
if(it->F==x)
{
ll ans=0;
rep(i,it->S,n) ans+=t[i];
cout<<ans<<"\n";
return 0;
}
}
return 0;
}
int main()
{
auto start = chrono::high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll test_cases=1;
while(test_cases--)
solve();
auto stop = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::milliseconds>(stop-start);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
typedef vector<int> vec;
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
void solve() {
int N; cin >> N;
int a=0, b=0, ba=0;
ll res = 0;
vector<string> sv(N);
rep(i, N) cin >> sv[i];
for(auto s: sv){
if(s[0] != 'B' && s.back() == 'A') a++;
if(s[0] == 'B' && s.back() != 'A') b++;
if(s[0] == 'B' && s.back() == 'A') ba++;
}
for(auto s: sv){
rep(i, (int)s.size()-1){
if(s[i] == 'A' && s[i+1] == 'B') res++;
}
}
if(a > 0){
a--; ba++;
}
if(b > 0){
b--; ba++;
}
if(a == 0 && b == 0 && ba == 0 ){
cout << res << endl;
return;
}
res += ba-1 + min(a, b);
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 0
| 33,138,538
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL<<61;
template<class T>bool chmax(T &a, const T &b) {
if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) {
if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;}
int main(){
int n;
cin>>n;
vector<ll> c(n-1);
vector<ll> s(n-1);
vector<ll> f(n-1);
rep(i,n-1){
cin>>c[i]>>s[i]>>f[i];
}
rep(i,n){
ll ans=0;
for(int j=i;j<n-1;j++){
if(ans<=s[j]) ans=s[j];
else ans=((ans+f[j]-1)/f[j])*f[j];
ans+=c[j];
}
cout << ans << endl;
}
}
|
#include<bits/stdc++.h>
#define mod 1000000007
using namespace std;
int dy[4]={1,0,-1,0};
int dx[4]={0,1,0,-1};
vector<vector<int>> graph;
bool sort_sec(const pair<int,int> &a,const pair<int,int> &b){
if(a.second<b.second){
return true;
}
return false;
}
void swap(int *a,int *b){
int temp=*a;
*a=*b;
*b=temp;
}
int main(void){
long long K,A,B;
cin>>K>>A>>B;
long long ans=1;
long long money=0;
long long temp=0;
while(1){
if(temp==K) break;
if(money>=1){
ans+=B*money;
money--;
}else{
if(ans>=A&&(K-temp)>1){
ans=ans-A;
money++;
}else{
ans++;
}
}
temp++;
}
cout<<max(1+K,ans)<<endl;
return 0;
}
| 0
| 36,046,651
|
#include<iostream>
#include<queue>
#include<ctype.h>
#include<cstdio>
using namespace std;
int H,W,sum,count;
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
struct node
{
int x,y;
int step;
int color;
char data;
}*map,now,next;
void BFS(int x,int y)
{
queue<node>q;
q.push(map[x*W+y]);
while(!q.empty())
{
now=q.front();
q.pop();
for(int i=0;i<4;i++)
{
next.x=now.x+dir[i][0];
next.y=now.y+dir[i][1];
if(next.x>=0&&next.y>=0&&next.x<H&&next.y<W&&map[next.x*W+next.y].data!='X'&&map[next.x*W+next.y].color<count)
{
map[next.x*W+next.y].step=now.step+1;
if(int(map[next.x*W+next.y].data-'0')==count)
{
count++;
map[next.x*W+next.y].data='.';
if(count>sum)
{
cout<<map[next.x*W+next.y].step<<endl;
return;
}
map[next.x*W+next.y].color=count;
BFS(next.x,next.y);
}
else
{
map[next.x*W+next.y].color=count;
q.push(map[next.x*W+next.y]);
}
if(count>sum)return;
}
}
}
}
int main()
{
while(cin>>H>>W>>sum)
{
map=new node[H*W];
for(int i=0;i<H;i++)
{
for(int j=0;j<W;j++)
{
cin>>map[i*W+j].data;
map[i*W+j].x=i;
map[i*W+j].y=j;
map[i*W+j].color=0;
if(map[i*W+j].data=='S')
{
now.x=i;
now.y=j;
}
}
}
count=1;
map[now.x*W+now.y].step=0;
map[now.x*W+now.y].color=1;
map[now.x*W+now.y].data='.';
BFS(now.x,now.y);
}
return 0;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
int parent[100000];
int r[100000];
void init(int n){
for(int i = 0;i < n;i++){
parent[i] = i;
r[i] = 0;
}
}
int find(int x){
if(parent[x] == x) return x;
else return parent[x] = find(parent[x]);
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return ;
if(r[x] < r[y]) parent[x] = y;
else{
parent[y] = x;
if(r[x] == r[y]) r[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
int main(){
int n, q, com, x, y;
cin >> n;
init(n);
cin >> q;
for(int i = 0;i < q;i++){
cin >> com >> x >> y;
if(com == 0) unite(x, y);
if(com == 1) cout << same(x, y) << endl;
}
return 0;
}
| 0
| 29,862,751
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s,s1;
cin>>s>>s1;
char key[s.length()+1] ;
strcpy(key, s.c_str());
char flagment[s1.length()+1] ;
strcpy(flagment, s1.c_str());
int n = s.length()-s1.length();
for ( int i=n; i>= 0 ;i--) {
bool temp = true ;
for ( int j= 0 ;j<s1.length(); j++) {
if (key[i+j]!= '?' && key[i+j]!=flagment[j]) {
temp = false ;
break ;
}
}
if (temp == true ){
for ( int j= 0 ;j<s1.length(); j++) {
key[i+j] = flagment[j];
}
for ( int j= 0 ;j<s.length(); j++) {
cout<<(key[j]== '?' ? 'a' :key[j]);
}
return 0;
}
}
cout<< "UNRESTORABLE"<<endl;
}
|
#include <bits/stdc++.h>
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
typedef long long ll;
typedef long double ld;
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define INF 100000000000000
using namespace std;
int main()
{
FAST
ll n,k;
cin>>n>>k;
if(k == n)
{
cout<<0;
return 0;
}
ll arr[n];
for(ll i=0;i<n;i++)
cin>>arr[i];
ll dp[n][k+1];
for(ll i=0;i<n;i++)
for(ll j=0;j<k+1;j++)
dp[i][j] = INF;
dp[0][0] = arr[0];
for(ll i=1;i<n;i++)
{
if(i<=k)
dp[i][i] = arr[i];
for(ll j=i-1;j>-1;j--)
{
ll ct = i-1-j;
for(ll k1=0;k1<=k;k1++)
{
if(k1+ct>k)
continue;
ll temp = dp[j][k1];
if(arr[i]>arr[j])
temp+=arr[i]-arr[j];
dp[i][k1+ct] = min(dp[i][k1+ct],temp);
}
}
}
ll ans = INF;
for(ll i=0;i<n;i++)
{
for(ll j=0;j<=k;j++)
{
ll rem = n-1-i;
if(rem+j<=k)
ans = min(ans, dp[i][j]);
}
}
cout<<ans;
return 0;
}
| 0
| 77,088,886
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for(ll i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
ll n, l;
cin >> n >> l;
vl a(n);
rep(i, n) cin >> a[i];
ll ans = -1;
rep(i, n - 1) if(a[i] + a[i + 1] >= l) ans = i;
if(ans >= 0) {
cout << "Possible" << '\n';
rep(i, ans) cout << i + 1 << '\n';
for(ll i = n - 2; i >= ans + 1; i--) cout << i + 1 << '\n';
cout << ans + 1 << '\n';
} else
cout << "Impossible" << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
const bool debug=false;
#define DEBUG if(debug==true)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
int main(void) {
ll n;cin>>n;
ll a[n];
ll diff[n];
ll sum=0;
rep(i,n){
cin>>a[i];
sum+=a[i];
}
if(sum%(n*(n+1)/2)!=0LL){
DEBUG{printf("out1\n");}
cout << "NO" << endl;
return 0;
}
ll val = sum/(n*(n+1)/2);
DEBUG{cout << "val : "<< val << endl;}
rep(i,n){
diff[i] = a[(i+1)%n] - a[i] - val;
}
ll cnt=0;
rep(i,n){
if(diff[i]>0||diff[i]%n){
DEBUG{printf("out2 i : %d reminder : %lld\n",i,diff[i]%n);}
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0
| 26,658,679
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define eb emplace_back
#define pb push_back
#define size(s) (int)s.size()
#define int long long
#define vi vector<int>
#define vs vector<string>
#define vv vector<vector<int>>
#define pii pair<int,int>
#define m_p(x,y) make_pair(x,y)
#define vp vector<pair<int,int>>
#define setbits(x) __builtin_popcountll(x)
#define f first
#define se second
#define inc(v,n,x) v.assign(n,x)
#define incd(v,n) v.resize(n)
#define iniz(n) memset(n,0,sizeof(n))
#define inin(n) memset(n,-1,sizeof(n))
#define inimi(n) memset(n,0xc0,sizeof(n))
#define inima(n) memset(n,0x3f,sizeof(n))
#define all(v) (v).begin(),(v).end()
using namespace std;
template<typename T1,typename T2>istream &operator>>(istream &is, vector<pair<T1,T2>> &v) { for (pair<T1,T2> &t : v) is >> t.f>>t.se; return is; }
template<typename T>istream &operator>>(istream &is, vector<T> &v) { for (T &t : v) is >> t; return is; }
template<typename T>ostream &operator<<(ostream &os, const vector<T> &v) { for (const T &t : v) {os << t <<" ";} os << '\n'; return os; }
const int N=200001;
double pi=acos(-1.0);
int md=1e9+7;
const int INF=1e15;
int dx1[]={0,0,-1,1};
int dy1[]={1,-1,0,0};
template<class T>
T abst(T a)
{return a<0?-a:a;}
void solve()
{
int n;cin>>n;
vector<pair<int,pii>> v;
for(int i=0;i<n-1;i++)
{
int c,s,f;
cin>>c>>s>>f;
v.push_back({c,{s,f}});
}
for(int i=0;i<n-1;i++)
{
int time=v[i].se.f+v[i].f;
for(int j=i+1;j<n-1;j++)
{
if(time<v[j].se.f)
{
time+=(v[j].se.f-time);
}
else
{
int x=time-v[j].se.f;
int left=x%v[j].se.se;
time+=(v[j].se.se-left)%v[j].se.se;
}
time+=v[j].f;
}
cout<<time<<"\n";
}
cout<<0<<"\n";
}
int32_t main(){
ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
int t=1;
for(int i=1;i<=t;i++)
{
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool solve() {
ll N;
cin >> N;
vector<ll> A(N);
for ( int i = 0; i < N; i++ ) {
cin >> A[i];
}
int a, b;
vector<vector<int>> G(N);
for ( int i = 0; i < N-1; i++ ) {
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
function<ll(int,int)> dfs = [&](int v, int p) {
if ( p != -1 && G[v].size() == 1 ) {
return A[v];
} else {
ll s = 0;
for ( int u : G[v] ) {
if ( u == p ) continue;
ll y = dfs(u, v);
if ( y < 0 ) return -1LL;
if ( y > A[v] ) return -1LL;
s += y;
}
if ( A[v] > s ) return -1LL;
ll x;
if ( p == -1 && G[v].size() == 1 ) {
x = A[v] - s;
} else {
x = 2*A[v] - s;
}
if ( x < 0 ) return -1LL;
return x;
}
};
bool ans = (dfs(0,-1) == 0LL);
return ans;
}
int main() {
string ans = solve() ? "YES" : "NO";
cout << ans << "\n";
return 0;
}
| 0
| 87,571,114
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m,x,y;
cin>>n>>m>>x>>y;
int left=-100;
int right=100;
for(int i=0;i<n;i++){
int a;
cin>>a;
left=max(a,left);
}
for(int i=0;i<m;i++){
int b;
cin>>b;
right=min(b,right);
}
string ans="War";
for(int i=x+1;i<=y;i++){
if(left<i && i<=right) ans="No War";
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll (i) = 0 ; (i) < (ll)(n) ; ++(i))
#define REPN(i, m, n) for (ll (i) = m ; (i) < (ll)(n) ; ++(i))
#define REP_REV(i, n) for (ll (i) = (ll)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (ll (i) = (ll)(n) - 1 ; (i) >= m ; --(i))
#define INF 2e9
#define INF_LL 1LL<<60
#define ll long long
#define Ceil(x, n) (((((x))+((n)-1))/n))
#define CeilN(x, n) (((((x))+((n)-1))/n)*n)
#define FloorN(x, n) ((x)-(x)%(n))
#define ALL(x) (x).begin(),(x).end()
typedef pair<ll, ll> P;
int main() {
ll a, b, c, k;
cin >> a >> b >> c >> k;
if(k % 2 == 0) {
cout << a - b << endl;
} else {
cout << b - a << endl;
}
return 0;
}
| 0
| 66,077,041
|
#include <bits/stdc++.h>
using namespace std;
char s[200010];
int main(){
scanf("%s",s);
int len=strlen(s);
int sum=0;
for(int i=0;i<len;i++)sum+=s[i]-'0';
if(sum%9==0){
puts("Yes");
}else{
puts("No");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1001001001;
const ll mod = 1000000007;
int main(){
int n, h; cin >> n >> h;
vector<pair<ll, ll>> a(n);
vector<ll> b(n);
ll st = 0;
for(int i = 0; i < n; i++){
cin >> a[i].first >> a[i].second;
b[i] = a[i].second;
}
sort(a.begin(), a.end(), greater<pair<int, int>>());
ll cnt = 0;
for(int i = 0; i < n; i++){
if(b[i] > a[0].first){
st += b[i];
cnt++;
}
}
if(st >= h){
sort(b.begin(), b.end(), greater<ll>());
ll tmp = 0;
for(int i = 0; i < n; i++){
tmp += b[i];
if(tmp >= h){
cout << i + 1 << endl;
return 0;
}
}
}
else{
h -= st;
cout << cnt + (h + a[0].first - 1) / a[0].first << endl;
}
}
| 0
| 13,247,026
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long int;
int ar[13][13],cost[13],check[13];
int main()
{
ll n,m,h;cin>>n>>m>>h;
for(ll i=0;i<n;i++)
{
cin>>cost[i];
for(ll j=0;j<m;j++)
{
ll k;cin>>k;
ar[i][j] = k;
}
}
ll net = 1<<n;
ll mi = 10000000;
for(ll i=0;i<net;i++)
{
ll sum=0;
ll dup[m];
memset(dup,0,sizeof(dup));
for(ll j=0;j<n;j++)
{
ll f = 1<<j;
if(f&i)
{
sum+=cost[j];
for(ll k=0;k<m;k++)
{
dup[k]+=ar[j][k];
}
}
}
bool flag = true;
for(ll i=0;i<m;i++)
{
if(dup[i]<h)
{
flag = false;
break;
}
}
if(flag==true)mi = min(mi,sum);
}
if(mi == 10000000){
cout << -1<<endl;
}
else{
cout << mi<<endl;
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#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 (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
ll const INF = 1LL << 60;
ll min_price = INF;
void dfs2(ll i, ll S, ll D, double n, ll sum) {
double lit = 2.0 / pow(2, (i-1));
if (min_price < sum) {
return;
}
if (i == 2) {
sum += n * S;
if (min_price > sum) {
min_price = sum;
}
return;
}
ll max_select = n / lit;
for (int k = 0; k <= max_select; k++) {
if (i == 1) {
dfs2(i+1, S, D, n-lit*k, sum + k*D);
}
}
}
int main() {
ll Q, H, S, D;
cin >> Q >> H >> S >> D;
ll N;
cin >> N;
H = min(H, 2*Q);
S = min(S, 2*H);
ll ans;
if (2 * S < D) {
ans = N * S;
} else {
ans = (N / 2) * D + (N % 2) * S;
}
cout << ans << endl;
return 0;
}
| 0
| 5,258,771
|
#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, m;
cin >> n >> m;
vector<pair<int, int> > ans;
if (n%2) {
for (int l = 1, r = n-1; l < r; l++, r--) {
ans.push_back(make_pair(l,r));
}
} else {
bool flag = false;
for (int l = 1, r = n-1; l < r; l++, r--) {
if (!flag && r-l <= n/2) {
--r;
flag = true;
}
ans.push_back(make_pair(l,r));
}
}
for(int i = 0; i < m; i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
|
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int n;
vector<long long> a;
vector<vector<int>> p;
vector<long long> q;
vector<bool> c;
long long dfs(int id, int from) {
if (c[id])
return q[id];
c[id] = true;
if (p[id].size() == 1) {
return q[id] = a[id];
}
long long sum = 0;
for (int i = 0; i < p[id].size(); i++)
if (p[id][i] != from)
sum += dfs(p[id][i], id);
long long b = sum - a[id];
long long c = a[id] - b;
if (b < 0 || c < 0) {
return q[id] = -1000000000000ll;
}
long long mm = 0;
for (int i = 0; i < p[id].size(); i++)
mm = max(mm, dfs(p[id][i], id));
if (mm > sum / 2) {
if (sum - mm < b)
return q[id] = -1000000000000ll;
} else {
if (sum / 2 < b)
return q[id] = -1000000000000ll;
}
return q[id] = c;
}
int main() {
cin >> n;
a.resize(n);
p.resize(n);
c.resize(n);
q.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
p[a].push_back(b);
p[b].push_back(a);
}
if (n == 2) {
if (a[0] == a[1])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (p[i].size() == 1)
continue;
if (dfs(i, -1) == 0) {
cout << "YES" << endl;
return 0;
} else {
cout << "NO" << endl;
return 0;
}
}
return 0;
}
| 0
| 1,379,050
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
cout << A + B / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int N, L;
cin >> N >> L;
vector<int> a(N);
for (int i = 0; i < N; i++) cin >> a[i];
int pos;
bool check = false;
for (int i = 1; i < N; i++) {
if (a[i-1]+a[i] >= L) {
check = true;
pos = i;
break;
}
}
if (!check) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
for (int i = 1; i < pos; i++) cout << i << endl;
for (int i = N-1; i >= pos; i--) cout << i << endl;
return 0;
}
| 0
| 79,756,452
|
#include<bits/stdc++.h>
#define rep(i,N) for(int i=0;i<(N);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e12;
const int inf = 1e9;
const int mod = 1e9+7;
typedef long long ll;
typedef pair<ll,int> P;
typedef set<int> S;
ll gcd(ll a, ll b){
if(a < b) swap(a,b);
if(a%b==0) return b;
else return gcd(b,a%b);
}
ll ngcd(vector<ll> a){
ll res;
res = a[0];
for(int i = 1; i < a.size() && res != 1; i++) {
res = gcd(a[i], res);
}
return res;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
ll nlcm(vector<ll> numbers) {
ll res;
res = numbers[0];
for (ll i = 1; i < numbers.size(); i++) {
res = lcm(res, numbers[i]);
}
return res;
}
int main(){
cout << fixed << setprecision(10);
int n;
ll x;
cin >> n >> x;
vector<ll> v(n);
rep(i,n){
ll z;
cin >> z;
v[i] = abs(z-x);
}
cout << ngcd(v) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> csum_a(n + 1,0), csum_b(n + 1,0);
for (int i = 1; i <= n; ++i) {
long long tmp;
cin >> tmp;
csum_a[i] = csum_a[i - 1] + tmp;
csum_b[i] = csum_b[i - 1] + max(tmp, 0LL);
}
long long ans = INT64_MIN;
for (int i = 1; i + k - 1 <= n; ++i) {
auto left = csum_b[i - 1];
auto center = max(csum_a[i + k - 1] - csum_a[i - 1], 0LL);
auto right = csum_b[n] - csum_b[i + k - 1];
ans = max(ans, left + center + right);
}
cout << ans << endl;
return 0;
}
| 0
| 22,013,033
|
#include<iostream>
using namespace std;
int main(){
int x,i=1;
while(1){
cin>>x;
if(x==0){
break;
}
else{
cout<<"Case"<<" "<<i<<":"<<" "<<x<<endl;
i++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M, Nmin, Nmax;
vector<int> P;
void solve(){
sort(P.rbegin(), P.rend());
int gap = 0;
int ans = -1;
for(int i=Nmin-1; i<Nmax; i++){
if(P[i]-P[i+1] >= gap){
gap = P[i]-P[i+1];
ans = i + 1;
}
}
cout << ans << endl;
}
int main(){
while(cin >> M >> Nmin >> Nmax, M|Nmin|Nmax){
P.resize(M);
for(auto &v: P)
cin >> v;
solve();
}
}
| 0
| 14,353,632
|
#include <bits/stdc++.h>
#define Rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef int64_t intl;
int main(){
int N,K;
cin >> N>>K;
if ( N%K ==0){cout << 0;}
else {cout <<1;}
}
|
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
#define SIZE 105
#define INF 1e18
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
ll d[SIZE][SIZE];
int V;
void warshall_floyd_init(){
fill(d[0],d[SIZE],INF);
rep(i,0,SIZE) d[i][i] = 0;
}
bool warshall_floyd(){
rep(k,0,V) rep(i,0,V){
if(d[i][k]==INF)continue;
rep(j,0,V){
if(d[k][j]==INF)continue;
d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
}
}
rep(i,0,V) if(d[i][i] < 0) return true;
return false;
}
void add_edge(int a,int b,ll cost){
d[a][b] = cost;
}
int E;
int main(){
cin >> V >> E;
warshall_floyd_init();
rep(i,0,E){
int s,t;
ll D;
cin >> s >> t >> D;
add_edge(s,t,D);
}
if(warshall_floyd()){
cout << "NEGATIVE CYCLE" << endl;
}else{
rep(k,0,V){
rep(i,0,V){
if(i!=0) cout << " ";
if(d[k][i]==INF)cout << "INF";
else cout << d[k][i];
}
cout << endl;
}
}
return 0;
}
| 0
| 26,435,281
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#define FOR(i,b,n) for(int i=b;i<n;i++)
#define RFOR(i,b,n) for(int i=n-1;i>=b;i--)
#define CLR(mat) memset(mat, 0, sizeof(mat))
#define NCLR(mat) memset(mat, -1, sizeof(mat))
using namespace std;
static const double EPS = 1e-9;
typedef long long ll;
typedef pair<int, int> paii;
int a, b, n;
bool con[100][100] = {0};
int solve()
{
int dp[100][100];
CLR(dp);
dp[1][1] = 1;
FOR(j, 1, b+1)
FOR(i, 1, a+1)
{
if( con[j][i] == true )
{
dp[j][i] = 0;
}
else
{
dp[j][i] += dp[j-1][i] + dp[j][i-1];
}
}
return dp[b][a];
}
int main()
{
while(cin >> a >> b, (a||b))
{
CLR(con);
cin >> n;
FOR(i, 0, n)
{
int x, y;
cin >> x >> y;
con[y][x] = true;
}
cout << solve() << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include<map>
#include<cmath>
#include<set>
#define ll long long int
#define ull unsigned long long int
#define I(a) scanf("%d",&a)
#define I2(a,b) scanf("%d%d",&a,&b)
#define I3(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define L(a) scanf("%lld",&a)
#define L2(a,b) scanf("%lld%lld",&a,&b)
#define L3(a,b,c) scanf("%lld%lld%lld",&a,&b,&c)
#define PI(a) printf("%d",a)
#define PL(a) printf("%lld",a)
#define PT(t) printf("Case %d: ",t)
#define PB push_back
#define x first
#define y second
#define xx first.first
#define xy first.second
#define yx second.first
#define yy second.second
#define SC scanf
#define PC printf
#define NL printf("\n")
#define SET(a) memset(a,0,sizeof a)
#define SETR(a) memset(a,-1,sizeof a)
#define SZ(a) ((int)a.size())-1
#define f(i,a,b) for(int i=a;i<=b; i++)
#define fr(i,a,b) for(int i=a;i<=b; i++)
#define frr(i,a,b) for(int i=a;i>=b; i--)
#define frv(i,a) for(int i=0;i<a.size();i++)
#define pi 2.0*acos(0.0)
#define R(a) freopen(a, "r", stdin);
#define W(a) freopen(a, "w", stdout);
#define CB(x) __builtin_popcount(x)
#define STN(a) stringtonumber<ll>(a)
#define lol printf("BUG\n")
#define Endl "\n"
#define mk make_pair
using namespace std;
template <class T> inline T BM(T p, T e, T M)
{
ll ret = 1;
for(; e > 0; e >>= 1)
{
if(e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T> inline T mul(T p, T e, T M)
{
ll ret = 0;
for(; e > 0; e >>= 1)
{
if(e & 1) ret = (ret + p) ;
p = (p + p) ;
if(ret>=M)ret-=M;
if(p>=M)p-=M;
}
return (T)ret;
}
template <class T> inline T gcd(T a, T b)
{
if(b == 0)return a;
return gcd(b, a % b);
}
template <class T> inline T mdINV(T a, T M)
{
return BM(a, M - 2, M);
}
template <class T> inline T PW(T p, T e)
{
ll ret = 1;
for(; e > 0; e >>= 1)
{
if(e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>bool ISLEFT(T a, T b, T c)
{
if(((a.xx - b.xx) * (b.yy - c.yy) - (b.xx - c.xx) * (a.yy - b.yy)) < 0.0)return 1;
else return 0;
}
#define mx 200004
#define base 193ll
typedef pair<int,int >P;
#define F(i,a,b) for(int i=a;i<b; i++)
#define LL long long
#define MX 1000007
#define md 1000000007ll
int main(){
string a, b;
cin>>a>>b;
string k;
for(int i = 0; i < a.size(); i++) {
string l;
for(int j=i; j<a.size(); j++)l+=a[j];
if(l+k ==b) {
cout<<"Yes"<<endl;
return 0;
}
k+= a[i];
}
cout<<"No"<<endl;
return 0;
}
| 0
| 8,975,484
|
#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;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define FS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define ld long double
#define pb push_back
#define bp __builtin_popcount
#define sz size()
#define ff first
#define ss second
#define vll vector<ll>
#define vbool vector<bool>
#define vpll vector<pair<ll,ll>>
#define pll pair<ll,ll>
#define vllv vector<vector<ll>>
#define setpri(x) cout<<setprecision(x)<<fixed;
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define yesr {cout<<"YES"<<endl;return;}
#define nor {cout<<"NO"<<endl;return;}
ll MOD=1e9+7;
ll ceil1(ll n,ll x){return (n-1)/x+(n>0);}
ll gcd(ll a,ll b){return __gcd(a,b);}
ll lcm(ll a,ll b){return (max(a,b)/gcd(a,b))*min(a,b);}
ll pow1(ll n,ll m ,ll mod=MOD );
ll pow2(ll n,ll k);
ll modinv(ll n,ll mod=MOD){ return pow1(n,mod-2,mod);}
bool func(pair<ll,ll> &a,pair<ll,ll> &b ){
if(a.ff != b.ff)return a.ff < b.ff;
return a.ss > b.ss;
}
ll const N=(ll)1e5+11;
ll const LG=(ll)log2(N)+1;
void solve(){
ll i,j,k,l,n,m,x,y,z,r;
cin>>n>>k;
m=n*3+k;
cout<<m/2<<endl;
}
int main(){
FS;
ll i,j,k,n,m,x,y,z,q;
q=1;
while(q--){
solve();
}
return 0;
}
ll pow1(ll n,ll m,ll mod){
if(m==0)return 1;
if(m%2==0)return pow1((n*n)%mod,m/2,mod);
return (pow1((n*n)%mod,m/2,mod)*n)%mod;
}
ll pow2(ll n,ll k){
ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;
n=n*n;
k/=2;
}
return ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve () {
string s, t;
cin >> s >> t;
int n = (int) s.size();
vector<int> b(26), a(26);
for (int i = 0; i < n; i++) {
b[t[i] - 'a']++;
a[s[i] - 'a']++;
if(a[s[i] - 'a'] != b[t[i] - 'a']) {
cout << "No";
return;
}
}
cout << "Yes";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 0
| 90,568,099
|
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main(void){
double a,b,c,d,x,y;
cin>>a>>b>>c>>d;
x = c-a;
y = b-d;
if(x<0)x =x*-1;
if(y<0)y =y*-1;
printf("%lf\n",sqrt(x*x+y*y));
return 0;
}
|
#include <iostream>
using namespace std;
int main()
{
int m, f, r;
while(true)
{
cin >> m >> f >> r;
if (m==-1 && f==-1 && r==-1) break;
char rank;
int sum = m+f;
if (m==-1 || f==-1)
{
rank = 'F';
}
else
{
if (sum>=80) rank = 'A';
else if (65<=sum && sum<80) rank = 'B';
else if (50<=sum && sum<65) rank = 'C';
else if (30<=sum && sum<50) rank = 'D';
else rank = 'F';
if (rank == 'D' && 50<=r) rank = 'C';
}
cout << rank << endl;
}
return 0;
}
| 0
| 38,555,182
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
int ans=a^b^c;
cout<<ans;
return 0;
}
|
#include <iostream>
#include <vector>
typedef long long LL;
using namespace std;
#define MAX 100100
vector<vector<int>> ab(MAX);
vector<vector<LL>> c(MAX);
vector<LL> d(MAX);
vector<bool> is_visit(MAX, false);
void dfs(int s){
if(ab[s].size()==0){
return;
}
for(int i=0; i<ab[s].size(); i++){
if(is_visit[ab[s][i]]==true){
continue;
}
d[ab[s][i]]=d[s]+c[s][i];
is_visit[ab[s][i]]=true;
dfs(ab[s][i]);
}
return;
}
int main(){
int n;
int q;
int k;
int tmp_a;
int tmp_b;
LL tmp_c;
cin >> n;
for(int i=0; i<n-1; i++){
cin >> tmp_a >> tmp_b >> tmp_c;
tmp_a--;
tmp_b--;
ab[tmp_a].push_back(tmp_b);
ab[tmp_b].push_back(tmp_a);
c[tmp_a].push_back(tmp_c);
c[tmp_b].push_back(tmp_c);
}
cin >> q >> k;
k--;
vector<int> x;
vector<int> y;
int tmp_x;
int tmp_y;
for(int i=0; i<q; i++){
cin >> tmp_x >> tmp_y;
tmp_x--;
tmp_y--;
x.push_back(tmp_x);
y.push_back(tmp_y);
}
is_visit[k]=true;
d[k]=0;
dfs(k);
for(int i=0; i<q; i++){
cout << d[x[i]]+d[y[i]] << endl;
}
return 0;
}
| 0
| 12,139,897
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1e9
const int MAX_N=100;
const int MAX_W=100;
const int MOD=1000000007;
int dp[1001][1001];
int main(){
string s1,s2;
cin>>s1>>s2;
for(int i=0;i<s1.length()+1;i++) dp[i][0]=i;
for(int j=0;j<s2.length()+1;j++) dp[0][j]=j;
for(int i=1;i<s1.length()+1;i++){
for(int j=1;j<s2.length()+1;j++){
int cost=s1[i-1]==s2[j-1]?0:1;
dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+cost);
}
}
cout<<dp[s1.length()][s2.length()]<<endl;
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int main(){
int h, w;
cin >> h >> w;
vector<string> s(h);
for(int i = 0; i < h; i++) cin >> s[i];
string ans = "Yes";
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
if(s[i][j] == '.') continue;
bool isok = false;
for(int k = 0; k < 4; k++){
if(i+dx[k] >= 0 && i+dx[k] < h && j+dy[k] >= 0 && j+dy[k] < w){
if(s[i+dx[k]][j+dy[k]] == '#') isok = true;
}
}
if(!isok) ans = "No";
}
}
cout << ans << endl;
return 0;
}
| 0
| 59,054,074
|
#include<cstdio>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<set>
#include<cstring>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define mp make_pair
#define pb push_back
#define LLIandI pair<long long int , int>
#define ll long long
bool d[10002][20002];
int main(void){
char s[10000];
scanf("%s",s);
int x,y;
scanf("%d %d",&x,&y);
int sx=-1,sy=0;int vec=0;
int cnt=0;
vector<int> ud;
vector<int> rl;
int N=strlen(s);
rep(i,N){
if(s[i]=='F'){
cnt++;
}else{
if(vec%2==0){
if(sx>-1)rl.pb(cnt);
else sx=cnt;
}else ud.pb(cnt);
cnt=0;vec++;
}
if(i==N-1&&cnt>0){
if(vec%2==0){
if(sx>-1)rl.pb(cnt);
else sx=cnt;
}else ud.pb(cnt);
}
}
rep(i,ud.size()+2)rep(j,20000){d[i][j]=false;}
d[0][sy+10000]=true;
rep(i,ud.size()){
rep(j,20000){
if(j+ud[i]>-1&&j+ud[i]<20000&&d[i][j]==true){d[i+1][j+ud[i]]=true;}
if(j-ud[i]>-1&&j-ud[i]<20000&&d[i][j]==true){d[i+1][j-ud[i]]=true;}
}
}
if(d[ud.size()][y+10000]==false){printf("No\n");return 0;}
rep(i,rl.size()+2)rep(j,20000){d[i][j]=false;}
d[0][sx+10000]=true;
rep(i,rl.size()){
rep(j,20000){
if(j+rl[i]>-1&&j+rl[i]<20000&&d[i][j]==true)d[i+1][j+rl[i]]=true;
if(j-rl[i]>-1&&j-rl[i]<20000&&d[i][j]==true)d[i+1][j-rl[i]]=true;
}
}
if(d[rl.size()][x+10000]==false){printf("No\n");return 0;}
printf("Yes\n");return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int h, w, m;
cin >> h >> w >> m;
vector<int> hs(h), ws(w);
set<P> s;
rep(i, m) {
int r, c;
cin >> r >> c;
--r; --c;
hs[r]++; ws[c]++;
s.emplace(r, c);
}
int mh = 0, mw = 0;
rep(i, h) mh = max(mh, hs[i]);
rep(j, w) mw = max(mw, ws[j]);
vector<int> mhs, mws;
rep(i, h) if (hs[i] == mh) mhs.push_back(i);
rep(j, w) if (ws[j] == mw) mws.push_back(j);
int ans = mh + mw;
for (auto i : mhs) for (auto j : mws) {
if (s.count(P(i, j))) continue;
cout << ans << endl;
return 0;
}
cout << ans - 1 << endl;
}
| 0
| 19,684,239
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template< typename T >
T mod_pow(T x, T n, const T &p) {
T ret = 1;
while(n > 0) {
if(n & 1) (ret *= x) %= p;
(x *= x) %= p;
n >>= 1;
}
return ret;
}
int main() {
int N, M;
cin >> N >> M;
vector<bitset<10>> light(M);
vector<int> p(M);
for (int i = 0; i < M; ++i) {
int k;
cin >> k;
for (int j = 0; j < k; ++j) {
int s;
cin >> s;
light[i][s-1] = true;
}
}
for (int i = 0; i < M; ++i) {
cin >> p[i];
}
int cnt = 0;
const int limit = mod_pow(2, N, 100000);
for (int i = 0; i < limit; ++i) {
bitset<10> bit = bitset<10>(i);
bool ok = true;
for (int j = 0; j < M; ++j) {
if ((light[j] & bit).count() % 2 != p[j]) {
ok = false;
break;
}
}
if (ok) cnt++;
}
cout << cnt << endl;
}
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define endl "\n"
#define pb push_back
#define PI 3.1415926535897932384626433832795l
#define F first
#define S second
#define mp make_pair
#define f(i,n) for(int i=0;i<n;i++)
#define fastio ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define all(v) (v).begin(),(v).end()
#define sort(v) sort((v).begin(),(v).end())
#define rall(v) (v).rbegin(),(v).rend()
#define rsort(v) sort((v).rbegin(),(v).rend())
#define gcd(a,b) __gcd((a),(b))
#define minn(v) *min_element(v.begin(), v.end());
#define maxx(v) *max_element(v.begin(), v.end());
#define print(x) cout<<(x)<<endl;
typedef pair<int,int> pii;
typedef vector<int> vi;
bool isPrime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
struct type{
int k, i, j;
};
signed main()
{
fastio;
string s,t;
cin>>s>>t;
int a,b;
cin>>a>>b;
string u;
cin>>u;
if(u==s)cout<<a-1<<" "<<b<<endl;
else cout<<a<<" "<<b-1<<endl;
}
| 0
| 24,293,109
|
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define SZ(x) (int((x).size()))
#define se second
#define ll long long
#define pq priority_queue
#define MP make_pair
#define pii pair<int,int>
#define mod 998244353
#define inf 0x3f3f3f3f
#define debug(x) cerr<<#x<<"="<<x<<'\n'
#define rep(i, a, b) for (int i=a; i<(b); i++)
const int maxn=3e5;
int n;
vector <int> edge[maxn];
vector <int> s;
ll tree[maxn*4],add[maxn*4];
void update(int c,int cl,int cr,int l,int r,ll val) {
if (l<=cl&&cr<=r) {
tree[c]+=(ll)(cr-cl+1)*val;
add[c]+=val;
return;
}
int mid=cl+cr>>1;
if (add[c]!=0) {
tree[c<<1]+=(ll)(mid-cl+1)*add[c];
add[c<<1]+=add[c];
tree[c<<1|1]+=(ll)(cr-mid)*add[c];
add[c<<1|1]+=add[c];
add[c]=0;
}
if (l<=mid) update(c<<1,cl,mid,l,r,val);
if (r>mid) update(c<<1|1,mid+1,cr,l,r,val);
tree[c]=tree[c<<1]+tree[c<<1|1];
return;
}
int main(){
std::ios::sync_with_stdio(false);
memset(tree,0,sizeof(tree));
memset(add,0,sizeof(add));
cin>>n;
rep(i,1,n) {
int u,v;
cin>>u>>v;
edge[u].pb(v);
edge[v].pb(u);
}
rep(i,1,n+1) sort(edge[i].begin(),edge[i].end());
ll ans=0;
rep(i,1,n+1) {
s.clear();
s.pb(0);
rep(j,0,SZ(edge[i]))
if (edge[i][j]<i) s.pb(edge[i][j]);
s.pb(i);
int cur=1;
for (int j=SZ(s)-2;j>=0;j--) update(1,1,n,s[j]+1,s[j+1],cur--);
ans+=tree[1];
}
cout<<ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool is_left(char c) {
string left="qwertasdfgzxcvb";
for(int i=0;i<left.size();i++) if(left[i]==c) return 1;
return 0;
}
int main() {
string s;
while(cin>>s,s!="#") {
bool L=is_left(s[0]);
int ans=0;
for(int i=1;i<s.size();i++) {
if(L!=is_left(s[i])) {ans++;L^=1;}
}
printf("%d\n",ans);
}
}
| 0
| 89,510,746
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.