code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <iostream>
#include <string>
using ll=long long;
#define rep(i,a,b) for(ll i=a;i<ll(b);i++)
#define repr(i,a,b) for(ll i=a;i>=ll(b);i--)
#define endl "\n"
#define ALL(x) x.begin(),x.end()
using namespace std;
string s, t;
int ans;
int main() {
cin >> s >> t;
int lengh = s.length();
rep(i, 0, lengh) if(s[i] != t[i]) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <bitset>
#include <iomanip>
using namespace std;
#define reps(i,s,n) for(int i = s; i < n; i++)
#define rep(i,n) reps(i,0,n)
#define Rreps(i,n,e) for(int i = n - 1; i >= e; --i)
#define Rrep(i,n) Rreps(i,n,0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
#define mp make_pair
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll N,M,H,W,K,Q,A,B;
string S, T;
const ll MOD = (1e+9) + 7;
const ll INF = 1LL << 60;
typedef pair<ll,ll> P;
int main(){
cin>>N;
vec a(N);
rep(i,N) cin>>a[i];
ll l = 2, r = 3;
Rrep(i,N){
ll nl = (l + a[i] - 1) / a[i], nr = (r - 1) / a[i];
if(nl > nr) {
cout<<-1<<endl;
return 0;
}else{
l = nl * a[i];
r = (nr + 1) * a[i];
}
}
cout<<l<<' '<<r - 1<<endl;
}
| 0
| 6,700,414
|
/* {:i:i:|i:i:/l/l-- --l/li:i:i|i:i:i:i}
{:rx|:i:i ィi芥ミ .ィi芥ミｉ:ｉ|ﾍ:i:i:}
. ｛ﾏ|ｉ: {::’:} {:‘::} :ｉ:i:|〉｝:/
乂|:i:| ｀¨¨¨¨´ ｀¨¨¨´ :i:ｉ:|ｼ/
ﾉ:|:i| ′ |:i:i:|ﾂ
/:/|:i:| ､ _ _ |:i:i:|
/:/ .|:i:|/ ＼ ｨ〔|:i:/
〈;/ く刈＿ 个 - ＜} ./|/_〉
r-っ'~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ~ﾞ|___
/／ニつ ､ ノﾆﾆ ＼
. | ニ⊃ ./ / ── / / ..⊆ﾆﾆ :|
. | 丁´ /|￣|￣ ─‐ /|￣|￣ .￣|丁 |
. | ﾉ. |￣|￣ ─‐ |￣|￣ .|八 |
. | ||. |￣|￣ |￣| |￣|￣ .| |
. | || ￣￣￣ ￣ ￣￣￣ .| | |
. ||＿＿＿＿＿＿＿＿＿＿＿＿______|__ ',
,′ | ７ﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆ} ,′
. { |/ }ﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆﾆ{/
*
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <limits>
using namespace std;
#define rep(a) _rep(0,int(a))
#define repj(a) for(int j=0;j<int(a);j++)
#define _rep(a,b) for(int i=int(a);i<int(b);i++)
#define ll long long
#define fst first
#define snd second
#define pf(b) printf("%.12f\n",(double)b)
#define _GLIBCXX_DEBUG
const double pai = 3.1415926535897;
#define _cos(n) cos(n*pai/180)
int fact(int n) {
int a = 1;
for (int i = 1;i <= n;i++) a *= i;
return a;
}
int sa(int n, int m) {
if (n < m)return m - n;
else return n - m;
}
int a[3];
signed main() {
rep(3)cin>>a[i];
sort(a, a + 3);
int ans = a[2] * 10 + a[1] + a[0];
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
deque<int> dq(v.begin(), v.end());
vector<pair<int, int>> res;
while (dq.size() > 2) {
int n1 = dq.front();
int n2 = dq.back();
dq.pop_front();
dq.pop_back();
int next1 = n1 - n2;
int next2 = n2 - n1;
if (max(abs(next1 - dq.front()), abs(next1 - dq.back())) < max(abs(next2 - dq.front()), abs(next2 - dq.back()))) {
dq.push_back(next2);
res.push_back(make_pair(n2, n1));
} else {
dq.push_front(next1);
res.push_back(make_pair(n1, n2));
}
}
cout << dq.back() - dq.front() << endl;
for (auto p : res) {
cout << p.first << " " << p.second << endl;
}
cout << dq.back() << " " << dq.front() << endl;
}
| 0
| 22,311,802
|
#include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/integer/common_factor.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
using std::string;
using std::vector;
using std::set;
using std::multiset;
using std::unordered_set;
using std::map;
using std::multimap;
using std::unordered_map;
using std::pair;
using std::cin;
using std::cout;
using boost::multiprecision::cpp_int;
using cpp_dec_float_1000 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000>>;
typedef uintmax_t ull;
typedef intmax_t ll;
typedef uint64_t ul;
typedef uint32_t ui;
typedef uint8_t uc;
constexpr char CRLF = '\n';
constexpr char SPACE = ' ';
constexpr char VECTOR_COUT_SEPARATOR = SPACE;
constexpr ll INF = 1000'000'007;
constexpr int MOD = 1000'000'007;
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; }
template<class T> std::ostream& operator<< (std::ostream& os, const std::vector<T>& vc) { for(auto it = vc.begin(); it != vc.end(); ++it) { if (std::next(it) == vc.end()) os << *it; else os << *it << VECTOR_COUT_SEPARATOR; } return os; }
template<class T1, class T2> inline std::ostream & operator<< (std::ostream & os, const std::pair<T1, T2> & p) { return os << p.first << ' ' << p.second; }
template<class T> T modinv(T a, T m) { T b = m, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; boost::swap(a, b); u -= t * v; boost::swap(u, v); } u %= m; if (u < 0) u += m; return u; }
struct Tmp
{
public:
Tmp(int N);
};
Tmp::Tmp(int N){}
void solve(void)
{
int N, M; cin >> N >> M;
vector<int> S(N), T(M);
for (auto& s : S) {
cin >> s;
}
for (auto& t : T) {
cin >> t;
}
vector<vector<cpp_int>> dp(N, vector<cpp_int>(M));
vector<vector<cpp_int>> sum(N, vector<cpp_int>(M));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
auto i0 = i - 1;
auto j0 = j - 1;
if (S[i] == T[j]) {
dp[i][j] += (i0 >= 0 && j0 >= 0) ? sum[i0][j0] : 0;
dp[i][j] += 1;
dp[i][j] %= MOD;
}
if (i0 >= 0) { sum[i][j] += sum[i0][j]; sum[i][j] %= MOD; }
if (j0 >= 0) { sum[i][j] += sum[i][j0]; sum[i][j] %= MOD; }
if (i0 >= 0 && j0 >= 0) { sum[i][j] -= sum[i0][j0]; sum[i][j] = (sum[i][j] + MOD) % MOD; }
sum[i][j] += dp[i][j];
sum[i][j] %= MOD;
}
}
cpp_int ans = sum[N-1][M-1] + 1;
ans %= MOD;
cout << ans.str() << CRLF;
return;
}
int main(void)
{
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
solve();
return 0;
}
|
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct Graph
{
int n;
vector<vector<int>> g;
Graph(int n) : n(n){
g.resize(n);
}
void init(int n_){
n = n_;
g.resize(n_);
}
void add_edge(int from, int to){
g[from].push_back(to);
}
};
struct Tree
{
int n;
int root;
vector<vector<int>> t;
vector<int> par;
vector<int> dpt;
void init(Graph &g, int root_){
n = g.n;
root = root_;
t.resize(n);
par.resize(n);
dpt.resize(n);
fill(dpt.begin(), dpt.end(), -1);
queue<int> que;
par[root] = -1;
dpt[root] = 0;
que.push(root);
while(que.size()){
int pa = que.front();
que.pop();
for(int ch : g.g[pa]){
if(dpt[ch] == -1){
t[pa].push_back(ch);
par[ch] = pa;
dpt[ch] = dpt[pa] + 1;
que.push(ch);
}
}
}
}
Tree(){}
Tree(Graph &g, int root_){
init(g, root_);
}
};
int dfs(Tree &t, int u){
int res = 0;
for(int v : t.t[u]){
res ^= dfs(t, v) + 1;
}
return res;
}
int main()
{
int n;
cin >> n;
Graph g(n);
for(int i = 0; i < n - 1; i++){
int x, y;
cin >> x >> y;
x--; y--;
g.add_edge(x, y);
g.add_edge(y, x);
}
Tree t(g, 0);
if(dfs(t, 0) != 0) cout << "Alice" << endl;
else cout << "Bob" << endl;
}
| 0
| 65,203,101
|
#include<iostream>
using namespace std;
int main(){
int a,b,c;
string res;
cin>>a>>b>>c;
if(a<b&b<c)res="Yes";else res="No";
cout<<res<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef double db;
const double pi = 3.141592654;
#define pb push_back
#define forab(i,a,b) for(int i=(a);i<=(b);i++)
#define CIN ios_base::sync_with_stdio(0); cin.tie(0)
#define pcase(z,x) printf("Case %ld: %lld\n",z,x)
#define nw "\n"
int main(void)
{
CIN;
ll tc,l,k,sum=0,x=0,y,z=0,m=1,n=0,ans=0,cnt=0;
string s;
ll a,b;
cin>>a>>b;
cin>>s;
l=s.size();
if(s[a]=='-')x=1;
for(ll i=0;i<l;i++){
if(i==a)continue;
if(!(s[i]>='0'&&s[i]<='9'))return cout<<"No",0;
}
if(x==1)cout<<"Yes";
else cout<<"No";
}
| 0
| 69,454,553
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int a, b;
cin >> a >> b;
vector<string> v;
for(int i=0; i<a; i++) {
string s;
cin >> s;
for(int j=0; j<b; j++) {
if(s[j] == '#') {
v.push_back(s);
break;
}
}
}
int c = v.size();
vector<string> w(b);
for(int i=0; i<c; i++) {
string s;
s = v[i];
for(int j=0; j<b; j++) {
w[j] += s[j];
}
}
for(int i=0; i<w.size(); i++) {
string s;
s = w[i];
for(int j=0; j<c; j++) {
if(s[j] == '#') break;
if(j == c-1 && s[j] == '.') {
w.erase(w.begin()+i);
i--;
}
}
}
int d = w.size();
vector<string> x(c);
for(int i=0; i<d; i++) {
for(int j=0; j<c; j++) {
string s;
s = w[i];
x[j] += s[j];
}
}
for(int i=0; i<c; i++) {
cout << x[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
int main()
{
int n, d;
cin >> n >> d;
vector<int> x(n * d);
rep(i, n * d) cin >> x[i];
int c = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
ll diff = 0;
rep(k, d) {
ll dx = x[d * i + k] - x[d * j + k];
diff += dx * dx;
}
int sq = (int)sqrt(diff);
if (sq * sq == diff) {
c += 1;
}
}
}
put(c)
return 0;
}
| 0
| 59,214,321
|
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int64_t A,B,C,D;
int64_t func(int64_t x){
int64_t sum= x/C+x/D-x/(C*D/__gcd(C,D));
return sum;
}
int main() {
cin>>A>>B>>C>>D;
cout<<(B-A+1)-(func(B)-func(A-1))<<endl;
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
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; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e18;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
typedef pair<ll,ll> P;
typedef pair<double,double> point;
const ll MAX = 200000;
constexpr ll nx[8] = {1,0,-1,0,1,-1,1,-1};
constexpr ll ny[8] = {0,1,0,-1,1,1,-1,-1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,k;
cin >> n >> k;
vector<ll> a(n),p(n+1,0),m(n+1,0);
rep(i,n){
cin >> a[i];
m[i+1] = m[i]+a[i];
if (a[i] > 0){
p[i+1] = p[i]+a[i];
}
else{
p[i+1] = p[i];
}
}
ll ans = -INF;
rep(i,n-k+1){
chmax(ans,max(m[i+k]-m[i],0ll)+p[i]+p[n]-p[i+k]);
}
PRINT(ans);
}
| 0
| 32,211,585
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for (int i = s; i < (int)(n); i++)
#define out(x) cout << x << endl
#define INF 1000000;
#include <map>
#include <math.h>
using ll = long long;
using namespace std;
ll n, k;
const ll mod = 1000000007;
int main(){
string s;
cin >> s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0]) out("Yes");
else out("No");
}
|
#include <iostream>
using namespace std;
int main()
{
int x = -1;
int i = 1;
while (true) {
cin >> x;
if (x != 0) {
cout << "Case " << i << ": " << x << endl;
} else {
return 0;
}
i++;
}
}
| 0
| 78,355,001
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
using namespace std;
using ll = long 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; }
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
int main(){
int n, z, w;
cin >> n >> z >> w;
vector<int> v(n);
rep(i, n) cin >> v[i];
int ans = abs(v[n-1] - w);
if(n >= 2) chmax(ans, abs(v[n-2] - v[n-1]));
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define REP(i, n) for(int i = 0; i < (n); ++i)
#define REPr(i, n) for(int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for(int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for(int i = (n); i >= (m); --i)
#define MP make_pair
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define DB(x) cerr << #x << " = " << x << endl
#define DB2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n";
#define DEBUG \
int x12345; \
cin >> x12345;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
const long long MOD = 1e9 + 7;
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 main() {
string S; cin >> S;
int ans = 0;
if (S == "RRR") ans = 3;
else if (S == "RRS") ans = 2;
else if (S == "SRR") ans = 2;
else if (S == "RSR") ans = 1;
else if (S == "RSS") ans = 1;
else if (S == "SRS") ans = 1;
else if (S == "SSR") ans = 1;
cout << ans << endl;
}
| 0
| 95,292,337
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
long long N, K;
long long H_tmp;
long long sum = 0;
long long sum_tgt = 0;
std::cin >> N >> K;
vector<long long> mons_list(N);
if(K >= N){
goto finish;
}
for(long long i = 0; i < N; i++){
std::cin >> H_tmp;
sum = sum + H_tmp;
mons_list[i] = H_tmp;
}
std::sort(mons_list.begin(), mons_list.end(), std::greater<long long>());
for(long long i = 0; i < K; i++){
sum_tgt = sum_tgt + mons_list[i];
}
sum = sum - sum_tgt;
finish:
std::cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
ll k,a,b;cin>>k>>a>>b;
ll ans=1;
if(a>=b-1)ans=k+1;
else for(int i=0;i<k;)
{
if(ans<a||i>=k-1)
{
ans++;
i++;
}
else
{
ans+=b-a;
i+=2;
}
}
cout<<ans<<"\n";
return 0;
}
| 0
| 68,639,394
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<cstddef>
#include<queue>
#include<math.h>
#include<iomanip>
using namespace std;
int main()
{
int k, x;
cin >> k >> x;
string ans = "No";
if(500 * k >= x) ans = "Yes";
cout << ans << endl;
return 0;
}
|
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<stack>
using namespace std;
int main(){
string s;
while(getline(cin,s),s!="."){
stack<int> a;
for(int i=0;i<s.size();i++){
if(s[i]=='('||s[i]=='['){
a.push(s[i]);
}
else if(s[i]==')'){
if(a.size()>0&&a.top()=='('){
a.pop();
}else{
cout<<"no"<<endl;
goto at;
}
}
else if(s[i]==']'){
if(a.size()>0&&a.top()=='['){
a.pop();
}else{
cout<<"no"<<endl;
goto at;
}
}
}
if(a.size()==0){
cout<<"yes"<<endl;
}else{
cout<<"no"<<endl;
}
at: ;
}
return 0;
}
| 0
| 6,073,174
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M; cin >> N >> M;
int sum=0;
vector<int> A(N);
for(int i=0; i<N; i++){
cin >> A.at(i);
sum=sum+A.at(i);
}
sort(A.begin(),A.end());
reverse(A.begin(),A.end());
if(A.at(M-1)*4*M<sum) cout << "No" << endl;
else cout << "Yes" << endl;
}
|
#include <iostream>
#include <vector>
#include <cmath>
#include <limits.h>
#include <utility>
#include <map>
#include <algorithm>
using namespace std;
using P=pair<int,int>;
using ll=long long;
int main(){
int m,k;
cin>>m>>k;
if(pow(2,m)<=k){
cout<<-1<<endl;
return 0;
}
if(k==0){
for(int i=0;i<pow(2,m)-1;i++){
cout<<i<<" "<<i<<" ";
}
cout<<pow(2,m)-1<<" "<<pow(2,m)-1<<endl;
return 0;
}
int x=0;
for(int i=1;i<pow(2,m);i++){
if(i!=k){
x^=i;
}
}
if(k==x){
cout<<k<<" ";
for(int i=0;i<pow(2,m);i++){
if(i!=k)cout<<i<<" ";
}
cout<<k<<endl;
for(int i=pow(2,m)-1;i>=1;i--){
if(i!=k)cout<<i<<" ";
}
cout<<0<<endl;
}else{
cout<<-1<<endl;
}
}
| 0
| 53,530,821
|
#include <stdio.h>
int main(){
int i;
while(1){
char str[1000];
int s=0;
scanf("%s\n",str);
if(str[0]=='0') break;
for(i=0;str[i]!='\0';i++){
s+=str[i]-'0';
}
printf("%d\n",s);
}
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
struct Node { int p, l, r; };
int main() {
int n;
cin >> n;
Node *u = new Node[n];
for (int i = 0; i < n; i++)
u[i].p = u[i].l = u[i].r = -1;
for (int i = 0; i < n; i++) {
int id, k;
cin >> id >> k;
if (k) {
int *c = new int[k];
for (int j = 0; j < k; j++)
cin >> c[j];
u[id].l = c[0];
for (int j = 0; j < k; j++) {
u[c[j]].p = id;
if (j + 1 != k)
u[c[j]].r = c[j+1];
}
delete[] c;
}
}
for (int i = 0; i < n; i++) {
cout << "node " << i;
cout << ": parent = " << u[i].p;
int depth = 0;
for (int id = i; u[id].p != -1; depth++)
id = u[id].p;
cout << ", depth = " << depth;
if (u[i].p == -1)
cout << ", root";
else if (u[i].l == -1)
cout << ", leaf";
else
cout << ", internal node";
cout << ", [";
int ifs = 1;
for (int id = u[i].l; id != -1; id = u[id].r) {
if (ifs == 0)
cout << ", ";
cout << id;
ifs = 0;
}
cout << "]";
cout << endl;
}
delete[] u;
return 0;
}
| 0
| 87,760,924
|
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=100005;
int n,k,s;
int main()
{
scanf("%d%d%d",&n,&k,&s);
for(int i=1;i<=k;i++)
printf("%d ",s);
for(int i=1;i<=n-k;i++)
printf("%d ",s==1000000000?1000000000-1:1000000000);
return 0;
}
|
#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, h, w;
cin >> w >> h >> n;
ll ux = w, bx = 0, uy = h, by = 0;
rep(i, 0, n){
ll x, y, a;
cin >> x >> y >> a;
if(a == 1){
bx = max(bx, x);
}
if(a == 2){
ux = min(ux, x);
}
if(a == 3){
by = max(by, y);
}
if(a == 4){
uy = min(uy, y);
}
}
ll ans;
if(bx > ux || by > uy) ans = 0;
else ans = (ux - bx) * (uy - by);
cout << ans << endl;
return 0;
}
| 0
| 68,805,262
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
typedef long long ll;
int n,k,a[10];
string s,t;
int main() {
cin >> s;
cout << (s.substr(0,4)=="YAKI" ? "Yes" : "No") << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define all(v) v.begin(), v.end()
bool chmin(ll & a, ll b) { if (b < a) { a = b; return 1; } return 0; }
bool chmax(ll & a, ll b) { if (b > a) { a = b; return 1; } return 0; }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N=500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans;
bool lamda(string S,string T){
if(S.length()>T.length())return true;
if(S.length()<T.length())return false;
if(S>T)return true;
return false;
}
int main() {
ll A[9]={2,5,5,4,5,6,3,7,6};
cin>>n>>m;
vl ok(9,0);
rep(i,m){
cin>>x;
ok[x-1]=1;
}
vector<string> V;
string S;
rep(i,n+1){
if(i==0)V.push_back("");
else V.push_back("!");
rep(j,9){
if(ok[j]==1&&i>=A[j]&&V[i-A[j]]!="!"){
S=V[i-A[j]];
char c='1'+j;
S=S+c;
if(lamda(S,V[i]))V[i]=S;
}
}
}
cout<<V[n]<<endl;
}
| 0
| 82,497,252
|
#include <bits/stdc++.h>
using namespace std;
long long n, x;
bool buf;
int main() {
buf = scanf("%lld %lld", &n, &x);
printf("%lld\n", 3LL*(n-__gcd(n, x)));
return 0;
}
|
#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;
}
| 0
| 22,517,943
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
#define rep(i, s, n) for(int i = (int)(s); i < (int)(n); i++)
ll INF = 1ll << 60;
int main(){
int n;
cin >> n;
vi p(n);
rep(i, 0, n)
cin >> p[i];
int cnt = 0;
int mn = p[0];
rep(i, 0, n){
if(mn >= p[i]){
cnt++;
mn = p[i];
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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; }
#define rep(i,cc,n) for(int i=cc;i<n;++i)
#define lrep(i,cc,n) for(long long i=cc;i<n;++i)
#define sqrep(i,cc,n) for(long long i=cc;i*i<=n;++i)
#define rrep(i,cc,n) for(long i=cc;i>n;--i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const vector<int> dx = {1, 0, -1, 0};
const vector<int> dy = {0, 1, 0, -1};
const double PI = 3.1415926535;
const ll inf = 1001001001;
const ll e9 = 1000000000;
const ll mod = 1000000007;
int main(){
map<string, int>mp;
int n;
cin >> n;
vector<string>p;
rep(i, 0, n){
string s;
cin >> s;
p.push_back(s);
mp[s]++;
}
for(auto i:mp){
if(i.second>1){
cout << "No" << endl;
return 0;
}
}
rep(i, 1, n){
if(p[i][0]!=p[i-1][p[i-1].size()-1]){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| 0
| 99,594,615
|
using namespace std;
#include<bits/stdc++.h>
#define Ranger159 ios_base::sync_with_stdio(false);
#define PrintLater cin.tie(0);cout.tie(0);
#define ll long long
#define phb push_back
#define break break
#define pob pop_back()
#define continue continue
#define size size
#define insrt insert
#define fir first
#define true true
#define clear clear
#define vL vector<ll>
#define resize resize
#define sec second
#define else else
#define reverse reverse
#define lbr1 cout<<"\n";
#define lbr2 cout<<"\n\n";
#define cin(v,n) for(ll i=0;i<n;i++) cin>>v[i];
#define cout(v,n) for(ll i=0;i<n;i++) cout<<v[i]<<" "; lbr1
const ll mod=1e9+7;
int main(int argc, char const *argv[])
{
Ranger159
ll test=1,n,a,b,c,k;
while(test--)
{
cin>>a>>b>>c>>k;
ll cnt=0;
if(b<=a)
{
cnt+=log2(a/b)+1;
b=b*pow(2,cnt);
}
if(c<=b)
cnt+=log2(b/c)+1;
if(cnt<=k)
cout<<"Yes";
else cout<<"No";
lbr1
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
int main(){
int h,w;
cin>>h>>w;
vector<vector<char>>grid(h,vector<char>(w));
rep(i,h)rep(j,w)cin>>grid[i][j];
const int dx[4]={1, 0, -1, 0};
const int dy[4]={0, 1, 0, -1};
bool ans=true;
rep(i,h)rep(j,w){
if(grid[i][j]=='#'){
bool found=false;
for (int dir = 0; dir < 4; ++dir) {
int nh = i + dx[dir];
int nw = j + dy[dir];
if (nh >= 0 && nh < h && nw >= 0 && nw < w && grid[nh][nw]=='#'){
found=true;
}
}
if(!found)ans=false;
}
}
if(ans)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
| 0
| 95,857,074
|
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
string s;
int main(void){
cin >> s;
vector<int> c(30);
rep(i, s.size()) c[s[i]-'a']++;
char ans = '#';
rep(i, 26) if(c[i] == 0){
ans = 'a'+i;
break;
}
if(ans == '#') cout << "None" << endl;
else cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N);
for(int i=0; i<N; ++i) {
cin >> s.at(i);
}
int M;
cin >> M;
vector<string> t(M);
for(int i=0; i<M; ++i) {
cin >> t.at(i);
}
vector<string> s2;
vector<int> s3;
for(int i=0; i<N; ++i) {
bool flg=0;
for(int j=0; j<s2.size(); ++j) {
if (s2.at(j) == s.at(i)) {
flg=1;
s3.at(j) += 1;
}
}
if (flg==0) {
s2.push_back(s.at(i));
s3.push_back(1);
}
}
for(int i=0; i<M; ++i) {
bool flg=0;
for(int j=0; j<s2.size(); ++j) {
if (s2.at(j) == t.at(i)) {
flg=1;
s3.at(j) -= 1;
}
}
}
int result = 0;
for(int i=0; i<s3.size(); ++i) {
if (result < s3.at(i))
result = s3.at(i);
}
cout << result <<endl;
return 0;
}
| 0
| 61,793,042
|
#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <limits.h>
using namespace std;
typedef long long 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;
}
const int INF = INT_MAX / 2;
vector<vector<int>> dp;
int solve(const int len1, const int len2, const string &s1, const string &s2) {
for (int pos1 = 0; pos1 <= len1; pos1++) {
for (int pos2 = 0; pos2 <= len2; pos2++) {
char c1 = s1[pos1];
char c2 = s2[pos2];
if (pos1 != 0 && pos2 != 0 && c1 == c2) {
chmin(dp[pos1][pos2], dp[pos1 - 1][pos2 - 1]);
}
if (pos1 - 1 >= 0) {
chmin(dp[pos1][pos2], dp[pos1 - 1][pos2] + 1);
}
if (pos1 - 1 >= 0 && pos2 - 1 >= 0) {
chmin(dp[pos1][pos2], dp[pos1 - 1][pos2 - 1] + 1);
}
if (pos2 - 1 >= 0) {
chmin(dp[pos1][pos2], dp[pos1][pos2 - 1] + 1);
}
}
}
return dp[len1][len2];
}
int main(void) {
string s1, s2;
cin >> s1 >> s2;
int len1 = (int) s1.size(), len2 = (int) s2.size();
s1 = " " + s1;
s2 = " " + s2;
dp.resize(len1 + 1, vector<int>(len2 + 1, INF));
dp[0][0] = 0;
cout << solve(len1, len2, s1, s2) << endl;
return 0;
}
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
#define REP(i,n) for(ll i=0; i<(n); i++)
#define REPR(i, n) for(ll i = n;i >= 0;i--)
#define FOR(i, m, n) for(ll i = m;i < n;i++)
#define ALL(n) begin(n),end(n)
#define IN(a, x, b) (a<=x && x<b)
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
template<class T> inline T CHMAX(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T CHMIN(T & a, const T b) { return a = (a > b) ? b : a; }
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
const long long MOD = 1000000007;
int main(void){
ll n;
ll m;
ll ans=0;
cin >> n >> m;
vector<vector<ll> > bait_list(100010);
multiset<ll> reward_list;
REP(i, n){
ll tmp1, tmp2;
cin >> tmp1 >> tmp2;
bait_list[tmp1].push_back(tmp2);
}
REP(i, m+1){
REP(j, bait_list[i].size()){
reward_list.insert(bait_list[i][j]);
}
if(! reward_list.empty()){
ans += *(--reward_list.end());
reward_list.erase(--reward_list.end() ) ;
}
}
cout << ans << endl;
return 0;
}
| 0
| 58,958,644
|
#include <iostream>
using namespace std;
template<typename T>
class Dice {
private:
void Init() {
upId = 0;
frontId = 1;
rightId = 2;
}
public:
Dice() :
number{1, 2, 3, 4, 5, 6}
{
Init();
}
Dice(T (&n)[6]) :
number{n[0], n[1], n[2], n[3], n[4], n[5]}
{
Init();
}
virtual ~Dice() {;}
enum Direction {
north,
south,
east,
west
};
void Roll(Direction direction) {
switch (direction) {
case north: {
int tmp = upId;
upId = frontId;
frontId = 5 - tmp;
break;
}
case south: {
int tmp = frontId;
frontId = upId;
upId = 5 - tmp;
break;
}
case east: {
int tmp = rightId;
rightId = upId;
upId = 5 - tmp;
break;
}
case west: {
int tmp = upId;
upId = rightId;
rightId = 5 - tmp;
break;
}
}
}
T Print() {
return number[upId];
}
T Search(T up, T front) {
int downId = 5 - upId;
int backId = 5 - frontId;
int leftId = 5 - rightId;
if (number[frontId] == up) {
Roll(north);
} else if (number[rightId] == up) {
Roll(west);
} else if (number[downId] == up) {
Roll(north);
Roll(north);
} else if (number[backId] == up) {
Roll(south);
} else if (number[leftId] == up) {
Roll(east);
}
downId = 5 - upId;
backId = 5 - frontId;
leftId = 5 - rightId;
if (number[frontId] == front) {
return number[rightId];
} else if (number[rightId] == front) {
return number[backId];
} else if (number[backId] == front) {
return number[leftId];
} else if (number[leftId] == front) {
return number[frontId];
}
return 0;
}
private:
T number[6];
int upId;
int frontId;
int rightId;
};
int SearchDice(Dice<int>& dice, int up, int front) {
if (dice.Print() != up) {
for (int i = 0; i < 3; ++i) {
dice.Roll(Dice<int>::north);
if (dice.Print() == up) {
break;
}
}
if (dice.Print() != up) {
dice.Roll(Dice<int>::east);
if (dice.Print() != up) {
dice.Roll(Dice<int>::west);
dice.Roll(Dice<int>::west);
}
}
}
dice.Roll(Dice<int>::north);
if (dice.Print() != up) {
for (int i = 0; i < 3; ++i) {
dice.Roll(Dice<int>::east);
if (dice.Print() == up) {
break;
}
}
}
dice.Roll(Dice<int>::east);
return dice.Print();
}
int main() {
int number[6]{};
for (int i = 0; i < 6; ++i) {
cin >> number[i];
}
int n{};
cin >> n;
while (n--) {
int up{}, front{};
cin >> up >> front;
Dice<int> dice(number);
cout << dice.Search(up, front) << endl;;
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORL(i,a,b) for(LL i=(a);i<(b);++i)
#define REPL(i,n) FORL(i,0,n)
#define SIZE(a) int((a).size())
#define ALL(a) (a).begin(),(a).end()
const double EPS = 1e-10;
const double PI = acos(-1.0);
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k, const Iterator last)
{
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1)
{
if (*--itr1 < *itr2)
{
Iterator j = k;
while (!(*itr1 < *j)) ++j;
iter_swap(itr1,j);
++itr1;
++j;
itr2 = k;
rotate(itr1,j,last);
while (last != j)
{
++j;
++itr2;
}
rotate(k,itr2,last);
return true;
}
}
rotate(first,k,last);
return false;
}
inline double get_time_sec(void){
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count())/1000000000;
}
template<typename T>
T gcd(T a, T b) {
if(a > b) swap(a, b);
if(a == 0) return b;
else return gcd(b%a, a);
}
template<typename T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template<typename T>
map<T, T> prime_list(T n) {
map<T, T> ret;
for(T i = 2; i*i <= n; i++) {
if(n % i == 0) {
ret[i] = 0;
while(n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if(n != 1) ret[n]++;
return ret;
}
#define MOD 1000000007
LL mypow(LL a, LL n) {
if(n == 1) return a % MOD;
if(n % 2 == 1) return (a * mypow(a, n-1)) % MOD;
LL t = mypow(a, n/2);
return (t * t) % MOD;
}
int main(void) {
int n, t;
cin >> n >> t;
VPII v(2 * n, PII(0, 0));
REP(i, n) {
int tmp;
cin >> tmp;
v[i].first = tmp;
v[i].second = 1;
v[i + n].first = tmp+t;
v[i + n].second = -1;
}
auto cmp = [](PII x, PII y){
return x.first < y.first;
};
sort(ALL(v), cmp);
int start = 0;
int l = 0;
int ans = 0;
REP(i, 2 * n) {
l += v[i].second;
if(l == 1 && v[i].second == 1) start = v[i].first;
if(l == 0) ans += v[i].first - start;
}
cout << ans << endl;
}
| 0
| 14,202,696
|
#include <iostream>
#include <algorithm>
typedef long long ll;
using namespace std;
int main(void){
ll N,M;cin>>N>>M;
ll S_TOTAL = min(M / 2, N);
M = M - 2 * S_TOTAL;
ll M_TOTAL = M / 4;
cout << S_TOTAL + M_TOTAL << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
while(1){
int N,A,B,C,X;
cin>>N>>A>>B>>C>>X;
if(N == 0 && A == 0 && B == 0 && C == 0 && X == 0){
break;
}
vector<int> Y;
for(int i = 0;i < N;++i){
int temp;
cin>>temp;
Y.push_back(temp);
}
int X_d;
int f = 0;
int s = 0;
for(int e : Y){
while(1){
if(s == 0 && e == X){
break;
}
else{
if(f == 10000){
f = -1;
break;
}
else{
X_d = (A*X + B) % C;
X = X_d;
++f;
}
}
if(X_d == e){
break;
}
}
if(f == -1){
break;
}
s = 1;
}
cout<<f<<endl;
}
return 0;
}
| 0
| 85,384,721
|
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
#include <string>
#include <bitset>
#include <tuple>
#include <cmath>
#include <map>
template<typename T> bool chmax( T &a, const T &b ) { if ( a <= b ) { a = b; return ( true ); } else { return ( false ); } }
template<typename T> bool chmin( T &a, const T &b ) { if ( a >= b ) { a = b; return ( true ); } else { return ( false ); } }
using namespace std;
using ll = long long;
using ull = unsigned long long;
using Pll = pair<ll, ll>;
using Pull = pair<ull, ull>;
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define rep( i, n ) for ( int i = 0; i < (int)( n ); ++i )
#define reps( i, n ) for ( int i = 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 arep( i, v ) for ( auto &&i : ( v ) )
template<typename T> T gcd( const T a, const T b ) { return ( b ? gcd( b, a % b ) : a ); }
#define ALL( c ) ( c ).begin(), ( c ).end()
#define RALL( c ) ( c ).rbegin(), ( c ).rend()
#define UNIQUE( c ) ( c ).erase( unique( ( c ).begin(), ( c ).end() ), ( c ).end() )
constexpr ll MOD = 1000000007LL;
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
template<typename T = ll> class UnionFind {
public:
UnionFind( T n ) { rep( i, n ) { par.resize( n ); siz.resize( n ); par[i] = i; siz[i] = 1; } }
T find( T x ) { if ( x == par[x] ) return ( x ); else return( par[x] = find( par[x] ) ); }
void unite( T x, T y ) { T xx = find( x ); T yy = find( y ); if ( xx == yy ) return;
if ( siz[xx] <= siz[yy] ) swap( xx, yy ); par[yy] = xx; siz[xx] += siz[yy]; }
private:
vector<T> par, siz;
};
template<typename T = ll> T power( T a, T b, T m = MOD ) {
T res = 1;
while ( b > 0 ) { if ( b & 1 ) res = res * a % m;
a = a * a % m; b >>= 1; }
return ( res );
}
void replace( string &s, string t, string r ) {
string::size_type p = 0;
while ( ( p = s.find( t, p ) ) != string::npos ) {
s.replace( p, t.length(), r );
p += r.length();
}
}
int main()
{
int A, B;
cin >> A >> B;
vector<vector<int>> v( 100, vector<int>( 100, 0 ) );
for ( int i = 0; i < 50; i++ )
{
for ( int j = 0; j < 100; j++ )
{
v[i][j] = 1;
}
}
--A, --B;
int black = 0;
for ( ; black < B / 50; black++ )
{
for ( int j = 1; j < 100; j += 2 )
{
v[2 * black + 51][j] = 1;
}
}
for ( int i = 0; i < B % 50; i++ )
{
v[2 * black + 51][i * 2 + 1] = 1;
}
int white = 0;
for ( ; white < A / 50; white++ )
{
for ( int j = 1; j < 100; j += 2 )
{
v[2 * white + 1][j] = 0;
}
}
for ( int i = 0; i < A % 50; i++ )
{
v[2 * white + 1][i * 2 + 1] = 0;
}
cout << "100 100" << endl;
vector<string> res( 100 );
for ( int i = 0; i < 100; i++ )
{
for ( int j = 0; j < 100; j++ )
{
res[i] += ( v[i][j] ? '#' : '.' );
}
}
arep( it, res ) cout << it << endl;
return ( 0 );
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <time.h>
#include <math.h>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <sstream>
#include <string>
#include <bitset>
using namespace std;
#define FOR(I,F,N) for(int I = F; I < (int)(N); I++)
#define rep(i, n) FOR(i, 0, n)
#define FIN(V) cout<<V<<endl
#define pb push_back
#define INF (1 << 30)
typedef pair<int, int> P;
typedef long long ll;
typedef priority_queue<int> pq;
int StrToInt(string);
string IntToStr(int);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main(void){
int n, m;
while(cin >> n >> m){
if(n+m == 0)break;
cout << min(n,m) << " " << max(n,m) << endl;
}
return 0;
}
| 0
| 91,980,539
|
#include<bits/stdc++.h>
using namespace std;
long long mod=1e9+7;
long long INF=1e7;
double EPS = 1e-12;
const long long lim = 1e6+100;
typedef long long int lld;
typedef long long ll;
#define rep(i,a,n) for(long long int i = (a); i <= (n); ++i)
#define repD(i,a,n) for(long long int i = (a); i >= (n); i--)
#define mset(a, v) memset(a, v, sizeof(a))
#define Error(x...) { cout << "(" << #x << ")" << " = ( "; printIt(x); }
template <typename T1> void printIt(T1 t1) { cout << t1 << " )" << endl; }
template <typename T1, typename... T2>
void printIt(T1 t1, T2... t2) { cout << t1 << " , "; printIt(t2...); }
#define popcount __builtin_popcountll
ll powP(ll x, ll y) {
ll ans = 1, po = x % mod;
while(y > 0) {
if(y & 1) ans = ans * po % mod;
y >>= 1; po = po * po % mod;
}
return ans;
}
ll findGcd(ll a, ll b){
while(a != 0) { ll temp = b % a; b = a; a = temp; }
return b;
}
set<ll> S[lim];
ll Array[lim], Prime[lim];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
lld T,i,p,j,l,e,r,b,c,k,m,q,a,d,w,x,y,u,v,z,t,curr,prev,sum=0,val,countA=0,indicator=0,pos,h,minA,maxA,type,n,ans=0,left,right;
string A,B;
A = "Yes", B="No";
cin>>n>>l;
rep(i,1,n) cin>>Array[i];
indicator=0;
rep(i,1,n-1) {
if(Array[i]+Array[i+1]>=l) indicator=1, val=i;
}
if(indicator==0) cout<<"Impossible"<<endl;
else {
cout<<"Possible"<<endl;
rep(j,1,val-1) cout<<j<<endl;
repD(j,n-1,val) cout<<j<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MOD = 1e9+7;
int main(){
ll K, A, B; cin >> K >> A >> B;
ll cnt = 1;
if(A+2 >= B){
cout << K+1 << endl;
return 0;
}
else{
for(int i = 0; i < K; i++){
if(cnt == A) {
int itr = (K-i)/2;
int p = (K-i)%2;
if(p == 1){
cnt += itr*(B-A) + 1;
}
else{
cnt += itr*(B-A);
}
break;
}
else cnt++;
}
cout << cnt << endl;
}
}
| 0
| 35,181,696
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int w,h,x,y;
cin>>w>>h>>x>>y;
double ans=(double)w*h/2;
int num=0;
if(w==x*2&&h==y*2) num++;
cout<<fixed<<setprecision(15)<<ans<<" "<<num<<endl;
}
|
#include<bits/stdc++.h>
#include<string.h>
typedef long long int ll;
#define all(x) (x).begin(), (x).end()
using namespace std;
int nxt() {
int x;
cin >> x;
return x;
}
ll nxtl(){
ll x;
cin>>x;
return x;
}
void SieveOfEratosthenes(int n,vector <int> &primes)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p])
primes.push_back(p);
}
ll max(ll a,ll b)
{
if(a>b)
return a;
return b;
}
ll power(ll x, ll y,ll mod)
{
ll temp;
if( y == 0)
return 1;
temp = power(x, y/2,mod);
if (y%2 == 0)
return (temp*temp)%mod;
else
return (((x*temp)%mod)*temp)%mod;
}
ll binomialCoeff(ll n, ll k)
{
ll C[k+1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++)
{
for (ll j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j-1];
}
return C[k];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int x=nxt(),a=nxt(),b=nxt();
if(b-a<=0)
cout<<"delicious\n";
else if(b-a<=x)
cout<<"safe\n";
else
cout<<"dangerous\n";
return 0;
}
| 0
| 69,769,300
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll=long long;
using ld=long double;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int keta(int n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int ketasum(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
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 n;
int main(void) {
cin>>n;
cout << n / 3 << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll MAXN = 1e5 + 5;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
ll m, k;
cin >> m >> k;
if(k > ((1 << m) - 1)){
cout << -1 << endl;
return 0;
}
if(m == 0){
if(k == 0){
cout << 0 << " " << 0 << endl;
}else{
cout << -1 << endl;
}
return 0;
}
if(m == 1){
if(k == 0){
cout << "0 0 1 1" << endl;
}else{
cout << -1 << endl;
}
return 0;
}
vector < ll > v;
for(int i = 0;i < (1 << m); i++){
if(i == k) continue;
v.push_back(i);
cout << i << " ";
}
cout << k << " ";
reverse(v.begin(), v.end());
for(auto i : v) cout << i << " ";
cout << k << " ";
cout << endl;
}
| 0
| 5,307,970
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int) (n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int) (n); i++)
#define _GLIBCXX_DEBUG
template <typename T>
bool chmax(T &a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1e8;
typedef long long ll;
ll n;
int f(ll a, ll b){
string s, t;
s = to_string(a), t = to_string(b);
return max(s.length(), t.length());
}
int main(){
cin >> n;
int ans = INF;
for(ll i = 1; i*i <= n; i++){
if(n % i == 0){
ans = min(ans, f(i, n/i));
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <cstdlib>
#include <stack>
#include <queue>
#include <list>
#include <vector>
using namespace std;
class c_counting
{
private:
public:
c_counting();
void f_input();
};
c_counting::c_counting()
{
}
void c_counting::f_input()
{
int n;
int i;
int j;
int m;
int d_max;
static int a[2000000];
static int c[2000000];
cin >> n;
d_max = 0;
for ( i = 0; i < n; ++i){
cin >> a[i];
if (d_max < a[i])d_max =a[i];
}
for ( i = 0; i < d_max + 1; ++i){
c[i] = 0;
}
for ( i = 0; i < n; ++i){
c[a[i]] = c[a[i]] + 1;
}
m = 0;
for ( i = 0; i <= d_max + 1; ++i){
for ( j = 0; j < c[i]; ++j){
if ( c[i] > 0 ){
if ( m == n-1 ){
cout << i << endl;
}else{
cout << i << " ";
++m;
}
}
}
}
}
int main(){
c_counting counting01;
counting01.f_input();
return 0;
}
| 0
| 35,170,646
|
#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=1; i<n; i++)
cin>>b[i];
ll sum=b[1]+b[n-1];
for(int i=1;i<n-1;i++){
sum+=min(b[i],b[i+1]);
}
cout<<sum<<endl;
}
|
#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
#define ll long long
#define rep(i,n) for (ll i = 0; i < (n); i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define FORR(i,a,b)for(ll i=(a);i<=(b);i++)
#define repR(i,n) for(ll i=n;i>=0;i--)
#define all(v)(v).begin(),(v).end()
#define rall(v)(v).rbegin(),(v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout<<(x)<<"\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll,vector<ll>,greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n" )
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n" )
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
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 dx[4]={0,1,0,-1};
ll dy[4]={1,0,-1,0};
int main(){
ll n;
cin>>n;
vll a(0);
a.pb(1);
ll cu=6;
for(int i=1;cu<=n;i++){
a.pb(cu);
cu*=6;
}
cu=9;
for(int i=1;cu<=n;i++){
a.pb(cu);
cu*=9;
}
sort(all(a));
vll dp(n+1,INF);
dp[0]=0;
rep(i,n){
rep(j,sz(a)){
if(a[j]+i<=n){
chmin(dp[i+a[j]],dp[i]+1);
}
}
}
COUT(dp[n]);
}
| 0
| 84,352,444
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = int64_t;
using pint = pair<int, int>;
int main()
{
string s, t;
cin >> s >> t;
cout << t + s << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define Rep(i, n) for(ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(),(a).end()
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll 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;
}
}
ll Len(ll n) {
ll s=0;
while(n!=0) s++, n/=10;
return s;
}
ll Sint(ll n) {
ll m=0,s=0,a=n;
while(a!=0) s++, a/=10;
for(ll i=s-1;i>=0;i--) m+=n/((ll)pow(10,i))-(n/((ll)pow(10,i+1)))*10;
return m;
}
ll Svec(vector<ll> v){
ll n=0;
for(ll i=0;i<v.size();i++) n+=v[i];
return n;
}
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;
}
ll Factorial(ll n){
ll m=1;
while(n>=1) m*=n,n--;
return m;
}
void runlength(string s,vector<pair<char,ll>> &p){
ll x=1;
if(s.size()==1){
p.push_back(pair<char,ll>(s[0],1));
}
for(ll i=0;i<s.size()-1;i++){
if(s[i]==s[i+1]){
x++;
if(i==s.size()-2){
p.push_back(pair<char,ll>(s[i],x));
}
}else{
p.push_back(pair<char,ll>(s[i],x));
x=1;
if(i==s.size()-2){
p.push_back(pair<char,ll>(s[s.size()-1],x));
}
}
}
}
ll 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;
}
string Toupper(string s){
string ans="";
rep(i,s.size()){
if('a'<=s[i] && s[i]<='z') ans+=(char)s[i]-32;
else ans+=s[i];
}
return ans;
}
string Tolower(string s){
string ans="";
rep(i,s.size()){
if('A'<=s[i] && s[i]<='Z') ans+=(char)s[i]+32;
else ans+=s[i];
}
return ans;
}
const int MAX_N=100010;
vector<bool> sieve_of_eratosthenes(){
vector<bool> isPrime(MAX_N+1,true);
for(int i=2;i<=MAX_N;i++){
if(isPrime[i]){
for(int j=2*i;j<=MAX_N;j+=i){
isPrime[j]=false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n){
vector<pint> ans;
for(ll p=2;p<=sqrt(n);p++){
if(n%p!=0) continue;
ll cnt=0;
while(n%p==0){
n/=p;
cnt++;
}
ans.push_back(make_pair(p,cnt));
}
if(n!=1) ans.push_back(make_pair(n,1));
return ans;
}
int main() {
IOS;
ll n;
cin>>n;
vector<ll> a(n),b(n);
rep(i,n) cin>>a[i];
rep(i,n) cin>>b[i];
if(Svec(a)<Svec(b)){
cout<<-1<<endl;
return 0;
}
ll cnt=0;
ll tmp=0;
vector<ll> v;
rep(i,n){
if(a[i]<b[i]){
cnt++;
tmp+=b[i]-a[i];
}else if(a[i]>b[i]){
v.push_back(a[i]-b[i]);
}
}
sort(ALL(v),greater<ll>());
vector<ll> sum;
if(v.size()>=1) sum.push_back(v[0]);
rep(i,v.size()-1){
sum.push_back(sum[i]+v[i+1]);
}
if(tmp>=1) cout<<cnt+((lower_bound(ALL(sum),tmp)-sum.begin()))+1<<endl;
else cout<<cnt<<endl;
}
| 0
| 68,645,948
|
#include<iostream>
#include<cstdio>
using namespace std;
struct Node
{
int value;
char c;
};
void BubbleSort(Node a[],int n)
{
for(int i=0;i<n-1;i++)
for(int j=n-1;j>=i+1;j--)
if(a[j].value<a[j-1].value)
swap(a[j],a[j-1]);
}
void SelectionSort(Node a[],int n)
{
for(int i=0;i<n-1;i++)
{
int minj=i;
for(int j=i+1;j<n;j++)
if(a[j].value<a[minj].value)
minj=j;
swap(a[i],a[minj]);
}
}
void IsStable(Node a[],Node temp[],int n)
{
int k=0;
char str[36];
for(int i=1;i<=9;i++)
for(int j=0;j<n;j++)
if(temp[j].value==i)
{
str[k]=temp[j].c;
k++;
}
for(int i=0;i<n;i++)
{
if(a[i].c!=str[i])
{
cout<<"Not stable"<<endl;
return ;
}
}
cout<<"Stable"<<endl;
}
int main()
{
int n;
cin>>n;
Node C[n];
for(int i=0;i<n;i++)
cin>>C[i].c>>C[i].value;
Node temp[n];
for(int i=0;i<n;i++)
temp[i].c=C[i].c,temp[i].value=C[i].value;
Node b[n];
for(int i=0;i<n;i++)
b[i].c=C[i].c,b[i].value=C[i].value;
BubbleSort(C,n);
for(int i=0;i<n-1;i++)
cout<<C[i].c<<C[i].value<<' ';
cout<<C[n-1].c<<C[n-1].value<<endl;
IsStable(C,temp,n);
SelectionSort(b,n);
for(int i=0;i<n-1;i++)
cout<<b[i].c<<b[i].value<<' ';
cout<<b[n-1].c<<b[n-1].value<<endl;
IsStable(b,temp,n);
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main (){
int n;
vector< pair<int,int> > tm;
while(cin>>n && n){
tm.clear();
char ch1,ch2;
int h,m,s;
for(int i=0;i<n;i++){
cin>>h>>ch1>>m>>ch2>>s;
tm.push_back(make_pair(h*3600+m*60+s,1));
cin>>h>>ch1>>m>>ch2>>s;
tm.push_back(make_pair(h*3600+m*60+s,-1));
}
sort(tm.begin(),tm.end());
int ans=0;
int co=0;
for(int i=0;i<(int)tm.size();i++){
co+=tm[i].second;
ans = max(co,ans);
}
cout<<ans<<endl;
}
return 0;
}
| 0
| 77,821,984
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string a[100], b[100];
bool check(int i, int j)
{
if ((n - i) < m || (n - j) < m)
{
return false;
}
for (int ax = i, bx = 0; bx < m; ax++, bx++)
{
for (int ay = j, by = 0; by < m; ay++, by++)
{
if (a[ax][ay] != b[bx][by])
return false;
}
}
return true;
}
int main()
{
cin >> n >> m;
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
for (int i = 0; i < m; i++)
{
cin >> b[i];
}
if (m > n)
{
cout << "No" << endl;
return 0;
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (a[i][j] == b[0][0])
{
if (check(i, j))
{
cout << "Yes" << endl;
return 0;
}
}
}
}
cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll solve() {
ll N, a;
cin >> N;
ll ans = 0, h = 0;
for ( int i = 0; i < N; i++ ) {
cin >> a;
if ( a < h+1 ) continue;
if ( a == h+1 ) {
h++;
continue;
}
ans += (a-1) / (h+1);
if ( h == 0 ) h++;
}
return ans;
}
int main() {
auto ans = solve();
cout << ans << "\n";
return 0;
}
| 0
| 93,597,708
|
#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;
cin >> n;
vector<int> a(n),a2(n);
rep(i,n) cin >> a[i],a2[i]=a[i];
::sort(a2.rbegin(),a2.rend());
int first_max = a2[0];
int second_max = a2[1];
rep(i,n){
if(a[i] == first_max){
cout << second_max <<endl;
}else{
cout <<first_max <<endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int k, s;
cin >> k >> s;
int ans=0;
for (int i=0; i<=k; i++){
for (int j=0; j<=k; j++){
if (s-i-j<=k && s-i-j>=0) ans++;
}
}
cout << ans << "\n";
}
| 0
| 57,477,401
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<iomanip>
using namespace std;
int main(){
int n;
cin>>n;
int a[n+1],b[n];
for(int i=0;i<=n;i++)cin>>a[i];
for(int i=0;i<n;i++)cin>>b[i];
long long ans=0;
for(int i=0;i<n;i++){
if(a[i]+a[i+1]>=b[i]){
ans+=b[i];
if(b[i]>=a[i]){
a[i+1]-=b[i]-a[i];
}
}else{
ans+=a[i]+a[i+1];
a[i+1]=0;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stack>
#include <queue>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <bitset>
#include <list>
#include <sstream>
#include <set>
#include <functional>
using namespace std;
#define INT_MAX 1 << 30
#define MAX 100
typedef long long ll;
int n;
char a[10],b[10];
int ans;
int change(char c)
{
int anss;
if(c == 'm')anss = 1000;
else if(c == 'c')anss = 100;
else if(c == 'x')anss = 10;
else if(c == 'i')anss = 1;
return anss;
}
int c_d(char d[100])
{
int summ = 0;
for (int i = 0; i < strlen(d); i += 1)
{
if ((d[i] >= 50) && (d[i] <= 57))
{
int j = i+1;
int a = int(d[i]-48);
int b = change(d[j]);
summ += a*b;
i++;
}
else
{
summ += change(d[i]);
}
}
return summ;
}
int main()
{
scanf("%d",&n);
while (n--)
{
scanf("%s",a);
scanf("%s",b);
ans = c_d(a)+c_d(b);
int j = 0,a1,k = 0;
char d[100] = {0};
a1 = ans;
while (a1)
{
a1 /= 10;
j++;
}
int t1,t2,t,j1=j;
for (int l = 0; l < j; l += 1)
{
t1 = ans%int(pow(10.0,j1));
t2 = pow(10.0,j1-1);
t = t1/t2;
if(t == 1)
{
if(j1 == 4) d[k] = 'm';
else if(j1 == 3) d[k] = 'c';
else if(j1 == 2) d[k] = 'x';
else if(j1 == 1) d[k] = 'i';
}
else if(t!=0)
{
int k1 = k+1;
if(j1 == 4) {d[k] = (t+48);d[k1] = 'm';}
else if(j1 == 3){d[k] = (t+48);d[k1] = 'c';}
else if(j1 == 2){d[k] = (t+48);d[k1] = 'x';}
else if(j1 == 1){d[k] = (t+48);d[k1] = 'i';}
k++;
}
if(t!=0)k++;
j1--;
}
cout << d << endl;
}
return 0;
}
| 0
| 99,241,394
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <iomanip>
#include <stack>
#include <queue>
#include <numeric>
#include <map>
#include <unordered_map>
#include <set>
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(x) x.begin(), x.end()
#define pb push_back
#define mod 1000000007
using ll = long long;
using namespace std;
int main(){
int A, B, C;
cin >> A >> B >> C;
cout << (A^B^C) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for (int i = 0; i < (a); i++ )
#define FOR(i, m, n) for(int i = m; i < n; i++)
typedef pair<int,int> P;
typedef long long ll;
const int INF = 1001001001;
const int MOD = 1000000007;
const double PI=acos(-1);
int H,W;
int dx[2] = {1,0};
int dy[2] = {0,1};
void bfs(vector<vector<char>> &c, vector<vector<int>> &seen) {
int cnt = 0;
queue<P> qw,qb;
vector<vector<bool>> queued(H,vector<bool>(W,false));
bool now = true;
if (c[0][0]=='.') {
qw.push(make_pair(0,0));
queued[0][0] = true;
}
else {
qb.push(make_pair(0,0));
queued[0][0] = true;
}
while(qb.size() || qw.size()) {
if (now) {
while(qw.size()) {
auto q = qw.front();
qw.pop();
int h,w;
h = q.first;
w = q.second;
seen[h][w] = cnt;
rep(i,2) {
if (h+dy[i]>=H || w+dx[i]>=W) {
continue;
}
else if (seen[h+dy[i]][w+dx[i]]!=INF) continue;
else if (queued[h+dy[i]][w+dx[i]] == true) continue;
else if (c[h+dy[i]][w+dx[i]]=='#') {
qb.push(make_pair(h+dy[i],w+dx[i]));
queued[h+dy[i]][w+dx[i]] = true;
}
else {
qw.push(make_pair(h+dy[i],w+dx[i]));
queued[h+dy[i]][w+dx[i]] = true;
}
}
}
cnt++;
now = false;
}
if (!now) {
while(qb.size()) {
auto q = qb.front();
qb.pop();
int h,w;
h = q.first;
w = q.second;
seen[h][w] = cnt;
rep(i,2) {
if (h+dy[i]>=H || w+dx[i]>=W) {
continue;
}
else if (seen[h+dy[i]][w+dx[i]]!=INF) continue;
else if (queued[h+dy[i]][w+dx[i]] == true) continue;
else if (c[h+dy[i]][w+dx[i]]=='.') {
qw.push(make_pair(h+dy[i],w+dx[i]));
queued[h+dy[i]][w+dx[i]] = true;
}
else {
qb.push(make_pair(h+dy[i],w+dx[i]));
queued[h+dy[i]][w+dx[i]] = true;
}
}
}
cnt++;
now = true;
}
}
}
int main(){
cin >> H >> W;
vector<vector<char>> c(H,vector<char>(W));
vector<vector<int>> seen(H,vector<int>(W,INF));
rep(h,H) {
string tmp;
cin >> tmp;
rep(w,W) {
c[h][w] = tmp[w];
}
}
bfs(c,seen);
if (c[H-1][W-1]=='.') {
cout << seen[H-1][W-1]/2 << endl;
}
else {
cout << seen[H-1][W-1]/2+1 << endl;
}
}
| 0
| 72,189,382
|
#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;
ll gcd(ll x,ll y){
if(x%y==0)return y;
return gcd(y,x%y);
}
ll LCM(int a, int b){
return a*b/gcd(a,b);
}
int main(void)
{
int n;
cin>>n;
map<string, int> mp;
ll ans=0;
rep(i,0,n){
string s;
cin>>s;
sort(s.begin(),s.end());
ans+=mp[s];
mp[s]++;
}
cout<<ans<<endl;
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;i>=0;i--)
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
typedef long long 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; }
int main(void){
string s;
cin >> s;
string t=s;
reverse(ALL(t));
if(t!=s){
cout << "No";
return 0;
}
int n=(s.size()-1)/2;
string s1=s.substr(0,n);
string t1=s1;
reverse(ALL(t1));
if(t1!=s1){
cout << "No";
return 0;
}
string s2=s.substr((s.size()+3)/2-1,n);
string t2=s2;
reverse(ALL(t2));
if(t2!=s2){
cout << "No";
return 0;
}
cout << "Yes";
return 0;
}
| 0
| 28,553,134
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie();
ll n, a, b;
cin>>n>>a>>b;
ll ans = 0;
ll g = a+b;
ll d = n/g;
ans += a*d;
n -= d*g;
ans += min(n, a);
cout<<ans;
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int INF = (1LL << 30) - 1;
int MOD = 1e9+7;
int N,M;
vector<P> graph[200010];
vector<int> dist;
bool dfs(int now, int d){
dist[now] = d;
for(auto p:graph[now]){
if(dist[p.first] != INF){
if(dist[p.first] != d + p.second)return true;
continue;
}
if(dfs(p.first, d + p.second))return true;
}
return false;
}
main(){
cin >> N >> M;
int num = 0;
rep(i,0,M){
int a,b,c;
cin >> a >> b >> c;
a--,b--;
graph[a].emplace_back(b,c);
graph[b].emplace_back(a,-c);
num = a;
}
dist = vector<int>(N,INF);
rep(i,0,N){
int cost = dist[i];
if(cost == INF)cost = 0;
if(dist[i] == INF && dfs(i, 0) ){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
| 0
| 45,289,061
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
bool b = true;
for(int i = 0; i <= 1000; i++) {
if(i * 0.08 - A >= 0 && i * 0.08 - A < 1 && i * 0.1 - B >= 0 && i * 0.1 - B < 1) {
cout << i << endl;
b = false;
break;
}
}
if(b) {
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
const long long MOD = 1e9+7;
using namespace std;
#define ll long long
#define ar array
int main () {
ios::sync_with_stdio(0);
cin.tie(0);
string S,T;
cin >> S >> T;
int ans = 0;
for (int i = 0; i < 3; i++) {
if (S[i]==T[i]) ans++;
}
cout << ans << endl;
return 0;
}
| 0
| 35,538,365
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
typedef long long ll;
using namespace std;
int main(){
int n;
cin>>n;
ll ans=1,x;
vector<ll> a(n);
for(int i=0;i<n;++i){
cin>>a[i];
ans*=a[i];
if(a[i]==0){
cout<<0<<endl;
return 0;
}
}
x=ans;
for(int i=n-1;i>=0;--i){
if(x==0){
cout<<-1<<endl;
return 0;
}
x/=a[i];
}
if(x!=1||ans>1000000000000000000)
cout<<-1<<endl;
else
cout<<ans<<endl;
return 0;
}
|
#include <numeric>
#include <bits/stdc++.h>
#include <utility>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <math.h>
#include <string>
#define ll long long
#define ull unsigned long long
#define make(type,x) type x; cin>>x
#define make2(type,x,y) type x,y; cin>>x>>y
#define fr(x,y) for(long long x=0;x<y;x++)
#define makevec(x,y,n) vector <x> y(n); for(ll i=0;i<n;i++) cin>>y[i]
#define M (ll)1000000007
#define MM (ll) 1e8
#define INF (ll) 1e18
# define IOS ios_base::sync_with_stdio(false); cin.tie(NULL)
using namespace std;
template <typename T>
T modpow(T base, T exp, T modulus) {
base %= modulus;
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
bool sortbysec(const pair <ll,ll> &a,const pair <ll,ll> &b){
return a.second<b.second;
}
struct cmp {
bool operator() (const pair<int, int> &a, const pair<int, int> &b) const {
int lena = a.second - a.first + 1;
int lenb = b.second - b.first + 1;
if (lena == lenb) return a.first < b.first;
return lena > lenb;
}
};
struct c_h {
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
x ^= FIXED_RANDOM;
return x ^ (x >> 16);
}
};
ll calcpow(ll x, ll y)
{
ll temp;
if(y == 0)
return 1;
temp = calcpow(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
{
if(y > 0)
return x * temp * temp;
else
return (temp * temp) / x;
}
}
ll gcd(ll a, ll b){
if(b==0) return a;
return gcd(b,a%b);
}
ll egcd(ll a, ll b, ll &x,ll &y){
if(b==0){
x=1;
y=0;
return a;
}
ll x1;
ll y1;
ll g=egcd(b,a%b,x1,y1);
x=y1;
y=x1-y1*(a/b);
return g;
}
bool isprime(ll a){
bool flag=1;
for(ll i=2;i*i<=a;i++){
if(a%i==0) {flag=0; break;}
}
return flag;
}
ll dx8[8]={1,0,-1,0,1,-1,1,-1};
ll dy8[8]={0,1,0,-1,1,-1,-1,1};
ll dx4[4]={0,0,1,-1};
ll dy4[4]={1,-1,0,0};
int main(){
IOS;
make2(ll,r,g);
make2(ll,b,n);
ll ans=0;
for(ll i=0;i<=n/r;i++){
for(ll j=0;j<=(n-i*(r))/b;j++){
if(n-i*r-j*b>=0 &&(n-i*r-j*b)%g==0) ans++;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 94,022,026
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> a(N);
for(int i=0;i<N;i++){
cin >> a.at(i);
}
int ans=0;
for(int i=1;i<N;){
if(a.at(i)==a.at(i-1)){
ans++;
i+=2;
}else{
i++;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main(void){
string a,b;
cin>>a>>b;
if(a==b){
cout<<"H"<<endl;
}
else if(a=="D"&&b=="H"){
cout<<"D"<<endl;
}
else if(a=="H"&&b=="D"){
cout<<"D"<<endl;
}
}
| 0
| 99,757,560
|
#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, amin = 0, bmin = 0;
cin >> N;
vector<int> p(N), ad(N + 1, 0), bd(N + 1, 0), a(N, 0), b(N, 0);
rep(i, N) {
cin >> p[i];
bd[p[i]] = -i;
p[i]--;
ad[p[i]] = i;
}
rep(i, N - 1) {
a[i + 1] = a[i] + 1;
a[i + 1] += ad[i + 1];
b[i + 1] = b[i] - 1;
b[i + 1] += bd[i + 1];
amin = min(amin, a[i + 1]);
bmin = min(bmin, b[i + 1]);
}
rep(i, N) {
a[i] -= amin - 1;
b[i] -= bmin - 1;
}
rep(i, N) {
cout << a[i];
if (i == N - 1) cout << "\n";
else cout << " ";
}
rep(i, N) {
cout << b[i];
if (i == N - 1) cout << "\n";
else cout << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
typedef long long int lli;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<lli> vlli;
typedef vector<bool> vb;
long long int max(long long int a,long long int b){
if(a>b)
return a;
else
return b;
}
long long int min(long long int a,long long int b){
if(a<b)
return a;
else
return b;
}
long long int binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b) {
if (b == 0)
return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
void solve(){
int n,m;
cin>>n>>m;
vector<string> grid(n);
for(int i = 0;i<n;i++){
cin>>grid[i];
}
vector<vector<int>> dp(n,vector<int>(m));
if(grid[0][0]=='#')
dp[0][0] = 1;
for(int i = 1;i<n;i++){
if(grid[i][0]=='#'){
if(grid[i-1][0]=='#')
dp[i][0] = dp[i-1][0];
else
dp[i][0] = dp[i-1][0]+1;
}
else{
dp[i][0] = dp[i-1][0];
}
}
for(int i = 1;i<m;i++){
if(grid[0][i]=='#'){
if(grid[0][i-1]=='#')
dp[0][i] = dp[0][i-1];
else
dp[0][i] = dp[0][i-1]+1;
}
else{
dp[0][i] = dp[0][i-1];
}
}
for(int i = 1;i<n;i++){
for(int j = 1;j<m;j++){
if(grid[i][j]=='#'){
dp[i][j] = min(grid[i-1][j]=='#'?dp[i-1][j]:dp[i-1][j]+1,grid[i][j-1]=='#'?dp[i][j-1]:dp[i][j-1]+1);
}
else{
dp[i][j] = min(dp[i-1][j],dp[i][j-1]);
}
}
}
cout<<dp[n-1][m-1];
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while(t--){
solve();
}
}
| 0
| 76,040,351
|
#include<stdio.h>
int main()
{
char s[105], t[105];
scanf("%s", &s);
scanf("%s", &t);
printf("%s%s\n", t, s);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <iomanip>
#include <set>
#include <ctime>
#include <tuple>
#include <bitset>
#include <assert.h>
#include <deque>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA() cerr << "AAAAA" << endl
#define debug_() cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
for (int i = 0; i < v.size(); i++) \
{ \
cout << v[i] << " "; \
} \
cout << endl;
using Graph = vector<vector<int>>;
int main()
{
int n;
cin >> n;
vector<ll> a(n + 1);
for (int i = 0; i <= n; i++)
{
cin >> a[i];
}
if (n == 0)
{
if (a[0] == 1)
{
cout << 1 << endl;
}
else
{
cout << -1 << endl;
}
return 0;
}
if (a[0] != 0)
{
cout << -1 << endl;
return 0;
}
vector<ll> MAX(n + 1);
MAX[n] = a[n];
for (int i = n - 1; i >= 0; i--)
{
MAX[i] = MAX[i + 1] + a[i];
}
MAX[0] = 1;
ll ans = 1;
for (int i = 1; i <= n; i++)
{
MAX[i] = min((MAX[i - 1] - a[i - 1]) * 2, MAX[i]);
ans += MAX[i];
if (MAX[i] <= 0)
{
cout << -1 << endl;
return 0;
}
}
if(MAX[n] < a[n]){
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
}
| 0
| 43,006,342
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <math.h>
#include <string>
#include <numeric>
#include <algorithm>
#include <utility>
using std::cout;
using std::cin;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a, ll b) {
while (b != 0) {
auto tmp = a;
a = b;
b = tmp % a;
}
return a;
}
ll lcm(ll a, ll b) {
return (a * b) / gcd(a, b);
}
void oneCase () {
int n, m;
cin >> n >> m;
vector<vector<int>> d(n, vector<int>(n, 1e9));
vector<int> a(m);
vector<int> b(m);
vector<int> c(m);
for (int i = 0; i < m; ++i ) {
int x, y, z;
cin >> x >> y >> z;
--x;
--y;
d[x][y] = z;
d[y][x] = z;
c[i] = z;
a[i] = x;
b[i] = y;
d[x][x] = 0;
d[y][y] = 0;
}
for (int mid = 0; mid < n; ++mid) {
for (int l = 0; l < n; ++l) {
for (int r = 0; r < n; ++r) {
d[l][r] = min(d[l][r], d[l][mid] + d[mid][r]);
}
}
}
int res = m;
for (int i = 0; i < m; ++i) {
bool sh = false;
for (int mid = 0; mid < n; ++mid) {
if (c[i] == d[a[i]][mid] - d[mid][b[i]]) {
sh = true;
break;
}
}
if (sh) {
--res;
}
}
cout << res << "\n";
}
int main() {
int t = 1;
while (t > 0) {
oneCase();
--t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const vector<int> match = {0,2,5,5,4,5,6,3,7,6};
void chmax(string &a, string b){
if(a == "-") a = b;
else if(a.size() < b.size()) a = b;
else if(a.size() == b.size()){
if(a < b) a = b;
}
}
int main(){
int n, m;
cin >> n >> m;
vector<int> a(m);
for(int i=0; i<m; i++){
cin >> a[i];
}
vector<string> dp(20000, "-");
dp[0] = "";
for(int i=0; i<=n; i++){
if(dp[i] == "-") continue;
for(auto num : a){
chmax(dp[i + match[num]],
dp[i] + (char)('0' + num)
);
}
}
cout << dp[n] << endl;
return 0;
}
| 0
| 79,563,732
|
#include <bits/stdc++.h>
typedef long long int LL;
typedef unsigned long long int ULL;
using namespace std;
LL a[200005];
LL prefix[200005];
unordered_map<LL, LL> m;
LL n, k;
LL mod(LL x) {
return ((x % k) + k) % k;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
if (k == 1) {
cout << 0 << endl;
return 0;
}
prefix[0] = 0;
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + a[i];
}
LL ans = 0;
m[0] = 1;
for (int i = 1; i <= n; i++) {
ans += m[mod(prefix[i] - i)];
if (i >= k - 1) {
m[mod(prefix[i - k + 1] - (i - k + 1))]--;
}
m[mod(prefix[i] - i)]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1 << 30;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
int main(){
int N;
string S;
cin >> N >> S;
int ans = 0;
for (char i = '0'; i <= '9'; i++) for (char j = '0'; j <= '9'; j++) for (char k = '0'; k <= '9'; k++) {
vector<char> v{i, j, k};
int t = 0;
for (int s = 0; s < N; s++) {
if (S[s] == v[t]) t++;
if (t >= 3) {
ans++;
break;
}
}
}
cout << ans << '\n';
}
| 0
| 21,057,122
|
#include <iostream>
#include <string>
using namespace std;
int main(){
int a[256];fill(a,a+256,0);
string line;
while(getline(cin,line))
for(int i=0;i<line.length();++i)
a[tolower(line[i])]++;
for(char i='a';i<='z';++i)
cout<<i<<" : "<<a[i]<<endl;
return 0;
}
|
#include<stdio.h>
#include<iostream>
#include<string>
#include<memory>
#include<cmath>
#include<algorithm>
#include<vector>
double min_double(double a,double b){
if(a<b) return a;
else return b;
}
void swap(int *x,int *y){
int tmp;
tmp=*x;
*x=*y;
*y=tmp;
}
int gcd(int a,int b){
if(a<b) swap(&a,&b);
if(b<1) return -1;
if(a%b==0) return b;
return gcd(b,a%b);
}
int lcm(int a,int b){
return a * b / gcd(a,b);
}
int main(){
int N;
std::cin>>N;
std::vector<int> A(N+1);
long long sum=0;
for(int i=0;i<N+1;i++) {
std::cin>>A[i];
sum+=A[i];
}
std::vector<int> B(N);
for(int i=0;i<N;i++) {
std::cin>>B[i];
if(B[i]>=A[i]){
B[i]-=A[i];
A[i]=0;
if(B[i]>=A[i+1]) A[i+1]=0;
else A[i+1]-=B[i];
}
else A[i]-=B[i];
}
long long rest=0;
for(int i=0;i<N+1;i++) rest+=A[i];
long long ans=sum-rest;
std::cout<<ans<<std::endl;
return 0;
}
| 0
| 54,200,991
|
#include<stdio.h>
#include<string.h>
int main(){
char moji[2][27]={"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
char uketori[1202];
int i,j,mojisuu,count[26]={0};
while(fgets(uketori,sizeof(uketori),stdin)!=NULL){
mojisuu=strlen(uketori);
for(i=0;i<mojisuu;i++){
for(j=0;j<26;j++){
if(uketori[i]==moji[0][j]){
count[j]++;
}else if(uketori[i]==moji[1][j]){
count[j]++;
}
}
}
}
for(i=0;i<26;i++){
printf("%c : %d\n",moji[0][i],count[i]);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i,n) for (int i = 0; i < (n); ++i)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF=1LL<<60;
const int inf=(1<<30)-1;
const int mod=1e9+7;
int dx[8]={1,0,-1,0,-1,-1,1,1};
int dy[8]={0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;cin >> n;
vector<int> x(n+1),y(n+1);
vector<pair<int,int>> p;
rep(i,n) {
int t;cin >> t;
cin >> x[i] >> y[i];
p.push_back({t,i});
}
x[n]=0,y[n]=0;
p.push_back({0,n});
sort(p.begin(),p.end());
for(int i=0;i<n;i++){
int dis=abs(x[p[i].second]-x[p[i+1].second])+abs(y[p[i].second]-y[p[i+1].second]);
if(dis>p[i+1].first-p[i].first){
cout << "No" << endl;
return 0;
}
if(dis%2!=(p[i+1].first-p[i].first)%2){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
| 0
| 7,463,528
|
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define precise(n,k) fixed << setprecision(k) << n
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define piii tuple<int, int, int>
#define pll pair<ll, ll>
#define plll tuple<ll, ll, ll>
#define X first
#define Y second
#define debug(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
string to_string(string s) {
return '"' + s + '"';
}
string to_string(bool b) {
return (b ? "true" : "false");
}
template <typename A, typename B>
string to_string(const pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename T>
string to_string(const vector<T> &v) {
bool first = true;
string res = "{";
for (const T &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string((T)x);
}
res += "}";
return res;
}
template<class T>
void println(const T &data) {
#ifndef ONLINE_JUDGE
cout << to_string((T)data) << endl;
#endif
}
const int MOD = int(1e9+7);
const ll oo = (ll)(1e9+20);
const ll lloo = (ll)(1e18)+40;
template<class T>
vector<T> divisors(T number) {
vector<T> solutions;
for (T i = 1; i <= sqrt(number); ++i) {
if (number % i == 0) {
if (number/i == i) {
solutions.push_back(i);
} else {
solutions.push_back(i);
solutions.push_back(number/i);
}
}
}
return solutions;
}
class Task {
public:
ll N;
ll solve(istream &in, ostream &out) {
in >> N;
if(sqrt(N) == ((ll)sqrt(N))) return (ll)sqrt(N)*2 -2;
vector<ll> divs = divisors<ll>(N);
sort(rall(divs));
ll ans = lloo;
for(ll i = 0; i < divs.size(); ++i) {
if(ans > (N/divs[i] + divs[i])) {
ans = (N/divs[i] + divs[i]) - 2;
}
}
return ans;
}
void run(istream &in, ostream &out) {
int t;
in >> t;
while(t--) {
out << solve(in, out) << endl;
}
}
};
auto main() -> int {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Task solver;
istream &in(cin);
ostream &out(cout);
cout << solver.solve(in, out) << endl;
return 0;
}
|
#include<bits/stdc++.h>
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
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
#define loop(i,a,b) for (ll i = a; i <= b; i++)
#define rloop(i,a,b) for (ll i = a; i >= b; i--)
#define ms(a,x) memset(a,x,sizeof a)
#define ll long long int
#define ff first
#define ss second
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define pb push_back
#define nl cout<<"\n"
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/(gcd(a,b))
#define sq(a) (a)*(a)
#define sz(a) a.size()
#define mod 1000000007
#define PI 2*acos(0.0)
int main()
{
IOS
int T=1;
while(T--)
{
ll n,m;
cin>>n>>m;
ll a[n];
loop(i,0,n-1)
{
cin>>a[i];
a[i]/=2;
}
ll t=__builtin_ctz(a[0]);
loop(i,0,n-1)
{
if(__builtin_ctz(a[i])!=t)
{
cout<<0;
return 0;
}
a[i]>>=t;
}
m>>=t;
ll lm=1;
loop(i,0,n-1)
{
lm=lcm(lm,a[i]);
if(lm>m)
{
cout<<0;
return 0;
}
}
m/=lm;
cout<<(m+1)/2;
}
return 0;
}
| 0
| 89,400,227
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <math.h>
#include <cassert>
#define rep(i,n) for(int i = 0; i < n; ++i )
using namespace std;
using ll = long long;
using P = pair<int,int>;
const int inf = 1e5+1;
ll m[inf];
int main() {
ll n,k;
cin >> n >> k;
rep(i,n){
ll a,b;
cin >> a >> b;
m[a]+=b;
}
int ans;
rep(i,inf){
k -= m[i];
if(k<=0){
ans = i;
break;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char S;
char check[100] = {'a', 'i' ,'u', 'e', 'o'};
bool flag = false;
cin >> S;
for (int i = 0; i < 5; i++){
if (S == check[i]) flag = true;
}
if(flag) {
cout << "vowel" << endl;
} else {
cout << "consonant" << endl;
}
}
| 0
| 50,453,947
|
#include <bits/stdc++.h>
int main(void)
{
std::string s;
std::cin >> s;
bool flag = false;
if (s[2] == s[3]) {
if (s[4] == s[5]) {
flag = true;
}
}
if (flag) {
std::cout << "Yes" << std::endl;
}
else {
std::cout << "No" << std::endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n;
int vis[100005]={0};
vector<int> grph[100005];
int mo=1000000007;
pair<int,int> dfs(int a,int p)
{
if(vis[a]==0)
{
vis[a]=1;
pair<int,int> ans;
ans.first=1;
ans.second=1;
for(auto &k:grph[a])
{
if(k!=p)
{
pair<int,int> temp=dfs(k,a);
ans.first=(ans.first * (temp.first + temp.second)%mo)%mo;
ans.second=(ans.second * temp.first)%mo;
}
}
return ans;
}
}
int32_t main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin>>n;
for(int i=0;i<(n-1);i++)
{
int x,y;
cin>>x>>y;
grph[x].push_back(y);
grph[y].push_back(x);
}
pair<int,int> ans=dfs(1,0);
cout<<(ans.first + ans.second)%mo;
}
| 0
| 60,987,112
|
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
int main()
{
int n;
cin >> n;
vector<int> p(n);
int i;
rep(i,n) cin >> p[i];
vector<int> ind(n);
rep(i,n)
{
ind[p[i]-1] = i;
}
multiset<int> s;
s.insert(-1);
s.insert(-1);
s.insert(n);
s.insert(n);
ll ans = 0;
int num;
for(num=n-1;num>=0;num--)
{
int j = ind[num];
auto it = s.upper_bound(j);
int a,b,c,d;
it++;
d = *it;
it--;
c = *it;
it--;
b = *it;
it--;
a = *it;
ll ks = 0;
ll kans = b-a;
kans *= (c-j);
ks += kans;
kans = j-b;
kans *= (d-c);
ks += kans;
ans += ks*(num+1);
s.insert(j);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<vector<int>> Graph;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
int main() {
string S, T; cin >> S >> T;
if(S.size() < T.size()) {
cout << "UNRESTORABLE" << endl;
return 0;
}
else {
string s = S;
bool judge = false;
for(int i = S.size() - T.size(); i >= 0; i--) {
bool can = true;
for(int j = 0; j < T.size(); j++) {
if(S[i + j] != T[j] && S[i + j] != '?') {
can = false;
break;
}
}
if(can) {
judge = true;
for(int j = 0; j < S.size(); j++) {
if(s[j] == '?') s[j] = 'a';
}
for(int j = 0; j < T.size(); j++) {
s[i + j] = T[j];
}
break;
}
}
if(judge) cout << s << endl;
else cout << "UNRESTORABLE" << endl;
return 0;
}
}
| 0
| 13,654,466
|
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <deque>
int main(){
std::string s;
std::cin >> s;
int n = s.length();
std::vector<char > notx;
for (int i=0; i<n; i++){
if (s[i]=='x') continue;
notx.push_back(s[i]);
}
bool canreverse = true;
int notxsize = notx.size();
if (notxsize==0){
printf("0\n");
return 0;
}
for (int i=0; i<=(notxsize-1)/2; i++){
if (notx[i]!=notx[notxsize-i-1]) {
canreverse = false;
break;
}
}
if (!canreverse){
printf("-1\n");
} else {
std::vector<int > gap(notxsize+1, 0);
int counter = 0;
for (int i=0; i<n; i++){
if (s[i]!='x') {
counter++;
} else {
gap[counter]++;
}
}
int ans = 0;
for (int i=0; i<=notxsize/2; i++){
ans += abs(gap[i]-gap[notxsize-i]);
}
printf("%d\n", ans);
}
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 g[15][15];
const int mod = 1000000007;
int main() {
int n;
cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
ll ans = 0;
rep(i,60) {
ll x = 0;
rep(j,n) if (a[j]>>i&1) x++;
ll now = x*(n-x)%mod;
rep(j,i) now = now*2%mod;
ans += now;
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 0
| 5,398,104
|
#include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
ll N, ans;
int main()
{
cin >> N;
for (ll i = 2, M = N; i * i <= M; i++)
{
ll z = i;
while (N % z == 0)
ans++, N /= z, z *= i;
while (N % i == 0)
N /= i;
}
cout << ans + (N != 1) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n - 1; i >= 0; i--)
#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 SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define VSORTR(v) sort(v.rbegin(), v.rend());
#define ALL(v) (v).begin(),(v).end()
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll mod = 1e9 + 7;
const ll inf = 1e18;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll n, k;
cin >> n >> k;
vll a(n);
REP(i, n) cin >> a[i];
ll end = 0;
REP(x, k) {
vll c(n + 1), b(n);
REP(i, n) {
c[max(i - a[i], 0LL)]++;
c[min(i + a[i] + 1, n)]--;
}
b[0] = c[0];
REP(i, n - 1) {
b[i + 1] = min(b[i] + c[i + 1], n);
}
a = b;
end = 1;
REP(i, n) {
if (a[i] != n) end = 0;
}
if (end) break;
}
REP(i, n) cout << a[i] << " ";
cout << endl;
return 0;
}
| 0
| 98,747,310
|
#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
char s[10];
int main(){
scanf("%s",s);
if(s[2]==s[3]&&s[4]==s[5]) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
|
#include <bits/stdc++.h>
#define EPS (1e-10)
#define rep(i, a, b) for (int i = a; i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = b - 1; i >= (int)(a); --i)
#define all(a) a.begin(), a.end()
using namespace std;
using ll = long long;
using vi = vector<int>;
using vb = vector<bool>;
using vll = vector<ll>;
using vd = vector<double>;
using vvi = vector<vi>;
using vvb = vector<vb>;
constexpr int MOD = 1000000007;
struct V {
ll val;
int l, m, n;
V(ll val = 0, int l = 0, int m = 0, int n = 0) : val(val), l(l), m(m), n(n) {}
bool const operator<(const V& v) const { return val < v.val; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int x, y, z, k;
cin >> x >> y >> z >> k;
vll a(x), b(y), c(z);
rep(i, 0, x) { cin >> a[i]; }
rep(i, 0, y) { cin >> b[i]; }
rep(i, 0, z) { cin >> c[i]; }
sort(all(a), greater<ll>());
sort(all(b), greater<ll>());
sort(all(c), greater<ll>());
vector<vvb> seen(x, vvb(y, vb(z, false)));
seen[0][0][0] = true;
priority_queue<V> pq;
pq.emplace(a[0] + b[0] + c[0], 0, 0, 0);
rep(_, 0, k) {
V p = pq.top();
pq.pop();
cout << p.val << endl;
if (p.l + 1 < x && !seen[p.l + 1][p.m][p.n]) {
pq.emplace(a[p.l + 1] + b[p.m] + c[p.n], p.l + 1, p.m, p.n);
seen[p.l + 1][p.m][p.n] = true;
}
if (p.m + 1 < y && !seen[p.l][p.m + 1][p.n]) {
pq.emplace(a[p.l] + b[p.m + 1] + c[p.n], p.l, p.m + 1, p.n);
seen[p.l][p.m + 1][p.n] = true;
}
if (p.n + 1 < z && !seen[p.l][p.m][p.n + 1]) {
pq.emplace(a[p.l] + b[p.m] + c[p.n + 1], p.l, p.m, p.n + 1);
seen[p.l][p.m][p.n + 1] = true;
}
}
return 0;
}
| 0
| 23,400,893
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (int i = (int)a; i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define MOD 1000000007
#define INF 1000000000
#define PI 3.14159265359
#define EPS 1e-12
int main(void) {
char left[15] = {'q', 'w', 'e', 'r', 't', 'a', 's', 'd',
'f', 'g', 'z', 'x', 'c', 'v', 'b'};
char right[11] = {'y', 'u', 'i', 'o', 'p', 'h', 'j', 'k', 'l', 'n', 'm'};
while (true) {
string str;
cin >> str;
if(str == "#") break;
bool isleft;
REP(i, 15) if (left[i] == str[0]) isleft = true;
REP(i, 11) if (right[i] == str[0]) isleft = false;
int cnt = 0;
FOR(i, 1, str.size()) {
if (isleft) {
REP(j, 11) {
if (right[j] == str[i]) {
cnt++;
isleft = false;
}
}
} else {
REP(j, 15) {
if (left[j] == str[i]) {
cnt++;
isleft = true;
}
}
}
}
cout << cnt << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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;
}
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define LLINF (1e18)
#define PI (acos(-1))
#define MOD (1000000007)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (ll i = 0; i < n; i++)
{
cin >> a[i];
}
vector<ll> rui(n + 1, 0);
for (ll i = 0; i < n; i++)
{
rui[i + 1] = rui[i] + a[i];
}
vector<ll> kouho;
for (ll i = 0; i <= n; i++)
{
for (ll j = i + 1; j <= n; j++)
{
kouho.push_back(rui[j] - rui[i]);
}
}
sort(RALL(kouho));
vector<ll> now = kouho;
for (ll i = 63; i >= 0; i--)
{
vector<ll> next;
for (ll j = 0; j < (ll)now.size(); j++)
{
if (now[j] & (1LL << i))
{
next.push_back(now[j]);
}
}
if ((ll)next.size() >= k)
{
now = next;
}
}
ll ans;
for (ll i = 0; i < k; i++)
{
i == 0 ? ans = now[i] : ans &= now[i];
}
cout << ans << endl;
}
| 0
| 85,173,584
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
using namespace std;
typedef pair<int,int> P;
const int MOD=1000000007;
int main()
{
int h,w;cin>>h>>w;
int a,b;cin>>a>>b;
for(int i=0;i<h;i++)
{
for(int j=0;j<w;j++)
{
if((j<a && i<b)||(j>=a && i>=b))cout<<0;
else cout<<1;
}
cout<<"\n";
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int x[100010],w[100010];
int ans[100010];
int n,L,r,t;
long long fldl;
int main()
{
scanf("%d%d%d",&n,&L,&t);
for(int i = 1;i <= n;i++)
{
scanf("%d%d",&x[i],&w[i]);
if(w[i] == 2)w[i] = -1;
}
for(int i = 1;i <= n;i++)
{
int len = x[i] + w[i] * t;
if (len > 0) (fldl += len / L) %= n;
else if (len < 0) (fldl += (len + 1) / L - 1) %= n;
ans[i] = (len % L + L) % L;
}
sort(ans + 1 ,ans + n + 1);
fldl = (fldl + n) % n;
for(int i = fldl + 1;i <= n;i++)printf("%d\n",ans[i]);
for(int i = 1;i <= fldl;i++) printf("%d\n",ans[i]);
return 0;
}
| 0
| 41,196,003
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, t, r;
cin >> x >> t;
r = x - t;
if (r < 0) {
cout << 0 << '\n';
} else {
cout << r << '\n';
}
}
|
#include<algorithm>
#include<bitset>
#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;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
int main() {
ll n; cin >> n;
ll a[100001]; INITA(a, 0, 100000, 0);
ll b[100001]; INITA(b, 0, 100000, 0);
ll a_tot = 0;
ll b_tot = 0;
REP(i, n) { cin >> a[i]; a_tot += a[i]; }
REP(i, n) { cin >> b[i]; b_tot += b[i]; }
if (a_tot < b_tot) {
cout << -1 << endl;
} else {
vector<ll> plus;
ll minus_tot = 0;
ll res = 0;
REP(i, n) {
ll diff = a[i] - b[i];
if (diff < 0) {
minus_tot -= diff;
res++;
} else if (diff > 0) {
plus.push_back(diff);
}
}
sort(ALL(plus));
while (minus_tot > 0) {
ll p = plus[plus.size()-1];
plus.pop_back();
res++;
minus_tot -= p;
}
cout << res << endl;
}
return 0;
}
| 0
| 31,054,491
|
#include<bits/stdc++.h>
using namespace std;
#define lli long long int
#define rep(i,s,e) for(int i=s;i<e;i++)
#define endl '\n'
int main(){
int k,n;cin>>k>>n;
vector<int>A(n),D(n);
rep(i,0,n)cin>>A[i];
rep(i,0,n-1)D[i]=A[i+1]-A[i];
D[n-1]=abs(k+A[0]-A[n-1]);
int diff=0;
for(int d:D){
diff=max(diff,d);
}
cout<<k-diff<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
#define N 1000000007
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = 5e5;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9 + 7;
vll adj[MAXN];ll vis[MAXN]={};
ll T = 1;
ll n, x, k, m, r, sum = 0, a, b;
string s;
void MAIN() {
cin >> n >> a >> b;
ll rem = n%(a+b);
ll quo = n/(a+b);
ll ans = quo * a + min(rem,a);
cout<<ans;
}
int main() {
fastio; randomINT;
while (T--) {
MAIN();
}
return 0;
}
| 0
| 27,595,476
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
#define MAX_N 5000
#define MAX_K 5000
int N, K;
ll A[MAX_N];
bool dp[MAX_N][MAX_K];
ll max(ll a, ll b) { return a > b ? a : b; }
bool need(int i) {
for (int n = 0; n < N; n++)
for (int k = 0; k < K; k++)
dp[n][k] = false;
dp[0][0] = true;
int elm_num = 0;
for (int a_idx = 0; a_idx < N; a_idx++) {
if (a_idx == i) continue;
ll a = A[a_idx];
for (int k = 0; k < K; k++)
dp[elm_num+1][k] = dp[elm_num][k] || (a <= k && dp[elm_num][k-a]);
elm_num++;
}
for (ll k = max(K-A[i], 0); k < K; k++)
if (dp[N-1][k]) return true;
return false;
}
int no_need() {
sort(A, A+N);
int l = -1, r = N;
while (l + 1 < r) {
int m = (l + r) / 2;
if (need(m)) r = m;
else l = m;
}
return l + 1;
}
int main(int argc, char **argv) {
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i];
int ans = no_need();
cout << ans << endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int n, l;
vector<int> x;
vector< vector<int> > dbl;
int f(int a, int b){
if(a > b) return f(b, a);
int res = 0;
while(a < b){
for(int k = 0; k < 20; k++){
if(dbl[a][k] >= b){
if(k == 0){
a = b;
res++;
}else{
a = dbl[a][k-1];
res += (1 << (k-1));
}
break;
}
}
}
return res;
}
int main(void){
cin >> n;
x.assign(n, 0);
for(int i=0;i<n;i++) cin >> x[i];
cin >> l;
dbl.assign(n, vector<int>(20, 0));
int nx = 0;
for(int i=0;i<n;i++){
while(nx+1 < n && x[nx+1] <= x[i]+l) nx++;
dbl[i][0] = nx;
}
for(int k=1;k<20;k++){
for(int i=0;i<n;i++){
dbl[i][k] = dbl[dbl[i][k-1]][k-1];
}
}
int q;
cin >> q;
while(q--){
int a, b;
cin >> a >> b;
cout << f(--a, --b) << endl;
}
}
| 0
| 75,576,240
|
#include <iostream>
using namespace std;
typedef long long ll;
ll inf = 1e9+7;
ll n,m;
int main(){
cin >> n >> m;
ll X[n+1],Y[m+1];
for(int i=1;i<=n;i++){
cin >> X[i];
}
for(int i=1;i<=m;i++){
cin >> Y[i];
}
ll x = 0, y = 0;
for(ll i=1;i<=n;i++){
x = (x + (i-1)*X[i] - (n-i)*X[i])%inf;
}
for(ll i=1;i<=m;i++){
y = (y + (i-1)*Y[i] - (m-i)*Y[i])%inf;
}
cout << (x*y)%inf << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> iint;
typedef pair<ll,ll> llll;
#define ALL(x) (x).begin(),(x).end()
const ll zero = 0;
const ll INF = 3000000000000000000;
const int inINF = 1000000000;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int main(){
int N, M;
cin >> N >> M;
vector<ll> x(N), y(N), z(N);
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i] >> z[i];
}
vector<vector<ll>> W(8, vector<ll> (N));
for (int i = 0; i < 8; i++) {
if(i & 1){
for (int j = 0; j < N; j++) {
W[i][j] = x[j];
}
}
else{
for (int j = 0; j < N; j++) {
W[i][j] = -x[j];
}
}
if(i & 2){
for (int j = 0; j < N; j++) {
W[i][j] += y[j];
}
}
else{
for (int j = 0; j < N; j++) {
W[i][j] -= y[j];
}
}
if(i & 4){
for (int j = 0; j < N; j++) {
W[i][j] += z[j];
}
}
else{
for (int j = 0; j < N; j++) {
W[i][j] -= z[j];
}
}
}
for (int i = 0; i < 8; i++) {
sort(ALL(W[i]), greater<ll> ());
}
ll tmp;
ll ans = 0;
for (int i = 0; i < 8; i++) {
tmp = 0;
for (int j = 0; j < M; j++) {
tmp += W[i][j];
}
ans = max(ans, tmp);
}
printf("%lld\n", ans);
}
| 0
| 21,062,256
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> p_ll;
typedef vector<pair<ll, ll>> vec_p;
#define ture ture
#define flase false
#define falg flag
#define REP(i, x) for (ll i = 0; i < (ll)(x); i++)
#define REPS(i, x) for (ll i = 1; i <= (ll)(x); i++)
#define RREP(i, x) for (ll i = ((ll)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (ll i = ((ll)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;
const int INF = pow(2, 30) - 1;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll N;
string S;
cin >> N;
vector<ll> a(N);
REP(i, N)
cin >> a.at(i);
sort(a.begin(), a.end());
ll a_max = a.at(N / 2);
ll a_min = a.at(N / 2 - 1);
cout << a_max - a_min << endl;
}
|
#include <bits/stdc++.h>
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();}
template<class T> inline T sqr(T x) {return x*x;}
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL,LL> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQGI;
typedef priority_queue<int, VI, greater<int>> PQLI;
typedef priority_queue<PII> PQGP;
typedef priority_queue<PII, VPII, greater<int>> PQLP;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EB emplace_back
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a)*(a))
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define SORTR(c) sort((c).rbegin(), (c).rend())
#define LB lower_bound
#define UB upper_bound
#define NEXP next_permutation
#define FI first
#define SE second
#define Vmin(a) *min_element((a).begin(),(a).end())
#define Vmax(a) *max_element((a).begin(),(a).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORR(i,a,b) for(int i = (b-1);i>=a;i--)
#define REPR(i,n) FORR(i,0,n)
#define BFOR(bit,a,b) for(int bit = (a); bit < (1<<(b)); ++bit)
#define BREP(bit,n) BFOR(bit,0,n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX/2;
const LL LINF = LLONG_MAX/2;
const int RINF = INT_MIN/2;
const LL RLINF = LLONG_MIN/3;
const LL MOD = 1e9+7;
const LL MODD = 998244353;
const int MAX = 510000;
inline bool Eq(double a, double b) { return fabs(b - a) < EPS; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define COUT(x) cout << (x) << endl
#define COUT2(x,y) cout << (x) << " " << (y) << endl
#define COUT3(x,y,z) cout << (x) << " " << (y) << " " << (z) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define BC(x) __builtin_popcountll(x)
void cYes(){ COUT("Yes");exit(0); }
void cNo(){ COUT("No");exit(0); }
void cYES(){ COUT("YES");exit(0); }
void cNO(){ COUT("NO");exit(0); }
void cyes(){ COUT("yes");exit(0); }
void cno(){ COUT("no");exit(0); }
void cMINU(){ COUT(-1);exit(0); }
void cZERO(){ COUT(0);exit(0); }
VI dx = {1,0,-1,0,1,1,-1,-1};
VI dy = {0,1,0,-1,1,-1,1,-1};
VC dc = {'R','D','L','U'};
VS ds = {"R","D","L","U","RD","RU","LD","LU"};
LL Gcd(LL a, LL b) {return __gcd(a,b);}
LL Lcm(LL a, LL b) {return a/Gcd(a,b)*b;}
LL ModPow(LL A, LL N, LL M){
LL res = 1;
while(N>0){
if(N&1) res = res * A % M;
A = A * A % M;
N >>= 1;
}
return res;
}
template<class T> void VCout(vector<T> &v){
int N = SZ(v);
REP(i,N){
cout << v.at(i);
if(i == N-1) cout << endl;
else cout << " ";
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int n,K; cin >> n >> K;
VPLL poi(n);
REP(i,n){
cin >> poi.at(i).FI >> poi.at(i).SE;
}
LL ans = LINF;
REP(i,n)REP(j,n)REP(k,n)REP(l,n){
LL xu = poi.at(i).FI, xd = poi.at(j).FI;
LL yu = poi.at(k).SE, yd = poi.at(l).SE;
if(xu<xd)continue;
if(yu<yd)continue;
int cnt = 0;
REP(w,n){
if(xu>=poi.at(w).FI && poi.at(w).FI>=xd && yu>=poi.at(w).SE && poi.at(w).SE>=yd){
cnt++;
}
}
if(cnt >= K){
chmin(ans,(xu-xd)*(yu-yd));
}
}
COUT(ans);
return 0;
}
| 0
| 58,167,930
|
#include <bits/stdc++.h>
using namespace std;
#define arep(i, x, n) for (int i = int(x); i < (int)(n); i++)
#define rep(i, n) for (long long i = 0; i < n; ++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9 + 7
using ll = long long;
int main() {
ll n;
ll k;
cin >> k >> n;
vector<ll> a(n);
rep(i, n){
cin >> a[i];
}
ll temp = a[0] + (k - a[n-1]);
arep(i, 1, n){
ll temp2 = a[i] - a[i - 1];
if(temp < temp2){
temp = temp2;
}
}
ll dist = k - temp;
cout << dist << endl;
}
|
#include <cstdio>
int m,nmin,nmax;
int P[205];
int diff[205];
int main(){
while(scanf("%d%d%d",&m,&nmin,&nmax)&&m&&nmin&&nmax){
for(int i=1;i<=m;i++) scanf("%d",P+i);
for(int i=1;i<=m-1;i++) diff[i]=P[i]-P[i+1];
int ans=nmax,difference=diff[ans];
for(int i=nmax;i>=nmin;i--)
if (diff[i]>difference) ans=i,difference=diff[i];
printf("%d\n",ans);
}
return 0;
}
| 0
| 58,266,463
|
#include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define ldb ldouble
typedef tuple<int, int, int> t3;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <ll, int> pli;
typedef pair <db, db> pdd;
int IT_MAX = 1 << 18;
const ll MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1);
const db ERR = 1e-10;
#define szz(x) (int)(x).size()
#define rep(i, n) for(int i=0;i<n;i++)
#define Se second
#define Fi first
int dis[1000050];
priority_queue <pii, vector<pii>, greater<pii>> Hx;
int main() {
int N, i;
scanf("%d", &N);
memset(dis, 0x3f, sizeof(dis));
for (i = 1; i <= 9; i++) {
dis[N*i] = 0;
Hx.emplace(0, N*i);
}
while (!Hx.empty()) {
pii u = Hx.top();
Hx.pop();
if (dis[u.second] != u.first) continue;
for (i = 0; i < 10; i++) {
int t = N * i + u.second;
if (dis[t / 10] > u.first + t % 10) {
dis[t / 10] = u.first + t % 10;
Hx.emplace(dis[t / 10], t / 10);
}
}
}
return !printf("%d\n", dis[0]);
}
|
#include<iostream>
#include<queue>
using namespace std;
int main(){
priority_queue<int> pq;
string order;
while(true){
cin >> order;
if(order == "insert"){
int key;
cin >> key;
pq.push(key);
}
else if(order == "extract"){
cout<<pq.top()<<endl;
pq.pop();
}
else if(order == "end"){
break;
}
}
return 0;
}
| 0
| 51,656,316
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n >> a;
while(n>=500){
n -= 500;
}
if(a >= n)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
#define int ll
const int INF=(int)2e18;
const int MOD = 1000000007;
const int PEG = 998244353;
long double pie=acos(-1);
typedef vector< int > vi;
typedef vector< string > vs;
typedef vector< vi > vvi;
typedef pair< int, int > pii;
typedef vector< pii > vpii;
#define X first
#define Y second
#define pb push_back
#define sz(a) (ll)(a).size()
#define all(a) (a).begin(),(a).end()
#define F(i,a,b) for(ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define Fo(i,a,b,j) for(ll i=a;i<=b;i+=j)
#define RFo(i,a,b,j) for(ll i=a;i>=b;i-=j)
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" "
#define out1(a,n) F(i,1,n)cout<<a[i]<<" "
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define popcount __builtin_popcountll
#define pfy cout<<"YES"
#define pfn cout<<"NO"
#define pfn1 cout<<"-1"
#define pf1 cout<<"1"
#define nl cout<<"\n"
#define watch(x) cout<<#x<<" is "<<x<<"\n"
#define dbg(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>void __f(const char* name,Arg1&& arg1);
template <typename Arg1,typename... Args>void __f(const char* names,Arg1&& arg1,Args&&... args);
ll binpow(ll x,ll y,ll p);
signed main()
{
#ifndef ONLINE_JUDGE
#endif
fast;
int n;
cin>>n;
string s;
cin>>s;
int ans=0;
F(i,0,999)
{
string tt=to_string(i);
tt="00"+tt;
tt=tt.substr(sz(tt)-3,3);
int cur=0;
F(i,0,n-1)
{
if(s[i]==tt[cur])
{
cur++;
if(cur==3)break;
}
}
if(cur==3)ans++;
}
cout<<ans;
return 0;
}
ll binpow(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1)
{
std::cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args)
{
const char *comma = strchr(names + 1, ',');
std::cout.write(names, comma - names) << " : " << arg1 << "\n";
__f(comma + 1, args...);
}
| 0
| 20,618,653
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ios::sync_with_stdio(false);
ll n;
cin >> n;
cout << n * (n-1) /2;
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, max = 0, maxNum = 1;
cin >> N;
for (int i = 1; i <= N; i++)
{
int cnt = 0;
int num = i;
while (num % 2 == 0)
{
cnt++;
num /= 2;
}
if (max < cnt)
{
max = cnt;
maxNum = i;
}
}
cout << maxNum << endl;
}
| 0
| 1,541,502
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define all(n) begin(n),end(n)
using ll = long long;
using P = pair<int,int>;
int main() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
rep(i,a) cin >> p[i];
rep(i,b) cin >> q[i];
rep(i,c) cin >> r[i];
sort(all(p));
sort(all(q));
sort(all(r));
reverse(all(p));
reverse(all(q));
reverse(all(r));
vector<ll> v;
ll ans = 0;
rep(i,x) v.push_back(p[i]);
rep(i,y) v.push_back(q[i]);
rep(i,c) v.push_back(r[i]);
sort(all(v));
reverse(all(v));
rep(i,x+y) ans += v[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll,ll> pl;
typedef vector<pl> vp;
const ll INF=1001001001;
const ll LINF=1001001001001001001;
const ll D4[]={0,1,0,-1,0};
const ll D8[]={0,1,1,0,-1,-1,1,-1,0};
#define _overload3(_1,_2,_3,name,...) name
#define _rep2(i,n) for(ll i=0;i<(n);++i)
#define _rep3(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(...) _overload3(__VA_ARGS__,_rep3,_rep2)(__VA_ARGS__)
#define _repe2(i,n) for(ll i=0;i<=(n);++i)
#define _repe3(i,a,b) for(ll i=(a);i<=(b);++i)
#define repe(...) _overload3(__VA_ARGS__,_repe3,_repe2)(__VA_ARGS__)
#define _rrep2(i,n) for(ll i=(n)-1;i>=0;i--)
#define _rrep3(i,a,b) for(ll i=(b)-1;i>=(a);i--)
#define rrep(...) _overload3(__VA_ARGS__,_rrep3,_rrep2)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
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;}
template<class T>
using pq=priority_queue<T,vector<T>,greater<T>>;
ll H;
ll W;
ll N;
vl a;
vl b;
void solve();
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin >> H;
cin >> W;
cin >> N;
a = vl(N);
b = vl(N);
for(int i = 0; i < N; ++i){
cin >> a[i];
cin >> b[i];
--a[i],--b[i];
}
solve();
}
void solve(){
map<ll,ll> mp;
rep(i,N)repe(j,-1,1)repe(k,-1,1){
ll ty=a[i]+j,tx=b[i]+k;
if(ty<1||ty>=H-1||tx<1||tx>=W-1)continue;
mp[ty*W+tx]++;
}
vl ans(10);
ans[0]=(H-2)*(W-2);
for(auto &p:mp)++ans[p.second],--ans[0];
rep(i,10)cout<<ans[i]<<endl;
}
| 0
| 53,739,436
|
#include <string>
#include <utility>
#include <iostream>
#define MAX 100
#define INF 100000000
int left[MAX];
int right[MAX];
int DP[MAX][MAX];
int main(){
int n;
std::cin >> n;
for(int i = 0; i < n; i++){
std::cin >> left[i];
std::cin >> right[i];
}
for(int i = 0; i < MAX; i++){
for(int j = 0; j < MAX; j++){
DP[i][j] = INF;
}
}
for(int k = 0; k < n; k++){
for(int l = 0; l + k < n; l++){
int r = l + k;
if(k == 0){
DP[l][r] = 0;
}else if(k == 1){
DP[l][r] = left[l] * right[l] * right[r];
}else{
for(int t = l; t < r; t++){
DP[l][r] = std::min(DP[l][r], DP[l][t] + DP[t + 1][r] + left[l] * right[t] * right[r]);
}
}
}
}
std::cout << DP[0][n - 1] << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto&(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) ll(x.size())
void yes() {
cout << "Yes" << endl;
exit(0);
}
void no() {
cout << "No" << endl;
exit(0);
}
int main() {
ll n;
cin >> n;
ll ct = 0, cx = 0, cy = 0;
vector<ll> t(n), x(n), y(n);
REP(i, n) { cin >> t[i] >> x[i] >> y[i]; }
REP(i, n) {
ll dt = t[i] - ct, dx = x[i] - cx, dy = y[i] - cy;
ll d = abs(dx) + abs(dy);
if (d > dt) {
no();
}
if ((dt - d) % 2 == 1) {
no();
}
cx = x[i];
cy = y[i];
ct = t[i];
}
yes();
}
| 0
| 87,791,641
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
const ll INF = 1LL << 60;
int main(){
ll n;
cin >> n;
ll count=0;
vector<ll> divisor;
for(ll i=1; i*i<=n; i++){
if(n%i==0){
divisor.push_back(i);
}
}
int len=divisor.size();
if(divisor.at(len-1) == sqrt(n)){
count = 2*divisor.at(len-1) - 2;
}
else{
ll div1 = divisor.at(len-1);
ll div2 = n/(divisor.at(len-1));
count = div1 + div2 - 2;
}
cout << count << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
struct SegTree {
ll n;
vector<ll> v;
SegTree(int size) {
n = 1;
while (n < size) n *= 2;
v = vector<ll>(2 * n - 1);
}
void add(int i, ll x) {
i += n - 1;
v[i] += x;
while (i > 0) {
i = (i - 1) / 2;
v[i] = v[2 * i + 1] + v[2 * i + 2];
}
}
ll query(int a, int b, int k, int l, int r) {
if (b <= l || r <= a) return 0;
if (a <= l && r <= b) return v[k];
ll c1 = query(a, b, 2 * k + 1, l, (l + r) / 2);
ll c2 = query(a, b, 2 * k + 2, (l + r) / 2, r);
return c1 + c2;
}
ll query(int a, int b) { return query(a, b, 0, 0, n); }
};
int main() {
int n, d, a;
cin >> n >> d >> a;
vector<P> w(n);
rep(i, n) cin >> w[i].first >> w[i].second;
sort(w.begin(), w.end());
ll ans = 0;
ll sum = 0;
priority_queue<P> pq;
rep(i, n) {
ll x = w[i].first;
ll h = w[i].second;
while (!pq.empty() && -pq.top().first < x) {
sum -= pq.top().second;
pq.pop();
}
h -= sum;
h = max(0ll, h);
int cnt = (h + a - 1) / a;
ans += cnt;
ll dmg = (ll)a * cnt;
sum += dmg;
pq.push({-(x + (ll)2 * d), dmg});
}
cout << ans << endl;
return 0;
}
| 0
| 32,777,114
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string A, B;
int ans;
cin >> A >> B;
if(A.at(0) == B.at(2)) {
ans++;
}
if(A.at(1) == B.at(1)) {
ans++;
}
if(A.at(2) == B.at(0)) {
ans++;
}
if(ans == 3) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int (i)=0;(i)<(n);++(i))
#define REPV(iter, v) for(auto (iter)=(v).begin(); (iter)!=(v).end();++(iter))
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
int main()
{
ll N;
cin >> N;
vector<ll> A(N, 0);
REP(i, N) cin >> A[i];
map<ll, ll> sumMap;
vector<ll> sumA(N, 0);
sumA[0] = A[0];
sumMap[sumA[0]]++;
REP(i, N - 1)
{
sumA[i + 1] = sumA[i] + A[i + 1];
sumMap[sumA[i + 1]]++;
}
ll ans = 0;
REPV(iter, sumMap)
{
if (iter->first == 0) ans += iter->second;
ans += iter->second * (iter->second - 1) / 2;
}
cout << ans << endl;
}
| 0
| 3,949,068
|
#include <bits/stdc++.h>
#include <string.h>
#include <stdio.h>
using namespace std;
using std::cout;
#include <algorithm>
#include <map>
int main(){
long long n,m=0;
cin>>n;
map<string,int>freq;
string x[n];
for(int i=0;i<n;i++)
{
cin>>x[i];
sort(x[i].begin(),x[i].end());
}
for(int i=0;i<n;i++)
{
freq[x[i]]++;
m+=(freq[x[i]]-1);
}
cout<<m<<endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <bitset>
#define ri register
#define inf 0x7fffffff
#define E (1)
#define mk make_pair
#define int long long
using namespace std; const int N=2000010, Mod=1e9+7;
inline int read()
{
int s=0, w=1; ri char ch=getchar();
while(ch<'0'||ch>'9') {if(ch=='-') w=-1; ch=getchar(); }
while(ch>='0'&&ch<='9') s=(s<<3)+(s<<1)+(ch-'0'), ch=getchar();
return s*w;
}
void print(int x) { if(x<0) x=-x, putchar('-'); if(x>9) print(x/10); putchar(x%10+'0'); }
int X,n,a[N],book[N];
signed main()
{
X=read()+100, n=read();
for(ri int i=1;i<=n;i++) a[i]=read()+100, book[a[i]]=1;
int mi=1e9, g=0;
for(ri int i=0;i<=300;i++)
{
if(book[i]) continue;
if(abs(i-X)<mi) mi=abs(i-X), g=i;
}
printf("%lld\n",g-100);
return 0;
}
| 0
| 67,412,772
|
#include<iostream>
#include<string>
int main(){
int q;
std::cin>>q;
int i,j,k;
std::string x,y;
int a[1001][1001];
int knum[q];
for(i=0; i<1001; i++){
for(j=0; j<1001; j++){
a[i][j]=0;
}
}
for(k=0; k<q; k++){
std::cin>>x;
std::cin>>y;
for(i=1; i<x.size()+1; i++){
for(j=1; j<y.size()+1; j++){
if(x[i-1]==y[j-1]){
a[i][j]=a[i-1][j-1]+1;
}else{
if(a[i-1][j]>a[i][j-1]){
a[i][j]=a[i-1][j];
}else{
a[i][j]=a[i][j-1];
}
}
}
}
knum[k]=a[x.size()][y.size()];
}
for(k=0; k<q; k++){
std::cout<<knum[k]<<"\n";
}
return 0;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <tuple>
#include <cassert>
#include <functional>
#include <set>
#include <deque>
#include <list>
using namespace std;
typedef long long ll;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
#define LNF __LONG_LONG_MAX__
const ll MOD = 1000000007;
const int MAX = 200000;
long long 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;
}
}
long long COM(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;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long gcd(long long x, long long y){
if(y==0) return x;
else return gcd(y,x%y);
}
long long lcm(long long x, long long y){
return x / gcd(x, y) * y;
}
long long com[200005];
void combination(long long n,long long k){
com[0] = 1;
for(int i=1;i<=k;i++){
com[i] = (com[i-1]*(n-i+1)%MOD)*modinv(i,MOD)%MOD;
}
}
int main(){
int N; cin >> N;
cout << N/3 << endl;
return 0;
}
| 0
| 36,394,986
|
#include <bits/stdc++.h>
using namespace std;
bool solve(int n) {
int cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (i == n % i) {
cnt++;
} else {
cnt += 2;
}
}
}
if (cnt == 8) {
return true;
} else {
return false;
}
}
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i += 2) {
if (solve(i)) ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(int)(n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main(){
int n, m;
cin >> n >> m;
vector<ll> h(n);
rep(i, n) cin >> h[i];
vector<bool> ok(n, true);
vector<int> cnt(n, 0);
rep(i, m){
int a, b;
cin >> a >> b;
a -= 1, b -=1;
if(h[a] < h[b]){
ok[a] = false, ok[b] = true;
cnt[a]++;
}else if(h[a] > h[b]){
ok[a] = true, ok[b] = false;
cnt[b]++;
}else{
ok[a] = ok[b] = false;
cnt[a]++; cnt[b]++;
}
}
int ans = 0;
rep(i, n) if(ok[i] && cnt[i]==0) ans++;
cout << ans << endl;
return 0;
}
| 0
| 59,199,072
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool A = false, B = false, C = false;
for (char c: S) {
if (c == 'a') A = true;
else if (c == 'b') B = true;
else C = true;
}
if (A && B && C) cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 5e5 + 10;
const ll mod = 1e9 + 7;
int main(){
ll k;cin >> k;
deque<ll>d;
if(k<10){cout << k;return 0;}
for(ll i = 1;i<10;i++) d.push_back(i);
k -= 9;
bool ok = 0;
while(true){
ll temp = d.front();
ll r = temp%10;
d.pop_front();
for(ll i = -1;i<=1;i++){
if(r==0&&i==-1) continue;
if(r==9&&i==1) continue;
d.push_back(temp*10+r+i);
k--;
if(!k) {cout << d.back();return 0;}
}
}
return 0;
}
| 0
| 51,957,505
|
#include<iostream>
using namespace std;
string s;
void read() {
cin >> s;
}
void work() {
for (int i = 3; i >= 0; --i) {
if (s.find(string(i, 'R')) != string::npos) {
cout << i << endl;
return;
}
}
}
int main() {
read();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define MOD 1000000007
int main(){
int N;
cin>>N;
vector<ll> a(N),b(N);
for(int i=0;i<N;i++){
cin>>a.at(i);
}
for(int i=0;i<N;i++){
cin>>b.at(i);
}
ll a_count=0,b_count=0;
for(int i=0;i<N;i++){
if(a.at(i)>b.at(i)){
b_count+=a.at(i)-b.at(i);
}else{
if((b.at(i)-a.at(i))%2==0){
a_count+=(b.at(i)-a.at(i))/2;
}else{
a_count+=(b.at(i)-a.at(i)-1)/2+1;
b_count++;
}
}
}
if(a_count>=b_count){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
}
| 0
| 5,690,242
|
#include<iostream>
#include<string>
int main()
{
while (true) {
std::string x;
std::cin >> x;
if (x == "0") break;
int sum = 0;
for (int i = 0; i < x.size()
; i++) {
sum += x[i] - '0';
}
std::cout << sum << std::endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
#define ok1 cerr<<"ok1\n";
#define ok2 cerr<<"ok2\n";
#define M LLONG_MAX
#define rep(i,n) for(ll i=0;i<n;++i)
#define REP(i,s,n) for(ll i=(s);i<(n);++i)
#define repr(i,n) for(ll i=n-1;i>=0;--i)
#define REPR(i,s,n) for(ll i=(s);i>=(n);--(i))
#define all(a) (a).begin(),(a).end()
#define reall(a) (a).rbegin(),(a).rend()
#define pb emplace_back
#define DOUBLE fixed << setprecision(15)
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define out(x, y) ((x) < 0 || h <= (x) || (y) < 0 || w <= (y))
#define TO_STRING(VariableName) # VariableName
#define debug(x) cerr<<TO_STRING(x)<<" is: "<<x<<" "<<endl;
const double pi = acos(-1.0L);
typedef vector<int> vi;
typedef vector<string> vs;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<char> vc;
typedef vector<double> vd;
typedef vector<bool> vb;
typedef deque<ll> dll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> TLL;
typedef vector<P> vP;
typedef vector<TLL> vTLL;
const ll mod = 1e9 + 7;
ll dx[8] = { -1,0,1,0,1,1,-1,-1 };
ll dy[8] = { 0,-1,0,1,1,-1,1,-1 };
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>&p) {
ost << "{ " << p.first << ", " << p.second << " }";
return ost;
}
template<class T>
ostream& operator<<(ostream& ost, const vector<T>&v) {
ost << "{ ";
for (int i = 0; i<v.size(); i++) {
if (i)ost << ", ";
ost << v[i];
}
ost << " }";
return ost;
}
template<class A, class B>
ostream& operator<<(ostream& ost, const map<A, B>&v) {
ost << "{ ";
for (auto p : v) {
ost << "{ " << p.first << ", " << p.second << " }";
}
ost << " }";
return ost;
}
void debugs() { std::cerr << "\n"; }
template <class T, class... Args>
void debugs(const T &x, const Args &... args) {
std::cerr << x << " ";
debugs(args...);
}
bool out_check(ll a, ll b) { return (0 <= a && a < b); }
double pitagoras(ll a, ll b, ll c, ll d) {
double dx = a - b, dy = c - d;
return pow(dx * dx + dy * dy, 0.5);
}
ll modpow(ll a, ll b, ll mod) { ll c = 1; while (b > 0) { if (b & 1) { c = a * c%mod; }a = a * a%mod; b >>= 1; }return c; }
void Yes(bool x) { cout << ((x) ? "Yes\n" : "No\n"); }
void YES(bool x) { cout << ((x) ? "YES\n" : "NO\n"); }
void yes(bool x) { cout << ((x) ? "yes\n" : "no\n"); }
void Yay(bool x) { cout << ((x) ? "Yay!\n" : ":(\n"); }
void OK(bool x) { cout << ((x) ? "OK!\n" : "NG\n"); }
ll n, m, d, e, l, r, k, h, w, Q, ans, ret = M;
bool flag = false, flag2 = false, flag3 = false;
string s, t, u;
int main() {
cin.tie(0); ios::sync_with_stdio(false);
cin >> s;
n = s.size();
vll v(n+1);
repr(i, n) {
if (s[i] == '>') v[i] = v[i + 1] + 1;
}
rep(i, n) {
if (s[i] == '<' && v[i] >= v[i + 1]) {
v[i + 1] = v[i] + 1;
}
}
rep(i, n + 1) ans += v[i];
cout << ans << endl;
}
| 0
| 7,443,181
|
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define R(a) cin>>a
#define R2(a,b) cin>>a>>b
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
const int MAXN=100000+20;
int dp[MAXN][2];
vector<int> g[MAXN];
int n,m;
int save=0;
int main(){
fastio;
R2(n,m);
rb(i,1,m){
int u,v;
R2(u,v);
g[u].PB(v);
g[v].PB(u);
}
set<pair<int,pair<int,bool> >> heap;
memset(dp,63,sizeof(dp));
rb(i,1,n)
dp[i][0]=i,heap.insert(II(i,II(i,0)));
while(!heap.empty()){
pair<int,pair<int,bool> > now=*heap.begin();
heap.erase(heap.begin());
int i,j,val;
i=now.SEC.FIR;
j=now.SEC.SEC;
val=now.FIR;
if(dp[i][j]!=val) continue;
for(auto it:g[i]){
if(dp[it][j^1]>dp[i][j]){
dp[it][j^1]=dp[i][j];
heap.insert(II(val,II(it,j^1)));
}
}
}
int N=0;
rb(i,1,n){
N+=g[i].empty();
}
int save1=0,save0=0,save3=0;
rb(i,1,n){
if(g[i].size()){
if(dp[i][0]==i){
save3+=dp[i][1]>=i;
save0++;
}
if(dp[i][1]>=i){
save1++;
}
}
}
LL rest=1ll*N*n*2-1ll*N*N;
rb(i,1,n){
if(g[i].size())
if(min(dp[i][0],dp[i][1])==i){
if(dp[i][0]==i&&dp[i][1]==i){
rest+=save3;
}
else{
rest+=save0;
}
}
}
cout<<rest<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for(int i=0; i<(n); ++i)
#define FOR(i, a, b) for(int i=(a); i<(b); ++i)
#define FORR(i, a, b) for(int i=(b)-1; i>=(a); --i)
#define DEBUG(x) cout<<#x<<": "<<(x)<<'\n'
#define DEBUG_VEC(v) cout<<#v<<":";REP(i, v.size())cout<<' '<<v[i];cout<<'\n'
#define ALL(a) (a).begin(), (a).end()
template<typename T> inline void CHMAX(T& a, const T b) {if(a<b) a=b;}
template<typename T> inline void CHMIN(T& a, const T b) {if(a>b) a=b;}
constexpr ll MOD=1000000007ll;
#define FIX(a) ((a)%MOD+MOD)%MOD
const double EPS=1e-11;
#define EQ0(x) (abs((x))<EPS)
#define EQ(a, b) (abs((a)-(b))<EPS)
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
ll a, b;
cin>>n;
ll sum=0, mi=1e9;
bool can=false;
REP(i, n){
cin>>a>>b;
if(a!=b){
can=true;
}
sum+=a;
if(a>b){
CHMIN(mi, b);
}
}
cout<<(can ? sum-mi : 0)<<'\n';
return 0;
}
| 0
| 19,531,500
|
#include <cstdio>
#include <cstring>
#include <cmath>
#include <utility>
#include <iostream>
#include <functional>
#include <bitset>
#include <algorithm>
#include <vector>
#include <forward_list>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <tuple>
#include <numeric>
#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll INF = (1ll << 60);
map<int64_t, int> prime_factor(int64_t n)
{
map<int64_t, int> ret;
for (int64_t i = 2; i * i <= n; i++)
{
while (n % i == 0)
{
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
int main(void)
{
ll n;
cin >> n;
vector<ll> v(n + 1, 0);
for (int i = 1; i <= n; i++)
{
auto p = prime_factor(i);
for (auto x : p)
{
v[x.first] += x.second;
}
}
ll ans = 0;
for (int i = 0; i <= n; i++)
{
if (v[i] >= 74)
{
ans++;
}
}
for (int i = 0; i <= n; i++)
{
for (int j = 0; j <= n; j++)
{
if (i == j)
{
continue;
}
if (v[i] >= 2 && v[j] >= 24)
{
ans++;
}
if (v[i] >= 4 && v[j] >= 14)
{
ans++;
}
}
}
for (int i = 0; i <= n; i++)
{
for (int j = i + 1; j <= n; j++)
{
for (int k = 0; k <= n; k++)
{
if (i == k || j == k)
{
continue;
}
if (v[i] >= 4 && v[j] >= 4 && v[k] >= 2)
{
ans++;
}
}
}
}
cout << ans << endl;
}
|
#include <iostream>
#include <string>
#include <cmath>
#include <stdio.h>
using namespace std;
class Dice{
public:
int labels[6];
Dice(int *s){
for(int i=0;i<6;i++){
labels[i] = s[i];
}
}
void update_state(char c){
int tmp;
switch(c){
case 'N':
tmp = labels[0];
labels[0] = labels[1];
labels[1] = labels[5];
labels[5] = labels[4];
labels[4] = tmp;
break;
case 'S':
tmp = labels[0];
labels[0] = labels[4];
labels[4] = labels[5];
labels[5] = labels[1];
labels[1] = tmp;
break;
case 'W':
tmp = labels[0];
labels[0] = labels[2];
labels[2] = labels[5];
labels[5] = labels[3];
labels[3] = tmp;
break;
case 'E':
tmp = labels[0];
labels[0] = labels[3];
labels[3] = labels[5];
labels[5] = labels[2];
labels[2] = tmp;
break;
}
}
void roll(){
int tmp = labels[1];
labels[1] = labels[3];
labels[3] = labels[4];
labels[4] = labels[2];
labels[2] = tmp;
}
};
int main(){
int labels[6];
for(int i=0;i<6;i++){
cin >> labels[i];
}
Dice dice(labels);
int q; cin >> q;
int nt, nf;
for(int i=0;i<q;i++){
cin >> nt >> nf;
if(nt==dice.labels[3]){
dice.update_state('E');
}else if(nt==dice.labels[2]){
dice.update_state('W');
}
while(nt != dice.labels[0]){
dice.update_state('N');
}
while(nf != dice.labels[1]){
dice.roll();
}
cout << dice.labels[2] << endl;
}
return 0;
}
| 0
| 81,664,125
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(cin >> n, n)
{
int max_s, min_s, sum;
cin >> max_s >> min_s;
sum = max_s + min_s;
if(max_s<min_s) swap(max_s, min_s);
for(int i=2; i<n; i++)
{
int s;
cin >> s;
sum += s;
if(max_s<s) max_s = s;
if(min_s>s) min_s = s;
}
cout << (sum - max_s - min_s) / (n - 2) << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <queue>
#define rep(i,n) for(int i=0; i<(n); ++i)
#define outl(x) cout<< (x) << '\n'
using namespace std;
using let = const int;
int V, E;
bool vis[10005];
vector <int> G[10005];
vector <int> out;
void bfs(let s, int *indeg)
{
queue <int> que; que.emplace(s);
while (!que.empty()) {
let u = que.front(); que.pop();
out.emplace_back(u);
for(let x : G[u]) if( --indeg[x] == 0 && !vis[x]++ ) que.emplace(x);
}
}
void topologial_sort()
{
static int indeg[10005] = {};
rep(i, V)
for(let x: G[i]) ++indeg[x];
rep(i, V)
if (indeg[i] == 0 && !vis[i]++) bfs(i, indeg);
for_each(out.cbegin(), out.cend(), [](let x) { outl( x ); });
}
signed main()
{
cin.tie(0), ios::sync_with_stdio(false);
cin >> V >> E;
while(E--) {
int s, t;
cin >> s >> t;
G[s].emplace_back(t);
}
topologial_sort();
}
| 0
| 52,983,435
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
int main() {
ll n, m, d;
cin >> n >> m >> d;
long double dd;
dd = m-1;
dd /= n;
dd /= n;
dd *= n-d;
if(d) dd *= 2;
cout << fixed << setprecision(10);
cout << dd << endl;
}
|
#pragma target("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef unordered_map<ll, ll> U_MAP;
typedef priority_queue<ll> pq;
typedef priority_queue<ll, vector<ll>, greater<ll>> rpq;
const int INF = 1e9, MOD = 1e9 + 7, ohara = 1e6 + 10;
const ll LINF = 1e18;
#define rep(i, n) for (ll(i) = 0; (i) < (int)(n); (i)++)
#define rrep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrrep(i, a, b) for (ll i = (a); i >= (b); i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout << (x) << endl
#define doublecout(a) cout << fixed << setprecision(15) << a << endl;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
string alph("abcdefghijklmnopqrstuvwxyz");
ll n, cnt, a, b, c, d, tmp, m, h, w, x, y, sum, k, q;
char now_ans[1500][1500], ans[1500][1500];
ll stx, sty;
int main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w >> d;
rep(i, 1200) {
rep(j, 1200) {
stx = d * j, sty = d * i;
if (stx > 1100 || sty > 1100) continue;
rrep(zx, stx, stx + d) {
if (zx > 1100) break;
rrep(zy, sty, sty + d) {
if (zy > 1100) break;
if (i % 2 == 0) {
if (j % 2 == 0)
now_ans[zy][zx] = 'G';
else
now_ans[zy][zx] = 'B';
} else {
if (j % 2 == 0)
now_ans[zy][zx] = 'Y';
else
now_ans[zy][zx] = 'R';
}
}
}
}
}
rep(i, 1100) {
rep(j, 1100) {
ll ansx, ansy;
if ((i + j - (w - 1)) % 2 == 1) continue;
ansy = (i + j - (w - 1)) / 2;
ansx = i - ansy;
if (ansx < 0 || ansx >= w || ansy < 0 || ansy >= h) continue;
ans[ansy][ansx] = now_ans[i][j];
}
}
rep(i, h) {
rep(j, w) { cout << ans[i][j]; }
cout << "\n";
}
return 0;
}
| 0
| 13,486,643
|
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
#define vecin(a) rep(i,a.size())cin >> a[i]
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll inf = 2147483647;
const ll INF = 1LL << 60;
const ld pi = 3.14159265358;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = 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 gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
ll fac[510000], finv[510000], inv[510000];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 510000; i++){
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod%i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll nCk(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 modpow(ll n,ll m,ll MOD){
ll res = 1;
while(m){
if(m & 1)res = (res * n) % MOD;
m >>= 1;
n *= n;
n %= MOD;
}
return res;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll N;
cin >> N;
vector<ll> num(N);
rep(i,N)cin >> num[i];
ll ans = 1;
rep(i,N){
if(num[i] == ans){
ans++;
}
}
ans--;
if(ans == 0){
cout << "-1\n";
return 0;
}
cout << N - ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>; using vpii = vector<pii>;
using vi = vector<int>; using vvi = vector<vi>;
using ll = long long;
using pll = pair<ll, ll>; using vpll = vector<pll>;
using vll = vector<long long>; using vvll = vector<vll>;
template <class T> using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> istream &operator>>(istream &, vector<T> &);
template <class T> ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U> istream &operator>>(istream &, pair<T, U> &);
template <class T, class U> ostream &operator<<(ostream &, const pair<T, U> &);
template <class T> struct Inf { static constexpr T inf() { return std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : std::numeric_limits<T>::max(); } };
template <> struct Inf<int> { static constexpr int inf() { return 0x3f3f3f3f; } };
template <> struct Inf<long long> { static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; } };
constexpr int INF = Inf<int>::inf(); constexpr ll BINF = Inf<ll>::inf();
struct Solver {
Solver() {}
int solve();
};
int Solver::solve() {
string s, t; cin >> s >> t;
if (s.length() < t.length()) swap(s, t);
int n = s.size() + t.size();
int l = 0, r = 0;
for (int i = 0; i < n; i++) {
if (i & 1)
cout << t[r++];
else
cout << s[l++];
}
cout << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0); cin.tie(0);
Solver solver;
#ifdef JUDGE_MULTI_CASE
int t; cin >> t; for (int i = 1; i <= t; i++)
#endif
solver.solve();
return 0;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto it=v.begin();it!=v.end();++it) is >> *it;
return is;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it=v.begin();it!=v.end();) os << *it, os << " \n"[++it==v.end()];
return os;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U> ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
| 0
| 31,319,483
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int D;
cin >> D;
switch (D) {
case 25:
cout << "Christmas" << endl;
break;
case 24:
cout << "Christmas"
<< " "
<< "Eve" << endl;
break;
case 23:
cout << "Christmas"
<< " "
<< "Eve"
<< " "
<< "Eve" << endl;
break;
case 22: cout << "Christmas"
<< " "
<< "Eve"
<< " "
<< "Eve"
<< " "
<< "Eve" << endl;
default:
break;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
const int INF = 1000000000;
int n;
int target[3];
std::vector<int> l;
int solve(int i = 0, int a = 0, int b = 0, int c = 0){
if(i == n){
if(!a || !b || !c) return INF;
else return std::abs(a - target[0]) + std::abs(b - target[1]) + std::abs(c - target[2]);
}
int cost = INF;
cost = std::min(cost, solve(i + 1, a, b, c));
cost = std::min(cost, solve(i + 1, a + l[i], b, c) + (a ? 10 : 0));
cost = std::min(cost, solve(i + 1, a, b + l[i], c) + (b ? 10 : 0));
cost = std::min(cost, solve(i + 1, a, b, c + l[i]) + (c ? 10 : 0));
return cost;
}
int main(){
std::cin >> n;
l.assign(n, 0);
for(int i = 0; i < 3; i++) std::cin >> target[i];
for(int i = 0; i < n; i++){
std::cin >> l[i];
}
std::cout << solve() << std::endl;
return 0;
}
| 0
| 68,526,815
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
typedef tree<ii,null_type,less<ii>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
int main() {
cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
char a,b; cin>>a>>b;
if (a==b) cout<<"H";
else cout<<"D"<<endl;
return 0;
}
|
#include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
vector<int> ans(n);
if(a == 1){
if(n == b){
rep(i,n) cout << n-i << " ";
cout << endl;
}
else{
cout << -1 << endl;
}
}
else if(b == 1){
if(n == a){
rep(i,n) cout << i+1 << " ";
cout << endl;
}
else{
cout << -1 << endl;
}
}
else if(n <= a || n <= b){
cout << -1 << endl;
}
else{
if(a <= b){
rep(i,a) ans[i] = n - a + i + 1;
int bound = n - a + 1;
if(b < 2 || a < (n - a + b - 2) / (b - 1) || bound < b){
cout << -1 << endl;
}
else{
int idx = a;
int cnt = 1;
while(idx < n){
rep(i,b-1){
ans[idx++] = min(n - a - i, (b - 1) * cnt - i);
if(idx == n) break;
}
++cnt;
}
rep(i,n) cout << ans[i] << " ";
cout << endl;
}
}
else{
rep(i,b) ans[i] = b - i;
int bound = n - b + 1;
if(a < 2 || b < (n - b + a - 2) / (a - 1) || bound < a){
cout << -1 << endl;
}
else{
int idx = b;
int cnt = 1;
while(idx < n){
rep(i,a-1){
ans[idx++] = max(b + 1 + i, n - (a - 1) * cnt + i + 1);
if(idx == n) break;
}
++cnt;
}
rep(i,n) cout << ans[i] << " ";
cout << endl;
}
}
}
return 0;
}
| 0
| 47,311,563
|
#include<iostream>
using namespace std;
int main(){
int cut=0;
int a;
int b;
while(1){
cin>>a;
cut=0;
if(a==0){
break;
}
b=1000-a;
cut+=b/500;
b=b%500;
cut+=b/100;
b=b%100;
cut+=b/50;
b=b%50;
cut+=b/10;
b=b%10;
cut+=b/5;
b=b%5;
cut+=b;
cout<<cut<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define endl '\n'
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline")
#pragma GCC option("arch=native","tune=native","no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
typedef unsigned long long ull;
typedef long long lld;
typedef long double ld;
typedef pair<int,int> pii;
const int MAXN=1e5+5;
const int MOD=1e9+7;
const int INF=1e9;
const ld PI=acos(-1);
const ld EPS=1e-9;
#define lg2(x) 31-__builtin_clz(x)
#define logx(a,b) (log(a)/log(b))
#define pow2(a) a*a
#define pow3(a) a*a*a
#define lcm(a,b) (a*b)/__gcd(a,b)
pii mkp(int a, int b){
if(a>b)swap(a,b);
return make_pair(a,b);
}
int mod_pow(int a, int b){
if(!b)return 1;
if(b&1)return mod_pow(a,b-1)*a%MOD;
int power=mod_pow(a,b>>1);
return power*power%MOD;
}
int modular_inverse(int a){
return mod_pow(a,MOD-2);
}
vector<int> movy={0,0,1,-1};
vector<int> movx={1,-1,0,0};
void solve(){
int n, l;
cin>>n>>l;
vector<string> a(n);
for(string &it:a)cin>>it;
sort(a.begin(),a.end());
for(string it:a)cout<<it;
cout<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0
| 21,703,431
|
#include <iostream>
#include <string>
#include <vector>
#include <queue>
using namespace std;
int main(){
int K;
cin>>K;
queue<long long> q;
for(int i=1;i<10;i++){
q.push(i);
}
int cnt=0;
long long node;
while(!q.empty()){
node=q.front();q.pop();
cnt++;
if(cnt==K){
cout<<node<<endl;
break;
}
int tmp=node%10;
if(tmp!=0){
q.push(node*10+tmp-1);
}
q.push(node*10+tmp);
if(tmp!=9){
q.push(node*10+tmp+1);
}
}
return 0;
}
|
#include <stdio.h>
#include <string.h>
int main(void) {
char x[1000] = "";
int sum;
do {
sum = 0;
scanf("%s", x);
for (int i = 0; i < strlen(x); i++) {
sum += (x[i] - '0');
}
if (sum < 1) break;
printf("%d\n", sum);
} while (true);
return 0;
}
| 0
| 43,356,443
|
#include<stdio.h>
#include <iostream>
#include <math.h>
using namespace std;
int main(){
long double Ax, Ay, Bx, By;
long double a;
cin >> Ax >> Ay >> Bx >> By;
a = (Bx - Ax) * (Bx - Ax) + (By - Ay) * (By - Ay);
printf("%lf\n",sqrt(a)) ;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
ll n,k; cin >> n >> k;
vector<pair<int,int>> a(n);
for(int ix=0;ix<n;ix++){
int x,y;
cin >> x >> y;
a.at(ix) = make_pair(x,y);
}
sort(a.begin(),a.end());
ll cnt=0,ans = -1;
int i=0;
while(cnt < k){
cnt += a.at(i).second;
if(cnt >= k) ans = a.at(i).first;
i++;
}
cout << ans << endl;
}
| 0
| 34,986,217
|
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
#include <iostream>
#define ll long long
using namespace std;
int dp[10000+7];
int t[10]= {0,2,5,5,4,5,6,3,7,6},a[10],b[100];
bool cmp(int a,int b)
{
return a>b;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n,m,i,j,k;
cin>>n>>m;
for(i=0; i<m; i++)
cin>>a[i];
sort(a,a+m,cmp);
dp[0]=1;
for(i=0;i<m;i++)
{
for(j=t[a[i]];j<=n;j++)
{
if(j&&j>=t[a[i]])dp[j]=max(dp[j],dp[j-t[a[i]]]+1);
}
}
while(n>0)
{
for(i=0;i<m;i++)
{
if(n>=t[a[i]]&&dp[n]-dp[n-t[a[i]]]==1)
{
cout<<a[i];
n=n-t[a[i]];
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long double> vld;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion
#pragma region ESTD
template<typename C, typename T> int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F> int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T> void erase(C& c, T t) { remove(ALL(c), t), c.end(); }
template<typename C> void remove(vector<C>& c, unsigned int index) { c.erase(c.begin()+index); }
template<typename C, typename T, typename U> void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U> void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C> void reverse(C& c) { reverse(ALL(c)); }
template<typename C> void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred> void sort(C& c, Pred p) { sort(ALL(c), p); }
#pragma endregion
#pragma region CONST_VAL
constexpr int PI = (2*acos(0.0));
constexpr int EPS = (1e-9);
constexpr int MOD = (int)(1e9+7);
constexpr int INF = 100000000;
#pragma endregion
int main()
{
int n, m, p;
while(cin>>n>>m>>p, n) {
int a, sum=0, win;
rep(i,n) {
cin >> a;
if(i+1==m) win = a;
sum += a*100;
}
sum *= 100-p;
sum /= 100;
if(win==0) cout << '0' << endl;
else cout << sum/win << endl;
}
return 0;
}
| 0
| 5,481,127
|
#include <iostream>
using namespace std;
int main() {
long long a, b, c, k;
cin >> a >> b >> c >> k;
if(k%2 == 1) cout << b-a;
else cout << a-b;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
for(int i = 1; i < n; i++) {
if(a[i] == a[i - 1]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0
| 66,828,699
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define yn(x) ((x) ? "YES" : "NO")
typedef pair <int, int> ii;
typedef pair <ii, int> iii;
const int siz = 2e5 + 10;
const int SIZ = 2e3 + 10;
const int mod = 1e9 + 7;
const int maxx = 2e9;
const int MAXX = 1e12;
const string file = "2";
int f[SIZ];
int dp(int rem) {
if (rem == 0) {
return 1;
}
int &res = f[rem];
if (res != -1) {
return res;
}
res = 0;
for (int i = 3; i <= rem; i++) {
(res += dp(rem - i)) %= mod;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int s;
cin >> s;
memset(f, -1, sizeof(f));
cout << dp(s) << "\n";
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> P2;
int next_animal(int a,int b,int c){
if(b==1) c=(c+1)%2;
if(c==0) return a;
else return (a+1)%2;
}
int main(){
int n;
cin>>n;
vector<int> vec;
for(int i=0;i<n;i++){
char a;
cin>>a;
if(a=='o') vec.push_back(0);
else vec.push_back(1);
}
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
vector<int> ans;
ans.push_back(i);
ans.push_back(j);
for(int k=1;k<n-1;k++){
int ps=ans.size()-1;
ans.push_back(next_animal(ans[ps-1],ans[ps],vec[ps]));
}
if(next_animal(ans[n-2],ans[n-1],vec[n-1])==i&&next_animal(j,i,vec[0])==ans[n-1]){
for(int k=0;k<n;k++) cout<<(ans[k]==0?'S':'W');
cout<<endl;
return 0;
}
}
}
cout<<-1<<endl;
return 0;
}
| 0
| 4,010,394
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll inf = 1LL<<60;
const double eps = 1e-9;
typedef pair<ll, ll> P;
int main()
{
int N, tmp = 0, ans = 0;
cin >> N;
vector <int> a(N+2, 0);
for (int i = 1; i <= N; i++) {
cin >> a[i];
ans += abs(a[i-1] - a[i]);
}
ans += abs(a[N] - 0);
for (int i = 1; i <= N; i++) {
cout << ans - (abs(a[i] - a[i-1]) + abs(a[i] - a[i+1])) + abs(a[i-1] - a[i+1]) << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
vector<int> B(N-1);
for(int i=0; i<N-1; i++){
cin>>B.at(i);
}
int a=0,sum=B.at(N-2);
if(N==2){
cout<<B.at(0)*2<<endl;
return 0;
}
else{
for(int i=N-3; i>=0; i--){
a=min(B.at(i),B.at(i+1));
sum+=a;
if(i==0){
if(B.at(i)>B.at(i+1)){
sum+=B.at(i);
}
else{
sum+=a;
}
}
}
}
cout<<sum<<endl;
}
| 0
| 30,210,284
|
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <set>
#include <map>
using namespace std;
int p[2100000];
int tx[2100000];
int w, h;
long long ans;
int toth, totw;
bool cmp(int x, int y) {
return p[x] < p[y];
}
int main() {
scanf("%d%d", &w, &h);
for (int i = 0; i < w + h; i++)
scanf("%d", &p[i]);
for (int i = 0; i < w + h; i++)
tx[i] = i;
sort(tx, tx + w + h, cmp);
totw = 0;
toth = 0;
for (int i = 0; i < w + h; i++)
if (tx[i] < w) {
ans += 1LL * p[tx[i]] * (h + 1 - toth);
totw += 1;
}else {
ans += 1LL * p[tx[i]] * (w + 1 - totw);
toth += 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i,a,b) for(ll i=a;(i)<(b);++(i))
#define RFOR(i,a,b) for(ll i=a;(i)>=(b);--(i))
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,n,0)
#define ALL(v) v.begin(), v.end()
#define UNIQ(v) sort(ALL(v)); v.erase(unique(ALL(v)), v.end())
#define BIT(n) (1LL<<(n))
#define DEBUG(a) cerr << #a << " = " << a << endl
const double PI = acos(-1);
const int inf = 1001001001;
const int mod = (int)1e9+7;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int main() {
int N, K;
cin >> N >> K;
ll ans = 0;
FOR(i, K, N+2) {
ll min = (0 + i-1) * i / 2;
ll max = (N + (N - (i-1))) * i / 2;
ans += max - min + 1;
ans %= mod;
}
cout << ans << endl;
}
| 0
| 12,719,814
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100005];
int getgrundy(int t, int p)
{
int ret = 0;
for (int nxt : graph[t])
{
if (nxt == p) continue;
ret ^= getgrundy(nxt, t) + 1;
}
return ret;
}
int main()
{
int n;
scanf("%d",&n);
for (int i = 1; i < n; i++)
{
int a, b;
scanf("%d%d",&a,&b);
graph[a].push_back(b);
graph[b].push_back(a);
}
if (getgrundy(1, -1)) printf("Alice\n");
else printf("Bob\n");
}
|
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
int n;
deque<int> qu, ql;
bool a[100005];
int main()
{
scanf("%d", &n);
qu.push_back(1);
ql.push_back(1);
while(!qu.empty())
{
int t1 = qu.front();
int t2 = ql.front();
qu.pop_front();
ql.pop_front();
if(t1 == 0)
{
printf("%d", t2);
return 0;
}
if(a[t1]) continue;
a[t1] = true;
qu.push_front(t1 * 10 % n);
ql.push_front(t2);
qu.push_back((t1 + 1) % n);
ql.push_back(t2 + 1);
}
return 0;
}
| 0
| 68,386,468
|
#include<stdio.h>
#include<math.h>
#define PI 3.141592653589793
int main()
{
double a,b,C,S,H,K,k,J;
a=0;b=0;C=0;S=0;H=0;K=0;k=0;J=0;
scanf("%lf",&a);scanf("%lf",&b);scanf("%lf",&C);
C=C*(PI)/180;
H=b*sin(C);
S=0.5*a*H;
k=a*a+b*b-2*a*b*cos(C);
K=sqrt(k);
J=a+b+K;
printf("%f\n%f\n%f\n",S,J,H);
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
| 38,108,507
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <stack>
#include <sstream>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long int ll;
struct node{
int num;
int count;
};
bool comp(const node LHS,const node RHS){
return LHS.count > RHS.count;
}
int main()
{
int n;
cin>>n;
vector<node> evenVec(100001);
vector<node> oddVec(100001);
for(int i = 0 ; i < 100001; i++){
evenVec[i].count = 0;
evenVec[i].num = i;
oddVec[i].count = 0;
oddVec[i].num = i;
}
for(int i = 0; i < n; i++){
int num;
cin>>num;
if( i % 2 == 0){
evenVec[num].count++;
}else{
oddVec[num].count++;
}
}
sort(evenVec.begin(),evenVec.end(),comp);
sort(oddVec.begin(),oddVec.end(),comp);
ll ans = 0;
if( evenVec[0].num != oddVec[0].num){
ans = n - (evenVec[0].count + oddVec[0].count);
}else{
int pattern1 = n - (evenVec[0].count + oddVec[1].count);
int pattern2 = n - (evenVec[1].count + oddVec[0].count);
ans = min(pattern1,pattern2);
}
cout<<ans<<endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<cctype>
#include<utility>
#include<string>
#include<cstring>
#include<cmath>
#include <numeric>
#include<queue>
#include<climits>
#include<cstdio>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#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 SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef long long int ll;
typedef pair<ll,int> LL_IP;
#define INF 1e9+7
ll a[10000001];
int main(){
ll n;
cin >> n;
vector<ll> arr;
REP(i,1e7+1){
a[i] = i+1;
}
REP(i,1e7){
a[i+1] += a[i];
}
REP(i,n){
if(a[i] >= n){
ll tmp = a[i] - n;
REP(j,i+1){
if((j+1) != tmp){
arr.push_back(j+1);
}
}
break;
}
}
REP(i,arr.size()){
cout << arr[i] << endl;
}
return 0;
}
| 0
| 93,999,940
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
string S;
cin >> S;
int l = S.size();
for (int i = 2 - l % 2; i <= l - 2; i = i + 2) {
int sp = (S.size() - i) / 2;
if (S.substr(0, sp) == S.substr(sp, sp)) {
cout << S.size() - i << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define ln "\n"
#define SORT(X) sort(X.begin(), X.end())
#define SORTi(X) sort(X.begin(), X.end(), greater<ll>())
#define REP(x, a, b) for (auto x = a; x <= b; x++)
#define REPi(x, b, a) for (auto x = b; x >= a; x--)
#define REPit(x, A) for (auto x = A.begin(); x != A.end(); x++)
#define REPr(x, A) for (auto x : A)
#define ll long long
#define ull unsigned long long
#define PB push_back
#define EB emplace_back
#define UMP unordered_map
#define UST unordered_set
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
int N , T, sum = 0;
cin >> N >> T;
vector <int> A(N);
REP(i, 0, N-1)
{
cin>>A[i];
}
int tmp = 0;
REP(i, 0, N-2)
{
tmp = (A[i+1] - A[i]);
if(tmp < T)
{
sum = sum + tmp;
}
else if (tmp >= T)
{
sum = sum + T;
}
}
sum = sum + T;
cout<<sum<<ln;
return 0;
}
| 0
| 63,101,876
|
#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 <iomanip>
using namespace std;
#define pi 3.141592653589793
int solve(string s1, string s2, int l1, int l2)
{
int a[1001][1001];
for(int i = 0; i <= l1; i++){
a[i][0] = 0;
}
for(int i = 0; i <= l2; i++){
a[0][i] = 0;
}
for(int i = 1; i <= l1; i++){
for(int j = 1; j <= l2; j++){
if(s1[i - 1] == s2[j - 1]) a[i][j] = a[i - 1][j - 1] + 1;
else a[i][j] = max(a[i - 1][j], a[i][j - 1]);
}
}
return a[l1][l2];
}
int main()
{
int q;
cin >> q;
for(int i = 0; i < q; i++){
string s1, s2;
cin >> s1 >> s2;
cout << solve(s1, s2, s1.length(), s2.length()) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
const ll LINF = 1LL << 60;
const int MOD = 1'000'000'007;
template <typename T>
void print(const T &v)
{
for (int i = 0; i < v.size(); i++)
{
if (i)
cout << ' ';
cout << v[i];
}
cout << endl;
}
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 dp[110][110] = {INF};
int main()
{
int h, w;
cin >> h >> w;
vector<vector<int>> g(h, vector<int>(w, 0));
for (int i = 0; i < h; i++)
{
string line;
cin >> line;
for (int j = 0; j < w; j++)
{
if (line[j] == '.')
{
g[i][j] = 0;
}
else
{
g[i][j] = 1;
}
}
}
dp[0][0] = 0;
for (int j = 1; j < w; j++)
{
if (g[0][j] && !g[0][j - 1])
{
dp[0][j] = dp[0][j - 1] + 1;
}
else
{
dp[0][j] = dp[0][j - 1];
}
}
for (int i = 1; i < h; i++)
{
if (g[i][0] && !g[i - 1][0])
{
dp[i][0] = dp[i - 1][0] + 1;
}
else
{
dp[i][0] = dp[i - 1][0];
}
}
for (int i = 1; i < h; i++)
{
for (int j = 1; j < w; j++)
{
if (!g[i][j])
{
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]);
}
else
{
dp[i][j] = min(dp[i - 1][j] + (g[i - 1][j] + g[i][j]) % 2, dp[i][j - 1] + (g[i][j - 1] + g[i][j]) % 2);
}
}
}
if (g[0][0])
{
cout << dp[h - 1][w - 1] + 1 << endl;
}
else
{
cout << dp[h - 1][w - 1] << endl;
}
return 0;
}
| 0
| 60,332,211
|
#include<bits/stdc++.h>
using namespace std;
int k,s,i,j,l;
int main(){
scanf("%d%d",&k,&s);
for (i=0;i<=k;i++){
for (j=0;j<=k;j++){
if (s-i-j<=k&&s-i-j>=0) l++;
}
}
printf("%d\n",l);
}
|
#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 rep1(i,n) for(int i = 1; i <= (n); i++)
#define rrep1(i,n) for(int i = (n); i > 0; i--)
#define ll long long
#define pi pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define INF 1000000000000000LL
using namespace std;
ll modpow(ll x, ll n, ll mod){
if(n==0) return 1;
if(n%2==0){
return modpow(x*x%mod, n/2, mod) % mod;
}else{
return x * modpow(x, (n-1), mod) % mod;
}
}
int main(){
int n;cin>>n;
vector<ll> t(n), a(n);
rep(i, n)cin>>t[i];
rep(i, n)cin>>a[i];
if(a[0]==t[0] && a.back()==t.back()){
cout<<modpow(a[0], max<ll>(0, n-2), MOD)<<endl;
return 0;
}
int max_t_i=0, max_a_i=n-1;
rep(i, n)if(t[max_t_i]<t[i])max_t_i=i;
rrep(i, n)if(a[max_a_i]<a[i])max_a_i=i;
if(a[max_a_i] != t[max_t_i] || max_a_i < max_t_i) { cout<<0<<endl; return 0;}
vector<pll> h_l;
ll ch=0, cl=0;
rep(i, n){
if(ch<t[i]){
if(ch>0 && cl>0)h_l.push_back({ch, cl});
ch=t[i]; cl=0;
}else{
cl++;
}
}
ch=0, cl=0;
rrep(i, n){
if(ch<a[i]){
if(ch>0 && cl>0)h_l.push_back({ch, cl});
ch=a[i]; cl=0;
}else{
cl++;
}
}
ll result=1;
for(auto p: h_l){
result = ( result * modpow(p.first, p.second, MOD) ) % MOD;
}
if(max_a_i != max_t_i)result=( result*modpow(a[max_a_i], max_a_i - max_t_i + 1-2, MOD) ) % MOD;
cout<<result<<endl;
return 0;
}
| 0
| 26,627,303
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
vector<pair<int,int>> students,chk_pts;
for(int i=0;i<n;i++)
{
int x,y;
cin>>x>>y;
students.push_back({x,y});
}
for(int i=0;i<m;i++)
{
int x,y;
cin>>x>>y;
chk_pts.push_back({x,y});
}
for(int i=0;i<n;i++)
{
int dis=1e9;
int cur=-1;
for(int j=0;j<m;j++)
{
int d=abs(students[i].first-chk_pts[j].first)+abs(students[i].second-chk_pts[j].second);
if(dis>d)
{
dis=d;
cur=j+1;
}
}
cout<<cur<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
string in;
int alp[26]={},i;
while (cin>>in) {
for (i=0;i<in.size();i++) {
if ('a' <= in[i] && in[i] <= 'z') alp[in[i]-'a']++;
if ('A' <= in[i] && in[i] <= 'Z') alp[in[i]-'A']++;
}
}
for (i=0;i<26;i++) {
cout << (char)('a'+i) << " : " << alp[i] << endl;
}
return 0;
}
| 0
| 39,711,779
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int N = 0 ,A, B, C, K;
string S;
cin >> A >> B >> C >> K;
if (K <= A) cout << K << endl;
else if (K <= A + B) cout << A <<endl;
else cout << 2*A + B -K << endl;
}
|
#include<bits/stdc++.h>
#define rint register int
#define ll long long
using namespace std;
const ll Max=1e9;
int N,P[1010000];
ll Sum[1010000],A[1010000],B[1000000];
int main(){
cin>>N;
for(rint i=1;i<=N;++i) cin>>P[i];
for(rint i=1;i<=N;++i) {
Sum[P[i]]=Max-N+i;
}
A[1]=Max/2;B[1]=Sum[1]-A[1];
for(rint i=2;i<=N;++i) {
B[i]=B[i-1]-N;
A[i]=Sum[i]-B[i];
}
for(rint i=1;i<=N;++i) cout<<A[i]<<" ";
cout<<"\n";
for(rint i=1;i<=N;++i) cout<<B[i]<<" ";
cout<<"\n";
return 0;
}
| 0
| 30,959,298
|
#include <bits/stdc++.h>
using namespace std;
int INF=1e9+7;
long long DP[1005][1005];
int main(){
int H,W;cin>>H>>W;
DP[1][1]=1;
for(int i=0;i<H;i++){
string S;cin>>S;
for(int j=0;j<W;j++){
DP[i+1][j+1]%=INF;
if(S.at(j)=='.'){DP[i+1][j+2]+=DP[i+1][j+1];DP[i+2][j+1]+=DP[i+1][j+1];}
}
}
cout<<DP[H][W]<<endl;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int cnt_digits(long long N) {
int digits = 0;
while(N > 0) {
N /= 10;
digits++;
}
return digits;
}
int main() {
long long N;
cin >> N;
int ans = cnt_digits(N);
for(long long A = 1; A*A <= N; A++) {
if(N%A != 0) continue;
const long long B = N/A;
const int cur = max(cnt_digits(A), cnt_digits(B));
if(ans > cur) {
ans = cur;
}
}
cout << ans << endl;
}
| 0
| 34,819,253
|
#include <iostream>
using namespace std;
int func(int n, int s, int i){
if(!n){
if(!s)return 1;
else return 0;
}
if(i >= 10 || s-i < 0)return 0;
return func(n, s, i+1) + func(n-1, s-i, i+1);
}
int main(){
int n, s;
while(cin >> n >> s && (n || s)){
cout << func(n, s, 0) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0;i < n;i++)
#define ll long long
using namespace std;
typedef pair<int, int> P;
typedef pair<ll,ll> LP;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const ll LINF = 1000000000000000000;
const ll MOD = 998244353;
const double PI = acos(-1.0);
const double EPS = 1e-10;
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; }
void solve(){
int H, W;
cin >> H >> W;
vector<string> fi(H);
REP(i,H) cin >> fi[i];
REP(i,H) REP(j,W) if(fi[i][j] == '#'){
bool ok = false;
REP(d, 4){
int nh = i + dx[d], nw = j + dy[d];
if(nh < 0 || nh >= H || nw < 0 || nw >= W) continue;
if(fi[nh][nw] == '#') ok = true;
}
if(!ok){
cout << "No" << endl;
return;
}
}
cout << "Yes" << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
| 0
| 55,317,627
|
#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 < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define m1(x) memset(x,-1,sizeof(x))
const int INF = 1000000001;
const ll MOD = 1000000007;
int main(){
int a[3];
rep(i, 3) cin >> a[i];
int b[3];
b[1] = abs(a[1] - a[0]);
b[0] = abs(a[2] - a[0]);
b[2] = abs(a[2] - a[1]);
cout << min(b[0]+b[1], min(b[1]+b[2], b[0]+b[2])) <<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int (i)=0;(i)<(n);(i)++)
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
long long ans = LLONG_MAX;
rep(i, pow(2, n)) {
bitset<32> b(i);
int num = 0;
rep(j, 32) {
if(b.test(j)) num++;
}
if(num < k || !b.test(0)) continue;
long long alt = 0;
int max = 0;
rep(j, n) {
if(j == 0) max = a[j];
else {
if(a[j] > max) {
max = a[j];
continue;
}
else if(b.test(j)){
alt += (max + 1) - a[j];
max += 1;
}
}
}
if(alt < ans) ans = alt;
}
cout << ans << endl;
}
| 0
| 15,483,757
|
#include <iostream>
#include <string>
#include <algorithm>
#include <utility>
#include <unordered_set>
#include <vector>
#include <list>
#include <string>
#include <iterator>
#include <deque>
#include <array>
#include <forward_list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <climits>
#include <bitset>
#include <numeric>
using namespace std;
const long double PI = 3.14159265358979323846264338327950;
const int N = 2*1e5;
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int arr[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> arr[i];
if (k >= n) {
cout << 0 << '\n';
} else {
sort(arr, arr + n);
long long ans = 0;
for (int i = 0; i < n - k; ++i) {
ans += arr[i];
}
cout << ans << '\n';
}
}
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#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 <queue>
#include <fstream>
using namespace std;
#define INF 100000000
#define EPS 1e-9
#define PI acos(-1)
typedef long long ll;
typedef pair<int, int> P;
#define MAX_N 10000
int n;
int v[60*60*24 + 5];
vector<int> ans_list;
int conv(string str){
string hh,mm,ss;
hh += str[0];
hh += str[1];
mm += str[3];
mm += str[4];
ss += str[6];
ss += str[7];
return atoi(hh.c_str()) * 3600 + atoi(mm.c_str()) * 60 + atoi(ss.c_str());
}
int main(){
while(true){
cin >> n;
if(n == 0)
break;
memset(v,0,sizeof(v));
string str1, str2;
for(int i = 0; i < n; i++){
cin >> str1 >> str2;
v[conv(str1)]++;
v[conv(str2)]--;
}
int ans = 0;
int tmp = 0;
for(int i = 0; i <= 60*60*24+1; i++){
tmp += v[i];
ans = max(ans,tmp);
}
ans_list.push_back(ans);
}
for(int i = 0; i < ans_list.size(); i++){
cout << ans_list[i] << endl;
}
return 0;
}
| 0
| 54,273,655
|
#include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using vc = vector<char>;
using pll = pair<ll, ll>;
template<class T> void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T> void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U> bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U> bool isin(T el, U container) { return find(all(container), el) != container.end(); }
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; }
template<class T> bool even(T n) { return ! (n & 1); }
template<class T> bool odd(T n) { return n & 1; }
template<class T> ll rup(T a, T b) { return a % b ? a / b + 1 : a / b; }
template<class T> ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T> ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll intpow(ll a, ll n, ll _mod=numeric_limits<ll>::max()) { ll p=1; while (n) { if (n&1) p=p*a%_mod; a=a*a%_mod; n>>=1; } return p; }
ll modc(ll a, char op, ll b, ll _mod=mod)
{
a %= _mod; b %= _mod; ll res = 1;
switch (op) {
case '+': res = (a + b) % _mod; break;
case '-': res = (a - b) % _mod; break;
case '*': res = a * b % _mod; break;
case '/': res = modc(a, '*', modc(b, '^', _mod-2, _mod), _mod); break;
case '^': res = intpow(a, b, _mod); break;
case 'P': rep(i, a-b+1, a+1) res = modc(res, '*', i, _mod); break;
case 'C': res = modc(modc(a, 'P', b, _mod), '/', modc(b, 'P', b, _mod)); break;
}
if (res < 0) { res += _mod; } return res;
}
int main()
{
ll N;
cin >> N;
vll A(N);
rep(i, 0, N) cin >> A[i];
vll acc(N+1);
rep(i, 1, N+1) acc[i] = acc[i-1] + A[i-1];
sort(all(acc));
acc.push_back(inf);
ll ans = 0;
ll now = acc[0];
ll cnt= 0;
rep(i, 0, N+2) {
if (acc[i] != now) {
ans += cnt*(cnt-1) / 2;
now = acc[i];
cnt = 1;
} else {
++cnt;
}
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N=105;
char s[N][N];
int dp[N][N];
void init();
void work();
int ca=1;
int main(){
ios::sync_with_stdio(0);
cin.tie(0),cout.tie(0);
work();
return 0;
}
void work(){
int n,m;cin>>n>>m;
for(int i=1;i<=n;i++) cin>>s[i]+1;
memset(dp,0x3f,sizeof dp);
if(s[1][1]=='#') dp[1][1]=1;
else dp[1][1]=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(i==1&&j==1) continue;
if(i>1){
if(s[i][j]!=s[i-1][j]){
if(s[i][j]=='#') dp[i][j]=min(dp[i][j],dp[i-1][j]+1);
else dp[i][j]=min(dp[i][j],dp[i-1][j]);
}else dp[i][j]=min(dp[i][j],dp[i-1][j]);
}
if(j>1){
if(s[i][j]!=s[i][j-1]){
if(s[i][j]=='#') dp[i][j]=min(dp[i][j],dp[i][j-1]+1);
else dp[i][j]=min(dp[i][j],dp[i][j-1]);
}else dp[i][j]=min(dp[i][j],dp[i][j-1]);
}
}
}
cout<<dp[n][m];
}
| 0
| 56,702,945
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.