code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 45
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int n,k;
cin>>k>>n;
vector<int> a(n);
for(int i=0;i<n;i++) cin>>a[i];
sort(a.begin(),a.end());
int ans=a[0]+k-a[n-1];
for(int i=1;i<n;i++) ans=max(ans,a[i]-a[i-1]);
ans=k-ans;
cout<<ans<<"\n";
return 0;
}
|
#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 all(x) x.begin(), x.end()
using ll = long long;
using pii = pair<int, int>;
const int mod = 1e9+7;
int main() {
string s, t;
cin >> s >> t;
int _s = s.size(), _t = t.size();
if (_s < _t) {
cout << "UNRESTORABLE" << endl;
return 0;
}
priority_queue<string, vector<string>, greater<string>> ans;
for (int i = 0; i + _t <= _s; i++) {
string x = s;
bool flag = false;
for (int j = 0; j < _t; j++) {
if (s[i + j] != t[j] && s[i + j] != '?') {
flag = true;
break;
} else {
x[i + j] = t[j];
}
}
if (flag) continue;
for (int k = 0; k < _s; k++) {
if (x[k] == '?') {
x[k] = 'a';
}
}
ans.push(x);
}
if (ans.empty()) {
cout << "UNRESTORABLE" << endl;
return 0;
} else {
cout << ans.top() << endl;
return 0;
}
}
| 0 | 46,881,079 |
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<algorithm>
#include<utility>
#include<map>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const int INF = 1001001001;
ll pow_mod(ll p, ll n, ll m) {
if (n == 0) return 1;
else if (n == 1) return p % m;
else if (n % 2 == 1) return p * pow_mod(p, n - 1, m) % m;
else {
ll tmp = pow_mod(p, n / 2, m);
return (tmp * tmp) % m;
}
}
ll gcd(ll x, ll y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
ll com_mod(ll n, ll k, ll m) {
if (k == 0) return 1;
else {
ll x = 1;
ll y = 1;
for (ll i = 0; i < k; i++) {
x = (x * (n - i)) % m;
y = (y * (i + 1)) % m;
}
ll res = (x * pow_mod(y, m - 2, m)) % m;
return res;
}
}
int main() {
int n, k, x, y; cin >> n >> k >> x >> y;
if (n <= k)cout << n * x << endl;
else cout << k * x + (n - k) * y << endl;
return 0;
}
|
#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
using namespace atcoder;
#define REP(i, n) for(int i = 0;i < (n);i++)
#define lint long long
const lint mod=1e9+7;
const lint inf=2.19e15+1;
const long double eps=1e-10;
template <class T,class U>bool chmin(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool chmax(T& a,U b){if(a<b){a=b;return true;}return false;}
signed main(){
int n, q;
cin >> n >> q;
dsu uni(n + 1);
REP(i,q){
int t, u, v;
cin >> t >> u >> v;
if (t==0){
uni.merge(u, v);
}
else{
if (uni.same(u,v)){
cout << 1 << endl;
}
else{
cout << 0 << endl;
}
}
}
}
| 0 | 7,305,822 |
#include<iostream>
#include<cstring>
using namespace std;
struct Node
{
int data;
Node* next;
Node* prev;
};
class List
{
private:
Node* mother;
public:
List();
~List();
void Ins(int);
void Del(int);
void DelFirst();
void DelLast();
void Show();
};
List::List()
{
mother = new Node;
mother->data = -1;
mother->next = this->mother;
mother->prev = this->mother;
}
void List::Ins(int x)
{
Node *tmp;
tmp = this->mother->next;
this->mother->next = new Node;
this->mother->next->data = x;
this->mother->next->next = tmp;
this->mother->next->prev = mother;
tmp->prev = mother->next;
return;
}
void List::Del(int x)
{
Node *tmp;
tmp = this->mother->next;
while (tmp != this->mother)
{
if (tmp->data == x)
{
tmp->prev->next = tmp->next;
tmp->next->prev = tmp->prev;
delete tmp;
break;
}
tmp = tmp->next;
}
return;
}
void List::DelFirst()
{
Node *tmp;
tmp = this->mother->next;
tmp->next->prev = mother;
this->mother->next = tmp->next;
delete tmp;
}
void List::DelLast()
{
Node *tmp;
tmp = this->mother->prev;
this->mother->prev = tmp->prev;
tmp->prev->next = mother;
delete tmp;
}
void List::Show()
{
Node *tmp;
tmp = mother->next;
cout << tmp->data;
tmp = tmp->next;
while (tmp != mother)
{
cout << " " << tmp->data;
tmp = tmp->next;
}
cout << endl;
return;
}
List::~List()
{
Node *tmp;
tmp = mother->next;
while (1)
{
tmp = tmp->next;
delete tmp->prev;
if (tmp == mother)
break;
}
}
int main()
{
int n, x;
char command[20];
List list;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> command;
if (!strcmp(command, "insert"))
{
cin >> x;
list.Ins(x);
}
else if (!strcmp(command, "delete"))
{
cin >> x;
list.Del(x);
}
else if (!strcmp(command, "deleteFirst"))
list.DelFirst();
else
list.DelLast();
}
list.Show();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main(){
int n;
cin >> n;
string s;
cin >> s;
vector<vector<bool>> l(n, vector<bool>(10)), r(n, vector<bool>(10));
l[0][s[0] - '0'] = true;
for(int i=1;i<n;i++){
for(int j=0;j<10;j++){
l[i][j] = l[i-1][j];
}
l[i][s[i] - '0'] = true;
}
r[n-1][s[n-1] - '0'] = true;
for(int i=n-2;i>=0;i--){
for(int j=0;j<10;j++){
r[i][j] = r[i+1][j];
}
r[i][s[i] - '0'] = true;
}
set<int> ans;
for(int c = 1; c < n-1;c++){
int cc = s[c] - '0';
for(int ll=0;ll<10;ll++){
for(int rr=0;rr<10;rr++){
if(l[c-1][ll] && r[c+1][rr]){
ans.insert(ll * 100 + cc * 10 + rr);
}
}
}
}
cout << ans.size() << endl;
return 0;
}
| 0 | 1,891,500 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n,ans;
ans=1;
cin>>n;
vector<long long> a(n);
for(int i=0;i<n;i++){
cin>>a.at(i);
}
for(int i=0;i<n;i++){
if(a.at(i)==0){
ans=0;
}
}
for(int i=0;i<n;i++){
if(ans!=0 && ans!=-1){
if(1000000000000000000/ans>=a.at(i)){
ans=ans*a.at(i);
}else{
ans=-1;
}
}
}
cout<<ans;
}
|
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <cmath>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <complex>
#include <string.h>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <sys/time.h>
#include <tuple>
#include <random>
using namespace std;
#define endl '\n'
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define UNIQ(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef long double ld;
typedef pair<ll, int> P;
typedef vector< vector<ld> > matrix;
struct pairhash {
public:
template<typename T, typename U>
size_t operator()(const pair<T, U> &x) const {
size_t seed = hash<T>()(x.first);
return hash<U>()(x.second) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
};
const int inf = 1e9 + 9;
const ll mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
ll n, k;
ll solve() {
ll l = 0, r = n;
ll res = 0;
for (int i = 1; i <= n+1; i++) {
if (i >= k) {
res += r - l + 1;
res %= mod;
}
l += i;
r += n-i;
}
return res;
}
void input() {
cin >> n >> k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
input();
cout << solve() << endl;
}
| 0 | 19,848,442 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info{
Info(int arg_a,int arg_b){
a = arg_a;
b = arg_b;
}
int a,b;
};
int main(){
int N,M;
scanf("%d %d",&N,&M);
vector<Info> info;
ll tmp = (M+1)/2;
for(int i = 0; i < tmp; i++){
info.push_back(Info(tmp-(i+1),tmp+i));
}
int tmp2 = M-tmp;
for(int i = 0; i < tmp2; i++){
info.push_back(Info(2*tmp+tmp2-(i+1),2*tmp+tmp2+(i+1)));
}
for(int i = 0; i < info.size(); i++){
printf("%d %d\n",info[i].a+1,info[i].b+1);
}
return 0;
}
|
#include<bits/stdc++.h>
int main(){
int n;std::cin>>n;
std::vector<long long>a(n+2);
for(int i=0;i<n;i++){
std::cin>>a.at(1+i);
}
std::vector<int>ord(n);
std::iota(ord.begin(),ord.end(),1);
std::sort(ord.begin(),ord.end(),[&a](int x,int y){return a.at(x)>a.at(y);});
int N=1;while(N<n+2)N<<=1;
std::vector<int>table(2*N);
table.at(N+0)=2;
table.at(N+1+n)=2;
for(int i=N-1;i>0;i--)table.at(i)=table.at(2*i)+table.at(2*i+1);
auto lower_bound=[&](int x){
int now=0;
int i=1;
while(i<N){
if(now+table.at(2*i)<x){
now+=table.at(2*i);
i=2*i+1;
}else{
i=2*i;
}
}
return i-N;
};
auto query=[&](int l,int r){
int ans=0;
for(l+=N,r+=N;l<r;l/=2,r/=2){
if(l&1)ans+=table.at(l++);
if(r&1)ans+=table.at(--r);
}
return ans;
};
long long ans=0;
for(int i:ord){
table.at(i+N)++;
for(int j=(i+N)/2;j>0;j>>=1)table.at(j)=table.at(2*j)+table.at(2*j+1);
int l0,l1,r0,r1;
int I=query(0,i+1);
l0=lower_bound(I-2);
l1=lower_bound(I-1);
r0=lower_bound(I+1);
r1=lower_bound(I+2);
ans+=a.at(i)*((l1-l0)*(r0-i)+(i-l1)*(r1-r0));
}
std::cout<<ans<<std::endl;
}
| 0 | 52,234,869 |
#include <iostream>
#include <iomanip>
#include <cassert>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <bitset>
#include <sstream>
#include <istream>
#include <cmath>
#include <cstdio>
using namespace std;
#define vci vector<int>
#define vcs vector<string>
#define pb push_back
#define sz size()
#define mapci map<char, int>
#define mapsi map<string, int>
#define all(x) x.begin(), x.end()
#define for_(i, a, b) for (int i=(int)a; i<(int)b; i++)
#define for_d(i, a, b) for (int i=(int)a-1; i>=b; i--)
#define for_r(i, a, b, c) for (int i=(int)a; i<(int)b; i += c)
#define for_dr(i, a, b, c) for (int i=(int)a-1; i>=b; i -= c)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define vcitr vector<int>::iterator
#define vcsitr vector<string>::iterator
#define mapcitr map<char, int>::iterator
#define mapsitr map<string, int>::iterator
typedef long long ll;
const int iINF = 2147483647;
const ll lINF = 9223372036854775807;
template <class T> inline void dbg(T t) { cout << t << endl; }
struct Point2D {
double x, y;
Point2D (double a=0, double b=0) { x=a; y=b; }
};
typedef Point2D Vector2D;
double dist2D(const Point2D& a, const Point2D& b) { return sqrt( (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) ); }
Vector2D sub_vector2D(const Vector2D& a, const Vector2D& b) {
Vector2D ret;
ret.x = a.x - b.x; ret.y = a.y - b.y;
return ret;
}
double cross_product(const Vector2D& a, const Vector2D& b) { return a.x*b.y - a.y*b.x; }
double inner_product(const Vector2D& a, const Vector2D& b) { return a.x*b.x + a.y*b.y; }
int main() {
int n; cin >> n;
Point2D a, b, c, d;
Vector2D x, y;
while (n--) {
cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y >> d.x >> d.y;
x = sub_vector2D(b, a); y = sub_vector2D(d, c);
if (fabs(cross_product(x, y)) < 1e-10) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stdio.h>
#include <list>
#include <numeric>
#include <stack>
#include <queue>
#include <tuple>
#include <bitset>
#include <map>
#include <math.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int,int> P;
const int inf=1000000007;
const ll mod=1000000007;
const double PI=3.14159265358979323846;
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
int main(){
int N,M;
cin >> N >> M;
int k[M];
int s[11][11];
int p[M];
rep(i,M) {
cin >> k[i];
rep(j,k[i]) {
cin >> s[i][j];
s[i][j]--;
}
}
rep(i,M) cin >> p[i];
int ans = 0;
for(int bit=0; bit < (1 << N); bit++) {
vector<bool> isturn(10,false);
rep(i,N) {
if((1<<i) & bit) {
isturn[i] = true;
}
}
int tmp = 0;
rep(i,M) {
int cnt = 0;
rep(j,k[i]) {
if(isturn[s[i][j]]) cnt++;
}
if(cnt%2 == p[i]) tmp++;
}
if(tmp == M) ans++;
}
cout << ans << endl;
return 0;
}
| 0 | 75,394,195 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll dis[150][150];
int main()
{
int n,m;
while(cin>>n>>m){
for(int i = 0;i < n;i++)
for(int j = 0;j < n;j++)
if(i == j) dis[i][j] = 0;
else dis[i][j] = INF;
int a,b,c;
while(m--){
cin>>a>>b>>c;
dis[a][b] = c;
}
for(int k = 0;k < n;k++)
for(int i = 0;i < n;i++){
if(dis[i][k] == INF) continue;
for(int j = 0;j < n;j++){
if(dis[k][j] == INF) continue;
dis[i][j] = min(dis[i][k] + dis[k][j],dis[i][j]);
}
}
int flag = 0;
for(int i = 0;i < n;i++)
if(dis[i][i]<0){
flag = 1;
break;
}
if(flag) cout<<"NEGATIVE CYCLE"<<endl;
else{
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
if(dis[i][j] == INF) cout<<"INF"<<(j==n-1?'\n':' ');
else cout<<dis[i][j] <<(j==n-1?'\n':' ');
}
}
}
}
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;
const int MAX = 1000000;
const int MOD = 1000000007;
int main(){
string s;
cin >> s;
if(s=="AAA"||s=="BBB"){
cout << "No" << endl;
}else{
cout << "Yes" << endl;
}
}
| 0 | 48,163,607 |
#include <stdio.h>
#include <iostream>
#include <queue>
#include <cstdio>
#include <stack>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string.h>
#include <limits.h>
#include <map>
#include <string>
#include <bitset>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
if (s[2] == s[3] && s[4] == s[5] && s.size() == 6) printf("Yes\n");
else printf("No\n");
return 0;
}
|
#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);
int main(void)
{
int n;
cin >> n;
map<ll, ll> even, odd;
vector<ll> v(n);
for (int i = 0; i < n; i++)
{
cin >> v[i];
if (i & 1)
{
odd[v[i]]++;
}
else
{
even[v[i]]++;
}
}
priority_queue<P> eq, oq;
eq.push({0, 0});
oq.push({0, 0});
for (auto x : even)
{
eq.push({x.second, x.first});
}
for (auto x : odd)
{
oq.push({x.second, x.first});
}
if (eq.top().second != oq.top().second)
{
cout << n - eq.top().first - oq.top().first << endl;
return 0;
}
else
{
P e1, e2, o1, o2;
e1 = eq.top();
eq.pop();
o1 = oq.top();
oq.pop();
e2 = eq.top();
o2 = oq.top();
cout << n - max(e1.first + o2.first, e2.first + o1.first) << endl;
}
}
| 0 | 47,021,203 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const i64 MOD = 1e9 + 7;
const i64 INF = i64(1e18) + 7;
template <typename T>
bool chmin(T& x, T y){
if(x > y){
x = y;
return true;
}
return false;
}
template <typename T>
bool chmax(T& x, T y){
if(x < y){
x = y;
return true;
}
return false;
}
template<typename T>
struct Compression{
vector<T> compvec;
Compression(vector<T>& inp){
compvec = inp;
sort(compvec.begin(), compvec.end());
compvec.erase(unique(compvec.begin(), compvec.end()), compvec.end());
}
int Index(T val){
auto it = lower_bound(compvec.begin(), compvec.end(), val);
return distance(compvec.begin(), it);
}
vector<T>& operator*(){
return compvec;
}
};
struct BitVector{
vector<uint64_t> v;
vector<int> r;
BitVector(){}
void build(){
r.assign(v.size() + 1, 0);
for(int i = 0; i < v.size(); ++i)
r[i + 1] = r[i] + __builtin_popcountll(v[i]);
}
bool access(int x){
return (v[x >> 6] >> (x & 63)) & 1;
}
int rank(int x){
return r[x >> 6] + __builtin_popcountll(v[x >> 6] & ((1uLL << (x & 63)) - 1));
}
int rank(int x, bool fl){
return fl ? rank(x) : x - rank(x);
}
};
template <typename T, int W>
struct WaveletMatrix{
array<BitVector, W> bv;
array<int, W> zero_cnt;
WaveletMatrix(vector<T>& a){
int n = a.size();
vector<T> v(a);
for(int i = W - 1; i >= 0; --i){
vector<uint64_t> b((n >> 6) + 1, 0);
vector<T> v1, v2;
for(int j = 0; j < n; ++j){
((v[j] >> i) & 1 ? v2 : v1).push_back(v[j]);
b[j >> 6] |= uint64_t((v[j] >> i) & 1) << (j & 63);
}
for(int j = 0; j < v.size(); ++j)
v[j] = (j < v1.size() ? v1[j] : v2[j - v1.size()]);
bv[i].v = move(b);
bv[i].build();
zero_cnt[i] = bv[i].rank(n, 0);
}
}
int count(int l, int r, T x){
for(int i = W - 1; i >= 0; --i){
bool fl = (x >> i) & 1;
int st = bv[i].rank(l, fl);
int en = bv[i].rank(r, fl);
l = (fl ? zero_cnt[i] : 0) + st;
r = (fl ? zero_cnt[i] : 0) + en;
}
return r - l;
}
int count_lower(int l, int r, T x){
int cnt = 0;
for(int i = W - 1; i >= 0; --i){
bool fl = (x >> i) & 1;
int st = bv[i].rank(l, fl);
int en = bv[i].rank(r, fl);
if(fl){
st += zero_cnt[i];
en += zero_cnt[i];
cnt += (bv[i].rank(r, 0) - bv[i].rank(l, 0));
}
l = st, r = en;
}
return cnt;
}
int count_range(int l, int r, T x, T y){
return count_lower(l, r, y) - count_lower(l, r, x);
}
T kth_min(int l, int r, int k){
T ans = 0;
for(int i = W - 1; i >= 0; --i){
int st = bv[i].rank(l, 0);
int en = bv[i].rank(r, 0);
if(en - st <= k){
k -= en - st;
l = zero_cnt[i] + bv[i].rank(l, 1);
r = zero_cnt[i] + bv[i].rank(r, 1);
ans |= (1uLL << i);
}
else{
l = st, r = en;
}
}
return ans;
}
pair<T, bool> predecessor(int l, int r, T x){
int idx = count_lower(l, r, x);
if(idx == r - l){
return make_pair((1uLL << W) - 1, false);
}
return make_pair(kth_min(l, r, idx), true);
}
pair<T, bool> successor(int l, int r, T x){
int idx = count_lower(l, r, x + 1);
if(idx == 0)
return make_pair(0, false);
return make_pair(kth_min(l, r, idx - 1), true);
}
};
signed main(){
int n, k;
cin >> n >> k;
vector<int> x(n), y(n);
vector<pair<int,int>> vx;
for(int i = 0; i < n; ++i){
cin >> x[i] >> y[i];
vx.emplace_back(x[i], i);
}
sort(vx.begin(), vx.end());
vector<int> wx, wy;
Compression<int> cy(y);
for(int i = 0; i < n; ++i){
wx.emplace_back(vx[i].first);
wy.emplace_back(cy.Index(y[vx[i].second]));
}
int siz = cy.compvec.size();
WaveletMatrix<int, 20> wm(wy);
i64 ans = 4 * INF + 5 * MOD;
for(int i = 0; i < n; ++i){
for(int j = i + 1; j <= n; ++j){
int lx = wx[i];
int rx = wx[j - 1];
for(int i2 = 0; i2 < siz; ++i2){
for(int j2 = i2 + 1; j2 <= siz; ++j2){
if(wm.count_range(i, j, i2, j2) >= k){
int ly = cy.compvec[i2];
int ry = cy.compvec[j2 - 1];
chmin(ans, 1LL * (rx - lx) * (ry - ly));
}
}
}
}
}
cout << ans << endl;
}
|
#pragma GCC optimize("O3")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define int long long
string per(int n) {
string s;
if (n == 0) {
s += '0';
return s;
}
while (n > 0) {
if (n % 2) s += '1';
else s += '0';
n /= 2;
}
return s;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n; cin >> n;
vector<int> vec(n), f(23, 0);
for (int i = 0; i < n; ++i) cin >> vec[i];
int l = 0, r = 0, ans = 0;
while (l < n) {
if (r == n) {
ans += r - l;
l++;
continue;
}
while (true) {
if (r == n) break;
string s = per(vec[r]);
bool flag = true;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1' && f[i] == 1) {
flag = false;
break;
}
}
if (!flag) break;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') f[i] += 1;
}
r++;
}
ans += r - l;
string s = per(vec[l]);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') f[i]--;
}
l++;
}
cout << ans;
}
| 0 | 63,969,158 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int N;
cin >> N;
vector<int> C(N-1), S(N-1), F(N-1);
rep(i,N-1) cin >> C.at(i) >> S.at(i) >> F.at(i);
for (int i = 0; i < N; ++i) {
if (i == N - 1) {
cout << 0 << endl;
} else {
int ans = 0;
for (int j = i; j < N - 1; ++j) {
if (ans >= S.at(j)) ans += (F.at(j) - ans % F.at(j)) % F.at(j) + C.at(j);
else ans = S.at(j) + C.at(j);
}
cout << ans << endl;
}
}
}
|
#include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef pair<int ,int > P;
typedef long long ll;
map<int,string> map1;
map<string,int> map2;
int main() {
string s;
while(cin>>s) {
map1[-s.size()]=s;
map2[s]++;
}
auto it = map2.begin();
int maxi=0;
string ans;
while(it!=map2.end()) {
if(maxi<it->sc) {
maxi = it->sc;
ans=it->fr;
}
it++;
}
cout<<ans<<" ";
cout<<(map1.begin()->sc)<<endl;
return 0;
}
| 0 | 73,282,930 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n; cin >> n;
string s; cin >> s;
int cnt = 0;
REP(i, 10) {
auto posA = find(s.begin(), s.end(), i + '0');
if (posA != s.end()) {
REP(j, 10) {
auto posB = find(posA+1, s.end(), j + '0');
if (posB != s.end()) {
REP(k, 10) {
auto posC = find(posB+1, s.end(), k + '0');
if (posC != s.end())
cnt++;
}
}
}
}
}
cout << cnt << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vec_int = vector<int>;
using P = pair<int,int>;
using T = tuple<int,int,int>;
using ll = long long;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
int charToInt(char c){
char zero_num = '0';
return (int)c - (int)zero_num;
}
int main(){
int N, M;cin>>N>>M;
vec_int Pref(M);
vec_int Y(M);
vector<vector<P>> pref_city(N+1);
rep(i,M){
cin>>Pref.at(i)>>Y.at(i);
pref_city.at(Pref.at(i)).push_back(make_pair(Y.at(i),i));
}
vec_int city_ind(M);
rep(i,N+1){
sort(pref_city.at(i).begin(),pref_city.at(i).end());
rep(j, pref_city.at(i).size()){
int year, city;
tie(year,city) = pref_city.at(i).at(j);
city_ind.at(city) = j+1;
}
}
rep(i,M){
string pref_str = to_string(Pref.at(i));
string city_str = to_string(city_ind.at(i));
while(pref_str.size()<6){
pref_str = '0'+pref_str;
}
while(city_str.size()<6){
city_str = '0'+city_str;
}
cout<<pref_str+city_str<<endl;
}
return 0;
}
| 0 | 3,735,116 |
#include "bits/stdc++.h"
using namespace std;
typedef long long int ll;
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep1(i,n) for(ll i=1;i<n;i++)
#define repr(i,n) for(ll i=n;i>0;i--)
#define all(v) v.begin(),v.end()
#define in cin>>
#define out cout<<
#define en <<endl
const ll INF = 10000000000000;
int main()
{
ll a, b, c;
in a >> b >> c;
if (a < b && b < c)
{
out "Yes" en;
}
else
out "No" en;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<stack>
#include<map>
using namespace std;
#define int long long
#define REP(i,n) for(int i=0;(i)<(n);(i)++)
#define ll long long
map<pair<int,int>, int> mp;
signed main() {
int H, W, N;
cin >> H >> W >> N;
int a, b;
pair<int, int> p;
REP(i, N) {
cin >> a >> b;
for (int i = -1;i <= 1;i++) {
for (int j = -1;j <= 1;j++) {
p.first = a + i;
p.second = b + j;
if (p.first<2 || p.first > H - 1 || p.second < 2 || p.second > W - 1) continue;
mp[p]++;
}
}
}
ll ans[10];
ans[0] = (H - 2)*(W - 2);
for (int i = 1;i <= 9;i++) {
ans[i] = 0;
for (auto m : mp) {
if (m.second == i) ans[i]++;
}
ans[0] -= ans[i];
}
REP(i, 10) cout << ans[i] << endl;
return 0;
}
| 0 | 47,446,299 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
cin>>s;
string strs[]={
"dream",
"dreamer",
"erase",
"eraser"
};
bool dp[100001]={true};
for(int i=0;i<s.size();i++){
for(auto e:strs){
int n=i+e.size();
if(n<=s.size()&&!s.compare(i,e.size(),e)){
dp[n]|=dp[i];
}
}
}
cout<<(dp[s.size()]?"YES":"NO")<<endl;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
bool IsPrime[1000000];
int PrimeNum[1000000];
int main()
{
for (int i = 0; i < 1000000; i++)
{
IsPrime[i] = true;
}
int count = 0;
PrimeNum[0] = PrimeNum[1] = 0;
for (int i = 2; i < 1000000; i++) {
if (IsPrime[i]) {
count++;
PrimeNum[i] = count;
for (int j = 2 * i; j < 1000000; j += i) {
IsPrime[j] = false;
}
}
else
{
PrimeNum[i] = PrimeNum[i - 1];
}
}
int n;
while (cin >> n)
{
cout << PrimeNum[n] << endl;
}
return 0;
}
| 0 | 85,563,678 |
#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/3;
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)
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() {
cout << fixed << setprecision(12);
int K; cin >> K;
deque<PII> deq;
deq.EB(1,1);
int ans;
VB used(K,false);
while(1){
PII now = deq.front(); deq.POF();
if(used.at(now.FI)) continue;
if(now.FI%K == 0){
ans = now.SE;
break;
}
used.at(now.FI) = true;
deq.EB((now.FI+1)%K,now.SE+1);
deq.emplace_front((now.FI*10)%K,now.SE);
}
COUT(ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long t,b,c,d,n,m,i,x,y;
cin>>n;
string s,a,aa;
cin>>s;
if(n%2){cout<<"No"<<endl;}
else
{
x=n/2;
for(i=0;i<x;i++)
{
a+=s[i];
}
for(i=x;i<n;i++)
{
aa+=s[i];
}
if(aa==a)cout<<"Yes"<<endl;
else {cout<<"No"<<endl;}
}
return 0;
}
| 0 | 94,256,627 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b && b < c) {
cout << "Yes"
<< "\n";
} else {
cout << "No"
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
#define vi vector<int >
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define sz(x) (x).size()
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin, (x).rend()
#define ll long long
#define ld long double
const ld EPS = 10e-9;
const int INF = 1e9 + 5;
const long long INFLL = (ll)INF * (ll)INF;
const ll MOD = 1e9 + 7;
const ld PI = 3.14159265358979323846;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i];
if (i != (int)v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v)
{
os << "{";
for (const auto& it : v) {
os << it;
if (it != *v.rbegin())
os << ", ";
}
os << "}\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const unordered_set<T>& v)
{
os << "{";
for (const auto& it : v) {
os << it;
if (it != *v.rbegin())
os << ", ";
}
os << "}\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v)
{
os << "{";
for (const auto& it : v) {
os << it.first << " : "
<< it.second;
if( it != *v.rbegin())
os << ", ";
}
os << "}\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const unordered_map<T, S>& v)
{
os << "{";
for (const auto& it : v) {
os << it.first << " : "
<< it.second;
if( it != *v.rbegin())
os << ", ";
}
os << "}\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v)
{
os << "(";
os << v.first << ", "
<< v.second << ")";
os << "\n";
return os;
}
#define DEBUG
#ifdef DEBUG
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define debug(...)
#endif
ll f(ll x, ll d)
{
return x + (ll)ceil((double)d/(x+1));
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
int s, w;
cin >> s >> w;
if(w >= s)
{
cout << "unsafe";
}
else
{
cout << "safe";
}
return 0;
}
| 0 | 70,614,407 |
#include "bits/stdc++.h"
using namespace std;
using i64 = int_fast64_t;
using seika = string;
template <class kizuna>
using akari = vector<kizuna>;
template <class yuzuki>
using yukari = akari<akari<yuzuki>>;
template <class tsurumaki>
using maki = akari<yukari<tsurumaki>>;
template <class kotonoha>
using akane = priority_queue<kotonoha, akari<kotonoha>, greater<kotonoha>>;
template <class kotonoha>
using aoi = priority_queue<kotonoha>;
inline void print()
{
cout << endl;
}
template <typename First, typename... Rest>
void print(const First &first, const Rest &... rest)
{
cout << first << ' ';
print(rest...);
}
void solve()
{
int n, q, l;
cin >> n;
akari<int> xs(n);
for (int i = 0; i < n; i++)
{
cin >> xs[i];
}
cin >> l >> q;
yukari<int> dp(n, akari<int>(21));
for (int i = 0; i < n; i++)
{
dp[i][0] = distance(xs.begin(), upper_bound(xs.begin(), xs.end(), xs[i] + l)) - 1;
}
for (int k = 0; k < 20; k++)
{
for (int i = 0; i < n; i++)
{
dp[i][k + 1] = dp[dp[i][k]][k];
}
}
while (q--)
{
int a, b;
cin >> a >> b;
if (a > b)
{
swap(a, b);
}
a--, b--;
int ans = 0;
for (int k = 20; k >= 0; k--)
{
if (dp[a][k] < b)
{
a = dp[a][k];
ans |= 1 << k;
}
}
ans++;
cout << ans << '\n';
}
}
int main()
{
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
#define MAXN 105
#define FOR(i, n) for (int i = 0; i < n; i++)
#define FORR(j, i, n) for (int i = j; i < n; i++)
#define FORD(i, n) for (int i = n - 1; i >= 0; i--)
#define FOBIR(i, n) for (int i = 1; i <= n; i++)
#define pb push_back
#define mp make_pair
#define endl '\n'
#define DUEHOANG \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define JaydenXia(in, out) \
freopen(in, "r", stdin); \
freopen(out, "w", stdout);
#define ll long long
typedef set<int> si;
typedef vector<int> vi;
typedef pair<ll, ll> pii;
typedef vector<pii> vii;
typedef priority_queue<int> pqi;
typedef stack<int> sti;
typedef queue<int> qi;
typedef deque<int> di;
typedef map<int, int> mii;
#define f first
#define s second
#define EPS 1e-9
int n;
pii psum[MAXN];
pii a[MAXN];
bool ang(pii p, pii q)
{
return atan2(p.f, p.s) < atan2(q.f, q.s);
}
int main()
{
cin >> n;
FOR(i, n)
{
cin >> a[i].f >> a[i].s;
}
sort(a, a+n, ang);
ll ans = 0;
FOR(i, n)
{
ll x = 0;
ll y = 0;
FOR(j, n)
{
x += a[(i+j)%n].f;
y += a[(i+j)%n].s;
ans = max(ans, x*x+y*y);
}
}
cout << setprecision(25) << fixed << sqrt(ans) << endl;
}
| 0 | 12,792,302 |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stack>
#include<cmath>
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
string key="keyence";
int lnth=s.length();
for(int i=0;i<=7;i++){
bool ans=true;
int ind=0;
for(int j=0;j<i;j++){
if(key[ind++]!=s[j]){
ans=false;
break;
}
}
for(int j=i+lnth-7;j<lnth;j++){
if(key[ind++]!=s[j]){
ans=false;
break;
}
}
if(ans){cout<<"YES"<<endl;return 0;}
}
cout<<"NO"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string alphabet = "abcdefghijklmnopqrstuvwxyz";
string S;
cin >> S;
vector<bool>al(26, false);
for (char s : S) al[s-'a'] = true;
if (S.size() == 26) {
int i = S.size()-1;
while (S[i-1] > S[i]) {
if (i == 1) {
cout << -1 << endl;
return 0;
}
al[S[i]-'a'] = false;
i--;
}
al[S[i]-'a'] = false;
while (al[S[i-1]-'a']) S[i-1]++;
S.erase(i);
cout << S << endl;
return 0;
}
int i = 0;
while (al[i]) i++;
S += alphabet[i];
cout << S << endl;
}
| 0 | 62,280,363 |
#include <iostream>
#include <ctime>
using namespace std;
int N,M;
void solve()
{
cin >> N >> M;
int X = 1900 * M + 100 * (N-M);
while (M > 0){
X *= 2;
--M;
}
cout << X << endl;
}
int main()
{
cin.tie();
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;
void solve() {
int N;
cin >> N;
vector<int> a(N), b(N);
for (int i=0; i<N; ++i) cin >> a[i] >> b[i];
ll sum = 0;
for (int x : a) sum += x;
int val = INF+1, ind = -1;
for (int i=0; i<N; ++i) if (a[i] > b[i] && chmin(val, b[i])) ind = i;
if (ind == -1) cout << 0 << '\n';
else cout << sum - val << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
| 0 | 17,531,059 |
#include <iostream>
#include <string>
#include <stack>
using namespace std;
int main(void) {
while (true) {
string str;
getline(cin,str);
if (str[0] == '.') break;
bool flag = true;
stack<int> s;
for (size_t i = 0; str[i] != '\0'; i++) {
int c = str[i];
if (c == 40) {
s.push(0);
}
else if (c == 91) {
s.push(1);
}
else if (c == 41) {
if (s.empty()) {
flag = false;
break;
}
else {
if (s.top() == 0) {
s.pop();
}
else
break;
}
}
else if (c == 93) {
if (s.empty()) {
flag = false;
break;
}
else {
if (s.top() == 1) {
s.pop();
}
else
break;
}
}
}
if (s.empty() && flag)
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
#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 map<int,int> MII;
typedef queue<int> QI;
typedef queue<PII> QPII;
typedef stack<int> SI;
typedef stack<PII> SPII;
typedef deque<int> DI;
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 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 LB lower_bound
#define UB upper_bound
#define SORTR(c) sort((c).begin(), (c).end(), greater<int>())
#define NEXP next_permutation
#define FI first
#define SE second
#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 BREP(bit,N) for (int bit = 0; bit < (1<<N); ++bit)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX/2;
const LL LINF = LLONG_MAX/2;
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 SEP(a) cout << fixed << setprecision(a)
#define COUT(x) cout << (x) << endl
#define COUT2(x,y) cout << (x) << " " << (y) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define cYes COUT("Yes")
#define cNo COUT("No")
#define cYES COUT("YES")
#define cNO COUT("NO")
#define cyes COUT("yes")
#define cno COUT("no")
#define BC(x) __builtin_popcountll(x)
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;
}
LL fac[MAX], finv[MAX], inv[MAX];
void ConInit(LL M) {
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 % M;
inv[i] = M - inv[M%i] * (M / i) % M;
finv[i] = finv[i - 1] * inv[i] % M;
}
}
LL COM(int n, int k, LL M){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % M) % M;
}
void VCout(auto v){
int N = SZ(v);
REP(i,N){
cout << v.at(i);
if(i == N-1)ENDL;
else SPACE;
}
return;
}
void Press(auto &v){v.erase(unique(ALL(v)),v.end());}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
SEP(12);
int N;
cin >> N;
VLL A(N),B(N),C(N);
LL ba=0,ab=0;
REP(i,N) cin >> A.at(i);
REP(i,N) cin >> B.at(i);
int ans=0;
REP(i,N){
if(A.at(i) < B.at(i)){
ba += B.at(i)-A.at(i);
ans++;
}
if(A.at(i) > B.at(i)) ab += A.at(i)-B.at(i);
C.at(i) = A.at(i)-B.at(i);
}
if(ba > ab){
COUT(-1);
return 0;
}
if(ba == 0){
COUT(0);
return 0;
}
SORTR(C);
REP(i,N){
ba -= C.at(i);
ans++;
if(ba <= 0) break;
}
COUT(ans);
return 0;
}
| 0 | 60,191,431 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
string s;cin>>s;
int ans=s.size(),n=s.size();
rep(i,2){
int cnt=0;
rep(j,n){
if(j%2==0&&s[j]!=(char)(i+'0'))cnt++;
if(j%2==1&&s[j]==(char)(i+'0'))cnt++;
}
ans=min(ans,cnt);
}
cout<<ans<<endl;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<math.h>
#include<queue>
#include<map>
#include<string>
#define all(x) (x).begin(),(x).end()
typedef long long ll;
using namespace std;
int main(){
map<string,int> mp;
int N; cin >> N;
ll tmp, ans;
for(int i=0; i<N; i++){
string s; cin >> s;
sort(all(s));
mp[s]++;
}
ans = 0;
for(auto i=mp.begin(); i != mp.end(); i++){
tmp = i->second;
ans += tmp*(tmp-1)/2;
}
cout << ans << endl;
return 0;
}
| 0 | 46,586,658 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int inf = 1001001001;
int main(){
int n,m;
cin >> n >> m;
priority_queue<ll> q;
rep(i,n){
ll a;
cin >> a;
q.push(a);
}
while(m>0){
ll t = q.top(); q.pop();
t /= 2;
q.push(t);
m--;
}
ll ans = 0;
while(!q.empty()){
ll t = q.top(); q.pop();
ans += t;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const int maxn = 3e5 + 20;
int pos[maxn] , a[maxn];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for(int i = 0; i < n; i++)
cin >> a[i] , a[i]-- , pos[a[i]] = i;
set<int> st;
st.insert(-1);
st.insert(n);
ll res = 0;
for(int i = n - 1; i >= 0; i--)
{
int k = pos[i];
auto R = st.lower_bound(k);
auto L = R;
L--;
if(*R != n)
{
auto tmp = R;
tmp++;
res += 1LL * (i + 1) * (*tmp - *R) * (k - *L);
}
if(*L != -1)
{
auto tmp = L;
tmp--;
res += 1LL * (i + 1) * (*R - k) * (*L - *tmp);
}
st.insert(k);
}
cout << res << endl;
}
| 0 | 67,548,123 |
#include <cassert>
#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>
#include <cwchar>
#include <cwctype>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#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>
#include <array>
#include <atomic>
#include <chrono>
#include <codecvt>
#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>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep2(i, n) for(int i = 1; i <= (int)(n); i++)
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef int64_t ll;
typedef long double ld;
const ll INF=(1LL<<62);
const double inf=pow(10,10);
const ld pi=acosl(1);
const ll mod = 1000000007;
const int dx[4]={0,1,0,-1};
const int dy[4]={1,0,-1,0};
const int ddx[8]={1,0,-1,-1,-1,0,1,1};
const int ddy[8]={1,1,1,0,-1,-1,-1,0};
int main(){
ll N,K;cin>>N>>K;
vector<ll>A(N);
rep(i,N){
cin>>A[i];
A[i]--;
}
vector<ll>sum(N+1,0);
map<ll,ll>mp;
rep(i,N){
sum[i+1]=sum[i]+A[i];
sum[i+1]%=K;
}
ll ans=0;
rep(i,N+1){
if(i-K>=0)mp[sum[i-K]]--;
ans+=mp[sum[i]];
mp[sum[i]]++;
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <vector>
#include <cctype>
#include <cstdio>
#include <iomanip>
#define PI 3.1415926535
using namespace std;
int n, a = 0, b = 0;
string s, t;
int main(){
cin >> n;
for (int i = 0; i < n; i++){
cin >> s >> t;
if (s>t)a += 3;
else if (s < t) b += 3;
else {
a++;
b++;
}
}
cout << a << " " << b << endl;
}
| 0 | 24,493,826 |
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#define For(i, a, b) for(int (i)=(a); (i)<(b); (i)++)
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); (i)--)
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef pair<int, int> pii;
int n, m;
vector<pii> s(10010);
int main(){
cin >> n >> m;
while(n){
rep(i, n){
int d, p; cin >> d >> p;
s[i] = pii(d, p);
}
sort(s.begin(), s.begin()+n, [](const pii &a, const pii &b){return a.se > b.se;});
rep(i, n){
if(m == 0) break;
else if(s[i].fi <= m){
m -= s[i].fi;
s[i] = pii(0, s[i].se);
}
else{
s[i] = pii(s[i].fi-m, s[i].se);
m = 0;
}
}
int ans = 0;
rep(i, n) ans += s[i].fi * s[i].se;
cout << ans << endl;
cin >> n >> m;
}
}
|
# include <bits/stdc++.h>
# define rep(i, n) for (ll i = 0; i < (n); i++)
# define reps(i, n) for (ll i = 1; i <= (n); i++)
# define foreps(i, m, n) for (ll i = (m); i < (n); i++)
# define len(x) ((int)(x).size())
# define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef long double ld;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
int main() {
ll n; cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
string ans;
for (char c = 'a'; c <= 'z'; c++) {
ll res = 1e18;
rep(i, n) {
ll cnt = 0;
rep(j, len(s[i])) {
if (s[i][j] == c) ++cnt;
}
res = min(res, cnt);
}
rep(i, res) ans += c;
}
cout << ans << endl;
}
| 0 | 88,075,212 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lvector vector<ll>
#define cvector vector<char>
#define svector vector<string>
#define lque queue<ll>
#define lpque priority_queue<ll>
#define dlpque priority_queue<ll,lvector,greater<ll>>
#define P pair<ll,ll>
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define rep(i,n) for(ll i=0; i<n; ++i)
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s,t;ll ans=0;cin>>s>>t;
rep(i,3) if(s[i]==t[i]) ans++;
print(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define rep1(i, n) FOR(i, 1, n+1)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define whole(x) (x).begin(),(x).end()
#define rwhole(x) (x).rbegin(), (x).rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define P pair<int, int>
#define debug(var) cerr << "[" << #var << "] " << var << '\n'
template<typename T1, typename T2>
bool chmax(T1 &a,T2 b){if(a<b){a=b;return true;}else return false;}
template<typename T1, typename T2>
bool chmin(T1 &a,T2 b){if(a>b){a=b;return true;}else return false;}
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define pr(s) cout << (s) << '\n'
const ll mod = 1000000007;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
const int INF = 1001001001;
const ll INFll = 1E+18;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, d;
cin >> n >> m >> d;
double ans = 0.0;
double res = min(d*2, n)*1.0/static_cast<double>(n) + (n-min(d*2, n))*2.0/static_cast<double>(n);
if (d==0) {
res = 1.0;
}
debug(res);
res *= static_cast<double>(m-1)/static_cast<double>(n);
ans = res;
printf("%.10f\n", ans);
return 0;
}
| 0 | 78,873,728 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int LOGN=20;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin>>n;
vector<ll> x(n);
for(int i=0;i<n;i++) cin>>x[i];
ll l; int q;
cin>>l>>q;
vector<vector<int>> dp(LOGN,vector<int>(n,0));
for(int i=0;i<n;i++){
auto it=prev(upper_bound(x.begin(),x.end(),x[i]+l));
int j=it-x.begin();
dp[0][i]=j;
}
for(int i=0;i+1<LOGN;i++){
for(int j=0;j<n;j++){
dp[i+1][j]=dp[i][dp[i][j]];
}
}
while(q--){
int a,b;
cin>>a>>b;
a--,b--;
if(a>b) swap(a,b);
int res=0;
for(int i=LOGN-1;i>=0;i--){
if(dp[i][a]<b){
res+=(1<<i);
a=dp[i][a];
}
}
res++;
cout<<res<<"\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = int;
using Graph = vector<vector<Edge>>;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e9;
const int MAX = 510000;
bool graph[nmax][nmax];
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;
}
}
ll 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;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
struct SegmentTree
{
private:
ll n;
vector<ll> node;
public:
SegmentTree(vector<ll> v)
{
ll sz = v.size();
n = 1;
while (n < sz)
{
n *= 2;
}
node.resize(2 * n - 1, INF);
for (ll i = 0; i < sz; i++)
{
node[i + n - 1] = v[i];
}
for (ll i = n - 2; i >= 0; i--)
{
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(ll x, ll val)
{
x += (n - 1);
node[x] = val;
while (x > 0)
{
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
ll find(ll a, ll b, ll k = 0, ll l = 0, ll r = -1)
{
if (r < 0)
r = n;
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = find(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
void warshall_floyd(ll n)
{
for (size_t i = 0; i < n; i++)
{
for (size_t j = 0; j < n; j++)
{
for (size_t k = 0; k < n; k++)
{
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
class UnionFind
{
public:
vector<ll> Parent;
UnionFind(ll N)
{
Parent = vector<ll>(N, -1);
}
ll find(ll A)
{
if (Parent[A] < 0)
return A;
return Parent[A] = find(Parent[A]);
}
ll size(ll A)
{
return -Parent[find(A)];
}
bool Union(ll A, ll B)
{
A = find(A);
B = find(B);
if (A == B)
{
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b)
{
ll g = gcd(a, b);
return a / g * b;
}
ll mulMod(ll a, ll b)
{
return (((a % MOD) * (b % MOD)) % MOD);
}
ll powMod(ll a, ll p)
{
if (p == 0)
{
return 1;
}
else if (p % 2 == 0)
{
ll half = powMod(a, p / 2);
return mulMod(half, half);
}
else
{
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b)
{
return (a + b - 1) / b;
}
vector<ll> tsort(Graph G)
{
ll N = G.size();
vector<ll> in(N);
for (auto &&edges : G)
{
for (auto &&edge : edges)
{
in[edge]++;
}
}
queue<int> que;
for (int i = 0; i < N; i++)
{
if (in[i] == 0)
{
que.push(i);
}
}
int cnt = 0;
vector<ll> ans;
while (!que.empty())
{
int v = que.front();
que.pop();
ans.push_back(v);
for (auto &&next : G[v])
{
in[next]--;
if (in[next] == 0)
{
que.push(next);
}
}
}
return ans;
}
Graph G(100);
void treeDFS(int from, int current, int dist, int &maxDist, int &maxVertex)
{
if (dist > maxDist)
{
maxDist = dist;
maxVertex = current;
}
for (auto to : G[current])
{
if (to == from)
continue;
treeDFS(current, to, dist + 1, maxDist, maxVertex);
}
}
pair<int, int> getTreeDiameter()
{
int start = 0, end = 0, maxDist = 0;
treeDFS(-1, start, 0, maxDist, end);
start = end, end = 0, maxDist = 0;
treeDFS(-1, start, 0, maxDist, end);
return make_pair(start, end);
}
void solve(std::string S)
{
vector<char> a(26);
for (char c = 'a'; c <= 'z'; c++)
{
a[c - 'a'] = c;
}
if (S == "zyxwvutsrqponmlkjihgfedcba")
{
cout << -1 << endl;
return;
}
if (S.size() == 26)
{
string T = S;
next_permutation(S.begin(), S.end());
for (int i = 0; i < S.size(); i++)
{
cout << S[i];
if (S[i] != T[i])
break;
}
cout << endl;
}
else
{
for (char c = 'a'; c <= 'z'; c++)
{
if (find(S.begin(), S.end(), c) == S.end())
{
cout << S << c << endl;
return;
}
}
}
}
int main()
{
std::string S;
std::cin >> S;
solve(S);
return 0;
}
| 0 | 73,299,497 |
#include<cstdio>
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a<b && b<c)puts("Yes");
else puts("No");
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int,int> P;
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<(b);i++)
#define repr(i,b,a) for(int i=int(b);i>=(a);i--)
#define all(x) x.begin(),x.end()
const ll mod = 1e9+7;
const ll INF = 1e9;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
bool valid(int lx,int ux,int ly,int uy,int x,int y){
return lx<=x&&x<ux&&ly<=y&&y<uy;
}
ll power(ll x,ll p){
if(p==0)return 1;
ll res=power(x*x%mod,p/2);
if(p%2==1)res=res*x%mod;
return res;
}
map<ll, int> prime_factor(ll n)
{
map<ll, int> res;
for(ll i = 2; i * i <= n; i++)
{
while(n % i == 0)
{
++res[i];
n /= i;
}
}
if (n != 1)
{
res[n] = 1;
}
return res;
}
int main()
{
ll n;
cin>>n;
map<ll, int> mp = prime_factor(n);
ll ans=0;
for(auto mm: mp){
int num=mm.second;
int cnt=0, i=1;
while(cnt+i<=num){
ans++;
cnt+=i;
i++;
}
}
cout<<ans<<endl;
return 0;
}
| 0 | 82,689,433 |
#include<stdio.h>
int prime[1000000];
int main(){
prime[0]=-1;
prime[1]=-1;
for(int i=2;i<1000000;i++){
if(prime[i]==0){
prime[i]=1;
for(int j=i*2;j<1000000;j+=i)prime[j]=-1;
}
}
int now;
while(~scanf("%d",&now)){
int ans=0;
for(int i=1;i<now+1;i++)if(prime[i]==1)ans++;
printf("%d\n",ans);
}
}
|
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
const int m = 61;
int n;
vector<bitset<m>> gaussian_elimination(vector<bitset<m>> b) {
vector<bitset<m>> c(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) c[i][j] = b[i][m - 1 - j];
}
int x = 0;
for (int i = 0; i < n && x < m; i++, x++) {
int pivot = -1;
for (int j = i; j < n; j++) {
if (c[j][x]) {
pivot = j;
break;
}
}
if (pivot == -1) {
i--;
continue;
}
swap(c[pivot], c[i]);
for (int j = i + 1; j < n; j++) {
if (c[j][x]) c[j] ^= c[i];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) b[i][j] = c[i][m - 1 - j];
}
return b;
}
signed main() {
ios::sync_with_stdio(false); cin.tie(0);
cin >> n;
vector<long long> a(n);
vector<bitset<m>> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = bitset<m>(a[i]);
}
long long x = 0;
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
cnt += b[i][j];
}
if (cnt % 2 == 0) continue;
x += 1LL << j;
for (int i = 0; i < n; i++) {
b[i][j] = 0;
}
}
b = gaussian_elimination(b);
bitset<m> y;
for (int j = m - 1; j >= 0; j--) {
for (int i = 0; i < n; i++) {
if (b[i][j] && y.to_ullong() < (y ^ b[i]).to_ullong()) {
y ^= b[i];
break;
}
}
}
cout << x + ((y.to_ullong()) << 1) << endl;
return 0;
}
| 0 | 96,240,715 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<int, PII> PIP;
const int MM = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 1000 + 10;
int n, m;
void prework(){
}
void read(){
}
char CH[5] = {'R', 'Y', 'G', 'B', 'R'};
int f[MAXN][MAXN];
int g[MAXN][MAXN][5];
set<PIP> st;
int vis[MAXN][MAXN];
int ADD(int x, int y, int col, int cnt){
st.erase(PIP(g[x][y][4], PII(x, y)));
if (g[x][y][col] == 0){
g[x][y][4]--;
}
g[x][y][col] += cnt;
if (g[x][y][col] == 0){
g[x][y][4]++;
}
st.insert(PIP(g[x][y][4], PII(x, y)));
if (g[x][y][4] == 0) return 0;
else return 1;
}
int d;
int dfs(int dep){
if (dep == n * m + 1){
for(int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++)
putchar(CH[f[i][j]]);
puts("");
}
return 1;
}
PIP p = *(st.begin());
st.erase(st.begin());
int x = p.second.first;
int y = p.second.second;
vis[x][y] = 1;
for (int i = 0; i < 4; i++)
if ((g[x][y][i] == 0)){
f[x][y] = i;
int flag = 1;
for (int dx = -d; dx <= d; dx++){
int dy = d - abs(dx);
if (1 <= x + dx && x + dx <= n && y + dy >= 1 && y + dy <= m && !vis[x + dx][y + dy]){
flag &= ADD(x + dx, y + dy, i, 1);
}
if (dy != 0) {
dy = -dy;
if (1 <= x + dx && x + dx <= n && y + dy >= 1 && y + dy <= m && !vis[x + dx][y + dy]){
flag &= ADD(x + dx, y + dy, i, 1);
}
}
}
if (flag) if (dfs(dep + 1)) return 1;
for (int dx = -d; dx <= d; dx++){
int dy = d - abs(dx);
if (1 <= x + dx && x + dx <= n && y + dy >= 1 && y + dy <= m && !vis[x + dx][y + dy]){
ADD(x + dx, y + dy, i, -1);
}
if (dy != 0) {
dy = -dy;
if (1 <= x + dx && x + dx <= n && y + dy >= 1 && y + dy <= m && !vis[x + dx][y + dy]){
ADD(x + dx, y + dy, i, -1);
}
}
}
}
vis[x][y] = 0;
st.insert(p);
return 0;
}
int px[8] = {-2, -1, -1, 0, 0, 1, 1, 2};
int py[8] = {0, -1, 1, -2, 2, -1, 1, 0};
int p[5000][5000];
void solve(int casi){
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++){
st.insert(PIP(4, PII(i, j)));
g[i][j][4] = 4;
vis[i][j] = 0;
}
if (d <= 5) dfs(1);
else{
if (d & 1){
for (int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++)
putchar((i + j) & 1 ? 'R' : 'B');
puts("");
}
}
else{
queue<PII> Q;
int dd = d / 2;
int bias = d;
for (int i = -dd + 1; i <= dd - 1; i++){
for (int j = 1 + (abs(i)); j <= d - abs(i); j++){
p[bias + i][bias + j] = 1;
Q.push(PII(bias + i, bias + j));
}
}
for (int i = -dd + 1; i <= dd - 1; i++){
for (int j = 1 + (abs(i)); j <= d - abs(i); j++){
p[bias + i][bias + j + d] = 2;
Q.push(PII(bias + i, bias + j + d));
}
}
for (int i = -dd + 1; i <= dd - 1; i++){
for (int j = 1 + (abs(i)); j <= d - abs(i); j++){
p[bias + i - dd][bias + j + dd] = 3;
Q.push(PII(bias + i - dd, bias + j + dd));
}
}
for (int i = -dd + 1; i <= dd - 1; i++){
for (int j = 1 + (abs(i)); j <= d - abs(i); j++){
p[bias + i + dd][bias + j + dd] = 4;
Q.push(PII(bias + i + dd, bias + j + dd));
}
}
while(!Q.empty()){
int x = Q.front().first, y = Q.front().second;
Q.pop();
for (int k = 0; k < 8; k++){
int xx = x + px[k] * d;
int yy = y + py[k] * d;
if (1 <= xx && xx <= n && 1 <= yy && yy <= m && p[xx][yy] == 0){
p[xx][yy] = p[x][y];
Q.push(PII(xx, yy));
}
}
}
for (int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++)
putchar(CH[p[i][j]]);
puts("");
}
}
}
}
void printans(){
}
int main(){
prework();
int T = 1;
for(int i = 1; i <= T; i++){
read();
solve(i);
printans();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, P;
cin >> N >> P;
vector < int >A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
int oddCount = 0, evenCount = 0;
for (int i = 0; i < N; i++) {
if (A[i] % 2 == 0) {
evenCount++;
} else {
oddCount++;
}
}
if (oddCount == 0) {
if (P == 0) {
cout << fixed << setprecision(0) << pow(2, N) << endl;
} else {
cout << 0 << endl;
}
return 0;
}
cout << fixed << setprecision(0) << pow(2, N - 1) << endl;
return 0;
}
| 0 | 20,051,496 |
#include <iostream>
using namespace std;
int main () {
int h,w,c1=0,c2=0,c=0;
char a[110][110];
cin >> h >> w;
for (int i=1;i<=h;i++)
{
for (int j=1;j<=w;j++)
{
cin >> a[i][j];
}
}
for (int i=1;i<=h;i++)
{
for (int j=1;j<=w;j++)
{
if (a[i][j]=='.')
{
for (int k=1;k<=h;k++)
{
if (a[k][j]=='#')
{
c1=1;
}
}
if (c1==0)
{
for (int k=1;k<=h;k++)
{
a[k][j]='?';
}
c1=0;
}
c1=0;
for (int k=1;k<=w;k++)
{
if (a[i][k]=='#')
{
c2=1;
}
}
if (c2==0)
{
for (int k=1;k<=w;k++)
{
a[i][k]='?';
}
}
c2=0;
}
}
}
for (int i=1;i<=h;i++)
{
for (int j=1;j<=w;j++)
{
if (a[i][j]!='?')
{
cout << a[i][j];
c=1;
}
}
if (c==1)
{
cout << endl;
}
c=0;
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define ll long long
#define MOD 1000000007
#define pii pair<ll, ll>
#define piii pair<ll, pii>
#define sz(x) ((ll)(x).size())
#define ft first
#define sd second
#define pb push_back
#define rep(i, n) for(ll i = 0; i < n; i++)
#define repr(i, n) for(ll i = n-1; i >= 0; i--)
#define itr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define mem(a, b) memset(a, (ll)b, sizeof(a))
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define edge(v, x, y) v[x].pb(y); v[y].pb(x);
#define popc __builtin_popcount
#define ANS(s) {cout << s << "\n"; return;}
template <typename T> void unique(T& c){c.erase(std::unique(c.begin(), c.end()), c.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(a > b){a = b; return 1;} return 0;}
template <typename T> istream &operator>>(istream &is, vector<T> &vec){for(auto &v: vec)is >> v; return is;}
template <typename T> ostream &operator<<(ostream &os, const vector<T>& vec){for(int i = 0; i < vec.size(); i++){ os << vec[i]; if(i + 1 != vec.size())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){os << "(" << p.first << ", " << p.second << ")"; return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << "(" << itr->first << ", " << itr->second << ")"; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << "(" << itr->first << ", " << itr->second << ")"; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
const ll N = 1e5+5, M = 1e6+5, A = 1e7+5, inf = 1e9;
const long long linf = 1LL << 60;
const double er = 1e-10, pi = 3.141592653589793238463;
const ll lx[4] = {0, 1, -1, 0};
const ll ly[4] = {1, 0, 0, -1};
const ll dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const ll dy[8] = {1, -1, 0, 0, 1, 1, -1, -1};
struct fast_io{
fast_io(){ios_base::sync_with_stdio(false); cin.tie(0); cout << fixed << setprecision(20);}
} fast_io_;
void solve(){
ll n; cin >> n;
vector<ll> a(n); cin >> a;
ll ans = 0, s = 0;
map<ll, ll> mp;
mp[0] = 1;
rep(i, n)
{
s += a[i];
ans += mp[s];
mp[s]++;
}
cout << ans;
}
int main(int argc, char const* argv[])
{
ll t = 1;
while(t--) {
solve();
}
return 0;
}
| 0 | 50,787,598 |
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
int type[300];
char str[1000];
int main() {
type[(int)'q'] = 1;
type[(int)'w'] = 1;
type[(int)'e'] = 1;
type[(int)'r'] = 1;
type[(int)'t'] = 1;
type[(int)'a'] = 1;
type[(int)'s'] = 1;
type[(int)'d'] = 1;
type[(int)'f'] = 1;
type[(int)'g'] = 1;
type[(int)'z'] = 1;
type[(int)'x'] = 1;
type[(int)'c'] = 1;
type[(int)'v'] = 1;
type[(int)'b'] = 1;
while (scanf("%s", str), str[0] != '#') {
int cnt = 0;
int prev = type[(int)str[0]];
int len = strlen(str);
REP(i, len) {
if (prev != type[(int)str[i]]) {
cnt++;
}
prev = type[(int)str[i]];
}
printf("%d\n", cnt);
}
}
|
#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 ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
ll sum = 0;
bool same = true;
int ma = INT_MAX;
rep(i, n) {
ll a, b;
cin >> a >> b;
sum += a;
if(a > b) chmin(ma, b);
if(a != b) same = false;
}
if(same) cout << 0 << endl;
else cout << sum-ma << endl;
}
| 0 | 73,262,512 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
string number;
while (cin >> number, number != "0") {
int sum = 0;
for (int i = 0; i < number.size(); i++) {
sum += number[i] - '0';
}
cout << sum << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
const ll M = 1e9 + 7;
ll n, m;
ll a[2005], b[2005];
ll d[2005][2005], e[2005][2005];
int main()
{
scanf("%lld%lld", &n, &m);
for(ll i = 1; i <= n; i++) scanf("%lld", &a[i]);
for(ll i = 1; i <= m; i++) scanf("%lld", &b[i]);
for(ll i = 1; i <= n + 1; i++)
{
for(ll j = 1; j <= m + 1; j++)
{
if(a[i] == b[j]) d[i][j] = e[i - 1][j - 1] + 1;
e[i][j] = e[i][j - 1] + e[i - 1][j] - e[i - 1][j - 1] + d[i][j] + M;
d[i][j] %= M;
e[i][j] %= M;
}
}
printf("%lld\n", d[n + 1][m + 1]);
return 0;
}
| 0 | 28,842,966 |
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using LLONG = long long;
const LLONG MOD = 1000000007;
class WeightedGraph
{
private:
const int INF = 1e9;
int m_nodeNum;
vector<vector<int>> m_adList;
vector<vector<int>> m_weights;
vector<vector<int>> m_dists;
void DFS(const int v)
{
deque<int> Q{ v };
vector<int> dists(m_nodeNum, INF);
dists[v] = 0;
while (!Q.empty())
{
const int u = Q.front(); Q.pop_front();
for (const int n : m_adList[u])
{
if (dists[n] > dists[u] + m_weights[u][n])
{
dists[n] = dists[u] + m_weights[u][n];
Q.push_back(n);
}
}
}
m_dists[v] = dists;
}
public:
WeightedGraph(int nodeNum) : m_nodeNum(nodeNum)
{
m_adList.assign(nodeNum, vector<int>());
m_weights.assign(nodeNum, vector<int>(nodeNum));
m_dists.assign(nodeNum, vector<int>(nodeNum, INF));
}
void AddEdge(const int v1, const int v2, const int weight)
{
m_adList[v1].push_back(v2);
m_adList[v2].push_back(v1);
m_weights[v1][v2] = m_weights[v2][v1] = weight;
}
void ComputeDistance()
{
for (int v = 0; v < m_nodeNum; ++v)
{
DFS(v);
}
}
const int GetDistance(const int v1, const int v2)
{
return m_dists[v1][v2];
}
};
int main()
{
int N, M, R; cin >> N >> M >> R;
vector<int> rs(R);
for (auto &ri : rs)
{
cin >> ri;
--ri;
}
WeightedGraph graph(N);
for (int i = 0; i < M; ++i)
{
int ai, bi, ci; cin >> ai >> bi >> ci; --ai; --bi;
graph.AddEdge(ai, bi, ci);
}
graph.ComputeDistance();
LLONG minDist = 1e9;
sort(rs.begin(), rs.end());
do
{
LLONG dist = 0;
for (int i = 0; i < R - 1; ++i)
{
dist += graph.GetDistance(rs[i], rs[i + 1]);
}
minDist = min(minDist, dist);
} while (next_permutation(rs.begin(), rs.end()));
cout << minDist << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using Pair = pair<int64_t, int64_t>;
constexpr int64_t kInf = INT64_MAX / 2L;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t N, K, Rock, Scissor, Paper;
string T;
cin >> N >> K >> Rock >> Scissor >> Paper >> T;
enum Janken : int32_t { kRock, kScissor, kPaper };
const int64_t janken[] = {'r', 's', 'p'};
const int64_t score[] = {Rock, Scissor, Paper};
int64_t result = 0;
for (int64_t k = 0; k < K; ++k) {
vector<vector<int64_t>> dp(N / K + 2, vector<int64_t>(3, 0));
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
int64_t last_index = -1;
for (int64_t i = 1; k + (i - 1) * K < N; ++i) {
const char enemy = T[k + (i - 1) * K];
for (int64_t j = kRock; j <= kPaper; ++j) {
bool win = false;
if (janken[j] == 'r' && enemy == 's') {
win = true;
} else if (janken[j] == 's' && enemy == 'p') {
win = true;
} else if (janken[j] == 'p' && enemy == 'r') {
win = true;
}
for (int64_t p = kRock; p <= kPaper; ++p) {
if (j != p) {
dp[i][j] = max(dp[i][j], dp[i - 1][p] + (win ? score[j] : 0));
}
}
}
last_index = i;
}
result += max(dp[last_index][0], max(dp[last_index][1], dp[last_index][2]));
}
cout << result << endl;
return 0;
}
| 0 | 77,799,736 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n;
cin >> n;
int mi=int(to_string(n).size());
for(long long i=1;i*i<=n;i++){
if(n%i==0){
mi = min(max(int(to_string(i).size()), int(to_string(n/i).size())),mi);
}
}
cout << mi << '\n';
}
|
#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 ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define endl "\n"
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[310][310][310];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<ll> h(n + 1, 0);
for (int i = 1; i <= n; i++)
{
cin >> h[i];
}
for (int i = 0; i < 310; i++)
{
for (int j = 0; j < 310; j++)
{
for (int l = 0; l < 310; l++)
{
dp[i][j][l] = LLINF;
}
}
}
dp[0][0][0] = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j <= i; j++)
{
for (int l = 0; l <= k; l++)
{
chmin(dp[i + 1][j][l+1], dp[i][j][l]);
chmin(dp[i + 1][i + 1][l], dp[i][j][l] + max(0LL, h[i + 1] - h[j]));
}
}
}
ll ans = LLINF;
for (int i = 0; i <= n; i++)
{
for (int j = 0; j <= k; j++)
{
chmin(ans, dp[n][i][j]);
}
}
cout << ans << endl;
}
| 0 | 71,644,101 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N;
cin >> N;
vector<int> Button(N);
for (int i = 0; i < N; i++) {
int z;
cin >> z;
--z;
Button.at(i) = z;
}
int cnt = 0;
int tmp = 0;
for (;;) {
if (tmp == 1) {
cout << cnt << endl;
break;
}
if (cnt >= N) {
cout << "-1" << endl;
break;
}
tmp = Button.at(tmp);
++cnt;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
int h, w, d;
char color[] = {'Y', 'R', 'G', 'B'};
int main() {
cin >> h >> w >> d;
if (d == 1) {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if ((i + j) % 2 == 0) {
cout << 'B';
}
else {
cout << 'R';
}
}
cout << endl;
}
}
else {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
int y = (i - j + 3000) / d;
int x = (i + j + 3000) / d;
cout << color[y % 2 * 2 + x % 2];
}
cout << '\n';
}
}
}
| 0 | 63,074,194 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define COUT(x) cout<<(x)<<endl
#define dump(x) cout<<#x<<" = "<<(x)<<endl;
#define Yes(x) cout<<(x?"Yes":"No")<<endl;
#define YES(x) cout<<(x?"YES":"NO")<<endl;
using ll = long long;
using P = pair<int,int>;
using Graph = vector<vector<int>>;
using M = map<int,int>;
using PQ = priority_queue<int>;
using PQG = priority_queue<int, vector<int>, greater<int>>;
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int main() {
int n; cin >> n;
vector<double> v(n); REP(i,n) cin >> v[i];
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans+v[i])/2;
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(x) (x).begin(),(x).end()
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(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, m; cin>>n>>m;
map<int,int> mp;
rep(i, m){
int a,b; cin>>a>>b;
mp[a]++;
mp[b]++;
}
for(auto a : mp){
if(a.second % 2 == 1){
cout<<"NO"<<endl;
return 0;
}
}
cout<<"YES"<<endl;
return 0;
}
| 0 | 74,852,164 |
#include<bits/stdc++.h>
typedef long long ll;
#define pb push_back
#define mod 1000000007ll
const ll maxn = 9e18;
using namespace std;
void solve() {
char a[50][50], b[50][50];
int n, m;
bool match = false;
cin >> n >> m;
for(int i = 0; i < n; ++i){
for(int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
for(int i = 0; i < m; ++i) {
for(int j = 0; j < m; ++j) {
cin >> b[i][j];
}
}
for(int i = 0 ; i < n; ++i) {
for(int j = 0; j < n; ++j) {
if(i + m - 1 >= n || j + m - 1 >= n) continue;
bool exist = true;
for(int lx = 0; lx < m; ++lx) {
for(int ly = 0; ly < m; ++ly) {
if(a[i + lx][j + ly] != b[lx][ly]) exist = false;
}
}
if(exist) match = true;
}
}
if(match) cout << "Yes" << endl;
else cout << "No" << endl;
return;
}
int main() {
ios_base :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(35);
solve();
return 0;
}
|
#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>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(int x, int y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
int N; cin >> N;
vector<long double>x(N);
vector<string>u(N);
long double A = 0;
rep(i, N) {
cin >> x[i] >> u[i];
if (u[i].at(0) == 'B')A += x[i] * 380000.0;
else A += x[i];
}
cout << fixed<< setprecision(100) <<A << endl;
}
| 0 | 92,181,377 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
int main() {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
printf("%dx%d=%d\n", i, j, i*j);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
using ll = long long;
const int N = 2e5 + 5;
int par[N], sz[N];
int n, m;
void init() {
for (int i = 1; i < N; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int u) {
return par[u] == u ? u : par[u] = find(par[u]);
}
void make(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
if (sz[u] < sz[v]) swap(u, v);
sz[u] += sz[v];
par[v] = u;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
init();
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
make(u, v);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, sz[find(i)]);
}
cout << ans << '\n';
return 0;
}
| 0 | 12,691,091 |
#include <iostream>
#include <vector>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100005;
vector<int> v[maxn];
int dfs(int root, int fa) {
int ret = 0;
for (int i = 0;i < v[root].size();i++) {
int to = v[root][i];
if (to == fa) continue;
ret ^= 1 + dfs(to, root);
}
return ret;
}
int main() {
int n;
cin >> n;
for (int i = 1, xi, yi;i < n;i++) {
scanf("%d %d", &xi, &yi);
v[xi].push_back(yi);
v[yi].push_back(xi);
}
if (dfs(1, 0) != 0) {
printf("Alice\n");
}
else {
printf("Bob\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<pii,int> ppii;
typedef pair<int,pii> pipi;
typedef pair<ll,ll> pll;
typedef pair<pll,ll> plpl;
typedef tuple<ll,ll,ll> tl;
ll mod2=1000000007;
ll mod=998244353;
ll inf=1000000000000000000;
double pi=2*acos(0);
#define rep(i,m,n) for(int i=m;i<n;i++)
#define rrep(i,n,m) for(int i=n;i>=m;i--)
int dh[4]={1,-1,0,0};
int dw[4]={0,0,1,-1};
int ddh[8]={-1,-1,-1,0,0,1,1,1};
int ddw[8]={-1,0,1,-1,1,-1,0,1};
ll lmax(ll a,ll b){
if(a<b)return b;
else return a;
}
ll lmin(ll a,ll b){
if(a<b)return a;
else return b;
}
int main(){
ll n;cin>>n;
ll a[n];
ll sum=0;
rep(i,0,n){
cin>>a[i];
sum+=a[i];
}
for(ll i=max((ll)0,sum-n*(n-1));i<sum+1;i++){
ll cnt=0;
rep(j,0,n){
ll r=a[j]+i-n+1;
if(r<=0)continue;
cnt+=r/(n+1);
if(r%(n+1)!=0)cnt++;
}
if(cnt==i){
cout<<i<<endl;
return 0;
}
}
}
| 0 | 47,471,879 |
#include <iostream>
#include <vector>
using namespace std;
typedef pair<char, char> P;
void solve()
{
int n;
while(cin >> n, n)
{
vector<P> trans(n);
for(int i = 0; i < n; ++i)
{
cin >> trans[i].first >> trans[i].second;
}
int num;
cin >> num;
vector<char> c(num);
for(int i = 0; i < num; ++i)
{
cin >> c[i];
}
for(int i = 0; i < num; ++i)
{
bool flag = true;
for(int j = 0; j < n; ++j)
{
if(c[i] == trans[j].first)
{
cout << trans[j].second;
flag = false;
}
}
if(flag)
{
cout << c[i];
}
}
cout << endl;
}
}
int main()
{
solve();
return(0);
}
|
#include<bits/stdc++.h>
#define ll long long
#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define dump(a) (cerr << #a << "=" << (a) << endl)
#define DUMP(list) cout << "{ "; for(auto nth : list){ cout << nth << " "; } cout << "}" << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
using namespace std;
const ll MAXN = 8020;
bool dp_x[MAXN][MAXN*2] = {false}, dp_y[MAXN][MAXN*2] = {false};
int main(){
string s;
cin >> s;
int x, y;
cin >> x >> y;
vector<int> t;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'T') {
if (cnt != 0) t.push_back(cnt);
t.push_back(0);
cnt = 0;
} else {
cnt++;
if (i == s.size()-1) t.push_back(cnt);
}
}
dp_x[0][8000] = true;
dp_y[0][8000] = true;
bool flag = false;
bool xy = true;
int cnt_x = 0, cnt_y = 0;
for (int i = 0; i < t.size(); i++) {
if (t[i] == 0) {
xy = !xy;
} else if (xy) {
cnt_x++;
for(int j = 0; j < MAXN*2; j++) {
if (dp_x[cnt_x-1][j]) {
if (j + t[i] < MAXN*2) dp_x[cnt_x][j+t[i]] = true;
if (j - t[i] >= 0 && flag) dp_x[cnt_x][j-t[i]] = true;
}
}
} else if (!xy) {
cnt_y++;
for (int j = 0; j < MAXN*2; j++) {
if (dp_y[cnt_y-1][j]) {
if (j + t[i] < MAXN*2) dp_y[cnt_y][j+t[i]] = true;
if (j - t[i] >= 0) dp_y[cnt_y][j-t[i]] = true;
}
}
}
if (!flag) flag = true;
}
cout << ((dp_x[cnt_x][x+8000] && dp_y[cnt_y][y+8000]) ? "Yes" : "No") << endl;
}
| 0 | 30,031,591 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
const ll MAX = 1001001;
const ll MOD = 1000000007;
int main()
{
ll n, a, b;
cin >> n >> a >> b;
vector<ll> p(n);
ll x = 0;
ll y = 0;
ll z = 0;
rep(i, n)
{
cin >> p[i];
if (p[i] <= a)
{
x++;
}
else if (p[i] > b)
{
z++;
}
else
{
y++;
}
}
cout << min({x, y, z}) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=1<<18,INF=1<<30;
int main(){
string ans;
cout<<"? 49999999999"<<endl;
char a;cin>>a;
if(a=='Y'){
for(int i=1;i<=4;i++){
cout<<"? "<<i<<"9999999999"<<endl;
cin>>a;
if(a=='Y'){
ans+='0'+i;
break;
}
}
}else{
for(int i=5;i<=9;i++){
cout<<"? "<<i<<"9999999999"<<endl;
cin>>a;
if(a=='Y'){
ans+='0'+i;
break;
}
}
}
bool ok=true;
while(ans.size()<=8){
cout<<"? "<<ans<<'4';
for(int j=0;j<13-ans.size();j++){
cout<<9;
}
cout<<endl;
cin>>a;
if(a=='Y'){
for(int i=0;i<=4;i++){
cout<<"? "<<ans<<i;
for(int j=0;j<13-ans.size();j++){
cout<<9;
}
cout<<endl;
cin>>a;
if(a=='Y'){
if(i==0){
if(ans=="9"){
cout<<"? "<<10<<endl;
cin>>a;
if(a=='N'){
ok=false;
break;
}else{
ans+='0';
break;
}
}else{
string T=ans;
T[T.size()-1]++;
cout<<"? "<<T<<endl;
cin>>a;
if(a=='Y'){
ok=false;
break;
}else{
ans+='0';
break;
}
}
}else{
ans+='0'+i;
break;
}
}
}
if(!ok) break;
}else{
for(int i=5;i<=9;i++){
cout<<"? "<<ans<<i;
for(int j=0;j<13-ans.size();j++){
cout<<9;
}
cout<<endl;
cin>>a;
if(a=='Y'){
ans+='0'+i;
break;
}
}
}
}
if(ans=="100000000"){
cout<<"? "<<100000001<<endl;
cin>>a;
if(a=='N') ans+='0';
}
cout<<"! "<<ans<<endl;
}
| 0 | 19,920,699 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; ++i)
int main (){
int n, m;
cin >> n >> m;
if(n % 3 == 0 || m % 3 == 0 || (n+m) % 3 == 0){
cout << "Possible" << endl;
}else{
cout << "Impossible" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#include <sys/time.h>
using namespace std;
#define rep(i,n) for(long long i = 0; i < (long long)(n); i++)
#define repi(i,a,b) for(long long i = (long long)(a); i < (long long)(b); i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mt make_tuple
#define mp make_pair
template<class T1, class T2> bool chmin(T1 &a, T2 b) { return b < a && (a = b, true); }
template<class T1, class T2> bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
using ll = long long; using vll = vector<ll>; using vvll = vector<vll>; using P = pair<ll, ll>;
using ld = long double; using vld = vector<ld>;
using vi = vector<int>; using vvi = vector<vi>; vll conv(vi& v) { vll r(v.size()); rep(i, v.size()) r[i] = v[i]; return r; }
inline void input(int &v){ v=0;char c=0;int p=1; while(c<'0' || c>'9'){if(c=='-')p=-1;c=getchar();} while(c>='0' && c<='9'){v=(v<<3)+(v<<1)+c-'0';c=getchar();} v*=p; }
template <typename T, typename U> ostream &operator<<(ostream &o, const pair<T, U> &v) { o << "(" << v.first << ", " << v.second << ")"; return o; }
template<size_t...> struct seq{}; template<size_t N, size_t... Is> struct gen_seq : gen_seq<N-1, N-1, Is...>{}; template<size_t... Is> struct gen_seq<0, Is...> : seq<Is...>{};
template<class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch,Tr>& os, Tuple const& t, seq<Is...>){ using s = int[]; (void)s{0, (void(os << (Is == 0? "" : ", ") << get<Is>(t)), 0)...}; }
template<class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr>& os, tuple<Args...> const& t) -> basic_ostream<Ch, Tr>& { os << "("; print_tuple(os, t, gen_seq<sizeof...(Args)>()); return os << ")"; }
ostream &operator<<(ostream &o, const vvll &v) { rep(i, v.size()) { rep(j, v[i].size()) o << v[i][j] << " "; o << endl; } return o; }
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) { o << '['; rep(i, v.size()) o << v[i] << (i != v.size()-1 ? ", " : ""); o << "]"; return o; }
template <typename T> ostream &operator<<(ostream &o, const deque<T> &v) { o << '['; rep(i, v.size()) o << v[i] << (i != v.size()-1 ? ", " : ""); o << "]"; return o; }
template <typename T> ostream &operator<<(ostream &o, const set<T> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it << (next(it) != m.end() ? ", " : ""); o << "]"; return o; }
template <typename T> ostream &operator<<(ostream &o, const unordered_set<T> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it << (next(it) != m.end() ? ", " : ""); o << "]"; return o; }
template <typename T, typename U> ostream &operator<<(ostream &o, const map<T, U> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it << (next(it) != m.end() ? ", " : ""); o << "]"; return o; }
template <typename T, typename U, typename V> ostream &operator<<(ostream &o, const unordered_map<T, U, V> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it; o << "]"; return o; }
vector<int> range(const int x, const int y) { vector<int> v(y - x + 1); iota(v.begin(), v.end(), x); return v; }
template <typename T> istream& operator>>(istream& i, vector<T>& o) { rep(j, o.size()) i >> o[j]; return i;}
template <typename T, typename S, typename U> ostream &operator<<(ostream &o, const priority_queue<T, S, U> &v) { auto tmp = v; while (tmp.size()) { auto x = tmp.top(); tmp.pop(); o << x << " ";} return o; }
template <typename T> ostream &operator<<(ostream &o, const queue<T> &v) { auto tmp = v; while (tmp.size()) { auto x = tmp.front(); tmp.pop(); o << x << " ";} return o; }
template <typename T> ostream &operator<<(ostream &o, const stack<T> &v) { auto tmp = v; while (tmp.size()) { auto x = tmp.top(); tmp.pop(); o << x << " ";} return o; }
template <typename T> unordered_map<T, ll> counter(vector<T> vec){unordered_map<T, ll> ret; for (auto&& x : vec) ret[x]++; return ret;};
string substr(string s, P x) {return s.substr(x.fi, x.se - x.fi); }
void vizGraph(vvll& g, int mode = 0, string filename = "out.png") { ofstream ofs("./out.dot"); ofs << "digraph graph_name {" << endl; set<P> memo; rep(i, g.size()) rep(j, g[i].size()) { if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i)))) continue; memo.insert(P(i, g[i][j])); ofs << " " << i << " -> " << g[i][j] << (mode ? " [arrowhead = none]" : "")<< endl; } ofs << "}" << endl; ofs.close(); system(((string)"dot -T png out.dot >" + filename).c_str()); }
size_t random_seed; namespace std { using argument_type = P; template<> struct hash<argument_type> { size_t operator()(argument_type const& x) const { size_t seed = random_seed; seed ^= hash<ll>{}(x.fi); seed ^= (hash<ll>{}(x.se) << 1); return seed; } }; };
#define ldout fixed << setprecision(40)
#define EPS (double)1e-14
#define INF (ll)1e18
#define mo (ll)(1e9+7)
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<int> ani(N+1);
for(int k = 1; k > -2; k-=2){
for(int l = 1; l > -2; l-=2){
ani[0]=k;
ani[1]=l;
for(int i = 1;i < N; ++i){
if(s[i]=='o'){
if(ani[i]==1){
ani[i+1]=ani[i-1];
}
else{
ani[i+1]=ani[i-1]*(-1);
}
} else{
if(ani[i]==1){
ani[i+1]=ani[i-1]*(-1);
}
else{
ani[i+1]=ani[i-1];
}
}
}
bool flag = false;
if(ani[0]==ani[N]){
if(ani[0]==1){
if(s[0]=='o' && ani[N-1]==ani[1]) flag = true;
else if(s[0]=='x' && ani[N-1]!=ani[1]) flag = true;
} else{
if(s[0]=='o' && ani[N-1]!=ani[1]) flag = true;
else if(s[0]=='x' && ani[N-1]==ani[1]) flag = true;
}
} else continue;
if(flag){
string ans;
for(int i = 0; i < N; ++i){
if(ani[i]==1) ans.push_back('S');
else ans.push_back('W');
}
cout << ans << endl;
return 0;
}
}
}
cout << -1 << endl;
}
| 0 | 46,519,189 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
if(h2 == 0) h2 += 24;
cout << (h2 * 60 + m2) - (h1 * 60 + m1) - k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll =long long;
#define all(v) v.begin(),v.end()
int main() {
ll N,M;
cin>>N>>M;
vector<vector<ll>> vec(N,vector<ll>(0));
for(ll i=0;i<M;i++) {
ll a,b;
cin>>a>>b;
vec[a-1].push_back(b);
vec[b-1].push_back(a);
}
vector<ll> A(N);
for(ll i=0;i<N;i++) {
A[i]=i+1;
}
sort(all(A));
ll ans=0;
do {
if(A[0]!=1) {
break;
}
bool b=true;
for(ll i=0;i<N-1;i++) {
ll k=A[i];
ll n=A[i+1];
bool a=false;
for(auto x:vec[k-1]) {
if(x==n) {
a=true;
}
}
if(!a) {
b=false;
break;
}
}
if(b) {
ans++;
}
}
while(next_permutation(all(A)));
cout<<ans<<endl;
}
| 0 | 6,496,188 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
long long N, P;
cin >> N >> P;
string S;
cin >> S;
long long dp[N];
long long pow_10 = 1;
for (int i = N - 1; i >= 0; i--){
if (i == N - 1) dp[i] = (S[i] - '0') % P;
else {
dp[i] = dp[i + 1] + (S[i] - '0') * pow_10;
dp[i] %= P;
}
pow_10 *= 10; pow_10 %= P;
}
long long sum[P];
for (int i = 0; i < P; i++) sum[i] = 0;
for (int i = 0; i < N; i++){
sum[dp[i]]++;
}
sum[0]++;
long long count = 0;
for (int i = 0; i < P; i++) count += sum[i] * (sum[i] - 1) / 2;
if (P != 2 && P != 5) cout << count << endl;
else {
if (P == 2){
long long sum = 0;
for (int i = 0; i < N; i++) if ((S[i] - '0') % 2 == 0) {
sum += i + 1;
}
cout << sum << endl;
}
if (P == 5){
long long sum = 0;
for (int i = 0; i < N; i++) if ((S[i] - '0') % 5 == 0) {
sum += i + 1;
}
cout << sum << endl;
}
}
}
|
#include <iostream>
#include <bits/stdc++.h>
#include <stdio.h>
typedef long long ll;
using namespace std;
bool isPrime(int n){
if(n < 2){
return 0;
}
if(n%2 == 0){
return n==2;
}
for(int i=3;i*i<=n;i++){
if(n%i == 0) return 0;
}
return 1;
}
int main() {
string s,t;
cin>>s>>t;
int d = 0;
for(int i=0;i<s.size();i++){
if(s[i] != t[i])d++;
}
cout<<d<<endl;
return 0;
}
| 0 | 78,384,567 |
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
int main() {
int d;
while (scanf("%d", &d) != EOF) {
long sum = 0;
for (int i=d; i<600; i+=d) {
sum += d*pow(i, 2);
}
cout << sum << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define REPS(i, m, n) for (int i = (m); i <= (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define reps(i, n) for (int i = 0; i <= (int)(n); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define fi first
#define se second
typedef long long ll;
typedef pair<int, int> P;
const int inf = INT_MAX;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
const double EPS = 1e-10;
const double PI = acos(-1.0);
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; }
template<typename A, size_t N, typename T> void Fill(A (&array)[N], const T &val) { fill( (T*)array, (T*)(array+N), val ); }
template <class T1, class T2, class Pred = std::less<T2> >
struct sort_pair_second {
bool operator()(const std::pair<T1,T2>&left, const std::pair<T1,T2>&right) {
Pred p;
return p(left.second, right.second);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, P;
cin >> N >> P;
string S; cin >> S;
ll ans = 0;
if (P == 2 || P == 5) {
rrep(i, N) {
ll num = S[i] - '0';
if (num % P == 0) ans += i + 1;
}
cout << ans << endl;
return 0;
}
vector<ll> cnt(P, 0);
ll ten = 1;
ll sum = 0;
cnt[sum]++;
rrep(i, N) {
ll num = S[i] - '0';
sum += num * ten;
sum %= P;
ten *= 10;
ten %= P;
cnt[sum]++;
}
rep(i, P) {
ans += cnt[i] * (cnt[i] - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 0 | 24,705,378 |
#define scanf_s scanf
#include <string>
#include <stdio.h>
#include <math.h>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <iostream>
using namespace std;
#define PI 3.14159265358
#define _rag(x) (x) * (PI / 180)
void fractale(int n, double p1x, double p1y, double p2x, double p2y)
{
if (n > 0) {
double sx = 0, sy = 0, ux = 0, uy = 0, tx = 0, ty = 0;
sx = (2 * p1x + p2x) / 3; sy = (2 * p1y + p2y) / 3;
tx = (p1x + 2 * p2x) / 3; ty = (p1y + 2 * p2y) / 3;
ux = (tx - sx) * cos(_rag(60.0)) - (ty - sy) * sin(_rag(60.0)) + sx;
uy = (tx - sx) * sin(_rag(60.0)) + (ty - sy) * cos(_rag(60.0)) + sy;
fractale(n - 1, p1x, p1y, sx, sy);
printf("%f %f\n", sx, sy);
fractale(n - 1, sx, sy, ux, uy);
printf("%f %f\n", ux, uy);
fractale(n - 1, ux, uy, tx, ty);
printf("%f %f\n", tx, ty);
fractale(n - 1, tx, ty, p2x, p2y);
}
}
int main(void)
{
int n;
scanf_s("%d", &n);
printf("%f %f\n", 0.0, 0.0);
fractale(n, 0.0, 0.0, 100.0, 0.0);
printf("%f %f\n", 100.0, 0.0);
}
|
#include <bits/stdc++.h>
#define int long long
#define FOR( i, m, n ) for( int (i) = (m); (i) < (n); (i)++ )
#define REP( i, n ) FOR( i, 0, n )
#define REPR( i, m ) for( int (i) = (m); (i) >= 0; (i)-- )
#define REPONE( i, n ) FOR( i, 1, n + 1 )
#define ALL( a ) (a).begin(), (a).end()
#define MP make_pair
using namespace std;
using P = pair<int, int>;
using PP = pair<int, pair<int, int> >;
template<class T>bool chmax( T& a, const T& b ) { if( a < b ) { a = b; return 1; } return 0; }
template<class T>bool chmin( T& a, const T& b ) { if( a > b ) { a = b; return 1; } return 0; }
const int INF = 1e9;
const int INFLL = 1e18;
const int MOD = 1e9 + 7;
signed main(){
int N; cin >> N;
REP( i, N ){
string s, t;
cin >> s >> t;
int snum = 0, tnum = 0, sdigit = 1, tdigit = 1;
REP( i, s.size() ){
if( s[i] == 'm' ){
snum += sdigit * 1000;
sdigit = 1;
}else if( s[i] == 'c' ){
snum += sdigit * 100;
sdigit = 1;
}else if( s[i] == 'x' ){
snum += sdigit * 10;
sdigit = 1;
}else if( s[i] == 'i' ){
snum += sdigit;
sdigit = 1;
}else{
sdigit = s[i] - '0';
}
}
REP( i, t.size() ){
if( t[i] == 'm' ){
tnum += tdigit * 1000;
tdigit = 1;
}else if( t[i] == 'c' ){
tnum += tdigit * 100;
tdigit = 1;
}else if( t[i] == 'x' ){
tnum += tdigit * 10;
tdigit = 1;
}else if( t[i] == 'i' ){
tnum += tdigit;
tdigit = 1;
}else{
tdigit = t[i] - '0';
}
}
int sum = snum + tnum;
if( sum / 1000 > 1 ) cout << sum / 1000;
if( sum / 1000 > 0 ) cout << 'm';
sum -= sum / 1000 * 1000;
if( sum / 100 > 1 ) cout << sum / 100;
if( sum / 100 > 0 ) cout << 'c';
sum -= sum / 100 * 100;
if( sum / 10 > 1 ) cout << sum / 10;
if( sum / 10 > 0 ) cout << 'x';
sum -= sum / 10 * 10;
if( sum > 1 ) cout << sum;
if( sum > 0 ) cout << 'i';
cout << endl;
}
}
| 0 | 15,104,488 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double pi=3.141592653589793;
typedef unsigned long long ull;
typedef long double ldouble;
const ll INF=1e18;
#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++)
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; }
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a%b);
}
int main(){
ll a, b;
cin >> a >> b;
cout << 3*(a-gcd(a, b)) << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 25;
const int MOD = 1e9+7;
const int S = 1e9;
int main() {
ll s;
cin >> s;
ll x3, y3;
y3 = (s + S - 1) / S;
x3 = S * y3 - s;
cout << 0 << " " << 0 << " ";
cout << S << " " << 1 << " ";
cout << x3 << " " << y3 << endl;
return 0;
}
| 0 | 97,974,592 |
#include <iostream>
using namespace std;
int w, h, x, y, r;
void readInput() {
cin >> w >> h >> x >> y >> r;
}
bool isOver() {
if ((x - r) < 0) return true;
if ((x + r) > w) return true;
if ((y - r) < 0) return true;
if ((y + r) > h) return true;
return false;
}
int main() {
readInput();
if (isOver()) {
cout << "No" << endl;
}
else {
cout << "Yes" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef complex<double> xy_t;
xy_t a, b, c, p;
double x1, x2, x3, xp, y_1, y2, y3, yp;
double s1, s2, s3;
int main()
{
while(cin >> x1 >> y_1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp)
{
a=xy_t(x1, y_1);
b=xy_t(x2, y2);
c=xy_t(x3, y3);
p=xy_t(xp, yp);
s1=(conj(a-p)*(b-p)).imag();
s2=(conj(b-p)*(c-p)).imag();
s3=(conj(c-p)*(a-p)).imag();
if(((s1>0)&&(s2>0)&&(s3>0))||((s1<0)&&(s2<0)&&(s3<0)))
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
}
return 0;
}
| 0 | 79,811,262 |
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define vi vector<int>
#define all(a) a.begin(),a.end()
typedef pair<int,int> P;
const long long mod=1000000007;
const long long inf=1ll<<61;
int a[100006],b[100006];
P ab[100006];
signed main(){
int n,m;cin>>n>>m;
rep(i,n){
cin>>a[i]>>b[i];
ab[i]=P(a[i],b[i]);
}
sort(ab,ab+n);
int ans=0,rs=0;
rep(i,n){
if(rs+ab[i].second<m){
ans+=ab[i].first*ab[i].second;
rs+=ab[i].second;
}
else{
ans+=ab[i].first*(m-rs);
break;
}
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define vt vector
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define se second
using ll = long long;
using pii = pair<int, int>;
void solve() {
int r;
cin >> r;
cout << r * r;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int tcs = 1;
for (int tc = 1; tc <= tcs; tc++) {
solve();
}
}
| 0 | 43,961,650 |
#include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = long long;
using std::cout;
using std::endl;
using std::cin;
template<typename T>
std::vector<T> make_v(size_t a){return std::vector<T>(a);}
template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
return std::vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}
int main() {
i64 x, y; scanf("%lld%lld", &x, &y);
if(std::abs(x - y) <= 1) printf("Brown\n");
else printf("Alice\n");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double lld;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> ppl;
#define ain(a,n) for(ll i=0;i<(n);++i) cin>>(a)[i];
#define DEBUG(x) cout << '>' << #x << ':' << x << endl;
#define loop(i,n) for(ll i=0;i<(n);++i)
#define FOR(i,a,b) for(ll i=(a);i<=(b);++i)
#define FORD(i,a,b) for(ll i=(a);i>=(b);--i)
#define cases ll T=0;cin>>T;while(T--)
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define END "\n"
#define pb push_back
#define mp make_pair
#define go(c,itr) for(auto itr=(c).begin(); itr!=(c).end(); ++itr)
#define back(c,itr) for(auto itr=(c).rbegin(); itr!=(c).rend(); ++itr)
#define PI 3.14159265359
#define inf 9e18
#define MOD 1000000007
#define MODU 998244353
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define MAXN 100005
const string alpha = "abcdefghijklmnopqrstuvwxyz";
const ll N = 1e8;
ll binexp(ll a, ll b, ll m) {
a %= m;
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll modinvfermat(ll a, ll m)
{
return binexp(a, m - 2, m);
}
void task(bool flag)
{
if (flag)
cout << "YES\n";
else
cout << "NO\n";
}
ll lcm(ll a, ll b)
{
return ((1LL * a * b) / (__gcd(a, b)));
}
vvl adj(MAXN);
vl vis(MAXN), par(MAXN, -1);
void addedge()
{
ll a, b;
cin >> a >> b;
adj[a].pb(b);
adj[b].pb(a);
}
void bfs(ll x)
{
queue<ll> q;
q.push(x);
while (!q.empty())
{
ll node = q.front();
q.pop();
vis[node] = 1;
for (auto child : adj[node])
{
if (vis[child] == 0)
{
par[child] = node;
vis[child] = 1;
q.push(child);
}
}
}
}
signed main() {
fast
ll n, m;
cin >> n >> m;
loop(i, m) addedge();
bfs(1);
bool ok = 1;
FOR(i, 1, n)
{
if (vis[i] == 0)
{
ok = 0;
break;
}
}
if (ok)
{
cout << "Yes\n";
FOR(i, 2, n) cout << par[i] << END;
}
else
{
cout << "No\n";
}
return 0;
}
| 0 | 14,662,346 |
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#define REP(i, lower, upper) for (long long i = lower; i < upper; i++)
#define ALL(list) (list.begin()), (list.end())
using namespace std;
using bint = boost::multiprecision::cpp_int;
typedef long long ll;
constexpr int MOD = 10000007;
vector<long long> divisor(long long n) {
vector<long long> head, tail;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
head.push_back(i);
if (i * i != n)
tail.push_back(n / i);
}
}
head.insert(head.end(), tail.rbegin(), tail.rend());
return (head);
}
void execute() {
ll n;
cin>>n;
vector<ll> ls(pow(10,5)+2,0);
REP(i,0,n){
ll a;
cin>>a;
ls[a]+=1;
ls[a+1]+=1;
ls[a+2]+=1;
}
ll sum=0;
for(auto i : ls){
sum=max(sum,i);
}
cout<<sum<<endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
execute();
return (0);
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
if(a==0 || b==0)return 0;
return a/__gcd(a,b)*b;
}
void input(ll ara[],ll n)
{
for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
for(ll i=0; i<n; i++)
cout<<ara[i]<<" ";
cout<<endl;
}
int main()
{
fastread();
ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;
bool flag=false;
string str;
cin>>n>>k;
l=n-2;
sum=(l*(l+1))/2;
if(sum<k)
{
cout<<-1<<endl;
return 0;
}
vector<pll>v;
for(i=2; i<=n; i++)
{
v.eb(1,i);
}
k=sum-k;
for(i=2; i<=n; i++)
{
for(j=i+1; j<=n && k; j++)
{
v.eb(i,j);
k--;
}
}
cout<<v.size()<<endl;
for(auto x : v)
cout<<x.F<<" "<<x.S<<endl;
}
| 0 | 36,324,206 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
int x3,y3,x4,y4;
int n = x2 - x1;
int m = y2 - y1;
if (n >= 0) {
if (m >= 0) {
x3 = x2 - m;
x4 = x3 - n;
y3 = y2 + n;
y4 = y3 - m;
}
else {
x3 = x2 - m;
x4 = x3 - n;
y3 = y2 + n;
y4 = y3 - m;
}
}
else {
if (m >= 0) {
x3 = x2 - m;
x4 = x3 - n;
y3 = y2 + n;
y4 = y3 - m;
}
else {
x3 = x2 - m;
x4 = x3 - n;
y3 = y2 + n;
y4 = y3 - m;
}
}
cout << x3 << ' ' << y3 << ' '<< x4 << ' ' << y4 << ' '<< endl;
}
|
#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 <queue>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <complex>
#include <fstream>
#include <stdio.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();}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VEC;
typedef vector<VEC> MAT;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef vector<LL> VLL;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#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 MT(a,b,c) MP(a, MP(b, c))
#define T1 first
#define T2 second.first
#define T3 second.second
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define EPS 1e-8
map<int, string> m;
int strtoi(string str){
int ret = 0;
int k=str.find('m');
if(k!=-1){
if(k==0||(k!=0&&isdigit(str[k-1])==false))ret+=1000;
else ret+=(str[k-1]-'0')*1000;
}
k=str.find('c');
if(k!=-1){
if(k==0||(k!=0&&isdigit(str[k-1])==false))ret+=100;
else ret+=(str[k-1]-'0')*100;
}
k=str.find('x');
if(k!=-1){
if(k==0||(k!=0&&isdigit(str[k-1])==false))ret+=10;
else ret+=(str[k-1]-'0')*10;
}
k=str.find('i');
if(k!=-1){
if(k==0||(k!=0&&isdigit(str[k-1])==false))ret+=1;
else ret+=(str[k-1]-'0')*1;
}
return ret;
}
string itos(int t){
string ret;
int p=1000;
while(p>0){
if(t/p==1)ret += m[p];
else if(t/p!=0){
ret+=t/p+'0';
ret+=m[p];
}
t%=p;
p/=10;
}
return ret;
}
int main(){
m[1] = "i";
m[10] = "x";
m[100] = "c";
m[1000] = "m";
int n;
cin >> n;
REP(i,n){
string str1,str2;
cin>>str1>>str2;
cout<<itos(strtoi(str1)+strtoi(str2))<<endl;
}
}
| 0 | 68,080,774 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
int n, k;
ll ans;
map<int, int> M;
ll norm(ll x) { return (x % k + k) % k;}
ll a[maxn];
int main()
{
scanf("%d%d", &n, &k);
for(int i = 1; i <= n; ++i) scanf("%lld", &a[i]), a[i] += a[i - 1];
M[0] = 1;
for(int i = 1; i <= n; ++i)
{
a[i] = norm(a[i] - i);
if(i >= k) --M[a[i - k]];
ans += M[a[i]];
++M[a[i]];
}
printf("%lld\n", ans);
return 0;
}
|
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <limits>
#include <random>
#include <complex>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cassert>
using namespace std;
#define REP(i,n) for (int i = 0; i < n; i++)
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
typedef long long ll;
int main ()
{
ll N; cin >> N;
vector < ll > a(N);
REP(i,N) cin >> a[i];
ll ans = 0;
while (true) {
sort(a.begin(), a.end());
if (a.back() < N) break;
ll minus = a.back() / N * N;
a.back() -= minus;
ans += minus / N;
REP(i,a.size() - 1) a[i] += minus / N;
}
cout << ans << endl;
return 0;
}
| 0 | 76,625,870 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const double PI = 3.14159265358979323846;
int main() {
int a, b;
cin >> a >> b;
bool flag = true;
if(a % 3 != 0 && b % 3 != 0 && (a+b) % 3 != 0) {
flag = false;
}
if(flag) cout << "Possible" << endl;
else cout << "Impossible" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
typedef long long ll;
typedef long double R;
const R EPS=1e-9L;
inline int sgn(const R& r){return(r > EPS)-(r < -EPS);}
inline R sq(R x){return sqrt(max(x,0.0L));}
const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};
int main() {
string s; cin >> s;
int w; cin >> w;
int count = w;
string ans = "";
for(int i = 0; i < s.length(); i++) {
if(w == count) {
ans.push_back(s[i]);
count = 0;
}
count++;
}
cout << ans << endl;
return 0;
}
| 0 | 42,708,766 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int main() {
int n;
while (cin >> n, n) {
int sum = 0;
int Max = 0, Min = 1000;
rep(i, n) {
int s; cin >> s;
Max = max(Max, s);
Min = min(Min, s);
sum += s;
}
cout << (sum - Max - Min) / (n - 2) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 2002;
const LL MOD = 1e9 + 7;
int n, k, a[N];
int main() {
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++) {
scanf("%d",&a[i]);
}
int cnt=0;
for(int i=1;i<=n;i++)for(int j=i+1;j<=n;j++)if(a[i]>a[j])cnt++;
LL ans = 1LL * cnt * k % MOD;
for(int i=1;i<=n;i++){
int tmp=0;
for(int j=1;j<=n;j++){
if(a[i]<a[j])tmp++;
}
ans = (ans + 1LL * tmp * (1LL * (k-1) * k / 2 % MOD) % MOD) % MOD;
}
cout << ans << endl;
}
| 0 | 87,085,276 |
#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>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
string k; cin >> k;
vector<char>A(15,'o');
rep(i, k.size())A[i]=k.at(i);
int ans = 0;
rep(i, 15) {
if (A[i] == 'o')ans++;
}
cout << (ans>7? "YES":"NO") << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<LL,int> P;
const LL mod=1000000007;
const LL LINF=1LL<<62;
const LL INF=1<<17;
int main(){
int N;cin >> N;
if(N==1){
puts("Yes");
puts("2");
cout << "1 1" << endl;
cout << "1 1" << endl;
return 0;
}
LL s=0;
for(LL i=1;i<=N;i++){
if(i*(i-1)==2*N){
s=i;
break;
}
}
if(s==0){
puts("No");
return 0;
}
int ans[s][s-1];
int a=1;
for (int i = 0; i < s; i++) {
for (int j = i; j < s-1; j++) {
ans[i][j]=a++;
}
a-=s-i-2;
for (int j = i+1; j < s-1; j++) {
ans[j][i]=a++;
}
}
for (int i = 0; i < s-1; i++) {
ans[s-1][i]=ans[i][i];
}
puts("Yes");
cout << s << endl;
for (int i = 0; i < s; i++) {
cout << s-1 << " ";
for (int j = 0; j < s-1; j++) {
cout << ans[i][j] << (j==s-2?"\n":" ");
}
}
return 0;
}
| 0 | 16,452,006 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lvector vector<ll>
#define cvector vector<char>
#define svector vector<string>
#define lque queue<ll>
#define lpque priority_queue<ll>
#define dlpque priority_queue<ll,lvector,greater<ll>>
#define P pair<ll,ll>
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define rep(i,n) for(ll i=0; i<n; ++i)
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;cin>>s;
map<char,ll> mp;rep(i,4) mp[s[i]]++;
print((mp.size()==2&&mp[s[0]]==2)?"Yes":"No");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool f(string s){
for(int i=0; i<s.size(); ++i){
if(s[i]!='.'){return false;}
}
return true;
}
bool g(const vector<string> &s, int j){
for(int i=0; i<s.size(); ++i){
if(s[i][j]!='.'){return false;}
}
return true;
}
int main(){
int h, w; cin >> h >> w;
vector<string> s(h);
vector<int> vi(h, 0), vj(w, 0);
for(int i=0; i<h; ++i){cin >> s[i];}
for(int i=0; i<h; ++i){
string t = s[i];
if(f(t)){vi[i]++;}
}
for(int i=0; i<w; ++i){
if(g(s, i)){vj[i]++;}
}
for(int i=0; i<h; ++i){
if(vi[i]!=0){continue;}
for(int j=0; j<w; ++j){
if(vj[j]!=0){continue;}
cout << s[i][j];
}
cout << endl;
}
return 0;
}
| 0 | 25,428,057 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
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;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n; cin >> n;
unordered_map<long long, int> mp;
for (int i = 0; i < n; i++) {
int x; cin >> x;
mp[x]++;
}
vector<long long> ans(2);
for (auto p : mp) {
for (int i = 0; i < 2; i++) {
if(p.second < 2) break;
if (p.first > ans[i]) {
ans[i] = p.first;
p.second -= 2;
}
}
sort(ans.begin(), ans.end());
debug(ans);
}
cout << ans[0] * ans[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0,i##_max=(N);i<i##_max;++i)
#define repp(i,l,r) for(int i=(l),i##_max=(r);i<i##_max;++i)
#define per(i,N) for(int i=(N)-1;i>=0;--i)
#define perr(i,l,r) for(int i=r-1,i##_min(l);i>=i##_min;--i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP cin.tie(0);ios::sync_with_stdio(false);
#define MAX_I INT_MAX
#define MIN_I INT_MIN
#define MAX_UI UINT_MAX
#define MAX_LL LLONG_MAX
#define MIN_LL LLONG_MIN
#define MAX_ULL ULLONG_MAX
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<char,char> PCC;
typedef pair<ll,ll> PLL;
typedef pair<char,int> PCI;
typedef pair<int,char> PIC;
typedef pair<ll,int> PLI;
typedef pair<int,ll> PIL;
typedef pair<ll,char> PLC;
typedef pair<char,ll> PCL;
inline void YesNo(bool b){ cout << (b?"Yes" : "No") << endl;}
inline void YESNO(bool b){ cout << (b?"YES" : "NO") << endl;}
inline void Yay(bool b){ cout << (b?"Yay!" : ":(") << endl;}
const int K_MAX = 1e5+5;
bool reached[K_MAX];
int solve(){
int K;cin >> K;
deque<PII> dq(1,PII(1,1));
reached[1] = true;
int n,count,val1,val2;
while(!dq.empty()){
n = dq.front().first;
count = dq.front().second;
if(n == 0) return count;
reached[n] = true;
val1 = (n+1)%K;
val2 = (n*10)%K;
dq.pop_front();
if(!reached[val1]) dq.push_back(PII(val1,count+1));
if(!reached[val2]) dq.push_front(PII(val2,count));
}
return 0;
}
int main(void){
SPEEDUP
cout << setprecision(15);
cout << solve() << endl;
return 0;
}
| 0 | 2,836,495 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
const int MAX_N = 2000000;
const int MAX_A = 10000;
int as[MAX_N], bs[MAX_N], cs[MAX_A + 1];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> as[i];
for (int i = 0; i <= MAX_A; i++) cs[i] = 0;
for (int j = 0; j < n; j++) cs[as[j]]++;
for (int i = 1; i <= MAX_A; i++) cs[i] += cs[i - 1];
for (int j = n - 1; j >= 0; j--) {
cs[as[j]]--;
bs[cs[as[j]]] = as[j];
}
for (int i = 0; i < n; i++) {
if (i) putchar(' ');
printf("%d", bs[i]);
}
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
#define spc ' '
#define endl '\n'
using namespace std;
int main(){
ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n, k;
cin >> n >> k;
long long ans = k;
for(int i = 0; i < n; i++){
if(i==0) continue;
ans*=k-1;
}
cout << ans;
return 0;
}
| 0 | 75,247,839 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define eb emplace_back
#define mt make_tuple
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
typedef long long ll;
typedef pair <int, int> ii;
typedef pair <ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef long double ld;
const ll INF=LLONG_MAX;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
string s,t;
cin >> s >> t;
int n=s.length();
bool ok = 0;
for(int i=0; i<n&&!ok; i++){
string ss = s.substr(i,n-i)+s.substr(0,i);
if(ss==t)ok=1;
}
if(ok)cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
template<class T> inline bool chmin(T& a, T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if(a<b){a=b;return true;}return false;}
vector<ll> G[200050];
vector<ll> stock(200050,0);
vector<bool> visited(200050);
void dfs(ll x){
visited[x]=true;
rep(i,sz(G[x])){
if(!visited[G[x][i]]){
stock[G[x][i]]+=stock[x];
dfs(G[x][i]);
}
}
}
int main(){
ll N,Q; cin>>N>>Q;
rep(i,N-1){
ll A,B; cin>>A>>B;
G[A].pb(B);
G[B].pb(A);
}
rep(i,Q){
ll p,x; cin>>p>>x;
stock[p]+=x;
}
dfs(1);
rep1(i,N){
cout<<stock[i]<<" ";
}
}
| 0 | 35,507,432 |
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#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>;
ll odd(ll x){ return (x+1)/2 % 2;}
ll cal(ll x){
if(x%2==1) return odd(x);
else return odd(x+1) ^ (x+1);
}
int main() {
ll a, b;
cin >> a >> b;
ll ans = cal(b) ^ cal(a-1);
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <bits/stdc++.h>
#include <vector>
#include <algorithm>
#include <cctype>
#include <string>
#include <map>
#include <set>
#include <math.h>
#include <cmath>
#define ll long long
#define lli long long int
using namespace std;
using P = pair<int,int>;
vector<int> enum_div(int n){
vector<int> ret;
for(int i = 1 ; i*i <= n ; ++i){
if(n%i == 0){
ret.push_back(i);
if(i != 1 && i*i != n){
ret.push_back(n/i);
}
}
}
return ret;
}
int main(){
int N;
cin >> N;
int ans = 0;
for (int i = 1; i <= N; i++) {
vector<int> vec(i);
vec = enum_div(i);
int size = vec.size()+1;
if(i%2 != 0 && size == 8) ans++;
}
cout << ans << endl;
return 0;
}
| 0 | 71,307,571 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q,h,s,d,n;
cin>>q>>h>>s>>d>>n;
long long ans=0;
long long two=min({q*8,h*4,s*2,d});
long long x=n/2;
n%=2;
ans+=two*x;
if(n%2==0) cout<<ans<<endl;
else cout<<min({ans+q*4,ans+h*2,ans+s})<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, K;
cin >> A >> B >> K;
for (int i = 0; i < K; i++) {
if (i % 2 == 0) {
if (A % 2 == 0) {
} else {
A--;
}
A /= 2;
B += A;
} else {
if (B % 2 == 0) {
} else {
B--;
}
B /= 2;
A += B;
}
}
cout << A << " " << B;
}
| 0 | 19,690,462 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
ll n, a, b;
cin >> n >> a >> b;
ll ans = b * (n - 1) + a - (a * (n - 1) + b) + 1;
cout << max(0ll, ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(void){
int h,w,m;
cin >> h >> w >> m;
vector<pair<int,int>> t;
vector<long>a(h),b(w),e(h),f(w);
rep(i,m){
int c,d;
cin >> c >> d;
c--;d--;
t.emplace_back(c,d);
a[c]++;
b[d]++;
}
long maxh=0,maxw=0,k=0,l=0;
rep(i,h) maxh = max(maxh,a[i]);
rep(i,w) maxw = max(maxw,b[i]);
rep(i,h){
if(a[i]==maxh){
e[i]=1;
k++;
}
}
rep(i,w){
if(b[i]==maxw){
f[i]=1;
l++;
}
}
long cnt = l*k;
for(auto i:t){
if(e[i.first]&&f[i.second]) cnt--;
}
if(cnt==0) cout << maxh+maxw-1 << endl;
else cout << maxw+maxh << endl;
}
| 0 | 8,871,406 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
ll N, M;
cin >> N >> M;
mat G(N);
REP(i,0,M) {
ll a, b;
cin >> a >> b;
--a; --b;
G[a].pb(b);
G[b].pb(a);
}
queue<ll> Q;
vec D(N, INF);
Q.push(0);
D[0] = 0;
while(!Q.empty()) {
ll v = Q.front(); Q.pop();
FORR(nv,G[v]) {
if(D[nv] > D[v] + 1) {
D[nv] = D[v] + 1;
Q.push(nv);
}
}
}
if(D[N-1] <= 2) PR("POSSIBLE");
else PR("IMPOSSIBLE");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 1e5 + 10;
const int MOD = 1e9 + 7;
vector<int> grafo[MAXN];
ll dp[MAXN][2];
int N;
ll solve(int v,int c,int p)
{
if(dp[v][c] != -1)
return dp[v][c];
ll tot = 1;
for(int u : grafo[v])
{
if(u == p)
continue;
if(c == 0)
tot = (tot * (solve(u,0,v) + solve(u,1,v))) % MOD;
else
tot = (tot * solve(u,0,v)) % MOD;
}
return dp[v][c] = tot;
}
int main(){
memset(dp,-1,sizeof(dp));
scanf("%d",&N);
for(int i = 1;i<N;i++)
{
int u,v;
scanf("%d %d",&u,&v);
grafo[u].push_back(v);
grafo[v].push_back(u);
}
printf("%lld\n", (solve(1,0,-1) + solve(1,1,-1)) % MOD );
return 0;
}
| 0 | 50,673,591 |
#include <bits/stdc++.h>
#include <iterator>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <math.h>
using namespace std;
#define vi vector<int>
#define vvi vector<vector<int> >
#define vl vector<long long>
#define vpi vector<pair<int,int> >
#define ll long long
#define sz(a) int(a.size())
#define forn(i,n) for(int i = 0 ; i < int(n) ; i++)
#define all(x) x.begin(),x.end()
#define vpl vector<pair<long long,long long> >
#define F first
#define S second
#define mp make_pair
#define ld long double
#define pb push_back
#define pii pair<int,int>
#define pll pair<long long,long long>
#define pci pair<char,int>
#define len(s) s.length()
#define un unsigned
# define M_PI 3.14159265358979323846
#define modulo 998244353ll
#define mod 1000000007ll
#define MAXN 1000001
#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
ll power(ll a,ll b){return b?power(a*a%mod,b/2)*(b%2?a:1)%mod:1;}
void solve()
{
int n,m;
cin>>n>>m;
vl dp(n+1,0);
dp[0] = 1;
set<int> s;
while (m--)
{
int x;
cin>>x;
s.insert(x);
}
if(s.find(1) == s.end())
{
dp[1] = 1;
}
for(int i = 2; i <= n ; i++)
{
if(s.find(i) == s.end())
{
dp[i] = dp[i-1]%mod+dp[i-2]%mod;
dp[i] %= mod;
}
}
cout<<dp[n]<<endl;
}
int main()
{
fast();
int t;
t = 1;
while(t--)
solve();
return 0;
}
|
#include <iostream>
#include <cmath>
#include <vector>
#include <map>
#include <iomanip>
#include <algorithm>
#include <sstream>
#include <string>
#include <math.h>
#include <set>
#include <deque>
#include <queue>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, h;
cin >> n >> h;
int a[n], b[n], m = 0, d = 0;
for (int i = 0 ; i < n ; i++) cin >> a[i] >> b[i], m = max(m, a[i]);
sort(b, b + n);
for (int i = n - 1 ; i >= 0 ; i--) {
if (b[i] < m) break;
h -= b[i];
d++;
if (h <= 0) {
cout << d;
return 0;
}
}
if (h % m == 0) cout << d + h / m;
else cout << d + h / m + 1;
}
| 0 | 54,635,487 |
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
int sum[400010];
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
string S; cin >> S;
vector<int> v;
int len = 0;
if(S[0] == '1') v.push_back(0);
rep(i, N) {
if(i == 0 || S[i - 1] == S[i]) len++;
else {
v.push_back(len);
len = 1;
}
}
if(len > 0) v.push_back(len);
int ans = 0;
int res = 0;
int right = 0;
int cnt = 0;
for(int left = 0; left < v.size(); left++) {
while(right < v.size() && (right % 2 == 0) + cnt <= K) {
res += v[right];
cnt += (right % 2 == 0);
++right;
}
ans = max(ans, res);
if(left == right) right++;
else {
cnt -= (left % 2 == 0);
res -= v[left];
}
}
cout << ans << endl;
return 0;
}
|
#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; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(v) v.begin(), v.end()
int64_t gcd(int64_t a, int64_t b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int64_t lcm(int64_t a, int64_t b) {
return a / gcd(a, b) * b;
}
int t(int64_t a){
int i = 0;
if( a == 0) return i;
if( a % 2 != 0) return i;
a /= 2;
i++;
return i + t(a);
}
int main() {
int64_t N, M;
cin >> N >> M;
vector<int64_t> a(N,0);
REP(i,N) cin >> a[i];
REP(i,N) a[i] /= 2;
int num = 0;
num = t(a[0]);
FOR(i,1,N){
if(num != t(a[i])){
cout << 0 << endl;
return 0;
}
}
REP(i,N) a[i] >>= num;
M >>= num;
int64_t lcm_ = 1;
REP(i, N){
lcm_ = lcm(lcm_,a[i]);
if(lcm_ > M){
cout << 0 << endl;
return 0;
}
}
int answer = (M/lcm_ +1)/2;
cout << answer << endl;
return 0;
}
| 0 | 38,247,999 |
#include <bits/stdc++.h>
#define pi 3.14159
using namespace std;
int main()
{
int n,r,f=0;
cin>>n;
while(n!=0)
{
r=n%10;
n=n/10;
if(r==7)
f++;
}
if(f==0)
cout<<"No"<<endl;
else
cout<<"Yes"<<endl;
return 0;
}
|
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <cstring>
#include <bitset>
#include <functional>
#include <random>
#define REP(_i,_a,_n) for(int _i=_a;_i<=_n;++_i)
#define PER(_i,_a,_n) for(int _i=_n;_i>=_a;--_i)
#define hr putchar(10)
#define pb push_back
#define lc (o<<1)
#define rc (lc|1)
#define mid ((l+r)>>1)
#define ls lc,l,mid
#define rs rc,mid+1,r
#define x first
#define y second
#define io std::ios::sync_with_stdio(false)
#define endl '\n'
#define DB(_a) ({REP(_i,1,n) cout<<_a[_i]<<',';hr;})
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int P = 1e9+7, INF = 0x3f3f3f3f;
ll gcd(ll a,ll b) {return b?gcd(b,a%b):a;}
ll qpow(ll a,ll n) {ll r=1%P;for (a%=P;n;a=a*a%P,n>>=1)if(n&1)r=r*a%P;return r;}
ll inv(ll x){return x<=1?1:inv(P%x)*(P-P/x)%P;}
inline int rd() {int x=0;char p=getchar();while(p<'0'||p>'9')p=getchar();while(p>='0'&&p<='9')x=x*10+p-'0',p=getchar();return x;}
#ifdef __APPLE__
const int N = 1e2+50;
#else
const int N = 1e6+50;
#endif
int n;
ll a[N];
int calc() {
int ans = 0;
while (1) {
sort(a+1,a+1+n);
if (a[n]<=n-1) break;
++ans;
a[n]-=n;
REP(i,1,n-1) ++a[i];
}
return ans;
}
int main() {
scanf("%d", &n);
REP(i,1,n) scanf("%lld",a+i);
ll ans = 0;
while (1) {
sort(a+1,a+1+n);
if (a[1]>60) {
ll t = a[1]-60;
ans += t*n;
REP(i,1,n) a[i]-=t;
}
if (a[n]<=2000) {
ans += calc();
break;
}
ll ma = -1;
int p = 0;
REP(i,2,n) if (a[i]-a[i-1]>ma) ma = a[i]-a[i-1], p = i;
if (ma<=200) throw;
ll w = n-p+1, t = (a[p]-a[p-1])/(n+1);
ans += t*w;
REP(i,1,p-1) a[i] += t*w;
REP(i,p,n) a[i] += t*(-n+w-1);
}
printf("%lld\n", ans);
}
| 0 | 78,308,447 |
#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<map>
#include<string.h>
#include<complex>
#include<math.h>
#include<queue>
#include <functional>
#include<time.h>
#include <stack>
#include<iomanip>
using namespace std;
#define rep(i,a,n) for(ll i=(a);i<(n);i++)
#define ll long long
#define llint long long int
#define reverse(v) reverse(v.begin(), v.end());
#define Yes(ans) if(ans)cout<<"Yes"<<endl; else cout<<"No"<<endl;
#define YES(ans) if(ans)cout<<"YES"<<endl; else cout<<"NO"<<endl;
#define hei(a) vector<a>
#define whei(a) vector<vector<a>>
#define UF UnionFind
#define Pint pair<int,int>
#define keta(a) fixed << setprecision(a)
constexpr auto INF = 100000000000;
constexpr auto mod = 1000000007;
struct edge { int to, cost; };
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 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;
}
ll int c(ll int a, ll int b, ll int m) {
ll int ans = 1;
for (ll int i = 0; i < b; i++) {
ans *= a - i;
ans %= m;
}
for (ll int i = 1; i <= b; i++) {
ans *= modinv(i, m);
ans %= m;
}
return ans;
}
void dijkdtra(int s, int v, vector<int>& d, whei(edge)& G) {
priority_queue<Pint, vector<Pint>, greater<Pint>> que;
d[s] = 0;
que.push(Pint(0, s));
while (!que.empty()) {
Pint p = que.top();
que.pop();
int V = p.second;
if (d[V] < p.first)continue;
for (int i = 0; i < G[V].size(); i++) {
edge e = G[V][i];
if (d[e.to] > d[V] + e.cost) {
d[e.to] = d[V] + e.cost;
que.push(Pint(d[e.to], e.to));
}
}
}
}
int main() {
ll s;
cin >> s;
const int a = 1000000000;
ll x = (a - (s % a)) % a;
ll y = (s + x) / a;
cout << "0 0 1000000000 1 " << x << " " << y << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
if( s[0] != 'A')
{
cout<<"WA";
return 0;
}
int count =0;
for(int i=2;i<=s.length() -2;i++)
{
if(s[i] =='C' )
count++;
}
if( count != 1)
{
cout<<"WA";
return 0;
}
for(int i=0;i<s.length();i++)
{
if( s[i] <96 && (s[i]!='A' && s[i] != 'C'))
{
cout<<"WA";
return 0;
}
}
cout<<"AC";
}
| 0 | 20,486,324 |
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
void solve(int n, vector<int>& arr) {
unordered_map<int, vector<int>> mp;
for (int i=0; i<n; i++) mp[arr[i]].push_back(i);
if (mp[1].size() == 1) {
cout << 1;
return;
}
if (mp[1].size() > 1) {
cout << 0;
return;
}
int cnt = 0;
for (auto a : arr) {
if (mp[a].size() > 1) continue;
cnt++;
for (int i=2; i<=sqrt(a); i++) {
if (a % i == 0 && (mp[i].size() > 0 || mp[a/i].size() > 0)) {
cnt--;
break;
}
}
}
cout << cnt;
}
int main() {
int n; cin >> n;
vector<int> arr(n);
for (int i=0; i<n; i++) cin >> arr[i];
solve(n, arr);
}
|
#include<bits/stdc++.h>
using namespace std;
#define lli long long int
#define pii pair<int,int>
#define pll pair<lli, lli>
#define vi vector<int>
#define vii vector<pair<int,int>>
#define vll vector<lli>
#define pb push_back
#define mpr make_pair
#define ss second
#define ff first
#define INF 1000000001
#define inf1 1000000000000000001
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define all(x) x.begin(),x.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define testcase() int tc;cin>>tc;while(tc--)
#define clean(x) memset(x,0,sizeof(x))
const lli maxn = 1e5+9;
vector<lli> catlan(int n) {
vector<lli> dp(n + 1, 0);
dp[0] = 1;
dp[1] = 1;
for (int i = 2; i <= n; i ++) {
for (int j = 0; j < i; ++ j) {
dp[i] += dp[j] * dp[i - j - 1];
}
}
return dp;
}
lli b_ex(lli n,lli a){lli res=1;while(n){if(n%2==1)res*=a;n>>=1;a=a*a;}return res;}
lli ncr(lli n,lli k){lli ans=1;if(k>n-k)k=n-k;for(lli i=1;i<=k;i++){ans*=(n-i+1),ans=ans/i;}return ans;}
lli power(lli a , lli n){lli ans = 1;while(n){if(n % 2)ans = (ans * a) % mod;n /= 2;a = (a * a) % mod;}return ans;}
lli set_bits(lli n)
{
int c=0;
if(n==0)return 0;
while(n)
{
if((n&1)==1)
{
cout<<c<<" ";
}
c++;
n=n>>1;
}
return c;
}
lli lcm(lli a,lli b)
{
lli ans=(a*b)/(__gcd(a,b));
return ans;
}
void solve()
{
int a,b;cin>>a>>b;
if(a==1)a+=100;
if(b==1)b+=100;
if(a>b)cout<<"Alice\n";
else if(b>a)cout<<"Bob\n";
else cout<<"Draw\n";
}
int main()
{
FAST;
solve();
}
| 0 | 19,113,343 |
#include <iostream>
#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <complex>
#include <string.h>
#include <numeric>
using namespace std;
#define reps(i,s,n) for(int (i)=(s);(i)<(n);++(i))
#define rep(i,n) reps(i,0,n)
#define all(c) (c).begin(),(c).end()
#define mp make_pair
typedef long long ll;
int main(){
int n = 0; cin >> n;
if(n==1) {printf("Yes\n2\n1 1\n1 1\n"); return 0;}
if(n<3){cout << "No" << endl; return 0;}
int k = 3;
while(k*(k-1) < 2 * n) k++;
if(k*(k-1) != 2 * n){cout << "No" << endl; return 0;}
vector<vector<int>> s(k);
rep(i,k) s[i].push_back(k-1);
s[0].push_back(1); s[0].push_back(2);
s[1].push_back(1); s[1].push_back(3);
s[2].push_back(2); s[2].push_back(3);
int now = 3,num = 3;
rep(i,k - 3){
rep(j,i+3) s[j].push_back(j+num+1);
rep(j,i+3) s[i+3].push_back(j+num+1);
num += i+3;
}
cout << "Yes" << endl;
cout << k << endl;
rep(i,k) { rep(j,k) cout << s[i][j] << " "; cout << endl;}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
bool isAC(const string &S) {
if (S[0] != 'A') return false;
int cnum = 0;
bool exist = false;
for (int i = 1; i < S.size(); ++i) {
if (i >= 2 && i + 1 < S.size() && S[i] == 'C') ++cnum;
if (S[i] >= 'A' && S[i] <= 'Z' && S[i] != 'C') exist = true;
}
if (cnum != 1) return false;
if (exist) return false;
return true;
}
int main() {
string S;
cin >> S;
if (isAC(S)) cout << "AC" << endl;
else cout << "WA" << endl;
}
| 0 | 81,571,022 |
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define pb push_back
#define vecsort(v) sort(v.begin(),v.end())
#define lcm(x,y) (x/__gcd(x,y))*y
#define forn(i,n) for(i = 0 ; i < n ; i++)
#define deb(x) cout << #x << " " << x << endl;
#define T(t) cout << "Case " << t <<": ";
#define scan(v) for(int i = 0; i<n; i++){ll x;cin>>x;v.pb(x);}
#define fast_cin ios_base::sync_with_stdio(false);cin.tie(NULL);
ll a[2000005];
int main() {
#ifndef ONLINE_JUDGE
#endif
ll x, n;
cin >> x >> n ;
set < ll > s;
ll mx = 0;
for( int i = 0 ; i < n ; i++ ){
cin >> a[i];
s.insert(a[i]);
}
if( n == 0 ){
cout << x << endl;
return 0;
}
ll mn = 1e9;
ll ans ;
for( int i = 0 ; i <= 105 ; i++ ){
if( abs(i - x ) < mn && !s.count(i)){
mn = abs(x-i);
ans = i ;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <cstring>
#include <cassert>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> ii;
typedef vector<vi> vvi;
const int INF = 1000000000;
const ll LINF = 1e17;
const double PI =3.141592653589793238;
#pragma unused(INF,PI,LINF)
#define F(i,a,n) for(int i=(a);i<(n);i++)
template<typename T,typename TT> ostream& operator<<(ostream &s,pair<T,TT> t) {return s<<"("<<t.first<<","<<t.second<<")";}
template<typename T> ostream& operator<<(ostream &s,vector<T> t){
for(int i=0;i<(t).size();i++)s<<t[i]<<((i<(t).size()-1)?" ":"");return s; }
template<typename T> ostream& operator<<(ostream &s,set<T> t){for(T x:t) s<<x<<" ";return s; }
template<typename T> istream& operator>>(istream &s,vector<T> &t){
for(int _i=0;_i<t.size();_i++) s>>t[_i];return s; }
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
const int MAXN=10010;
int parent[MAXN];
int root(int v){return parent[v] < 0 ? v : (parent[v] = root(parent[v]));}
void merge(int x,int y){
if((x = root(x)) == (y = root(y)))
return ;
if(parent[y] < parent[x])
swap(x, y);
parent[x] += parent[y];
parent[y] = x;
}
int main(int argc, const char * argv[]) {
#ifdef local_test
freopen("input","r",stdin);
freopen("output","w",stdout);
#endif
int n,q;
cin>>n>>q;
F(i,0,n) parent[i]=-1;
F(i,0,q){
int com,x,y;
cin>>com>>x>>y;
if(com==0){
merge(x,y);
} else {
cout<<(root(x)==root(y))<<"\n";
}
}
}
| 0 | 27,833,384 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr long long MOD = 1000000007;
constexpr long long INF = 1LL << 60;
const long double PI = acosl(-1.0);
constexpr long double EPS = 1e-11;
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(){
ll n;
cin>>n;
bool flag = false;
for (ll i = 0; i < n; i++) {
for (ll j = 0;j<n;j++){
if (4 * i + 7 * j == n) flag = true;
}
}
cout << (flag ? "Yes" : "No") << endl;
}
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v) out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007
#define INF 1000000000
#define LLINF 2000000000000000000LL
#define SIZE 200010
int test(int M, int K) {
int arr[SIZE];
int N = 1 << M;
for (int i=0; i<N; i++)
arr[i*2] = arr[i*2+1] = i;
bool res = false;
do{
bool ok = true;
for (int i=0; i<N*2; i++) {
ll sum = 0;
for (int j=i+1; j<N*2; j++) {
if (arr[i] == arr[j]) {
ok &= sum == K;
}
sum ^= arr[j];
}
}
if (ok) {
for (int i=0; i<N*2; i++)
cerr << arr[i] << ", ";
cerr << endl;
return true;
}
res |= ok;
}while(next_permutation(arr, arr+2*N));
return res;
}
int main() {
int M, K;
cin >> M >> K;
int N = 1 << M;
if (K >= N || (M == 1 && K > 0)) {
puts("-1");
return 0;
}
if (K == 0) {
for (int i=0; i<N; i++) {
printf("%d %d%c", i, i, " \n"[i+1==N]);
}
return 0;
}
vector<int> ans;
ans.push_back(K);
for (int i=0; i<N; i++)
if (i != K)
ans.push_back(i);
ans.push_back(K);
for (int i=N-1; i>=0; i--)
if (i != K)
ans.push_back(i);
for (int i=0; i<N*2; i++)
printf("%d%c", ans[i], " \n"[i == N*2-1]);
#ifdef LOCAL
bool ok = true;
for (int i=0; i<N*2; i++) {
ll sum = 0;
for (int j=i+1; j<N*2; j++) {
if (ans[i] == ans[j]) {
ok &= sum == K;
}
sum ^= ans[j];
}
}
cerr << (ok ? "OK!" : "WA...") << endl;
#endif
return 0;
}
| 0 | 91,041,296 |
#include <iostream>
#define int long long int
using namespace std;
signed main()
{
int a, b, k;
cin >> a >> b >> k;
if (k <= a)
a -= k;
else
{
b -= (k - a);
a = 0;
}
if (b < 0)
b = 0;
cout << a << " " << b << endl;
return 0;
}
|
#include "bits/stdc++.h"
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define mFOR(i, a, b) for (int i = a; i > b; i--)
#define MP make_pair
#define PB push_back
#define ALL(v) v.begin(), v.end()
#define N 100007
#define INF 1000000007
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll fceil(ll a, ll b) { return (a % b == 0 ? a / b : a / b + 1); }
int main()
{
int n;
string ans = "No";
cin >> n;
for (int i = 0; i <= n; i += 4)
if ((n - i) % 7 == 0)
ans = "Yes";
cout << ans << endl;
return 0;
}
| 0 | 5,263,978 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m,X,Y;
cin >> n >> m >> X >> Y;
vector<int> x(n),y(m);
for(int i=0;i<n;++i) cin >> x[i];
for(int i=0;i<m;++i) cin >> y[i];
bool ok=true;
if(Y-X<1) ok=false;
if(!ok){
cout << "War" << endl;
return 0;
}
sort(x.begin(),x.end());
sort(y.begin(),y.end());
ok=false;
for(int z=Y;z>X;--z){
if(x[n-1]<z && y[0]>=z){
ok=true;
break;
}
}
if(ok) cout << "No War" << endl;
else cout << "War" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define fi first
#define se second
long long mo = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
template<class A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}cout << "\n";}
ld PI=3.14159265358979323846;
int main(){
ll N,K;
cin >> N >> K;
string S;
cin >> S;
vector<ll> v;
ll cnt = 0;
ll now = 1;
rep(i,N){
if(S[i] - '0' == now){
cnt++;
}else{
v.push_back(cnt);
cnt = 0;
now = (now==0?1:0);
i--;
}
}
v.push_back(cnt);
if(now==0){
v.push_back(0);
}
ll M = v.size();
ll ans = 0;
ll tmp = 0;
ll r = 0;
rep(l,M){
if(l > r) r = l;
while(r < M && r < l+K*2+1 ){
tmp += v[r];
r++;
}
cmax(ans, tmp);
if(l<r){
tmp -= v[l];
}
l++;
if(l<r){
tmp -= v[l];
}
}
cout << ans << endl;
}
| 0 | 93,158,701 |
#include <bits/stdc++.h>
using namespace std;
int main (void) {
int N, K;
cin >> N >> K;
vector<int> a(N);
for ( int i = 0; i < N; i++ ) {
cin >> a.at(i);
}
for ( int ki = 0; ki < K; ki++ ) {
vector<int> new_a(N+1);
for ( int i = 0; i < N; i++ ) {
int l = max(0, i - a.at(i));
int r = min(N, i + a.at(i) + 1);
new_a.at(l)++;
new_a.at(r)--;
}
for ( int i = 0; i < N; i++ ) {
new_a.at(i+1) += new_a.at(i);
}
new_a.pop_back();
if ( a == new_a )
break;
a = new_a;
}
for ( int i = 0; i < N; i++ ) {
cout << a.at(i);
if ( i != N-1 )
cout << " ";
}
cout << endl;
return 0;
}
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
int main()
{
ll X, A, B;
cin >> X >> A >> B;
if (X < B - A)
{
cout << "dangerous" << endl;
}
else if (A >= B)
{
cout << "delicious" << endl;
}
else
{
cout << "safe" << endl;
}
}
| 0 | 93,284,791 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
const ll MOD=1000000007;
const ll MOD2=998244353;
const double PI=3.14159265358979;
const ll INF= pow(10,18);
typedef pair<ll,ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
#define FOR(i,a,b) for(ll i=a;i<b;i++)
#define rep(i,n) FOR(i,0,n)
string abc="abcdefghijklmnopqrstuvwxyz";
string ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
struct edge{ll to,cost;};
int main() {
ll n,m;
cin >> n >> m;
vl cnt(n,0);
rep(i,m){
ll a,b;
cin >> a >> b;
cnt[a-1]++;
cnt[b-1]++;
}
bool B=true;
rep(i,n){
if(cnt[i]%2!=0){
B=false;
}
}
if(B){
cout << "YES" << endl;
}
else{
cout << "NO" << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <vector>
#include <queue>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <numeric>
#include <iomanip>
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for(int i=(a);i<(n);++i)
#define RFOR(i, a, n) for(int i=(n)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
#define OUT(a, x, b) (x<a || b<=x)
template<class T> inline T chmax(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T chmin(T& a, const T b) { return a = (a > b) ? b : a; }
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT { INIT(){
cin.tie(0); ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}}INIT;
signed main() {
int N;
cin >> N;
string s;
cin >> s;
int MAX = 0;
vector<int> d(N, 0);
REP(i, N){
if(i != 0) d[i] += d[i-1];
if(s[i] == ')') d[i]++;
else d[i]--;
chmax(MAX, d[i]);
}
REP(i, MAX) s = '('+s;
d = vector<int>(s.size(), 0);
REP(i, s.size()){
if(i != 0) d[i] += d[i-1];
if(s[i] == ')') d[i]--;
else d[i]++;
}
REP(i, d.back()) s += ')';
cout << s << "\n";
return 0;
}
| 0 | 82,388,863 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
#define int ll
const int N = 110;
int k, dp[N];
int solve(string s){
int n = s.size();
for(int i=0 ; i<n ; i++){
int cur = 1e9;
for(int j=i-1 ; j>0 ; j--){
if(s[j] == s[j-1]){
cur = min(cur, dp[j]);
cur = min(cur, dp[j-1]);
break;
}
}
if(cur>n)
cur = 0;
dp[i] = 1 + cur;
}
int ret=0, all=0;
for(int i=n-1 ; i>0 ; i--)
if(s[i] == s[i-1]){
all = min(dp[i-1], dp[i]);
break;
}
if(s[0] != s[n-1])
return all*k;
return dp[n-1]*(k-1) + all;
}
signed main(){
ios_base::sync_with_stdio(false); cin.tie(NULL);
string s;cin >> s;
cin >> k;
bool f = true;
for(auto c : s)
f &= (c == s[0]);
if(f){
cout << k*s.size()/2 << "\n";
return 0;
}
string t = s;
reverse(t.begin(), t.end());
cout << min(solve(s), solve(t)) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
const ll mod = 1000000007;
int main() {
int N, M, K;
cin >> N >> M >> K;
ll blackCnt = 0;
string ans;
ans = "No";
rep(ni, N + 1){
rep(mi, M + 1){
blackCnt = (ll)ni * M + mi * N - 2 * ni * mi;
if(blackCnt == K){
ans = "Yes";
}
}
}
cout << ans << endl;
return 0;
}
| 0 | 90,420,331 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int nCr(int A, int B) {
ll ans = 1;
for (int i = 0; i < B; i++) {
ans *= A - i;
}
for (int i = 0; i < B; i++) {
ans /= i + 1;
}
return ans;
}
int main() {
int N;
cin>>N;
vector<int>A(N);
rep(i,N){
cin>>A[i];
}
ll ans=0;
rep(i,N){
if(A[A[i]-1]==i+1){
ans++;
}
}
cout<<ans/2<<endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#include <string>
#define reps(i,s,n) for(int (i) = (s); (i) < (n); (i)++)
#define rep(i,n) reps(i,0,n)
using namespace std;
using ll = long long;
int main(){
int n;
cin >> n;
vector<string> str(n);
rep(i,n) cin >> str[i];
int table[51][26] = {0};
string alp = "abcdefghijklmnopqrstuvwxyz";
rep(i,n){
rep(j,str[i].length()){
int num = (int)(str[i][j] - 'a');
table[i][num]++;
}
}
vector<int> mindata(26,1000);
rep(i,26){
rep(j,n){
mindata[i] = min(mindata[i],table[j][i]);
}
}
rep(i,26){
rep(j,mindata[i]){
cout << alp[i];
}
}
cout << endl;
return 0;
}
| 0 | 49,694,237 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int a[n];
for (int i=0; i<n; i++) cin>>a[i];
sort(a, a + n);
int m = a[n-1];
for (int i=1; i<n-1; i++) {
if (a[i] >= 0) {
m += a[i];
} else {
m -= a[i];
}
}
m -= a[0];
cout<<m<<endl;
int left = a[0];
int right = a[n-1];
for (int i=1; i<n-1; i++) {
if (a[i] >= 0) {
cout<<left<<" "<<a[i]<<endl;
left -= a[i];
} else {
cout<<right<<" "<<a[i]<<endl;
right -= a[i];
}
}
cout<<right<<" "<<left<<endl;
}
|
#include<bits/stdc++.h>
#define ll long long
const int maxn = int(1e5) + 7;
using namespace std;
ll inf=1e9+7;
ll a[900009];
ll sum[20];
int main()
{
ll h,w,n;
scanf("%lld%lld%lld",&h,&w,&n);
ll x,y;
int k=0;
ll zo=(h-2)*(w-2);
for(ll i=1;i<=n;i++)
{
scanf("%lld%lld",&x,&y);
for(ll i=0;i<=2;i++)
for(ll j=0;j<=2;j++)
{
if(x-i>=1&&x-i<=h-2&&y-j>=1&&y-j<=w-2)
{
a[k++]=inf*(x-i)+(y-j);
}
}
}
sort(a,a+k);
ll t=1;
for(int i=0;i<k;i++)
{
if(a[i]==a[i+1])t++;
else
{
sum[t]++;t=1;zo--;
}
}
cout<<zo<<endl;
for(int i=1;i<=9;i++)
{
cout<<sum[i]<<endl;
}
}
| 0 | 81,345,449 |
#include <bits/stdc++.h>
using namespace std;
const string M[] = {"",
".,!? ",
"abc",
"def",
"ghi",
"jkl",
"mno",
"pqrs",
"tuv",
"wxyz"};
int main() {
int T;
cin >> T;
cin.ignore();
while(T--) {
string s;
getline(cin, s);
for(int i = 0, j = -1, k = -1; i < s.size(); ++i) {
int d = s[i] - '0';
if(d == 0) {
if(j != -1) {
cout << M[j][k];
j = k = -1;
}
} else {
j = d;
k = (k + 1) % M[j].size();
}
}
cout << endl;
}
return 0;
}
|
#include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <bitset>
#include <set>
#include <unordered_set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define ALL(v) v.begin(),v.end()
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; }
#define DEBUG_VLL(vec) for(int sz=0;sz<int(vec.size());sz++) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');
const long long MOD = 1000000007;
const long long HIGHINF = (long long)1e18;
const int INF = (int)1e9;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
V<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vll dp(n + 1, 0);
dp[0] = 1000;
for (int i = 1; i <= n; i++) {
chmax(dp[i], dp[i - 1]);
for (int j = 1; j < i; j++) {
ll kabu = dp[j] / a[j - 1];
chmax(dp[i], dp[j] - (a[j - 1] * kabu) + kabu * a[i - 1]);
}
}
cout << dp[n] << '\n';
return 0;
}
| 0 | 71,431,720 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
int i, t;
do{
cin >> s;
if ((int)s[0]-48 == 0)
break;
i = 0, t = 0;
while (s[i])
{
t += ((int)s[i] - 48);
i++;
}
cout << t << endl;
} while (1);
return 0;
}
|
#include<iostream>
using namespace std;
int n, s;
int cou;
void dfs(int i, int sum,int num_of_add) {
if (sum == s&&num_of_add==n) {
cou++;
return;
}
if (n == num_of_add||i==10)return;
dfs(i + 1, sum, num_of_add);
dfs(i + 1, sum + i, num_of_add + 1);
}
int main() {
while (cin >> n >> s,n != 0 || s != 0) {
cou = 0;
dfs(0, 0, 0);
cout << cou << endl;
}
}
| 0 | 42,888,405 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
int main() {
int n;
cin >> n;
int cnt = 0;
for(int i = 1; i <= n; i++){
string s = to_string(i);
if(s.size()%2 != 0) cnt++;
}
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
typedef vector<vector<int>> VVi;
#define REP(i, a, b) for(ll i=(a); i<(b); i++)
#define PER(i, a, b) for(ll i=(a); i>=(b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF=1e16+18;
const ll MAX=100005;
const ll MOD=1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a,b)
#define Each(a,b) for(auto &a :b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) cerr << #mp << ":"<<endl; for (auto i = mp.begin(); i != mp.end(); ++i) { cerr << i->first <<":"<<i->second << endl;}
#define dbgarr(n,m,arr) rep(i,n){rep(j,m){cerr<<arr[i][j]<<" ";}cerr<<endl;}
#define dbgdp(n,arr) rep(i,n){cerr<<arr[i]<<" ";}cerr<<endl;
#define sum(v) accumulate(ALL(v),0)
#define fi first
#define se second
template<typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) { return s<<"("<<p.first<<", "<<p.second<<")"; }
template<typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
int len=v.size();
for(int i=0; i<len; ++i) {
s<<v[i];
if(i<len-1) s<<" ";
}
return s;
}
template<typename T>
ostream &operator<<(ostream &s, const vector<vector<T> > &vv) {
int len=vv.size();
for(int i=0; i<len; ++i) {
s<<vv[i]<<endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout<<std::setprecision(10);
ll n,h,w;
cin>>n>>h>>w;
ll ans=0;
rep(i,n){
ll a,b;
cin>>a>>b;
if(a>=h&&b>=w)ans++;
}
cout<<ans<<endl;
return 0;
}
| 0 | 77,743,978 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int number;
cin >> number;
int digit = 10;
int divider = number % digit;
for (int i = 0; i<7; i++){
if(number / digit)divider += (number % (digit*10))/digit;
digit *= 10;
}
if(number%divider == 0){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
}
|
#include<iostream>
using namespace std;
struct Card{ char suit;int value; };
void bubbleSort(struct Card A[], int N){
for(int i=0;i<N;i++){
for(int j=N-1;j>i;j--){
if(A[j].value < A[j-1].value){
struct Card t = A[j];
A[j] = A[j-1];
A[j-1] = t;
}
}
}
}
void selectionSort(struct Card A[], int N){
for(int i=0;i<N;i++){
int minj=i;
for(int j=i;j<N;j++){
if(A[minj].value > A[j].value) minj = j;
}
if(minj != i){
struct Card t = A[minj];
A[minj] = A[i];
A[i] = t;
}
}
}
bool isStable(struct Card A1[],struct Card A2[],int N){
for(int i=0;i<N;i++){
if(A1[i].suit != A2[i].suit) return false;
}
return true;
}
void print(struct Card A[],int N){
for(int i=0;i<N;i++){
if(i) cout<<" ";
cout<<A[i].suit<<A[i].value;
}
cout<<endl;
}
int main(){
int N;
cin>>N;
struct Card C1[36],C2[36];
for(int i=0;i<N;i++){
cin>>C1[i].suit>>C1[i].value;
}
for(int i=0;i<N;i++){
C2[i] = C1[i];
}
bubbleSort(C1,N);
print(C1,N);
cout<<"Stable"<<endl;
selectionSort(C2,N);
print(C2,N);
if(isStable(C1,C2,N)){
cout<<"Stable"<<endl;
}else{
cout<<"Not stable"<<endl;
}
return 0;
}
| 0 | 26,575,027 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
long long int n,a,b;
cin>>n;
std::deque<long long int> A;
std::deque<long long int> B;
for (int i=0;i<n;i++) {
cin>>a;
A.emplace_back(a);
cin>>b;
B.emplace_back(b);
}
long long int tmp=0;
for (int i=n-1;i>=0;i--) {
if ((A[i]+tmp)%B[i]!=0) {
tmp+=B[i]-((A[i]+tmp)%B[i]);
}
}
cout<<tmp<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI 3.141592653589793
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, a, n) for (int i = a; i < (n); i++)
#define rrep(i, n, k) for (int i = (n); i >= (k); i--);
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
template<class T> istream &operator>>(istream&is,vector<T>&v){for(auto &elemnt:v)is>>elemnt;return is;}
template<class T,class U> istream &operator>>(istream&is,pair<T,U>&p){is>>p.first>>p.second;return is;}
template<class T>vector<T> make_vector(size_t a){return vector<T>(a);}
template<class T, class... Ts>auto make_vector(size_t a, Ts... ts){return vector<decltype(make_vector<T>(ts...))>(a, make_vector<T>(ts...));}
const int MOD = 1e9+ 7;
const int INF = 2e18;
signed main() {
int N;
cin >> N;
vector<int> A(N);
cin >> A;
auto check = [&](int types) {
map<int, int> count;
for (int i = 1; i < N; i++) {
if (A[i - 1] < A[i]) continue;
int idx = A[i];
if (types == 1) return false;
while (true) {
count[idx]++;
if (count[idx] >= types) {
count.erase(idx);
idx--;
} else break;
}
auto itr = next(count.find(idx), 1);
while (itr != count.end()) itr = count.erase(itr);
}
bool ok = count[0] == 0;
return ok;
};
int left = 0, right = 1e9 + 100;
while (right - left > 1) {
int mid = left + (right - left) / 2;
if (check(mid)) right = mid;
else left = mid;
}
cout << right << endl;
}
| 0 | 16,366,290 |
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repi(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define all(a) (a).begin(), (a).end()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using ll = long long;
using P = std::pair<ll, ll>;
ll N;
ll a[100010];
std::vector<P> vs;
ll cnt[100010];
int main()
{
std::cin >> N;
rep( i, N )
{
std::cin >> a[i];
vs.emplace_back( P( a[i], i ) );
}
vs.emplace_back( P( 0, N+1 ) );
std::sort( vs.rbegin(), vs.rend() );
ll ans = 0, mi = 1ll<<60;
rep( i, vs.size() )
{
ll x1 = vs[i].first, x2 = vs[i+1].first;
chmin( mi, vs[i].second );
cnt[mi] += (i+1)*(x1-x2);
}
rep( i, N )
std::cout << cnt[i] << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <vector>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define size_of_array(array) (sizeof(array)/sizeof(array[0]))
using ll =long long;
using namespace std;
using Graph=vector<vector<int>>;
using Field=vector<vector<int>>;
int main(){
int n,d;
cin>>n>>d;
vector<vector<int>> x(n,vector<int>(d));
rep(i,n){
rep(j,d){
cin>>x[i][j];
}
}
int ans=0;
rep(i,n){
for(int j=i+1;j<n;++j){
int norm=0;
rep(k,d){
int diff=x[i][k]-x[j][k];
norm+=diff*diff;
}
bool flg=false;
for(int k=0;k<=norm;++k){
if(k*k==norm)flg=true;
}
if(flg)++ans;
}
}
cout<<ans<<endl;
}
| 0 | 71,380,597 |
#include <iostream>
#include <vector>
using namespace std;
vector<int> v;
const long long MAX = 1e15;
vector<vector<long long>> dp;
signed main(){
int n, k;
cin >> n >> k;
v.resize(n+1);
dp.resize(n+1);
for(int i = 0; i <= n; i++){
dp[i].resize(k+1,MAX);
if(i)cin >> v[i];
}
dp[0][0] = 0;
for(int i = 0; i < n; i++){
for(int e = 0; e <= i; e++){
for(int j = k; j >= 0; j--){
dp[i+1][j] = min(dp[i+1][j], dp[e][j] + max(0, v[i+1]-v[e]));
dp[e][j] = j?dp[e][j-1]:MAX;
}
}
}
long long ans = MAX;
for(int i = 0; i <= n; i++)for(int j = 0; j <= k; j++)ans = min(ans, dp[i][j]);
cout << ans << endl;
}
|
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <iomanip>
#include <vector>
#include <queue>
#include <map>
#include <utility>
#include <limits.h>
#include <bitset>
#include <set>
using namespace std;
#define LL long long int
const LL INF = (1LL<<60);
const int INF_INT = 2147483647-1e6-1;
const LL mod = 1000000007ll;
const int mod_int = 1000000007;
LL H,W,A,B;
bool no_flag = true;
vector<vector<int>> ans;
void solve(){
no_flag = false;
ans = vector<vector<int>>(H,vector<int>(W,0));
for(int h=0;h<B;h++){
for(int w=0;w<A;w++){
ans[h][w] = 1;
}
}
for(int h=B;h<H;h++){
for(int w=A;w<W;w++){
ans[h][w] = 1;
}
}
}
int main(){
cin >> H >> W >> A >> B;
solve();
if(no_flag){
cout << "No" << endl;
}else{
for(int h=0;h<H;h++){
for(int w=0;w<W;w++){
cout << ans[h][w];
}
cout << endl;
}
}
return 0;
}
| 0 | 65,725,807 |
#include<stdio.h>
int main(){
int N;
char D[10][7]={"",".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
scanf("%d",&N);
for(int iii=0;iii<N;iii++){char x[1025]={};
scanf("%s",x);
int d=0;char pp;int y=0;
for(int i=0;i<1024;i++)
{if(x[i]!='0'&&x[i-1]==x[i]){d++;if(D[y][d]==NULL){d=0;}}
else if(x[i]!='0'&&x[i-1]!=x[i]){d=0;y=x[i]-'0';}
else if(x[i]=='0'&&y!=0){printf("%c",D[y][d]);y=0;d=0;}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
string A, B;
cin >> A >> B;
if(SZ(A) > SZ(B)) PR("GREATER");
else if(SZ(A) < SZ(B)) PR("LESS");
else {
ll f = true;
REP(i,0,SZ(A)) {
if(A[i] > B[i]) {
PR("GREATER");
f = false;
break;
}
else if(A[i] < B[i]) {
PR("LESS");
f = false;
break;
}
}
if(f) PR("EQUAL");
}
return 0;
}
| 0 | 56,572,200 |
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <sstream>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
static const LL INF = 1LL << 60;
void solve(long long N, std::vector<long long> &a) {
LL ans = 0;
for (LL i = 0; i < N; ++i) {
LL x = max(0LL, a[i] / (N + 1) - N);
a[i] -= x * (N + 1);
ans += x * (N + 1);
}
int index;
while (index = max_element(a.begin(), a.end()) - a.begin(), a[index] >= N) {
++ans;
for (LL i = 0; i < N; ++i) {
a[i] += i == index ? -N : 1;
}
}
cout << ans << endl;
}
int main() {
long long N;
std::cin >> N;
std::vector<long long> a(N);
for (int i = 0; i < N; i++) {
std::cin >> a[i];
}
solve(N, a);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0;i<n;i++)
#define rep2(i,a,n) for(int i=a;i<n;i++)
#define been(ix) (ix).begin(),(ix).end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
const ll INFL = 1e18;
const int INF = 1001001001;
typedef pair<int,int> P;
#define foreach(ix,i) for(auto& (ix) : (i))
typedef long double ld;
const int mod =1000000007;
const double PI = acos(-1);
int main(){
int n,m;cin>>n>>m;
map<int,int>ma;
rep(i,m){
int a,b;
cin>>a>>b;
ma[a]++;ma[b]++;
}
bool f=true;
for(auto x:ma){
if(x.second%2)f=false;
}
if(f)cout<<"YES"<<endl;
else
{
cout<<"NO"<<endl;
}
}
| 0 | 47,472,093 |
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
void solve()
{
int a,b,i;
cin>>a>>b;
if(a<b){
for(i=1;i<=b;i++) cout<<a;
return;
}
else{
for(i=1;i<=a;i++) cout<<b;
return;
}
}
int main()
{
solve();
}
|
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cstdio>
#include <string>
#include <vector>
#include <random>
#include <chrono>
#include <utility>
#include <numeric>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <sstream>
#include <assert.h>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <unordered_map>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(bool x) {cerr << (x ? "true" : "false");}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
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...);}
#ifdef HOME
#warning CHECK int:ll::INT_MAX:LLONG_MAX
#define maxn 20
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define maxn 2000006
#define gcd __gcd
#define debug(x...)
#endif
#define ff first
#define endl '\n'
#define ss second
#define inf 0x3f3f3f3f
#define MOD 1000000007
#define PI 3.14159265358979323846264338327950L
#define f(i,x,n) for(int i=x;i<=n;i++)
#define fr(i,x,n) for(int i=x;i>=n;i--)
struct _ { ios_base::Init i; _() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); } } _;
int dx[] = { -1, 0, 1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, 1, -1};
int main() {
int a, b; cin >> a >> b;
cout << 6 - a - b;
return 0;
}
| 0 | 86,581,509 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
template <typename T> bool chmax(T &a, const T &b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, const T &b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const long long MOD = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
cout << (N * (N - 1) + M * (M - 1)) / 2 << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#define inf (int)(1e9+7)
#define abs(x) (x >= 0 ? x : -(x))
#define ceil(a, b) a / b + !!(a % b)
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }
ll pow(ll a, int b) { return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1; }
template<typename T> T gcd(T a, T b) { if (b == 0) return a; return gcd(b, a % b); }
int main() {
int n;
cin >> n;
string s[n];
rep(i, n) cin >> s[i];
int c = 0;
rep(b, n) {
string t[n];
rep(k, n) rep(l, n) {
t[k] += s[k][(l + b) % n];
if (k > l) {
if (t[k][l] != t[l][k]) {
goto nxt;
}
}
}
c += n;
nxt:
continue;
}
cout << c << '\n';
}
| 0 | 18,086,890 |
#pragma comment (linker, "/STACK:526000000")
#define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
typedef string::const_iterator State;
#define eps 1e-11L
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144
#define pb push_back
#define mp make_pair
typedef long long ll;
#define REP(a,b) for(long long (a) = 0;(a) < (b);++(a))
#define ALL(x) (x).begin(),(x).end()
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
void init() {
iostream::sync_with_stdio(false);
cout << fixed << setprecision(100);
}
#define int ll
int n, m, v, p;
vector<int> A;
int judge(int now) {
ll go = 0;
REP(i, A.size()) {
if (i < p-1) {
go += m;
}
else if (i >= now) {
go += m;
}
else {
if (A[now] + m - A[i] < 0) return 0;
go += A[now] + m - A[i];
}
}
if (go < m*v) return 0;
return 1;
}
void solve() {
cin >> n >> m >> v >> p;
REP(i, n) {
int a;
cin >> a;
A.push_back(a);
}
sort(ALL(A));
reverse(ALL(A));
int bot = p-1;
int top = A.size();
while (abs(top - bot) > 1) {
int mid = (top + bot) / 2;
if (judge(mid) == 1) {
bot = mid;
}
else {
top = mid;
}
}
cout << bot+1 << endl;
}
#undef int
int main() {
init();
solve();
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
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;}
const ll INF=1e9+1;
int main()
{
string s;
cin >> s;
ll k;
cin >> k;
ll n=s.length();
ll ans=1;
rep(i,min(n,k)){
ll num=(ll)(s[i]-'0');
if(num!=1){
ans=num;
break;
}
}
cout << ans << endl;
return 0;
}
| 0 | 45,132,050 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for(int i=0;i<n;i++)
int main() {
string s;
cin>>s;
int ans=0;
int tmp=0;
for(int i=0;i<3;i++){
if(s[i]=='R')
tmp++;
else{
ans=max(ans,tmp);
tmp=0;
}
}
ans=max(ans,tmp);
cout<<ans<<endl;
}
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <cassert>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long int ll;
const ll INF = 1000000000000000000;
const double PI = acos(-1);
int main()
{
ll a, b, k;
cin >> a >> b >> k;
if (k < a) {
a -= k;
}
else if (k < (a + b)) {
b -= (k - a);
a = 0;
}
else {
a = 0;
b = 0;
}
cout << a << ' ' << b << endl;
return 0;
}
| 0 | 4,812,604 |
#include <iostream>
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#include <algorithm>
#include <bits/stdc++.h>
#define MOD 1000000007
#define ll long long
#define mm(arr) memset(arr, 1, sizeof(arr))
#define scanArray(a,n) for(int i = 0; i < n; i++){cin >> a[i];}
using namespace std;
int main(){
FAST
string s; cin >> s;
for(int i=0; i<3; i++){
if(s[i]-'0' == 7){
cout << "Yes" << endl;
return 0;
}
else{
continue;
}
}
cout << "No" << endl;
return 0;
}
|
#include<iostream>
#include<cmath>
using namespace std;
int main(){
double x1,x2,x3,x4,y1,y2,y3,y4;
double abx,aby,cdx,cdy,abr,cdr;
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>x1>>y1>>x2>>y2>>x3>>y3>>x4>>y4;
abx=x1-x2;
aby=y1-y2;
cdx=x3-x4;
cdy=y3-y4;
abr=sqrt(abx*abx+aby*aby);
cdr=sqrt(cdx*cdx+cdy*cdy);
abx=abx/abr;
aby=aby/abr;
cdx=cdx/cdr;
cdy=cdy/cdr;
if(abx==cdx&&aby==cdy)
cout<<"YES\n";
else if(abx==-1*cdx&&aby==-1*cdy)
cout<<"YES\n";
else
cout<<"NO\n";
}
return 0;
}
| 0 | 27,479,473 |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long ll;
#define pb push_back
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll sum = 0LL;
for (ll k = 1; k <= n; k++)
{
ll lim = n / k;
sum += (k * lim * (lim + 1)) / 2;
}
cout << sum;
return 0;
}
|
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <cmath>
#include <tuple>
#include <cstring>
#include <map>
#include <iomanip>
#include <ctime>
#include <complex>
#include <cassert>
#include <climits>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define _ << " " <<
#define all(X) (X).begin(), (X).end()
#define len(X) (X).size()
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define Tiii tuple<int, int, int>
#define Tlll tuple<ll, ll, ll>
int main() {
ll a, b;
cin >> a >> b;
ll ans = 0;
vector<ll> p(a), q(b);
for (int i = 0; i < a; i++) {
cin >> p[i];
ans += p[i];
}
for (int i = 0; i < b; i++) {
cin >> q[i];
ans += q[i];
}
sort(all(q));
vector<ll> s(b + 1, 0);
for (int i = 0; i < b; i++) s[i + 1] = s[i] + q[i];
for (int i = 0; i < a; i++) {
int l = -1, r = b;
while (r - l > 1) {
int m = (l + r) / 2;
if (q[m] > p[i]) r = m;
else l = m;
}
ans += s[l + 1] + (b - l - 1) * p[i];
}
cout << ans << endl;
}
| 0 | 28,662,167 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool AC=true;
if (S[0]!='A') AC=false;
int count=0;
for (int i=2; i<S.length()-1; i++){
if (S[i]=='C') count++;
}
if (count!=1) AC=false;
int COUNT=0;
for (int i=0; i<S.length(); i++){
if (S[i]>='A' && S[i]<='Z') COUNT++;
}
if (COUNT!=2) AC=false;
if (AC) cout << "AC" << endl;
else cout << "WA" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,x) for(int i=0;i<x;i++)
#define put(ans) cout << ans << endl;
int main(){
ll price[4];
rep(i,4){
cin >> price[i];
}
price[0] *= 4; price[1] *= 2;
ll price_1L(min({price[0],price[1],price[2]}));
ll n; cin >> n;
if(price_1L*2<=price[3]){
cout << n*price_1L << endl;
}else if(n%2==0){
cout << n/2*price[3] << endl;
}else{
cout << n/2*price[3]+price_1L << endl;
}
return 0;
}
| 0 | 65,800,268 |
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
struct Node{
int parent;
int depth;
vector<int> children;
};
void solve(vector<struct Node> &node, int x){
for(int i=0;i<node[x].children.size();i++){
node[node[x].children[i]].depth += node[x].depth + 1;
solve(node, node[x].children[i]);
}
}
void printNode(vector<struct Node> node, int n){
for(int i=0;i<n;i++){
cout<<"node "<<i<<": parent = "<<node[i].parent<<", depth = "<<node[i].depth<<", ";
if(node[i].parent == -1)
cout<<"root";
else if(node[i].children.size() == 0)
cout<<"leaf";
else
cout<<"internal node";
cout<<", [";
for(int j=0;j<node[i].children.size();j++){
cout<<node[i].children[j];
if(j != node[i].children.size()-1)
cout<<", ";
}
cout<<"]"<<endl;
}
}
int main(){
int n, id, k, c, x;
vector<struct Node> node(100000);
cin>>n;
for(int i=0;i<n;i++){
node[i].parent = -1;
node[i].depth = 0;
}
for(int i=0;i<n;i++){
cin>>id>>k;
for(int j=0;j<k;j++){
cin>>c;
node[id].children.push_back(c);
node[c].parent = id;
}
}
for(int i=0;i<n;i++)
if(node[i].parent == -1)
x = i;
solve(node, x);
printNode(node, n);
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
bool compare(const pair<int,int> &A,const pair<int,int> &B){
if(A.first!=B.first) return A.first<B.first;
else return A.second<B.second;
}
int main(void){
int n;
while(cin>>n,n){
vector<pair<int,int> > timetable;
for(int i=0;i<n;++i){
int sh,sm,ss,eh,em,es;
scanf("%d:%d:%d",&sh,&sm,&ss);
scanf("%d:%d:%d",&eh,&em,&es);
timetable.push_back(make_pair(sh*3600+sm*60+ss,1));
timetable.push_back(make_pair(eh*3600+em*60+es,-1));
}
sort(timetable.begin(),timetable.end(),compare);
int ans=0;
int now=0;
for(int i=0;i<2*n;++i){
now+=timetable[i].second;
ans=max(now,ans);
}
cout<<ans<<endl;
}
return 0;
}
| 0 | 26,897,949 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define MOD 1000000007
int main()
{
ll n, k;
cin >> n >> k;
ll ans = 0;
for (ll i = k; i <= n + 1; i++)
{
ll min, max;
min = i * (i - 1) / 2;
max = (i * (2 * (n - i + 1) + (i - 1))) / 2;
ans = (ans + (max - min + 1)) % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <list>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <stack>
#include <cstring>
using namespace std;
int main(){
stack<int> garage;
vector<int> out;
int enter;
while(cin >> enter){
if(enter == 0){
out.push_back(garage.top());
garage.pop();
}
else{
garage.push(enter);
}
}
for(vector<int>::iterator it = out.begin(); it != out.end(); it++){
cout << *it << endl;
}
return 0;
}
| 0 | 3,988,499 |
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
struct Node {
unsigned long long int key;
struct Node *next;
struct Node *prev;
};
struct Node * nil;
void init(){
nil = (struct Node*)malloc(sizeof(struct Node));
nil->prev = nil;
nil->next = nil;
}
struct Node * listSearch(int key) {
Node *cur = nil->next;
while (cur != nil && cur->key != key) {
cur = cur->next;
}
return cur;
}
void printList() {
Node *cur = nil->next;
int isf = 0;
while (1) {
if (cur == nil) break;
if (isf++ > 0) printf(" ");
printf("%llu", cur->key);
cur = cur->next;
}
printf("\n");
}
void deleteNode(Node *t) {
if (t == nil) return;
t->prev->next = t->next;
t->next->prev = t->prev;
free(t);
}
void deleteFirst() {
deleteNode(nil->next);
}
void deleteLast() {
deleteNode(nil->prev);
}
void deleteKey(int key) {
deleteNode(listSearch(key));
}
void insert(int key) {
struct Node *new_node = (struct Node * )malloc(sizeof(struct Node));
new_node->key = key;
new_node->next = nil->next;
nil->next->prev = new_node;
nil -> next = new_node;
new_node->prev = nil;
}
int main() {
int n;
char s[100];
unsigned long long int x;
init();
scanf("%d", &n);
for (int i = 0; i < n; i++){
scanf("%s%llu", s, &x);
if (s[0] == 'i') {
insert(x);
}
else if(s[0] == 'd') {
if (strlen(s) == 6) deleteKey(x);
if (strlen(s) == 11) deleteFirst();
if (strlen(s) == 10) deleteLast();
}
}
printList();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
using vld = vector<ld>;
using vvld = vector<vld>;
typedef pair<ll, ll> P;
#define bit(n) (1LL << (n))
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define REP(i, n) for (ll i = 1; i < n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORm(i, m) for (auto i = m.begin(); i != m.end(); i++)
template <class T>
inline void chmax(T& a, T b) {
a = std::max(a, b);
}
template <class T>
inline void chmin(T& a, T b) {
a = std::min(a, b);
}
#define mod (ll)(1e9 + 7)
const long long INF = 1LL << 60;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, m;
cin >> n >> m;
vs a(n), b(m);
rep(i, n) {
cin >> a[i];
}
rep(i, m) {
cin >> b[i];
}
rep(y, n - m + 1) {
rep(x, n - m + 1) {
bool match = true;
rep(q, m) {
rep(p, m) {
if (b[q][p] != a[y + q][x + p]) {
match = false;
goto end;
}
}
}
end:
if (match) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
}
| 0 | 68,417,672 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6+100;
const int MAX = 1E6;
int n;
int a[N];
int G;
bool vis[N],flag;
int prime[N] = {0},num_prime = 0;
bool isNotPrime[N] = {1, 1};
int sieve(int n)
{
for(int i = 2 ; i < n ; i ++)
{
if(! isNotPrime[i])
prime[num_prime ++]=i;
for(int j = 0 ; j < num_prime && i * prime[j]< N ; j ++)
{
isNotPrime[i * prime[j]] = 1;
if( !(i % prime[j] ) )
break;
}
}
return num_prime;
}
void prime_divide(int x)
{
if(!flag) return ;
for(int i=0;i<num_prime;i++)
{
int nowprime = prime[i];
if(nowprime*nowprime > x) break;
if(x%nowprime) continue;
if(vis[nowprime] == true)
{
flag = false;
break;
}
vis[nowprime] = true;
while((x /= nowprime)%nowprime == 0);
}
if(!flag) return ;
if(x!=1)
{
if(vis[x] == true)
flag = false;
else vis[x] = true;
}
return ;
}
int main()
{
scanf("%d",&n);
sieve(MAX);
memset(vis,false,sizeof(vis));
flag = true;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
if(i==1) G = a[i];
else G = __gcd(G,a[i]);
prime_divide(a[i]);
}
if(G!=1)
{
printf("not coprime\n");
return 0;
}
if(flag) printf("pairwise coprime\n");
else printf("setwise coprime\n");
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<unordered_set>
#define lol(i,n) for(int i=0;i<n;i++)
#define mod 1000000007
typedef long long ll;
using namespace std;
#define N 100010
int n;
bool t[N];
unordered_set<int> v[N];
unordered_set<int>::iterator it;
queue<int> Q;
void BFS(int x){
if(v[x].size()==0)return;
int to=*v[x].begin();
t[to]=false;
t[x]=false;
for(it=v[x].begin();it!=v[x].end();it++){
v[*it].erase(x);
}
for(it=v[to].begin();it!=v[to].end();it++){
v[*it].erase(to);
if(v[*it].size()==1)Q.push(*it);
}
}
int main(){
cin>>n;
lol(i,n-1){
int a,b;cin>>a>>b;
a--,b--;
v[a].insert(b);
v[b].insert(a);
}
lol(i,n)t[i]=true;
lol(i,n)if(v[i].size()==1)Q.push(i);
while(!Q.empty()){
int x=Q.front();
Q.pop();
BFS(x);
}
int sum=0;
lol(i,n)sum+=t[i];
cout<<(sum>0?"First":"Second")<<endl;
return 0;
}
| 0 | 96,405,429 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string g;
cin >> g;
int n;
cin >> n;
for(int w=0;w<g.size();w+=n)
{
cout << g[w];
}
cout << "\n";
return 0;
}
|
#include <cstdio>
using namespace std;
int
main (
)
{
int n;
scanf ( "%d", &n );
while ( n-- )
{
int y, m, d;
int res = 0;
scanf ( "%d%d%d", &y, &m, &d );
while ( y != 1000 || m != 1 || d != 1 )
{
++d;
if ( y % 3 == 0 )
{
if ( d > 20 )
{
d = 1;
++m;
}
}
else
{
if ( m % 2 == 0 )
{
if ( d > 19 )
{
d = 1;
++m;
}
}
else
{
if ( d > 20 )
{
d = 1;
++m;
}
}
}
if ( m > 10 )
{
++y;
m = 1;
}
++res;
}
printf ( "%d\n", res );
}
return ( 0 );
}
| 0 | 4,448,816 |
#include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<stdio.h>
#include<vector>
#include<queue>
#include<math.h>
using namespace std;
#define int long long
#define double long double
#define rep(s,i,n) for(int i=s;i<n;i++)
#define c(n) cout<<n<<endl;
#define ic(n) int n;cin>>n;
#define sc(s) string s;cin>>s;
#define mod 1000000007
#define inf 1000000000000000007
#define f first
#define s second
#define mini(c,a,b) *min_element(c+a,c+b)
#define maxi(c,a,b) *max_element(c+a,c+b)
#define pi 3.141592653589793238462643383279
#define e_ 2.718281828459045235360287471352
#define P pair<int,int>
#define upp(a,n,x) upper_bound(a,a+n,x)-a;
#define low(a,n,x) lower_bound(a,a+n,x)-a;
#define UF UnionFind
int keta(int x){
rep(0,i,30){
if(x<10){
return i+1;
}
x=x/10;
}
}
int gcd(int x,int y){
if(x==0||y==0)return x+y;
int aa=x,bb=y;
rep(0,i,1000){
aa=aa%bb;
if(aa==0){
return bb;
}
bb=bb%aa;
if(bb==0){
return aa;
}
}
}
int lcm(int x,int y){
int aa=x,bb=y;
rep(0,i,1000){
aa=aa%bb;
if(aa==0){
return x/bb*y;
}
bb=bb%aa;
if(bb==0){
return x/aa*y;
}
}
}
bool p(int x){
if(x==1)return false;
rep(2,i,sqrt(x)+1){
if(x%i==0&&x!=i){
return false;
}
}
return true;
}
int max(int a,int b){
if(a>=b)return a;
else return b;
}
string maxst(string s,string t){
int n=s.size();
int m=t.size();
if(n>m)return s;
else if(n<m)return t;
else{
rep(0,i,n){
if(s[i]>t[i])return s;
if(s[i]<t[i])return t;
}
return s;
}
}
int min(int a,int b){
if(a>=b)return b;
else return a;
}
int n2[41];
int nis[41];
int nia[41];
int mody[41];
int nn;
int com(int n,int y){
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
int bunsi=1,bunbo=1;
rep(0,i,y)bunsi=(bunsi*(n-i))%mod;
rep(0,i,y)bunbo=(bunbo*(i+1))%mod;
mody[0]=bunbo;
rep(1,i,41){
bunbo=(bunbo*bunbo)%mod;
mody[i]=bunbo;
}
rep(0,i,41)nis[i]=0;
nn=mod-2;
for(int i=40;i>=0;i-=1){
if(nn>n2[i]){
nis[i]++;
nn-=n2[i];
}
}
nis[0]++;
rep(0,i,41){
if(nis[i]==1){
bunsi=(bunsi*mody[i])%mod;
}
}
return bunsi;
}
int gyakugen(int n,int y){
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
mody[0]=y;
rep(1,i,41){
y=(y*y)%mod;
mody[i]=y;
}
rep(0,i,41)nis[i]=0;
nn=mod-2;
for(int i=40;i>=0;i-=1){
if(nn>n2[i]){
nis[i]++;
nn-=n2[i];
}
}
nis[0]++;
rep(0,i,41){
if(nis[i]==1){
n=(n*mody[i])%mod;
}
}
return n;
}
int yakuwa(int n){
int sum=0;
rep(1,i,sqrt(n+1)){
if(n%i==0)sum+=i+n/i;
if(i*i==n)sum-=i;
}
return sum;
}
bool integer(double n){
if(n==long(n))return true;
else return false;
}
int poow(int y,int n){
if(n==0)return 1;
n-=1;
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
int yy=y;
mody[0]=yy;
rep(1,i,41){
yy=(yy*yy)%mod;
mody[i]=yy;
}
rep(0,i,41)nis[i]=0;
nn=n;
for(int i=40;i>=0;i-=1){
if(nn>=n2[i]){
nis[i]++;
nn-=n2[i];
}
}
rep(0,i,41){
if(nis[i]==1){
y=(y*mody[i])%mod;
}
}
return y;
}
int minpow(int x,int y){
int sum=1;
rep(0,i,y)sum*=x;
return sum;
}
int ketawa(int x,int sinsuu){
int sum=0;
rep(0,i,100)sum+=(x%poow(sinsuu,i+1))/(poow(sinsuu,i));
return sum;
}
int sankaku(int a){
return a*(a+1)/2;
}
int sames(int a[1111111],int n){
int ans=0;
rep(0,i,n){
if(a[i]==a[i+1]){
int j=i;
while(a[j+1]==a[i]&&j<=n-2)j++;
ans+=sankaku(j-i);
i=j;
}
}
return ans;
}
bool search(int x){
int n;
int a[n];
int l=0,r=n;
while(r-l>=1){
int i=(l+r)/2;
if(a[i]==x)return true;
else if(a[i]<x)l=i+1;
else r=i;
}
return false;
}
int XOR(int a,int b){
int ni=1;
rep(0,i,41){
n2[i]=ni;
ni*=2;
}
rep(0,i,41)nis[i]=0;
for(int i=40;i>=0;i-=1){
if(a>=n2[i]){
nis[i]++;
a-=n2[i];
}
if(b>=n2[i]){
nis[i]++;
b-=n2[i];
}
}
int sum=0;
rep(0,i,41)sum+=(nis[i]%2*n2[i]);
return sum;
}
struct UnionFind {
vector<int> par;
vector<int> siz;
UnionFind(int N) :par(N),siz(N){
for(int i = 0; i < N; i++){
par[i] = i;
siz[i]=1;
}
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
if(siz[rx]>siz[ry]){
siz[rx]+=siz[ry];
par[y]=x;
}
else{
siz[ry]+=siz[rx];
par[x]=y;
}
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x){
return siz[root(x)];
}
};
int d[11];
signed main(){
ic(n)
ic(a) ic(b) ic(c)
int ma[1024577][21];
for(int bit=0;bit<(1<<2*n);bit++)rep(0,i,2*n)if(bit&(1<<i))ma[bit][i]=1;
rep(0,i,n)cin>>d[i];
int ans=inf;
rep(0,i,minpow(4,n)){
int A=0,B=0,C=0;
int sum=0;
rep(0,j,n){
if(ma[i][j*2]==0&&ma[i][j*2+1]==1){
if(A>0)sum+=10;
A+=d[j];
}
else if(ma[i][j*2]==1&&ma[i][j*2+1]==0){
if(B>0)sum+=10;
B+=d[j];
}
else if(ma[i][j*2]==1&&ma[i][j*2+1]==1){
if(C>0)sum+=10;
C+=d[j];
}
}
if(A>0&&B>0&&C>0){
sum+=abs(A-a)+abs(B-b)+abs(C-c);
ans=min(sum,ans);
}
}
c(ans)
}
|
#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() {
int n; cin >> n;
int a[100001]; INITA(a, 0, 100000, 0);
REP(i, n) {
cin >> a[i+1];
}
int res = 0;
REP(i, n) {
if (a[a[i+1]] == i+1) {
res++;
}
}
cout << res / 2 << endl;
return 0;
}
| 0 | 69,557,533 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.